Github-Strategie, um eine Version der Datei privat zu halten

Ich bin ein Dozent, der Codierungsprobleme für Studenten schreibt. Ich möchte den Schülern den Code mit den Platzhaltern für die Funktionen geben, die die Schüler ausführen sollen. Ich werde den Schülern Zugang zu einem privaten Github-Repo geben, um dies zu klonen.

Ich möchte jedoch auch eine Version der Codebasis mit Beispiellösungen. Natürlich möchte ich nicht, dass die Schüler Zugriff auf die Lösung haben (bis die Aufgabe beendet ist).

Ich habe über Filialen nachgedacht, aber AFAIK, ich kann nicht eine Filiale privat halten.

Vielleicht könnte ich das Projekt in ein anderes privates Repo aufteilen, bin mir aber nicht sicher, wie ich die Projekte in snyc halten könnte (abgesehen von der Datei, die die Lösung enthält).

Gibt es einen Workflow für diese Situation?

Was könnte durchaus machbar sein:

• Erstellen Sie 2 Repositorys: Schüler und Lehrer.
• Klonen Sie sie auf Ihren Computer (kann mit dem Github-Client durchgeführt werden)
• Sie arbeiten nur als Lehrer , berühren niemals Schüler.

Ihre Verzeichnisstruktur besteht also aus 2 geklonten Git-Repos:

• / student (mit einem .git-Ordner)
• / Lehrer (mit einem .git Ordner)

Sie setzen Markierungen um den "privaten" Code in Kommentaren für Ihre Sprache, Beispiel Javascript unten. Die Markierungen geben an, wo der private Code beginnt und endet.

function sum(a, b) {
  // -----------------------START
  return a + b; // so this is what you expect from the student
  // -----------------------END
}

console.log(sum(1,1)); // I expect 2 as a result of your homework

Erstellen Sie dann ein einfaches Skript auf Ihrem lokalen Computer:

files.forEach((fileContent, fileName) => {
  let newFileContent = '';
  let public = true;
  fileContent.forEach((line) => {
    switch(line) {
      case '// -----------------------START':
        public = false;
        break;
      case '// -----------------------END':
        public = true;
        break;
      default:
        if(public) {
          newFileContent = newFileContent + line + "\n";
        }
    }
  });
  writeFile('../student/' + fileName, newFileContent);
});

Es wird: alle Ihre Dateien nehmen und den Inhalt ohne die privat markierten Teile des Codes nach / student kopieren (überschreiben). Wenn Sie möchten, können Sie dort leere Zeilen einfügen. Dies kann jedoch einen Hinweis darauf geben, welche Art von Lösung Sie erwarten.

Es ist ungetesteter Beispielcode, daher müssen Sie wahrscheinlich etwas debuggen.

Jetzt müssen Sie nur noch das Schüler-Repository festschreiben und verschieben, wenn Sie mit der Ausgabe zufrieden sind. Dies kann mit einem Klick erfolgen, wenn Sie den GitHub-Client verwenden (damit Sie eine schnelle visuelle Überprüfung durchführen können) oder einfach manuell über die Befehlszeile.

Das Schüler-Repo ist nur ein Ausgabe-Repository, damit es immer auf dem neuesten Stand bleibt. Den Schülern wird durch Betrachten der Commits klar, was sich geändert hat (da sie nur Änderungen anzeigen), und es ist einfach zu handhaben.

Ein weiterer Schritt wäre, einen Git-Commit-Hook zu erstellen, der Ihr Skript automatisch ausführt.

Bearbeiten: Wir sehen, dass Sie Ihren Beitrag bearbeitet haben:

Natürlich möchte ich nicht, dass die Schüler Zugriff auf die Lösung haben (bis die Aufgabe beendet ist).

Ich vermute, es ist klar, aber um vollständig zu sein: Entfernen Sie einfach die Tags um die fertige Übung, um die Antwort auf die gleiche Weise zu veröffentlichen, wie Sie es für normale Aktualisierungen der Übungen tun würden.

Du könntest

