copernicium 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7ec43a07b4f3d15b9d556319b6d7afd72e5cc7f
-  data.tar.gz: ed07ade71e83ac560723852e8b81bfee6dc58946
+  metadata.gz: dba707602c7f877affc0641be13bd03bcf0148da
+  data.tar.gz: 62c8ea960286bcf26035bc94fe437756efa88fdd
 SHA512:
-  metadata.gz: a7f2f92fbb43d8d08babd1d201396ca896f7e4e9418d8ea3c6fd1ae2dc4e0df6a2b52c9899ac57e58d1bc3578ceaa6b1794d3efbb1a08bafd4d278fef50e2062
-  data.tar.gz: 563d55b11341b39786aeea08cf535677476c7bc96ba6d08ea8c4c2577a5c499baa1c52a2655eb41eba4b31f85f2e565bfbb9f7afe609b8cc5a440e8a412780b8
+  metadata.gz: 6c07b40b065382971669a01444f0204e1ddef79ada08fb599b56b6b04d1ef9c6433a392be840823d7ba2ed86e5d66669564d5b5dedad4ef4591e5739deb91575
+  data.tar.gz: e27a5d5060d7a074e031b44034a6ad735ee8a74c692f5a951d88d38eb5539fd3881fc8c9b6b9a5caf838e7bfb9949657e95c127c277e2423de9c4ce09e76e194

data/bin/cn

@@ -4,7 +4,8 @@
 
 require_relative "../lib/required.rb"
 
-include Copernicium
+include Copernicium::Driver
 
-Copernicium::Driver.new.run(ARGV)
+Copernicium::Driver.setup
+Copernicium::Driver.run(ARGV)
 

data/lib/RevLog.rb

@@ -25,47 +25,47 @@
 # out - success and merged file name/content, or failure and conflict
 
 module Copernicium
-  class RevLog
-    def initialize(root)
-      @root = root
-      @cop_path = File.join(root, '.cn')
-      @log_path = File.join(@cop_path, 'logmap.yaml')
-      @hash_path = File.join(@cop_path, 'hashmap.yaml')
-      if File.exist?(@log_path) && File.exist?(@hash_path)
-        @logmap = hash_array.merge(YAML.load_file(@log_path))
-        @hashmap = hash_array.merge(YAML.load_file(@hash_path))
+  module RevLog
+    def RevLog.setup(root = Dir.pwd)
+      @@root = root
+      @@cop_path = File.join(@@root, '.cn')
+      @@rev_path = File.join(@@cop_path, 'revs')
+      @@log_path = File.join(@@cop_path, 'logmap.yaml')
+      @@hash_path = File.join(@@cop_path, 'hashmap.yaml')
+      Dir.mkdir(@@cop_path) unless Dir.exist?(@@cop_path)
+      Dir.mkdir(@@rev_path) unless Dir.exist?(@@rev_path)
+      if File.exist?(@@log_path) && File.exist?(@@hash_path)
+        @@logmap = hash_array.merge(YAML.load_file(@@log_path))
+        @@hashmap = hash_array.merge(YAML.load_file(@@hash_path))
       else
-        @logmap = hash_array
-        @hashmap = hash_array
-        Dir.mkdir(@cop_path) unless File.exist?(@cop_path)
+        @@logmap = hash_array
+        @@hashmap = hash_array
       end
     end
 
-  def hash_array
-    Hash.new {[]}
-  end
+    def hash_array
+      Hash.new {[]}
+    end
 
-    def add_file(file_name, content)
+    def RevLog.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
+      File.open(File.join(@@rev_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}
+      updatelog
       return hash
     end
 
     ## return 1 if succeed, otherwise 0
-    def delete_file(file_id)
+    def RevLog.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))
+        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 }
+        updatelog
+        File.delete(File.join(@@rev_path, file_id))
         return 1
       rescue Exception
         return 0
@@ -73,8 +73,8 @@ module Copernicium
     end
 
 
-    def get_file(id)
-      file_path = File.join(@cop_path, id)
+    def RevLog.get_file(id)
+      file_path = File.join(@@rev_path, id)
       if File.exist? file_path
         File.open(file_path, 'r') { |f| return f.read }
       else
