makit 0.0.99 → 0.0.112

data/lib/makit/humanize.rb

@@ -1,129 +1,137 @@
-# 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
+  # 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 = %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
+
+      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.positive?
+        summary += "  Output:\n"
+        summary += indent_string(command.output, 4)
+        summary += "\n"
+      end
+      if command.error.length.positive?
+        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 %= 60
+      days = (hours / 24).to_i
+      hours %= 24
+      milliseconds = (seconds_value % 1 * 1000).to_i
+
+      parts = []
+      parts << "#{days} days" if days.positive?
+      parts << "#{hours} hours" if hours.positive?
+      if minutes.positive?
+        parts << if minutes == 1
+          "1 minute"
+        else
+          "#{minutes} minutes"
+        end
+      end
+      if seconds.positive?
+        parts << if seconds == 1
+          "1 second"
+        else
+          "#{seconds} seconds"
+        end
+      end
+      # parts << "#{seconds} seconds" if seconds > 0
+      parts << "#{milliseconds} milliseconds" if milliseconds.positive? && seconds < 1
+
+      parts << "0 seconds" if parts.empty?
+      parts.join(", ")
+    end
+  end
+end

data/lib/makit/indexer.rb

@@ -1,56 +1,47 @@
-# 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, :protoc_json_serializer # Hash of string key to string[] of keyword
+
+    def initialize
+      @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_value do |value|
+        value = value.to_s.downcase
+        keywords << value if value.length >= 3 && !keywords.include?(value)
+      end
+      keywords.each do |keyword|
+        @keywords_index[keyword] = [] unless @keywords_index.key?(keyword)
+        @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|
+        keys << key if get_match_count(terms, value) == terms.length
+      end
+      keys
+    end
+
+    def get_match_count(terms, keywords)
+      match_count = 0
+      terms.each do |term|
+        match_count += 1 if keywords.include?(term)
+      end
+      match_count
+    end
+  end
+end

