raykit 0.0.304 → 0.0.305

data/lib/raykit/git/directory.rb

@@ -1,150 +1,145 @@
+# frozen_string_literal: true
+
 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
-            @repository
-
-            def initialize(directory)
-                @directory=directory
-            end
-
-            def outstanding_commit?
-                Dir.chdir(directory) do
-                    if(user_can_commit)
-                        return !`git status`.include?('nothing to commit,')
-                    else
-                        return false
-                    end
-                end
-            end
-
-            def detached?
-                Dir.chdir(directory) do
-                    status=`git status`.strip
-                    if status.include?('detached')
-                        true
-                    else
-                        false
-                    end
-                end
-            end
-
-            def pull
-                Dir.chdir(directory) do
-                    diff=`git diff`.strip
-                    status=`git status`.strip
-                    if(diff.length == 0 && status.include?('nothing to commit'))
-                        PROJECT.run('git pull',false)
-                    end
-                end
-            end
-
-            def rake(task)
-
-                if(!Dir.exist?(@directory))
-                    puts 'directory not found.'
-                    return 1
-                end
-                debug=false
-                sub_dir='work'
-                sub_dir='make' if(@directory.include?('/make/'))
-                rake_log=repository.get_dev_dir('log') + "/#{sub_dir}.rake.#{task}.json"
-
-                puts "log filename #{rake_log}" if(debug)
-                if(File.exist?(rake_log))
-                    if(File.mtime(rake_log) > last_modified_time)
-                        puts "using logged data" if(debug)
-                        cmd=Raykit::Command::parse(File.read(rake_log))
-                        cmd.summary
-                        return
-                    end
-                end
-
-                Dir.chdir(@directory) do
-                    if(File.exist?('rakefile.rb'))
-                        cmd = Raykit::Command.new("rake #{task}")
-                        cmd.summary
-                        FileUtils.mkdir_p(File.dirname(rake_log))
-                        File.open(rake_log, 'w') {|f| f.write(JSON.generate(cmd.to_hash)) }
-                    else
-                        puts 'rakefile.rb not found'
-                    end
-                end
-            end
-
-            def last_modified_time
-                Dir.chdir(@directory) do
-                    File.mtime(Dir.glob("**/*.*").select{|f| File.file?(f)}.max_by {|f| File.mtime(f)})
-                end
-            end
-
-            # The latest tag for a branch of the repository
-            def latest_tag(branch)
-                Dir.chdir(directory) do
-                    return `git describe --abbrev=0`.strip
-                end
-                ''
-            end
-
-            def get_tag_commit_id(name)
-                cmd = Raykit::Command.new("git rev-parse \"#{name}\"",0,nil,false)
-                if !cmd.output.include?('fatal') && !cmd.error.include?('fatal')
-                    cmd.output.strip()
-                else
-                    ''
-                end
-            end
-
-            def get_sha(filename)
-                if File.exists?(filename)
-                    Digest::SHA256.file(filename).hexdigest.to_s
-                else
-                    "#{filename} not found"
-                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 repository
-                if(@repository.nil?)
-                    @repository = Raykit::Git::Repository.new(remote)
-                end
-                @repository
-            end
-
-            def remote
-                if(Dir.exist?(directory))
-                    Dir.chdir(directory) do
-                        if(Dir.exist?('.git'))
-                            return Command.new('git config --get remote.origin.url').output.strip 
-                        end
-                    end
-                end
-                ""
-            end
+  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
+
+      @repository
+
+      def initialize(directory)
+        @directory = directory
+      end
+
+      def outstanding_commit?
+        Dir.chdir(directory) do
+          if user_can_commit
+            return !`git status`.include?("nothing to commit,")
+          else
+            return false
+          end
+        end
+      end
+
+      def detached?
+        Dir.chdir(directory) do
+          status = `git status`.strip
+          if status.include?("detached")
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def pull
+        Dir.chdir(directory) do
+          diff = `git diff`.strip
+          status = `git status`.strip
+          PROJECT.run("git pull", false) if diff.length.zero? && status.include?("nothing to commit")
+        end
+      end
+
+      def rake(task)
+        unless Dir.exist?(@directory)
+          puts "directory not found."
+          return 1
+        end
+        debug = false
+        sub_dir = "work"
+        sub_dir = "make" if @directory.include?("/make/")
+        rake_log = repository.get_dev_dir("log") + "/#{sub_dir}.rake.#{task}.json"
+
+        puts "log filename #{rake_log}" if debug
+        if File.exist?(rake_log) && (File.mtime(rake_log) > last_modified_time)
+          puts "using logged data" if debug
+          cmd = Raykit::Command.parse(File.read(rake_log))
+          cmd.summary
+          return
+        end
+
+        Dir.chdir(@directory) do
+          if File.exist?("rakefile.rb")
+            cmd = Raykit::Command.new("rake #{task}")
+            cmd.summary
+            FileUtils.mkdir_p(File.dirname(rake_log))
+            File.open(rake_log, "w") { |f| f.write(JSON.generate(cmd.to_hash)) }
+          else
+            puts "rakefile.rb not found"
+          end
+        end
+      end
+
+      def last_modified_time
+        Dir.chdir(@directory) do
+          File.mtime(Dir.glob("**/*.*").select { |f| File.file?(f) }.max_by { |f| File.mtime(f) })
+        end
+      end
+
+      # The latest tag for a branch of the repository
+      def latest_tag(_branch)
+        Dir.chdir(directory) do
+          return `git describe --abbrev=0`.strip
+        end
+        ""
+      end
+
+      def get_tag_commit_id(name)
+        cmd = Raykit::Command.new("git rev-parse \"#{name}\"", 0, nil, false)
+        if !cmd.output.include?("fatal") && !cmd.error.include?("fatal")
+          cmd.output.strip
+        else
+          ""
+        end
+      end
+
+      def get_sha(filename)
+        if File.exist?(filename)
+          Digest::SHA256.file(filename).hexdigest.to_s
+        else
+          "#{filename} not found"
+        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.zero?
+        return false if user_email.length.zero?
+
+        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.positive? && scan[0].length.positive?
+        end
+        "master"
+      end
+
+      def repository
+        @repository = Raykit::Git::Repository.new(remote) if @repository.nil?
+        @repository
+      end
+
+      def remote
+        if Dir.exist?(directory)
+          Dir.chdir(directory) do
+            return Command.new("git config --get remote.origin.url").output.strip if Dir.exist?(".git")
+          end
         end
