copernicium 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cffaf1f93a4556043ac0a484ef0e10c24f7ea692
+  data.tar.gz: 41ece5cd459baf3690d2701e153b232293f3a433
+SHA512:
+  metadata.gz: 215e18ebaa93fb182b3ea4407bbf266cee5004baef77e1ff195cbcd32061a7314e7c49b02b1f762482c950436c495b802f302d8d2bf976c0b17518bd17d5444c
+  data.tar.gz: ebf39e146f63bc17bc70de329ea98c2b5f0cbea79f6a4aa620f9f21719f96879ea7737864e34a2d747ee75861ba2c5f9daad1c9a6f55c81a509a6a95a324f265

data/bin/cn

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+# copernicium -  a distributed version control system
+
+require_relative "../lib/required.rb"
+
+include Copernicium
+
+Copernicium::Driver.new.run(ARGV)
+

data/lib/RevLog.rb

@@ -0,0 +1,141 @@
+# Revlog Top Level Function Definitions (Xiangru)
+#
+# add_file: add a file to the revision history
+# in - file name, content
+# out - hash id of file (file_id)
+#
+# delete_file: a delete a file from revision history
+# in - file_id
+# out - exit status code
+#
+# diff_files: generate the differences between 2 files
+# in - two file_ids
+# out - list of differences
+#
+# get_file: get the contents of a file based on hash id
+# in - file_id
+# out - content of specified file
+#
+# hash_file: generate hash id for a given file
+# in - file name, content
+# out - hashed id
+#
+# merge: given two files, try to merge them
+# in - file_id_1, file_id_2
+# out - success and merged file name/content, or failure and conflict
+
+module Copernicium
+  class RevLog
+    def initialize(project_path)
+      @project_path = project_path
+      @cop_path = File.join(project_path, ".cop")
+      @log_path = File.join(@cop_path, "logmap.yaml")
+      @hash_path = File.join(@cop_path, "hashmap.yaml")
+      if File.exist?(@log_path) and File.exist?(@hash_path) then
+        @logmap = default_hash_factory.merge(YAML.load_file(@log_path))
+        @hashmap = default_hash_factory.merge(YAML.load_file(@hash_path))
+      else
+        @logmap = default_hash_factory()
+        @hashmap = default_hash_factory()
+        unless File.exist?(@cop_path)
+          Dir.mkdir(@cop_path)
+        end
+      end
+    end
+
+    def default_hash_factory()
+      Hash.new {[]}
+    end
+
+    def add_file(file_name, content)
+      hash = hash_file(file_name, content)
+      File.open(File.join(@cop_path, hash), "w") { |f|
+        f.write(content)
+      }
+      @logmap[file_name] = @logmap[file_name] << {:time => Time.now,
+                                                  :hash => hash}
+      @hashmap[hash] = @hashmap[hash] << {:time => Time.now,
+                                          :filename => file_name}
+      update_log_file()
+      return hash
+    end
+
+    ## return 1 if succeed, otherwise 0
+    def delete_file(file_id)
+      begin
+        file_name = @hashmap[file_id][0][:filename]
+        @hashmap[file_id].delete_if { |e|
+          e[:filename] == file_name
+        }
+        @logmap[file_name].delete_if { |e|
+          e[:hash] == file_id
+        }
+        update_log_file()
+        File.delete(File.join(@cop_path, file_id))
+        return 1
+      rescue Exception
+        return 0
+      end
+    end
+
+
+    def get_file(file_id)
+      file_path = File.join(@cop_path, file_id)
+      if File.exist?(file_path)
+        File.open(file_path, "r") { |f|
+          return f.read
+        }
+      else
+        raise Exception, "Invalid file_id!"
+      end
+    end
+
+
+    def diff_files(file_id1, file_id2)
+      return Diffy::Diff.new(get_file(file_id1),
+                             get_file(file_id2)).to_s()
+    end
+
+    def hash_file(file_name, content)
+      Digest::SHA256.hexdigest(file_name + content.to_s)
+    end
+
+    def merge(file_id1, file_id2)
+      diff_a = Diffy::Diff.new(get_file(file_id1),
+                               get_file(file_id2)).each_chunk.to_a()
+      if diff_a.all? { |d| d[0]!="-"}
+        return get_file(file_id2)
+      end
+      # if diff_a.all? { |d| d[0]!="+"}
+      #   return get_file(file_id1)
+      # end
+      return diff_a
+    end
+
+    def history(file_name)
+      hashs = []
+      for m in @logmap[file_name]
+        hashs << m[:hash]
+      end
+      return hashs
+    end
+
+    def update_log_file()
+      File.open(File.join(@cop_path, "logmap.yaml"), "w") { |f|
+        f.write(@logmap.to_yaml)
+      }
+      File.open(File.join(@cop_path, "hashmap.yaml"), "w") { |f|
+        f.write(@hashmap.to_yaml)
+      }
+    end
+
+    # def alterFile(fileObject, fileReferenceString, versionReferenceString)
+    # end
+
+    # def deleteFileVersion(fileReferenceString, versionReferenceString)
+    # end
+
+    # def viewFileHistory(fileReferenceString)
+    # end
+  end
+end

