raykit 0.0.49 → 0.0.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b317f633ca2cb66a7f82a200081804a133d96b5aa3a22a8a50857b69468954e2
-  data.tar.gz: 3af4b61349f2d5fbce324db2116c214dc83b56fd08a7bfff3f514b2898ac9ff3
+  metadata.gz: cc13a57b744ff422351ff702e896ea0674597e990d38d037e859e4229d57d4ca
+  data.tar.gz: b18b4d532221b9d9479f17e686de57005e1682dd1347348d8ea280921875971b
 SHA512:
-  metadata.gz: 311ab8cf559de63e1fc696c72d31de74b7a534b12a16ab8e6ec9d3c14acd270f224a0844a0f1751d5f0909e30f5e753922bc9f193956a3d2d03389671043cbaf
-  data.tar.gz: cf2d8fa22bf9071247693857a436a01be66204ccae06cf89a56df7c4a7f09290d1eed663b06d7530935a2444ae6d5486f33af0c809b3190dc4061bb30efa334a
+  metadata.gz: e48927331652260d8c221c933761c94e1a544f01fa6e5b8811ed530c45277abab89e368926a29dbb84a09a966191e8faf1fde62703bd4ed7c0833731ca710ff4
+  data.tar.gz: 0edb350db610b2fd54472290950f9e8f987936c260377dc5ed9abd697bfbb2fbdf40fe23c6fd73663b1350e90187f2ed9e86ed34a2e784bca2679c1fba2757c1

data/bin/raykit

@@ -1,9 +1,3 @@
 #!/usr/bin/env ruby
-
 require_relative '../lib/raykit.rb'
-#NAME='raykit'
-#VERSION=Raykit::Version.detect
-
-#puts "#{NAME} #{VERSION}"
-
 Raykit::Console::run

data/lib/raykit.rb

@@ -1,12 +1,17 @@
-require_relative './raykit/timer.rb'
-require_relative './raykit/git.rb'
-require_relative './raykit/dotnet.rb'
-require_relative './raykit/version.rb'
-require_relative './raykit/environment.rb'
-require_relative './raykit/logging.rb'
-require_relative './raykit/command.rb'
-require_relative './raykit/rake.rb'
-require_relative './raykit/console.rb'
+#require_relative './raykit/timer.rb'
+#require_relative './raykit/gitlegacy.rb'
+#require_relative './raykit/git/commit.rb'
+#require_relative './raykit/dotnet.rb'
+#require_relative './raykit/version.rb'
+#require_relative './raykit/environment.rb'
+#require_relative './raykit/logging.rb'
+#require_relative './raykit/command.rb'
+#require_relative './raykit/rake.rb'
+#require_relative './raykit/console.rb'
+lib_root = File.dirname(File.absolute_path(__FILE__))
+puts "lib_root #{lib_root}"
+Dir.glob(lib_root + '/raykit/**/*.rb') {|file| require file}
+
 require 'rainbow'
 require 'rake/clean'
 require 'open3'
@@ -14,7 +19,11 @@ require 'rake/testtask'
 
 TIMER= Raykit::Timer.new
 LOG = Raykit::Logging.new
+REPOSITORIES = Raykit::Git::Repositories.new(Raykit::Environment::get_dev_dir('log') + "/Raykit.Git.Repositories.json")
 
+if(Dir.exist?('.git'))
+    GIT_DIRECTORY=Raykit::Git::Directory.new(File.dirname(__FILE__))
+end
 
 module Raykit
     def Raykit.run(command) 

data/lib/raykit/console.rb

@@ -1,7 +1,6 @@
 require 'optparse'
 
 module Raykit
-
     # Parses the command line arguments for the Raykit console application
     class Parser
         def self.parse(options)
@@ -63,37 +62,32 @@ module Raykit
         end
 
         def self.list(hash)
-            pattern=nil
+            pattern=''
             if(hash.include?(:pattern))
-                pattern=hash[:pattern]
+                pattern=hash["pattern"]
             end
