Add files via upload

Author: koenmatt

Branch.class

@@ -0,0 +1,99 @@
+package gitlet;
+
+
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.HashMap;
+import static gitlet.Utils.*;
+
+/** Represents a gitlet commit object.
+ *  does at a high level.
+ *
+ *  @author Matthew Koen
+ */
+public class Commit implements Serializable {
+    /**
+     * List all instance variables of the Commit class here with a useful
+     * comment above them describing what that variable represents and how that
+     * variable is used. We've provided  one example for `message`.
+     */
+
+    /** The message of this Commit. */
+
+    private String parent;
+
+    private HashMap<String, String> blobs;
+
+    private String iD;
+
+    private String time;
+
+    private String message;
+
+
+    public Commit(String message, String time) {
+        this.message = message;
+        this.time = time;
+    }
+
+    public Commit(String parent, String message, String time, HashMap<String, String> blobs) {
+        this.message = message;
+        this.time = time;
+        this.blobs = blobs;
+        this.parent = parent;
+
+    }
+
+    public String getParent() {
+        return parent;
+    }
+
+    public String getID() {
+        return iD;
+    }
+
+    public HashMap<String, String> getBlobs() {
+        return blobs;
+    }
+
+    public void updateBlobs(HashMap<String, String> k) {
+        blobs = k;
+    }
+
+    public static void saveBlobs(HashMap<String, String> blobs) {
+        for (String fileName: blobs.keySet()) {
+            File baseFile = join(Repository.CWD, fileName);
+            File blob = join(Repository.BLOB_DIR, blobs.get(fileName));
+
+            try {
+                blob.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            byte[] content = readContents(baseFile);
+            writeContents(blob, content);
+        }
+
+    }
+
+    public void updateParent(String parentSHA) {
+        parent = parentSHA;
+
+    }
+
+    public void updateID(String identifier) {
+        this.iD = identifier;
+    }
+
+    public String getTime() {
+        return time;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+}

Commit.class

@@ -0,0 +1,43 @@
+package gitlet;
+
+import java.io.File;
+
+/** A debugging class whose main program may be invoked as follows:
+ *      java gitlet.DumpObj FILE...
+ *  where each FILE is a file produced by Utils.writeObject (or any file
+ *  containing a serialized object).  This will simply read FILE,
+ *  deserialize it, and call the dump method on the resulting Object.
+ *  The object must implement the gitlet.Dumpable interface for this
+ *  to work.  For example, you might define your class like this:
+ *
+ *        import java.io.Serializable;
+ *        import java.util.TreeMap;
+ *        class MyClass implements Serializeable, Dumpable {
+ *            ...
+ *            @Override
+ *            public void dump() {
+ *               System.out.printf("size: %d%nmapping: %s%n", _size, _mapping);
+ *            }
+ *            ...
+ *            int _size;
+ *            TreeMap<String, String> _mapping = new TreeMap<>();
+ *        }
+ *
+ *  As illustrated, your dump method should print useful information from
+ *  objects of your class.
+ *  @author P. N. Hilfinger
+ */
+public class DumpObj {
+
+    /** Deserialize and apply dump to the contents of each of the files
+     *  in FILES. */
+    public static void main(String... files) {
+        for (String fileName : files) {
+            Dumpable obj = Utils.readObject(new File(fileName),
+                                            Dumpable.class);
+            obj.dump();
+            System.out.println("---");
+        }
+    }
+}
+

Commit.java

@@ -0,0 +1,11 @@
+package gitlet;
+
+import java.io.Serializable;
+
+/** An interface describing dumpable objects.
+ *  @author P. N. Hilfinger
+ */
+interface Dumpable extends Serializable {
+    /** Print useful information about this object on System.out. */
+    void dump();
+}

DumpObj.class

@@ -0,0 +1,20 @@
+package gitlet;
+
+/** General exception indicating a Gitlet error.  For fatal errors, the
+ *  result of .getMessage() is the error message to be printed.
+ *  @author P. N. Hilfinger
+ */
+class GitletException extends RuntimeException {
+
+
+    /** A GitletException with no message. */
+    GitletException() {
+        super();
+    }
+
+    /** A GitletException MSG as its message. */
+    GitletException(String msg) {
+        super(msg);
+    }
+
+}

DumpObj.java

@@ -0,0 +1,86 @@
+package gitlet;
+
+
+/** Driver class for Gitlet, a subset of the Git version-control system.
+ *  @author Matthew Koen
+ */
+public class Main {
+
+    /** Usage: java gitlet.Main ARGS, where ARGS contains
+     *  <COMMAND> <OPERAND1> <OPERAND2> ... 
+     */
+
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.print("Must have at least one argument");
+            return;
+        }
+
+        String firstArg = args[0];
+        switch (firstArg) {
+            case "init":
+                Repository.init();
+                break;
+            case "add":
+                Repository.add(args[1]);
+                break;
+            case "commit":
+                if ((args.length < 2) || (args[1].equals(""))) {
+                    System.out.print("Please enter a commit message.");
+                    break;
+                }
+                Repository.commit(args[1]);
+                break;
+            case "rm":
+                Repository.rm(args[1]);
+                break;
+            case "log":
+                Repository.log();
+                break;
+            case "global-log":
+                Repository.globalLog();
+                break;
+            case "find":
+                Repository.find(args[1]);
+                break;
+            case "status":
+                Repository.status();
+                break;
+            case "checkout":
+                if (args.length == 3) {
+                    Repository.checkout(args[2]);
+                } else if (args.length == 4) {
+                    if (!args[2].equals("--")) {
+                        System.out.print("Incorrect operands.");
+                        break;
+                    }
+                    Repository.checkout(args[3], args[1]);
+                } else if (args.length == 2) {
+                    Repository.checkoutBranch(args[1]);
+                }
+                break;
+            case "branch":
+                Repository.branch(args[1]);
+                break;
+            case "rm-branch":
+                Repository.rmBranch(args[1]);
+                break;
+            case "reset":
+
+                break;
+            case "merge":
+
+                break;
+            default:
+                System.out.print("Unknown argument.");
+        }
+
+
+
+    }
+
+
+
+
+}

Dumpable.class

@@ -0,0 +1,21 @@
+package gitlet;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/** A suite of tests for IntList.
+ @author Zephyr Barkan, Maurice Lee, Kevin Lin
+ */
+
+public class MiscTests {
+
+
+    @Test
+    public void testAdd() {
+        String[] test = new String[]{"add", "kalsdf"};
+        Main.main(test);
+    }
+
+
+
+}