data/lib/banners.rb

@@ -0,0 +1,23 @@
+# file for large constant strings
+
+
+HELP_BANNER = <<-EOS
+Copernicium - simple DVCS
+
+Starting:
+    init - create a new repository
+    status - check repo status
+
+Commands:
+    commit <files> -m [message]
+    checkout [branch name]
+    merge [branch name]
+    clone [remote url]
+    push <remote name>
+    pull <remote name>
+
+Options:
+    -v: print version
+    -h: show help
+EOS
+

data/lib/pushpull.rb

@@ -0,0 +1,168 @@
+# Frank Tamburrino
+# CSC 253
+# PushPull Module
+# November 6, 2015
+
+
+module Copernicium
+  class PushPull
+
+    def connect(remote, user = nil, passwd = nil, &block)
+      exit_code = false
+      if(block.nil?)
+        begin
+          if(user.nil?)
+            print "Username for remote repo?: "
+            user = (STDIN.readline).strip
+          end
+          if(passwd.nil?)
+            print "Password for #{user}: "
+            passwd = (STDIN.noecho(&:gets)).strip
+            puts
+          end
+          Net::SSH.start(remote, user, :password => passwd) do |ssh|
+            result = ssh.exec!("echo Successful Connection!")
+            puts result
+            exit_code = true;
+          end
+        rescue
+          puts "Connection Unsuccessful"
+        end
+      else
+        begin
+          if(user.nil?)
+            print "Username for remote repo: "
+            user = (STDIN.readline).strip
+          end
+          if(passwd.nil?)
+            print "Password for #{user}: "
+            passwd = (STDIN.noecho(&:gets)).strip
+            puts
+          end
+          Net::SSH.start(remote, user, :password => passwd) do |ssh|
+            yield ssh
+          end
+          exit_code = true;
+        rescue
+          puts "Unable to execute command!"
+        end
+      end
+      return exit_code
+    end
+
+    def transfer(remote, local, dest, user = nil, passwd = nil)
+      exit_code = false
+      if(user.nil?)
+        print "Username for remote repo: "
+        user = (STDIN.readline).strip
+      end
+      if(passwd.nil?)
+        print "Password for #{user}: "
+        passwd = (STDIN.noecho(&:gets)).strip
+        puts
+      end
+      begin
+        Net::SCP.start(remote, user, :password => passwd) do |scp|
+          scp.upload!(local, dest)
+        end
+        exit_code = true
+      rescue
+        puts "Unable to upload file!"
+      end
+    end
+
+    def fetch(remote, dest, local, user = nil, passwd = nil)
+      exit_code = false
+      if(user.nil?)
+        print "Username for remote repo: "
+        user = (STDIN.readline).strip
+      end
+      if(passwd.nil?)
+        print "Password for #{user}: "
+        passwd = (STDIN.noecho(&:gets)).strip
+        puts
+      end
+      begin
+        Net::SCP.start(remote, user, :password => passwd) do |scp|
+          scp.download!(dest, local, :recursive => true)
+        end
+        exit_code = true
+      rescue
+        puts "Unable to fetch file(s)!"
+      end
+
+      return exit_code
+    end
+
+    def push(remote, branch, remote_dir)
+      ################ One way we can handle it ###################
+      ################ Needs Repos and Revlog Functionality! ######
+      # snap_id = (Repos::Repo.history(branch)).last
+      # snap = RevLog::RevLog.get_file(snap_id)
+      # connect(remote) do |x|
+      #   result = test.exec!("<call to Repos to diff the snapshots>")
+      # end
+      # print "Username for remote repo: "
+      # user = (STDIN.readline).strip
+      # print "Password for #{user}: "
+      # passwd = (STDIN.noecho(&:gets)).strip
+      # puts
+      # for result.each do |x|
+      #   transfer(remote, "./#{x}", remote_dir, user, passwd)
+      # end
+      # connect(remote) do |x|
+      #   test.exec!("<call to Repos to merge the files>")
+      #   test.exec!("<clean up the files>")
+      # end
+      #############################################################
+    end
+
+    def pull(remote, branch, remote_dir)
+      ################ One way we can handle it ###################
+      ################ Needs Repos and Revlog Functionality! ######
+      # snap_id = (Repos::Repo.history(branch)).last
+      # snap = RevLog::RevLog.get_file(snap_id)
+      # connect(remote) do |x|
+      #   result = test.exec!("<call to Repos to diff the snapshots>")
+      # end
+      # print "Username for remote repo: "
+      # user = (STDIN.readline).strip
+      # print "Password for #{user}: "
+      # passwd = (STDIN.noecho(&:gets)).strip
+      # puts
+      # for result.each do |x|
+      #   fetch(remote, remote_dir, "./#{x}", user, passwd)
+      #   RevLog::Revlog.merge(x, local_x)
+      #   File.delete(x)
+      # end
+      #############################################################
+    end
+
+    def clone(remote, dir, user = nil, passwd = nil)
+      exit_code = false
+      if(user.nil?)
+        print "Username for remote repo: "
+        user = (STDIN.readline).strip
+      end
+      if(passwd.nil?)
+        print "Password for #{user}: "
+        passwd = (STDIN.noecho(&:gets)).strip
+        puts
+      end
+      begin
+        fetch(remote, dir, ".", user, passwd)
+        nd = File.basename(dir)
+        ################ Needs Repos Functionality! #################
+        # Initializes the folder as a Repo
+        # Repos::Repos.make_branch(nd)
+        #############################################################
+        exit_code = true;
+      rescue
+        puts "Failed to clone the remote branch!"
+      end
+
+      return exit_code
+    end
+
+  end
+end

