dev_suite 0.2.11 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aa7bc365cd71c523150cc3dde4eb92eb84c7c7b3cff4435ac373474f7d73871
-  data.tar.gz: 7ec2c14843c493cfa0ef819350463e994344e407a248a5d83f317ec6d9c021ff
+  metadata.gz: 6c4f76e1bde363b53c6e0e76616ce4589f37e17af746b6e1d77019aa0d2c58d9
+  data.tar.gz: b93fd9c938777e4c5c366b34b761b38d5e3bfb38231b345b125f41f5655576ab
 SHA512:
-  metadata.gz: e86091d8c8ca69fa6dec4a1a8a7b5403671e7fcd8a08db8a364b71a473704c613d8135a70645e990741e8a23b00cac8ffdab1cb419c2582e9b75476829842a9d
-  data.tar.gz: 6fbbf0e0cb281dd9ead32c6a4eeeeec414d3cf2216865f2c3c01908e3d25eb946b9de82de68002c34d170e05bd7038cbe2fae7ba86b88a5c78de412e49dff279
+  metadata.gz: a8c153fb7c5fa8f73a03e1ae33cc8fbc71b825150c557dad9d0f2bc9e2a1b3e8054b7d334b02bfe51cb4e72c10d13732bbb0247be3c5235ece0c639338aa370e
+  data.tar.gz: f42462a700acc328deca1071c7a9cccd63c93eba44928c3510707afe4173b7ea6c478328103d47abfe30ce86d2e7430d120ecc5c3a46fa95f3e9355d5b27c377

data/.codeclimate.yml

@@ -1,12 +1,54 @@
 version: "2"
 checks:
-  argument_count:
+  argument-count:
     enabled: true
-  file_lines:
+  complexity:
     enabled: true
-ratings:
-  paths:
-    - "**.rb"
+  duplication:
+    enabled: true
+  file-lines:
+    enabled: true
+  method-lines:
+    enabled: true
+  return-statements:
+    enabled: true
+  similar-code:
+    enabled: true
+  npath-complexity:
+    enabled: true
+  identical-code:
+    enabled: true
+
+engines:
+  rubocop:
+    enabled: true
+    channel: rubocop-1-48-1
+    config:
+      file: .rubocop.yml
+  bundler-audit:
+    enabled: true
+    channel: bundler-audit-0-9-1
+  duplication:
+    enabled: true
+    config:
+      languages:
+        ruby:
+          mass_threshold: 50
+          paths:
+            - "lib/**/*.rb"
+  fixme:
+    enabled: false
+    config:
+      strings:
+        - "TODO"
+        - "FIXME"
+
 exclude_patterns:
-  - "examples/**"  # Ignore examples folder
-  - "tmp/**"       # Ignore temp files
+  - "spec/"
+  - "test/"
+  - "vendor/"
+  - "bin/"
+  - "log/"
+  - "tmp/"
+  - "coverage/"
+  - "examples/"

data/Gemfile

@@ -21,3 +21,7 @@ group :development do
   gem "rubocop", "~> 1.65", require: false
   gem "rubocop-shopify", "~> 2.15", require: false
 end
+
+group :test do
+  gem "webmock", "~> 3.13"
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dev_suite (0.2.11)
+    dev_suite (0.2.13)
       benchmark (~> 0.1)
       csv (~> 3.0)
       get_process_mem (~> 1.0)
@@ -10,11 +10,16 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.2)
     benchmark (0.3.0)
     bigdecimal (3.1.8)
     coderay (1.1.3)
     concurrent-ruby (1.3.4)
+    crack (1.0.0)
+      bigdecimal
+      rexml
     csv (3.3.0)
     diff-lcs (1.5.1)
     docile (1.4.1)
@@ -47,6 +52,7 @@ GEM
     get_process_mem (1.0.0)
       bigdecimal (>= 2.0)
       ffi (~> 1.0)
+    hashdiff (1.1.1)
     i18n (1.14.5)
       concurrent-ruby (~> 1.0)
     json (2.7.2)
@@ -60,10 +66,12 @@ GEM
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    public_suffix (6.0.1)
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.2.1)
     regexp_parser (2.9.2)
+    rexml (3.3.8)
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -101,6 +109,10 @@ GEM
     simplecov_json_formatter (0.1.4)
     thor (1.3.2)
     unicode-display_width (2.5.0)