• Erstellen Sie ein öffentliches GitHub-Repostory, in dem Sie den Boilerplate-Code festschreiben
• Fork dieses Repository als privates GitHub-Repostory
• Lösen Sie die Zuweisungen im gegabelten Repository
• Führen Sie jede Lösung nach Abschluss der Zuweisung in das öffentliche Repository ein

So würde ich diesen Workflow implementieren:

• Erstellen Sie ein öffentliches Repostory, assignmentsdas auf GitHub gehostet wird. Fügen Sie den Boilerplate-Code für die Zuweisungen hinzu. Zum Beispiel führen Sie für jede Aufgabe ein neues Unterverzeichnis ein, das den Boilerplate-Code der Aufgabe enthält.
• Erstellen Sie ein neues privates Repository assignments-solvedauf GitHub. Klonen Sie das assignmentsRepo auf Ihrem Computer und verschieben Sie es in das assignments-solved Repo (im Wesentlichen teilen Sie Ihr eigenes Repository als private Kopie auf): git clone https://github.com/[user]/assignments assignments-solved cd assignments-solved git remote set-url origin https://github.com/[user]/assignments-solved git push origin master git push --all
• Fügen Sie das assignments-solvedRepo als Remote zum assignmentsRepo hinzu: cd assignments # change to the assignments repo on your machine git remote add solutions https://github.com/[user]/assignments-solved
• Implementieren Sie jede Zuordnung im assignments-solvedRepository. Stellen Sie sicher, dass jedes Commit nur Änderungen aus einer Zuweisung enthält.
• Möglicherweise möchten Sie eine solvedVerzweigung im assignmentsRepo erstellen , damit die ursprünglichen Zuordnungen nicht geändert werden: cd assignments # change to the assignments repo on your machine git branch -b solutions git push -u origin
• Wenn Sie eine Lösung in veröffentlichen möchten assignments, rufen Sie die solvedFernbedienung und cherry-pickdie Commits mit den Lösungen ab. cd assignments # change to the assignments repo on your machine git checkout solved git fetch solutions git cherry-pick [commithash] Wo [commithash]enthält das Commit Ihrer Lösung.

Möglicherweise können Sie den Workflow auch implementieren, indem Sie jede Zuweisung in einem separaten Zweig des assignments-solvedRepos implementieren und dann eine Pull-Anforderung im assignmentsRepo erstellen . Ich bin mir aber nicht sicher, ob dies in GitHub funktionieren wird, da das assignments-solvedRepo keine echte Gabel ist.

Ich kann Ihnen nur ein Dienstprogramm vorschlagen, mit dem Sie .gitignoreDateien in Ihrem Repository verschlüsseln können. Der Workflow ist etwas schwierig zu verwenden, macht jedoch die verschlüsselten Gegenstücke Ihrer Dateien zusammen mit anderen nicht geheimen Dateien auf der Arbeitskopie verfügbar, sodass Sie sie wie gewohnt per Git verfolgen können.

#!/bin/bash

set -o errexit
set -o pipefail
set -o nounset

version=1
OPTIND=1
verbose=0
mode="add"
recurse=()
files=()

while getopts ":vaslr:" opt
do
    case "$opt" in
        \?) echo "error: invalid option: -$OPTARG" >&2 ; exit 1
            ;;
        :)  echo "error: option -$OPTARG requires an argument" >&2 ; exit 1
            ;;
        v)  let "verbose++" ; echo "verbosity increased"
            ;;
        a)  mode="add"
            ;;
        s)  mode="save"
            ;;
        l)  mode="load"
            ;;
        r)  recurse+=("$OPTARG")
            ;;
    esac
done
shift $((OPTIND-1))
if [[ "${#recurse[@]}" != 0 ]] 
then
    for pattern in "${recurse[@]}" 
    do
        while IFS= read -d $'\0' -r file
        do
            files+=("$file")
        done < <(find . -name "$pattern" -type f -print0)
    done
else
    files=("$@")
fi

[[ "${#files[@]}" != 0 ]] || { echo "list of files to process is empty" >&2 ; exit 1 ; }

