raykit 0.0.471 → 0.0.472

data/lib/raykit/git/directory.rb

@@ -1,186 +1,216 @@
-# 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
-          return false if !File.exist?(".git")
-          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
-
-      # git ls-tree -r master --name-only
-      def src_files
-        files = Array.new
-        Dir.chdir(@directory) do
-          `git ls-tree -r #{branch} --name-only`.each_line { |line|
-            file = line.strip
-            files << file if file.length > 0
-          }
-        end
-        files
-      end
-
-      def last_modified_src_time
-        Dir.chdir(@directory) do
-          File.mtime(src_files.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}\"").run
-        if !cmd.output.include?("fatal") && !cmd.error.include?("fatal")
-          cmd.output.strip
-        else
-          ""
-        end
-      end
-
-      def has_tag(name)
-        cmd = Raykit::Command.new("git rev-parse \"#{name}\"").run
-        if !cmd.output.include?("fatal") && !cmd.error.include?("fatal")
-          true
-        else
-          false
-        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").run.output.strip if Dir.exist?(".git")
-          end
-        end
-        ""
-      end
-
-      def tag_version(version)
-        if has_tag "v#{version}"
-          puts "  git tag v#{version} already exists"
-        else
-          if outstanding_commit?
-            raise "outstanding commit, will not tag"
-          else
-            puts "  git tag v#{version} does not exist"
-            run("git tag -a v#{version} -m\"version #{version}\"")
-          end
-        end
-      end
-    end
-  end
-end
+# 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
+          return false if !File.exist?(".git")
+          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
+
+      # git ls-tree -r master --name-only
+      def src_files
+        files = Array.new
+        Dir.chdir(@directory) do
+          `git ls-tree -r #{branch} --name-only`.each_line { |line|
+            file = line.strip
+            files << file if file.length > 0
+          }
+        end
+        files
+      end
+
+      def last_modified_src_time
+        Dir.chdir(@directory) do
+          File.mtime(src_files.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}\"").run
+        if !cmd.output.include?("fatal") && !cmd.error.include?("fatal")
+          cmd.output.strip
+        else
+          ""
+        end
+      end
+
+      def has_tag(name)
+        cmd = Raykit::Command.new("git rev-parse \"#{name}\"").run
+        if !cmd.output.include?("fatal") && !cmd.error.include?("fatal")
+          true
+        else
+          false
+        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").run.output.strip if Dir.exist?(".git")
+          end
+        end
+        ""
+      end
+
+      def tag_version(version)
+        if has_tag "v#{version}"
+          puts "  git tag v#{version} already exists"
+        else
+          if outstanding_commit?
+            raise "outstanding commit, will not tag"
+          else
+            puts "  git tag v#{version} does not exist"
+            run("git tag -a v#{version} -m\"version #{version}\"")
+          end
+        end
+      end
+
+      def get_unique_ruby_constants
+        # Define the regular expression pattern
+        pattern = /\b([A-Z][A-Z0-9_]*)\b\s*=/
+
+        constants = []
+
+        # Loop through each .rb file in the specified directory
+        Dir.glob("#{directory}/**/*.rb").each do |file|
+          # Read the contents of the file
+          content = File.read(file)
+
+          # Scan the content for constants and add the matches to the array.
+          content.scan(pattern) do |match|
+            # Add matched constant name to the constants array.
+            constants << match[0]
+          end
+          # Scan the content for constants and add the matches to the array
+          #constants.concat(content.scan(pattern))
+        end
+
+        # Return unique constants
+        constants.uniq
+      end
+    end
+
+    def setup
+      DEFAULT_SUBDIRECTORIES.each do |subdirectory|
+        FileUtils.mkdir_p(subdirectory)
+      end
+    end
+  end
+end

data/lib/raykit/git/files.rb

@@ -1,46 +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
-        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
+# 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
+        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

data/lib/raykit/git/repositories.rb

@@ -1,89 +1,89 @@
-# frozen_string_literal: true
-
-require_relative("./directory")
-
-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 do |url|
-            insert(-1, url)
-          end
-        else
-          # puts "filename #{filename} does not exist"
-        end
-      end
-
-      def save(_filename)
-        File.open(@filename, "w") do |f|
-          f.write(JSON.pretty_generate(self))
-        end
-      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 remove(url)
-        if include?(url)
-          delete(url)
-          save(@filename)
-        end
-      end
-
-      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
-
-          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
+# frozen_string_literal: true
+
+require_relative("./directory")
+
+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 do |url|
+            insert(-1, url)
+          end
+        else
+          # puts "filename #{filename} does not exist"
+        end
+      end
+
+      def save(_filename)
+        File.open(@filename, "w") do |f|
+          f.write(JSON.pretty_generate(self))
+        end
+      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 remove(url)
+        if include?(url)
+          delete(url)
+          save(@filename)
+        end
+      end
+
+      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
+
+          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