dev_suite 0.2.7 → 0.2.10

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Config
+        class Configuration < Utils::Construct::Config::Base
+          set_default_settings(
+            driver: {
+              file: {
+                path: "#{Dir.pwd}/tmp/store.json",
+              },
+            },
+          )
+
+          config_attr :driver,
+            default_value: :memory,
+            type: :symbol,
+            resolver: :resolve_driver
+
+          private
+
+          def resolve_driver(value)
+            Driver.build_component(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Config
+        require_relative "config/config"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Driver
+        class Base < Construct::Component::Base
+          def set(key, value)
+            raise NotImplementedError, "Subclasses must implement the `set` method"
+          end
+
+          def fetch(key)
+            raise NotImplementedError, "Subclasses must implement the `fetch` method"
+          end
+
+          def delete(key)
+            raise NotImplementedError, "Subclasses must implement the `delete` method"
+          end
+
+          def import(source)
+            raise NotImplementedError, "Subclasses must implement the `import` method"
+          end
+
+          def export(destination)
+            raise NotImplementedError, "Subclasses must implement the `export` method"
+          end
+
+          def clear
+            raise NotImplementedError, "Subclasses must implement the `clear` method"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Driver
+        include Construct::Component::Manager
+
+        require_relative "base"
+        require_relative "file"
+        require_relative "memory"
+
+        register_component(File)
+        register_component(Memory)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Driver
+        class File < Base
+          def initialize(**options)
+            super()
+            @path = options[:path] || fetch_setting(:path, default: "tmp/store.json")
+            @data = {}
+            load_data
+          end
+
+          def set(key, value)
+            Data.set_value_by_path(@data, key, value)
+            save_data
+          end
+
+          def fetch(key)
+            Data.get_value_by_path(@data, key)
+          end
+
+          def delete(key)
+            Data.delete_key_by_path(@data, key)
+            save_data
+          end
+
+          def clear
+            @data = {}
+            save_data
+          end
+
+          def import(source)
+            raise ArgumentError, "The file does not exist" unless ::File.exist?(source)
+
+            @data = FileLoader.load(source)
+          end
+
+          def export(destination)
+            FileWriter.write(destination, @data)
+          end
+
+          private
+
+          def load_data
+            @data = FileLoader.load(@path) if ::File.exist?(@path)
+          end
+
+          def save_data
+            FileWriter.write(@path, @data)
+          end
+
+          def fetch_setting(key, default: nil)
+            Config.configuration.settings.get(key, default: default)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Driver
+        class Memory < Base
+          def initialize
+            super
+            @data = {}
+          end
+
+          def set(key, value)
+            Data.set_value_by_path(@data, key, value)
+          end
+
+          def fetch(key)
+            Data.get_value_by_path(@data, key)
+          end
+
+          def delete(key)
+            Data.delete_key_by_path(@data, key)
+          end
+
+          def clear
+            @data.clear
+          end
+
+          def import(source)
+            raise ArgumentError, "The file does not exist" unless ::File.exist?(source)
+
+            @data = FileLoader.load(source)
+          end
+
+          def export(destination)
+            FileWriter.write(destination, @data)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      module Driver
+        require_relative "driver/driver"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Store
+      require_relative "config"
+      require_relative "driver"
+
+      class Store
+        def initialize(**options)
+          @driver = initialize_driver(**options)
+        end
+
+        def set(key, value)
+          @driver.set(key, value)
+        end
+
+        def fetch(key)
+          @driver.fetch(key)
+        end
+
+        def delete(key)
+          @driver.delete(key)
+        end
+
+        def import(source)
+          @driver.import(source)
+        end
+
+        def export(destination)
+          @driver.export(destination)
+        end
+
+        def clear
+          @driver.clear
+        end
+
+        private
+
+        def initialize_driver(**options)
+          return Config.configuration.driver unless options.key?(:driver)
+
+          build_driver(options)
+        end
+
+        def build_driver(options)
+          Driver.build_component(options.fetch(:driver), **options.except(:driver))
+        end
+      end
+
+      class << self
+        # Retrieve the singleton store instance
+        def instance
+          @store ||= Store.new
+        end
+
+        # Reset the singleton store instance
+        def reset!
+          @store = nil
+        end
+
+        # Create a new store instance (isolated from the singleton)
+        def create(**options)
+          Store.new(**options)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/store.rb

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

data/lib/dev_suite/utils/utils.rb

@@ -2,14 +2,26 @@
 
 module DevSuite
   module Utils
+    PATH = "dev_suite/utils"
+
+    # Load essential modules immediately because they are critical for
+    # application startup and early functionality.
     require_relative "emoji"
     require_relative "logger"
+    require_relative "data"
     require_relative "error_handler"
+    require_relative "warning_handler"
     require_relative "dependency_loader"
-    require_relative "construct"
-    require_relative "color"
-    require_relative "table"
-    require_relative "file_loader"
-    require_relative "path_matcher"
+
+    # Core utilities
+    autoload :Construct, "#{PATH}/construct"
+
+    # Functional utilities
+    autoload :Store, "#{PATH}/store"
+    autoload :Color, "#{PATH}/color"
+    autoload :Table, "#{PATH}/table"
+    autoload :FileLoader, "#{PATH}/file_loader"
+    autoload :FileWriter, "#{PATH}/file_writer"
+    autoload :PathMatcher, "#{PATH}/path_matcher"
   end
 end

data/lib/dev_suite/utils/warning_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module WarningHandler
+      extend self
+
+      def warn_if_missing(attribute_name, value)
+        if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+          log_warning("#{attribute_name} is missing or empty!")
+        end
+      end
+
+      private
+
+      def log_warning(message)
+        Utils::Logger.log(
+          message,
+          level: :warn,
+          emoji: :warning,
+        )
+      end
+    end
+  end
+end

data/lib/dev_suite/version.rb

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

data/lib/dev_suite/workflow/engine.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    class Engine
+      attr_reader :steps, :context
+
+      def initialize(initial_context = {}, **options)
+        @steps = []
+        @context = StepContext.new(initial_context, **options)
+      end
+
+      # Add steps to the engine
+      def step(step)
+        @steps << step
+        self # Return the current engine instance to support chaining
+      end
+
+      # Execute the workflow
+      def execute
+        @steps.each do |step|
+          step.run(@context)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/step/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      class Base < Utils::Construct::Component::Base
+        attr_accessor :name, :next_step
+
+        def initialize(name:, &action)
+          super()
+          @name = name
+          @action = action
+          @next_step = nil
+        end
+
+        # Executes the step and moves to the next step
+        def run(context)
+          result = perform_action(context)
+          Utils::Logger.log("Step: #{@name} - Result: #{result}", level: :info)
+
+          # If the result is nil or false, stop execution chain
+          return unless result
+
+          update_context(context, result)
+          run_next_step(context)
+        end
+
+        # Chain the next step
+        def next(step)
+          @next_step = step
+          step
+        end
+
+        private
+
+        # Perform the action associated with this step
+        def perform_action(context)
+          @action.call(context)
+        rescue StandardError => e
+          Utils::Logger.log("Step: #{@name} - Error: #{e}", level: :error)
+          false
+        end
+
+        # Update the context with the result of the action (without clearing it)
+        def update_context(context, result)
+          context.update(result)
+        end
+
+        # Execute the next step if it exists
+        def run_next_step(context)
+          @next_step&.run(context)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/step/composite.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      class Composite < Base
+        def initialize(name:)
+          super
+          @steps = []
+        end
+
+        # Add steps to the composite
+        def step(step)
+          @steps << step
+          self
+        end
+
+        # Override execute to run all steps in sequence
+        def run(context)
+          @steps.each do |step|
+            step.run(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/step/conditional.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      class Conditional < Base
+        def initialize(name:, condition:, &action)
+          super(name: name, &action)
+          @condition = condition
+        end
+
+        # Only execute if the condition is met
+        def run(context)
+          if @condition.call(context)
+            super
+          else
+            Utils::Logger.log("Step: #{@name} - Skipped due to condition", level: :info)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/step/loop.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      class Loop < Base
+        def initialize(name:, iterations:, &action)
+          super(name: name, &action)
+          @iterations = iterations
+        end
+
+        def run(context)
+          @iterations.times do |i|
+            Utils::Logger.log("Step: #{@name} - Iteration: #{i + 1}", level: :info)
+            super(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/step/parallel.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      class Parallel < Base
+        # Executes multiple tasks in parallel using threads
+        def run(context)
+          tasks = @action.call(context)
+          threads = tasks.map do |task|
+            Thread.new { task.call(context) }
+          end
+          threads.each(&:join)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/step/step.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      include Utils::Construct::Component::Manager
+
+      require_relative "base"
+      require_relative "composite"
+      require_relative "conditional"
+      require_relative "loop"
+      require_relative "parallel"
+
+      register_component Base
+      register_component Composite
+      register_component Conditional
+      register_component Loop
+      register_component Parallel
+    end
+  end
+end

data/lib/dev_suite/workflow/step.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    module Step
+      require_relative "step/step"
+    end
+  end
+end

data/lib/dev_suite/workflow/step_context.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    class StepContext
+      attr_reader :data, :store
+
+      def initialize(data = {}, **options)
+        @data = data
+        @store = create_store(options)
+      end
+
+      # Update the context with new data
+      def update(new_data)
+        unless new_data.is_a?(Hash) || new_data.is_a?(Array)
+          raise ArgumentError, "New data must be a Hash"
+        end
+
+        Utils::Data.deep_merge!(@data, new_data)
+      end
+
+      # Set data by key
+      def set(key, value)
+        Utils::Data.set_value_by_path(@data, key, value)
+      end
+
+      # Retrieve data by key
+      def get(key)
+        Utils::Data.get_value_by_path(@data, key)
+      end
+
+      # Clear the context data
+      def clear
+        @data.clear # Reset the context data
+      end
+
+      private
+
+      def create_store(options)
+        driver = options[:driver] || :file
+        path = options[:path]
+        Utils::Store.create(driver: driver, path: path)
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow/workflow.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    require_relative "step_context"
+    require_relative "step"
+    require_relative "engine"
+
+    class << self
+      def create_engine(context = {}, **options)
+        Engine.new(context, **options)
+      end
+
+      def create_step(name, type: :base, **args, &block)
+        Step.build_component(type, name: name, **args, &block)
+      end
+
+      def create_base_step(name, &block)
+        create_step(name, type: :base, &block)
+      end
+
+      def create_parallel_step(name, &block)
+        create_step(name, type: :parallel, &block)
+      end
+
+      def create_conditional_step(name, condition:, &block)
+        create_step(name, type: :conditional, condition: condition, &block)
+      end
+
+      def create_loop_step(name, iterations:, &block)
+        create_step(name, type: :loop, iterations: iterations, &block)
+      end
+
+      def create_composite_step(name)
+        create_step(name, type: :composite)
+      end
+    end
+  end
+end

data/lib/dev_suite/workflow.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Workflow
+    require_relative "workflow/workflow"
+  end
+end