makit 0.0.99 → 0.0.111

data/lib/makit/git/cli.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  class Git
+    # This class provides methods for executing git commands and operations
+    # that modify repository state.
+    class CLI
+      def self.integrate
+        return unless Repository.git_repo? && !Repository.detached
+
+        ## check for unstaged or untracked files
+        unstaged_files = `git status --porcelain`.split("\n")
+        untracked_files = `git ls-files --others --exclude-standard`.split("\n")
+        return unless unstaged_files.length.positive? || untracked_files.length.positive?
+
+        "git add .".run
+        "git commit -m \"integrate\"".run unless Repository.clean?
+      end
+
+      def self.sync
+        return unless Repository.git_repo? && !Repository.detached
+
+        "git pull".try
+        "git push origin".try
+        "git push origin --tags".try
+      end
+
+      def self.pull
+        return unless Repository.git_repo? && !Repository.detached
+
+        "git pull".try
+      end
+
+      def self.zip_source_files(zipfilename)
+        "git archive --format zip --output #{zipfilename} HEAD".run
+      end
+
+      def self.tag(version)
+        # only tag if the repo is not read only
+        if Repository.read_only?
+          puts "  cannot tag a read only repo".colorize(:red)
+          return
+        end
+        # check if a tag for the current version already exists
+        if `git tag -l v#{version}`.strip.length.positive?
+          puts "  tag v#{version} already exists".colorize(:red)
+        else
+          "git tag -a v#{version} -m \"version #{version}\"".run
+        end
+      end
+    end
+  end
+end

data/lib/makit/git/repository.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  class Git
+    # This class provides methods for querying git repository state and metadata.
+    class Repository
+      def self.git_repo?
+        Dir.exist? ".git"
+      end
+
+      def self.ci?
+        ENV["CI"] == "true"
+      end
+
+      def self.detached
+        `git status`.include?("detached")
+      end
+
+      def self.read_only?
+        !git_repo? || detached
+      end
+
+      def self.clean?
+        `git status --porcelain`.empty?
+      end
+
+      def self.unstaged_files
+        `git status --porcelain`.split("\n")
+      end
+
+      def self.untracked_files
+        `git ls-files --others --exclude-standard`.split("\n")
+      end
+
+      def self.get_file_infos
+        file_infos = []
+        file_list = `git ls-files`.split("\n")
+        # iterate over the filelist and get the file infos
+        file_list.each do |file|
+          file_infos << FileInfo.new(name: file, mtime: File.mtime(file), size: File.size(file))
+        rescue StandardError
+          next
+        end
+        file_infos.sort_by!(&:mtime).reverse!
+        file_infos
+      end
+
+      def self.get_untracked_file_infos
+        file_infos = []
+        file_list = `git ls-files --others --exclude-standard`.split("\n")
+        file_list.each do |file|
+          file_infos << FileInfo.new(name: file, mtime: File.mtime(file), size: File.size(file))
+        rescue StandardError
+          next
+        end
+        file_infos.sort_by!(&:mtime).reverse!
+        file_infos
+      end
+
+      def self.branch
+        `git branch --show-current`.strip
+      end
+
+      def self.commitsha
+        `git rev-parse HEAD`.strip
+      end
+
+      def self.commitmsg
+        `git log -1 --pretty=%B`.strip
+      end
+
+      def self.commitdate
+        `git log -1 --pretty=%cd`.strip
+      end
+
+      def self.commitauthor
+        `git log -1 --pretty=%an`.strip
+      end
+
+      def self.commitemail
+        `git log -1 --pretty=%ae`.strip
+      end
+
+      def self.get_remote_url
+        `git remote get-url origin`.strip
+      end
+    end
+  end
+end

data/lib/makit/git.rb

@@ -1,145 +1,98 @@
 # frozen_string_literal: true
 
+require_relative "git/repository"
+require_relative "git/cli"
+
 # This module provides classes for the Makit gem.
 module Makit