+        ""
+      end
     end
-end
+  end
+end

data/lib/raykit/git/files.rb

@@ -1,45 +1,46 @@
+# frozen_string_literal: true
+
 module Raykit
-    module Git
-        # Functionality to manage a local clone of a git repository
-        class Files
-            @url
-            @commit_id
-            def initialize(url,commit_id)
-                @url = url
-                @commit_id = commit_id
-            end
-
-            def clean
-                if Dir.exists?(commit_path())
-                    FileUtils.rm_rf(commit_path())
-                end
-            end
-
-            def get(name)
-                puts "commit_path(): " + commit_path()
-                if !Dir.exists?(commit_path())
-                    puts 'cloning commit path...'
-                    clone = Raykit::Command.new('git clone ' + @url + ' ' + commit_path())
-                    puts clone.output
-                    puts clone.error
-                    Dir.chdir(commit_path()) do
-                        checkout = Raykit::Command.new('git checkout ' + @commit_id)
-                    end
-                end
-
-                if File.exists?(filename(name))
-                    return filename(name)
-                end
-                ''
-            end
-
-            def commit_path
-                Dir.tmpdir() + File::SEPARATOR + 'Raykit.Git.Files' + File::SEPARATOR + @url.gsub('://','.') + File::SEPARATOR + @commit_id
-            end
-
-            def filename(name)
-                commit_path() + File::SEPARATOR + name
-            end
+  module Git
+    # Functionality to manage a local clone of a git repository
+    class Files
+      @url
+      @commit_id
+
+      def initialize(url, commit_id)
+        @url = url
+        @commit_id = commit_id
+      end
+
+      def clean
+        FileUtils.rm_rf(commit_path) if Dir.exist?(commit_path)
+      end
+
+      def get(name)
+        puts "commit_path(): #{commit_path}"
+        unless Dir.exist?(commit_path)
+          puts "cloning commit path..."
+          clone = Raykit::Command.new("git clone #{@url} #{commit_path}")
+          puts clone.output
+          puts clone.error
+          Dir.chdir(commit_path) do
+            checkout = Raykit::Command.new("git checkout #{@commit_id}")
+          end
         end
