dev_suite 0.2.7 → 0.2.10

data/lib/dev_suite/utils/data/search_filter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module SearchFilter
+        # Deep search for all occurrences of a key
+        def deep_find_by_key(data, search_key)
+          result = []
+          traverse_and_collect(data) do |key, value|
+            result << value if key == search_key
+          end
+          result
+        end
+
+        # Recursively filter a nested hash or array based on a key-value condition
+        def deep_filter_by_key_value(data, filter_key, filter_value)
+          case data
+          when Hash
+            filter_hash_by_key_value(data, filter_key, filter_value)
+          when Array
+            filter_array_by_key_value(data, filter_key, filter_value)
+          else
+            raise ArgumentError, "Unsupported data type: #{data.class}"
+          end
+        end
+
+        private
+
+        # Helper method to filter a hash by a key-value condition
+        def filter_hash_by_key_value(hash, filter_key, filter_value)
+          return hash if hash[filter_key] == filter_value
+
+          hash.each_with_object({}) do |(key, value), result|
+            filtered_value = deep_filter_by_key_value(value, filter_key, filter_value)
+            result[key] = filtered_value unless filtered_value.nil? || filtered_value.empty?
+          end
+        end
+
+        # Helper method to filter an array by a key-value condition
+        def filter_array_by_key_value(array, filter_key, filter_value)
+          array.map { |item| deep_filter_by_key_value(item, filter_key, filter_value) }.compact
+        end
+
+        # Helper method to traverse and collect values
+        def traverse_and_collect(data, &block)
+          case data
+          when Hash
+            data.each do |key, value|
+              block.call(key, value)
+              traverse_and_collect(value, &block)
+            end
+          when Array
+            data.each { |item| traverse_and_collect(item, &block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/data/serialization.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "json"
+require "csv"
+
+module DevSuite
+  module Utils
+    module Data
+      module Serialization
+        # Convert a hash or array of hashes to compact JSON
+        def to_json(data)
+          return if data.nil?
+
+          ::JSON.generate(data) # Use JSON.generate for compact output
+        end
+
+        # Convert an array of hashes to CSV format
+        def to_csv(array_of_hashes)
+          return "" if array_of_hashes.empty?
+
+          ::CSV.generate do |csv|
+            csv << array_of_hashes.first.keys # Header row
+            array_of_hashes.each { |hash| csv << hash.values }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/data/transformations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module Transformations
+        # Recursively convert all values to strings without altering the structure
+        def deep_stringify_values(data)
+          case data
+          when Hash
+            data.each_with_object({}) do |(key, value), result|
+              result[key] = deep_stringify_values(value) # Recursively process nested values
+            end
+          when Array
+            data.map { |item| deep_stringify_values(item) }
+          else
+            data.to_s # Only convert the value itself to a string
+          end
+        end
+
+        # Recursively symbolize keys in a nested structure
+        def deep_symbolize_keys(data)
+          traverse_transform(data) { |key, value| [key.to_sym, value] }
+        end
+
+        private
+
+        # Helper method for transforming structures
+        def traverse_transform(data, &block)
+          case data
+          when Hash
+            data.each_with_object({}) do |(key, value), result|
+              new_key, new_value = block.call(key, traverse_transform(value, &block))
+              result[new_key] = new_value
+            end
+          when Array
+            data.map { |item| traverse_transform(item, &block) }
+          else
+            data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/data.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      require_relative "data/data"
+    end
+  end
+end

data/lib/dev_suite/utils/dependency_loader.rb

@@ -11,7 +11,7 @@ module DevSuite
         # @param dependencies [Array<String>] List of gem names to load.
         # @param on_failure [Proc] Handler to call with missing dependencies if any are not found.
         # @yield Executes the block if all dependencies are loaded.
-        def safe_load_dependencies(*dependencies, on_failure: method(:default_failure_handler))
+        def safe_load_dependencies(dependencies = [], on_failure: method(:default_failure_handler))
           missing_dependencies = find_missing_dependencies(dependencies)
 
           if missing_dependencies.empty?
@@ -39,7 +39,7 @@ module DevSuite
         # @param dependencies [Array<String>] List of gem names to check.
         # @return [Array<String>] List of missing dependencies.
         def find_missing_dependencies(dependencies)
-          dependencies.reject { |gem_name| gem_installed?(gem_name) }
+          Array(dependencies).reject { |gem_name| gem_installed?(gem_name) }
         end
 
         # Default failure handler that logs missing dependencies.

data/lib/dev_suite/utils/emoji.rb

@@ -11,6 +11,25 @@ module DevSuite
         retry: "💥",
         warning: "⚠️", # For warnings
         caution: "🟡", # For caution or proceed with care
+        pending: "🕒", # For pending or waiting
+        paused: "⏸️",  # For paused or halted
+        running: "🏃",  # For running or in progress
+        done: "🎉",     # For done or completed
+        finish: "🏁",   # For finish or end
+        stop: "🛑",     # For stopping or halting
+        cancel: "🚫",   # For canceling or aborting
+        skip: "⏭️",    # For skipping or jumping
+        next: "⏩",     # For next or moving forward
+        previous: "⏪", # For previous or moving backward
+        up: "⬆️",      # For up or moving up
+        down: "⬇️",    # For down or moving down
+        left: "⬅️",    # For left or moving left
+        right: "➡️",   # For right or moving right
+        top: "🔝",      # For top or highest
+        bottom: "🔚",   # For bottom or lowest
+        middle: "🔽", # For middle or center
+        full: "🔴",     # For full or maximum
+        empty: "⚪",    # For empty or minimum
       }.freeze
 
       # Action-related emojis

data/lib/dev_suite/utils/file_loader/file_loader.rb

@@ -3,14 +3,10 @@
 module DevSuite
   module Utils
     module FileLoader
-      require "pathname"
-      require "json"
-      require "yaml"
-
+      require_relative "config"
       require_relative "loader"
       require_relative "loader_registry"
       require_relative "loader_manager"
-      require_relative "config"
 
       class << self
         def load(path)

data/lib/dev_suite/utils/file_loader/loader/json.rb

@@ -12,7 +12,10 @@ module DevSuite
           end
 
           def load(path)
-            ::JSON.parse(::File.read(path))
+            content = ::File.read(path)
+            return {} if content.strip.empty?
+
+            ::JSON.parse(content)
           end
         end
       end

data/lib/dev_suite/utils/file_loader/loader/loader.rb

@@ -4,37 +4,41 @@ module DevSuite
   module Utils
     module FileLoader
       module Loader
+        include Construct::Component::Manager
+
         require_relative "base"
-        require_relative "text"
-        require_relative "json"
-        require_relative "yaml"
 
         class << self
+          # Registers the specified loaders with the given registry.
+          #
+          # @param registry [Object] the registry to register loaders with
+          # @param loader_symbols [Array<Symbol>] the symbols representing the loaders to register
+          # @return [Object] the updated registry
           def registry_loaders(registry, loader_symbols)
-            loader_classes = map_loaders(loader_symbols)
+            loader_classes = registered_components.values_at(*loader_symbols)
             loader_classes.each do |loader|
               registry.register(loader)
             end
             registry
           end
 
-          private
-
-          def map_loaders(loader_symbols)
-            loader_symbols.map do |symbol|
-              case symbol
-              when :json
-                Loader::Json
-              when :text
-                Loader::Text
-              when :yaml
-                Loader::Yaml
-              else
-                raise "Unknown loader: #{symbol}"
-              end
-            end
+          def handle_missing_dependencies(missing_dependencies)
+            Config.configuration.remove_failed_dependency(:loaders, :json, *missing_dependencies)
           end
         end
+
+        require_relative "text"
+        register_component(Text)
+
+        load_dependency(["json"], on_failure: method(:handle_missing_dependencies)) do
+          require_relative "json"
+          register_component(Json)
+        end
+
+        load_dependency(["yaml"], on_failure: method(:handle_missing_dependencies)) do
+          require_relative "yaml"
+          register_component(Yaml)
+        end
       end
     end
   end

data/lib/dev_suite/utils/file_loader/loader.rb

@@ -4,8 +4,6 @@ module DevSuite
   module Utils
     module FileLoader
       module Loader
-        include Construct::Component::Manager
-
         require_relative "loader/loader"
       end
     end

data/lib/dev_suite/utils/file_writer/atomic_writer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      class AtomicWriter
+        def initialize(path, content, mode: 0o644)
+          @path = path
+          @content = content
+          @mode = mode
+        end
+
+        def write
+          ensure_directory_exists
+
+          ::File.open(@path, "w") do |file|
+            file.flock(::File::LOCK_EX) # Lock for exclusive write access
+            write_to_tempfile_and_replace
+          end
+        end
+
+        private
+
+        def write_to_tempfile_and_replace
+          temp_path = "#{@path}.tmp"
+          begin
+            ::File.open(temp_path, "w") do |tempfile|
+              tempfile.write(@content)
+              tempfile.flush
+              tempfile.fsync # Ensure data is physically written to disk
+            end
+
+            # Atomically replace the original file with the temporary file
+            ::File.rename(temp_path, @path)
+
+            # Set correct file permissions
+            ::File.chmod(@mode, @path)
+          rescue IOError, Errno::ENOSPC => e
+            raise "Failed to write or replace the original file: #{e.message}"
+          ensure
+            # Clean up the temporary file if it still exists
+            ::File.delete(temp_path) if ::File.exist?(temp_path)
+          end
+        end
+
+        def ensure_directory_exists
+          directory = ::File.dirname(@path)
+          ::FileUtils.mkdir_p(directory) unless ::Dir.exist?(directory)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/backup_manager.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      class BackupManager
+        def initialize(path)
+          @path = path
+        end
+
+        def create_backup
+          backup_path = "#{@path}.bak"
+          Logger.log("Creating backup of #{@path} at #{backup_path}", level: :info)
+          ::FileUtils.cp(@path, backup_path)
+        rescue IOError => e
+          raise "Failed to create backup: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/file_writer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      require_relative "atomic_writer"
+      require_relative "backup_manager"
+      require_relative "writer"
+      require_relative "writer_manager"
+
+      class << self
+        def write(path, content)
+          writer = WriterManager.new
+          writer.write(path, content)
+        end
+
+        def update_key(path, key, value)
+          writer = WriterManager.new
+          writer.update_key(path, key, value)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      module Writer
+        class Base < Utils::Construct::Component::Base
+          # Abstract method that subclasses must implement for custom file write operations
+          def write(_path, _content)
+            raise NotImplementedError, "Subclasses must implement the `write` method"
+          end
+
+          # General method to update a key in any structured file
+          def update_key(path, key, value, **options)
+            # Step 1: Load the existing content of the file (this will be subclass-specific)
+            content = load_file_content(path)
+
+            # Step 2: Use a utility function to modify the content at the specified key path
+            Utils::Data.set_value_by_path(content, key, value)
+
+            # Step 3: Write the updated content back to the file using the subclass's write method
+            write(path, content, **options)
+          end
+
+          private
+
+          def file_exists?(path)
+            ::File.exist?(path)
+          end
+
+          # Load the file content using a file loader
+          def load_file_content(file_path)
+            FileLoader.load(file_path)
+          end
+
+          def create_backup(path)
+            BackupManager.new(path).create_backup if file_exists?(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer/json.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      module Writer
+        class Json < Base
+          def write(path, content, pretty: false, backup: false)
+            create_backup(path) if backup
+
+            json_content = convert_to_json(content, pretty)
+            AtomicWriter.new(path, json_content).write
+          end
+
+          private
+
+          def convert_to_json(content, pretty)
+            pretty ? ::JSON.pretty_generate(content) : ::JSON.dump(content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer/text.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      module Writer
+        class Text < Base
+          def write(path, content, backup: false)
+            create_backup(path) if backup
+
+            AtomicWriter.new(path, content).write
+          end
+
+          # Updates a key-like pattern in a plain text file (find and replace)
+          def update_key(path, key, value, backup: false)
+            content = load_file_content(path)
+
+            # Simple pattern matching and replacement (e.g., `key: value`)
+            updated_content = content.gsub(/^#{Regexp.escape(key)}:.*/, "#{key}: #{value}")
+
+            write(path, updated_content, backup: backup)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer/writer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      module Writer
+        require_relative "base"
+        require_relative "text"
+        require_relative "json"
+        require_relative "yaml"
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer/yaml.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      module Writer
+        class Yaml < Base
+          def write(path, content, normalize: false, backup: false, yaml_options: {})
+            validate_content(content)
+            create_backup(path) if backup
+
+            yaml_content = prepare_yaml_content(content, normalize, yaml_options)
+            AtomicWriter.new(path, yaml_content).write
+          end
+
+          private
+
+          # Prepare YAML content by normalizing and applying options
+          def prepare_yaml_content(content, normalize, yaml_options)
+            normalized_content = normalize ? normalize_yaml(content) : content
+            ::YAML.dump(normalized_content, yaml_options)
+          end
+
+          # Validates that content is a Hash or an Array of Hashes
+          def validate_content(content)
+            unless valid_content?(content)
+              raise ArgumentError, "Content must be a Hash or an Array of Hashes"
+            end
+          end
+
+          # Check if content is a valid Hash or an Array of Hashes
+          def valid_content?(content)
+            content.is_a?(Hash) || (content.is_a?(Array) && content.all? { |item| item.is_a?(Hash) })
+          end
+
+          # Normalize the YAML content (e.g., sort keys)
+          def normalize_yaml(content)
+            content.is_a?(Hash) ? content.sort.to_h : content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      module Writer
+        require_relative "writer/writer"
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer/writer_manager.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      class WriterManager
+        def write(path, content)
+          writer = writer_for(path)
+          writer.write(path, content)
+        end
+
+        def update_key(path, key, value)
+          writer = writer_for(path)
+          writer.update_key(path, key, value)
+        end
+
+        private
+
+        def writer_for(path)
+          case ::File.extname(path)
+          when ".json"
+            Writer::Json.new
+          when ".yml", ".yaml"
+            Writer::Yaml.new
+          else
+            Writer::Text.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/file_writer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module FileWriter
+      require_relative "file_writer/file_writer"
+    end
+  end
+end

data/lib/dev_suite/utils/logger.rb

@@ -4,6 +4,7 @@ module DevSuite
   module Utils
     module Logger
       LOG_DETAILS = {
+        none: { prefix: "", color: :white },
         info: { prefix: "[INFO]", color: :green },
         warn: { prefix: "[WARNING]", color: :yellow },
         error: { prefix: "[ERROR]", color: :red },
@@ -16,9 +17,9 @@ module DevSuite
         # @param message [String] The message to log.
         # @param level [Symbol] The log level (:info, :warn, :error, :debug).
         # @param emoji [String, Symbol] Optional emoji to prepend to the message.
-        def log(message, level: :info, emoji: nil)
+        def log(message, level: :none, emoji: nil, prefix: nil, color: nil)
           emoji_icon = resolve_emoji(emoji)
-          formatted_message = format_message("#{emoji_icon} #{message}", level)
+          formatted_message = format_message("#{emoji_icon} #{message}", level, prefix, color)
           output_log(formatted_message)
         end
 
@@ -39,11 +40,12 @@ module DevSuite
         # @param message [String] The message to format.
         # @param level [Symbol] The log level (:info, :warn, :error, :debug).
         # @return [String] The formatted log message.
-        def format_message(message, level)
+        def format_message(message, level, custom_prefix, custom_color)
           details = LOG_DETAILS[level]
-          raise ArgumentError, "Invalid log level: #{level}" unless details
+          prefix = custom_prefix || details[:prefix]
+          color = custom_color || details[:color]
 
-          Utils::Color.colorize("#{details[:prefix]} #{message}", color: details[:color])
+          Utils::Color.colorize("#{prefix} #{message}", color: color)
         end
 
         # Outputs the formatted log message to the console.

data/lib/dev_suite/utils/store/config/config.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Config
+        include Construct::Config::Manager
+
+        require_relative "configuration"
+      end
+    end
+  end
+end