teckel 0.4.0 → 0.5.0

data/lib/teckel/chain/result.rb

@@ -29,9 +29,9 @@ module Teckel
       end
 
       def deconstruct_keys(keys)
-        super.tap { |e|
-          e[:step] = @step.name if keys.include?(:step)
-        }
+        e = super
+        e[:step] = @step.name if keys.include?(:step)
+        e
       end
     end
   end

data/lib/teckel/chain/runner.rb

@@ -9,6 +9,9 @@ module Teckel
       # @!visibility private
       UNDEFINED = Object.new
 
+      # @!visibility private
+      StepResult = Struct.new(:value, :success, :step)
+
       def initialize(chain, settings = UNDEFINED)
         @chain, @settings = chain, settings
       end
@@ -20,29 +23,37 @@ module Teckel
       #
       # @return [Teckel::Chain::Result] The result object wrapping
       #   either the success or failure value.
-      def call(input)
-        last_result = nil
-        last_step = nil
-        steps.each do |step|
-          last_step = step
-          value     = last_result ? last_result.value : input
+      def call(input = nil)
+        step_result = run(input)
+        chain.result_constructor.call(*step_result)
+      end
+
+      def steps
+        settings == UNDEFINED ? chain.steps : steps_with_settings
+      end
+
+      private
+
+      def run(input)
+        steps.each_with_object(StepResult.new(input)) do |step, step_result|
+          result = step.operation.call(step_result.value)
 
-          last_result = step.operation.call(value)
+          step_result.step = step
+          step_result.value = result.value
+          step_result.success = result.successful?
 
-          break if last_result.failure?
+          break step_result if result.failure?
         end
+      end
 
-        chain.result_constructor.call(last_result.value, last_result.successful?, last_step)
+      def step_with_settings(step)
+        settings.key?(step.name) ? step.with(settings[step.name]) : step
       end
 
-      def steps
-        if settings == UNDEFINED
-          chain.steps
-        else
-          Enumerator.new do |yielder|
-            chain.steps.each do |step|
-              yielder << (settings.key?(step.name) ? step.with(settings[step.name]) : step)
-            end
+      def steps_with_settings
+        Enumerator.new do |yielder|
+          chain.steps.each do |step|
+            yielder << step_with_settings(step)
           end
         end
       end

data/lib/teckel/config.rb

@@ -19,11 +19,7 @@ module Teckel
     # @!visibility private
     def for(key, value = nil, &block)
       if value.nil?
-        if block
-          @config[key] ||= @config.fetch(key, &block)
-        else
-          @config[key]
-        end
+        get_or_set(key, &block)
       elsif @config.key?(key)
         raise FrozenConfigError, "Configuration #{key} is already set"
       else
@@ -48,5 +44,15 @@ module Teckel
         copy.instance_variable_set(:@config, @config.dup)
       end
     end
+
+    private
+
+    def get_or_set(key, &block)
+      if block
+        @config[key] ||= @config.fetch(key, &block)
+      else
+        @config[key]
+      end
+    end
   end
 end

data/lib/teckel/operation.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "operation/config"
 require_relative "operation/result"
 require_relative "operation/runner"
 
@@ -13,13 +14,14 @@ module Teckel
   # +input+. +output+ and +error+ methods to point them to anonymous classes.
   #
   # If you like "traditional" result objects to ask +successful?+ or +failure?+ on,
-  # use {.result!} and get {Teckel::Operation::Result}
+  # use {Teckel::Operation::Config#result! result!} and get {Teckel::Operation::Result}
   #
   # By default, +input+. +output+ and +error+ classes are build using +:[]+
   # (eg: +Input[some: :param]+).
-  # Use {ClassMethods#input_constructor input_constructor},
-  # {ClassMethods#output_constructor output_constructor} and
-  # {ClassMethods#error_constructor error_constructor} to change them.
+  #
+  # Use {Teckel::Operation::Config#input_constructor input_constructor},
+  # {Teckel::Operation::Config#output_constructor output_constructor} and
+  # {Teckel::Operation::Config#error_constructor error_constructor} to change them.
   #
   # @example class definitions via methods
   #   class CreateUserViaMethods
@@ -56,309 +58,21 @@ module Teckel
   # @!visibility public
   module Operation
     module ClassMethods