data/lib/repos.rb

@@ -0,0 +1,165 @@
+# repos module
+
+#require 'marshal'
+# Details from this link:
+#   https://docs.google.com/document/d/1r3-NquhyRLbCncqTOQPwsznSZ-en6G6xzLbWIAmxhys/edit#heading=h.7pyingf1unu
+
+
+# Repos Top Level Function Definitions (Logan)
+
+# make_snapshot: Creates new snapshot from current files and versions
+#   in - array of file objects. file object = array of all versions: {id, content}
+#   out - hash id of snapshot
+
+# restore_snapshot: Set current file versions to specified snapshot
+#   in - id of target snapshot
+#   out - Comm object with status
+
+# history: Returns ids for all snapshots
+#   in - branch name
+#   out - Array of snapshot ids
+
+# delete_snapshot: delete specified a snapshot
+#   in - target snapshot
+#   out -  Comm object with status
+
+# diff_snapshots: Returns diff between two different snapshots
+#   in - two ids of snapshots to perform diff on
+#   out - list of filenames and versions
+
+# make_branch: make a new branch
+#   in - branch name
+#   out - hash id of new branch
+
+# delete_branch: delete a branch
+#   in - branch name
+#   out - exit status code
+
+# Also do a get_snapshot
+
+module Copernicium
+  class Snapshot
+    def initialize(in_array)
+      @files = in_array
+      @id = ""
+      # id = hash of in array?
+    end
+
+    def set_id(in_id)
+      @id = in_id
+    end
+
+    # drop get prefix?
+    def get_id()
+      @id
+    end
+
+    def get_files()
+      @files
+    end
+    # Initialize hash at startup
+    # Possible? Or problem with self object?
+  end
+
+  class Repos
+    def initialize()
+      # Create manifest
+      # It's a list of snapshots in chronological order
+      @manifest = {"default" => []}
+      @curr_branch = "default"
+      # what to do about branch IDs?
+      # Read in project path and make manifest file?
+      # Create current
+    end
+
+    def manifest()
+      @manifest
+    end
+
+    def make_snapshot(file_array)
+      # Return hash ID of snapshot
+      new_snap = Snapshot.new(file_array)
+      # Set ID, consider breaking up that line
+      new_snap.set_id(Digest::SHA256.hexdigest(Marshal.dump(new_snap)))
+      @manifest[@curr_branch].push(new_snap)
+      # Update manifest file?
+      return new_snap.get_id()
+    end
+
+    def get_snapshot(target_id)
+      # Return snapshot (or just contents) given id
+      # Find snapshot
+      found_index = @manifest[@curr_branch].index{ |x| x.get_id() == target_id }
+      # Handle not found case
+      # Return it
+      if(found_index)
+        return @manifest[@curr_branch][found_index]
+      else
+        return found_index
+      end
+      #return ret_snap
+    end
+
+    # Not sure how I'm gonna do this one
+    def restore_snapshot(target_id)
+      # Return comm object with status
+      # Need a way to change files in workspace
+      return 1
+    end
+
+    #def history(branch_name)
+    def history()
+      # Return array of snapshot IDs
+      names_list = []
+      @manifest[@curr_branch].each {|x| names_list.push(x.get_id())}
+      return names_list
+    end
+
+    def delete_snapshot(target_id)
+      # Return comm object with status
+      # Find snapshot, delete from manifest/memory
+      @manifest[@curr_branch].delete_if { |x| x.get_id() == target_id }
+      # catch error
+      # update manifest file?
+    end
+
+    # Finds the files in snap1 that aren't in snap2, change this?
+    # Consider using diffy?
+    def diff_snapshots(id1, id2)
+      # Return list of filenames and versions
+      diff_files = []
+      # Put in error catching
+      files1 = get_snapshot(id1).get_files()
+      files2 = get_snapshot(id2).get_files()
+      # Find snapshot1 and snapshot2
+      files1.each do |x|
+        if(!files2.include?(x))
+          diff_files.push(x)
+        end
+      end
+      return diff_files
+      # Use revlog diff on each set of files? Look at Diffy
+    end
+
+    def make_branch(branch_name)
+      # Return hash ID of new branch
+      # Not sure where to store branches
+      # What goes in to the hash?
+      @manifest[branch_name] = @manifest[@curr_branch]
+      @curr_branch = branch_name
+      return 1
+    end
+
+    def delete_branch(branch_name)
+      # Exit status code
+      @manifest.delete("branch_name")
+    end
+
+    def clear()
+      # Just a placeholder for now
+    end
+
+  end
+end
+
+

