makit 0.0.75 → 0.0.76

data/lib/makit/humanize.rb

@@ -1,129 +1,129 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-module Makit
-  class Humanize
-    def self.get_humanized_size(bytes, precision = 2)
-      units = ["B", "KB", "MB", "GB", "TB", "PB"]
-      return "0 B" if bytes == 0
-
-      exp = (Math.log(bytes) / Math.log(1024)).to_i
-      exp = units.size - 1 if exp >= units.size
-
-      size = bytes.to_f / (1024 ** exp)
-      format("%.#{precision}f %s", size, units[exp])
-    end
-
-    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
-
-    def self.get_make_result_summary(make_result)
-      summary = "Make Result\n"
-      summary += "  Repository: #{make_result.repository}\n"
-      summary += "  Commit: #{make_result.commit}\n"
-      summary += "  Branch: #{make_result.branch}\n"
-      summary += "  Tag: #{make_result.tag}\n"
-      summary += "  Device: #{make_result.device}\n"
-      summary += "  Runtime Identifier: #{make_result.runtime_identifier}\n"
-      summary += "  Initial Size: #{get_humanized_size(make_result.initial_size)}\n"
-      summary += "  Final Size: #{get_humanized_size(make_result.final_size)}\n"
-      summary += "  Delta Size: #{get_humanized_size(make_result.final_size - make_result.initial_size)}\n"
-      summary += "  Commands: (#{make_result.commands.length})\n"
-      make_result.commands.each do |command|
-        details = get_command_details(command)
-        summary += "\n"
-        summary += indent_string(details, 4)
-        summary += "\n"
-      end
-
-      summary
-    end
-
-    def self.get_commands(commands)
-      message = ""
-      commands.each do |command|
-        message += Makit::Humanize::get_command_details(command)
-      end
-      message
-    end
-
-    def self.get_command_summary(command)
-      symbol = Makit::Symbols.warning
-      symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
-      symbol = Makit::Symbols.error if command.exit_code != 0
-      "#{symbol} #{command.name} #{command.arguments.join(" ")}"
-    end
-
-    def self.get_command_details(command)
-      summary = "#{get_command_summary(command)}\n"
-      summary += "  Name: #{command.name}\n"
-      summary += "  Arguments: #{command.arguments.join(" ")}\n"
-      summary += "  Directory: #{command.directory}\n"
-      summary += "  Exit Code: #{command.exit_code}\n"
-      if command.output.length > 0
-        summary += "  Output:\n"
-        summary += indent_string(command.output, 4)
-        summary += "\n"
-      end
-      if command.error.length > 0
-        summary += "  Error:\n"
-        summary += indent_string(command.error, 4)
-        summary += "\n"
-      end
-      summary
-    end
-
-    def self.indent_string(string, spaces)
-      string.split("\n").map { |line| " " * spaces + line }.join("\n")
-    end
-
-    def self.get_protobuf_timestamp(timestamp)
-      Time.at(timestamp.seconds, timestamp.nanos / 1000.0).strftime("%Y-%m-%d %H:%M:%S")
-    end
-
-    def self.get_protobuf_duration(duration)
-      total_seconds = duration.seconds + (duration.nanos / 1_000_000_000.0)
-      hours = (total_seconds / 3600).to_i
-      minutes = ((total_seconds % 3600) / 60).to_i
-      seconds = (total_seconds % 60).round(2)
-      "#{hours}h #{minutes}m #{seconds}s"
-    end
-
-    def self.get_humanized_duration(seconds_value)
-      minutes = (seconds_value / 60).to_i
-      seconds = (seconds_value % 60).to_i
-      hours = (minutes / 60).to_i
-      minutes = minutes % 60
-      days = (hours / 24).to_i
-      hours = 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"
-        else
-          parts << "#{minutes} minutes"
-        end
-      end
-      if (seconds > 0)
-        if (seconds == 1)
-          parts << "1 second"
-        else
-          parts << "#{seconds} seconds"
-        end
-      end
-      #parts << "#{seconds} seconds" if seconds > 0
-      parts << "#{milliseconds} milliseconds" if milliseconds > 0 && seconds < 1
-
-      if (parts.length == 0)
-        parts << "0 seconds"
-      end
-      parts.join(", ")
-    end
-  end
-end
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  class Humanize
+    def self.get_humanized_size(bytes, precision = 2)
+      units = ["B", "KB", "MB", "GB", "TB", "PB"]
+      return "0 B" if bytes == 0
+
+      exp = (Math.log(bytes) / Math.log(1024)).to_i
+      exp = units.size - 1 if exp >= units.size
+
+      size = bytes.to_f / (1024 ** exp)
+      format("%.#{precision}f %s", size, units[exp])
+    end
+
+    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
+
+    def self.get_make_result_summary(make_result)
+      summary = "Make Result\n"
+      summary += "  Repository: #{make_result.repository}\n"
+      summary += "  Commit: #{make_result.commit}\n"
+      summary += "  Branch: #{make_result.branch}\n"
+      summary += "  Tag: #{make_result.tag}\n"
+      summary += "  Device: #{make_result.device}\n"
+      summary += "  Runtime Identifier: #{make_result.runtime_identifier}\n"
+      summary += "  Initial Size: #{get_humanized_size(make_result.initial_size)}\n"
+      summary += "  Final Size: #{get_humanized_size(make_result.final_size)}\n"
+      summary += "  Delta Size: #{get_humanized_size(make_result.final_size - make_result.initial_size)}\n"
+      summary += "  Commands: (#{make_result.commands.length})\n"
+      make_result.commands.each do |command|
+        details = get_command_details(command)
+        summary += "\n"
+        summary += indent_string(details, 4)
+        summary += "\n"
+      end
+
+      summary
+    end
+
+    def self.get_commands(commands)
+      message = ""
+      commands.each do |command|
+        message += Makit::Humanize::get_command_details(command)
+      end
+      message
+    end
+
+    def self.get_command_summary(command)
+      symbol = Makit::Symbols.warning
+      symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
+      symbol = Makit::Symbols.error if command.exit_code != 0
+      "#{symbol} #{command.name} #{command.arguments.join(" ")}"
+    end
+
+    def self.get_command_details(command)
+      summary = "#{get_command_summary(command)}\n"
+      summary += "  Name: #{command.name}\n"
+      summary += "  Arguments: #{command.arguments.join(" ")}\n"
+      summary += "  Directory: #{command.directory}\n"
+      summary += "  Exit Code: #{command.exit_code}\n"
+      if command.output.length > 0
+        summary += "  Output:\n"
+        summary += indent_string(command.output, 4)
+        summary += "\n"
+      end
+      if command.error.length > 0
+        summary += "  Error:\n"
+        summary += indent_string(command.error, 4)
+        summary += "\n"
+      end
+      summary
+    end
+
+    def self.indent_string(string, spaces)
+      string.split("\n").map { |line| " " * spaces + line }.join("\n")
+    end
+
+    def self.get_protobuf_timestamp(timestamp)
+      Time.at(timestamp.seconds, timestamp.nanos / 1000.0).strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def self.get_protobuf_duration(duration)
+      total_seconds = duration.seconds + (duration.nanos / 1_000_000_000.0)
+      hours = (total_seconds / 3600).to_i
+      minutes = ((total_seconds % 3600) / 60).to_i
+      seconds = (total_seconds % 60).round(2)
+      "#{hours}h #{minutes}m #{seconds}s"
+    end
+
+    def self.get_humanized_duration(seconds_value)
+      minutes = (seconds_value / 60).to_i
+      seconds = (seconds_value % 60).to_i
+      hours = (minutes / 60).to_i
+      minutes = minutes % 60
+      days = (hours / 24).to_i
+      hours = 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"
+        else
+          parts << "#{minutes} minutes"
+        end
+      end
+      if (seconds > 0)
+        if (seconds == 1)
+          parts << "1 second"
+        else
+          parts << "#{seconds} seconds"
+        end
+      end
+      #parts << "#{seconds} seconds" if seconds > 0
+      parts << "#{milliseconds} milliseconds" if milliseconds > 0 && seconds < 1
+
+      if (parts.length == 0)
+        parts << "0 seconds"
+      end
+      parts.join(", ")
+    end
+  end
+end