-      # @!group Contacts definition
-
-      # @overload input()
-      #   Get the configured class wrapping the input data structure.
-      #   @return [Class] The +input+ class
-      # @overload input(klass)
-      #   Set the class wrapping the input data structure.
-      #   @param  klass [Class] The +input+ class
-      #   @return [Class] The +input+ class
-      def input(klass = nil)
-        @config.for(:input, klass) { self::Input if const_defined?(:Input) } ||
-          raise(Teckel::MissingConfigError, "Missing input config for #{self}")
-      end
-
-      # @overload input_constructor()
-      #   The callable constructor to build an instance of the +input+ class.
-      #   Defaults to {Teckel::DEFAULT_CONSTRUCTOR}
-      #   @return [Proc] A callable that will return an instance of the +input+ class.
-      #
-      # @overload input_constructor(sym_or_proc)
-      #   Define how to build the +input+.
-      #   @param  sym_or_proc [Symbol, #call]
-      #     - Either a +Symbol+ representing the _public_ method to call on the +input+ class.
-      #     - Or anything that response to +#call+ (like a +Proc+).
-      #   @return [#call] The callable constructor
-      #
-      #   @example simple symbol to method constructor
-      #     class MyOperation
-      #       include Teckel::Operation
-      #
-      #       class Input
-      #         def initialize(name:, age:); end
-      #       end
-      #
-      #       # If you need more control over how to build a new +Input+ instance
-      #       # MyOperation.call(name: "Bob", age: 23) # -> Input.new(name: "Bob", age: 23)
-      #       input_constructor :new
-      #     end
-      #
-      #     MyOperation.input_constructor.is_a?(Method) #=> true
-      #
-      #   @example Custom Proc constructor
-      #     class MyOperation
-      #       include Teckel::Operation
-      #
-      #       class Input
-      #         def initialize(*args, **opts); end
-      #       end
-      #
-      #       # If you need more control over how to build a new +Input+ instance
-      #       # MyOperation.call("foo", opt: "bar") # -> Input.new(name: "foo", opt: "bar")
-      #       input_constructor ->(name, options) { Input.new(name: name, **options) }
-      #     end
-      #
-      #     MyOperation.input_constructor.is_a?(Proc) #=> true
-      def input_constructor(sym_or_proc = nil)
-        get_set_counstructor(:input_constructor, input, sym_or_proc) ||
-          raise(MissingConfigError, "Missing input_constructor config for #{self}")
-      end
-
-      # @overload output()
-      #  Get the configured class wrapping the output data structure.
-      #  Defaults to {Teckel::DEFAULT_CONSTRUCTOR}
-      #  @return [Class] The +output+ class
-      #
-      # @overload output(klass)
-      #   Set the class wrapping the output data structure.
-      #   @param  klass [Class] The +output+ class
-      #   @return [Class] The +output+ class
-      def output(klass = nil)
-        @config.for(:output, klass) { self::Output if const_defined?(:Output) } ||
-          raise(Teckel::MissingConfigError, "Missing output config for #{self}")
-      end
-
-      # @overload output_constructor()
-      #  The callable constructor to build an instance of the +output+ class.
-      #  Defaults to {Teckel::DEFAULT_CONSTRUCTOR}
-      #  @return [Proc] A callable that will return an instance of +output+ class.
-      #
-      # @overload output_constructor(sym_or_proc)
-      #   Define how to build the +output+.
-      #   @param sym_or_proc [Symbol, #call]
-      #     - Either a +Symbol+ representing the _public_ method to call on the +output+ class.
-      #     - Or anything that response to +#call+ (like a +Proc+).
-      #   @return [#call] The callable constructor
-      #
-      #   @example
-      #     class MyOperation
-      #       include Teckel::Operation
-      #
-      #       class Output
-      #         def initialize(*args, **opts); end
-      #       end
-      #
-      #       # MyOperation.call("foo", "bar") # -> Output.new("foo", "bar")
-      #       output_constructor :new
-      #
-      #       # If you need more control over how to build a new +Output+ instance
-      #       # MyOperation.call("foo", opt: "bar") # -> Output.new(name: "foo", opt: "bar")
-      #       output_constructor ->(name, options) { Output.new(name: name, **options) }
-      #     end
-      def output_constructor(sym_or_proc = nil)
-        get_set_counstructor(:output_constructor, output, sym_or_proc) ||
-          raise(MissingConfigError, "Missing output_constructor config for #{self}")
-      end
-
-      # @overload error()
-      #   Get the configured class wrapping the error data structure.
-      #   @return [Class] The +error+ class
-      #
-      # @overload error(klass)
-      #   Set the class wrapping the error data structure.
-      #   @param klass [Class] The +error+ class
-      #   @return [Class,nil] The +error+ class or +nil+ if it does not error
-      def error(klass = nil)
-        @config.for(:error, klass) { self::Error if const_defined?(:Error) } ||
-          raise(Teckel::MissingConfigError, "Missing error config for #{self}")
-      end
-
-      # @overload error_constructor()
-      #   The callable constructor to build an instance of the +error+ class.
-      #   Defaults to {Teckel::DEFAULT_CONSTRUCTOR}
-      #   @return [Proc] A callable that will return an instance of +error+ class.
-      #
-      # @overload error_constructor(sym_or_proc)
-      #   Define how to build the +error+.
-      #   @param sym_or_proc [Symbol, #call]
-      #     - Either a +Symbol+ representing the _public_ method to call on the +error+ class.
-      #     - Or anything that response to +#call+ (like a +Proc+).
-      #   @return [#call] The callable constructor
-      #
-      #   @example
-      #     class MyOperation
-      #       include Teckel::Operation
-      #
-      #       class Error
-      #         def initialize(*args, **opts); end
-      #       end
-      #
-      #       # MyOperation.call("foo", "bar") # -> Error.new("foo", "bar")
-      #       error_constructor :new
-      #
-      #       # If you need more control over how to build a new +Error+ instance
-      #       # MyOperation.call("foo", opt: "bar") # -> Error.new(name: "foo", opt: "bar")
-      #       error_constructor ->(name, options) { Error.new(name: name, **options) }
-      #     end
-      def error_constructor(sym_or_proc = nil)
-        get_set_counstructor(:error_constructor, error, sym_or_proc) ||
-          raise(MissingConfigError, "Missing error_constructor config for #{self}")
-      end
-
-      # @!endgroup
-
-      # @overload settings()
-      #  Get the configured class wrapping the settings data structure.
-      #  @return [Class] The +settings+ class, or {Teckel::Contracts::None} as default
-      #
-      # @overload settings(klass)
-      #   Set the class wrapping the settings data structure.
-      #   @param klass [Class] The +settings+ class
-      #   @return [Class] The +settings+ class configured
-      def settings(klass = nil)
-        @config.for(:settings, klass) { const_defined?(:Settings) ? self::Settings : none }
-      end
-
-      # @overload settings_constructor()
-      #   The callable constructor to build an instance of the +settings+ class.
-      #   Defaults to {Teckel::DEFAULT_CONSTRUCTOR}
-      #   @return [Proc] A callable that will return an instance of +settings+ class.
-      #
-      # @overload settings_constructor(sym_or_proc)
-      #  Define how to build the +settings+.
-      #  @param  sym_or_proc [Symbol, #call]
-      #    - Either a +Symbol+ representing the _public_ method to call on the +settings+ class.
-      #    - Or anything that response to +#call+ (like a +Proc+).
-      #  @return [#call] The callable constructor
-      #
-      #  @example
-      #    class MyOperation
-      #      include Teckel::Operation
-      #
-      #      class Settings
-      #        def initialize(*args); end
-      #      end
-      #
-      #      # MyOperation.with("foo", "bar") # -> Settings.new("foo", "bar")
-      #      settings_constructor :new
-      #    end
-      def settings_constructor(sym_or_proc = nil)
-        get_set_counstructor(:settings_constructor, settings, sym_or_proc) ||
-          raise(MissingConfigError, "Missing settings_constructor config for #{self}")
-      end
-
-      # @overload runner()
-      #   @return [Class] The Runner class
-      #   @!visibility protected
-      #
-      # @overload runner(klass)
-      #   Overwrite the default runner
-      #   @param klass [Class] A class like the {Runner}
-      #   @!visibility protected
-      def runner(klass = nil)
-        @config.for(:runner, klass) { Teckel::Operation::Runner }
-      end
-
-      # @overload result()
-      #   Get the configured result object class wrapping {error} or {output}.
-      #   The {ValueResult} default will act as a pass-through and does. Any error
-      #   or output will just returned as-is.
-      #   @return [Class] The +result+ class, or {ValueResult} as default
-      #
-      # @overload result(klass)
-      #   Set the result object class wrapping {error} or {output}.
-      #   @param klass [Class] The +result+ class
-      #   @return [Class] The +result+ class configured
-      def result(klass = nil)
-        @config.for(:result, klass) { const_defined?(:Result, false) ? self::Result : ValueResult }
-      end
-
-      # @overload result_constructor()
-      #   The callable constructor to build an instance of the +result+ class.
-      #   Defaults to {Teckel::DEFAULT_CONSTRUCTOR}
-      #   @return [Proc] A callable that will return an instance of +result+ class.
-      #
-      # @overload result_constructor(sym_or_proc)
-      #  Define how to build the +result+.
-      #  @param  sym_or_proc [Symbol, #call]
-      #    - Either a +Symbol+ representing the _public_ method to call on the +result+ class.
-      #    - Or anything that response to +#call+ (like a +Proc+).
-      #  @return [#call] The callable constructor
-      #
-      #  @example
-      #    class MyOperation
-      #      include Teckel::Operation
-      #
-      #      class Result
-      #        include Teckel::Result
-      #        def initialize(value, success, opts = {}); end
-      #      end
-      #
-      #      # If you need more control over how to build a new +Settings+ instance
-      #      result_constructor ->(value, success) { result.new(value, success, {foo: :bar}) }
-      #    end
-      def result_constructor(sym_or_proc = nil)
-        get_set_counstructor(:result_constructor, result, sym_or_proc) ||
-          raise(MissingConfigError, "Missing result_constructor config for #{self}")
-      end
-
-      # @!group Shortcuts
-
-      # Shortcut to use {Teckel::Operation::Result} as a result object,
-      # wrapping any {error} or {output}.
-      #
-      # @!visibility protected
-      # @note Don't use in conjunction with {result} or {result_constructor}
-      # @return [nil]
-      def result!
-        @config.for(:result, Teckel::Operation::Result)
-        @config.for(:result_constructor, Teckel::Operation::Result.method(:new))
-        nil
-      end
-
-      # Convenience method for setting {#input}, {#output} or {#error} to the
-      # {Teckel::Contracts::None} value.
-      # @return [Object] The {Teckel::Contracts::None} class.
-      #
-      # @example Enforcing nil input, output or error
-      #   class MyOperation
-      #     include Teckel::Operation
-      #
-      #     input none
-      #
-      #     # same as
-      #     output Teckel::Contracts::None
-      #
-      #     error none
-      #
-      #     def call(_) # you still need to take than +nil+ input when using `input none`
-      #       # when using `error none`:
-      #       # `fail!` works, but `fail!("data")` raises an error
-      #
-      #       # when using `output none`:
-      #       # `success!` works, but `success!("data")` raises an error
-      #       # same thing when using simple return values as success:
-      #       # take care to not return anything
-      #       nil
-      #     end
-      #   end
-      #
-      #   MyOperation.call #=> nil
-      def none
-        Teckel::Contracts::None
-      end
-
-      # @endgroup
-
       # Invoke the Operation
       #