data/lib/required.rb

@@ -0,0 +1,21 @@
+# gem requirements
+
+require 'yaml'
+require 'diffy'
+require 'digest'
+require 'pathname'
+require 'singleton'
+require 'socket'        # Socket needed for communicating over the network
+require 'io/console'    # Needed to hide password at console
+require 'net/ssh'       # Needed to communicate with the remote
+require 'net/scp'       # Needed for file transfer between servers
+
+# coperncicium files
+
+require_relative "ui"
+require_relative "repos"
+require_relative "RevLog"
+require_relative "banners"
+require_relative "pushpull"
+require_relative "workspace"
+

data/lib/ui.rb

@@ -0,0 +1,161 @@
+# user interface module - parse and execute commands
+# integrates all modules, central module
+
+
+VERSION = "0.0.1"
+
+module Copernicium
+  class Driver
+    # Get some info from the user when they dont specify it
+    def get(info)
+      puts "Hi, #{info} not specified. Enter #{info}:"
+      gets.chomp # read a line from user, and return it
+    end
+
+    # Print and exit with a specific code
+    def pexit(msg, sig)
+      puts msg
+      exit sig
+    end
+
+    # Executes the required action for a given user command.
+    #
+    # Parameters:
+    #   * args - an array containing the tokenized argv from the user
+    #   For instance: "cn hello world" -> ['hello', 'world']
+    #
+    # Return value:
+    #   A UIComm object containing details of the command to be
+    #   executed by the respective backend module.
+    #
+    def run(args)
+
+      # if no arguments given show help information
+      pexit HELP_BANNER, 0 if args.empty?
+
+      # get first command
+      cmd = args.shift
+
+      # if no arguments given show help information
+      pexit HELP_BANNER, 0 if cmd == '-h'
+
+      # if -v flag givem show version
+      pexit VERSION, 0 if cmd == '-v'
+
+      # Handle standard commands
+      case cmd
+      when 'init'
+        init args
+      when 'status'
+        status args
+      when 'clone'
+        clone args
+      when 'commit'
+        commit args
+      when 'checkout'
+        checkout args
+      when 'merge'
+        merge args
+      when 'push'
+        push args
+      when 'pull'
+        pull args
+      else # handle an unrecognized argument, show help and exit
+        pexit "Unrecognized command #{cmd}\n" + HELP_BANNER, 1
+      end
+    end # run
+
+    def init(args)
+      UIComm.new(command: 'init', opts: args)
+      # todo - make call to repos to create repo
+    end
+
+    def status(args)
+      UIComm.new(command: 'status', opts: args)
+      # todo - make call to workspace, get and show status
+    end
+
+    def push(args)
+      UIComm.new(command: 'push', opts: args)
+      # todo - make call to pushpull, push remote
+    end
+
+    def pull(args)
+      UIComm.new(command: 'pull', opts: args)
+      # todo - make call to pushpull, pull remote
+    end
+
+    def checkout(args)
+      if args.empty?
+        rev = get 'branch or revision'
+      else
+        rev = args.shift
+        files = args
+      end
+
+      # todo - call repos checkout the given / branch
+      # todo - also, figure out if is branch or rev id
+      # this can be done by checking if it is a branch, and if not, then just
+      # assume it is a rev id. if it isnt, then something will break :/
+
+      UIComm.new(command: 'checkout', rev: rev, files: files)
+    end
+
+    def clone(args)
+      # todo - optionally check for folder to clone into, instead of cwd
+      if args.empty?
+        repo = get 'repo url to clone'
+      else
+        repo = args.first
+      end
+
+      # todo - actually clone remote locally
+
+      UIComm.new(command: 'clone', repo: repo)
+    end
+
+    def commit(args)
+      messflag = args.find_index('-m')
+      if messflag.nil?
+        message = get 'commit message'
+      else # mash everything after -m into a single string
+        message = args[messflag + 1..-1].join ' '
+      end
+
+      # todo parse file list, in case just commiting some files
+      # todo call revlog, commit files
+      # todo call repos, update commit
+
+      UIComm.new(command: 'commit', commit_message: message)
+    end
+
+    def merge(args)
+      if args.empty?
+        puts 'I need a commit to merge.'
+        rev = get 'single commit to merge'
+      else # use given
+        rev = args.first
+      end
+
+      # todo - call repos merge command
+
+      UIComm.new(command: 'merge', rev: rev)
+    end
+  end
+
+  # Communication object that will pass commands to backend modules
+  # rev - A single revision indicator (commit #, branch name, HEAD, etc.)
+  # repo - URL/path to a remote repository
+  class UIComm
+    attr_reader :command, :arguments, :files, :rev, :commit_message, :repo
+    def initialize(command: nil, files: nil, rev: nil,
+                   commit_message: nil, repo: nil, opts: nil)
+      @commit_message = commit_message
+      @command = command
+      @files = files
+      @opts = opts
+      @repo = repo
+      @rev = rev
+    end
+  end
+end

