README.md

# Personal Prof

Rascal implementation of a rule checker for student Java assignments. See also
the accompanying paper
https://gitlab.science.ru.nl/objectorientatie/personal-prof-paper

Personal Prof consists of two parts: The rule checker itself and the
Brightspace daemon. The rule checker is called **Personal Prof**, the
Brightspace integration is called **pp-bs-daemon**. The rule checker is written
in Rascal, which runs on the Java Virtual Machine. The Brightspace daemon is
written in Python 3.



## Running Personal Prof

To run Personal Prof, you need a rascal jar and the Personal Prof source code.
Both can be found in this repository. The rascal jar can be found in `src/lib`
and the source code in `src`. To run Personal Prof, you have to call java as
follows.

```
$ cd src
$ java -Xmx1G -Xss32m -jar lib/rascal-0.15.2-SNAPSHOT.jar Main.rsc <ruleset-name> <absolute-path-to-project-under-test>
```

- Rascal sometimes needs lots of memory to parse big projects, the official
  Rascal documentation recommends running java with `-Xmx1G -Xss32m`
- Due to the way Rascal module loading works, you have to run it from the
  directory where `Main.rsc` is
- Rascal needs absolute paths to open files. The path to the project under test
  must be absolute
- To see which rulesets are available, look at the big switch statement in
  `Main.rsc`

There is a script `run.sh` which simplifies running Personal Prof. This script
can handle relative paths to the project under test.

1. Run the script

```
$ ./run.sh <ruleset-name> <path-to-student-project>
```

  For example

```
$ ./run.sh hangman ~/tmp/oo-grading-2020/assignment02-hangman/grading/TA_Name/128863\ -\ 34172\ -\ AsgnA\ 142\ -\ Student\ Name\ -\ 2020-02-16T09_23_57.733Z/submission/
Gallows should use StringBuilder
at |java+class:///hangman/Gallows|
```


# Running The Brightspace Daemon

The Brightspace deamon is a Python 3 program that periodically polls
Brightspace for new student submissions. When a new student submission is
detected, the daemon downloads it, runs Personal Prof, and uploads the
resulting feedback to Brightspace.

For all this to work, the daemon needs two dependencies: the Personal Prof and
no-bs. no-bs is a Python library and command line program to interact with
Brightspace. Both dependencies are included in this repository.

no-bs is a component that can run independently of the daemon. You have to set
up no-bs first, before you can run the daemon. no-bs has its own configuration
file, and you have to use no-bs to log in to Brightspace. This needs to be done
only once. Logging in with no-bs stores a long-term authentication cookie on
your computer.

1. Clone repository

```
$ git clone --recurse-submodules https://gitlab.science.ru.nl/objectorientatie/personal-prof.git
$ cd personal-prof
```

3. Optional: Run tests

```
$ ./test.sh
```

4. Create config directories for no-bs and pp-bs-daemon

```
$ mkdir -p ~/.config/grading-tools
$ mkdir -p ~/.config/personal-prof
```

5. Copy config files to config direcotries

```
$ cd brightspace-integration
$ cp app.json.config ~/.config/personal-prof
$ cp brightspace-grading-tool/grading-tool-python/app.json.config.default ~/.config/grading-tools/app.json.config
```

6. Edit config files. For no-bs you have to set `lms_url` and `courses`.

```
$ vim ~/.config/personal-prof/app.json.config
```

For pp-bs-daemon you have to set `rascalJar` and `personalProfInstallPath`

```
$ vim ~/.config/grading-tools/app.json.config
```

7. Install d2lvalence python module

```
$ pip3 install D2LValence
```

8. Log in with no-bs

```
$ cd brightspace-grading-tool/grading-tool-python/
$ ./no-bs login-manual
```

9. See if it works

```
$ ./no-bs list-courses
$ ./no-bs list-folders <course-id>
```

10. Start the daemon

```
$ export PYTHONPATH=`readlink -f brightspace-grading-tool/grading-tool-python`
$ screen
$ ./personal-prof run <course-name> <folder-id> <target-directory> <ruleset-name>
```



# Contributing

If you want to work on Personal Prof, use eclipse-rcp.

## Developing the rules

To develop rascal code, use eclipse-rcp. Follow the instructions here:
https://www.rascal-mpl.org/start/


## Running the test cases

There are some test projects and test cases to check that the rules give
correct error messages. To run the tests, use the test script. The test script
looks for all files `*Spec.rsc` and executes them

        $ ./test.sh

To test only specific files, specify them on the command line.

        $ ./test.sh Assignment02RulesSpec.rsc Assignment03RulesSpec.rsc




# References

- Rascal official website https://www.rascal-mpl.org/
- Rascal github https://github.com/usethesource/rascal
- Rascal documentation http://tutor.rascal-mpl.org/Rascal/Rascal.html