dev_suite 0.2.10 → 0.2.12

data/lib/dev_suite/utils/data/path_access.rb

@@ -4,167 +4,21 @@ module DevSuite
   module Utils
     module Data
       module PathAccess
+        require_relative "path_access/path_accessor"
+
         # Fetch value from a nested structure using a path
         def get_value_by_path(data, path)
-          keys = parse_path(path)
-          traverse_path_for_get(data, keys)
+          PathAccessor.get(data, path)
         end
 
         # Set value in a nested structure using a path
         def set_value_by_path(data, path, value)
-          keys = parse_path(path)
-          last_key = keys.pop
-          target = traverse_path_for_set(data, keys)
-
-          set_final_value(target, last_key, value)
+          PathAccessor.set(data, path, value)
         end
 
         # Delete a key from a nested structure using a path
         def delete_key_by_path(data, path)
-          keys = parse_path(path)
-          last_key = keys.pop
-          target = traverse_path_for_delete(data, keys)
-
-          delete_final_key(target, last_key)
-        end
-
-        private
-
-        # Parse the path into an array of keys/symbols/integers
-        def parse_path(path)
-          return path if path.is_a?(Array)
-          return [path] if single_symbol_path?(path)
-
-          parse_symbol_or_string_path(path)
-        end
-
-        # Check if the path is a symbol without dots
-        def single_symbol_path?(path)
-          path.is_a?(Symbol) && !path.to_s.include?(".")
-        end
-
-        # Parse a symbol or string path into an array of keys
-        def parse_symbol_or_string_path(path)
-          if path.is_a?(Symbol)
-            parse_symbol_path(path)
-          else
-            parse_string_path(path)
-          end
-        end
-
-        # Parse a symbol path that contains dots (e.g., :"test.1")
-        def parse_symbol_path(path)
-          path.to_s.split(".").map { |part| parse_part(part) }
-        end
-
-        # Parse a string path into keys (e.g., 'users.1.name')
-        def parse_string_path(path)
-          path.to_s.split(/\.|\[|\]/).reject(&:empty?).map { |part| parse_part(part) }
-        end
-
-        # Parse each part into either a symbol or integer
-        def parse_part(part)
-          part.match?(/^\d+$/) ? part.to_i : part.to_sym
-        end
-
-        # Helper to traverse the path for getting values
-        def traverse_path_for_get(data, keys)
-          keys.reduce(data) do |current_data, key|
-            check_invalid_path(current_data, key)
-
-            case current_data
-            when Hash
-              fetch_from_hash(current_data, key)
-            when Array
-              fetch_from_array(current_data, key)
-            else
-              raise KeyError, "Invalid data type at '#{key}'"
-            end
-          end
-        end
-
-        # Helper to traverse the path for setting values
-        def traverse_path_for_set(data, keys)
-          keys.reduce(data) do |current_data, key|
-            check_invalid_path(current_data, key)
-
-            case current_data
-            when Hash
-              current_data[find_existing_key(current_data, key)] ||= {}
-            when Array
-              current_data[key.to_i] ||= {}
-            else
-              break nil
-            end
-          end
-        end
-
-        # Helper to check for invalid paths
-        def check_invalid_path(data, key)
-          raise KeyError, "Invalid path at '#{key}'" if data.nil?
-        end
-
-        # Fetch value from a hash, trying both symbol and string keys
-        def fetch_from_hash(hash, key)
-          hash[key.to_sym] || hash[key.to_s]
-        end
-
-        # Fetch value from an array if the key is an integer
-        def fetch_from_array(array, key)
-          key.is_a?(Integer) ? array[key] : nil
-        end
-
-        # Set the final value in a hash or array
-        def set_final_value(target, last_key, value)
-          case target
-          when Hash
-            target[find_existing_key(target, last_key)] = value
-          when Array
-            if last_key.is_a?(Integer)
-              target[last_key] = value
-            else
-              raise KeyError, "Invalid path or type at '#{last_key}'"
-            end
-          else
-            raise KeyError, "Invalid target type for path at '#{last_key}'"
-          end
-        end
-
-        # Check if the key already exists and return the key in its original type (symbol or string)
-        def find_existing_key(hash, key)
-          return key if hash.key?(key) # Key already exists in original form
-          return key.to_s if hash.key?(key.to_s) # Exists as a string
-          return key.to_sym if hash.key?(key.to_sym) # Exists as a symbol
-
-          key # Otherwise, return the key as-is (use the incoming type)
-        end
-
-        # Helper to traverse the path for deletion
-        def traverse_path_for_delete(data, keys)
-          keys.reduce(data) do |current_data, key|
-            check_invalid_path(current_data, key)
-
-            case current_data
-            when Hash
-              current_data[find_existing_key(current_data, key)]
-            when Array
-              current_data[key.to_i]
-            else
-              raise KeyError, "Invalid data type at '#{key}'"
-            end
-          end
-        end
-
-        # Helper to delete the final key in a hash or array
-        def delete_final_key(target, last_key)
-          case target
-          when Hash
-            target.delete(find_existing_key(target, last_key))
-          when Array
-            target.delete_at(last_key.to_i) if last_key.is_a?(Integer)
-          else
-            raise KeyError, "Cannot delete key from unsupported data type"
-          end
+          PathAccessor.delete(data, path)
         end
       end
     end

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

