teckel 0.4.0 → 0.8.0

data/lib/teckel/result.rb

@@ -47,16 +47,18 @@ module Teckel
       end
 
       def deconstruct_keys(keys)
-        {}.tap do |e|
-          e[:success] = successful? if keys.include?(:success)
-          e[:value] = value if keys.include?(:value)
-        end
+        e = {}
+        e[:success] = successful? if keys.include?(:success)
+        e[:value] = value if keys.include?(:value)
+        e
       end
     end
 
     def self.included(receiver)
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
+      receiver.class_eval do
+        extend  ClassMethods
+        include InstanceMethods
+      end
     end
   end
 end

data/lib/teckel/version.rb

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

data/lib/teckel.rb

@@ -19,4 +19,3 @@ require_relative "teckel/config"
 require_relative "teckel/contracts"
 require_relative "teckel/result"
 require_relative "teckel/operation"
-require_relative "teckel/chain"

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

@@ -3,72 +3,72 @@
 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
+module TeckelChainDefaultsViaBaseClass
+  LOG = [] # rubocop:disable Style/MutableConstant
 
-      around do |chain, input|
-        require 'benchmark'
-        result = nil
-        LOG << Benchmark.measure { result = chain.call(input) }
-        result
-      end
+  class LoggingChain
+    include Teckel::Chain
 
-      freeze
+    around do |chain, input|
+      require 'benchmark'
+      result = nil
+      LOG << Benchmark.measure { result = chain.call(input) }
+      result
     end
 
-    class OperationA
-      include Teckel::Operation
+    freeze
+  end
 
-      result!
+  class OperationA
+    include Teckel::Operation
 
-      input none
-      output Types::Integer
-      error none
+    result!
 
-      def call(_)
-        rand(1000)
-      end
+    input none
+    output Types::Integer
+    error none
 
-      finalize!
+    def call(_)
+      success! rand(1000)
     end
 
-    class OperationB
-      include Teckel::Operation
+    finalize!
+  end
 
-      result!
+  class OperationB
+    include Teckel::Operation
 
-      input none
-      output Types::String
-      error none
+    result!
 
-      def call(_)
-        ("a".."z").to_a.sample
-      end
+    input none
+    output Types::String
+    error none
 
-      finalize!
+    def call(_)
+      success! ("a".."z").to_a.sample
     end
 
-    class ChainA < LoggingChain
-      step :roll, OperationA
+    finalize!
+  end
 
-      finalize!
-    end
+  class ChainA < LoggingChain
+    step :roll, OperationA
 
-    class ChainB < LoggingChain
-      step :say, OperationB
+    finalize!
+  end
 
-      finalize!
-    end
+  class ChainB < LoggingChain
+    step :say, OperationB
 
-    class ChainC < ChainB
-      finalize!
-    end
+    finalize!
+  end
+
+  class ChainC < ChainB
+    finalize!
   end
+end
 
+RSpec.describe Teckel::Chain do
   before do
     TeckelChainDefaultsViaBaseClass::LOG.clear
   end

data/spec/chain/none_input_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TeckelChainNoneInputTest
+  class MyOperation
+    include Teckel::Operation
+    result!
+
+    settings Struct.new(:say)
+
+    input none
+    output String
+    error none
+
+    def call(_)
+      success!(settings&.say || "Called")
+    end
+  end
+
+  class Chain
+    include Teckel::Chain
+
+    step :a, MyOperation
+  end
+end
+
+RSpec.describe Teckel::Chain do
+  specify "call chain without input value" do
+    result = TeckelChainNoneInputTest::Chain.call
+    expect(result.success).to eq("Called")
+  end
+
+  specify "call chain runner without input value" do
+    result = TeckelChainNoneInputTest::Chain.with(a: "What").call
+    expect(result.success).to eq("What")
+  end
+end

data/spec/chain/results_spec.rb

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

data/spec/chain_spec.rb

@@ -3,68 +3,73 @@
 require 'support/dry_base'
 require 'support/fake_models'
 
-RSpec.describe Teckel::Chain do
-  module TeckelChainTest
-    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 save User", errors: user.errors)
-        end
+module TeckelChainTest
+  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 save User", errors: user.errors)
       end
     end
+  end
 
-    class LogUser
-      include ::Teckel::Operation
+  class LogUser
+    include ::Teckel::Operation
 
-      result!
+    result!
 
-      input Types.Instance(User)
-      error none
-      output input
+    input Types.Instance(User)
+    error none
+    output input
 
-      def call(usr)
-        Logger.new(File::NULL).info("User #{usr.name} created")
-        usr
-      end
+    def call(usr)
+      Logger.new(File::NULL).info("User #{usr.name} created")
+      success! usr
     end
+  end
 
-    class AddFriend
-      include ::Teckel::Operation
+  class AddFriend
+    include ::Teckel::Operation
 
