teckel 0.3.0 → 0.4.0

data/lib/teckel/operation/result.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Teckel
+  module Operation
+    # The optional, default result object for {Teckel::Operation}s.
+    # Wraps +output+ and +error+ into a {Teckel::Operation::Result}.
+    #
+    # @example
+    #   class CreateUser
+    #     include Teckel::Operation
+    #
+    #     result!    # Shortcut to use this Result object
+    #
+    #     input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
+    #     output Types.Instance(User)
+    #     error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
+    #
+    #     def call(input)
+    #       user = User.new(name: input[:name], age: input[:age])
+    #       if user.save
+    #         success!(user) # exits early with success, prevents any further execution
+    #       else
+    #         fail!(message: "Could not save User", errors: user.errors)
+    #       end
+    #     end
+    #   end
+    #
+    #   # A success call:
+    #   CreateUser.call(name: "Bob", age: 23).is_a?(Teckel::Operation::Result) #=> true
+    #   CreateUser.call(name: "Bob", age: 23).success.is_a?(User) #=> true
+    #
+    #   # A failure call:
+    #   CreateUser.call(name: "Bob", age: 10).is_a?(Teckel::Operation::Result) #=> true
+    #   CreateUser.call(name: "Bob", age: 10).failure.is_a?(Hash) #=> true
+    #
+    # @!visibility public
+    class Result
+      include Teckel::Result
+
+      # @param value [Object] The result value
+      # @param success [Boolean] whether this is a successful result
+      def initialize(value, success)
+        @value = value
+        @success = (!!success).freeze
+      end
+
+      # Whether this is a success result
+      # @return [Boolean]
+      def successful?
+        @success
+      end
+
+      # @!attribute [r] value
+      # @return [Mixed] the value/payload
+      attr_reader :value
+
+      # Get the error/failure value
+      # @yield [Mixed] If a block is given and this is not a failure result, the value is yielded to the block
+      # @param  default [Mixed] return this default value if it's not a failure result
+      # @return [Mixed] the value/payload
+      def failure(default = nil, &block)
+        return @value unless @success
+        return yield(@value) if block
+
+        default
+      end
+
+      # Get the success value
+      # @yield [Mixed] If a block is given and this is not a success result, the value is yielded to the block
+      # @param  default [Mixed] return this default value if it's not a success result
+      # @return [Mixed] the value/payload
+      def success(default = nil, &block)
+        return @value if @success
+        return yield(@value) if block
+
+        default
+      end
+    end
+
+    # The default "no-op" Result handler. Just returns the value, ignoring the
+    # success state.
+    module ValueResult
+      class << self
+        def [](value, *_)
+          value
+        end
+
+        alias :new :[]
+      end
+    end
+  end
+end

data/lib/teckel/operation/runner.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Teckel
+  module Operation
+    # The default implementation for executing a single {Operation}
+    # @note You shouldn't need to call this explicitly.
+    #   Use {ClassMethods#with MyOperation.with()} or {ClassMethods#with MyOperation.call()} instead.
+    # @!visibility protected
+    class Runner
+      # @!visibility private
+      UNDEFINED = Object.new.freeze
+
+      def initialize(operation, settings = UNDEFINED)
+        @operation, @settings = operation, settings
+      end
+      attr_reader :operation, :settings
+
+      def call(input = nil)
+        err = catch(:failure) do
+          simple_return = UNDEFINED
+          out = catch(:success) do
+            simple_return = call!(build_input(input))
+          end
+          return simple_return == UNDEFINED ? build_output(*out) : build_output(simple_return)
+        end
+        build_error(*err)
+      end
+
+      # This is just here to raise a meaningful error.
+      # @!visibility private
+      def with(*)
+        raise Teckel::Error, "Operation already has settings assigned."
+      end
+
+      private
+
+      def call!(input)
+        op = @operation.new
+        op.settings = settings if settings != UNDEFINED
+        op.call(input)
+      end
+
+      def build_input(input)
+        operation.input_constructor.call(input)
+      end
+
+      def build_output(*args)
+        value =
+          if args.size == 1 && operation.output === args.first # rubocop:disable Style/CaseEquality
+            args.first
+          else
+            operation.output_constructor.call(*args)
+          end
+
+        operation.result_constructor.call(value, true)
+      end
+
+      def build_error(*args)
+        value =
+          if args.size == 1 && operation.error === args.first # rubocop:disable Style/CaseEquality
+            args.first
+          else
+            operation.error_constructor.call(*args)
+          end
+
+        operation.result_constructor.call(value, false)
+      end
+    end
+  end
+end

data/lib/teckel/result.rb

@@ -1,63 +1,62 @@
 # frozen_string_literal: true
 
 module Teckel
-  # Wrapper for +output+ and +error+ return values of Operations
-  #
-  # @example asking for status
-  #
-  #   Teckel::Result.new("some output", true).successful? #=> true
-  #   Teckel::Result.new("some output", true).failure? #=> false
-  #
-  #   Teckel::Result.new("some error", false).successful? #=> false
-  #   Teckel::Result.new("some error", false).failure? #=> true
-  #
-  # @example Use +.value+ to get the wrapped value regardless of success state
-  #
-  #   Teckel::Result.new("some output", true).value #=> "some output"
-  #   Teckel::Result.new("some error", false).value #=> "some error"
-  #
-  # @example Use +.success+ to get the wrapped value of a successful result
-  #
-  #  # Note: The +.failure+ method works just the same for successful results
-  #  Teckel::Result.new("some output", true).success #=> "some output"
-  #  Teckel::Result.new("some error", false).success #=> nil
-  #  Teckel::Result.new("some error", false).success("other default") #=> "other default"
-  #  Teckel::Result.new("some error", false).success { |value| "Failed: #{value}" } #=> "Failed: some error"
-  #
-  # @!visibility public
-  class Result
-    # @param value [Mixed] the value/payload of the result.
-    # @param success [Bool] whether this is a successful result
-    def initialize(value, success)
-      @value = value
-      @success = (!!success).freeze
+  # @abstract The interface an {Operation}s result object needs to adopt.
+  #
+  # @example
+  #   class MyResult
+  #     include Teckel::Result
+  #
+  #     def initialize(value, success)
+  #       @value = value
+  #       @success = (!!success).freeze
+  #     end
+  #
+  #     def successful?; @success end
+  #
+  #     def value; @value end
+  #   end
+  module Result
+    module ClassMethods
+      def [](value, success)
+        new(value, success)
+      end
     end
 
