README.md

@@ -5,387 +5,26 @@ I denne lab'en skal vi utforske *grensesnitt*, og fortsette med å benytte oss a
 
 Samtidig skal vi benytte anledningen til å bli bedre kjent med terminalen, som er et svært viktig verktøy for alle som jobber teknisk med datamaskiner. Både utviklere, system-adminstratorer og vanlige brukere som ønsker å benytte spesialisert software andre har laget vil ha stor glede av den.
 
-> Kjært barn har mange navn. Under lister vi opp noen synonymer til «terminal» med litt ulike opphav, og som har litt ulike konnotasjoner. I praksis bruker vi disse ordene litt om hverandre.
-> * **Terminal**. Opprinnelig brukt om kombinasjonen av en fysisk skjerm og et tastatur. Disse kunne være et annet sted enn selve datamaskinen. I senere tid har begrepet blitt brukt om programmer som gir et grafisk brukergrensesnitt (et vindu) til et shell. En **konsoll** var en spesiell terminal som var en integrert del av datamaskinen, og som ikke kunne skilles fra den slik man kunne med andre terminaler.
-> * **Shell**. Programmet som vanligvis vises i en terminal. Dette er et rent software-konsept. Et shell *tolker* kommandoer og kan starter andre prosesser. Opprinnelig var dette det dataprogrammet som startet først når oppstarten var ferdig og datamaskinen var klar til bruk. Det ble kalt et shell fordi det «omgav» kjernen i operativsystemet som et skall, og ble for brukerne det eneste de trengte å forholde seg til ved bruk av maskinen. Ordet kommer naturligvis fra tiden før vinduer og mus var vanlig. Det finnes mange ulike shell: for eksempel er **bash** og **zsh** i dag vanlige shell for Linux/Mac mens **cmd** og **PowerShell** er vanlige shell i Windows.
-> * **CLI** (kommandolinjen). Et CLI (*command line interface*) er et program med et tekstbasert grensesnitt, for eksempel et shell. Men en kommandolinje er ikke nødvendigvis knyttet til å navigere et operativsystem og starte andre programmer. For eksempel kan vi lage et tekstbasert spill; dette spillet vil da ha en kommandolinje selv om vi ikke ville kalt det for et shell.
-
-I denne lab'en skal vi lage et enkelt shell for å navigere filsystemet som er løst inspirert av *bash*. Kommandoene vi bruker vil også fungere omtrent på samme måte i zsh og PowerShell.
-
-
-## Oversikt
-
-* [Bli kjent med eksisterende kildekode](#bli-kjent-med-eksisterende-kildekode)
-* [Kjøre SimpleShell](#kjøre-simpleshell)
-  * [Vis SimpleShell gjennom GUI](#vis-simpleshell-gjennom-gui)
-* [Et grensesnitt for kommandoer](#et-grensesnitt-for-kommandoer)
-  * [Opprette grensesnittet Command](#opprette-grensesnittet-command)
-  * [Definere metoder i Command](#definere-metoder-i-command)
-  * [Vår første kommando: echo](#vår-første-kommando--echo)
-* [Installere kommandoer i SimpleShell](#installere-kommandoer-i-simpleshell)
-* [Frivillige forbedringer](#frivillige-forbedringer)
-  * [exit: en annen enkel kommando](#exit--en-annen-enkel-kommando)
-  * [pwd, cd og ls: kommandoer som trenger kontekst](#pwd--cd--og-ls--kommandoer-som-trenger-kontekst)
-  * [man: kommando for å lese manualen](#man--kommando-for-å-lese-manualen)
-  * [Trykk backspace for å fjerne bakerste bokstav i kommandoen](#trykk-backspace-for-å-fjerne-bakerste-bokstav-i-kommandoen)
-  * [Starte Java-programmer fra SimpleShell](#starte-java-programmer-fra-simpleshell)
-  * [Forbedret ls: ls -l, ls -a, ls path/to/folder](#forbedret-ls--ls--l--ls--a--ls-pathtofolder)
-  * [Flere kommandoer som trenger kontekst: touch, mkdir, cat, rm, mv, cp](#flere-kommandoer-som-trenger-kontekst--touch-mkdir-cat-rm-mv-cp)
-  * [grep: en bonus-utfordring](#grep--en-bonus-utfordring)
-
-
-## Bli kjent med eksisterende kildekode
-
-- [ ] Kjør *main*-metoden i `Main` ([link](./src/main/java/no/uib/inf101/terminal/Main.java)) og se at du får opp et vindu du kan skrive i. Sjekk at det virker å skrive, og at du får en ny linje når du trykker enter.
-- [ ] I *main*-metoden, bytt ut *DummyShell* med *EchoShell*. Sjekk at når du nå kjører programmet, vil du få et ekko av hver linje du skriver.
-
-Dette du nå har bevitnet kalles *polymorfisme*, og innebærer at to objekter med forskjellig *klasse* begge har samme *type*, og at det finnes kode som fungerer bra med objekter fra begge klassene selv om metodene deres er implementert ulikt. Dette gir oss en høy grad av *modularitet*, siden vi enkelt kan bytte ut objekter i én klasse med objekter i en annen klasse med en litt annen oppførsel.
-
-- [ ] Besvar spørsmålene i `TextAnswers` ([link](./src/main/java/no/uib/inf101/terminal/TextAnswers.java)).
-
-
-✅ Du er klar til å gå videre når testene i `TestTextAnswers` ([link](./src/test/java/no/uib/inf101/terminal/TestTextAnswers.java)) passerer
-
-## Kjøre SimpleShell
-
-I resten av oppgaven skal vi modifisere klassen [SimpleShell](./src/main/java/no/uib/inf101/terminal/SimpleShell.java) og senere opprette noen andre klasser og grensesnitt som vi skal bruke for å forbedre SimpleShell.
-
-- [ ] Kjør testene i `TestSimpleShellStarter` ([link](./src/test/java/no/uib/inf101/terminal/TestSimpleShellStarter.java)) og se at de allerede passerer.
-
-
-### Vis SimpleShell gjennom GUI
-Vi ønsker at det grafiske brukergrensesnittet vårt [Terminal](./src/main/java/no/uib/inf101/terminal/Terminal.java) skal virke sammen med SimpleShell. Konsturktøren til Terminal-klassen aksepterer alle shell og objekter som implementerer *CommandLineInterface*.
-
-- [ ] La `SimpleShell` implementere grensesnittet `CommandLineInterface`.
-- [ ] Opprett de metodene som må implementeres for å oppfylle kontrakten *CommandLineInterface* beskriver. Du kan enten
-  - gi nytt navn til metodene *aKeyIsPressed* og *whatTheScreenLooksLike* slik at de stemmer overens med metodenavnene som er angitt i CommandLineInterface. Når du endrer navnet, bruk din IDE sin «refactor» -funksjonalitet: høyreklikk på metodenavnet og velg *rename symbol* (VS Code) eller *refactor -> rename* (Intellij) eller tilsvarende. Hvis du glemmer dette, må du endre navnet manuelt i alle testene i TestSimpleShellStarter som bruker disse metodenavnene. Alternativt kan du:
-  - opprette metodene som kreves av CommandLineInterface og la dem enkelt og greit kalle på *aKeyIsPressed* og *whatTheScreenLooksLike*.
-- [ ] Husk i *SimpleShell* å bruke `@Override` foran de metodene som opprinnelig er definert i et grensesnitt.
-- [ ] I `Main::main`-metoden: Bytt ut *EchoShell/DummyShell* med *SimpleShell*. Kjør programmet og se at kommandoene `pwd`, `cd` og `ls` virker. Prøv også noe helt annet og se at det kommer en feilmelding uten at java-programmet krasjer.
-
-> Våre kommandoer er forenklede versjoner av de samme kommandoene i bash.
->  * `pwd` (print working directory) skriver ut hvilken mappe i filsystemet som er **cwd** (current working directory), altså den mappen man «er» i.
->  * `ls` skriver ut alle filene og mappene som befinner seg i cwd.
->  * `cd foo` endrer cwd til å bli mappen «foo». Mappen «foo» må ligge i cwd.
->  * `cd ..` endrer cwd til å bli mappen over seg i mappehierarkiet.
->  * `cd` endrer cwd til å bli «home» -mappen. Det er ikke så viktig hvilken mappe dette er, men det er den samme hver gang (hvis man ikke manipulerer hvilken mappe dette er (slik vi må gjøre i testene), vil dette være cwd for programmet som startet java-prosessen).
-
-✅ Du er klar til å gå videre når testene i `TestSimpleShell` ([link](./src/test/java/no/uib/inf101/terminal/TestSimpleShell.java)) passerer.
-
-## Et grensesnitt for kommandoer
-
-- [ ] Les over kildekoden for metoden `executeCommand` i `SimpleShell`. Det er i denne metoden at vi bestemmer at ulike ting skal skje basert på hvilken kommando som blir gitt (se sekvensen med if og else if).
-
-Vi ønsker å endre executeCommand slik at vi ikke bruker en lang sekvens med if og else if, men i stedet slår opp på `commandName` i et oppslagsverk og finner hvilken kommando som skal utføres der. Vi ønsker altså at koden skal se omtrent slik ut i stedet:
-
-```java
-Command command = this.allCommands.get(commandName);
-if (command != null) {
-  String result = command.run(args);
-  return result;
-} else {
-  return "Command not found: \"" + commandName + "\"";
-}
-```
-Som pseudokode kan koden over tolkes slik:
-* Basert på verdien av `commandName`, finn ut hvilken kommando som skal utføres
-* Dersom vi fant en gyldig kommando, utfør den og returner resultatet.
-
-Du trenger ikke å ender denne koden helt enda, men dette illustrer hvor vi er på vei. For å komme oss hit, mangler vi en del ting. For eksempel finnes det ikke en type som heter `Command`. La oss definer den nå:
-
-### Opprette grensesnittet `Command`
-
-- [ ] Opprett et nytt grensesnitt som heter `Command` i pakken *no.uib.inf101.terminal*.
-  * VS Code: høyreklikk på «terminal» der det står no/uib/inf101/terminal i filutforskeren. ![klikk her i VSCode](./img/vscode-terminalfolder.png) Velg så *new file* og skriv *Command.java*. I den nye filen kan du opprette grensesnittet, og skrive inn koden som vises under.
-  * Intellij: høyreklikk «no.uib.inf101.terminal» i prosjekt-navigatoren, og velg *new -> Java class*. I boksen som kommer opp, skriv *Command* og velg *Interface* i menyen under. Koden som vises under skal nå ha blitt generert automatisk for deg.
-
-Filen skal se nå se slik ut:
-
-```java
-package no.uib.inf101.terminal;
-
-public interface Command {
-  
-}
-```
-
-### Definere metoder i `Command`
-
-Planen er at vi skal kunne kalle på  `run` på *Command* -objekter. Nærmere bestemt ønsker vi at følgende skal være mulig hvis *command* er en variabel som har typen *Command*:
-```java
-String[] args = new String[] { "foo", "bar" };
-String result = command.run(args);
-```
-For at dette skal være lov, må grensesnittet *Command* definere en metodesignatur `String run(String[])`. La oss gjøre det nå. 
-- [ ] Legg til følgende metodesignatur i `Command`:
-
-```java
-String run(String[] args);
-```
-
-I tillegg trenger vi å vite hva navnet til kommandoen er.
-- [ ] Legg til følgende metodesignatur i `Command`:
-
-```java
-String getName();
-```
-
-### Vår første kommando: echo
-
-Echo er en enkel kommando. Hvis man skriver kommandoen `echo foo bar`, så blir resultatet `foo bar `. Denne kommandoen vil du også finne i bash og lignende shell, og det eneste den gjør er å spytte tilbake argumentene den fikk som input.
-
-* [ ] Opprett en klasse `CmdEcho` i pakken *no.uib.inf101.terminal*
-* [ ] La `CmdEcho` implementere grensesnittet `Command`
-* [ ] La `CmdEcho` implementere metodene som er definert i *Command* -gresesnittet. Husk å annotere hver av dem med `@Override`.
-* [ ] La `getName()` alltid returnere `"echo"`.
-* [ ] La `run(String[])` returnere en streng hvor hvert av argumentene i String[] -arrayen er limt sammen med mellomrom. Gå gjennom args med en foreach-løkke, og legg til et mellomrom etter hver av strengene. For eksempel, hvis input er `new String[] {"foo", "bar"}`, skal returverdien være `"foo bar "` (legg merke til ekstra mellomrom etter *bar*).
-* [ ] I filen `TestCmdEcho` ([link](./src/test/java/no/uib/inf101/terminal/TestCmdEcho.java)), fjern kommentarene slik at testene blir aktivert.
-
-✅ Du kan gå videre når testene i `TestCmdEcho` er aktivert og passerer.
-
-## Installere kommandoer i SimpleShell
-
-Vi skal nå installere kommandoer i SimpleShell. Til dette trenger vi å lagre forskjellige Command-objekter. Dette gjør vi i et oppslagsverk
-
-- [ ] Opprett en instansvariabel `allCommands` i SimpleShell:
-
-```java
-private final HashMap<String, Command> allCommands = new HashMap<>();
-```
-Koden over oppretter en variabel som
-* heter `allCommands`, og
-* har typen `HashMap<String, Command>`. Det betyr at typen er et oppslagsverk hvor nøklene er av typen `String`, og verdiene er av typen `Command`.
-
-I tillegg opprettes det et nytt objekt i klassen `HashMap` som da er et tomt oppslagsverk uten noen nøkler eller verdier enda. Det neste vi skal gjøre er å gjøre det mulig å legge til kommandoer i oppslagsverket.
-
-- [ ] Opprett en metode i SimpleShell med signatur `public void installCommand(Command)`. La metoden hente ut navnet fra Command -objektet og opprett et nytt nøkkel-verdi -par i *allCommands* med navnet som nøkkel og Command-objektet som verdi. For eksempel:
-
-```java
-this.allCommands.put(command.getName(), command);
-```
-
-- [ ] I `Main::main` -metoden, kall `installCommand` på SimpleShell -objektet med et nytt `CmdEcho` -objekt som argument. Merk at du må endre typen til shell-variabelen slik at den har typen SimpleShell, ellers vil du ikke ha tilgang til installCommand -metoden.
-
-```java
-SimpleShell shell = new SimpleShell();
-shell.installCommand(new CmdEcho());
-
-Terminal gui = new Terminal(shell);
-gui.run();
-```
-
-
-Vi har nå installert kommandoen *echo* i shellet vi bruker i Main-metoden. Det eneste som gjenstår før vi kan bruke echo-kommandoen er at `executeCommand` faktisk slår opp i oppslagsverket og kjører kommandoen.
-
-- [ ] Modifiser `executeCommand` slik at den slår opp på kommandoen og kaller run dersom den fant en kommando med det gitte kommandonavnet.
-```java
-Command command = this.allCommands.get(commandName);
-if (command != null) {
-  return command.run(args);
-} else if (/* ... */) {
-  // ...
-} else {
-  return "Command not found: \"" + commandName + "\"";
-}
-```
-
-- [ ] Kjør `Main` og sjekk at echo-kommandoen virker i praksis.
-- [ ] Fjern kommenteringen fra `TestSimpleShellEcho` ([link](./src/test/java/no/uib/inf101/terminal/TestSimpleShellEcho.java)) slik at testen blir aktiv.
-
-
-
-✅ Du er ferdig med den obligatoriske delen av laben når testen i `TestSimpleShellEcho` er aktivert og passerer (i tillegg til at testene i `TestCmdEcho`, `TestSimpleShell` og `TestTextAnswers` fremdeles passerer).
-
-
-## Frivillige forbedringer
-
-### `exit`: en annen enkel kommando
-
-- [ ] Opprett en ny klasse `CmdExit` etter samme mønster som `CmdEcho`, som også implementerer *Command* -grensesnittet.
-- [ ] I run-metoden, gjør et kall til `System.exit(0);`
-- [ ] Installer kommandoen i `Main::main` på samme måte som tidligere. 
-- [ ] Sjekk at det fungerer å lukke programmet ved å gi kommandoen `exit`.
-
-### `pwd`, `cd`, og `ls`: kommandoer som trenger kontekst
-
-Vi skal opprette egne klasser for hver av metodene `pwd`, `cd` og `ls`. Dette er kommandoer som har behov for å vite konteksten shellet kjører i. Vi gjør dette ved at SimpleShell gir disse kommandoene en kontekst når de blir installert.
-
- - [ ] I `Command`: legg til en metode-signatur for å sette kontekst.
-```java
-default void setContext(Context context) { /* do nothing */ };
-```
-Denne linjen oppretter en metode i grensesnittet med en *standard* (default) implementasjon (som altså her er å ikke gjøre noen ting som helst dersom metoden blir kalt). Dette innebærer imidlertid at vi nå kan kalle på `setContext` dersom vi har å gjøre med et `Command`-objekt.
-
-- [ ] I `SimpleShell::installCommand`, gjør et kall til *setContext*:
-
-```java
-command.setContext(this.context);
-```
-
-Vi er nå klare til å opprette klassene `CmdLs`, `CmdPwd` og `CmdCd` som alle implementerer *Command* -grensesnittet.
-- [ ] La disse klassene ha en instansvariabel for kontekst, og la dem overskrive `setContext` -metoden slik at denne instansvariabelen bli initiert med en verdi når metoden kalles.
-- [ ] Kopier funksjonaliteten fra de tilsvarende metodene i SimpleShell inn i run-metodene i de nye klassene.
-- [ ] Fjern metodene fra SimpleShell (inkludert sekvensen med else-if i executeCommand), og installer dem i stedet i `Main::main` på samme måte som vi gjorde for echo -kommandoen
-- [ ] Sjekk at testene fremdeles passerer og at de fremdeles virker i terminal-gui'en
-
-
-### `man`: kommando for å lese manualen
-
-* `man command` gir oss manualen til kommandoen `command`.
-
-- [ ] La `Command` -grensesnittet ha en metode `String getManual()` som returnerer instruksjoner for hvordan kommandoen brukes
-- [ ] La `Command` -grensesnittet ha en default-metode `void setCommandContext(Map<String, Command>)` med en standard-implementasjon som ikke gjør noen ting.
-- [ ] I `SimpleShell::installCommand`, gjør et kall til setCommandContext med this.allCommands som argument.
-- [ ] I `CmdMan`, la det være en instansvariabel av typen `Map<String, Command>`, og initer denne i `setCommandContext`.
-- [ ] I `run` -metoden til `CmdMan`, hent ut riktig Command-objekt fra nevnte instansvariabel og skriv ut resultatet av getManual() kalt på dette objektet.
-
-### Trykk backspace for å fjerne bakerste bokstav i kommandoen
-
-Undersøk metoden `SimpleShell::keyPressed` og se hvordan ulike taster håndteres. Legg til funskjonalitet slik at når backspace trykkes fjernes bakerste bokstav i kommandoen.
-
-> Hint: sjekk hvilken verdi som kommer når du trykker på backspace ved å legge til
-`System.out.println("Keycode pressed: '" + ((int) key) + "'");` i begynnelsen av keyPressed-metoden. Start programmet, trykk backspace og se hva som skrives ut. Dette vil være et tall, siden vi *castet* key-variabelen til en `int`.
->
-> Når du senere ønsker å legge til en betingelse i programflyten, kan du også sammenligne castet verdi, slik: `((int) key) == /* tallet her */`
-
-### Starte java-programmer fra SimpleShell
-
-Det neste steget for å få et fullt funksjonelt shell er muligheten til å starte og avslutte andre programmer, kontrollere hva disse programmene får som input, og la dem gi oss output i sanntid. Hva som skal til for å klare alle disse oppgavene går utenfor pensum i INF101, og er ikke støttet av Terminal-klassen vår.
-
-Likevel kan vi gi en liten smakebit, nemlig hvordan vi kan kjøre andre *java* -programmer med den begrensning at de ikke er basert på interaktiv input i konsollen.
-
-#### Hello World
-
-- [ ] Opprett en klasse `HelloWorld` som skriver ut `"Hello World!"` til skjermen. Denne skal du kjenne igjen fra tidligere:
-
-```java
-package no.uib.inf101.terminal;
-
-public class HelloWorld {
-  public static void main(String[] args) {
-    System.out.println("Hello World!");
-  }
-}
-```
-
-- [ ] Opprett en klasse `CmdJavaProgram` og kopier inn koden under (avhengig av hvor mange metoder du har i `Command` -grensesnittet kan det være du må legge til en metode). Du trenger ikke å forstå alt koden gjør.
-
-```java
-package no.uib.inf101.terminal;
-
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import java.lang.reflect.Method;
-import java.nio.charset.StandardCharsets;
-
-public class CmdJavaProgram implements Command {
-
-  private final Class<?> mainClass;
-  private final String commandName;
-
-  /**
-   * Create a command from a Java program. Programs that read from
-   * standard input are not supported, but printing to standard
-   * output (i.e. using System.out to print) is ok.
-   *
-   * @param commandName  The name of the command
-   * @param mainClass  The class containing a main(String[]) method
-   */
-  public JavaProgram(String commandName, Class<?> mainClass) {
-    this.mainClass = mainClass;
-    this.commandName = commandName;
-  }
-  
-  @Override
-  public String getName() {
-    return this.commandName;
-  }
-
-  @Override
-  public String run(String[] args) {
-    // Remember original System.out and System.err
-    final PrintStream orgOut = System.out;
-    final PrintStream orgErr = System.err;
-
-    try {
-      // Prepare for capturing the output of the program
-      ByteArrayOutputStream out = new ByteArrayOutputStream();
-      PrintStream newOut = new PrintStream(out, true, StandardCharsets.UTF_8);
-      System.setOut(newOut);
-      System.setErr(newOut);
-
-      // Invoke  main method of the class for which this command was created
-      Method main = this.mainClass.getMethod("main", String[].class);
-      main.invoke(null, new Object[] {args});
-
-      // Convert the captured output to a string and return it
-      return out.toString(StandardCharsets.UTF_8);
-    } catch (NoSuchMethodException e) {
-      return "No main method found in class " + this.mainClass.getName();
-    } catch (Exception e) {
-      return e.toString();
-    } finally {
-      // Restore the original System.out and System.err
-      System.setOut(orgOut);
-      System.setErr(orgErr);
-    }
-  }
-}
-```
-
-Så gjenstår det å installere HelloWorld som en kommando `"hello"`.
-
-- [ ] I `Main::main`, installer HelloWorld som en kommando:
-
-```java
-shell.installCommand(new CmdJavaProgram("hello", HelloWorld.class));
-```
-
-✅ Sjekk at du kan kjøre programmet, og at kommandoen `"hello"` skriver ut `Hello World!` i GUI'en.
-
-PS: Prøv også:
-
-```java
-shell.installCommand(new CmdJavaProgram("new", Main.class));
-```
-
-Hva er det som skjer?
-
-
-### Forbedret `ls`: `ls -l`, `ls -a`, `ls path/to/folder`
-
-I bash har kommandoen `ls` flere muligheter enn det vi så langt har laget. For eksempel:
-* elementene vises i sortert rekkefølge
-* `ls -l` vil vise elementene med linjeskift `'\n'` mellom seg i stedet for mellomrom `' '`
-* `ls -a` vil vise skjulte filer, mens vanlig `ls` kun viser filer som ikke er skjulte.
-* `ls -la` er en kombinasjon av de to over
-* `ls path/to/folder` vil vise filene i mappen `cwd/path/to/folder`.
-
-Det kan være en fin øvelse å gjenskape dette for vår `ls` -kommando.
-
-### Flere kommandoer som trenger kontekst: touch, mkdir, cat, rm, mv, cp
-
-* `touch filename` oppretter en ny tom fil med det gitte navnet (hvis den ikke finnes fra før)
-* `mkdir dirname` oppretter en ny mappe med det gitte navnet (hvis den ikke finnes fra før)
-* `cat filename` returnerer tekst-innholdet i den gitte filen som en streng
-* `rm filname` sletter en fil eller en tom mappe (forsiktig når du tester med denne!)
-* `rm -r foldername` sletter en mappe og alt innholdet i den (veldig forsiktig når du tester med denne!)
-* `mv source target` endrer navn på filen eller mappen *source* til filnavnet/mappenavnet *target*. Dette kan innebære flytting hvis target er en sti til en annen mappe. Dersom *target* er en mappe som finnes fra før, flyttes *source* -filen/mappen til *target* -mappen og beholder sitt opprinnelige navn.
-* `cp source target` det samme som mv, men lager en kopi i stedet for å flytte.
-
-### `grep`: en bonus-utfordring
-
-Grep er på mange måter *cat* med inkludert filter. Den skriver kun ut de linjene som har innhold som matcher søkeordet. Standard bruk:
-
-`grep searchword filename`
-
-Vi anbefaler alle å bli kjent med hvordan grep virker i shell som bash. De ambisiøse kan også implementere det de klarer av den til bruk i vårt eget SimpleShell.
-
-* `grep -i searchword filename` ignorerer case, dvs søkeordet `abc` vil få treff på `aBC`
-* `grep -v searchword filename` skriver ut alle linjene som *ikke* matcher søkeordet
-* `grep searchword foldername` kjører grep på alle filer i mappen. I utskriften skrives navnet på filen ut først, og så linjene i den filen.
-* `grep -l searchword foldername` skriver kun ut navnet på filene med innhold som matcher, uten å skrive ut selve treffene
-* `grep -L searchword foldername` skriver kun ut navnet på filene *uten* innhold som matcher
-* `grep -r searchword foldername` kjører grep på alle filer i mappen *og* på alle filer i alle undermapper i uendelig dypde.
-
-Prøv deg frem og sammenlign med hva som skjer i bash. Les mer om grep [her](https://www.opensourceforu.com/2012/06/beginners-guide-gnu-grep-basics/) eller en annen introduksjon [her](https://danielmiessler.com/study/grep/).
+I denne lab'en skal vi modifisere et enkelt shell for å navigere filsystemet som er løst inspirert av *bash*. Kommandoene vi bruker vil også fungere omtrent på samme måte i zsh og PowerShell.
+
+
+1.  [Anbefalte forberedelser](./guide/01-preparations.md)
+2.  [Ordbok: shell og terminal](./guide/02-dictionary.md)
+3.  [Bli kjent med eksisterende kildekode](./guide/03-source_code.md)
+4.  [Kjøre SimpleShell](./guide/04-SimpleShell.md)
+  <br></br> - Vis SimpleShell gjennom GUI
+5. [Et grensesnitt for kommandoer](./guide/05-interface_for_commands.md)
+  <br></br>- Opprette grensesnittet Command
+  <br></br>- Definere metoder i Command
+  <br></br>- Vår første kommando: echo
+6. [Installere kommandoer i SimpleShell](./guide/06-install_commands_SimpleShell.md)
+7. [Anbefalte forbedringer](./guide/07-improvements.md)
+  <br></br>- exit: en annen enkel kommando
+  <br></br>- pwd, cd og ls: kommandoer som trenger kontekst
+  <br></br>- man: kommando for å lese manualen
+  <br></br>- Trykk backspace for å fjerne bakerste bokstav i kommandoen
+  <br></br>- Starte Java-programmer fra SimpleShell
+8. [Flere frivillige forbedringer](./guide/08-voluntary_improvements.md)
+  <br></br>- Forbedret ls: ls -l, ls -a, ls path/to/folder
+  <br></br>- Flere kommandoer som trenger kontekst: touch, mkdir, cat, rm, mv, cp
+  <br></br>- grep: søking i filer

guide/01-preparations.md

+forrige • [oversikt](../README.md) • [neste](02-dictionary.md)
+
+## Anbefalte forberedelser
+
+Les og forstå kursnotater som er spesielt relevante for denne lab'en:
+* Kursnotater om [klasser og objekter](https://inf101v23.stromme.me/notat/objekter/) utgjør grunnlaget vi bygger videre på.
+* Kursnotatene om [grensesnitt](https://inf101v23.stromme.me/notat/grensesnitt/) frem til og med avsnittet om polymorfisme er særlig relevante for denne lab'en.
+* En skumlesning av avsnittet om [innfødte array'er](https://inf101v23.stromme.me/notat/array/#innf%C3%B8dt-array) i notatene om array og lister kan være greit også.
+
+For de frivillige oppgavene på slutten er også følgende relevant:
+* Avsnittet om [Filer](https://inf101v23.stromme.me/notat/inputoutput/#filer) i notatene om input og output.

guide/02-dictionary.md

+[forrige](01-preparations.md) • [oversikt](../README.md) • [neste](03-source_code.md)
+
+## Ordbok: shell og terminal
+
+Kjært barn har mange navn. Under lister vi opp noen synonymer til «terminal» med litt ulike opphav, og som har litt ulike konnotasjoner. I praksis bruker vi disse ordene litt om hverandre.
+* **Terminal**. Opprinnelig brukt om kombinasjonen av en fysisk skjerm og et tastatur. Disse kunne være et annet sted enn selve datamaskinen. I senere tid har begrepet blitt brukt om programmer som gir et grafisk brukergrensesnitt (et vindu) til et shell. En **konsoll** var en spesiell terminal som var en integrert del av datamaskinen, og som ikke kunne skilles fra den slik man kunne med andre terminaler.
+* **Shell**. Programmet som vanligvis vises i en terminal. Dette er et rent software-konsept. Et shell *tolker* kommandoer og kan starte andre prosesser. Opprinnelig var dette det dataprogrammet som startet først når oppstarten var ferdig og datamaskinen var klar til bruk. Det ble kalt et shell fordi det «omgav» kjernen i operativsystemet som et skall, og ble for brukerne det eneste de trengte å forholde seg til ved bruk av maskinen. Ordet kommer naturligvis fra tiden før vinduer og mus var vanlig. Det finnes mange ulike shell: for eksempel er **bash** og **zsh** i dag vanlige shell for Linux/Mac mens **cmd** og **PowerShell** er vanlige shell i Windows.
+* **CLI** (kommandolinjen). Et CLI (*command line interface*) er et program med et tekstbasert grensesnitt, for eksempel et shell. Men en kommandolinje er ikke nødvendigvis knyttet til å navigere et operativsystem og starte andre programmer. For eksempel kan vi lage et tekstbasert spill; dette spillet vil da ha en kommandolinje selv om vi ikke ville kalt det for et shell.

guide/03-source_code.md

+[forrige](02-dictionary.md) • [oversikt](../README.md) • [neste](04-SimpleShell.md)
+
+## Bli kjent med eksisterende kildekode
+
+**TODO:**
+- Kjør *main*-metoden i `Main` ([link](../src/main/java/no/uib/inf101/terminal/Main.java)) og se at du får opp et vindu du kan skrive i. Sjekk at det virker å skrive, og at du får en ny linje når du trykker enter.
+- I *main*-metoden, bytt ut *DummyShell* med *EchoShell*. Sjekk at når du nå kjører programmet, vil du få et ekko av hver linje du skriver.
+
+Dette du nå har bevitnet kalles *polymorfisme*, og innebærer at to objekter med forskjellig *klasse* begge har samme *type*, og at det finnes kode som fungerer bra med objekter fra begge klassene selv om metodene deres er implementert ulikt. Dette gir oss en høy grad av *modularitet*, siden vi enkelt kan bytte ut objekter i én klasse med objekter i en annen klasse med en litt annen oppførsel.
+
+**TODO:**
+- Besvar spørsmålene i `TextAnswers` ([link](../src/main/java/no/uib/inf101/terminal/TextAnswers.java)).
+
+
+✅ Du er klar til å gå videre når testene i `TestTextAnswers` ([link](../src/test/java/no/uib/inf101/terminal/TestTextAnswers.java)) passerer

guide/04-SimpleShell.md

+[forrige](03-source_code.md) • [oversikt](../README.md) • [neste](05-interface_for_commands.md)
+
+## Kjøre SimpleShell
+
+I resten av oppgaven skal vi modifisere klassen [SimpleShell](../src/main/java/no/uib/inf101/terminal/SimpleShell.java) og senere opprette noen andre klasser og grensesnitt som vi skal bruke for å forbedre SimpleShell.
+
+**TODO: Kjør testene i `TestSimpleShellStarter` ([link](../src/test/java/no/uib/inf101/terminal/TestSimpleShellStarter.java)) og se at de allerede passerer.**
+
+> **Målet med laben.** Før vi gjør noen endringer i det hele tatt, støtter SimpleShell tre kommandoer: pwd, ls og cd. I løpet av laben skal vi oppdatere SimpleShell slik at
+> * det virker sammen med GUI'en vår «Terminal», og
+> * shellet virker med ubegrenset mange kommandoer.
+> 
+> Når laben er gjennomført skal vi kunne installere så mange kommandoer vi vil i SimpleShell uten at vi trenger å endre ytterligere på kildekoden i SimpleShell-klassen utover det vi gjorde i løpet av denne lab'en.
+
+### Vis SimpleShell gjennom GUI
+Vi ønsker at det grafiske brukergrensesnittet vårt [Terminal](../src/main/java/no/uib/inf101/terminal/Terminal.java) skal virke sammen med SimpleShell. Konsturktøren til Terminal-klassen aksepterer alle shell og objekter som implementerer *CommandLineInterface*.
+
+**TODO:**
+- La `SimpleShell` implementere grensesnittet `CommandLineInterface`.
+- Opprett de metodene som må implementeres for å oppfylle kontrakten *CommandLineInterface* beskriver. Du kan enten
+  - gi nytt navn til metodene *aKeyIsPressed* og *whatTheScreenLooksLike* slik at de stemmer overens med metodenavnene som er angitt i CommandLineInterface. Når du endrer navnet, bruk din IDE sin «refactor» -funksjonalitet: høyreklikk på metodenavnet og velg *rename symbol* (VS Code) eller *refactor -> rename* (Eclipse/Intellij) eller tilsvarende. Hvis du glemmer dette, må du endre navnet manuelt i alle testene i TestSimpleShellStarter som bruker disse metodenavnene. Alternativt kan du:
+  - opprette metodene som kreves av CommandLineInterface og la dem enkelt og greit kalle på *aKeyIsPressed* og *whatTheScreenLooksLike*.
+- Husk i *SimpleShell* å bruke `@Override` foran de metodene som opprinnelig er definert i et grensesnitt.
+- I `Main::main`-metoden: Bytt ut *EchoShell/DummyShell* med *SimpleShell*. Kjør programmet og se at kommandoene `pwd`, `cd` og `ls` virker. Prøv også noe helt annet og se at det kommer en feilmelding uten at java-programmet krasjer.
+
+> Våre kommandoer er forenklede versjoner av de samme kommandoene i bash.
+>  * `pwd` (print working directory) skriver ut hvilken mappe i filsystemet som er **cwd** (current working directory), altså den mappen man «er» i.
+>  * `ls` skriver ut alle filene og mappene som befinner seg i cwd.
+>  * `cd foo` endrer cwd til å bli mappen «foo». Mappen «foo» må ligge i cwd.
+>  * `cd ..` endrer cwd til å bli mappen over seg i mappehierarkiet.
+>  * `cd` endrer cwd til å bli «home» -mappen. Det er ikke så viktig hvilken mappe dette er, men det er den samme hver gang (hvis man ikke manipulerer hvilken mappe dette er (slik vi må gjøre i testene), vil dette være cwd for programmet som startet java-prosessen).
+
+✅ Du er klar til å gå videre når testene i `TestSimpleShell` ([link](../src/test/java/no/uib/inf101/terminal/TestSimpleShell.java)) passerer.

guide/05-interface_for_commands.md

+[forrige](04-SimpleShell.md) • [oversikt](../README.md) • [neste](06-install_commands_SimpleShell.md)
+
+## Et grensesnitt for kommandoer
+
+**TODO: Les over kildekoden for metoden `executeCommand` i `SimpleShell`.** Det er i denne metoden at vi bestemmer at ulike ting skal skje basert på hvilken kommando som blir gitt (se sekvensen med if og else if).
+
+Vi ønsker å endre executeCommand slik at vi ikke bruker en lang sekvens med if og else if, men i stedet slår opp på `commandName` i et oppslagsverk og finner hvilken kommando som skal utføres der. Vi ønsker altså at koden skal se omtrent slik ut i stedet:
+
+```java
+Command command = this.allCommands.get(commandName);
+if (command != null) {
+  String result = command.run(args);
+  return result;
+} else {
+  return "Command not found: \"" + commandName + "\"";
+}
+```
+Som pseudokode kan koden over tolkes slik:
+* Basert på verdien av `commandName`, finn ut hvilken kommando som skal utføres
+* Dersom vi fant en gyldig kommando, utfør den og returner resultatet.
+
+Du trenger ikke å ender denne koden helt enda, men dette illustrer hvor vi er på vei. For å komme oss hit, mangler vi en del ting. For eksempel finnes det ikke en type som heter `Command`. La oss definere den nå:
+
+### Opprette grensesnittet `Command`
+
+**TODO: Opprett et nytt grensesnitt som heter `Command` i pakken *no.uib.inf101.terminal*.**
+  * VS Code: høyreklikk på «terminal» der det står no/uib/inf101/terminal i filutforskeren. ![klikk her i VSCode](../img/vscode-terminalfolder.png) Velg så *new file* og skriv *Command.java*. I den nye filen kan du opprette grensesnittet, og skrive inn koden som vises under.
+  * Eclipse: høyreklikk «no.uib.inf101.terminal» i prosjekt-navigatoren, og velg *new -> Interface*. I boksen som kommer opp, skriv *Command*. Koden som vises under skal nå ha blitt generert automatisk for deg.
+  * Intellij: høyreklikk «no.uib.inf101.terminal» i prosjekt-navigatoren, og velg *new -> Java class*. I boksen som kommer opp, skriv *Command* og velg *Interface* i menyen under. Koden som vises under skal nå ha blitt generert automatisk for deg.
+
+Filen skal se nå se slik ut:
+
+```java
+package no.uib.inf101.terminal;
+
+public interface Command {
+  
+}
+```
+
+### Definere metoder i `Command`
+
+Planen er at vi skal kunne kalle på  `run` på *Command* -objekter. Nærmere bestemt ønsker vi at følgende skal være mulig hvis *command* er en variabel som har typen *Command*:
+```java
+String[] args = new String[] { "foo", "bar" };
+String result = command.run(args);
+```
+For at dette skal være lov, må grensesnittet *Command* definere en metodesignatur `String run(String[])`. La oss gjøre det nå. 
+
+**TODO: Legg til følgende metodesignatur i `Command`:**
+
+```java
+String run(String[] args);
+```
+
+I tillegg trenger vi å vite hva navnet til kommandoen er.
+
+**TODO: Legg til følgende metodesignatur i `Command`:**
+
+```java
+String getName();
+```
+
+### Vår første kommando: echo
+
+Echo er en enkel kommando. Hvis man skriver kommandoen `echo foo bar`, så blir resultatet `foo bar `. Denne kommandoen vil du også finne i bash og lignende shell, og det eneste den gjør er å spytte tilbake argumentene den fikk som input.
+
+**TODO:**
+* Opprett en klasse `CmdEcho` i pakken *no.uib.inf101.terminal*
+* La `CmdEcho` implementere grensesnittet `Command`
+* La `CmdEcho` implementere metodene som er definert i *Command* -gresesnittet. Husk å annotere hver av dem med `@Override`.
+* La `getName()` alltid returnere `"echo"`.
+* La `run(String[])` returnere en streng hvor hvert av argumentene i String[] -arrayen er limt sammen med mellomrom. Gå gjennom args med en foreach-løkke, og legg til et mellomrom etter hver av strengene. For eksempel, hvis input er `new String[] {"foo", "bar"}`, skal returverdien være `"foo bar "` (legg merke til ekstra mellomrom etter *bar*).
+* I filen `TestCmdEcho` ([link](../src/test/java/no/uib/inf101/terminal/TestCmdEcho.java)), fjern kommentarene slik at testene blir aktivert.
+
+✅ Du kan gå videre når testene i `TestCmdEcho` er aktivert og passerer.

guide/06-install_commands_SimpleShell.md

+[forrige](05-interface_for_commands.md) • [oversikt](../README.md) • [neste](07-improvements.md)
+
+## Installere kommandoer i SimpleShell
+
+Vi skal nå installere kommandoer i SimpleShell. Til dette trenger vi å lagre forskjellige Command-objekter. Dette gjør vi i et oppslagsverk
+
+**TODO: Opprett en instansvariabel `allCommands` i SimpleShell:**
+
+```java
+private final HashMap<String, Command> allCommands = new HashMap<>();
+```
+Koden over oppretter en variabel som
+* heter `allCommands`, og
+* har typen `HashMap<String, Command>`. Det betyr at typen er et oppslagsverk hvor nøklene er av typen `String`, og verdiene er av typen `Command`.
+
+I tillegg opprettes det et nytt objekt i klassen `HashMap` som ved opprettelse er et tomt oppslagsverk uten noen nøkler eller verdier enda. Det neste vi skal gjøre er å gjøre det mulig å legge til kommandoer i oppslagsverket.
+
+**TODO: Opprett en metode i SimpleShell med signatur `public void installCommand(Command command)`**. La metoden hente ut navnet fra Command -objektet og opprett et nytt nøkkel-verdi -par i *allCommands* med navnet som nøkkel og Command-objektet som verdi. For eksempel:
+
+```java
+this.allCommands.put(command.getName(), command);
+```
+
+**TODO: I `Main::main` -metoden, kall `installCommand` på SimpleShell -objektet med et nytt `CmdEcho` -objekt som argument**. Merk at du må endre typen til shell-variabelen slik at den har typen SimpleShell, ellers vil du ikke ha tilgang til installCommand -metoden.
+
+```java
+SimpleShell shell = new SimpleShell();
+shell.installCommand(new CmdEcho());
+
+Terminal gui = new Terminal(shell);
+gui.run();
+```
+
+
+Vi har nå installert kommandoen *echo* i shellet vi bruker i Main-metoden. Det eneste som gjenstår før vi kan bruke echo-kommandoen er at `executeCommand` faktisk slår opp i oppslagsverket og kjører kommandoen.
+
+**TODO: Modifiser `executeCommand` slik at den slår opp på kommandoen og kaller run dersom den fant en kommando med det gitte kommandonavnet**. Siden vi ikke har laget og installert kommandoer for pwd, cd og ls enda lar vi den gamle implementasjonen stå for disse kommandoene.
+```java
+Command command = this.allCommands.get(commandName);
+if (command != null) {
+  return command.run(args);
+} else if (/* ... */) {
+  // ...
+} else {
+  return "Command not found: \"" + commandName + "\"";
+}
+```
+
+**TODO:**
+- Kjør `Main` og sjekk at echo-kommandoen virker i praksis.
+- Fjern kommenteringen fra `TestSimpleShellEcho` ([link](../src/test/java/no/uib/inf101/terminal/TestSimpleShellEcho.java)) slik at testen blir aktiv.
+
+
+
+✅ Du er ferdig med den obligatoriske delen av laben når testen i `TestSimpleShellEcho` er aktivert og passerer (i tillegg til at testene i `TestCmdEcho`, `TestSimpleShell` og `TestTextAnswers` fremdeles passerer).

guide/07-improvements.md

+[forrige](06-install_commands_SimpleShell.md) • [oversikt](../README.md) • [neste](08-voluntary_improvements.md)
+
+## Anbefalte forbedringer
+
+Forbedringene i dette avsnittet er frivillige med tanke på å bestå laben, men er sterkt anbefalt å prøve seg på.
+
+### `exit`: en annen enkel kommando
+
+**TODO:**
+- Opprett en ny klasse `CmdExit` etter samme mønster som `CmdEcho`, som også implementerer *Command* -grensesnittet.
+- I run-metoden, gjør et kall til `System.exit(0);`. Denne metoden kan returnere for eksempel null.
+- Installer kommandoen i `Main::main` på samme måte som tidligere. 
+- Sjekk at det fungerer å lukke programmet ved å gi kommandoen `exit`.
+
+### `pwd`, `cd`, og `ls`: kommandoer som trenger kontekst
+
+Vi skal opprette egne klasser for hver av kommandoene `pwd`, `cd` og `ls`. Dette er SimpleShell sine tre kjerne-kommandoer som alltid må være tilgengelig, og som allerede var implementert; men vi ønsker å benytte oss av samme struktur som de andre kommandoene (jo færre ting som håndteres på en spesiell måte, jo bedre).
+
+Det som skiller disse kommandoene fra echo og exit, er at de har behov for å vite *konteksten* shellet kjører i. Vi løser dette ved at SimpleShell skal gi kommandoene som ønsker det tilgang til Context-objektet når de blir installert.
+
+**TODO: I `Command`, legg til en metode-signatur for å sette kontekst:**
+```java
+default void setContext(Context context) { /* do nothing */ };
+```
+Denne linjen oppretter en metode i grensesnittet med en *standard* (default) implementasjon (som altså her er å ikke gjøre noen ting som helst dersom metoden blir kalt). Dette innebærer imidlertid at vi nå kan kalle på `setContext` dersom vi har å gjøre med et `Command`-objekt.
+
+**TODO: I `SimpleShell::installCommand`, gjør et kall til *setContext*:**
+
+```java
+command.setContext(this.context);
+```
+
+Vi er nå klare til å opprette klassene `CmdLs`, `CmdPwd` og `CmdCd` som alle implementerer *Command* -grensesnittet.
+**TODO:**
+- La disse klassene ha en instansvariabel for kontekst, og la dem overskrive `setContext` -metoden slik at denne instansvariabelen bli initiert med en verdi når metoden kalles.
+- Kopier funksjonaliteten fra de tilsvarende metodene i SimpleShell inn i run-metodene i de nye klassene.
+- Fjern metodene fra SimpleShell (inkludert sekvensen med else-if i executeCommand), og installer i stedet kommandoene i *konstruktøren til SimpleShell*. Dette gjøres på samme måte som vi gjorde for echo -kommandoen i Main, men objektet vi kaller installCommand på heter *this* i stedet for *shell*: for eksempel `this.installCommand(new CmdLs())`.
+- Sjekk at testene fremdeles passerer og at de fremdeles virker i terminal-gui'en
+
+
+### `man`: kommando for å lese manualen
+
+* `man command` gir oss manualen til kommandoen `command`.
+
+**TODO:**
+- La `Command` -grensesnittet ha en metode `String getManual()` som returnerer instruksjoner for hvordan kommandoen brukes. Du må nå oppdatere alle klassene som implementerer Command slik at de implementerer metoden og returnerer en hensiktsmessig hjelpetekst.
+- La `Command` -grensesnittet ha en default-metode `default void setCommandContext(Map<String, Command>)` med en standard-implementasjon som ikke gjør noen ting.
+- I `SimpleShell::installCommand`, gjør et kall til setCommandContext med this.allCommands som argument.
+- I `CmdMan`, la det være en instansvariabel av typen `Map<String, Command>`, og initer denne i `setCommandContext`.
+- I `run` -metoden til `CmdMan`, hent ut riktig Command-objekt fra nevnte instansvariabel og returner resultatet av getManual() kalt på dette objektet.
+
+### Trykk backspace for å fjerne bakerste bokstav i kommandoen
+
+Undersøk metoden `SimpleShell::keyPressed` og se hvordan ulike taster håndteres. Legg til funskjonalitet slik at når backspace trykkes fjernes bakerste bokstav i kommandoen.
+
+> Hint: sjekk hvilken verdi som kommer når du trykker på backspace ved å legge til
+`System.out.println("Keycode pressed: '" + ((int) key) + "'");` i begynnelsen av keyPressed-metoden. Start programmet, trykk backspace og se hva som skrives ut. Dette vil være et tall, siden vi *castet* key-variabelen til en `int`.
+>
+> Når du senere ønsker å legge til en betingelse i programflyten, kan du også sammenligne castet verdi, slik: `((int) key) == /* tallet her */`
+
+### Starte java-programmer fra SimpleShell
+
+Det neste steget for å få et fullt funksjonelt shell er muligheten til å starte og avslutte andre programmer, kontrollere hva disse programmene får som input, og la dem gi oss output i sanntid. Hva som skal til for å klare alle disse oppgavene går utenfor pensum i INF101, og er ikke støttet av Terminal-klassen vår.
+
+Likevel kan vi gi en liten smakebit, nemlig hvordan vi kan kjøre andre *java* -programmer med den begrensning at de ikke er basert på interaktiv input i konsollen.
+
+#### Hello World
+
+**TODO: Opprett en klasse `HelloWorld` som skriver ut `"Hello World!"` til skjermen**. Denne skal du kjenne igjen fra tidligere:
+
+```java
+package no.uib.inf101.terminal;
+
+public class HelloWorld {
+  public static void main(String[] args) {
+    System.out.println("Hello World!");
+  }
+}
+```
+
+**TODO: Opprett en klasse `CmdJavaProgram` og kopier inn koden under** (avhengig av hvor mange metoder du har i `Command` -grensesnittet kan det være du må legge til en metode). Du trenger ikke å forstå alt koden gjør.
+
+```java
+package no.uib.inf101.terminal;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
+
+public class CmdJavaProgram implements Command {
+
+  private final Class<?> mainClass;
+  private final String commandName;
+
+  /**
+   * Create a command from a Java program. Programs that read from
+   * standard input are not supported, but printing to standard
+   * output (i.e. using System.out to print) is ok.
+   *
+   * @param commandName  The name of the command
+   * @param mainClass  The class containing a main(String[]) method
+   */
+  public CmdJavaProgram(String commandName, Class<?> mainClass) {
+    this.mainClass = mainClass;
+    this.commandName = commandName;
+  }
+  
+  @Override
+  public String getName() {
+    return this.commandName;
+  }
+
+  @Override
+  public String run(String[] args) {
+    // Remember original System.out and System.err
+    final PrintStream orgOut = System.out;
+    final PrintStream orgErr = System.err;
+
+    try {
+      // Prepare for capturing the output of the program
+      ByteArrayOutputStream out = new ByteArrayOutputStream();
+      PrintStream newOut = new PrintStream(out, true, StandardCharsets.UTF_8);
+      System.setOut(newOut);
+      System.setErr(newOut);
+
+      // Invoke  main method of the class for which this command was created
+      Method main = this.mainClass.getMethod("main", String[].class);
+      main.invoke(null, new Object[] {args});
+
+      // Convert the captured output to a string and return it
+      return out.toString(StandardCharsets.UTF_8);
+    } catch (NoSuchMethodException e) {
+      return "No main method found in class " + this.mainClass.getName();
+    } catch (Exception e) {
+      return e.toString();
+    } finally {
+      // Restore the original System.out and System.err
+      System.setOut(orgOut);
+      System.setErr(orgErr);
+    }
+  }
+}
+```
+
+Så gjenstår det å installere HelloWorld som en kommando `"hello"`.
+
+**TODO: I `Main::main`, installer HelloWorld som en kommando:**
+
+```java
+shell.installCommand(new CmdJavaProgram("hello", HelloWorld.class));
+```
+
+✅ Sjekk at du kan kjøre programmet, og at kommandoen `"hello"` skriver ut `Hello World!` i GUI'en.
+
+PS: Prøv også:
+
+```java
+shell.installCommand(new CmdJavaProgram("new", Main.class));
+```
+
+Hva er det som skjer?

guide/08-voluntary_improvements.md

+[forrige](07-improvements.md) • [oversikt](../README.md) • neste
+
+## Flere frivillige forbedringer
+
+Forbedringene under krever at du setter deg inn i `File` -klassen fra Java sitt standardbibliotek, og bruker `Context` -klassen som følger med dette prosjektet aktivt. Du kan lese litt om `File` i [kursnotatene](https://inf101v23.stromme.me/notat/inputoutput/#filer) eller slå opp i den [offisielle dokumentasjonen](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/File.html).
+
+### Forbedret `ls`: `ls -l`, `ls -a`, `ls path/to/folder`
+
+I bash har kommandoen `ls` flere muligheter enn det vi så langt har laget. For eksempel:
+* elementene vises i sortert rekkefølge
+* `ls -l` vil vise elementene med linjeskift `'\n'` mellom seg i stedet for mellomrom `' '`
+* `ls -a` vil vise skjulte filer, mens vanlig `ls` kun viser filer som ikke er skjulte.
+* `ls -la` er en kombinasjon av de to over
+* `ls path/to/folder` vil vise filene i mappen `cwd/path/to/folder`.
+
+Det kan være en fin øvelse å gjenskape dette for vår `ls` -kommando.
+
+### Flere kommandoer som trenger kontekst: touch, mkdir, cat, rm, mv, cp
+
+* `touch filename` oppretter en ny tom fil med det gitte navnet (hvis den ikke finnes fra før)
+* `mkdir dirname` oppretter en ny mappe med det gitte navnet (hvis den ikke finnes fra før)
+* `cat filename` returnerer tekst-innholdet i den gitte filen som en streng
+* `rm filname` sletter en fil eller en tom mappe (forsiktig når du tester med denne!)
+* `rm -r foldername` sletter en mappe og alt innholdet i den (veldig forsiktig når du tester med denne!)
+* `mv source target` endrer navn på filen eller mappen *source* til filnavnet/mappenavnet *target*. Dette kan innebære flytting hvis target er en sti til en annen mappe. Dersom *target* er en mappe som finnes fra før, flyttes *source* -filen/mappen til *target* -mappen og beholder sitt opprinnelige navn.
+* `cp source target` det samme som mv, men lager en kopi i stedet for å flytte.
+
+### `fgrep`: søking i filer
+
+*Grep* og lillebroren *fgrep* er på mange måter *cat* med et søkefilter inkludert. Den skriver kun ut de linjene som har innhold som matcher søkeordet. Standard bruk:
+
+`fgrep searchword filename`
+
+Vi anbefaler alle å bli kjent med hvordan grep/fgrep virker i bash. De ambisiøse kan også implementere det de klarer av fgrep til bruk i vårt eget SimpleShell:
+
+* `fgrep searchword filename -n` viser linjenummer
+* `fgrep searchword filename -i` ignorerer case, dvs søkeordet `abc` vil få treff på `aBC`
+* `fgrep searchword filename -v` skriver ut alle linjene som *ikke* matcher søkeordet
+* `fgrep searchword filename -c` skriver ut hvor mange linjer som matchet søkeordet
+* `fgrep searchword *` kjører grep på alle filer i current working directory. Hvis kombinert med `-n` viser utskriften navnet på filen ut først, og så linjenummer i den filen.
+* `fgrep searchword * -l` skriver kun ut navnet på filene med innhold som matcher, uten å skrive ut selve treffene
+* `fgrep searchword * -L` skriver kun ut navnet på filene *uten* innhold som matcher
+* `fgrep searchword foldername -r` kjører grep på alle filer i mappen *og* på alle filer i alle undermapper i uendelig dypde.
+
+Flagg (delen av kommandoene som begynner med `-`) kan ofte kombineres, for eksempel vil `-ni` både vise linjenummer og ignorere case. Du trenger ikke håndtere søkeord som inneholder mellomrom i første omgang, det blir eventuelt en superbonusoppgave.
+
+Prøv deg frem og sammenlign med hva som skjer i bash. Les mer om grep i introduksjonen til [ryanstutorials](https://ryanstutorials.net/linuxtutorial/grep.php), [opensourceforu](https://www.opensourceforu.com/2012/06/beginners-guide-gnu-grep-basics/) eller [danielmiessler](https://danielmiessler.com/study/grep/).

build_app_mac.sh → make/build_app_mac.sh

@@ -30,8 +30,11 @@ echo "  PROJECT_VERSION: $PROJECT_VERSION" # version in pom, e.g. "1.0-SNAPSHOT"
 echo "computed variables..."
 CURRENT_YEAR=$(date +'%Y')
 echo "  CURRENT_YEAR: $CURRENT_YEAR"
-PATH_TO_MAIN_CLASS="target/classes/${MAIN_CLASS//'.'//}.class"
+#PATH_TO_MAIN_CLASS="target/classes/${MAIN_CLASS//'.'//}.class"
+PATH_TO_MAIN_CLASS="target/classes/${APP_PACKAGE//'.'//}/"
 echo "  PATH_TO_MAIN_CLASS: $PATH_TO_MAIN_CLASS"
+echo "  pwd: "
+pwd
 
 # ------ SETUP DIRECTORIES AND FILES ----------------------------------------
 # Remove previously generated java runtime and installers. Copy all required
@@ -54,6 +57,14 @@ cp "target/${MAIN_JAR}" target/installer/input/libs/
 ## application.
 
 echo "detecting required modules.."
+echo "$JAVA_HOME/bin/jdeps" \
+       -q \
+       --multi-release "${JAVA_VERSION}" \
+       --ignore-missing-deps \
+       --print-module-deps \
+       --class-path "target/installer/input/libs/*" \
+         "$PATH_TO_MAIN_CLASS"
+
 detected_modules=$("$JAVA_HOME/bin/jdeps" \
   -q \
   --multi-release "${JAVA_VERSION}" \
@@ -75,6 +86,14 @@ echo "  detected modules: ${detected_modules}"
 # works with dependencies that are not fully modularized, yet.
 
 echo "creating java runtime image..."
+echo "$JAVA_HOME/bin/jlink" \
+       --strip-native-commands \
+       --no-header-files \
+       --no-man-pages  \
+       --compress=2  \
+       --strip-debug \
+       --add-modules "${detected_modules}" \
+       --output target/java-runtime
 "$JAVA_HOME/bin/jlink" \
   --strip-native-commands \
   --no-header-files \
@@ -88,6 +107,21 @@ echo "creating java runtime image..."
 # In the end we will find the package inside the target/installer directory.
 
 echo "creating installer of type $INSTALLER_TYPE..."
+echo "$JAVA_HOME/bin/jpackage" \
+       --type "$INSTALLER_TYPE" \
+       --dest target/installer \
+       --input target/installer/input/libs \
+       --name "${PROJECT_NAME}" \
+       --main-class "${MAIN_CLASS}" \
+       --main-jar "${MAIN_JAR}" \
+       --runtime-image target/java-runtime \
+       --icon "${ICON_PATH}" \
+       --app-version "${APP_VERSION}" \
+       --vendor "${APP_VENDOR}" \
+       --copyright "Copyright © ${CURRENT_YEAR} ${APP_VENDOR}." \
+       --mac-package-identifier "${APP_PACKAGE}"
+     # --java-options -Xmx2048m \
+
 "$JAVA_HOME/bin/jpackage" \
   --type "$INSTALLER_TYPE" \
   --dest target/installer \

build_app_windows.bat → make/build_app_windows.bat

@@ -29,7 +29,8 @@ ECHO "  PROJECT_NAME: %PROJECT_NAME%"
 ECHO "  PROJECT_VERSION: %PROJECT_VERSION%"
 
 ECHO "computed variables..."
-SET PATH_TO_MAIN="target\classes\%MAIN_CLASS:.=\%.class"
+@REM SET PATH_TO_MAIN="target\classes\%MAIN_CLASS:.=\%.class"
+SET PATH_TO_MAIN="target\classes\%APP_PACKAGE:.=\%"
 ECHO "  PATH_TO_MAIN: %PATH_TO_MAIN%"
 SET YEAR=%DATE:~6,4%
 ECHO "  YEAR: %YEAR%"

pom.xml

@@ -5,10 +5,10 @@
     <modelVersion>4.0.0</modelVersion>
 
     <!-- Major project properties -->
-    <groupId>no.uib.inf101.app</groupId>
-    <artifactId>SamplePackagedSwingApp</artifactId>
+    <groupId>no.uib.inf101.terminal</groupId> <!-- must match package of Main class -->
+    <artifactId>INF101ShellLab</artifactId>
     <version>1.0-SNAPSHOT</version>
-    <name>Sample Application</name>
+    <name>INF101 Shell Lab</name>
     <packaging>jar</packaging>
 
     <properties>
@@ -17,8 +17,8 @@
         <java.version>17</java.version>
 
         <!-- Properties required for packaging application as JAR and installer -->
-        <app.main.class>no.uib.inf101.terminal.Main</app.main.class>
-        <app.vendor>Torstein Strømme</app.vendor> <!-- copyright holder -->
+        <app.main.class>${groupId}.Main</app.main.class> <!-- name of main class -->
+        <app.vendor>Torstein Strømme</app.vendor> <!-- replace with your name -->
         <app.version>1.0.0</app.version> <!-- version displayed in "about" -->
         <app.installer.macosx.type>dmg</app.installer.macosx.type> <!-- dmg, pkg -->
         <app.installer.windows.type>msi</app.installer.windows.type> <!-- msi, exe -->
@@ -30,6 +30,7 @@
         <maven.compiler.plugin.version>3.10.1</maven.compiler.plugin.version>
         <maven.dependency.plugin.version>3.4.0</maven.dependency.plugin.version>
         <maven.jar.plugin.version>3.3.0</maven.jar.plugin.version>
+        <maven.surefire.plugin.version>3.0.0-M5</maven.surefire.plugin.version>
         <exec.maven.plugin.version>1.6.0</exec.maven.plugin.version>
 
         <!-- Computed properties -->
@@ -99,6 +100,17 @@
                     </archive>
                 </configuration>
             </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven.surefire.plugin.version}</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.jupiter</groupId>
+                        <artifactId>junit-jupiter-engine</artifactId>
+                        <version>${junit.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
     </build>
 
@@ -125,7 +137,7 @@
                         </executions>
                         <configuration>
                             <workingDirectory>${project.basedir}</workingDirectory>
-                            <executable>./build_app_mac.sh</executable>
+                            <executable>./make/build_app_mac.sh</executable>
                             <environmentVariables>
                                 <APP_PACKAGE>${project.groupId}</APP_PACKAGE>
                                 <ABOUT_NAME>${project.name}</ABOUT_NAME>
@@ -168,7 +180,7 @@
                         </executions>
                         <configuration>
                             <workingDirectory>${project.basedir}</workingDirectory>
-                            <executable>build_app_windows.bat</executable>
+                            <executable>./make/build_app_windows.bat</executable>
                             <environmentVariables>
                                 <APP_PACKAGE>${project.groupId}</APP_PACKAGE>
                                 <APP_VENDOR>${app.vendor}</APP_VENDOR>

src/main/java/no/uib/inf101/terminal/CommandLineInterface.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - CommandLineInterface.java
+//
+// Grensesnittet CommanLineInterface beskriver metoder for input og
+// output til et program som virker med et tekstbasert grensesnitt.
+// Du trenger ikke gjøre noen endringer i denne filen for denne lab'en.
+
 /**
  * A command line interface is a program with a text-based user interface.
  * The user can enter keys as input, and the program will respond by giving
@@ -10,13 +16,14 @@ public interface CommandLineInterface {
   /**
    * Called when a key is pressed.
    *
-   * @param key The key that was pressed
+   * @param key  the key that was pressed
    */
   void keyPressed(char key);
 
   /**
    * Get the text to display on the screen.
-   * @return The text to display
+   *
+   * @return  the text to display
    */
   String getScreenContent();
 }

src/main/java/no/uib/inf101/terminal/Context.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - Context.java
+//
+// Denne filen inneholder kode som navigerer et filsystem. Du trenger
+// ikke gjøre noen endringer i denne filen for denne lab'en (med mindre
+// du selv ønsker).
+
 import java.io.File;
 import java.io.IOException;
 import java.util.Objects;
 
 public class Context {
 
+  ////////////////////////
+  // Instance variables
+  ////////////////////////
   private final File home;
   private File cwd;
 
+  ////////////////////////
+  // Constructors
+  ////////////////////////
+
+  /**
+   * Create a new context with the java current working directory as
+   * home.
+   */
+  public Context() {
+    this(new File(System.getProperty("user.dir")));
+  }
+
+  /**
+   * Create a new context with the given directory as home.
+   *
+   * @param home  the home directory.
+   */
   public Context(File home) {
     try {
       this.home = home.getCanonicalFile();
@@ -18,27 +44,50 @@ public class Context {
     }
   }
 
+  ////////////////////////
+  // Instance methods
+  ////////////////////////
+
+  /**
+   * Go to the given path, if it exists. The path can be relative to
+   * the current working directory, or absolute.
+   *
+   * @param path  the path to go to.
+   * @return  true if the path exists, false otherwise
+   */
   public boolean goToPath(String path) {
-    File newDir = new File(cwd, path);
+    File newDir = new File(this.cwd, path);
     if (!newDir.isDirectory()) {
       return false;
     }
     try {
-      cwd = newDir.getCanonicalFile();
+      this.cwd = newDir.getCanonicalFile();
+      return true;
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
-    return true;
   }
 
+  /**
+   * Get the current working directory.
+   *
+   * @return  the current working directory.
+   */
   public File getCwd() {
     return this.cwd;
   }
 
+  /** Set the current working directory to the home directory.*/
   public void goToHome() {
     this.cwd = this.home;
   }
 
+  /**
+   * Check if the current working directory is the home directory.
+   *
+   * @return  true if the current working directory is the home
+   *          directory, false otherwise.
+   */
   public boolean isAtHome() {
     return Objects.equals(this.cwd, this.home);
   }

src/main/java/no/uib/inf101/terminal/DummyShell.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - DynamicShell.java
+//
+// Denne koden er gitt som et eksempel på en klasse som implementerer
+// CommandLineInterface. Du trenger ikke gjøre noen endringer i denne
+// filen for denne lab'en (med mindre du selv ønsker).
+
 public class DummyShell implements CommandLineInterface {
 
   private String screenContent = "$ ";
 
   @Override
-  public void keyPressed(char keyCode) {
-    if (keyCode == '\n') {
+  public void keyPressed(char key) {
+    if (key == '\n') {
       screenContent += "\n$ ";
     } else {
-      screenContent += keyCode;
+      screenContent += key;
     }
   }
 

src/main/java/no/uib/inf101/terminal/EchoShell.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - EchoShell.java
+//
+// Denne koden er gitt som et eksempel på en klasse som implementerer
+// CommanLineInterface. Du trenger ikke gjøre noen endringer i denne
+// filen for denne lab'en (med mindre du selv ønsker).
+
 import java.util.ArrayList;
 
 public class EchoShell implements CommandLineInterface {
@@ -7,13 +13,13 @@ public class EchoShell implements CommandLineInterface {
   String currentLine = "";
 
   @Override
-  public void keyPressed(char keyCode) {
-    if (keyCode == '\n') {
+  public void keyPressed(char key) {
+    if (key == '\n') {
       outputLines.add("$ " + currentLine);
       outputLines.add("Oh, an echo! listen: " + currentLine);
       currentLine = "";
     } else {
-      currentLine += keyCode;
+      currentLine += key;
     }
   }
 

src/main/java/no/uib/inf101/terminal/Main.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - Main.java
+// Dette er filen som inneholder main-metoden.
+
 public class Main {
 
   public static void main(String[] args) {

src/main/java/no/uib/inf101/terminal/SimpleShell.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - SimpleShell.java
+//
+// Dette er klassen vi skal forbedre i denne lab'en. Slik koden er
+// allerede før du begynner på laben, støtter den tre kommandoer:
+//
+// - cd: Bytt til en annen mappe
+// - ls: List opp filer i mappen
+// - pwd: Vis sti til nåværende mappe
+//
+// Vi skal endre denne klassen slik at den
+// - kan vises av Terminal.java
+// - kan støtte ubegrenset mange kommandoer
+
 import java.io.File;
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
-// TODO: Let SimpleShell implement CommandLineInterface
+// TODO 1: Let SimpleShell implement CommandLineInterface
 public class SimpleShell {
 
   //////////////////////////////////////////////////////////////////////
@@ -14,20 +28,24 @@ public class SimpleShell {
   /** The prompt to show before each command */
   private final String prompt = "$ ";
   /** The context variable contains cwd and home directories etc. */
-  private final Context context = new Context(
-      new File(System.getProperty("user.dir"))
-  );
+  private final Context context = new Context();
   /** A list of historic commands and their outputs */
-  private final ArrayList<String> history = new ArrayList<>();
+  private final List<String> history = new ArrayList<>();
   /** The command currently being typed */
   private String currentCommand = "";
+  // TODO 4: Create instance variable storing Command objects
 
   //////////////////////////////////////////////////////////////////////
-  /// Public methods                                              //////
+  /// Public instance methods                                     //////
   /// (methods expected to be used by someone outside this class) //////
   //////////////////////////////////////////////////////////////////////
 
-  // TODO: rename method to fit new interface, annotate with @Override
+  /** Constructor for SimpleShell */
+  public SimpleShell() {
+    // TODO 7-8-9: Install core commands SimpleShell supports (pwd, ls, cd)
+  }
+
+  // TODO 2: rename method to fit new interface, annotate with @Override
   // Note: methods with @Override generally do not need javadoc comments,
   // since the javadoc comment is inherited. You should hence remove the
   // javadoc comment here unless there is something special about this
@@ -42,10 +60,12 @@ public class SimpleShell {
       this.processCurrentCommandLine();
     } else if (key >= ' ' && key <= '~') {
       this.currentCommand += key;
+    } else {
+      // Some special key was pressed (e.g. shift, ctrl), we ignore it
     }
   }
 
-  // TODO: rename method to fit new interface, annotate with @Override
+  // TODO 3: rename method to fit new interface, annotate with @Override
   /**
    * Get the text which the terminal should display
    *
@@ -61,6 +81,8 @@ public class SimpleShell {
     return s;
   }
 
+  // TODO 5: Add method to install a command
+
   //////////////////////////////////////////////////////////////////////
   /// Private methods                                ///////////////////
   /// (helper methods used internally in this class) ///////////////////
@@ -98,7 +120,8 @@ public class SimpleShell {
    * @return  The output of the command
    */
   private String executeCommand(String commandName, String[] args) {
-    // TODO: Change sequence of if/else if below to a lookup in a map
+    // TODO 6: Call run on Command object for given commandName if present
+    // TODO 7-8-9: Remove if's for cd, ls, pwd once installed as commands
     if (Objects.equals(commandName, "pwd")) {
       return this.doPwd(args);
     } else if (Objects.equals(commandName, "cd")) {
@@ -110,12 +133,12 @@ public class SimpleShell {
     }
   }
 
-  // TODO: remove this method and replace it with Command -type object
+  // TODO 7: remove this method and replace it with Command -type object
   private String doPwd(String[] args) {
     return this.context.getCwd().getAbsolutePath();
   }
 
-  // TODO: remove this method and replace it with Command -type object
+  // TODO 8: remove this method and replace it with Command -type object
   private String doCd(String[] args) {
     if (args.length == 0) {
       this.context.goToHome();
@@ -131,7 +154,7 @@ public class SimpleShell {
     }
   }
 
-  // TODO: remove this method and replace it with Command -type object
+  // TODO 9: remove this method and replace it with Command -type object
   private String doLs(String[] args) {
     File cwd = this.context.getCwd();
     String s = "";

src/main/java/no/uib/inf101/terminal/Terminal.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - Terminal.java
+//
+// Denne filen inneholder kode som tegner et vindu på skjermen, som
+// viser et CommandLineInterface -program. Du er ikke forventet å
+// forstå denne koden denne uken, og du trenger ikke gjøre noen
+// endringer i denne filen for denne lab'en (med mindre du selv ønsker).
+
 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.KeyAdapter;
 import java.awt.event.KeyEvent;
 
+/**
+ * A simple terminal GUI for interacting with command line interfaces.
+ */
 public class Terminal extends JPanel {
-  private final CommandLineInterface terminal;
+  ////////////////////////
+  // Instance variables
+  ////////////////////////
+  /** The command line interface to interact with. */
+  private final CommandLineInterface cli;
 
+  ////////////////////////
+  // Constructor
+  ////////////////////////
+  /** Create a new terminal GUI for the given command line interface. */
   public Terminal(CommandLineInterface cli) {
-    this.terminal = cli;
+    this.cli = cli;
     this.setPreferredSize(new Dimension(400, 300));
     this.setFocusable(true);
     this.addKeyListener(new KeyAdapter() {
       @Override
       public void keyPressed(KeyEvent e) {
-        Terminal.this.terminal.keyPressed(e.getKeyChar());
+        Terminal.this.cli.keyPressed(e.getKeyChar());
         Terminal.this.repaint();
       }
     });
   }
 
-
+  ////////////////////////
+  // Instance methods
+  ////////////////////////
   @Override
   public void paintComponent(Graphics g) {
     super.paintComponent(g);
-    String content = this.terminal.getScreenContent();
-
-    // Calculate number of lines that can fit display
-    int lineHeight = g.getFontMetrics().getHeight() + 5;
-    int lines = this.getHeight() / lineHeight;
 
-    // Draw the text on the screen, line by line
     g.setColor(Color.BLACK);
     g.setFont(new Font("Monospaced", Font.PLAIN, 12));
-    int y = lineHeight;
+    int lineHeight = g.getFontMetrics().getHeight() + 2;
 
-    // Iterate through the last 'lines' lines of the content
-    String[] linesOfContent = content.split("\n");
-    for (int i = Math.max(0, linesOfContent.length - lines); i < linesOfContent.length; i++) {
-      g.drawString(linesOfContent[i], 5, y);
+    // Tegn teksten på skjermen, linje for linje. Potensiell forbedring:
+    // hvis det er for mange linjer, vis kun de siste av dem.
+    String content = this.cli.getScreenContent();
+    int y = 20;
+    for (String line : content.split("\n")) {
+      g.drawString(line, 5, y);
       y += lineHeight;
     }
   }
 
+  /** Run the terminal GUI in a window frame. */
   public void run() {
     JFrame frame = new JFrame("INF101 Terminal");
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

src/main/java/no/uib/inf101/terminal/TextAnswers.java

 package no.uib.inf101.terminal;
 
+// UiB INF101 ShellLab - TextAnswers.java
+//
+// I denne filen skal du besvare spørsmålene under. Du kan sjekke
+// svarene dine ved å kjøre testen TextAnswersTest.java.
+
 public class TextAnswers {
 
-  /*
+  /**
    * Consider the following code:
-   *
    * CommandLineInterface cli = new DummyShell();
+   *
+   * What is the type of the variable cli?
    */
-  /** What is the type of the variable cli? */
   static final String q1 = "";
 
-  /** In which class is the object cli refers to? */
+  /**
+   * Consider the following code:
+   * CommandLineInterface cli = new DummyShell();
+   *
+   * In which class is the object cli refers to?
+   */
   static final String q2 = "";
 
-  /** True or false: CommandLineInterface is both a type and an interface. */
+  /**
+   * Consider the following code:
+   * CommandLineInterface cli = new DummyShell();
+   *
+   * true or false: CommandLineInterface is both a type and an interface.
+   */
   static final Boolean q3 = null;
 
-  /** True or false: DummyShell is both a class and a type. */
+  /**
+   * Consider the following code:
+   * CommandLineInterface cli = new DummyShell();
+   *
+   * true or false: DummyShell is both a class and a type.
+   */
   static final Boolean q4 = null;
 
 }