workflow_template 0.0.4

data/lib/workflow_template/validation/adapter/abstract/result/failure.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Validation
+    module Adapter
+      module Abstract
+        module Result
+          module Failure
+            def code
+              raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+            end
+
+            def message(*)
+              raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+            end
+
+            def data
+              raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/adapter/abstract/validator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Validation
+    module Adapter
+      module Abstract
+        module Validator
+          def initialize
+            freeze
+          end
+
+          def validate(_data)
+            raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+          end
+
+          def describe
+            raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/adapter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'adapter/abstract/builder'
+require_relative 'adapter/abstract/validator'
+require_relative 'adapter/abstract/result/failure'
+require_relative 'validator/result/success'
+
+module WorkflowTemplate
+  module Validation
+    module Adapter
+      def self.registry
+        @registry ||= {}
+      end
+
+      def self.register(name, adapter)
+        registry[name.to_sym] = adapter
+      end
+
+      def self.fetch(name)
+        name = name.to_sym
+        raise Error, "Not a registered validation adapter: #{name}" unless registry.key? name
+
+        registry[name]
+      end
+
+      def builder_class
+        raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+      end
+
+      def register(name)
+        Adapter.register(name, self)
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/builder/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../../error'
+
+module WorkflowTemplate
+  module Validation
+    module Builder
+      class Error < WorkflowTemplate::Error; end
+    end
+  end
+end

