LICENSE

-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

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 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;
 
 }

src/test/java/no/uib/inf101/terminal/TestSimpleShellEcho.java

@@ -30,7 +30,7 @@ public class TestSimpleShellEcho {
 //    shell.keyPressed('r');
 //    shell.keyPressed('\n');
 //
-//    String expected = "$ echo foo bar \nfoo bar \n$ ";
+//    String expected = "$ echo foo bar\nfoo bar \n$ ";
 //    assertEquals(expected, shell.getScreenContent());
 //  }
 }