+
+        return filename(name) if File.exist?(filename(name))
+
+        ""
+      end
+
+      def commit_path
+        Dir.tmpdir + File::SEPARATOR + "Raykit.Git.Files" + File::SEPARATOR + @url.gsub("://",
+                                                                                        ".") + File::SEPARATOR + @commit_id
+      end
+
+      def filename(name)
+        commit_path + File::SEPARATOR + name
+      end
     end
-end
+  end
+end

data/lib/raykit/git/repositories.rb

@@ -1,93 +1,91 @@
-require_relative('./directory.rb')
+# frozen_string_literal: true
+
+require_relative("./directory")
 
 module Raykit
-    module Git
-        # Functionality to manage a remote git repository
-        class Repositories < Array
-            attr_accessor :filename
+  module Git
+    # Functionality to manage a remote git repository
+    class Repositories < Array
+      attr_accessor :filename
 
-            def initialize(filename)
-                @filename=filename
-                open(@filename)
-            end
+      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)
-                    }
-                else
-                    #puts "filename #{filename} does not exist"
-                end
-            end
+      def open(filename)
+        if File.exist?(filename)
+          JSON.parse(File.read(filename)).each do |url|
+            insert(-1, url)
+          end
+        else
+          # puts "filename #{filename} does not exist"
+        end
+      end
 
-            def save(filename)
-                File.open(@filename,'w'){|f|
-                    #json = JSON.pretty_generate(self)
-                    f.write(JSON.pretty_generate(self))
-                    #f.write(self.to_json)
-                }
-            end
+      def save(_filename)
+        File.open(@filename, "w") do |f|
+          # json = JSON.pretty_generate(self)
+          f.write(JSON.pretty_generate(self))
+          # f.write(self.to_json)
+        end
+      end
 
-            def work_dir
-                Environment::get_dev_dir('work')
-            end
+      def work_dir
+        Environment.get_dev_dir("work")
+      end
 
-            def is_remote_url pattern
-                return true if(pattern.include?('http://'))
-                return true if(pattern.include?('https://'))
-                false
-            end
+      def is_remote_url(pattern)
+        return true if pattern.include?("http://")
+        return true if pattern.include?("https://")
 
-            def remove url
-                if(include?(url))
-                    self.delete(url)
-                    save(@filename)
-                end
-            end
+        false
+      end
 
-            def import(pattern)
-                imported=Array.new
-                if(is_remote_url(pattern))
-                    remote=pattern
-                    if(!include?(remote))
-                        insert(-1,remote)
-                        imported.insert(-1,remote)
-                    end
-                else
-                    git_dirs = Array.new
-                    Dir.chdir(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
+      def remove(url)
+        if include?(url)
+          delete(url)
+          save(@filename)
+        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)
-                            imported.insert(-1,remote)
-                        end
-                    }
-                end
-                save(@filename)
-                imported
+      def import(pattern)
+        imported = []
+        if is_remote_url(pattern)
+          remote = pattern
+          unless include?(remote)
+            insert(-1, remote)
+            imported.insert(-1, remote)
+          end
+        else
+          git_dirs = []
+          Dir.chdir(work_dir) do
+            Dir.glob("**/.git") do |git_dir|
+              dir = File.expand_path("..", git_dir)
+              git_dirs.insert(0, dir) if dir.length.positive?
             end
+          end
 
-            def matches(pattern)
-                matches = Array.new
-                REPOSITORIES.each{|url|
-                    if(url.include?(pattern))
-                        matches << url
-                    end
-                }
-                matches
+          git_dirs.each do |git_dir|
+            dir = Raykit::Git::Directory.new(git_dir)
+            remote = dir.remote
+            if remote.include?(pattern) && !include?(remote)
+              insert(-1, remote)
+              imported.insert(-1, remote)
             end
+          end
+        end
+        save(@filename)
+        imported
+      end
+
+      def matches(pattern)
+        matches = []
+        REPOSITORIES.each do |url|
+          matches << url if url.include?(pattern)
         end
+        matches
+      end
     end
+  end
 end
-