-  # This class provide methods for working with the system Environment.
+  # This class provides a unified interface for git operations.
+  # Methods have been organized into Repository (state/metadata) and CLI (commands) classes.
   #
   class Git
-    def self.is_git_repo
-      Dir.exist? ".git"
+    # Delegate repository state and metadata methods to Repository class
+    def self.git_repo?
+      Repository.git_repo?
     end
 
-    def self.is_ci
-      ENV["CI"] == "true"
+    def self.ci?
+      Repository.ci?
     end
 
     def self.detached
-      `git status`.include?("detached")
+      Repository.detached
     end
 
-    def self.is_read_only
-      !is_git_repo || detached
+    def self.read_only?
+      Repository.read_only?
     end
 
-    def self.is_clean
-      `git status --porcelain`.empty?
+    def self.clean?
+      Repository.clean?
     end
 
     def self.unstaged_files
-      `git status --porcelain`.split("\n")
+      Repository.unstaged_files
     end
 
     def self.untracked_files
-      `git ls-files --others --exclude-standard`.split("\n")
-    end
-
-    def self.integrate
-      if is_git_repo && !detached
-        ## check for unstaged or untracked files
-        unstaged_files = `git status --porcelain`.split("\n")
-        untracked_files = `git ls-files --others --exclude-standard`.split("\n")
-        if unstaged_files.length > 0 || untracked_files.length > 0
-          "git add .".run
-          "git commit -m \"integrate\"".run unless is_clean
-        end
-      end
-    end
-
-    def self.sync
-      if is_git_repo && !detached
-        "git pull".try
-        "git push origin".try
-        "git push origin --tags".try
-      end
-    end
-
-    def self.pull
-      if is_git_repo && !detached
-        "git pull".try
-      end
-    end
-
-    def self.zip_source_files(zipfilename)
-      "git archive --format zip --output #{zipfilename} HEAD".run
+      Repository.untracked_files
     end
 
     def self.get_file_infos
-      file_infos = []
-      file_list = `git ls-files`.split("\n")
-      # iterate over the filelist and get the file infos
-      file_list.each do |file|
-        begin
-          file_infos << FileInfo.new(name: file, mtime: File.mtime(file), size: File.size(file))
-        rescue
-          next
-        end
-      end
-      file_infos.sort_by! { |info| info.mtime }.reverse!
-      file_infos
+      Repository.get_file_infos
     end
 
     def self.get_untracked_file_infos
-      #Makit::FileInfo::get_file_infos(`git ls-files --others --exclude=standard`.split("\n")).sort_by! { |info| info.mtime }.reverse!
-      file_infos = []
-      file_list = `git ls-files --others --exclude=standard`.split("\n")
-      file_list.each do |file|
-        begin
-          file_infos << FileInfo.new(name: file, mtime: File.mtime(file), size: File.size(file))
-        rescue
-          next
-        end
-      end
-      file_infos.sort_by! { |info| info.mtime }.reverse!
-      file_infos
-      #    file_infos << FileInfo.new(name: path, mtime: File.mtime(path), size: File.size(path))
-      #  rescue
-      #    next
-      #ß  end
-      #end
-      #file_infos.sort_by! { |info| info.mtime }.reverse!
-      #file_infos
+      Repository.get_untracked_file_infos
     end
 
     def self.branch
-      `git branch --show-current`.strip
+      Repository.branch
     end
 
     def self.commitsha
-      `git rev-parse HEAD`.strip
+      Repository.commitsha
     end
 
     def self.commitmsg
-      `git log -1 --pretty=%B`.strip
+      Repository.commitmsg
     end
 
     def self.commitdate
-      `git log -1 --pretty=%cd`.strip
+      Repository.commitdate
     end
 
     def self.commitauthor
-      `git log -1 --pretty=%an`.strip
+      Repository.commitauthor
     end
 
     def self.commitemail
