workflow_template 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d667870c842a4893938a5e8c16d15a25dc93b34a5abac6d0bac3edb406508712
+  data.tar.gz: afdd0e2bfc21078e170220e8b94e60d6b5b0a9bccd66c212f7f28bdf82b59c24
+SHA512:
+  metadata.gz: 95110fcbdecc896edb5e991ce6f02fcc8f3ee6f72ada962ab90dfdad469c3fdc9a23f7d4c2e04b112a9b9fcf416195ee035676cc046125203c3ac1acbfa70b56
+  data.tar.gz: 6768412262225de5d9df7ea6ab85cb294a6c3dedee3a7f34b6630e2c27c736379de6c5f5daa893e9de1ec56c8e04145eb43a94123cc75c407200444de8b68c0c

data/lib/workflow_template/action/abstract.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module WorkflowTemplate
+  module Action
+    module Abstract
+      module Prepared
+        include Abstract
+
+        def perform(state, receiver)
+          raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+        end
+      end
+
+      module Named
+        include Abstract
+
+        attr_reader :name
+
+        def initialize(name)
+          @name = name.to_sym
+          freeze
+        end
+      end
+
+      module Unprepared
+        include Named
+      end
+
+      def describe
+        raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+      end
+
+      def prepare(*)
+        raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+      end
+    end
+  end
+end

data/lib/workflow_template/action/description/validated.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Action
+    module Description
+      class Validated
+        def self.instance(action)
+          new action
+        end
+
+        private_class_method :new
+
+        attr_reader :action
+
+        def initialize(action)
+          @action = action
+          freeze
+        end
+
+        def format(level:)
+          ["#{'  ' * level}#{self.class.describe(action)}"]
+        end
+
+        def self.describe(action)
+          extras = [
+            describe_defaults(action),
+            describe_validations(action),
+            describe_state_transition_strategy(action)
+          ].compact
+          return action.name if extras.empty?
+
+          "#{action.name} #{extras.join(', ')}"
+        end
+
+        def self.describe_defaults(action)
+          hash = action.defaults
+          return if hash.nil? || hash.empty?
+
+          "defaults: { #{hash.map { |key, value| "#{key}: #{value}" }.join(', ')} }"
+        end
+
+        def self.describe_validations(action)
+          case action.validates
+          when nil then nil
+          when Array then "validates: #{action.validates.join(', ')}" unless action.validates.empty?
+          else "validates: #{action.validates}"
+          end
+        end
+
+        def self.describe_state_transition_strategy(action)
+          return if action.state_transition_strategy.nil?
+
+          "state: #{action.state_transition_strategy}"
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/action/description/wrapper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'validated'
+
+module WorkflowTemplate
+  module Action
+    module Description
+      class Wrapper < Validated
+        def self.instance(action, nested_actions)
+          new action, nested_actions
+        end
+
+        private_class_method :new
+
+        attr_reader :action, :nested_actions
+
+        def initialize(action, nested_actions)
+          @nested_actions = nested_actions.freeze
+          super(action)
+        end
+
+        def format(level:)
+          super + nested_actions.flat_map { |nested_action| nested_action.format(level: level + 1) }
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/action/nested.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'abstract'
+
+module WorkflowTemplate
+  module Action
+    module Nested
+      class Unprepared
+        include Action::Abstract::Unprepared
+        include Nested
+
+        def self.instance(wrapper_action, workflow_module, &block)
+          workflow = Module.new do
+            extend workflow_module
+
+            instance_eval(&block)
+            send :store_wrapper_action, wrapper_action
+
+            freeze
+          end
+
+          new(wrapper_action.name, workflow)
+        end
+
+        private_class_method :new
+      end
+
+      class Prepared
+        extend Forwardable
+        include Action::Abstract::Named
+        include Action::Abstract::Prepared
+        include Nested
+
+        def_delegator :@workflow, :perform
+      end
+
+      def initialize(name, workflow)
+        @workflow = workflow
+        super(name)
+      end
+
+      def duplicate(&block)
+        duplicate = @workflow.redefine(&block)
+
+        Unprepared.send(:new, name, duplicate)
+      end
+
+      def prepare(*args)
+        prepared = @workflow.prepare(*args)
+        Prepared.send(:new, name, prepared)
+      end
+
+      def describe
+        @workflow.describe
+      end
+    end
+  end
+end