-      # @param input Any form of input your {#input} class can handle via the given {#input_constructor}
-      # @return Either An instance of your defined {#error} class or {#output} class
+      # @param input Any form of input your {Teckel::Operation::Config#input input} class can handle via the given
+      #   {Teckel::Operation::Config#input_constructor input_constructor}
+      # @return Either An instance of your defined {Teckel::Operation::Config#error error} class or
+      #   {Teckel::Operation::Config#output output} class
       # @!visibility public
       def call(input = nil)
-        runner.new(self).call(input)
+        default_settings = self.default_settings
+
+        if default_settings
+          runner.new(self, default_settings.call)
+        else
+          runner.new(self)
+        end.call(input)
       end
 
       # Provide {InstanceMethods#settings() settings} to the running operation.
@@ -366,8 +80,9 @@ module Teckel
       # This method is intended to be called on the operation class outside of
       # it's definition, prior to running {#call}.
       #
-      # @param input Any form of input your {#settings} class can handle via the given {#settings_constructor}
-      # @return [Class] The configured {runner}
+      # @param input Any form of input your {Teckel::Operation::Config#settings settings} class can handle via the given
+      #   {Teckel::Operation::Config#settings_constructor settings_constructor}
+      # @return [Class] The configured {Teckel::Operation::Config#runner runner}
       # @!visibility public
       #
       # @example Inject settings for an operation call