-      `git log -1 --pretty=%ae`.strip
+      Repository.commitemail
     end
 
     def self.get_remote_url
-      `git remote get-url origin`.strip
+      Repository.get_remote_url
+    end
+
+    # Delegate command execution methods to CLI class
+    def self.integrate
+      CLI.integrate
+    end
+
+    def self.sync
+      CLI.sync
+    end
+
+    def self.pull
+      CLI.pull
+    end
+
+    def self.zip_source_files(zipfilename)
+      CLI.zip_source_files(zipfilename)
     end
 
     def self.tag(version)
-      # only tag if the repo is not read only
-      if is_read_only
-        puts "  cannot tag a read only repo".colorize(:red)
-        return
-      end
-      # check if a tag for the current version already exists
-      if (`git tag -l v#{version}`.strip.length > 0)
-        puts "  tag v#{version} already exists".colorize(:red)
-      else
-        "git tag -a v#{version} -m \"version #{version}\"".run
-      end
+      CLI.tag(version)
     end
   end
 end

data/lib/makit/gitlab_runner.rb

@@ -12,7 +12,6 @@ module Makit
   #   Makit::Directory.find_directory_with_pattern("/home/user", "*.rb")
   #
   class GitLabRunner
-
     # Parse the .gitlab-ci.yml file
     def parse_gitlab_ci_file(file_path)
       YAML.load_file(file_path)

data/lib/makit/humanize.rb

@@ -2,10 +2,19 @@
 
 # This module provides classes for the Makit gem.
 module Makit
+  # Provides utilities for converting data into human-readable formats.
+  #
+  # This class handles formatting of file sizes, timestamps, durations,
+  # and build result summaries for display to users.
+  #
+  # @example Basic usage
+  #   Makit::Humanize.get_humanized_size(1024)  # => "1.00 KB"
+  #   Makit::Humanize.get_humanized_duration(3661)  # => "1 hour, 1 minute, 1 second"
+  #
   class Humanize
     def self.get_humanized_size(bytes, precision = 2)
-      units = ["B", "KB", "MB", "GB", "TB", "PB"]
-      return "0 B" if bytes == 0
+      units = %w[B KB MB GB TB PB]
+      return "0 B" if bytes.zero?
 
       exp = (Math.log(bytes) / Math.log(1024)).to_i
       exp = units.size - 1 if exp >= units.size
@@ -16,6 +25,7 @@ module Makit
 
     def self.get_humanized_timestamp(timestamp)
       return timestamp.strftime("%Y-%m-%d %I:%M:%S %p") if timestamp.respond_to?(:strftime)
+
       timestamp.strftime("%Y-%m-%d %H:%M:%S")
     end
 
@@ -44,7 +54,7 @@ module Makit
     def self.get_commands(commands)
       message = ""
       commands.each do |command|
-        message += Makit::Humanize::get_command_details(command)
+        message += Makit::Humanize.get_command_details(command)
       end
       message
     end
@@ -62,12 +72,12 @@ module Makit
       summary += "  Arguments: #{command.arguments.join(" ")}\n"
       summary += "  Directory: #{command.directory}\n"
       summary += "  Exit Code: #{command.exit_code}\n"
-      if command.output.length > 0
+      if command.output.length.positive?
         summary += "  Output:\n"
         summary += indent_string(command.output, 4)
         summary += "\n"
       end
-      if command.error.length > 0
+      if command.error.length.positive?
         summary += "  Error:\n"
         summary += indent_string(command.error, 4)
         summary += "\n"
@@ -76,7 +86,7 @@ module Makit
     end
 
     def self.indent_string(string, spaces)
-      string.split("\n").map { |line| " " * spaces + line }.join("\n")
+      string.split("\n").map { |line| (" " * spaces) + line }.join("\n")
     end
 
     def self.get_protobuf_timestamp(timestamp)