@@ -10,13 +10,23 @@ module DevSuite
 
       class << self
         def write(path, content)
-          writer = WriterManager.new
-          writer.write(path, content)
+          WriterManager.write(path, content)
+        end
+
+        def append(path, content)
+          WriterManager.append(path, content)
+        end
+
+        def delete_lines(path, start_line, end_line = start_line)
+          WriterManager.delete_lines(path, start_line, end_line)
         end
 
         def update_key(path, key, value)
-          writer = WriterManager.new
-          writer.update_key(path, key, value)
+          WriterManager.update_key(path, key, value)
+        end
+
+        def delete_key(path, key)
+          WriterManager.delete_key(path, key)
         end
       end
     end

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

@@ -5,21 +5,51 @@ module DevSuite
     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"
+          attr_reader :path
+
+          def initialize(path)
+            super()
+            @path = path
+          end
+
+          def read
+            FileLoader.load(path)
           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)
+          def write(content, backup: false)
+            create_backup if backup
+            AtomicWriter.new(path, content).write
+          end
 
-            # Step 2: Use a utility function to modify the content at the specified key path
+          def append(content)
+            current_content = read
+            updated_content = current_content.merge(content)
+            write(updated_content)
+          end
+
+          def delete_lines(start_line, end_line = start_line)
+            lines = ::File.readlines(path)
+            lines.slice!(start_line - 1, end_line - start_line + 1)
+            write(lines.join)
+          end
+
+          def update_key(key, value, **options)
+            content = read
             Utils::Data.set_value_by_path(content, key, value)
+            write(content, **options)
+          end
+
+          def delete_key(key, **options)
+            content = read
+            Utils::Data.delete_key_by_path(content, key)
+            write(content, **options)
+          end
 
-            # Step 3: Write the updated content back to the file using the subclass's write method
-            write(path, content, **options)
+          def append_array(array_key, new_elements)
+            data = read
+            data[array_key] ||= []
+            data[array_key].concat(new_elements)
+            write(data)
           end
 
           private
@@ -28,11 +58,6 @@ module DevSuite
             ::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

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

@@ -5,7 +5,7 @@ module DevSuite
     module FileWriter
       module Writer
         class Json < Base
-          def write(path, content, pretty: false, backup: false)
+          def write(content, pretty: false, backup: false)
             create_backup(path) if backup
 
             json_content = convert_to_json(content, pretty)

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

@@ -5,20 +5,22 @@ module DevSuite
     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)