data/lib/workflow_template/validation/builder/proxy.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative '../evaluation'
+
+module WorkflowTemplate
+  module Validation
+    module Builder
+      class Proxy
+        def self.instance(adapter, collection, name: nil, context: nil)
+          new adapter, collection, normalize_name(name), normalize_context(context)
+        end
+
+        def self.normalize_name(name)
+          return if name.nil?
+
+          raise Error, 'Empty name' if name.empty?
+
+          name.to_sym
+        end
+
+        def self.normalize_context(context)
+          return if context.nil? || context.empty?
+
+          raise Error, "Context contains invalid keys: #{context}" if context.any?(&:empty?)
+
+          context.map(&:to_sym)
+        end
+
+        private_class_method :new
+
+        def initialize(adapter, collection, name, context)
+          @adapter = adapter
+          @collection = collection
+          @name = name&.to_sym
+          @context = context.freeze
+          freeze
+        end
+
+        attr_reader :name, :context
+
+        def key?
+          false
+        end
+
+        def key
+          nil
+        end
+
+        def named(name)
+          raise Error, "Name already defined: #{self.name}" if self.name
+
+          self.class.instance(adapter, collection, name: name, context: context)
+        end
+
+        def with_context(*context)
+          raise Error, "Context already defined: #{self.context}" if self.context
+
+          self.class.instance(adapter, collection, name: name, context: context)
+        end
+
+        def validate(key = nil, **opts, &block)
+          proxy = if key
+            Keyed.instance(key, adapter, collection, name: name, context: context)
+          else
+            raise Error, 'Key must be supplied if name is missing' if name.nil?
+            raise Error, 'Context is not available if key is not specified' unless context.nil?
+
+            self
+          end
+
+          adapter.builder_class
+                 .new(proxy)
+                 .validate(**opts, &block)
+        end
+
+        def declare(validation)
+          collection.add(evaluation(validation))
+        end
+
+        private
+
+        attr_reader :adapter, :collection
+
+        def evaluation(validation)
+          evaluation_class.new(name, key, context, validation)
+        end
+
+        def evaluation_class
+          case adapter.result_type
+          when :boolean then Evaluation::Boolean
+          when :canonical then Evaluation::Canonical
+          else raise Error, "Unexpected result type: #{adapter.result_type}"
+          end
+        end
+
+        class Keyed < Proxy
+          def self.instance(key, adapter, collection, name: nil, context: nil)
+            key = normalize_key(key)
+            new key, adapter, collection, normalize_name(name) || key, normalize_context(context)
+          end
+
+          def self.normalize_key(key)
+            return if key.nil?
+
+            raise Error, 'Empty key' if key.empty?
+
+            key.to_sym
+          end
+
+          def initialize(key, *args)
+            @key = key.to_sym
+            super(*args)
+          end
+
+          attr_reader :key
+
+          def key?
+            true
+          end
+
+          def validate(**opts, &block)
+            adapter.builder_class.new(self).validate(**opts, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module WorkflowTemplate
+  module Validation
+    class Error < WorkflowTemplate::Error
+      attr_reader :failure
+
+      def initialize(failure)
+        @failure = failure
+        super(failure.describe)
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/evaluation/abstract.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+require_relative '../adapter/abstract/result/failure'
+require_relative '../validator/result/success'
+require_relative '../validator/result/failure'
+require_relative '../result/failure'
+require_relative '../result/success'
+
+module WorkflowTemplate
+  module Validation
+    module Evaluation
+      class Abstract
+        attr_reader :name, :key, :context, :validator
+
+        def initialize(name, key, context, validator)
+          @name = name.to_sym
+          @key = key&.to_sym
+          @context = context.freeze
+          @validator = validator
+          freeze
+        end
+
+        def call(data)
+          result = run_validator(data)
+          evaluate(result)
+        end
+
+        def evaluate(_result)
+          raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+        end
+
+        def describe
+          validator.describe
+        end
+
+        private
+
+        def run_validator(data)
+          input = key.nil? ? data : data[key]
+          case context
+          when nil then validator.call(input)
+          else validator.call(input, context: data&.slice(*context))
+          end
+        end
+
+        def to_failure(result)
+          if result.is_a? Adapter::Abstract::Result::Failure
+            Result::Failure.instance(name, key, result)
+          else
+            to_failure(Validator::Result::Failure.new(validator, data: result))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/evaluation/boolean.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module WorkflowTemplate
+  module Validation
+    module Evaluation
+      class Boolean < Abstract
+        def evaluate(result)
+          result, detail = result
+          if result
+            case detail
+            when nil then Result::Success
+            when Hash, Array
+              raise Fatal::BadValidationReturn, name unless detail.empty?
+
+              Result::Success
+            else
+              raise Fatal::BadValidationReturn, name
+            end
+          else
+            to_failure(detail)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/evaluation/canonical.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module WorkflowTemplate
+  module Validation
+    module Evaluation
+      class Canonical < Abstract
+        def evaluate(result)
+          case result
+          when Validator::Result::Success then Result::Success
+          when Adapter::Abstract::Result::Failure
+            to_failure(result)
+          else
+            raise Fatal::BadValidationReturn, name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/evaluation.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'evaluation/boolean'
+require_relative 'evaluation/canonical'

data/lib/workflow_template/validation/result/failure/abstract.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Validation
+    module Result
+      class Failure
+        module Abstract
+          def success?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/result/failure.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'failure/abstract'
+require 'forwardable'
+
+module WorkflowTemplate
+  module Validation
+    module Result
+      class Failure
+        include Abstract
+        extend Forwardable
+
+        attr_reader :name, :key, :failure
+
+        def_delegator :failure, :data
+
+        def self.instance(name, key, failure)
+          new name, key, failure
+        end
+
+        def initialize(name, key, failure)
+          @name = name.to_sym
+          @key = key&.to_sym
+          @failure = failure
+          freeze
+        end
+
+        def code
+          failure.code || :"#{name}_failed"
+        end
+
+        def describe
+          "#{code}: #{name} #{failure.describe}"
+        end
+
+        def message(*args, **opts)
+          failure.message(*args, **opts)
+        end
+
+        def eql?(other)
+          return false unless other.is_a?(self.class)
+
+          name == other.name
+        end
+
+        def hash
+          name.hash
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/result/success.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Validation
+    module Result
+      module Success
+        def self.success?
+          true
+        end
+
+        def self.===(other)
+          other.equal?(self)
+        end
+
+        freeze
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/validator/result/failure.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../adapter/abstract/result/failure'
+
+module WorkflowTemplate
+  module Validation
+    module Validator
+      module Result
+        class Failure
+          include Adapter::Abstract::Result::Failure
+
+          attr_reader :validator, :code, :data
+
+          def initialize(validator, code: nil, data: nil)
+            @validator = validator
+            @code = code&.to_sym || :validation_failed
+            @data = data
+            freeze
+          end
+
+          def success?
+            false
+          end
+
+          def describe
+            validator.describe
+          end
+
+          def message(*)
+            describe
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/validation/validator/result/success.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module WorkflowTemplate
+  module Validation
+    module Validator
+      module Result
+        module Success
+          def self.success?
+            true
+          end
+
+          def self.===(other)
+            other.equal?(self)
+          end
+
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/workflow_template/workflow/description.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module WorkflowTemplate
+  class Workflow
+    class Description
+      def self.register(group, key, &block)
+        registry[group][key] = block
+      end
+
+      def self.describe(workflow)
+        description = new
+        registry.each do |group, blocks|
+          blocks.each_value do |block|
+            result = block.call(workflow)
+            next if result.nil?
+
+            description.add!(result, group)
+          end
+        end
+        description.format
+      end
+
+      def self.registry
+        @registry ||= { initialize: {}, perform: {}, finalize: {} }
+      end
+
+      def initialize
+        @initialize = []
+        @perform = []
+        @finalize = []
+      end
+
+      def add!(description, group)
+        case group
+        when :initialize then @initialize << description
+        when :perform then @perform << description
+        when :finalize then @finalize << description
+        else raise Error, "Unexpected group: #{group}"
+        end
+      end
+
+      def format
+        [@initialize, @perform, @finalize].filter_map do |group|
+          next if group.empty?
+
+          formatted = group.map do |element|
+            element.is_a?(String) ? element : element.format(level: 0)
+          end
+          formatted.join("\n")
+        end.join("\n\n") << "\n"
+      end
+    end
+  end
+end

data/lib/workflow_template/workflow.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'definer/has_actions'
+require_relative 'definer/has_actions/root'
+require_relative 'definer/has_default_state_transition_strategy'
+require_relative 'definer/has_output_normalizer'
+require_relative 'definer/has_state_adapter'
+require_relative 'definer/has_validations'
+require_relative 'definer/has_validations/description'
+require_relative 'outcome'
+
+require_relative 'performer'
+require_relative 'workflow/description'
+
+module WorkflowTemplate
+  class Workflow
+    module ModuleMethods
+      include Definer::HasActions::Root
+      include Definer::HasDefaultStateTransitionStrategy
+      include Definer::HasOutputNormalizer
+      include Definer::HasStateAdapter
+      include Definer::HasValidations
+      include Performer
+
+      def perform(input, receiver, trace: false) # rubocop:disable Metrics/AbcSize
+        state_class = State.state_class(state_adapter)
+        state = state_class.initial(
+          input,
+          default_state_transition_strategy,
+          validations.input_validations,
+          trace: trace
+        )
+        state = super(state, receiver) if state.continue?
+        state = state.normalize_data(output_normalizer)
+        state = state.apply_validations(validations.output_validations)
+        Outcome.new(state.final)
+      rescue Fatal
+        raise
+      rescue StandardError => e
+        raise Fatal, "Unable to initialize state class: #{e}" unless state_class
+        raise Fatal, "Unable to initialize state: #{e}" unless state
+
+        raise Fatal, "Unexpected error: #{e}"
+      end
+
+      def describe
+        raise Error, "Can't describe unfrozen workflow" unless frozen?
+
+        Description.describe(self)
+      end
+    end
+
+    module ClassMethods
+      attr_reader :impl
+
+      def freeze
+        @impl = new.freeze
+        super
+      end
+    end
+
+    extend ModuleMethods
+    extend ClassMethods
+
+    def perform(inputs, trace: false)
+      self.class.perform(inputs, self, trace: trace)
+    end
+  end
+end

data/lib/workflow_template.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'workflow_template/workflow'
+
+module WorkflowTemplate
+  VERSION = '0.0.4'
+
+  def self.gem_version
+    ::Gem::Version.new(VERSION)
+  end
+end