@@ -401,85 +116,39 @@ module Teckel
       end
       alias :set :with
 
-      # @!visibility private
-      # @return [void]
-      def define!
-        %i[
-          input input_constructor
-          output output_constructor
-          error error_constructor
-          settings settings_constructor
-          result result_constructor
-          runner
-        ].each { |e| public_send(e) }
-        nil
-      end
-
-      # Disallow any further changes to this Operation.
-      # Make sure all configurations are set.
+      # Convenience method for setting {Teckel::Operation::Config#input input},
+      # {Teckel::Operation::Config#output output} or
+      # {Teckel::Operation::Config#error error} to the
+      # {Teckel::Contracts::None} value.
       #
-      # @raise [MissingConfigError]
-      # @return [self] Frozen self
-      # @!visibility public
-      def finalize!
-        define!
-        @config.freeze
-        self
-      end
-
-      # Produces a shallow copy of this operation and all it's configuration.
+      # @return [Object] The {Teckel::Contracts::None} class.
       #
-      # @return [self]
-      # @!visibility public
-      def dup
-        super.tap do |copy|
-          copy.instance_variable_set(:@config, @config.dup)
-        end
-      end
-
-      # Produces a clone of this operation and all it's configuration
+      # @example Enforcing nil input, output or error
+      #   class MyOperation
+      #     include Teckel::Operation
       #
