adding files to remote repository

Author: jorge1289

Commit.class

@@ -0,0 +1,55 @@
+package gitlet;
+import java.io.File;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.HashMap;
+
+public class Commit implements Serializable {
+
+    private String message;
+
+    /** something that keeps tracks of what files this commit is tracking.  file name is the key, value is the blobs or the sha1.*/
+    private HashMap<String, String> Tracker;
+
+    /** the Head commit of a commit object, will be a file name which were we can find the parent.*/
+    private String parent;
+
+    /** the Hash of the given Commit object */
+    private String ownHash;
+
+    /** the variable representing the date of a commit object */
+    private String _date;
+
+    private String _merge;
+
+    public Commit(String message, HashMap<String,String> Tracker, String parent, String date, String merge) {
+        this.Tracker = Tracker;
+        this.message = message;
+        _date = date;
+        this.parent = parent;
+        ownHash = Utils.sha1((Object) Utils.serialize(this), getMessage(), getDate());
+        this._merge = merge;
+    }
+
+    public String getMessage() {
+        return this.message;
+    }
+
+    public String getDate() {
+        return _date;
+    }
+    public String getOwnHash() {
+        return ownHash;
+    }
+
+    public String getParent() {
+        return this.parent;
+    }
+    public HashMap<String, String> getTracker() {
+        return this.Tracker;
+    }
+    public String getMerge() {
+        return this._merge;
+    }
+
+}

Commit.java

@@ -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("---");
+        }
+    }
+}
+

DumpObj.class

@@ -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.java

@@ -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);
+    }
+
+}

Dumpable.class

@@ -0,0 +1,57 @@
+package gitlet;
+import java.io.File;
+import java.util.Arrays;
+import java.util.Date;
+
+/** Driver class for Gitlet, the tiny stupid version-control system.
+ *  @author Jorge Emanuel Nunez
+ */
+public abstract class Main {
+
+    /** Usage: java gitlet.Main ARGS, where ARGS contains
+     *  <COMMAND> <OPERAND> ....
+     *  java gitlet.Main add hello.txt*/
+
+    private static File CWD = new File(System.getProperty("user.dir"));
+    private static Repository repo = new Repository();
+
+
+    public static void main(String... args) {
+        if (args[0].equals("add")) {
+            repo.add(args[1]);
+        }
+        if (args[0].equals("init")) {
+            repo.init();
+        }
+        if (args[0].equals("commit")) {
+            repo.commit(args[1]);
+        }
+        if (args[0].equals("log")) {
+            repo.log();
+        }
+        if (args[0].equals("checkout")) {
+            repo.checkout(args);
+        }
+        if (args[0].equals("branch")) {
+            repo.branch(args[1]);
+        }
+        if (args[0].equals("global-log")) {
+            repo.globalLog();
+        }
+        if (args[0].equals("find")) {
+            repo.find(args[1]);
+        }
+        if (args[0].equals("rm-branch")) {
+            repo.rmBranch(args[1]);
+        }
+        if (args[0].equals("status")) {
+            repo.status();
+        }
+        if (args[0].equals("reset")) {
+            repo.reset(args[1]);
+        }
+        if (args[0].equals("rm")) {
+            repo.rm(args[1]);
+        }
+    }
+}

Dumpable.java

@@ -0,0 +1,69 @@
+# This makefile is defined to give you the following targets:
+#
+#    default: The default target: Compiles $(PROG) and whatever it 
+#	   depends on.
+#    style: Run our style checker on the project source files.  Requires that
+#           the source files compile.
+#    check: Compile $(PROG), if needed, and then for each file, F.in, in
+#	   directory testing, use F.in as input to "java $(MAIN_CLASS)" and
+#          compare the output to the contents of the file names F.out.
+#          Report discrepencies.
+#    clean: Remove all the .class files produced by java compilation, 
+#          all Emacs backup files, and testing output files.
+#
+# In other words, type 'gmake' to compile everything; 'gmake check' to 
+# compile and test everything, and 'gmake clean' to clean things up.
+# 
+# You can use this file without understanding most of it, of course, but
+# I strongly recommend that you try to figure it out, and where you cannot,
+# that you ask questions.  The Lab Reader contains documentation.
+
+STYLEPROG = style61b
+
+JFLAGS = -g -Xlint:unchecked -Xlint:deprecation
+
+CLASSDIR = ../classes
+
+# See comment in ../Makefile
+PYTHON = python3
+
+RMAKE = "$(MAKE)"
+
+# A CLASSPATH value that (seems) to work on both Windows and Unix systems.
+# To Unix, it looks like ..:$(CLASSPATH):JUNK and to Windows like
+# JUNK;..;$(CLASSPATH).
+CPATH = "..:$(CLASSPATH):;..;$(CLASSPATH)"
+
+# All .java files in this directory.
+SRCS := $(wildcard *.java)
+
+.PHONY: default check clean style acceptance unit
+
+# As a convenience, you can compile a single Java file X.java in this directory
+# with 'make X.class'
+%.class: %.java
+	javac $(JFLAGS) -cp $(CPATH) $<
+
+# First, and therefore default, target.
+default: compile
+
+compile: $(SRCS)
+	javac $(JFLAGS) -cp $(CPATH) $(SRCS)
+
+style: default
+	$(STYLEPROG) $(SRCS) 
+
+check:
+	$(RMAKE) -C .. PYTHON=$(PYTHON) check
+
+acceptance:
+	$(RMAKE) -C .. PYTHON=$(PYTHON) acceptance
+
+unit: default
+	java -ea -cp $(CPATH) gitlet.UnitTest
+
+# 'make clean' will clean up stuff you can reconstruct.
+clean:
+	$(RM) *~ *.class sentinel
+
+

GitletException.class

@@ -1,2 +1,18 @@
-# Gitlet
-Version-Control System
+# Gitlet: A Miniature Version-Control System
+Gitlet is a simplified version-control system inspired by Git, designed to implement essential features for managing and tracking changes in a collection of files. This project was developed as part of UC Berkeley's CS 61B: Data Structures course and aims to provide hands-on experience with building a lightweight version-control system from the ground up.
+
+# Features:
+Commit System: Save the entire state of a directory with a single commit, capturing snapshots of your project at different points in time.
+
+File Restoration: Check out and restore specific versions of files or entire commits to recover previous states of the project.
+
+Version History: View the complete log of commits to track the history and evolution of your project.
+
+Branching: Create and manage branches to organize related sequences of commits for different development paths.
+
+Merging: Merge changes from one branch into another, allowing collaboration and combination of different code versions.
+
+Gitlet mimics the basic functionality of Git but is designed to be smaller and simpler, making it ideal for learning core version-control concepts.
+
+# Technical Notes:
+The project is written in Java and emphasizes implementing fundamental version-control operations manually to understand their internal mechanics.