@@ -95,34 +105,32 @@ module Makit
       minutes = (seconds_value / 60).to_i
       seconds = (seconds_value % 60).to_i
       hours = (minutes / 60).to_i
-      minutes = minutes % 60
+      minutes %= 60
       days = (hours / 24).to_i
-      hours = hours % 24
+      hours %= 24
       milliseconds = (seconds_value % 1 * 1000).to_i
 
       parts = []
-      parts << "#{days} days" if days > 0
-      parts << "#{hours} hours" if hours > 0
-      if (minutes > 0)
-        if (minutes == 1)
-          parts << "1 minute"
+      parts << "#{days} days" if days.positive?
+      parts << "#{hours} hours" if hours.positive?
+      if minutes.positive?
+        parts << if minutes == 1
+          "1 minute"
         else
-          parts << "#{minutes} minutes"
+          "#{minutes} minutes"
         end
       end
-      if (seconds > 0)
-        if (seconds == 1)
-          parts << "1 second"
+      if seconds.positive?
+        parts << if seconds == 1
+          "1 second"
         else
-          parts << "#{seconds} seconds"
+          "#{seconds} seconds"
         end
       end
-      #parts << "#{seconds} seconds" if seconds > 0
-      parts << "#{milliseconds} milliseconds" if milliseconds > 0 && seconds < 1
+      # parts << "#{seconds} seconds" if seconds > 0
+      parts << "#{milliseconds} milliseconds" if milliseconds.positive? && seconds < 1
 
-      if (parts.length == 0)
-        parts << "0 seconds"
-      end
+      parts << "0 seconds" if parts.empty?
       parts.join(", ")
     end
   end

data/lib/makit/indexer.rb

@@ -5,28 +5,23 @@ module Makit
   # This class provide methods for indexing objects.
   #
   class Indexer
-    attr_accessor :keywords_index # Hash of string key to string[] of keyword
-    attr_accessor :protoc_json_serializer
+    attr_accessor :keywords_index, :protoc_json_serializer # Hash of string key to string[] of keyword
 
     def initialize
-      @keywords_index = Hash.new
-      @protoc_json_serializer = Makit::Serializer::new(Makit::Proto3Formats::JSON)
+      @keywords_index = {}
+      @protoc_json_serializer = Makit::Serializer.new(Makit::Proto3Formats::JSON)
     end
 
     def index(key, item)
       # item must be serializable to json
       keywords = []
       hash = JSON.parse(item.to_json)
-      hash.each do |key, value|
+      hash.each_value do |value|
         value = value.to_s.downcase
-        if (value.length >= 3 && !keywords.include?(value))
-          keywords << value
-        end
+        keywords << value if value.length >= 3 && !keywords.include?(value)
       end
       keywords.each do |keyword|
-        if !@keywords_index.key?(keyword)
-          @keywords_index[keyword] = []
-        end
+        @keywords_index[keyword] = [] unless @keywords_index.key?(keyword)
         @keywords_index[keyword] << key unless @keywords_index[keyword].include?(key)
       end
     end
@@ -34,23 +29,19 @@ module Makit
     def search(query)
       keys = []
       # todo, remove terms less that length of 3
-      terms = query.downcase.split(" ").reject { |term| term.length < 3 }
-      keywords_index.each do |key, value| #{|kvp|
-        if (get_match_count(terms, value) == terms.length)
-          keys << key
-        end
+      terms = query.downcase.split.reject { |term| term.length < 3 }
+      keywords_index.each do |key, value| # {|kvp|
+        keys << key if get_match_count(terms, value) == terms.length
       end
       keys
     end
 
     def get_match_count(terms, keywords)
       match_count = 0
-      terms.each { |term|
-        if (keywords.include?(term))
-          match_count += 1
-        end
-      }
-      return match_count
+      terms.each do |term|
+        match_count += 1 if keywords.include?(term)
+      end
+      match_count
     end
-  end # class Indexer
-end # module Makit
+  end
+end