data/lib/makit/indexer.rb

@@ -1,56 +1,56 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-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
-
-    def initialize
-      @keywords_index = Hash.new
-      @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|
-        value = value.to_s.downcase
-        if (value.length >= 3 && !keywords.include?(value))
-          keywords << value
-        end
-      end
-      keywords.each do |keyword|
-        if !@keywords_index.key?(keyword)
-          @keywords_index[keyword] = []
-        end
-        @keywords_index[keyword] << key unless @keywords_index[keyword].include?(key)
-      end
-    end
-
-    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
-      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
-    end
-  end # class Indexer
-end # module Makit
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+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
+
+    def initialize
+      @keywords_index = Hash.new
+      @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|
+        value = value.to_s.downcase
+        if (value.length >= 3 && !keywords.include?(value))
+          keywords << value
+        end
+      end
+      keywords.each do |keyword|
+        if !@keywords_index.key?(keyword)
+          @keywords_index[keyword] = []
+        end
+        @keywords_index[keyword] << key unless @keywords_index[keyword].include?(key)
+      end
+    end
+
+    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
+      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
+    end
+  end # class Indexer
+end # module Makit

data/lib/makit/logging.rb

@@ -1,106 +1,106 @@
-# frozen_string_literal: true
-
-require "logger"
-require "colorize"
-require_relative "symbols"
-
-# This module provides classes for the Makit gem.
-module Makit
-  module Logging
-    ANSI_COLOR_REGEX = /\e\[[0-9;]*m/
-
-    def self.log_rake_duration
-      # use the STARTTIME constant to log the duration of the rake task
-      # to the log/rake.duration.txt file
-      duration = Time.now - STARTTIME
-      FileUtils.mkdir_p("log") unless Dir.exist?("log")
-      File.open("log/rake.duration.txt", "a") do |file|
-        file.puts "Rake task duration: #{duration} seconds"
-      end
-    end
-
-    class PlainFormatter < Logger::Formatter
-      def call(_severity, _time, _progname, msg)
-        stripped_msg = msg.gsub(ANSI_COLOR_REGEX, "") # Remove ANSI color codes
-        "#{stripped_msg}\n"
-      end
-    end
-
-    class ColorFormatter < Logger::Formatter
-      def call(_severity, _time, _progname, msg)
-        "#{msg}\n"
-      end
-    end
-
-    # This class provide methods for working with Directories/
-    #
-    # Example:
-    #
-    #   Makit::Directory.find_directory_with_pattern("/home/user", "*.rb")
-    #
-    class MultiLogger
-      def initialize(*targets)
-        @targets = targets
-      end
-
-      def add(severity, message = nil, progname = nil, &block)
-        @targets.each do |logger|
-          logger.add(severity, message, progname, &block)
-          logger.flush if logger.respond_to?(:flush)
-        end
-      end
-
-      def <<(message)
-        @targets.each do |logger|
-          logger << message
-          logger.flush if logger.respond_to?(:flush)
-        end
-      end
-
-      def close
-        @targets.each(&:close)
-      end
-
-      def method_missing(method, *args, &block)
-        @targets.each { |logger| logger.send(method, *args, &block) }
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        @targets.all? { |logger| logger.respond_to?(method, include_private) }
-      end
-
-      def self.create_logger
-        stdout_logger = Logger.new($stdout) # ColoredLogger.new(STDOUT)
-        stdout_logger.level = Logger::DEBUG
-        # Assign the custom formatter to the file_logger
-        stdout_logger.formatter = ColorFormatter.new
-
-        # if clean or clobber commands are used, then log ONLY to stdout
-        if ARGV.include?("clean") || ARGV.include?("clobber")
-          return stdout_logger
-        end
-        if Makit::Environment.project_root_directory.nil?
-          logger = stdout_logger
-        else
-          #log_filename = if ARGV.empty?
-          #    "#{Makit::Environment.project_root_directory}/artifacts/rake.log"
-          #  else
-          #    "#{Makit::Environment.project_root_directory}/artifacts/rake_#{ARGV.join("_").gsub(":",
-          #                                                                                       "_")}.log"
-          #  end
-          # FileUtils.remove_file(log_file) if File.exist?(log_file)
-          #FileUtils.mkdir_p(File.dirname(log_filename)) unless Dir.exist?(File.dirname(log_filename))
-          #File.open(log_filename, "w")
-          #file_logger = Logger.new(log_filename)
-          #file_logger.level = Logger::DEBUG
-          # Assign the custom formatter to the file_logger
-          #file_logger.formatter = PlainFormatter.new
-          #logger = MultiLogger.new(file_logger, stdout_logger)
-          logger = stdout_logger
-        end
-
-        logger
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "logger"
+require "colorize"
+require_relative "symbols"
+
+# This module provides classes for the Makit gem.
+module Makit
+  module Logging
+    ANSI_COLOR_REGEX = /\e\[[0-9;]*m/
+
+    def self.log_rake_duration
+      # use the STARTTIME constant to log the duration of the rake task
+      # to the log/rake.duration.txt file
+      duration = Time.now - STARTTIME
+      FileUtils.mkdir_p("log") unless Dir.exist?("log")
+      File.open("log/rake.duration.txt", "a") do |file|
+        file.puts "Rake task duration: #{duration} seconds"
+      end
+    end
+
+    class PlainFormatter < Logger::Formatter
+      def call(_severity, _time, _progname, msg)
+        stripped_msg = msg.gsub(ANSI_COLOR_REGEX, "") # Remove ANSI color codes
+        "#{stripped_msg}\n"
+      end
+    end
+
+    class ColorFormatter < Logger::Formatter
+      def call(_severity, _time, _progname, msg)
+        "#{msg}\n"
+      end
+    end
+
+    # This class provide methods for working with Directories/
+    #
+    # Example:
+    #
+    #   Makit::Directory.find_directory_with_pattern("/home/user", "*.rb")
+    #
+    class MultiLogger
+      def initialize(*targets)
+        @targets = targets
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        @targets.each do |logger|
+          logger.add(severity, message, progname, &block)
+          logger.flush if logger.respond_to?(:flush)
+        end
+      end
+
+      def <<(message)
+        @targets.each do |logger|
+          logger << message
+          logger.flush if logger.respond_to?(:flush)
+        end
+      end
+
+      def close
+        @targets.each(&:close)
+      end
+
+      def method_missing(method, *args, &block)
+        @targets.each { |logger| logger.send(method, *args, &block) }
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @targets.all? { |logger| logger.respond_to?(method, include_private) }
+      end
+
+      def self.create_logger
+        stdout_logger = Logger.new($stdout) # ColoredLogger.new(STDOUT)
+        stdout_logger.level = Logger::DEBUG
+        # Assign the custom formatter to the file_logger
+        stdout_logger.formatter = ColorFormatter.new
+
+        # if clean or clobber commands are used, then log ONLY to stdout
+        if ARGV.include?("clean") || ARGV.include?("clobber")
+          return stdout_logger
+        end
+        if Makit::Environment.project_root_directory.nil?
+          logger = stdout_logger
+        else
+          #log_filename = if ARGV.empty?
+          #    "#{Makit::Environment.project_root_directory}/artifacts/rake.log"
+          #  else
+          #    "#{Makit::Environment.project_root_directory}/artifacts/rake_#{ARGV.join("_").gsub(":",
+          #                                                                                       "_")}.log"
+          #  end
+          # FileUtils.remove_file(log_file) if File.exist?(log_file)
+          #FileUtils.mkdir_p(File.dirname(log_filename)) unless Dir.exist?(File.dirname(log_filename))
+          #File.open(log_filename, "w")
+          #file_logger = Logger.new(log_filename)
+          #file_logger.level = Logger::DEBUG
+          # Assign the custom formatter to the file_logger
+          #file_logger.formatter = PlainFormatter.new
+          #logger = MultiLogger.new(file_logger, stdout_logger)
+          logger = stdout_logger
+        end
+
+        logger
+      end
+    end
+  end
+end