standard_procedure_operations 0.5.3 → 0.7.0

data/app/models/operations/task/data_carrier.rb

@@ -1,18 +0,0 @@
-class Operations::Task::DataCarrier < OpenStruct
-  def fail_with(message) = task.fail_with(message)
-
-  def call(sub_task_class, **data, &result_handler) = task.call(sub_task_class, **data, &result_handler)
-
-  def start(sub_task_class, **data, &result_handler) = task.start(sub_task_class, **data, &result_handler)
-
-  def go_to(state, data = nil) = task.go_to state, data || self
-
-  def complete(results) = task.complete(results)
-
-  def inputs(*names)
-    missing_inputs = (names.map(&:to_sym) - to_h.keys)
-    raise ArgumentError.new("Missing inputs: #{missing_inputs.join(", ")}") if missing_inputs.any?
-  end
-
-  def optional(*names) = nil
-end

data/app/models/operations/task/deletion.rb

@@ -1,17 +0,0 @@
-module Operations::Task::Deletion
-  extend ActiveSupport::Concern
-
-  included do
-    scope :for_deletion, -> { where(delete_at: ..Time.now.utc) }
-    attribute :delete_at, :datetime, default: -> { deletes_after.from_now.utc }
-    validates :delete_at, presence: true
-  end
-
-  class_methods do
-    def delete_after(value) = @@deletes_after = value
-
-    def deletes_after = @@deletes_after ||= 90.days
-
-    def delete_expired = for_deletion.destroy_all
-  end
-end

data/app/models/operations/task/exports.rb