-            Raykit::Git::remote_urls.each{|url| 
-                if(pattern.nil? || url.include?(pattern))
+            pattern='' if(pattern.nil?)
+
+            REPOSITORIES.each{|url|
+                if(url.include?(pattern))
                     puts Rainbow(url).yellow.bright
                 end
             }
         end
 
         def self.import(hash)
+            pattern=''
+            pattern=hash["pattern"] if(hash.include?("pattern"))
             puts 'scanning...'
-            scanned_remotes = Raykit::Git::scan_remote_urls
-            remotes = Raykit::Git::remote_urls
-            count = 0
-            scanned_remotes.each{|remote|
-                if(!remotes.include?(remote))
-                    puts "imported " + Rainbow(remote).yellow.bright
-                    remotes.insert(0,remote)
-                    count = count + 1
-                end
-            }
-            if(count > 0)
-                puts 'updating Raykit::Git::remote_urls'
-                Raykit::Git::remote_urls = remotes
-            end
+            count=REPOSITORIES.length
+            REPOSITORIES.import(pattern)
+            new_count=REPOSITORIES.length-count
+            puts "imported #{new_count} git repositories"
         end
 
         def self.rake(hash)
-            Raykit::Git::remote_urls.each{|remote|
+            REPOSITORIES.each{|remote|
+            #Raykit::Git::remote_urls.each{|remote|
                 if(remote.include?(hash[:pattern]))
                     begin
                         puts "remote: #{remote}"

data/lib/raykit/git/commit.rb

@@ -0,0 +1,17 @@
+
+module Raykit
+    module Git
+        # Functionality to manage a git commit
+        class Commit
+            attr_accessor :url
+            attr_accessor :branch
+            attr_accessor :commit_id
+
+            def initialize(url,branch,commit_id)
+                @url=url
+                @branch=branch
+                @commit_id=commit_id
+            end
+        end
+    end
+end

data/lib/raykit/git/directory.rb

@@ -0,0 +1,53 @@
+module Raykit
+    module Git
+        # Functionality to manage a local clone of a git repository
+        class Directory
+            # The directory name of the local repository clone
+            attr_accessor :directory
+
+            def initialize(directory)
+                @directory=directory
+            end
+
+            def outstanding_commit?
+                Dir.chdir(directory) do
+                    if(user_can_commit)
+                        #puts `git status`
+                        return !`git status`.include?('nothing to commit,')
+                    else
+                        return false
+                    end
+                end
+            end
+
+            def user_name
+                `git config --get user.name`.strip
+            end
+    
+            def user_email
+                `git config --get user.email`.strip
+            end
+    
+            def user_can_commit
+                return false if(user_name.length == 0)
+                return false if(user_email.length == 0)
+                return true
+            end
+
+            def branch
+                Dir.chdir(directory) do
+                    scan=`git branch`.scan(/\*\s([\w\.-]+)/)
+                    return scan[0][0].to_s if(!scan.nil? && scan.length > 0 && scan[0].length > 0)
+                end
+                'master'
+            end
+
+            def remote
+                Dir.chdir(directory) do
+                    return Command.new('git config --get remote.origin.url').output.strip if(Dir.exist?('.git'))
+                end
+                ``
+            end
+        end
+    end
+end

data/lib/raykit/git/repositories.rb

@@ -0,0 +1,55 @@
+require_relative('./directory.rb')
+
+module Raykit
+    module Git
+        # Functionality to manage a remote git repository
+        class Repositories < Array
+            attr_accessor :filename
+
+            def initialize(filename)
+                @filename=filename
+                open(@filename)
+            end
+
+            def open(filename)
+                if(File.exist?(filename))
+                    JSON.parse(File.read(filename)).each{|url|
+                        insert(-1,url)
+                    }
+                    puts "filename #{filename} imported #{self.length} entries"
+                else
+                    puts "filename #{filename} does not exist"
+                end
+            end
+
+            def save(filename)
+                File.open(@filename,'w'){|f|
+                    f.write(self.to_json)
+                }
+            end
+
+            def import(pattern)
+                git_dirs = Array.new
+                Dir.chdir(Environment::get_dev_dir('work')) do
+                    Dir.glob('**/.git'){|git_dir|
+                        dir = File.expand_path('..',git_dir)
+                        if(dir.length > 0)
+                            git_dirs.insert(0,dir)
+                        end
+                    }
+                end
+
+                git_dirs.each{|git_dir|
+                    dir=Raykit::Git::Directory.new(git_dir)
+                    remote=dir.remote
+                    if(remote.include?(pattern) && !include?(remote))
+                        insert(-1,remote)
+                    end
+                }
+                save(@filename)
+                self
+            end
+        end
+    end
+end
+        

data/lib/raykit/git/repository.rb

@@ -0,0 +1,105 @@
+module Raykit
+    module Git
+        # Functionality to manage a remote git repository
+        class Repository
+            # The url of the remote repository
+            attr_accessor :url
+
+            def initialize(url)
+                @url=url
+            end
+
+            def to_json
+                JSON.generate({"url" => @url})
+            end
+
+            def self.parse(json)
+                hash=JSON.parse(json)
+                repo=Repository.new(hash["url"])
+                repo
+            end
+
+            # The relative path is a valid local path name derived from the url
+            def relative_path
+                @url.gsub('https://','').gsub('.git','')
+            end
+
+            def get_dev_dir(dir)
+                dev_dir=Environment::get_dev_dir(dir)
+                return "#{dev_dir}/#{relative_path}"
+            end
+
+            # Clone the repository to a specific directory
+            def clone(directory,depth=0)
+                if(depth == 0)
+                    Raykit::run("git clone #{@url} #{directory}") 
+                else
+                    Raykit::run("git clone #{@url} #{directory} --depth #{depth}")
+                end
+            end
+
+            # The branches for the git repository
+            def branches
+                results = Array.new
+                update_local_clone_directory
+                if(Dir.exist?(local_clone_directory))
+                    Dir.chdir(local_clone_directory) do
+                        `git branch`.split('\n').each{|line|
+                            branch = line.gsub('*','').strip
+                            results.insert(-1,branch) if(branch.length > 0)
+                        }
+                    end
+                end
+                results
+            end
+
+            # The latest commit id for a branch of the repostiory
+            def latest_commit(branch)
+                if(checkout_local_clone_directory_branch(branch))
+                    text=`git log -n 1`
+                    scan=text.scan(/commit ([\w]+)\s/)
+                    return scan[0][0].to_s 
+                end
+                ''
+            end
+
+            # The latest tag for a branch of the repository
+            def latest_tag(branch)
+                # git describe --abbrev=0
+                if(checkout_local_clone_directory_branch(branch))
+                    return `git describe --abbrev=0`.strip
+                end
+                ''
+            end
+
+            private def local_clone_directory
+                clone_dir="#{Environment::get_dev_dir('clone')}/#{relative_path}"
+            end
+
+            private def update_local_clone_directory
+                if(Dir.exist?(local_clone_directory))
+                    Dir.chdir(local_clone_directory) do
+                        `git pull`
+                    end
+                else
+                    Raykit::run("git clone #{@url} #{local_clone_directory}")
+                end
+            end
+
+            private def checkout_local_clone_directory_branch(branch)
+                update_local_clone_directory
+                if(Dir.exist?(local_clone_directory))
+                    Dir.chdir(local_clone_directory) do
+                        check=`git branch`
+                        if(!check.include?("* #{branch}"))
+                            `git checkout #{branch}`
+                        end
+                        check=`git branch`
+                        return check.include?("* #{branch}")
+                    end
+                end
+                false
+            end
+        end
+    end
+end

data/lib/raykit/gitlegacy.rb

@@ -0,0 +1,68 @@
+module Raykit
+    class GitLegacy
+        def self.get_remote
+            if(Dir.exist?('.git'))
+                cmd = Command.new('git config --get remote.origin.url')
+                #cmd.run
+                return cmd.output.strip
+            else
+                ``
+            end
+        end
+
+        def self.add_remote
+            remote = get_remote
+            if(remote.length > 0)
+                remote_urls_copy = remote_urls
+                if(!remote_urls_copy.include?(remote))
+                    remote_urls_copy.insert(0,remote)
+                    Git::remote_urls = remote_urls_copy
+                end
+            end
+        end
+
+        def self.remote_urls
+            filename="#{Environment::get_dev_dir('log')}/Raykit.Git.RemoteUrls.json";
+            if(File.exist?(filename))
+                JSON.parse(File.read(filename))
+            else
+                Array.new
+            end
+        end
+
+        def self.remote_urls=(urls)
+            filename="#{Environment::get_dev_dir('log')}/Raykit.Git.RemoteUrls.json"
+            File.open(filename,'w'){|f|
+                f.write(JSON.generate(urls))
+            }
+        end
+
+        def self.list_remotes
+            remote_urls.each{|url| puts url}
+        end
+
+        def self.scan_remote_urls
+            remotes = Array.new
+            git_dirs = Array.new
+            Dir.chdir(Environment::work_dir) do
+                Dir.glob('**/.git'){|git_dir|
+                    dir = File.expand_path('..',git_dir)
+                    if(dir.length > 0)
+                        git_dirs.insert(0,dir)
+                    end
+                    
+                }
+            end
+
+            git_dirs.each{|git_dir|
+                Dir.chdir(git_dir) do
+                    remote = get_remote
+                    if(remote.length > 0)
+                        remotes.insert(0,remote)
+                    end
+                end
+            }
+            remotes
+        end
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raykit
 version: !ruby/object:Gem::Version
-  version: 0.0.49
+  version: 0.0.50
 platform: ruby
 authors:
 - Lou Parslow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-22 00:00:00.000000000 Z
+date: 2019-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,7 +67,11 @@ files:
 - lib/raykit/console.rb
 - lib/raykit/dotnet.rb
 - lib/raykit/environment.rb
-- lib/raykit/git.rb
+- lib/raykit/git/commit.rb
+- lib/raykit/git/directory.rb
+- lib/raykit/git/repositories.rb
+- lib/raykit/git/repository.rb
+- lib/raykit/gitlegacy.rb
 - lib/raykit/logging.rb
 - lib/raykit/rake.rb
 - lib/raykit/timer.rb

data/lib/raykit/git.rb

@@ -1,143 +0,0 @@
-module Raykit
-    class Git
-        attr_accessor :start_time
-
-        def self.branch
-            branches = `git branch`
-            branches.match(/ ([\w.]+)/).captures[0]
-        end
-   
-        def self.last_tag
-            `git describe --abbrev=0 --tags`.strip
-        end
-
-        def self.user_name
-            return `git config --get user.name`.strip
-        end
-
-        def self.user_email
-            return `git config --get user.email`.strip
-        end
-
-        def self.user_can_commit
-            return false if(user_name.length == 0)
-            return false if(user_email.length == 0)
-            return true
-        end
-
-        def self.outstanding_commit
-            if(Git::user_can_commit)
-                return !`git status`.include?('nothing to commit,')
-            else
-                return false
-            end
-        end
-
-        # get the latest tag for the current directory
-        def self.get_latest_tag
-            `git describe --abbrev=0 --tags`.strip
-        end
-
-        def self.get_current_branch
-            text=`git branch`
-            if(text.include?('HEAD detached'))
-                return 'master'
-            end
-            #puts "get_current_branch text=#{text}"
-            scan=text.scan(/\*\s([\w\.-]+)/)
-            #puts "scan=#{scan}"
-            scan[0][0].to_s
-        end
-
-        def self.get_latest_commit(remote,branch)
-            clone_dir="#{Environment::get_dev_dir('clone')}/#{get_relative_path(remote)}"
-            if(!Dir.exist?(clone_dir))
-                parent_dir = File.expand_path('..',clone_dir)
-                if(!Dir.exist?(parent_dir))
-                    FileUtils.mkdir_p(parent_dir)
-                end 
-                Command.new("git clone #{remote} #{clone_dir}")
-            end
-            Dir.chdir(clone_dir) do
-                Command.new('git pull')
-                if(get_current_branch != branch)
-                    Command.new("git checkout #{branch}")
-                end
-                text=`git log --name-status HEAD^..HEAD`
-                #puts "get_latest_commit text: #{text}"
-                scan=text.scan(/commit ([\w]+)\s/)
-                #puts "scan: #{scan}"
-                return scan[0][0].to_s
-            end  
-        end
-
-        def self.get_relative_path(remote)
-            remote.gsub('https://','').gsub('.git','')
-        end
-
-        def self.get_remote
-            if(Dir.exist?('.git'))
-                cmd = Command.new('git config --get remote.origin.url')
-                #cmd.run
-                return cmd.output.strip
-            else
-                ``
-            end
-        end
-
-        def self.add_remote
-            remote = get_remote
-            if(remote.length > 0)
-                remote_urls_copy = remote_urls
-                if(!remote_urls_copy.include?(remote))
-                    remote_urls_copy.insert(0,remote)
-                    Git::remote_urls = remote_urls_copy
-                end
-            end
-        end
-
-        def self.remote_urls
-            filename="#{Environment::get_dev_dir('log')}/Raykit.Git.RemoteUrls.json";
-            if(File.exist?(filename))
-                JSON.parse(File.read(filename))
-            else
-                Array.new
-            end
-        end
-
-        def self.remote_urls=(urls)
-            filename="#{Environment::get_dev_dir('log')}/Raykit.Git.RemoteUrls.json"
-            File.open(filename,'w'){|f|
-                f.write(JSON.generate(urls))
-            }
-        end
-
-        def self.list_remotes
-            remote_urls.each{|url| puts url}
-        end
-
-        def self.scan_remote_urls
-            remotes = Array.new
-            git_dirs = Array.new
-            Dir.chdir(Environment::work_dir) do
-                Dir.glob('**/.git'){|git_dir|
-                    dir = File.expand_path('..',git_dir)
-                    if(dir.length > 0)
-                        git_dirs.insert(0,dir)
-                    end
-                    
-                }
-            end
-
-            git_dirs.each{|git_dir|
-                Dir.chdir(git_dir) do
-                    remote = get_remote
-                    if(remote.length > 0)
-                        remotes.insert(0,remote)
-                    end
-                end
-            }
-            remotes
-        end
-    end
-end