cmdx 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14a2616a171c3c514fbc553369936eac48fe2fd3d8e406cc4780ee39a483637f
-  data.tar.gz: 28d973a4973c4f2dc5e3acf1c1a09d4a0e0fbe158bc2f3553a5722acb9490051
+  metadata.gz: ef05af7473358890c311d872369f870fbaa7ff7bf2fd6d6d14cddd9c9dc80aec
+  data.tar.gz: 8e1c20c5991d453f947ed5aea44099c9c05861ad11637b27eb02bb5baea4e4f2
 SHA512:
-  metadata.gz: 363225923cd389ddca29f5580321ef3fb3efe863b08480a31b505f67ca08db260695e752631f0b58912421679bc43b52bd679c6e3a0441a8d54628f7b09d855c
-  data.tar.gz: 7d479a75b0e048e9eb7385ce31b7f3bc10512856ba9fe95b34bde5b4a833822787a087d0420a6020830fc322846d72e80604ff3706d25795cc486707d1c31726
+  metadata.gz: c59da9cc99292e6241bf9d7fabb91cc00887a6b8a4cd18950c22a495a1adfdc32a769194818944726da0e732e8fb23c842c7086d67ea451f2556a31c4f3a5ef2
+  data.tar.gz: 89d64b25f51d583605960e19d9b08b366dc4269b5c2ca07cddf562714aaf2cc4c0d9f1a06bbae42ed0ba9ed536715030c4d79dbf8c486305bd4891c331a5107d

data/CHANGELOG.md

@@ -6,10 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [TODO]
 
+## [1.6.0] - 2025-08-22
+
+### Changes
+- Rename `Worker` class to `Executor`
+- Move workflow `work` logic into `Pipeline`
+- Add workflow task `:breakpoints`
+
 ## [1.5.2] - 2025-08-22
 
 ### Changes
-- Rename the workflow `execution_groups` attribute to `pipeline`
+- Rename workflow `execution_groups` attribute to `pipeline`
 
 ## [1.5.1] - 2025-08-21
 

data/LLM.md

@@ -2794,8 +2794,7 @@ CMDx provides comprehensive internationalization support for all error messages,
 
 ## Localization
 
-> [!NOTE]
-> CMDx automatically localizes all error messages based on the `I18n.locale` setting.
+CMDx automatically localizes all error messages based on the `I18n.locale` setting.
 
 ```ruby
 class ProcessQuote < CMDx::Task
@@ -2812,6 +2811,9 @@ I18n.with_locale(:fr) do
 end
 ```
 
