workflow_template 0.0.4

data/lib/workflow_template/adapters/validation/dry_validation/validator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/adapter/abstract/validator'
+require_relative '../../../validation/validator/result/success'
+require_relative 'failure'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module DryValidation
+        class Validator
+          extend WorkflowTemplate::Validation::Adapter::Abstract::Validator
+
+          def initialize(contract_class)
+            @contract_class = contract_class
+          end
+
+          def call(input, context: {})
+            return Failure.new(self, code: :input_null) if input.nil?
+
+            result = contract(context).call(input)
+            return WorkflowTemplate::Validation::Validator::Result::Success if result.success?
+
+            Failure.new(
+              self,
+              code: :input_invalid,
+              data: result
+            )
+          end
+
+          def describe
+            'contract to be satisfied'
+          end
+
+          private
+
+          attr_reader :contract_class
+
+          def contract(context)
+            contract_class.new(**context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/dry_validation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../validation/adapter'
+require_relative 'dry_validation/builder'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module DryValidation
+        extend WorkflowTemplate::Validation::Adapter
+
+        def self.builder_class
+          Builder
+        end
+
+        def self.result_type
+          :canonical
+        end
+
+        register(:dry_validation)
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/generic/block.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'validator'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module Generic
+        class Block < Validator
+          def initialize(block)
+            @block = block
+            super()
+          end
+
+          private
+
+          def call_foreign(object, **opts)
+            @block.call(object, **opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/generic/builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/adapter/abstract/builder'
+require_relative 'object'
+require_relative 'block'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module Generic
+        class Builder < WorkflowTemplate::Validation::Adapter::Abstract::Builder
+          class Error < WorkflowTemplate::Error; end
+
+          def validate(&block)
+            return self unless block
+
+            proxy.declare(Generic::Block.new(block))
+          end
+
+          def using(implementation)
+            validator = Generic::Object.new(implementation)
+            proxy.declare(validator)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/generic/object.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'validator'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module Generic
+        class Object < Validator
+          def initialize(object)
+            @object = object
+            super()
+          end
+
+          def describe
+            object.respond_to?(:describe) ? object.describe : super
+          end
+
+          private
+
+          attr_reader :object
+
+          def call_foreign(value, **opts)
+            object.call(value, **opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/generic/validator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/adapter/abstract/validator'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module Generic
+        class Validator
+          include WorkflowTemplate::Validation::Adapter::Abstract::Validator
+
+          def call(object, **opts)
+            call_foreign(object, **opts)
+          rescue StandardError => e
+            raise Fatal::ForeignCodeError, e
+          end
+
+          def describe
+            "#{self.class.name.split('::').last.downcase} validation"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/generic.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../validation/adapter'
+require_relative 'generic/builder'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module Generic
+        extend WorkflowTemplate::Validation::Adapter
+
+        def self.builder_class
+          Builder
+        end
+
+        def self.result_type
+          :boolean
+        end
+
+        register(:generic)
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/actions.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../../error'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      module Actions
+        class Unprepared
+          def self.instance
+            new
+          end
+
+          def initialize(simple: [], wrapper: [])
+            @unprepared_simple = simple.freeze
+            @unprepared_wrapper = wrapper.freeze
+          end
+
+          private_class_method :new
+
+          def add_simple(action, position)
+            @unprepared_simple = [*@unprepared_simple, [action, position]].freeze
+          end
+
+          def add_wrapper(action)
+            @unprepared_wrapper = [action, *@unprepared_wrapper].freeze
+          end
+
+          def prepared
+            simple = prepare_simple(existing: [])
+            wrapper = prepare_wrapper(existing: [])
+
+            Prepared.new(simple: simple, wrapper: wrapper)
+          end
+
+          protected
+
+          attr_reader :unprepared_simple, :unprepared_wrapper
+
+          def prepare_simple(existing:)
+            unprepared_simple.reduce(existing) do |existing, (action, position)|
+              position.apply_onto(existing, action)
+            end
+          end
+
+          def prepare_wrapper(existing:)
+            unprepared_wrapper + existing
+          end
+        end
+
+        class Prepared
+          attr_reader :simple, :wrapper
+
+          def initialize(simple:, wrapper:)
+            @simple = simple.freeze
+            @wrapper = wrapper.freeze
+            freeze
+          end
+
+          def merge(unprepared)
+            simple = unprepared.send(:prepare_simple, existing: self.simple)
+            wrapper = unprepared.send(:prepare_wrapper, existing: self.wrapper)
+
+            Prepared.new(simple: simple, wrapper: wrapper)
+          end
+
+          def map(&block)
+            simple_actions = simple.map(&block)
+            wrapper_actions = wrapper.map(&block)
+            self.class.new simple: simple_actions, wrapper: wrapper_actions
+          end
+
+          def next_wrapper_action
+            return [nil, self] if wrapper.empty?
+
+            action, *rest = wrapper
+            container = self.class.new(simple: simple, wrapper: rest)
+            [action, container]
+          end
+
+          def inspect
+            simple = simple().map(&:name).join(', ')
+            wrapper = wrapper().map(&:name).join(', ')
+            "#<#{self.class.name} simple=[#{simple}] wrapper=[#{wrapper}]>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/description.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../workflow/description'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      class Description
+        Workflow::Description.register(:perform, :actions) do |workflow|
+          Description.new(workflow)
+        end
+
+        attr_reader :workflow
+
+        def initialize(workflow)
+          @workflow = workflow
+          freeze
+        end
+
+        def format(level:)
+          self.class.describe(workflow).flat_map { |action| action.format(level: level) }
+        end
+
+        def self.describe(workflow)
+          describe_wrapper_actions(workflow.actions.wrapper, workflow.actions.simple)
+        end
+
+        def self.describe_wrapper_actions(wrapper_actions, simple_actions)
+          action, *rest = wrapper_actions
+          if action.nil?
+            describe_actions(simple_actions)
+          else
+            [describe_wrapper_action(action, rest, simple_actions)]
+          end
+        end
+
+        def self.describe_wrapper_action(action, rest, simple_actions)
+          nested = describe_wrapper_actions(rest, simple_actions)
+          action.describe(nested)
+        end
+
+        def self.describe_actions(actions)
+          actions.map(&:describe)
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/dsl.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../../action'
+require_relative 'insert'
+require_relative 'inside'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      module Dsl
+        def apply(action_name, **opts, &block)
+          insert_action(action_name, position: :after, **opts, &block)
+        end
+
+        alias and_then apply
+
+        def append_action(after: nil)
+          Insert.new(self, :after, after)
+        end
+
+        def prepend_action(before: nil)
+          Insert.new(self, :before, before)
+        end
+
+        def replace_action(name)
+          Insert.new(self, :at, name)
+        end
+
+        def inside_action(name, &block)
+          position = Inside.new(name, block)
+          store_action(nil, position)
+        end
+
+        def wrap_template(action_name, **opts)
+          action = Action.instance(action_name, :wrapper, **translate_action_parameters(**opts))
+          store_wrapper_action(action)
+        end
+
+        def remove_action(action_name)
+          position = Position.instance(:at, action_name)
+          store_action(nil, position)
+        end
+
+        protected
+
+        def insert_action(action_name, position: :after, reference: nil, **opts, &block)
+          action = if block.nil?
+            Action.instance(action_name, :simple, **translate_action_parameters(**opts), &block)
+          else
+            wrapper_action = Action.instance(action_name, :wrapper, **translate_action_parameters(**opts))
+            Action::Nested::Unprepared.instance(wrapper_action, Nested::Unprepared, &block)
+          end
+
+          position = Position.instance(position, reference)
+          store_action(action, position)
+        end
+
+        def translate_action_parameters(state: nil, validate: nil, **opts)
+          { state_transition_strategy: state, validates: validate, **opts }
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/insert.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      class Insert
+        def initialize(workflow, position, reference)
+          @workflow = workflow
+          @position = position
+          @reference = reference
+        end
+
+        def apply(action_name, **opts, &block)
+          @workflow.send(
+            :insert_action,
+            action_name,
+            position: @position,
+            reference: @reference,
+            **opts,
+            &block
+          )
+          @workflow = nil
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/inside.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'position'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      class Inside
+        attr_reader :reference, :block
+
+        def initialize(reference, block)
+          @reference = reference
+          @block = block
+          freeze
+        end
+
+        def apply_onto(actions, action)
+          raise Error, 'Action expected to be nil' unless action.nil?
+
+          before, action, after = Position.slice_actions(actions, reference)
+          clone = action.duplicate(&block)
+          [*before, clone, *after]
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/nested.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'redefine'
+require_relative 'description'
+require_relative 'dsl'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      module Nested
+        include HasActions
+
+        def describe
+          raise Error, "Can't describe unfrozen workflow" unless frozen?
+
+          Description.new(self)
+        end
+
+        module Unprepared
+          include Dsl
+          include Nested
+          include HasActions::Redefine
+
+          def prepare(*args)
+            unprepared = self
+
+            target = Module.new do
+              extend Prepared
+
+              define_singleton_method :unprepared do
+                unprepared
+              end
+            end
+
+            actions.wrapper.each do |action|
+              target.send :store_wrapper_action, action.prepare(*args)
+            end
+            actions.simple.each do |action|
+              position = Position.instance(:after, nil)
+              target.send :store_action, action.prepare(*args), position
+            end
+            target.freeze
+          end
+
+          def redefine(&block)
+            redefine_onto(Unprepared, &block)
+          end
+        end
+
+        module Prepared
+          include Nested
+          include Performer
+
+          def prepare(*args)
+            unprepared.prepare(*args)
+          end
+
+          def redefine(&block)
+            unprepared.redefine(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/position.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../../error'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      class Position
+        def self.instance(type, reference)
+          case type
+          when :before
+            Position::Before.new(reference)
+          when :after
+            Position::After.new(reference)
+          when :at
+            raise Error, 'Reference not expected to be nil' if reference.nil?
+
+            Position::At.new(reference)
+          else
+            raise Error, "Unexpected position: #{type}"
+          end
+        end
+
+        def self.slice_actions(actions, reference)
+          index, *rest = actions.each_index.reduce([]) do |result, index|
+            next result unless actions[index].name == reference
+
+            [*result, index]
+          end
+          raise Error, "Reference not found: #{reference}" if index.nil?
+          raise Error, "Duplicate action name: #{reference}" if rest.length.positive?
+
+          before = actions[0...index]
+          action = actions[index]
+          after = actions[(index + 1)..]
+          [before, action, after]
+        end
+
+        def initialize(reference)
+          @reference = reference&.to_sym
+          freeze
+        end
+
+        def apply_onto(actions, action)
+          if reference.nil?
+            apply_without_reference(actions, action)
+          else
+            before, reference, after = self.class.slice_actions(actions, self.reference)
+            apply_with_reference(before, action, reference, after)
+          end
+        end
+
+        attr_reader :reference
+
+        class Before < Position
+          def apply_without_reference(actions, action)
+            [action, *actions]
+          end
+
+          def apply_with_reference(before, action, reference, after)
+            [*before, action, reference, *after]
+          end
+        end
+
+        class After < Position
+          def apply_without_reference(actions, action)
+            [*actions, action]
+          end
+
+          def apply_with_reference(before, action, reference, after)
+            [*before, reference, action, *after]
+          end
+        end
+
+        class At < Position
+          def apply_with_reference(before, action, _reference, after)
+            action.nil? ? [*before, *after] : [*before, action, *after]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/redefine.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'position'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      module Redefine
+        def redefine_onto(workflow_module, &block)
+          target = Module.new do
+            extend workflow_module
+          end
+
+          actions.wrapper.each do |action|
+            target.send :store_wrapper_action, action
+          end
+          actions.simple.each do |action|
+            position = Position.instance(:after, nil)
+            target.send :store_action, action, position
+          end
+          target.instance_eval(&block)
+
+          target.freeze
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/definer/has_actions/root.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'dsl'
+
+module WorkflowTemplate
+  module Definer
+    module HasActions
+      module Root
+        include HasActions
+        include Dsl
+
+        def prepare_actions
+          actions.map { prepare_action(_1) }
+        end
+
+        def prepare_action(action)
+          action
+        end
+      end
+    end
+  end
+end