@@ -83,40 +83,39 @@ module Copernicium
     end
 
 
-    def diff_files(file_id1, file_id2)
+    def RevLog.diff_files(file_id1, file_id2)
       Diffy::Diff.new(get_file(file_id1), get_file(file_id2)).to_s()
     end
 
-    def hash_file(file_name, content)
+    def RevLog.hash_file(file_name, content)
       Digest::SHA256.hexdigest(file_name + content.to_s)
     end
 
-    def merge(id1, id2)
+    def RevLog.merge(id1, id2)
       diff_a = Diffy::Diff.new(get_file(id1), get_file(id2)).each_chunk.to_a
       return get_file(id2) if diff_a.all? { |d| d[0]!='-'}
       # return get_file(id1) if diff_a.all? { |d| d[0]!='+'}
       diff_a
     end
 
-    def history(file_name)
+    def RevLog.history(file_name)
       hashs = []
-      @logmap[file_name].each { |m| hashs << m[:hash] }
+      @@logmap[file_name].each { |m| hashs << m[:hash] }
       hashs
     end
 
-    def update_log_file
-      # writeFile defined in workspace.rb
-      writeFile(File.join(@cop_path, 'logmap.yaml'), @logmap.to_yaml)
-      writeFile(File.join(@cop_path, 'hashmap.yaml'), @hashmap.to_yaml)
+    def RevLog.updatelog
+      File.open(@@log_path, 'w') { |f| f.write(@@logmap.to_yaml) }
+      File.open(@@hash_path, 'w') { |f| f.write(@@hashmap.to_yaml) }
     end
 
-    # def alterFile(fileObject, fileReferenceString, versionReferenceString)
+    # def RevLog.alterFile(fileObject, fileReferenceString, versionReferenceString)
     # end
 
-    # def deleteFileVersion(fileReferenceString, versionReferenceString)
+    # def RevLog.deleteFileVersion(fileReferenceString, versionReferenceString)
     # end
 
-    # def viewFileHistory(fileReferenceString)
+    # def RevLog.viewFileHistory(fileReferenceString)
     # end
   end
 end

data/lib/banners.rb

@@ -34,6 +34,7 @@ Commands:
     branch [opt] [branchname]
       -r | rename current branch
       -c | create a new branch
+      -d | delete a branch
     merge <branch name>
     clone <remote url>
     push [remote name]
@@ -47,3 +48,6 @@ Note: [optional] <required>
 
 EOS
 
+REPO_WARNING = <<-EOS
+You are not currently in a Copernicium repo... run `cn init` to create one!
+EOS

data/lib/pushpull.rb

@@ -2,6 +2,8 @@
 # CSC 253
 # PushPull Module
 # November 6, 2015
+require 'net/ssh'
+require 'net/scp'
 
 
 module Copernicium
@@ -26,155 +28,274 @@ module Copernicium
       end
     end
 
-    def connect(remote, user = nil, passwd = nil, &block)
+    # Function: connect()
+    #
+    # Description:
+    #   a net/ssh wrapper, if given a block will execute block on server, otherwise tests connection.
+    #
+    # remote: the remote server, formatted "my.server"
+    # user: the user to connect as
+    def connect(remote, user, &block)
       exit_code = false
       if(block.nil?)
         begin
-          if(user.nil?)
+          Net::SSH.start(remote, user) do |ssh|
+            result = ssh.exec!("echo Successful Connection!")
+            puts result
+            exit_code = true;
+          end
+        rescue
+          begin
             print "Username for remote repo?: "
             user = (STDIN.readline).strip
-          end
-          if(passwd.nil?)
+
             print "Password for #{user}: "
             passwd = (STDIN.noecho(&:gets)).strip
             puts
+
+            Net::SSH.start(remote, user, :password => passwd) do |ssh|
+              result = ssh.exec!("echo Successful Connection!")
+              puts result
+              exit_code = true;
+            end
+          rescue
+              puts "Unsuccessful Connection"
           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?)
+          Net::SSH.start(remote, user) do |ssh|
+            yield ssh
+          end
+          exit_code = true;
+        rescue
+          begin
             print "Username for remote repo: "
             user = (STDIN.readline).strip
