teckel 0.2.0 → 0.7.0

data/lib/teckel/operation/runner.rb

@@ -0,0 +1,74 @@
+# 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)
+        catch(:halt) do
+          op = instance
+          op_input = op.instance_exec(input, &operation.input_constructor)
+          op.call(op_input)
+          nil # return values need to go through +success!+ or +fail!+
+        end
+      end
+
+      def instance
+        return @instance if instance_variable_defined?(:@instance)
+
+        op = operation.new
+        op.runner = self
+        op.settings = settings if settings != UNDEFINED
+
+        @instance = op
+      end
+
+      # This is just here to raise a meaningful error.
+      # @!visibility private
+      def with(*)
+        raise Teckel::Error, "Operation already has settings assigned."
+      end
+
+      # Halt any further execution with a output value
+      #
+      # @return a thing matching your {Teckel::Operation::Config#output output} definition
+      # @!visibility protected
+      def success!(*args)
+        value =
+          if args.size == 1 && operation.output === args.first # rubocop:disable Style/CaseEquality
+            args.first
+          else
+            operation.output_constructor.call(*args)
+          end
+
+        throw :halt, instance.instance_exec(value, true, &operation.result_constructor)
+      end
+
+      # Halt any further execution with an error value
+      #
+      # @return a thing matching your {Teckel::Operation::Config#error error} definition
+      # @!visibility protected
+      def fail!(*args)
+        value =
+          if args.size == 1 && operation.error === args.first # rubocop:disable Style/CaseEquality
+            args.first
+          else
+            operation.error_constructor.call(*args)
+          end
+
+        throw :halt, instance.instance_exec(value, false, &operation.result_constructor)
+      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)
+        e = {}
+        e[:success] = successful? if keys.include?(:success)
+        e[:value] = value if keys.include?(:value)
+        e
+      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.2.0"
+  VERSION = "0.7.0"
 end

data/spec/chain/around_hook_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_db'
+require 'support/fake_models'
+
+module TeckelChainAroundHookTest
+  class CreateUser
+    include ::Teckel::Operation
+
+    result!
+
+    input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer.optional)
+    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)
+      else
+        fail!(message: "Could not safe User", errors: user.errors)
+      end
+    end
+  end
+
+  class AddFriend
+    include ::Teckel::Operation
+
+    result!
+
+    settings Struct.new(:fail_befriend)
+
+    input Types.Instance(User)
+    output Types::Hash.schema(user: Types.Instance(User), friend: Types.Instance(User))
+    error  Types::Hash.schema(message: Types::String)
+
+    def call(user)
+      if settings&.fail_befriend
+        fail!(message: "Did not find a friend.")
+      else
+        success! user: user, friend: User.new(name: "A friend", age: 42)
+      end
+    end
+  end
+
+  @stack = []
+  def self.stack
+    @stack
+  end
+
+  class Chain
+    include Teckel::Chain
+
+    around ->(chain, input) {
+      result = nil
+      begin
+        TeckelChainAroundHookTest.stack << :before
+
+        FakeDB.transaction do
+          result = chain.call(input)
+          raise FakeDB::Rollback if result.failure?
+        end
+
+        TeckelChainAroundHookTest.stack << :after
+        result
+      rescue FakeDB::Rollback
+        result
+      end
+    }
+
+    step :create, CreateUser
+    step :befriend, AddFriend
+  end
+end
+
+RSpec.describe Teckel::Chain do
+  before { TeckelChainAroundHookTest.stack.clear }
+
+  context "success" do
+    it "result matches" do
+      result = TeckelChainAroundHookTest::Chain.call(name: "Bob", age: 23)
+      expect(result.success).to include(user: kind_of(User), friend: kind_of(User))
+    end
+
+    it "runs around hook" do
+      TeckelChainAroundHookTest::Chain.call(name: "Bob", age: 23)
+      expect(TeckelChainAroundHookTest.stack).to eq([:before, :after])
+    end
+  end
+
+  context "failure" do
+    it "runs around hook" do
+      TeckelChainAroundHookTest::Chain.
+        with(befriend: :fail).
+        call(name: "Bob", age: 23)
+      expect(TeckelChainAroundHookTest.stack).to eq([:before])
+    end
+  end
+end

data/spec/chain/default_settings_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module TeckelChainDefaultSettingsTest
+  class MyOperation
+    include Teckel::Operation
+    result!
+
+    settings Struct.new(:say, :other)
+    settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) } # ruby 2.4 way for `keyword_init: true`
+
+    input none
+    output Hash
+    error none
+
+    def call(_)
+      success! settings.to_h
+    end
+  end
+
+  class Chain
+    include Teckel::Chain
+
+    default_settings!(a: { say: "Chain Default" })
+
+    step :a, MyOperation
+  end
+end
+
+RSpec.describe Teckel::Chain do
+  specify "call chain without settings, uses default settings" do
+    result = TeckelChainDefaultSettingsTest::Chain.call
+    expect(result.success).to eq(say: "Chain Default", other: nil)
+  end
+
+  specify "call chain with explicit settings, overwrites defaults" do
+    result = TeckelChainDefaultSettingsTest::Chain.with(a: { other: "What" }).call
+    expect(result.success).to eq(say: nil, other: "What")
+  end
+end

data/spec/chain/inheritance_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+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(_)
+      success! rand(1000)
+    end
+
+    finalize!
+  end
+
+  class OperationB
+    include Teckel::Operation
+
+    result!
+
+    input none
+    output Types::String
+    error none
+
+    def call(_)
+      success! ("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
+
+RSpec.describe Teckel::Chain do
+  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