+          def update_key(key, value, backup: false)
+            content = read
 
             # Simple pattern matching and replacement (e.g., `key: value`)
             updated_content = content.gsub(/^#{Regexp.escape(key)}:.*/, "#{key}: #{value}")
 
-            write(path, updated_content, backup: backup)
+            write(updated_content, backup: backup)
+          end
+
+          def append(content)
+            ::File.open(path, "a") do |file|
+              file.write("\n") if ::File.size(path).nonzero?
+
+              file.write(content.strip)
+            end
           end
         end
       end

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

@@ -5,7 +5,7 @@ module DevSuite
     module FileWriter
       module Writer
         class Yaml < Base
-          def write(path, content, normalize: false, backup: false, yaml_options: {})
+          def write(content, normalize: false, backup: false, yaml_options: {})
             validate_content(content)
             create_backup(path) if backup
 

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

@@ -3,27 +3,50 @@
 module DevSuite
   module Utils
     module FileWriter
+      class UnsupportedFileTypeError < StandardError; end
+
       class WriterManager
-        def write(path, content)
-          writer = writer_for(path)
-          writer.write(path, content)
-        end
+        WRITERS = {
+          ".json" => Writer::Json,
+          ".yml" => Writer::Yaml,
+          ".yaml" => Writer::Yaml,
+          ".txt" => Writer::Text,
+        }.freeze
 
-        def update_key(path, key, value)
-          writer = writer_for(path)
-          writer.update_key(path, key, value)
-        end
+        class << self
+          def write(path, content)
+            writer_instance(path).write(content)
+          end
+
+          def append(path, content)
+            writer_instance(path).append(content)
+          end
+
+          def delete_lines(path, start_line, end_line = start_line)
+            writer_instance(path).delete_lines(start_line, end_line)
+          end
 
-        private
+          def update_key(path, key, value)
+            writer_instance(path).update_key(key, value)
+          end
+
+          def delete_key(path, key)
+            writer_instance(path).delete_key(key)
+          end
+
+          private
+
+          # Returns the appropriate writer instance based on the file extension
+          def writer_instance(path)
+            writer_class = WRITERS[file_extension(path)]
+            raise UnsupportedFileTypeError, "Unsupported file type: #{file_extension(path)}" unless writer_class
+
+            writer_class.new(path)
+          end
 
-        def writer_for(path)
-          case ::File.extname(path)
-          when ".json"
-            Writer::Json.new
-          when ".yml", ".yaml"
-            Writer::Yaml.new
-          else
-            Writer::Text.new
+          # Returns the file extension from the path
+          def file_extension(path)
+            ::File.extname(path).downcase
           end
         end
       end

data/lib/dev_suite/utils/logger/base.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Logger
+      require_relative "formatter"
+      require_relative "emoji"
+      require_relative "errors"
+
+      class Base
+        LOG_LEVELS = [:none, :info, :warn, :error, :debug].freeze
+
+        attr_accessor :log_level
+
+        def initialize(log_level: :none)
+          validate_log_level(log_level)
+          @log_level = log_level
+        end
+
+        # Logs a message with optional emoji, prefix, and color.
+        def log(message, level: :none, emoji: nil, prefix: nil, color: nil)
+          validate_log_level(level)
+          return if skip_logging?(level)
+
+          options = {
+            level: level,
+            emoji: emoji,
+            prefix: prefix,
+            color: color,
+          }
+
+          formatted_message = Formatter.format(message, options)
+          output_log(formatted_message)
+        end
+
+        private
+
+        def validate_log_level(level)
+          return if LOG_LEVELS.include?(level)
+
+          raise InvalidLogLevelError, "Invalid log level: #{level}. Valid levels are: #{LOG_LEVELS.join(", ")}."
+        end
+
+        def skip_logging?(level)
+          LOG_LEVELS.index(level) < LOG_LEVELS.index(@log_level)
+        end
+
+        def output_log(formatted_message)
+          puts formatted_message if formatted_message
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/logger/emoji.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Logger
+      module Emoji
+        class << self
+          def resolve(emoji)
+            return "" unless emoji
+
+            emoji.is_a?(Symbol) ? Utils::Emoji.get(emoji) : emoji
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/logger/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Logger
+      class InvalidLogLevelError < StandardError; end
+    end
+  end
+end

data/lib/dev_suite/utils/logger/formatter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Logger
+      module Formatter
+        LOG_DETAILS = {
+          none: { prefix: "", color: :white },
+          info: { prefix: "[INFO]", color: :green },
+          warn: { prefix: "[WARNING]", color: :yellow },
+          error: { prefix: "[ERROR]", color: :red },
+          debug: { prefix: "[DEBUG]", color: :blue },
+        }.freeze
+
+        class << self
+          def format(message, options = {})
+            return "" if message.nil? || message.strip.empty?
+
+            details = fetch_log_details(options[:level])
+            prefix = options[:prefix] || details[:prefix]
+            color = options[:color] || details[:color]
+            emoji_icon = Emoji.resolve(options[:emoji])
+
+            formatted_message = build_message(prefix, emoji_icon, message)
+            Utils::Color.colorize(formatted_message, color: color)
+          end
+
+          private
+
+          def fetch_log_details(level)
+            LOG_DETAILS[level || :none]
+          end
+
+          def build_message(prefix, emoji_icon, message)
+            "#{prefix} #{emoji_icon} #{message}".strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/logger/logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Logger
+      require_relative "base"
+
+      class << self
+        # Provides access to the global logger instance
+        #
+        # @return [Base] the global logger instance
+        def logger
+          @logger ||= Base.new
+        end
+
+        # Logs a message using the global logger instance
+        #
+        # @param message [String] The message to log.
+        # @param level [Symbol] The log level (:none, :info, :warn, :error, :debug).
+        # @param emoji [String, Symbol, nil] Optional emoji to prepend to the message.
+        # @param prefix [String, nil] Custom prefix for the message.
+        # @param color [Symbol, nil] Custom color for the message.
+        def log(message, level: :none, emoji: nil, prefix: nil, color: nil)
+          logger.log(message, level: level, emoji: emoji, prefix: prefix, color: color)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/logger.rb

@@ -3,58 +3,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 },
-        debug: { prefix: "[DEBUG]", color: :blue },
-      }.freeze
-
-      class << self
-        # Logs a message with an optional emoji and specified log level.
-        #
-        # @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: :none, emoji: nil, prefix: nil, color: nil)
-          emoji_icon = resolve_emoji(emoji)
-          formatted_message = format_message("#{emoji_icon} #{message}", level, prefix, color)
-          output_log(formatted_message)
-        end
-
-        private
-
-        # Resolves the emoji, either from a symbol or directly as a string.
-        #
-        # @param emoji [String, Symbol, nil] The emoji or its symbol key.
-        # @return [String] The resolved emoji or an empty string if none is provided.
-        def resolve_emoji(emoji)
-          return "" unless emoji
-
-          emoji.is_a?(Symbol) ? Emoji.get(emoji) : emoji
-        end
-
-        # Formats the log message with the appropriate prefix and color.
-        #
-        # @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, custom_prefix, custom_color)
-          details = LOG_DETAILS[level]
-          prefix = custom_prefix || details[:prefix]
-          color = custom_color || details[:color]
-
-          Utils::Color.colorize("#{prefix} #{message}", color: color)
-        end
-
-        # Outputs the formatted log message to the console.
-        #
-        # @param formatted_message [String] The message to output.
-        def output_log(formatted_message)
-          puts formatted_message if formatted_message
-        end
-      end
+      require_relative "logger/logger"
     end
   end
 end

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