+    webmock (3.24.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
   arm64-darwin-23
@@ -115,6 +127,7 @@ DEPENDENCIES
   rubocop (~> 1.65)
   rubocop-shopify (~> 2.15)
   simplecov (~> 0.21)
+  webmock (~> 3.13)
 
 BUNDLED WITH
    2.5.17

data/README.md

@@ -428,6 +428,10 @@ Trace all method calls within a specific block of code, including optional loggi
    🏁 #depth:1 < MathOperations#greet #=> "Hello, Ruby!" at (irb):12 in 0.02ms
 Hello, Ruby!
 ```
+
+  **Tips**:
+
+  Use `max_depth` to Limit Tracing: If you have deeply nested method calls, use the `max_depth` option to limit the depth of tracing. This can help reduce the amount of log output and focus on the most relevant parts of your code. A recommended value for `max_depth` is between `2` and `5`, depending on the complexity of your code.
 </details>
 
 ## Development

data/lib/dev_suite/method_tracer/logger.rb

@@ -5,40 +5,66 @@ module DevSuite
     module Logger
       class << self
         def log_method_call(tp, tracer)
-          tracer.depth += 1
-
-          method_name = Helpers.format_method_name(tp)
-          params_str = Helpers.format_params(tp) if tracer.show_params
-          indent = Helpers.calculate_indent(tracer.depth)
-
           # Store the start time for execution time calculation
           tracer.start_times[tp.method_id] = Time.now
 
-          message = "#{indent}#depth:#{tracer.depth} > #{method_name} at #{tp.path}:#{tp.lineno} #{params_str}"
-          Utils::Logger.log(
-            message,
-            emoji: :start,
-            color: :blue,
-          )
+          message = build_call_message(tp, tracer)
+          Utils::Logger.log(message, emoji: :start, color: :blue)
         end
 
         def log_method_return(tp, tracer)
           duration = Helpers.calculate_duration(tp, tracer.start_times)
 
-          method_name = Helpers.format_method_name(tp)
-          result_str = Helpers.format_result(tp) if tracer.show_results
-          exec_time_str = Helpers.format_execution_time(duration) if tracer.show_execution_time
-          indent = Helpers.calculate_indent(tracer.depth)
+          message = build_return_message(tp, tracer, duration)
+          Utils::Logger.log(message, emoji: :finish, color: :cyan)
+        end
+
+        private
+
+        # Builds the log message for method calls
+        #
+        # @param tp [TracePoint] The TracePoint object
+        # @param tracer [Tracer] The tracer instance
+        # @return [String] The formatted log message
+        def build_call_message(tp, tracer)
+          method_name = colorize_text(Helpers.format_method_name(tp), :blue)
+          params_str = tracer.show_params ? colorize_text(Helpers.format_params(tp), :yellow) : ""
+          indent = Helpers.calculate_indent(tracer.current_depth)
+          depth_str = colorize_text("#depth:#{tracer.current_depth}", :magenta)
 
-          message = "#{indent}#depth:#{tracer.depth} < #{method_name}#{result_str} at #{tp.path}:#{tp.lineno}#{exec_time_str}"
-          Utils::Logger.log(
-            message,
-            emoji: :finish,
-            color: :cyan,
-          )
+          "#{indent}#{depth_str} > #{method_name} at #{tp.path}:#{tp.lineno} #{params_str}"
+        end
+
+        # Builds the log message for method returns
+        #
+        # @param tp [TracePoint] The TracePoint object
+        # @param tracer [Tracer] The tracer instance
+        # @param duration [Float] The execution time
+        # @return [String] The formatted log message
+        def build_return_message(tp, tracer, duration)
+          method_name = colorize_text(Helpers.format_method_name(tp), :cyan)
+          result_str = tracer.show_results ? colorize_text(Helpers.format_result(tp), :green) : ""
+          exec_time_str = if tracer.show_execution_time
+            colorize_text(
+              Helpers.format_execution_time(duration),
+              :light_white,
+            )
+          else
+            ""
+          end
+          indent = Helpers.calculate_indent(tracer.current_depth)
+          depth_str = colorize_text("#depth:#{tracer.current_depth}", :magenta)
+
+          "#{indent}#{depth_str} < #{method_name}#{result_str} at #{tp.path}:#{tp.lineno}#{exec_time_str}"
+        end
 
-          # Decrement depth safely
-          tracer.depth = [tracer.depth - 1, 0].max
+        # Helper method to colorize text
+        #
+        # @param text [String] The text to colorize
+        # @param color [Symbol] The color to use
+        # @return [String] The colorized text
+        def colorize_text(text, color)
+          Utils::Color.colorize(text, color: color)
         end
       end
     end

data/lib/dev_suite/method_tracer/tracer.rb

@@ -4,7 +4,7 @@ module DevSuite
   module MethodTracer
     class Tracer
       attr_reader :show_params, :show_results, :show_execution_time, :max_depth
-      attr_accessor :depth, :trace_point, :start_times
+      attr_accessor :current_depth, :trace_point, :start_times
 
       def initialize(
         show_params: false,
@@ -16,8 +16,8 @@ module DevSuite
         @show_results = show_results
         @show_execution_time = show_execution_time
         @max_depth = max_depth
-        @depth = 0
         @start_times = {}
+        @current_depth = 0
       end
 
       def trace(&block)
@@ -50,15 +50,23 @@ module DevSuite
       end
 
       def handle_call_event(tp)
-        Logger.log_method_call(tp, self) if depth_within_limit?
+        @current_depth += 1
+
+        if current_depth_within_limit?
+          Logger.log_method_call(tp, self)
+        end
       end
 
       def handle_return_event(tp)
-        Logger.log_method_return(tp, self) if depth_within_limit?
+        if current_depth_within_limit?
+          Logger.log_method_return(tp, self)
+        end
+
+        @current_depth -= 1
       end
 
-      def depth_within_limit?
-        max_depth.nil? || @depth < max_depth
+      def current_depth_within_limit?
+        max_depth.nil? || current_depth <= max_depth
       end
     end
   end

data/lib/dev_suite/utils/color/colorizer.rb

@@ -5,7 +5,7 @@ module DevSuite
     module Color
       class Colorizer
         def colorize(text, **kargs)
-          puts Config.configuration.strategy.colorize(text, **kargs)
+          Config.configuration.strategy.colorize(text, **kargs)
         end
       end
 

data/lib/dev_suite/utils/color/palette/default.rb

@@ -6,6 +6,8 @@ module DevSuite
       module Palette
         class Default < Base
           COLORS = {
+            # Standard Colors
+            black: 30,
             red: 31,
             green: 32,
             yellow: 33,
@@ -14,6 +16,37 @@ module DevSuite
             cyan: 36,
             white: 37,
             default: 39,
+
+            # Light Colors
+            light_black: 90,
+            light_red: 91,
+            light_green: 92,
+            light_yellow: 93,
+            light_blue: 94,
+            light_magenta: 95,
+            light_cyan: 96,
+            light_white: 97,
+
+            # Background Colors
+            bg_black: 40,
+            bg_red: 41,
+            bg_green: 42,
+            bg_yellow: 43,
+            bg_blue: 44,
+            bg_magenta: 45,
+            bg_cyan: 46,
+            bg_white: 47,
+            bg_default: 49,
+
+            # Light Background Colors
+            bg_light_black: 100,
+            bg_light_red: 101,
+            bg_light_green: 102,
+            bg_light_yellow: 103,
+            bg_light_blue: 104,
+            bg_light_magenta: 105,
+            bg_light_cyan: 106,
+            bg_light_white: 107,
           }.freeze
         end
       end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "key_handler"
+
+module DevSuite
+  module Utils
+    module Data
+      module PathAccess
+        module DataTraverser
+          extend self
+
+          # Traverse nested data for retrieving a value
+          def fetch(data, keys)
+            keys.reduce(data) { |current, key| traverse_data(current, key) }
+          end
+
+          # Traverse nested data for setting a value
+          def assign(data, keys, value)
+            last_key = keys.pop
+            target = keys.reduce(data) { |current, key| traverse_or_create(current, key) }
+            set_final_value(target, last_key, value)
+          end
+
+          # Traverse nested data for deleting a value
+          def remove(data, keys)
+            last_key = keys.pop
+            target = keys.reduce(data) { |current, key| traverse_data(current, key) }
+            delete_final_value(target, last_key)
+          end
+
+          private
+
+          # Traverse through hash or array data types
+          def traverse_data(current, key)
+            KeyHandler.validate_path(current, key)
+            case current
+            when Hash
+              current[KeyHandler.find_key(current, key)]
+            when Array
+              current[key.to_i]
+            else
+              raise DataStructureError, "Unexpected data type at '#{key}'"
+            end
+          end
+
+          # Traverse or create new hash elements when setting a value
+          def traverse_or_create(current, key)
+            KeyHandler.validate_path(current, key)
+            case current
+            when Hash
+              current[KeyHandler.find_key(current, key)] ||= {}
+            when Array
+              current[key.to_i] ||= {}
+            else
+              raise DataStructureError, "Unexpected data type at '#{key}'"
+            end
+          end
+
+          # Set the final value in hash or array
+          def set_final_value(target, key, value)
+            case target
+            when Hash
+              target[KeyHandler.find_key(target, key)] = value
+            when Array
+              target[key] = value if key.is_a?(Integer)
+            else
+              raise DataStructureError, "Cannot set value on unsupported data type"
+            end
+          end
+
+          # Delete the final value from hash or array
+          def delete_final_value(target, key)
+            case target
+            when Hash
+              target.delete(KeyHandler.find_key(target, key))
+            when Array
+              target.delete_at(key) if key.is_a?(Integer)
+            else
+              raise DataStructureError, "Cannot delete key from unsupported data type"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module PathAccess
+        class InvalidPathError < StandardError; end
+        class DataStructureError < StandardError; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module PathAccess
+        module KeyHandler
+          extend self
+
+          # Find an existing key in a hash, handling both symbol and string keys
+          def find_key(hash, key)
+            return key if hash.key?(key)
+            return key.to_s if hash.key?(key.to_s)
+            return key.to_sym if hash.key?(key.to_sym)
+
+            key
+          end
+
+          # Validate the path by checking if it's pointing to a valid data structure
+          def validate_path(data, key)
+            raise InvalidPathError, "Invalid path at '#{key}'" if data.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "path_parser"
+require_relative "data_traverser"
+require_relative "key_handler"
+require_relative "errors"
+
+module DevSuite
+  module Utils
+    module Data
+      module PathAccess
+        module PathAccessor
+          extend self
+
+          # Get value from nested data
+          def get(data, path)
+            keys = PathParser.parse(path)
+            DataTraverser.fetch(data, keys)
+          end
+
+          # Set value in nested data
+          def set(data, path, value)
+            keys = PathParser.parse(path)
+            DataTraverser.assign(data, keys, value)
+          end
+
+          # Delete key in nested data
+          def delete(data, path)
+            keys = PathParser.parse(path)
+            DataTraverser.remove(data, keys)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module PathAccess
+        module PathParser
+          extend self
+
+          def parse(path)
+            return path if path.is_a?(Array)
+            return parse_symbol_path(path) if path.is_a?(Symbol)
+            return parse_string_path(path) if path.is_a?(String)
+
+            [path]
+          end
+
+          private
+
+          def parse_symbol_path(symbol_path)
+            symbol_path.to_s.split(/\.|\[|\]/).reject(&:empty?).map { |part| parse_part(part) }
+          end
+
+          def parse_string_path(string_path)
+            string_path.split(/\.|\[|\]/).reject(&:empty?).map { |part| parse_part(part) }
+          end
+
+          def parse_part(part)
+            part.match?(/^\d+$/) ? part.to_i : part.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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/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.11"
+  VERSION = "0.2.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dev_suite
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.13
 platform: ruby
 authors:
 - Huy Nguyen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-27 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark
@@ -258,6 +258,11 @@ files:
 - lib/dev_suite/utils/data/base_operations.rb
 - lib/dev_suite/utils/data/data.rb
 - lib/dev_suite/utils/data/path_access.rb
+- lib/dev_suite/utils/data/path_access/data_traverser.rb
+- lib/dev_suite/utils/data/path_access/errors.rb
+- lib/dev_suite/utils/data/path_access/key_handler.rb
+- lib/dev_suite/utils/data/path_access/path_accessor.rb
+- lib/dev_suite/utils/data/path_access/path_parser.rb
 - lib/dev_suite/utils/data/search_filter.rb
 - lib/dev_suite/utils/data/serialization.rb
 - lib/dev_suite/utils/data/transformations.rb
@@ -289,6 +294,11 @@ files:
 - lib/dev_suite/utils/file_writer/writer/yaml.rb
 - lib/dev_suite/utils/file_writer/writer_manager.rb
 - lib/dev_suite/utils/logger.rb
+- lib/dev_suite/utils/logger/base.rb
+- lib/dev_suite/utils/logger/emoji.rb
+- lib/dev_suite/utils/logger/errors.rb
+- lib/dev_suite/utils/logger/formatter.rb
+- lib/dev_suite/utils/logger/logger.rb
 - lib/dev_suite/utils/path_matcher.rb
 - lib/dev_suite/utils/path_matcher/matcher.rb
 - lib/dev_suite/utils/path_matcher/path_matcher.rb