-      # @return [self]
-      # @!visibility public
-      def clone
-        if frozen?
-          super
-        else
-          super.tap do |copy|
-            copy.instance_variable_set(:@config, @config.dup)
-          end
-        end
-      end
-
-      # @!visibility private
-      def inherited(subclass)
-        subclass.instance_variable_set(:@config, @config.dup)
-      end
-
-      # @!visibility private
-      def self.extended(base)
-        base.instance_exec do
-          @config = Config.new
-          attr_accessor :settings
-        end
-      end
-
-      private
-
-      def get_set_counstructor(name, on, sym_or_proc)
-        constructor = build_counstructor(on, sym_or_proc) unless sym_or_proc.nil?
-
-        @config.for(name, constructor) {
-          build_counstructor(on, Teckel::DEFAULT_CONSTRUCTOR)
-        }
-      end
-
-      def build_counstructor(on, sym_or_proc)
-        if sym_or_proc.is_a?(Symbol) && on.respond_to?(sym_or_proc)
-          on.public_method(sym_or_proc)
-        elsif sym_or_proc.respond_to?(:call)
-          sym_or_proc
-        end
+      #     input none
+      #
+      #     # same as
+      #     output Teckel::Contracts::None
+      #
+      #     error none
+      #
+      #     def call(_) # you still need to take than +nil+ input when using `input none`
+      #       # when using `error none`:
+      #       # `fail!` works, but `fail!("data")` raises an error
+      #
+      #       # when using `output none`:
+      #       # `success!` works, but `success!("data")` raises an error
+      #       # same thing when using simple return values as success:
+      #       # take care to not return anything
+      #       nil
+      #     end
+      #   end
+      #
+      #   MyOperation.call #=> nil
+      def none
+        Teckel::Contracts::None
       end
     end
 
@@ -492,7 +161,7 @@ module Teckel
 
       # Halt any further execution with a output value
       #
-      # @return a thing matching your {Operation::ClassMethods#output Operation#output} definition
+      # @return a thing matching your {Teckel::Operation::Config#output output} definition
       # @!visibility protected
       def success!(*args)
         throw :success, args
@@ -500,7 +169,7 @@ module Teckel
 
       # Halt any further execution with an error value
       #
-      # @return a thing matching your {Operation::ClassMethods#error Operation#error} definition
+      # @return a thing matching your {Teckel::Operation::Config#error error} definition
       # @!visibility protected
       def fail!(*args)
         throw :failure, args
@@ -508,6 +177,7 @@ module Teckel
     end
 
     def self.included(receiver)
+      receiver.extend         Config
       receiver.extend         ClassMethods
       receiver.send :include, InstanceMethods
     end