+> [!TIP]
+> CMDx supports 85+ locales via the [cmdx-i18n](https://github.com/drexed/cmdx-i18n) gem.
+
 ---
 
 url: https://github.com/drexed/cmdx/blob/main/docs/deprecation.md

data/docs/internationalization.md

@@ -8,8 +8,7 @@ CMDx provides comprehensive internationalization support for all error messages,
 
 ## Localization
 
-> [!NOTE]
-> CMDx automatically localizes all error messages based on the `I18n.locale` setting.
+CMDx automatically localizes all error messages based on the `I18n.locale` setting.
 
 ```ruby
 class ProcessQuote < CMDx::Task
@@ -26,6 +25,9 @@ I18n.with_locale(:fr) do
 end
 ```
 
+> [!TIP]
+> CMDx supports 85+ locales via the [cmdx-i18n](https://github.com/drexed/cmdx-i18n) gem.
+
 ---
 
 - **Prev:** [Logging](logging.md)

data/lib/cmdx/{worker.rb → executor.rb}

@@ -3,19 +3,19 @@
 module CMDx
   # Executes CMDx tasks with middleware support, error handling, and lifecycle management.
   #
-  # The Worker class is responsible for orchestrating task execution, including
+  # The Executor class is responsible for orchestrating task execution, including
   # pre-execution validation, execution with middleware, post-execution callbacks,
   # and proper error handling for different types of failures.
-  class Worker
+  class Executor
 
     attr_reader :task
 
     # @param task [CMDx::Task] The task to execute
     #
-    # @return [CMDx::Worker] A new worker instance
+    # @return [CMDx::Executor] A new executor instance
     #
     # @example
-    #   worker = CMDx::Worker.new(my_task)
+    #   executor = CMDx::Executor.new(my_task)
     def initialize(task)
       @task = task
     end
@@ -30,8 +30,8 @@ module CMDx
     # @raise [StandardError] When raise is true and execution fails
     #
     # @example
-    #   CMDx::Worker.execute(my_task)
-    #   CMDx::Worker.execute(my_task, raise: true)
+    #   CMDx::Executor.execute(my_task)
+    #   CMDx::Executor.execute(my_task, raise: true)
     def self.execute(task, raise: false)
       instance = new(task)
       raise ? instance.execute! : instance.execute
@@ -42,8 +42,8 @@ module CMDx
     # @return [CMDx::Result] The execution result
     #
     # @example
-    #   worker = CMDx::Worker.new(my_task)
-    #   result = worker.execute
+    #   executor = CMDx::Executor.new(my_task)
+    #   result = executor.execute
     def execute
       task.class.settings[:middlewares].call!(task) do
         pre_execution!
@@ -69,8 +69,8 @@ module CMDx
     # @raise [StandardError] When execution fails
     #
     # @example
-    #   worker = CMDx::Worker.new(my_task)
-    #   result = worker.execute!
+    #   executor = CMDx::Executor.new(my_task)
+    #   result = executor.execute!
     def execute!
       task.class.settings[:middlewares].call!(task) do
         pre_execution!

data/lib/cmdx/pipeline.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module CMDx
+  # Executes workflows by processing task groups with conditional logic and breakpoint handling.
+  # The Pipeline class manages the execution flow of workflow tasks, evaluating conditions
+  # and handling breakpoints that can interrupt execution at specific task statuses.
+  class Pipeline
+
+    # @return [Workflow] The workflow instance being executed
+    attr_reader :workflow
+
+    # @param workflow [Workflow] The workflow to execute
+    #
+    # @return [Pipeline] A new pipeline instance
+    #
+    # @example
+    #   pipeline = Pipeline.new(my_workflow)
+    def initialize(workflow)
+      @workflow = workflow
+    end
+
+    # Executes a workflow using a new pipeline instance.
+    #
+    # @param workflow [Workflow] The workflow to execute
+    #
+    # @return [void]
+    #
+    # @example
+    #   Pipeline.execute(my_workflow)
+    def self.execute(workflow)
+      new(workflow).execute
+    end
+
+    # Executes the workflow by processing all task groups in sequence.
+    # Each group is evaluated against its conditions, and breakpoints are checked
+    # after each task execution to determine if workflow should continue or halt.
+    #
+    # @return [void]
+    #
+    # @example
+    #   pipeline = Pipeline.new(my_workflow)
+    #   pipeline.execute
+    def execute
+      workflow.class.pipeline.each do |group|
+        next unless Utils::Condition.evaluate(workflow, group.options, workflow)
+
+        breakpoints = group.options[:breakpoints] ||
+                      workflow.class.settings[:breakpoints] ||
+                      workflow.class.settings[:workflow_breakpoints]
+        breakpoints = Array(breakpoints).map(&:to_s).uniq
+
+        execute_group_tasks(group, breakpoints)
+      end
+    end
+
+    private
+
+    # Executes tasks within a group using the configured execution strategy.
+    # Override this method to implement custom execution strategies like parallel
+    # processing or conditional task execution.
+    #
+    # @param group [ExecutionGroup] The group of tasks to execute
+    # @param breakpoints [Array<String>] Breakpoint statuses that trigger workflow interruption
+    #
+    # @return [void]
+    #
+    # @example
+    #   def execute_group_tasks(group, breakpoints)
+    #     # Custom parallel execution strategy
+    #     group.tasks.map { |task| Thread.new { task.execute(workflow.context) } }
+    #   end
+    def execute_group_tasks(group, breakpoints)
+      # NOTE: Override this method to introduce alternative execution strategies
+      execute_tasks_sequentially(group, breakpoints)
+    end
+
+    # Executes tasks sequentially within a group, checking breakpoints after each task.
+    # If a task result status matches a breakpoint, the workflow is interrupted.
+    #
+    # @param group [ExecutionGroup] The group of tasks to execute
+    # @param breakpoints [Array<String>] Breakpoint statuses that trigger workflow interruption
+    #
+    # @return [void]
+    #
+    # @raise [HaltError] When a task result status matches a breakpoint
+    #
+    # @example
+    #   execute_tasks_sequentially(group, ["failed", "skipped"])
+    def execute_tasks_sequentially(group, breakpoints)
+      group.tasks.each do |task|
+        task_result = task.execute(workflow.context)
+        next unless breakpoints.include?(task_result.status)
+
+        workflow.throw!(task_result)
+      end
+    end
+
+  end
+end

data/lib/cmdx/task.rb

@@ -200,7 +200,7 @@ module CMDx
     #   result = task.execute
     #   result = task.execute(raise: true)
     def execute(raise: false)
-      Worker.execute(self, raise:)
+      Executor.execute(self, raise:)
     end
 
     # @raise [UndefinedMethodError] Always raised as this method must be overridden

data/lib/cmdx/version.rb

@@ -2,6 +2,6 @@
 
 module CMDx
 
-  VERSION = "1.5.2"
+  VERSION = "1.6.0"
 
 end

data/lib/cmdx/workflow.rb

@@ -87,39 +87,21 @@ module CMDx
       base.extend(ClassMethods)
     end
 
-    # Executes the workflow by processing each execution group sequentially.
-    # Tasks within each group are executed based on conditional logic and breakpoint handling.
+    # Executes the workflow by processing all tasks in the pipeline.
+    # This method delegates execution to the Pipeline class which handles
+    # the processing of tasks with proper error handling and context management.
     #
-    # @return [void]
-    #
-    # @raise [CMDx::Fault] If a breakpoint is encountered during execution
-    #
-    # @example
-    #   workflow = MyWorkflow.new
-    #   workflow.work # Executes all tasks in the workflow
     # @example
-    #   class DataProcessingWorkflow
+    #   class MyWorkflow
     #     include CMDx::Workflow
-    #     task ValidateDataTask, breakpoints: [:failure]
-    #     task ProcessDataTask, breakpoints: [:halt]
-    #     task NotifyCompletionTask
+    #     task ValidateTask
+    #     task ProcessTask
     #   end
-    #   workflow = DataProcessingWorkflow.new
-    #   workflow.work # Stops on first breakpoint encountered
+    #
+    #   workflow = MyWorkflow.new
+    #   result = workflow.work
     def work
-      self.class.pipeline.each do |group|
-        next unless Utils::Condition.evaluate(self, group.options, self)
-
-        breakpoints = group.options[:breakpoints] || self.class.settings[:workflow_breakpoints]
-        breakpoints = Array(breakpoints).map(&:to_s).uniq
-
-        group.tasks.each do |task|
-          task_result = task.execute(context)
-          next unless breakpoints.include?(task_result.status)
-
-          throw!(task_result)
-        end
-      end
+      Pipeline.execute(self)
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cmdx
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Juan Gomez
@@ -235,6 +235,7 @@ files:
 - lib/cmdx/deprecator.rb
 - lib/cmdx/errors.rb
 - lib/cmdx/exceptions.rb
+- lib/cmdx/executor.rb
 - lib/cmdx/faults.rb
 - lib/cmdx/freezer.rb
 - lib/cmdx/identifier.rb
@@ -248,6 +249,7 @@ files:
 - lib/cmdx/middlewares/correlate.rb
 - lib/cmdx/middlewares/runtime.rb
 - lib/cmdx/middlewares/timeout.rb
+- lib/cmdx/pipeline.rb
 - lib/cmdx/railtie.rb
 - lib/cmdx/result.rb
 - lib/cmdx/task.rb
@@ -262,7 +264,6 @@ files:
 - lib/cmdx/validators/numeric.rb
 - lib/cmdx/validators/presence.rb
 - lib/cmdx/version.rb
-- lib/cmdx/worker.rb
 - lib/cmdx/workflow.rb
 - lib/generators/cmdx/install_generator.rb
 - lib/generators/cmdx/task_generator.rb