-          end
-          if(passwd.nil?)
+
             print "Password for #{user}: "
             passwd = (STDIN.noecho(&:gets)).strip
             puts
+
+            Net::SSH.start(remote, user, :password => passwd) do |ssh|
+              yield ssh
+            end
+            exit_code = true;
+          rescue
+            puts "Unable to execute command!"
           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)
+    # Function: transfer()
+    #
+    # Description:
+    #   a net/scp wrapper to copy to server
+    #
+    # remote: the remote server and directory to pull from, formatted "my.server:/the/location/we/want"
+    # user: the user to connect as
+    def transfer(remote, user, &block)
       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)
+        Net::SCP.start(remote, user) do |scp|
+          yield scp
         end
         exit_code = true
       rescue
-        puts "Unable to upload file!"
+        begin
+          print "Username for remote repo: "
+          user = (STDIN.readline).strip
+
+          print "Password for #{user}: "
+          passwd = (STDIN.noecho(&:gets)).strip
+          puts
+
+          Net::SCP.start(remote, user, :passwd => passwd) do |scp|
+            yield scp
+          end
+          exit_code = true
+        rescue
+          puts "Unable to upload file!"
+        end
       end
     end
 
-    def fetch(remote, dest, local, user = nil, passwd = nil)
+    # Function: fetch()
+    #
+    # Description:
+    #   a net/scp wrapper to copy from server, can take a block or do a one-off copy without one
+    #
+    # remote: the remote server and directory to push to, formatted "my.server:/the/location/we/want"
+    # dest: what we want of the branch, not needed for blocked calls
+    # local: where we want to put the file, not needed for blocked calls
+    # user: the user to connect as
+    def fetch(remote, dest, local, user, &block)
       exit_code = false
-      if(user.nil?)
-        print "Username for remote repo: "
-        user = (STDIN.readline).strip
+      if(block.nil?)
+        begin
+          Net::SCP.start(remote, user, :password => passwd) do |scp|
+            scp.download!(dest, local, :recursive => true)
+          end
+          exit_code = true
+        rescue
+          begin
+            print "Username for remote repo: "
+            user = (STDIN.readline).strip
+
+            print "Password for #{user}: "
+            passwd = (STDIN.noecho(&:gets)).strip
+            puts
+
+            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
+        end
+      else
+        begin
+          Net::SCP.start(remote, user, :password => passwd) do |scp|
+            yield scp
+          end
+          exit_code = true
+        rescue
+          begin
+            print "Username for remote repo: "
+            user = (STDIN.readline).strip
+
+            print "Password for #{user}: "
+            passwd = (STDIN.noecho(&:gets)).strip
+            puts
+
+            Net::SCP.start(remote, user, :password => passwd) do |scp|
+              yield scp
+            end
+            exit_code = true
+          rescue
+            puts "Unable to fetch file(s)!"
+          end
+        end
       end
-      if(passwd.nil?)
-        print "Password for #{user}: "
-        passwd = (STDIN.noecho(&:gets)).strip
-        puts
+      return exit_code
+    end
+
+    # Function: push()
+    #
+    # Description:
+    #   pushes local changes on the current branch to a remote branch
+    #
+    # remote: the remote server and directory to push to, formatted "my.server:/the/location/we/want"
+    # branch: the branch that we are pushing to
+    # user: the user to connect as
+    def push(remote, branch, user)
+      # check contents of folder for .cn, fail if not present and remove otherwise
+      dest = remote.split(':');
+      contents = Dir.entries(Dir.pwd)
+      if(!content.include? '.cn')
+        puts 'failed to push to remote, not an initialized Copernicium repo'
+        return
+      else
+        contents = contents.delete_if{|x| (x.eql? '.cn') || (x.eql? '.') || (x.eql? '..')}
       end
-      begin
-        Net::SCP.start(remote, user, :password => passwd) do |scp|
-          scp.download!(dest, local, :recursive => true)
+
+      connect(dest[0], user) do |session|
+        session.exec!("cd #{dest[1]}")
+        result = session.exec!('ls .cn')
+        if(result.strip.eql? '')
+          puts 'remote directory not a Copernicium repo'
+          return
         end