data/lib/makit/logging/configuration.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Makit
+  module Logging
+    # Configuration management for unified logging
+    #
+    # Provides schema validation, default configurations, and helper methods
+    # for setting up the unified file sink with various output configurations.
+    #
+    # @example Basic configuration
+    #   config = Configuration.new(
+    #     configurations: [
+    #       { file: $stdout, format: :console },
+    #       { file: "logs/app.log", format: :json }
+    #     ]
+    #   )
+    #
+    # @example YAML configuration
+    #   config = Configuration.from_yaml("config/logging.yml")
+    #
+    # @example Environment-based configuration
+    #   config = Configuration.for_environment(:production)
+    class Configuration
+      # @return [Array<Hash>] list of output configurations
+      attr_reader :configurations
+
+      # Initialize configuration
+      #
+      # @param configurations [Array<Hash>] list of output configurations
+      def initialize(configurations: [])
+        @configurations = configurations
+      end
+
+      # Create configuration from YAML file
+      #
+      # @param yaml_file [String] path to YAML configuration file
+      # @return [Configuration] new configuration instance
+      def self.from_yaml(yaml_file)
+        require "yaml"
+        data = YAML.load_file(yaml_file)
+        configurations = data["logging"]["sinks"] || []
+
+        # Convert string keys to symbols
+        configurations = configurations.map do |config|
+          config.transform_keys(&:to_sym)
+        end
+
+        new(configurations: configurations)
+      end
+
+      # Create configuration from JSON file
+      #
+      # @param json_file [String] path to JSON configuration file
+      # @return [Configuration] new configuration instance
+      def self.from_json(json_file)
+        require "json"
+        data = JSON.parse(File.read(json_file))
+        configurations = data["logging"]["sinks"] || []
+
+        # Convert string keys to symbols
+        configurations = configurations.map do |config|
+          config.transform_keys(&:to_sym)
+        end
+
+        new(configurations: configurations)
+      end
+
+      # Create environment-specific configuration
+      #
+      # @param environment [Symbol] environment name (:development, :production, :test)
+      # @return [Configuration] new configuration instance
+      def self.for_environment(environment)
+        case environment
+        when :development
+          development_config
+        when :production
+          production_config
+        when :test
+          test_config
+        when :ci
+          ci_config
+        else
+          default_config
+        end
+      end
+
+      # Get default configuration
+      #
+      # @return [Configuration] default configuration
+      def self.default_config
+        new(
+          configurations: [
+            { file: $stdout, format: :console },
+            { file: "artifacts/makit.log", format: :json, append: true },
+          ],
+        )
+      end
+
+      # Get development configuration
+      #
+      # @return [Configuration] development configuration
+      def self.development_config
+        new(
+          configurations: [
+            {
+              file: $stdout,
+              format: :console,
+              show_timestamp: true,
+              show_level: true,
+            },
+            {
+              file: "logs/development.log",
+              format: :text,
+              append: true,
+              include_context: true,
+            },
+            {
+              file: "logs/debug.log",
+              format: :json,
+              append: true,
+              min_level: :debug,
+            },
+          ],
+        )
+      end
+
+      # Get production configuration
+      #
+      # @return [Configuration] production configuration
+      def self.production_config
+        new(
+          configurations: [
+            {
+              file: "logs/application.log",
+              format: :json,
+              append: true,
+              include_metadata: true,
+              rotation: { max_size: "100MB", max_files: 10 },
+            },
+            {
+              file: "logs/errors.log",
+              format: :json,
+              append: true,
+              min_level: :error,
+              include_metadata: true,
+            },
+          ],
+        )
+      end
+
+      # Get test configuration
+      #
+      # @return [Configuration] test configuration
+      def self.test_config
+        new(
+          configurations: [
+            {
+              file: "logs/test.log",
+              format: :text,
+              append: false,
+              include_context: true,
+            },
+          ],
+        )
+      end
+
+      # Get CI/CD configuration
+      #
+      # @return [Configuration] CI configuration
+      def self.ci_config
+        new(
+          configurations: [
+            {
+              file: $stdout,
+              format: :console,
+              show_level: true,
+            },
+            {
+              file: "artifacts/build.log",
+              format: :json,
+              append: true,
+              include_metadata: true,
+            },
+          ],
+        )
+      end
+
+      # Validate configuration
+      #
+      # @return [Boolean] true if valid
+      # @raise [ArgumentError] if configuration is invalid
+      def validate!
+        raise ArgumentError, "configurations must be an array" unless @configurations.is_a?(Array)
+        raise ArgumentError, "at least one configuration is required" if @configurations.empty?
+
+        @configurations.each_with_index do |config, index|
+          validate_single_configuration(config, index)
+        end
+
+        true
+      end
+
+      # Check if configuration is valid
+      #
+      # @return [Boolean] true if valid
+      def valid?
+        validate!
+        true
+      rescue ArgumentError
+        false
+      end
+
+      # Get configuration as hash
+      #
+      # @return [Hash] configuration as hash
+      def to_hash
+        {
+          logging: {
+            sinks: @configurations,
+          },
+        }
+      end
+
+      # Save configuration to YAML file
+      #
+      # @param yaml_file [String] path to YAML file
+      # @return [void]
+      def save_yaml(yaml_file)
+        require "yaml"
+        FileUtils.mkdir_p(File.dirname(yaml_file))
+        File.write(yaml_file, to_hash.to_yaml)
+      end
+
+      # Save configuration to JSON file
+      #
+      # @param json_file [String] path to JSON file
+      # @return [void]
+      def save_json(json_file)
+        require "json"
+        FileUtils.mkdir_p(File.dirname(json_file))
+        File.write(json_file, JSON.pretty_generate(to_hash))
+      end
+
+      private
+
+      # Validate a single configuration
+      #
+      # @param config [Hash] configuration to validate
+      # @param index [Integer] configuration index for error messages
+      # @raise [ArgumentError] if configuration is invalid
+      def validate_single_configuration(config, index)
+        raise ArgumentError, "configuration #{index} must be a hash" unless config.is_a?(Hash)
+
+        required_keys = [:file, :format]
+        missing_keys = required_keys - config.keys
+        raise ArgumentError, "configuration #{index} missing required keys: #{missing_keys.join(", ")}" unless missing_keys.empty?
+
+        # Validate file
+        file = config[:file]
+        unless file.is_a?(String) || file.is_a?(IO) || file.respond_to?(:write)
+          raise ArgumentError, "configuration #{index} file must be a String path, IO object, or writable object"
+        end
+
+        # Validate format
+        format = config[:format]
+        unless format.is_a?(Symbol) || format.is_a?(String)
+          raise ArgumentError, "configuration #{index} format must be a Symbol or String"
+        end
+
+        # Validate log levels if specified
+        if config[:min_level] && !valid_log_level?(config[:min_level])
+          raise ArgumentError, "configuration #{index} min_level must be a valid log level"
+        end
+
+        if config[:max_level] && !valid_log_level?(config[:max_level])
+          raise ArgumentError, "configuration #{index} max_level must be a valid log level"
+        end
+
+        # Validate rotation if specified
+        if config[:rotation] && !valid_rotation_config?(config[:rotation])
+          raise ArgumentError, "configuration #{index} rotation must be a valid rotation configuration"
+        end
+      end
+
+      # Check if log level is valid
+      #
+      # @param level [Symbol] log level to check
+      # @return [Boolean] true if valid
+      def valid_log_level?(level)
+        %i[debug info warn error fatal success].include?(level)
+      end
+
+      # Check if rotation configuration is valid
+      #
+      # @param rotation [Hash] rotation configuration
+      # @return [Boolean] true if valid
+      def valid_rotation_config?(rotation)
+        return false unless rotation.is_a?(Hash)
+
+        valid_keys = [:max_size, :max_files, :compress, :pattern]
+        rotation.keys.all? { |key| valid_keys.include?(key) }
+      end
+    end
+  end
+end