teckel 0.3.0 → 0.4.0

data/lib/teckel/chain/result.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Teckel
+  module Chain
+    class Result < Teckel::Operation::Result
+      extend Forwardable
+
+      # @param value [Object] The result value
+      # @param success [Boolean] whether this is a successful result
+      # @param step [Teckel::Chain::Step]
+      def initialize(value, success, step)
+        super(value, success)
+        @step = step
+      end
+
+      class << self
+        alias :[] :new
+      end
+
+      # @!method step
+      #   Delegates to +step.name+
+      #   @return [String,Symbol] The step name of the failed operation.
+      def_delegator :@step, :name, :step
+
+      def deconstruct
+        [successful?, @step.name, value]
+      end
+
+      def deconstruct_keys(keys)
+        super.tap { |e|
+          e[:step] = @step.name if keys.include?(:step)
+        }
+      end
+    end
+  end
+end

data/lib/teckel/chain/runner.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Teckel
+  module Chain
+    # The default implementation for executing a {Chain}
+    #
+    # @!visibility protected
+    class Runner
+      # @!visibility private
+      UNDEFINED = Object.new
+
+      def initialize(chain, settings = UNDEFINED)
+        @chain, @settings = chain, settings
+      end
+      attr_reader :chain, :settings
+
+      # Run steps
+      #
+      # @param input Any form of input the first steps +input+ class can handle
+      #
+      # @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
+
+          last_result = step.operation.call(value)
+
+          break if last_result.failure?
+        end
+
+        chain.result_constructor.call(last_result.value, last_result.successful?, last_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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/teckel/chain/step.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Teckel
+  module Chain
+    # Internal wrapper of a step definition
+    Step = Struct.new(:name, :operation) do
+      def finalize!
+        name.freeze
+        operation.finalize!
+        freeze
+      end
+
+      def with(settings)
+        self.class.new(name, operation.with(settings))
+      end
+    end
+  end
+end

data/lib/teckel/config.rb

@@ -2,29 +2,6 @@
 
 module Teckel
   class Config
-    @default_constructor = :[]
-    class << self
-      # @!attribute [r] default_constructor()
-      # The default constructor method for +input+, +output+ and +error+ class (default: +:[]+)
-      # @return [Class] The Output class
-
-      # @!method default_constructor(sym_or_proc)
-      # Set the default constructor method for +input+, +output+ and +error+ class
-      #
-      # defaults to +:[]+
-      #
-      # @param sym_or_proc [Symbol,#call] The method name on the +input+,
-      #   +output+ and +error+ class or a callable which accepts the
-      #   +input+, +output+ or +error+
-      #
-      # @return [Symbol,#call]
-      def default_constructor(sym_or_proc = nil)
-        return @default_constructor if sym_or_proc.nil?
-
-        @default_constructor = sym_or_proc
-      end
-    end
-
     # @!visibility private
     def initialize
       @config = {}
@@ -38,6 +15,7 @@ module Teckel
     #   - sets (and returns) the blocks return value otherwise
     # - calling without +value+ and +block+ works like {Hash#[]}
     #
+    # @raise [FrozenConfigError] When overwriting a key
     # @!visibility private
     def for(key, value = nil, &block)
       if value.nil?

data/lib/teckel/contracts.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Teckel
+  module Contracts
+    # Simple contract for enforcing data to be not set or +nil+
+    module None
+      class << self
+        # Always return nil
+        # @return nil
+        # @raise [ArgumentError] when called with any non-nil arguments
+        def [](*args)
+          raise ArgumentError, "None called with arguments" if args.any?(&:itself)
+        end
+
+        alias :new :[]
+      end
+    end
+  end
+end

data/lib/teckel/operation.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "operation/result"
+require_relative "operation/runner"
+
 module Teckel
   # The main operation Mixin
   #
@@ -10,7 +13,7 @@ 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,
-  # see {Teckel::Operation::Results Teckel::Operation::Results}
+  # use {.result!} and get {Teckel::Operation::Result}
   #
   # By default, +input+. +output+ and +error+ classes are build using +:[]+
   # (eg: +Input[some: :param]+).
@@ -18,43 +21,6 @@ module Teckel
   # {ClassMethods#output_constructor output_constructor} and
   # {ClassMethods#error_constructor error_constructor} to change them.
   #
-  # @example class definitions via constants
-  #   class CreateUserViaConstants
-  #     include Teckel::Operation
-  #
-  #     class Input
-  #       def initialize(name:, age:)
-  #         @name, @age = name, age
-  #       end
-  #       attr_reader :name, :age
-  #     end
-  #
-  #     Output = ::User
-  #
-  #     class Error
-  #       def initialize(message, errors)
-  #         @message, @errors = message, errors
-  #       end
-  #       attr_reader :message, :errors
-  #     end
-  #
-  #     input_constructor :new
-  #     error_constructor :new
-  #
-  #     # @param [CreateUser::Input]
-  #     # @return [User,CreateUser::Error]
-  #     def call(input)
-  #       user = ::User.new(name: input.name, age: input.age)
-  #       if user.save
-  #         user
-  #       else
-  #         fail!(message: "Could not save User", errors: user.errors)
-  #       end
-  #     end
-  #   end
-  #
-  #   CreateUserViaConstants.call(name: "Bob", age: 23).is_a?(User) #=> true
-  #
   # @example class definitions via methods
   #   class CreateUserViaMethods
   #     include Teckel::Operation
@@ -89,201 +55,272 @@ module Teckel
   #
   # @!visibility public
   module Operation
-    # The default implementation for executing a single {Operation}
-    #
-    # @!visibility protected
-    class Runner
-      # @!visibility private
-      UNDEFINED = Object.new.freeze
-
-      def initialize(operation)
-        @operation = operation
-      end
-      attr_reader :operation
-
-      def call(input)
-        err = catch(:failure) do
-          simple_return = UNDEFINED
-          out = catch(:success) do
-            simple_return = @operation.new.call(build_input(input))
-          end
-          return simple_return == UNDEFINED ? build_output(*out) : build_output(simple_return)
-        end
-        build_error(*err)
-      end
-
-      private
-
-      def build_input(input)
-        operation.input_constructor.call(input)
-      end
-
-      def build_output(*args)
-        if args.size == 1 && operation.output === args.first # rubocop:disable Style/CaseEquality
-          args.first
-        else
-          operation.output_constructor.call(*args)
-        end
-      end
-
-      def build_error(*args)
-        if args.size == 1 && operation.error === args.first # rubocop:disable Style/CaseEquality
-          args.first
-        else
-          operation.error_constructor.call(*args)
-        end
-      end
-    end
-
     module ClassMethods
-      # @!attribute [r] input()
-      # Get the configured class wrapping the input data structure.
-      # @return [Class] The +input+ class
-
-      # @!method input(klass)
-      # Set the class wrapping the input data structure.
-      # @param  klass [Class] The +input+ class
-      # @return [Class] The +input+ class
+      # @!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
 
-      # @!attribute [r] input_constructor()
-      # The callable constructor to build an instance of the +input+ class.
-      # @return [Class] The Input class
-
-      # @!method 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
+      # @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.
       #
-      # @example simple symbol to method constructor
-      #   class MyOperation
-      #     include Teckel::Operation
+      # @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
       #
-      #     class Input
-      #       def initialize(name:, age:); end
+      #   @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
       #
-      #     # 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
       #
-      #   MyOperation.input_constructor.is_a?(Method) #=> true
+      #   @example Custom Proc constructor
+      #     class MyOperation
+      #       include Teckel::Operation
       #
-      # @example Custom Proc constructor
-      #   class MyOperation
-      #     include Teckel::Operation
+      #       class Input
+      #         def initialize(*args, **opts); end
+      #       end
       #
-      #     class Input
-      #       def initialize(*args, **opts); 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
       #
-      #     # 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 = Config.default_constructor)
-        @config.for(:input_constructor) { build_counstructor(input, sym_or_proc) } ||
+      #     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
 
-      # @!attribute [r] output()
-      # Get the configured class wrapping the output data structure.
-      # @return [Class] The +output+ class
-
-      # @!method output(klass)
-      # Set the class wrapping the output data structure.
-      # @param  klass [Class] The +output+ class
-      # @return [Class] The +output+ class
+      # @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
 
-      # @!attribute [r] output_constructor()
-      # The callable constructor to build an instance of the +output+ class.
-      # @return [Class] The Output class
-
-      # @!method 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
+      # @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.
       #
-      # @example
-      #   class MyOperation
-      #     include Teckel::Operation
+      # @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
       #
-      #     class Output
-      #       def initialize(*args, **opts); end
-      #     end
+      #   @example
+      #     class MyOperation
+      #       include Teckel::Operation
       #
-      #     # MyOperation.call("foo", "bar") # -> Output.new("foo", "bar")
-      #     output_constructor :new
+      #       class Output
+      #         def initialize(*args, **opts); end
+      #       end
       #
-      #     # 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 = Config.default_constructor)
-        @config.for(:output_constructor) { build_counstructor(output, sym_or_proc) } ||
+      #       # 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
 
-      # @!attribute [r] error()
-      # Get the configured class wrapping the error data structure.
-      # @return [Class] The +error+ class
-
-      # @!method 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
+      # @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
 
-      # @!attribute [r] error_constructor()
-      # The callable constructor to build an instance of the +error+ class.
-      # @return [Class] The Error class
-
-      # @!method 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
+      # @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.
       #
-      # @example
-      #   class MyOperation
-      #     include Teckel::Operation
+      # @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
       #
-      #     class Error
-      #       def initialize(*args, **opts); end
-      #     end
+      #   @example
+      #     class MyOperation
+      #       include Teckel::Operation
       #
-      #     # MyOperation.call("foo", "bar") # -> Error.new("foo", "bar")
-      #     error_constructor :new
+      #       class Error
+      #         def initialize(*args, **opts); end
+      #       end
       #
-      #     # 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 = Config.default_constructor)
-        @config.for(:error_constructor) { build_counstructor(error, sym_or_proc) } ||
+      #       # 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
 
-      # Convenience method for setting {#input}, {#output} or {#error} to the {None} value.
-      # @return [Object] The {Teckel::None} class.
+      # @!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
@@ -292,7 +329,7 @@ module Teckel
       #     input none
       #
       #     # same as
-      #     output Teckel::None
+      #     output Teckel::Contracts::None
       #
       #     error none
       #
@@ -310,35 +347,71 @@ module Teckel
       #
       #   MyOperation.call #=> nil
       def none
-        None
+        Teckel::Contracts::None
       end
 
-      # @!attribute [r] runner()
-      # @return [Class] The Runner class
-      # @!visibility protected
-
-      # Overwrite the default runner
-      # @param klass [Class] A class like the {Runner}
-      # @!visibility protected
-      def runner(klass = nil)
-        @config.for(:runner, klass) { Runner }
-      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 {#input} class can handle via the given {#input_constructor}
+      # @return Either An instance of your defined {#error} class or {#output} class
       # @!visibility public
       def call(input = nil)
         runner.new(self).call(input)
       end
 
+      # Provide {InstanceMethods#settings() settings} to the running operation.
+      #
+      # 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}
+      # @!visibility public
+      #
+      # @example Inject settings for an operation call
+      #   LOG = []
+      #
+      #   class MyOperation
+      #     include ::Teckel::Operation
+      #
+      #     settings Struct.new(:log)
+      #
+      #     input none
+      #     output none
+      #     error none
+      #
+      #     def call(_input)
+      #       settings.log << "called" if settings&.log
+      #       nil
+      #     end
+      #   end
+      #
+      #   MyOperation.with(LOG).call
+      #   LOG #=> ["called"]
+      #
+      #   LOG.clear
+      #
+      #   MyOperation.with(false).call
+      #   MyOperation.call
+      #   LOG #=> []
+      def with(input)
+        runner.new(self, settings_constructor.call(input))
+      end
+      alias :set :with
+
       # @!visibility private
       # @return [void]
       def define!
-        %i[input input_constructor output output_constructor error error_constructor runner].each { |e|
-          public_send(e)
-        }
+        %i[
+          input input_constructor
+          output output_constructor
+          error error_constructor
+          settings settings_constructor
+          result result_constructor
+          runner
+        ].each { |e| public_send(e) }
         nil
       end
 
@@ -351,7 +424,7 @@ module Teckel
       def finalize!
         define!
         @config.freeze
-        freeze
+        self
       end
 
       # Produces a shallow copy of this operation and all it's configuration.
@@ -378,8 +451,29 @@ module Teckel
         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)
@@ -390,6 +484,12 @@ module Teckel
     end
 
     module InstanceMethods
+      # @!attribute [r] settings()
+      # @return [Class,nil] When executed with settings, an instance of the
+      #   configured {.settings} class. Otherwise +nil+
+      # @see ClassMethods#settings
+      # @!visibility public
+
       # Halt any further execution with a output value
       #
       # @return a thing matching your {Operation::ClassMethods#output Operation#output} definition
@@ -410,12 +510,6 @@ module Teckel
     def self.included(receiver)
       receiver.extend         ClassMethods
       receiver.send :include, InstanceMethods
-
-      receiver.class_eval do
-        @config = Config.new
-
-        protected :success!, :fail!
-      end
     end
   end
 end