@@ -1,45 +0,0 @@
-module Operations::Task::Exports
-  extend ActiveSupport::Concern
-  class_methods do
-    # Returns a hash representation of the task's structure
-    # Useful for exporting to different formats (e.g., GraphViz)
-    def to_h
-      {name: name, initial_state: initial_state, inputs: required_inputs, optional_inputs: optional_inputs, states: state_handlers.transform_values { |handler| handler_to_h(handler) }}
-    end
-
-    def handler_to_h(handler)
-      case handler
-      when Operations::Task::StateManagement::DecisionHandler
-        {type: :decision, transitions: decision_transitions(handler), inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      when Operations::Task::StateManagement::ActionHandler
-        {type: :action, next_state: handler.next_state, inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      when Operations::Task::StateManagement::WaitHandler
-        {type: :wait, transitions: wait_transitions(handler), inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      when Operations::Task::StateManagement::CompletionHandler
-        {type: :result, inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      else
-        {type: :unknown}
-      end
-    end
-
-    def extract_inputs(handler)
-      handler.instance_variable_defined?(:@required_inputs) ? handler.instance_variable_get(:@required_inputs) : []
-    end
-
-    def extract_optional_inputs(handler)
-      handler.instance_variable_defined?(:@optional_inputs) ? handler.instance_variable_get(:@optional_inputs) : []
-    end
-
-    def decision_transitions(handler)
-      if handler.instance_variable_defined?(:@true_state) && handler.instance_variable_defined?(:@false_state)
-        {"true" => handler.instance_variable_get(:@true_state), "false" => handler.instance_variable_get(:@false_state)}
-      else
-        handler.instance_variable_get(:@destinations).map.with_index { |dest, i| [:"condition_#{i}", dest] }.to_h
-      end
-    end
-
-    def wait_transitions(handler)
-      handler.instance_variable_get(:@destinations).map.with_index { |dest, i| [:"condition_#{i}", dest] }.to_h
-    end
-  end
-end

data/app/models/operations/task/input_validation.rb

@@ -1,17 +0,0 @@
-module Operations::Task::InputValidation
-  def inputs(*names) = @required_inputs = names.map(&:to_sym)
-
-  def optional(*names) = @optional_inputs = names.map(&:to_sym)
-
-  def optional_inputs = @optional_inputs ||= []
-
-  def required_inputs = @required_inputs ||= []
-
-  def required_inputs_are_present_in?(hash) = missing_inputs_from(hash).empty?
-
-  def missing_inputs_from(hash) = (required_inputs - hash.keys.map(&:to_sym))
-
-  def validate_inputs! hash
-    raise ArgumentError, "Missing inputs: #{missing_inputs_from(hash).join(", ")}" unless required_inputs_are_present_in?(hash)
-  end
-end

data/app/models/operations/task/state_management/action_handler.rb

@@ -1,17 +0,0 @@
-class Operations::Task::StateManagement::ActionHandler
-  attr_accessor :next_state
-
-  def initialize name, &action
-    @name = name.to_sym
-    @required_inputs = []
-    @optional_inputs = []
-    @action = action
-    @next_state = nil
-  end
-
-  def call(task, data)
-    data.instance_exec(&@action).tap do |result|
-      data.go_to @next_state unless @next_state.nil?
-    end
-  end
-end

data/app/models/operations/task/state_management/completion_handler.rb

@@ -1,14 +0,0 @@
-class Operations::Task::StateManagement::CompletionHandler
-  def initialize name, inputs = [], optional = [], &handler
-    @name = name.to_sym
-    @required_inputs = inputs
-    @optional_inputs = optional
-    @handler = handler
-  end
-
-  def call(task, data)
-    results = OpenStruct.new
-    data.instance_exec(results, &@handler) unless @handler.nil?
-    data.complete(results)
-  end
-end

data/app/models/operations/task/state_management/decision_handler.rb

@@ -1,49 +0,0 @@
-class Operations::Task::StateManagement::DecisionHandler
-  include Operations::Task::InputValidation
-
-  def initialize name, &config
-    @name = name.to_sym
-    @conditions = []
-    @destinations = []
-    @true_state = nil
-    @false_state = nil
-    instance_eval(&config)
-  end
-
-  def condition(destination = nil, options = {}, &condition)
-    @conditions << condition
-    @destinations << destination if destination
-    @condition_labels ||= {}
-    condition_index = @conditions.size - 1
-    @condition_labels[condition_index] = options[:label] if options[:label]
-  end
-
-  def go_to(destination) = @destinations << destination
-
-  def condition_labels
-    @condition_labels ||= {}
-  end
-
-  def if_true(state = nil, &handler) = @true_state = state || handler
-
-  def if_false(state = nil, &handler) = @false_state = state || handler
-
-  def call(task, data)
-    validate_inputs! data.to_h
-    has_true_false_handlers? ? handle_single_condition(task, data) : handle_multiple_conditions(task, data)
-  end
-
-  private def has_true_false_handlers? = !@true_state.nil? || !@false_state.nil?
-
-  private def handle_single_condition(task, data)
-    next_state = data.instance_eval(&@conditions.first) ? @true_state : @false_state
-    next_state.respond_to?(:call) ? data.instance_eval(&next_state) : data.go_to(next_state, data)
-  end
-
-  private def handle_multiple_conditions(task, data)
-    condition = @conditions.find { |condition| data.instance_eval(&condition) }
-    raise Operations::NoDecision.new("No conditions matched #{@name}") if condition.nil?
-    index = @conditions.index condition
-    data.go_to(@destinations[index])
-  end
-end

data/app/models/operations/task/state_management.rb

@@ -1,39 +0,0 @@
-module Operations::Task::StateManagement
-  extend ActiveSupport::Concern
-
-  included do
-    attribute :state, :string
-    validate :state_is_valid
-  end
-
-  class_methods do
-    def starts_with(value) = @initial_state = value.to_sym
-
-    def initial_state = @initial_state
-
-    def decision(name, &config) = state_handlers[name.to_sym] = DecisionHandler.new(name, &config)
-
-    def action(name, &handler) = state_handlers[name.to_sym] = ActionHandler.new(name, &handler)
-
-    def wait_until(name, &config) = state_handlers[name.to_sym] = WaitHandler.new(name, &config)
-
-    def result(name, inputs: [], optional: [], &results) = state_handlers[name.to_sym] = CompletionHandler.new(name, inputs, optional, &results)
-
-    def go_to(state)
-      # Get the most recently defined action handler
-      last_action = state_handlers.values.reverse.find { |h| h.is_a?(ActionHandler) }
-      raise ArgumentError, "No action handler defined yet" unless last_action
-
-      last_action.next_state = state.to_sym
-    end
-
-    def state_handlers = @state_handlers ||= {}
-
-    def handler_for(state) = state_handlers[state.to_sym]
-  end
-
-  private def handler_for(state) = self.class.handler_for(state.to_sym)
-  private def state_is_valid
-    errors.add :state, :invalid if state.blank? || handler_for(state.to_sym).nil?
-  end
-end

data/app/models/operations/task/testing.rb

@@ -1,62 +0,0 @@
-module Operations::Task::Testing
-  extend ActiveSupport::Concern
-
-  class_methods do
-    def handling state, background: false, **data, &block
-      # Create a task specifically for testing - avoid serialization issues
-      task = new(state: state, background: background)
-      # Use our own test-specific data carrier so we can examine results
-      data = TestResultCarrier.new(data.merge(task: task))
-
-      # Testing doesn't use the database, so handle serialization by overriding task's go_to
-      # to avoid serialization errors
-      def task.go_to(state, data = {}, message: nil)
-        self.state = state
-        # Don't call super to avoid serialization
-      end
-
-      handler_for(state).call(task, data)
-      data.completion_results.nil? ? block.call(data) : block.call(data.completion_results)
-    end
-  end
-
-  # Instead of extending DataCarrier (which no longer has go_to),
-  # create a new class with similar functionality but keeps the go_to method for testing
-  class TestResultCarrier < Operations::Task::DataCarrier
-    def go_to(state, message = nil)
-      self.next_state = state
-      self.status_message = message || next_state.to_s
-    end
-
-    def fail_with(message)
-      self.failure_message = message
-    end
-
-    def inputs(*names)
-      missing_inputs = (names.map(&:to_sym) - to_h.keys)
-      raise ArgumentError.new("Missing inputs: #{missing_inputs.join(", ")}") if missing_inputs.any?
-    end
-
-    def optional(*names) = nil
-
-    def call(sub_task_class, **data, &result_handler)
-      record_sub_task sub_task_class
-      super
-    end
-
-    def start(sub_task_class, **data, &result_handler)
-      record_sub_task sub_task_class
-      # Just record the sub_task for testing, don't actually start it
-      nil
-    end
-
-    def complete(results)
-      self.completion_results = results
-    end
-
-    private def record_sub_task sub_task_class
-      self.sub_tasks ||= []
-      self.sub_tasks << sub_task_class
-    end
-  end
-end

data/db/migrate/20250127160616_create_operations_tasks.rb

@@ -1,17 +0,0 @@
-class CreateOperationsTasks < ActiveRecord::Migration[7.1]
-  def change
-    create_table :operations_tasks do |t|
-      t.string :type
-      t.integer :status, default: 0, null: false
-      t.string :state, null: false
-      t.string :status_message, default: "", null: false
-      t.text :data
-      t.text :results
-      t.boolean :background, default: false, null: false
-      t.datetime :delete_at, null: false, index: true
-      t.timestamps
-    end
-
-    add_index :operations_tasks, [:type, :status]
-  end
-end

data/db/migrate/20250309160616_create_operations_task_participants.rb

@@ -1,15 +0,0 @@
-class CreateOperationsTaskParticipants < ActiveRecord::Migration[7.1]
-  def change
-    create_table :operations_task_participants do |t|
-      t.references :task, null: false, foreign_key: {to_table: :operations_tasks}
-      t.references :participant, polymorphic: true, null: false
-      t.string :role, null: false
-      t.string :context, null: false, default: "data"
-      t.timestamps
-    end
-
-    add_index :operations_task_participants, [:task_id, :participant_type, :participant_id, :role, :context],
-      name: "index_operations_task_participants_on_full_identity",
-      unique: true
-  end
-end

data/db/migrate/20250403075414_add_becomes_zombie_at_field.rb

@@ -1,6 +0,0 @@
-class AddBecomesZombieAtField < ActiveRecord::Migration[8.0]
-  def change
-    add_column :operations_tasks, :becomes_zombie_at, :datetime, null: true
-    add_index :operations_tasks, :becomes_zombie_at
-  end
-end

data/lib/operations/cannot_wait_in_foreground.rb

@@ -1,2 +0,0 @@
-class Operations::CannotWaitInForeground < Operations::Error
-end