-    # @!attribute [r] value
-    # @return [Mixed] the value/payload
-    attr_reader :value
-
-    def successful?
-      @success
-    end
-
-    def failure?
-      !@success
-    end
-
-    def failure(default = nil, &block)
-      return @value if !@success
-      return yield(@value) if block
-
-      default
+    module InstanceMethods
+      # Whether this is a success result
+      # @return [Boolean]
+      def successful?
+        raise NotImplementedError, "Result object does not implement `successful?`"
+      end
+
+      # Whether this is a error/failure result
+      # @return [Boolean]
+      def failure?
+        !successful?
+      end
+
+      # @!attribute [r] value
+      # @return [Mixed] the value/payload
+      def value
+        raise NotImplementedError, "Result object does not implement `value`"
+      end
+
+      def deconstruct
+        [successful?, value]
+      end
+
+      def deconstruct_keys(keys)
+        {}.tap do |e|
+          e[:success] = successful? if keys.include?(:success)
+          e[:value] = value if keys.include?(:value)
+        end
+      end
     end
 
-    def success(default = nil, &block)
-      return @value if @success
-
-      return yield(@value) if block
-
-      default
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
     end
   end
 end

data/lib/teckel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teckel
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/chain/inheritance_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+RSpec.describe Teckel::Chain do
+  module TeckelChainDefaultsViaBaseClass
+    LOG = [] # rubocop:disable Style/MutableConstant
+
+    class LoggingChain
+      include Teckel::Chain
+
+      around do |chain, input|
+        require 'benchmark'
+        result = nil
+        LOG << Benchmark.measure { result = chain.call(input) }
+        result
+      end
+
+      freeze
+    end
+
+    class OperationA
+      include Teckel::Operation
+
+      result!
+
+      input none
+      output Types::Integer
+      error none
+
+      def call(_)
+        rand(1000)
+      end
+
+      finalize!
+    end
+
+    class OperationB
+      include Teckel::Operation
+
+      result!
+
+      input none
+      output Types::String
+      error none
+
+      def call(_)
+        ("a".."z").to_a.sample
+      end
+
+      finalize!
+    end
+
+    class ChainA < LoggingChain
+      step :roll, OperationA
+
+      finalize!
+    end
+
+    class ChainB < LoggingChain
+      step :say, OperationB
+
+      finalize!
+    end
+
+    class ChainC < ChainB
+      finalize!
+    end
+  end
+
+  before do
+    TeckelChainDefaultsViaBaseClass::LOG.clear
+  end
+
+  let(:base_chain) { TeckelChainDefaultsViaBaseClass::LoggingChain }
+  let(:chain_a) { TeckelChainDefaultsViaBaseClass::ChainA }
+  let(:chain_b) { TeckelChainDefaultsViaBaseClass::ChainB }
+  let(:chain_c) { TeckelChainDefaultsViaBaseClass::ChainC }
+
+  it "inherits config" do
+    expect(chain_a.around)
+    expect(chain_b.around)
+
+    expect(base_chain.steps).to eq([])
+    expect(chain_a.steps.size).to eq(1)
+    expect(chain_b.steps.size).to eq(1)
+  end
+
+  it "runs chain a" do
+    expect {
+      result = chain_a.call
+      expect(result.success).to be_a(Integer)
+    }.to change {
+      TeckelChainDefaultsViaBaseClass::LOG.size
+    }.from(0).to(1)
+  end
+
+  it "runs chain b" do
+    expect {
+      result = chain_b.call
+      expect(result.success).to be_a(String)
+    }.to change {
+      TeckelChainDefaultsViaBaseClass::LOG.size
+    }.from(0).to(1)
+  end
+
+  it "inherits steps" do
+    expect {
+      result = chain_c.call
+      expect(result.success).to be_a(String)
+    }.to change {
+      TeckelChainDefaultsViaBaseClass::LOG.size
+    }.from(0).to(1)
+  end
+end

data/spec/chain/results_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+RSpec.describe Teckel::Chain do
+  module TeckelChainResultTest
+    class Message
+      include ::Teckel::Operation
+
+      result!
+
+      input Types::Hash.schema(message: Types::String)
+      error none
+      output Types::String
+
+      def call(input)
+        input[:message].upcase
+      end
+    end
+
+    class Chain
+      include Teckel::Chain
+
+      step :message, Message
+
+      class Result < Teckel::Operation::Result
+        def initialize(value, success, step, opts = {})
+          super(value, success)
+          @step = step
+          @opts = opts
+        end
+
+        class << self
+          alias :[] :new # Alias the default constructor to :new
+        end
+
+        attr_reader :opts, :step
+      end
+
+      result_constructor ->(value, success, step) {
+        result.new(value, success, step, time: Time.now.to_i)
+      }
+    end
+  end
+
+  specify do
+    result = TeckelChainResultTest::Chain.call(message: "Hello World!")
+    expect(result).to be_successful
+    expect(result.success).to eq("HELLO WORLD!")
+    expect(result.opts).to include(time: kind_of(Integer))
+  end
+end