-      result!
+    result!
 
-      settings Struct.new(:fail_befriend)
+    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)
+    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
-          { user: user, friend: User.new(name: "A friend", age: 42) }
-        end
+    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
 
-    class Chain
-      include Teckel::Chain
+  class Chain
+    include Teckel::Chain
 
-      step :create, CreateUser
-      step :log, LogUser
-      step :befriend, AddFriend
-    end
+    step :create, CreateUser
+    step :log, LogUser
+    step :befriend, AddFriend
+  end
+end
+
+RSpec.describe Teckel::Chain do
+  let(:frozen_error) do
+    # different ruby versions raise different errors
+    defined?(FrozenError) ? FrozenError : RuntimeError
   end
 
   it 'Chain input points to first step input' do
@@ -85,8 +90,7 @@ RSpec.describe Teckel::Chain do
 
   context "success" do
     it "result matches" do
-      result =
-        TeckelChainTest::Chain.
+      result = TeckelChainTest::Chain.
         with(befriend: nil).
         call(name: "Bob", age: 23)
 
@@ -96,8 +100,7 @@ RSpec.describe Teckel::Chain do
 
   context "failure" do
     it "returns a Result for invalid input" do
-      result =
-        TeckelChainTest::Chain.
+      result = TeckelChainTest::Chain.
         with(befriend: :fail).
         call(name: "Bob", age: 0)
 
@@ -108,8 +111,7 @@ RSpec.describe Teckel::Chain do
     end
 
     it "returns a Result for failed step" do
-      result =
-        TeckelChainTest::Chain.
+      result = TeckelChainTest::Chain.
         with(befriend: :fail).
         call(name: "Bob", age: 23)
 
@@ -121,11 +123,6 @@ RSpec.describe Teckel::Chain do
   end
 
   describe "#finalize!" do
-    let(:frozen_error) do
-      # different ruby versions raise different errors
-      defined?(FrozenError) ? FrozenError : RuntimeError
-    end
-
     subject { TeckelChainTest::Chain.dup }
 
     it "freezes the Chain class and operation classes" do
@@ -177,4 +174,82 @@ RSpec.describe Teckel::Chain do
       expect(subject.call).to eq(:mocked)
     end
   end
+
+  describe "#clone" do
+    subject { TeckelChainTest::Chain.dup }
+    let(:klone) { subject.clone }
+
+    it 'clones' do
+      expect(klone.object_id).not_to be_eql(subject.object_id)
+    end
+
+    it 'clones config' do
+      orig_config = subject.instance_variable_get(:@config)
+      klone_config = klone.instance_variable_get(:@config)
+      expect(klone_config.object_id).not_to be_eql(orig_config.object_id)
+    end
+
+    it 'clones steps' do
+      orig_settings = subject.instance_variable_get(:@config).instance_variable_get(:@config)[:steps]
+      klone_settings = klone.instance_variable_get(:@config).instance_variable_get(:@config)[:steps]
+
+      expect(orig_settings).to be_a(Array)
+      expect(klone_settings).to be_a(Array)
+      expect(klone_settings.object_id).not_to be_eql(orig_settings.object_id)
+    end
+  end
+
+  describe "frozen" do
+    subject { TeckelChainTest::Chain.dup }
+
+    it "also freezes the config" do
+      expect { subject.freeze }.to change {
+        [
+          subject.frozen?,
+          subject.instance_variable_get(:@config).frozen?
+        ]
+      }.from([false, false]).to([true, true])
+    end
+
+    it "prevents changes to steps" do
+      subject.freeze
+      expect {
+        subject.class_eval do
+          step :yet_other, TeckelChainTest::AddFriend
+        end
+      }.to raise_error(frozen_error)
+    end
+
+    it "prevents changes to config" do
+      subject.freeze
+      expect {
+        subject.class_eval do
+          default_settings!(a: { say: "Chain Default" })
+        end
+      }.to raise_error(frozen_error)
+    end
+
+    describe '#clone' do
+      subject { TeckelChainTest::Chain.dup }
+
+      it 'clones the class' do
+        subject.freeze
+        klone = subject.clone
+
+        expect(klone).to be_frozen
+        expect(klone.object_id).not_to be_eql(subject.object_id)
+      end
+
+      it 'cloned class uses the same, frozen config' do
+        subject.freeze
+        klone = subject.clone
+
+        orig_config = subject.instance_variable_get(:@config)
+        klone_config = klone.instance_variable_get(:@config)
+
+        expect(klone_config).to be_frozen
+        expect(klone_config.object_id).to be_eql(orig_config.object_id)
+      end
+    end
+  end
 end

data/spec/doctest_helper.rb

@@ -5,3 +5,4 @@ require_relative 'support/fake_db'
 require_relative 'support/fake_models'
 
 require "teckel"
+require "teckel/chain"