if [[ $mode == "add" ]]
then
    for file in "${files[@]}"
    do
        [[ -e $file ]] && cp "$file" "${file}.bak" || touch "$file"
        sshare_file="${file}.sshare"
        [[ -e $sshare_file ]] || { echo "$version" > "$sshare_file" ; git add --intent-to-add "$sshare_file" ; echo "$file" >> .gitignore ; echo "${file}.bak" >> .gitignore ; git add .gitignore ; }
    done
    exit 0
fi
tmp_dir=`mktemp --tmpdir -d sshare.XXXX`
read -r -s -p "enter password to $mode tracked files:" sshare_password && echo ;
for file in "${files[@]}"
do
    [[ ! -e $file ]] && touch "$file" || cp "$file" "${file}.bak"
    sshare_file="${file}.sshare"
    [[ -r $sshare_file ]] || { echo "warning: can't read file '$sshare_file' (file '$file' skipped)" >&2 ; continue ; }
    file_version=$(head -1 "$sshare_file")
    [[ "$file_version" == $version ]] || { echo "warning: version '$file_version' of '$sshare_file' file differs from version '$version' of script (file '$file' skipped)" >&2 ; continue ; }
    tmp_file="$tmp_dir/$file"
    mkdir -p "$(dirname "$tmp_file")"
    > "$tmp_file"
    line_number=0
    while IFS= read -r line
    do
        let "line_number++" || :
        [[ -n $line ]] || { echo "warning: empty line encountered at #$line_number in file '$sshare_file' (ignored)" >&2 ; continue ; }
        echo "$line" | openssl enc -d -A -base64 -aes256 -k "$sshare_password" | gunzip --to-stdout --force | patch "$tmp_file" --normal --quiet
    done < <(tail --lines=+2 "$sshare_file")
    if [[ $mode == "load" ]]
    then
        cp -f "$tmp_file" . || { echo "warning: can't write to file '$file' (file '$file' skipped)" >&2 ; continue ; }
    elif [[ $mode == "save" ]]
    then
        chunk=$(diff "$tmp_file" "$file" || :)
        [[ -n $chunk ]] || { echo "nothing to comit since last edit for file '$file'" ; continue ; }
        [[ -w $sshare_file ]] || { echo "warning: can't update sshare database '$sshare_file' (file '$file' skipped)" ; continue ; }
        echo "$chunk" | gzip --stdout | openssl enc -e -A -base64 -aes256 -k "$sshare_password" >> "$sshare_file"
        echo >> "$sshare_file"
        echo "changes encrypted for file '$file'"
    fi
done

So erstellen Sie eine geheime Datei mit dem Dateinamen a.txttype sshare -a a.txt. Dienstprogramm Datei erstellen a.txtund Datei hinzugefügt .gitignore. Anschließend wird ein verschlüsseltes Gegenstück zur "Datenbank" erstellt, a.txt.sshareindem .ssharedem Dateinamen eine Erweiterung hinzugefügt wird .

Dann können Sie a.txtmit etwas Text füllen . Um seinen Zustand direkt vor speichern git commitTyp sshare -s a.txt, dann Dienstprogramm Aufforderung für Sie Kennwort Neuzustand der Datei zu verschlüsseln a.txt. Wenn Sie dieses Kennwort verwenden a.txt, wird am Ende der a.txt.sshareDatei ein verschlüsselter Unterschied zwischen dem vorherigen und dem aktuellen Dateistatus hinzugefügt .

Nach dem Abrufen / Ziehen des Repositorys mit verschlüsselten Dateien sollten Sie das sshareDienstprogramm für jede Datei mit dem -lSchlüssel ("Laden") ausführen . In diesem Fall entschlüsselt das Dienstprogramm *.sshareDateien in Textdateien, die von git in der Arbeitskopie nicht verfolgt werden.

Sie können für jede geheime Datei unterschiedliche Passwörter verwenden.

Das Dienstprogramm ermöglicht es git Spur ändert effizient ( diff von .sshareDateien ist einfach eine Zeile).