data/lib/workflow_template/action/simple.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'validated'
+
+module WorkflowTemplate
+  module Action
+    module Simple
+      class Unprepared < Validated::Unprepared
+        def prepare(validations)
+          Prepared.instance(self, validations)
+        end
+      end
+
+      class Prepared < Validated::Prepared
+        private
+
+        def invoke_validated(state, receiver)
+          result = invoke_method(state, receiver)
+          state.process_wrapped_result(result, self, trace: true, validate: true)
+        end
+
+        def handle_standard_error(error, state)
+          state.merge_error(error, self)
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/action/validated.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'abstract'
+require_relative 'description/validated'
+
+module WorkflowTemplate
+  module Action
+    module Validated
+      class Unprepared
+        include Abstract::Unprepared
+
+        def self.normalize_validation_names(option)
+          return if option.nil?
+          return option.map(&:to_sym).freeze if option.is_a?(Array)
+
+          option.to_sym.freeze
+        end
+
+        attr_reader :defaults, :validates, :state_transition_strategy
+
+        def initialize(name, defaults: nil, validates: nil, state_transition_strategy: nil)
+          @defaults = defaults.freeze
+          @validates = self.class.normalize_validation_names(validates)
+
+          unless state_transition_strategy.nil?
+            @state_transition_strategy = State.normalize_transition_strategy(state_transition_strategy)
+          end
+          super(name)
+        end
+
+        def prepare(*args)
+          raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+        end
+
+        def describe
+          Description::Validated.instance(self)
+        end
+      end
+
+      class Prepared
+        include Abstract::Prepared
+        extend Forwardable
+
+        FATAL_SUBCLASSES = Fatal.constants.map { |name| Fatal.const_get(name) }.freeze
+
+        def_delegators :unprepared, :defaults
+        def_delegators :unprepared, :describe
+        def_delegators :unprepared, :name
+        def_delegators :unprepared, :state_transition_strategy
+        def_delegators :unprepared, :validates
+
+        def self.instance(unprepared, validations)
+          new unprepared, validations.resolve_validations(unprepared.validates)
+        end
+
+        def initialize(unprepared, validations)
+          @unprepared = unprepared
+          @validations = validations
+          freeze
+        end
+
+        private_class_method :new
+
+        def prepare(validations)
+          self.class.instance(unprepared, validations)
+        end
+
+        attr_reader :unprepared, :validations
+
+        def perform(state, receiver, &block)
+          invoke_validated(state, receiver, &block)
+        rescue *FATAL_SUBCLASSES
+          raise
+        rescue Fatal => e
+          detailed = Fatal::Detailed.new(name, state.bare_state, e.message)
+          raise detailed
+        rescue ArgumentError => e
+          invocation = method(:invoke_validated)
+          raise Fatal::ArgumentError.new(name, e.message) if Fatal::ArgumentError.depth(e, invocation) == 2
+
+          handle_standard_error(e, state)
+        rescue StandardError => e
+          handle_standard_error(e, state)
+        end
+
+        private
+
+        def invoke_method(state, receiver, &block)
+          raise Fatal::Unimplemented, name unless receiver.respond_to? name
+
+          input = with_defaults(state.bare_state)
+          receiver.send(name, **input, &block)
+        end
+
+        def with_defaults(input)
+          return input if defaults.nil?
+
+          defaults.merge(input)
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/action/wrapper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'validated'
+require_relative 'description/wrapper'
+
+module WorkflowTemplate
+  module Action
+    module Wrapper
+      class Unprepared < Validated::Unprepared
+        def prepare(validations)
+          Prepared.instance(self, validations)
+        end
+
+        def describe(nested_actions)
+          Description::Wrapper.instance(self, nested_actions)
+        end
+      end
+
+      class Prepared < Validated::Prepared
+        private
+
+        def invoke_validated(state, receiver, *, &block)
+          invoke_method state, receiver, &block
+        end
+
+        def handle_standard_error(error, state, *, **)
+          state.class.wrap_error_with_bare_state(error, {})
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/action.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action/simple'
+require_relative 'action/wrapper'
+require_relative 'action/nested'
+
+module WorkflowTemplate
+  module Action
+    def self.instance(name, type, **opts)
+      case type
+      when :simple
+        Simple::Unprepared.new(name, **opts)
+      when :wrapper
+        Wrapper::Unprepared.new(name, **opts)
+      else
+        raise Error, "Unimplemented action type: #{type}"
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/state/default.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../../state/adapter'
+require_relative '../../state/validation'
+
+module WorkflowTemplate
+  module Adapters
+    module State
+      module Default
+        module InstanceMethods
+          include WorkflowTemplate::State::Adapter::Abstract::InstanceMethods
+
+          # Optimizations
+
+          def halted?
+            !!wrapped_state[:halted]
+          end
+
+          def error?
+            !!wrapped_state[:error]
+          end
+        end
+
+        module ClassMethods
+          include WorkflowTemplate::State::Adapter::Abstract::ClassMethods
+
+          def canonical?(wrapped_state)
+            wrapped_state.is_a? Hash
+          end
+
+          def error?(wrapped_state)
+            !!wrapped_state[:error]
+          end
+
+          def wrap_success(bare_state)
+            bare_state
+          end
+
+          def unwrap_success(wrapped_state)
+            wrapped_state
+          end
+
+          def wrap_error_with_bare_state(error, bare_state)
+            { **bare_state, error: error }
+          end
+
+          def unwrap_error(wrapped_state)
+            wrapped_state[:error]
+          end
+
+          def map_unwrappable_state(wrapped_state)
+            yield wrapped_state
+          end
+
+          def flat_map_unwrappable_state(wrapped_state)
+            yield wrapped_state
+          end
+
+          def run_handler!(state, binding, &block)
+            if binding
+              binding.receiver.instance_exec(**state.bare_state, &block)
+            else
+              block.call(**state.bare_state)
+            end
+          end
+        end
+
+        WorkflowTemplate::State::Adapter.register :default, self
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/state/dry_monads.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+require_relative '../../state/adapter'
+
+module WorkflowTemplate
+  module Adapters
+    module State
+      module DryMonads
+        module Handler
+          extend Dry::Monads[:result]
+        end
+
+        module InstanceMethods
+          include WorkflowTemplate::State::Adapter::Abstract::InstanceMethods
+        end
+
+        module ClassMethods
+          include WorkflowTemplate::State::Adapter::Abstract::ClassMethods
+
+          def canonical?(wrapped_state)
+            wrapped_state.is_a? Dry::Monads::Result
+          end
+
+          def error?(wrapped_state)
+            wrapped_state.failure?
+          end
+
+          def wrap_success(bare_state)
+            Dry::Monads::Success(bare_state)
+          end
+
+          def unwrap_success(wrapped_state)
+            raise Fatal::InconsistentState, "Expected Success, got #{wrapped_state}" unless wrapped_state.success?
+
+            wrapped_state.success
+          end
+
+          def wrap_error_with_bare_state(error, _bare_state)
+            Dry::Monads::Failure(error)
+          end
+
+          def unwrap_error(wrapped_state)
+            raise Fatal::InconsistentState, "Expected Failure, got #{wrapped_state}" unless wrapped_state.failure?
+
+            wrapped_state.failure
+          end
+
+          def map_unwrappable_state(wrapped_state, &block)
+            wrapped_state.fmap(&block)
+          end
+
+          def flat_map_unwrappable_state(wrapped_state, &block)
+            wrapped_state.bind(&block)
+          end
+
+          def run_handler!(state, _binding, &block)
+            if state.error?
+              state.wrapped_state.or { Handler.instance_exec(state.error, &block) }
+            else
+              state.wrapped_state.bind { Handler.instance_exec(**state.bare_state, &block) }
+            end
+          end
+        end
+
+        WorkflowTemplate::State::Adapter.register(:dry_monads, self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/adapter/abstract/builder'
+require_relative 'validator'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module ActiveModel
+        class Builder < WorkflowTemplate::Validation::Adapter::Abstract::Builder
+          def validate
+            proxy.declare(Validator)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/active_model/failure.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/validator/result/failure'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module ActiveModel
+        class Failure < WorkflowTemplate::Validation::Validator::Result::Failure
+          def message(*)
+            data.full_messages.to_sentence
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/adapters/validation/active_model/null_model.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module ActiveModel
+        class NullModel
+          include ::ActiveModel::Validations
+          include ::ActiveModel::Naming
+
+          @_model_name = ::ActiveModel::Name.new(self, nil, 'Unknown')
+
+          def base
+            nil
+          end
+
+          validates :base, presence: true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/adapter/abstract/validator'
+require_relative '../../../validation/validator/result/success'
+require_relative 'failure'
+require_relative 'null_model'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module ActiveModel
+        class Validator
+          extend WorkflowTemplate::Validation::Adapter::Abstract::Validator
+
+          def self.call(input)
+            model = input || NullModel.new
+            return WorkflowTemplate::Validation::Validator::Result::Success if model.valid?
+
+            code = input ? "#{model.model_name.singular}_invalid" : :model_nil
+
+            Failure.new(
+              self,
+              code: code,
+              data: model.errors
+            )
+          end
+
+          def self.describe
+            'model to be valid'
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/adapter/abstract/builder'
+require_relative 'validator'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module DryValidation
+        class Builder < WorkflowTemplate::Validation::Adapter::Abstract::Builder
+          def validate(contract:)
+            proxy.declare(Validator.new(contract))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../../../validation/validator/result/failure'
+
+module WorkflowTemplate
+  module Adapters
+    module Validation
+      module DryValidation
+        class Failure < WorkflowTemplate::Validation::Validator::Result::Failure
+          def message(*)
+            return if data.nil?
+
+            data.errors(full: true).messages.map(&:text).join(', ')
+          end
+        end
+      end
+    end
+  end
+end