-        exit_code = true
-      rescue
-        puts "Unable to fetch file(s)!"
+        session.exec!("cn branch .temp_push_#{user}")
+        session.exec!("find . ! -name \".cn\" -exec rm -r {} \\;")
+
+        # Move the files over to the remote branch
+        transfer(dest[0], user) do |scp|
+          contents.each do |x|
+            scp.upload!(Dir.pwd+'/'+x, dest[1], :recursive => true)
+          end
+        end
+
+        # Commit the files and merge the branches
+        session.exec!('cn add .')
+        session.exec!('cn commit -m \'Temp commit for push\'')
+        session.exec!('cn checkout #{branch}')
+        session.exec!("cn merge .temp_push_#{user}")
+        session.exec!("cn branch -r temp_push_#{user}")
       end
 
-      return exit_code
+      puts "Successfully pushed to #{remote}"
     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
+    # Function: pull()
+    #
+    # Description:
+    #   pulls remote changes to the current branch from remote branch
+    #
+    # remote: the remote server and directory to push to, formatted "my.server:/the/location/we/want"
+    # branch: the branch that we are pushing to
+    # user: the user to connect as
+    def pull(remote, branch, user)
+      # check contents of folder for .cn, fail if not present and remove otherwise
+      crbr = Repos.new.current_branch() # assumed function
+      dest = remote.split(':');
+      contents = Dir.entries(Dir.pwd)
+      if(!content.include? '.cn')
+        puts 'failed to pull from remote, not an initialized Copernicium repo'
+        return
+      else
+        contents = contents.delete_if{|x| (x.eql? '.cn') || (x.eql? '.') || (x.eql? '..')}
+      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
+      # create a new branch and clean it in prep for the incoming files
+      system "cn branch .temp_pull_#{user}"
+      contents.each do |x|
+        system "rm -r #{x}"
+      end
 
-    def clone(remote, dir, user = nil, passwd = nil)
-      exit_code = false
-      if(user.nil?)
-        print "Username for remote repo: "
-        user = (STDIN.readline).strip
+      # get the file list from the remote directory
+      connect(dest[0], user) do |session|
+        session.exec!("cd #{dest[1]}")
+        session.exec!("cn checkout #{branch}")
+        collection = session.exec!("ls | cat")
+      end
+      collection  = collection.split('\n')
+      if(!collection.include? '.cn')
+        puts 'failed to pull from remote, remote folder not an initialized Copernicium repo'
+        return
+      else
+        collection = collection.delete_if{|x| (x.eql? '.cn') || (x.eql? '.') || (x.eql? '..')}
       end
-      if(passwd.nil?)
-        print "Password for #{user}: "
-        passwd = (STDIN.noecho(&:gets)).strip
-        puts
+
+      # fetch the files from the remote directory and merge them to the branch
+      fetch(dest[0], nil, nil, user) do |scp|
+        collection.each do |x|
+          scp.download!(dest[1]+'/'+x, Dir.pwd, :recursive => true)
+        end
       end
+      system "cn add ."
+      system "cn commit -m \'Temp commit for pull\'"
+      system "cn checkout #{crbr}"
+      system "cn merge .temp_pull_#{user}"
+      system "cn branch -r .temp_pull_#{user}"
+      puts "Successfully pulled from #{remote}"
+    end
+
+    # Function: clone()
+    #
+    # Description:
+    #   Grabs a repository from a remote server
+    #
+    # remote: the remote server and directory to push to, formatted "my.server:/the/location/we/want"
+    # user: the user to connect as
+    def clone(remote, user = nil)
+      exit_code = false
+      dest = remote.split(':')
       begin
-        fetch(remote, dir, ".", user, passwd)
-        nd = File.basename(dir)
-        ################ Needs Repos Functionality! #################
-        # Initializes the folder as a Repo
-        # Repos::Repos.make_branch(nd)
-        #############################################################
+        fetch(dest[0], dest[1], Dir.pwd, user) 
         exit_code = true;
       rescue
         puts "Failed to clone the remote branch!"