data/lib/workspace.rb

@@ -0,0 +1,212 @@
+# This is the workspace module
+# The functions are clean, commit, checkout and status
+
+module Copernicium
+  class FileObj
+    attr_reader :path, :history_hash_ids
+    def initialize(path, ids)
+      @path = path
+      @history_hash_ids = ids
+    end
+
+    def ==(rhs)
+      if rhs.is_a? String
+        @path == rhs
+      else
+        @path == rhs.path
+      end
+    end
+  end
+
+  class Workspace
+    def writeFile(path, content)
+      f = open(path, 'w')
+      f.write(content)
+      f.close
+    end
+
+    def readFile(path)
+      f = open(path, 'r')
+      txt = f.read
+      f.close
+      txt
+    end
+
+    #private_class_method :writeFile
+    #private_class_method :readFile
+
+    def initialize(bname = 'master', rootdir = './workspace')
+      @files = []
+      @branch_name = bname
+      @revlog = Copernicium::RevLog.new('.')
+      @repos = Copernicium::Repos.new
+      @root = rootdir
+      if !File.directory?(@root)
+        Dir.mkdir(@root)
+      end
+    end
+
+    def indexOf(x)
+      index = -1
+      @files.each_with_index do |e,i|
+        if e.path == x
+          index = i
+          break
+        end
+      end
+      index
+    end
+
+    # if include all the elements in list_files
+    def include?(list_files)
+      list_files.each do |x|
+        if indexOf(x) == -1
+          return false
+        end
+      end
+      true
+    end
+
+    # if list_files is nil, then rollback the list of files from the branch
+    # or rollback to the entire branch head pointed
+    def clean(comm)
+      list_files = comm.files
+      if list_files.nil? # reset first: delete them from disk and reset @files
+        @files.each{|x| File.delete(x.path)}
+        @files = []
+        # restore it with checkout() if we have had a branch name
+        if @branch_name != ''
+          # or it is the initial state, no commit and no checkout
+          return checkout(@branch_name)
+        else
+          return 0
+        end
+
+      else #list_files are not nil
+        # check that every file need to be reset should have been recognized by the workspace
+        #workspace_files_paths = @files.each{|x| x.path}
+        return -1 if (self.include? list_files) == false
+
+        # the actual action, delete all of them from the workspace first
+        list_files.each do |x|
+          File.delete(x)
+          idx = indexOf(x)
+          if !idx==-1
+            @files.delete_at(idx)
+          end
+        end
+
+        # if we have had a branch, first we get the latest snapshot of it
+        # and then checkout with the restored version of them
+        if @branch_name != ''
+          return checkout(list_files)
+        else
+          return 0
+        end
+      end
+    end
+
+    # commit a list of files or the entire workspace to make a new snapshot
+    def commit(comm)
+      # for this commented version, we first get all files in the workspace and then add files from comm obj
+      # it's not used at this time
+      # Linfeng Song
+      #list_files = @files.each{|x| x.path}
+      #if comm.files != nil
+      #  comm.files.each do |x|
+      #    if indexOf(x) == -1
+      #      list_files.push(x)
+      #    end
+      #  end
+      #end
+      list_files = Dir[ File.join(@root, '**', '*') ].reject { |p| File.directory? p }
+      if list_files != nil
+        list_files.each do |x|
+          if indexOf(x) == -1
+            content = readFile(x)
+            hash = @revlog.add_file(x, content)
+            fobj = FileObj.new(x, [hash,])
+            @files.push(fobj)
+          else
+            content = readFile(x)
+            hash = @revlog.add_file(x, content)
+            if @files[indexOf(x)].history_hash_ids[-1] != hash
+              @files[indexOf(x)].history_hash_ids << hash
+            end
+          end
+        end
+      end
+      return @repos.make_snapshot(@files)
+    end
+
+    def checkout(comm)
+      argu = comm.files
+      # if argu is an Array Object, we assume it is a list of files to be added to the workspace
+      if argu != nil
+        # we add the list of files to @files regardless whether it has been in it.
+        # that means there may be multiple versions of a file.
+        list_files = argu
+        snapshot_id = @repos.history()[-1]
+        returned_snapshot = @repos.get_snapshot(snapshot_id)
+        list_files_last_commit = returned_snapshot.get_files()
+        list_files_last_commit.each do |x|
+          if list_files.include? x.path
+            path = x.path
+            content = @revlog.get_file(x.history_hash_ids[-1])
+            idx = indexOf(x.path)
+            if  idx == -1
+              @files.push(x)
+            else
+              @files[idx] = x
+            end
+            writeFile(path,content)
+          end
+        end
+        # if argu is not an Array, we assume it is a String, representing the branch name
+        # we first get the last snapshot id of the branch, and then get the commit object
+        # and finally push all files of it to the workspace
+      else
+        argu = comm.rev #branch name
+        snapshot_id = @repos.history()[-1]
+        snapshot_obj = @repos.get_snapshot(snapshot_id).get_files()
+        snapshot_obj.each do |fff|
+          idx = indexOf(fff.path)
+          if  idx == -1
+            @files.push(fff)
+          else
+            @files[idx] = fff
+          end
+          path = fff.path
+          content = @revlog.get_file(fff.history_hash_ids[-1])
+          writeFile(path,content)
+        end
+      end
+    end
+
+    def status(comm)
+      adds = []
+      deletes = []
+      edits = []
+      wsFiles = Dir[ File.join(@root, '**', '*') ].reject { |p| File.directory? p }
+      wsFiles.each do |f|
+        idx = indexOf(f)
+        if idx != -1
+          x1 = @revlog.get_file(@files[idx].history_hash_ids[-1])
+          x2 = readFile(f)
+          if x1 != x2
+            edits.push(f)
+          end
+        else
+          adds.push(f)
+        end
+      end
+      @files.each do |f|
+        if ! (wsFiles.include? f.path)
+          deletes.push(f.path)
+        end
+      end
+      return [adds, edits, deletes]
+    end
+  end
+end
+

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: copernicium
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Team Copernicium
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.7
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.8.1
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+description: A simple distributed version control system written in Ruby.
+email: jeremywrnr@gmail.com
+executables:
+- cn
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/cn
+- lib/RevLog.rb
+- lib/banners.rb
+- lib/pushpull.rb
+- lib/repos.rb
+- lib/required.rb
+- lib/ui.rb
+- lib/workspace.rb
+homepage: http://github.com/jeremywrnr/copernicium
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Simple DVCS in Ruby.
+test_files: []