@@ -44,7 +44,9 @@ module DevSuite
         end
 
         def build_driver(options)
-          Driver.build_component(options.fetch(:driver), **options.except(:driver))
+          driver_type = options.fetch(:driver)
+          driver_options = options.reject { |key, _| key == :driver }
+          Driver.build_component(driver_type, **driver_options)
         end
       end
 

data/lib/dev_suite/utils/table/renderer/simple.rb

@@ -49,7 +49,7 @@ module DevSuite
 
             total_width = column_widths.sum + column_widths.size * 3 - 1
             title_str = "| #{table.title.center(total_width - 2)} |"
-            colorize(title_str, settings.get("colors.title"))
+            puts colorize(title_str, settings.get("colors.title"))
           end
 
           def render_header(table, column_widths)
@@ -59,13 +59,13 @@ module DevSuite
               text_align(column.name, column_widths[index])
             end
             header_str = "| #{header.join(" | ")} |"
-            colorize(header_str, settings.get("colors.column"))
+            puts colorize(header_str, settings.get("colors.column"))
           end
 
           def render_separator(column_widths)
             separator = column_widths.map { |width| "-" * width }.join("-+-")
             separator_str = "+-#{separator}-+"
-            colorize(separator_str, settings.get("colors.border"))
+            puts colorize(separator_str, settings.get("colors.border"))
           end
 
           def render_rows(table, column_widths)
@@ -73,7 +73,7 @@ module DevSuite
               render_row(row, column_widths)
             end
             cells_str = cells.join("\n")
-            colorize(cells_str, settings.get("colors.row"))
+            puts colorize(cells_str, settings.get("colors.row"))
           end
 
           def render_row(row, column_widths)
@@ -81,7 +81,7 @@ module DevSuite
               text_align(cell.to_s, column_widths[index])
             end
             cell_str = "| #{cell.join(" | ")} |"
-            colorize(cell_str, settings.get("colors.row"))
+            puts colorize(cell_str, settings.get("colors.row"))
           end
         end
       end

data/lib/dev_suite/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DevSuite
-  VERSION = "0.2.10"
+  VERSION = "0.2.12"
 end