dry-transaction 0.10.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 679662590f13d07a84ae193679d65f448ddb9e54
-  data.tar.gz: 5810baddf36d0bfd0691acdcb663c5b866f04576
+SHA256:
+  metadata.gz: 6e276d629eb7ee813600d0cfce597d0857370b5ee44472de1495faa16f7db44f
+  data.tar.gz: 240ce1181835f188c975415c947b2b10f8f45de45d2ea6e0293af360d680796b
 SHA512:
-  metadata.gz: 57726a7d740fa0e5983690fe21956303d2f4db5a62ba16f2c8aa334c7dd40b92aefccdc3e13df2f568eed5cf2ee7b4707d0ad78a771c20c89652f29f3fea1049
-  data.tar.gz: 3c9de9200a701e364c397279c3a277c5f575b725afa62c87b7102f6c31ae747b9b3f6f93b5798a99bd026062bb932aeac8ea78925d8147b678897fe0f8cd90b1
+  metadata.gz: b6d04f7008727c783260df83e97221a5ebecc9b703da004d860bc040ed5334869d4844d2977cc5575e7a59ebd4a5ed95a6745aaa50981f7fb97aa777511265c2
+  data.tar.gz: b242f6281051877a0bc85f962e8655f3c92439388fa5790ad793ad34afbaa15a628f6f0aa8bc3484d250dd8be515232d18accca218a39a51a88d3c86d1f4bfe2

data/Gemfile

@@ -5,7 +5,7 @@ gemspec
 group :test do
   gem "simplecov"
   gem "codeclimate-test-reporter"
-  gem "byebug", platform: :mri
+  gem "pry-byebug", platform: :mri
   gem "dry-container"
 end
 

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    dry-transaction (0.10.2)
+    dry-transaction (0.11.0)
       dry-container (>= 0.2.8)
-      dry-matcher (>= 0.5.0)
-      dry-monads (>= 0.0.1)
-      wisper (>= 1.6.0)
+      dry-events (>= 0.1.0)
+      dry-matcher (>= 0.7.0)
+      dry-monads (>= 0.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.3.0)
-    byebug (8.2.2)
+    byebug (9.1.0)
     codeclimate-test-reporter (0.5.0)
       simplecov (>= 0.7.1, < 1.0.0)
     coderay (1.1.1)
@@ -23,12 +23,16 @@ GEM
     dry-container (0.6.0)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.3.1)
+    dry-core (0.4.2)
       concurrent-ruby (~> 1.0)
     dry-equalizer (0.2.0)
-    dry-matcher (0.6.0)
-    dry-monads (0.3.1)
-      dry-core
+    dry-events (0.1.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.4)
+      dry-equalizer (~> 0.2)
+    dry-matcher (0.7.0)
+    dry-monads (0.4.0)
+      dry-core (~> 0.3, >= 0.3.3)
       dry-equalizer
     json (1.8.6)
     method_source (0.8.2)
@@ -39,6 +43,9 @@ GEM
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
+    pry-byebug (3.5.0)
+      byebug (~> 9.1)
+      pry (~> 0.10)
     rainbow (2.1.0)
     rake (11.2.2)
     rspec (3.3.0)
@@ -68,7 +75,6 @@ GEM
     simplecov-html (0.10.0)
     slop (3.6.0)
     unicode-display_width (1.1.1)
-    wisper (2.0.0)
     yard (0.8.7.6)
 
 PLATFORMS
@@ -76,16 +82,16 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.15)
-  byebug
   codeclimate-test-reporter
   dry-container
   dry-transaction!
   pry
-  rake (~> 11.2.2)
-  rspec (~> 3.3.0)
+  pry-byebug
+  rake (~> 11.2, >= 11.2.2)
+  rspec (~> 3.3)
   rubocop
   simplecov
   yard
 
 BUNDLED WITH
-   1.15.1
+   1.16.1

data/lib/dry/transaction/builder.rb

@@ -1,4 +1,3 @@
-require "dry/monads/either"
 require "dry/transaction/step"
 require "dry/transaction/dsl"
 require "dry/transaction/instance_methods"
@@ -17,9 +16,8 @@ module Dry
 
       def included(klass)
         klass.extend(dsl_mod)
-        klass.send(:include, InstanceMethods)
-        klass.send(:prepend, resolver_mod)
-        klass.send(:include, Dry::Monads::Either::Mixin)
+        klass.include(InstanceMethods)
+        klass.prepend(resolver_mod)
       end
     end
   end

data/lib/dry/transaction/callable.rb

@@ -0,0 +1,38 @@
+module Dry
+  module Transaction
+    # @api private
+    class Callable
+      def self.[](callable)
+        if callable.is_a?(self)
+          callable
+        elsif callable.nil?
+          nil
+        else
+          new(callable)
+        end
+      end
+
+      attr_reader :operation
+      attr_reader :arity
+
+      def initialize(operation)
+        @operation = case operation
+                     when Proc, Method
+                       operation
+                     else
+                       operation.method(:call)
+                     end
+
+        @arity = @operation.arity
+      end
+
+      def call(*args, &block)
+        if arity.zero?
+          operation.(&block)
+        else
+          operation.(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/errors.rb

@@ -0,0 +1,27 @@
+module Dry
+  module Transaction
+    class InvalidStepError < ArgumentError
+      def initialize(step_name)
+        super("step +`#{step_name}`+ must respond to `#call`")
+      end
+    end
+
+    class MissingStepError < ArgumentError
+      def initialize(step_name)
+        super("Definition for step +`#{step_name}`+ is missing")
+      end
+    end
+
+    class InvalidResultError < ArgumentError
+      def initialize(step_name)
+        super("step +#{step_name}+ must return a Result object")
+      end
+    end
+
+    class MissingCatchListError < ArgumentError
+      def initialize(step_name)
+        super("step +#{step_name}+ requires one or more exception classes provided via +catch:+")
+      end
+    end
+  end
+end

data/lib/dry/transaction/instance_methods.rb

@@ -1,33 +1,38 @@
-require "dry/monads"
+require "dry/monads/result"
 require "dry/transaction/result_matcher"
+require "dry/transaction/stack"
 
 module Dry
   module Transaction
     module InstanceMethods
+      include Dry::Monads::Result::Mixin
+
       attr_reader :steps
       attr_reader :operations
       attr_reader :listeners
+      attr_reader :stack
 
       def initialize(steps: (self.class.steps), listeners: nil, **operations)
         @steps = steps.map { |step|
-          operation = methods.include?(step.step_name) ? method(step.step_name) : operations[step.step_name]
+          operation = resolve_operation(step, operations)
           step.with(operation: operation)
         }
         @operations = operations
+        @stack = Stack.new(@steps)
         subscribe(listeners) unless listeners.nil?
       end
 
-      def call(input, &block)
+      def call(input = nil, &block)
         assert_step_arity
 
-        result = steps.inject(Dry::Monads.Right(input), :bind)
+        result = stack.(Success(input))
 
         if block
           ResultMatcher.(result, &block)
         else
           result.or { |step_failure|
             # Unwrap the value from the StepFailure and return it directly
-            Dry::Monads.Left(step_failure.value)
+            Failure(step_failure.value)
           }
         end
       end
@@ -76,6 +81,18 @@ module Dry
         operation.(*args, &block)
       end
 
+      def resolve_operation(step, **operations)
+        if methods.include?(step.step_name) || private_methods.include?(step.step_name)
+          method(step.step_name)
+        elsif operations[step.step_name].nil?
+          raise MissingStepError.new(step.step_name)
+        elsif operations[step.step_name].respond_to?(:call)
+          operations[step.step_name]
+        else
+          raise InvalidStepError.new(step.step_name)
+        end
+      end
+
       def assert_valid_step_args(step_args)
         step_args.each_key do |step_name|
           unless steps.any? { |step| step.step_name == step_name }

data/lib/dry/transaction/operation.rb

@@ -1,14 +1,14 @@
-require "dry/monads/either"
+require "dry/monads/result"
 require "dry/matcher"
-require "dry/matcher/either_matcher"
+require "dry/matcher/result_matcher"
 
 module Dry
   module Transaction
     module Operation
       def self.included(klass)
         klass.class_eval do
-          include Dry::Monads::Either::Mixin
-          include Dry::Matcher.for(:call, with: Dry::Matcher::EitherMatcher)
+          include Dry::Monads::Result::Mixin
+          include Dry::Matcher.for(:call, with: Dry::Matcher::ResultMatcher)
         end
       end
     end

data/lib/dry/transaction/operation_resolver.rb

@@ -6,7 +6,11 @@ module Dry
           define_method :initialize do |**kwargs|
             operation_kwargs = self.class.steps.select(&:operation_name).map { |step|
               operation = kwargs.fetch(step.step_name) {
-                ops_container and ops_container.key?(step.operation_name) and ops_container[step.operation_name]
+                if ops_container && ops_container.key?(step.operation_name)
+                  ops_container[step.operation_name]
+                else
+                  nil
+                end
               }
 
               [step.step_name, operation]

data/lib/dry/transaction/result_matcher.rb

@@ -5,17 +5,17 @@ module Dry
     ResultMatcher = Dry::Matcher.new(
       success: Dry::Matcher::Case.new(
         match: -> result { result.right? },
-        resolve: -> result { result.value }
+        resolve: -> result { result.value! }
       ),
       failure: Dry::Matcher::Case.new(
         match: -> result, step_name = nil {
           if step_name
-            result.left? && result.value.step.step_name == step_name
+            result.left? && result.left.step.step_name == step_name
           else
             result.left?
           end
         },
-        resolve: -> result { result.value.value }
+        resolve: -> result { result.left.value }
       )
     )
   end

data/lib/dry/transaction/stack.rb

@@ -0,0 +1,24 @@
+module Dry
+  module Transaction
+    # @api private
+    class Stack
+      RETURN = -> x { x }
+
+      def initialize(steps)
+        @stack = compile(steps)
+      end
+
+      def call(m)
+        @stack.(m)
+      end
+
+      private
+
+      def compile(steps)
+        steps.reverse.reduce(RETURN) do |next_step, step|
+          proc { |m| m.bind { |value| step.(value, next_step) } }
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/step.rb

@@ -1,62 +1,78 @@
-require "dry/monads/either"
-require "wisper"
+require "dry/monads/result"
+require 'dry/events/publisher'
 require "dry/transaction/step_failure"
+require "dry/transaction/step_adapter"
 
 module Dry
   module Transaction
     # @api private
     class Step
       UNDEFINED = Object.new.freeze
+      RETURN = -> x { x }
 
-      include Wisper::Publisher
-      include Dry::Monads::Either::Mixin
+      include Dry::Events::Publisher[name || object_id]
+      include Dry::Monads::Result::Mixin
+
+      register_event(:step)
+      register_event(:step_succeeded)
+      register_event(:step_failed)
 
       attr_reader :step_adapter
       attr_reader :step_name
       attr_reader :operation_name
-      attr_reader :operation
-      attr_reader :options
       attr_reader :call_args
 
       def initialize(step_adapter, step_name, operation_name, operation, options, call_args = [])
-        @step_adapter = step_adapter
+        @step_adapter = StepAdapter[step_adapter, operation, **options, step_name: step_name]
         @step_name = step_name
         @operation_name = operation_name
-        @operation = operation
-        @options = options
         @call_args = call_args
       end
 
       def with(operation: UNDEFINED, call_args: UNDEFINED)
         return self if operation == UNDEFINED && call_args == UNDEFINED
-        new_operation = operation == UNDEFINED ? self.operation : operation
-        new_call_args = call_args == UNDEFINED ? self.call_args : call_args
+
+        new_operation = operation == UNDEFINED ? step_adapter.operation : operation
+        new_call_args = call_args == UNDEFINED ? self.call_args : Array(call_args)
 
         self.class.new(
           step_adapter,
           step_name,
           operation_name,
           new_operation,
-          options,
-          new_call_args,
+          step_adapter.options,
+          new_call_args
         )
       end
 
-      def call(input)
-        args = [input] + Array(call_args)
-        result = step_adapter.call(self, *args)
+      def call(input, continue = RETURN)
+        args = [input, *call_args]
+
+        if step_adapter.yields?
+          with_broadcast(args) { step_adapter.(args, &continue) }
+        else
+          continue.(with_broadcast(args) { step_adapter.(args) })
+        end
+      end
 
-        result.fmap { |value|
-          broadcast :"#{step_name}_success", value
+      def with_broadcast(args)
+        publish(:step, step_name: step_name, args: args)
+
+        yield.fmap { |value|
+          publish(:step_succeeded, step_name: step_name, args: args, value: value)
           value
         }.or { |value|
-          broadcast :"#{step_name}_failure", *args, value
-          Left(StepFailure.new(self, value))
+          publish(:step_failed, step_name: step_name, args: args, value: value)
+          Failure(StepFailure.new(self, value))
         }
       end
 
       def arity
-        operation.is_a?(Proc) ? operation.arity : operation.method(:call).arity
+        step_adapter.operation.arity
+      end
+
+      def operation
+        step_adapter.operation
       end
     end
   end

data/lib/dry/transaction/step_adapter.rb

@@ -0,0 +1,49 @@
+require "dry/transaction/callable"
+
+module Dry
+  module Transaction
+    # @api private
+    class StepAdapter
+      def self.[](adapter, operation, options)
+        if adapter.is_a?(self)
+          adapter.with(operation, options)
+        else
+          new(adapter, operation, options)
+        end
+      end
+
+      attr_reader :adapter
+      attr_reader :operation
+      attr_reader :options
+
+      def initialize(adapter, operation, options)
+        @adapter = case adapter
+                   when Proc, Method
+                     adapter
+                   else
+                     adapter.method(:call)
+                   end
+
+        @operation = Callable[operation]
+
+        @options = options
+
+        @yields = @adapter.
+                    parameters.
+                    any? { |type, _| type == :block }
+      end
+
+      def yields?
+        @yields
+      end
+
+      def call(args, &block)
+        adapter.(operation, options, args, &block)
+      end
+
+      def with(operation = self.operation, new_options = {})
+        self.class.new(adapter, operation, options.merge(new_options))
+      end
+    end
+  end
+end

data/lib/dry/transaction/step_adapters/around.rb

@@ -0,0 +1,25 @@
+require "dry/monads/result"
+require "dry/transaction/errors"
+
+module Dry
+  module Transaction
+    class StepAdapters
+      # @api private
+      class Around
+        include Dry::Monads::Result::Mixin
+
+        def call(operation, options, args, &block)
+          result = operation.(*args, &block)
+
+          unless result.is_a?(Dry::Monads::Result)
+            raise InvalidResultError.new(options[:step_name])
+          end
+
+          result
+        end
+      end
+
+      register :around, Around.new
+    end
+  end
+end

data/lib/dry/transaction/step_adapters/check.rb

@@ -0,0 +1,18 @@
+module Dry
+  module Transaction
+    class StepAdapters
+      # @api private
+      class Check
+        include Dry::Monads::Either::Mixin
+
+        def call(operation, _options, args)
+          input = args[0]
+          res = operation.(*args)
+          res == true || res.is_a?(Success) ? Success(input) : Failure(input)
+        end
+      end
+
+      register :check, Check.new
+    end
+  end
+end

data/lib/dry/transaction/step_adapters/map.rb

@@ -3,10 +3,10 @@ module Dry
     class StepAdapters
       # @api private
       class Map
-        include Dry::Monads::Either::Mixin
+        include Dry::Monads::Result::Mixin
 
-        def call(step, input, *args)
-          Right(step.operation.call(input, *args))
+        def call(operation, _options, args)
+          Success(operation.(*args))
         end
       end
 

data/lib/dry/transaction/step_adapters/raw.rb

@@ -1,20 +1,14 @@
-require "dry/monads/either"
+require "dry/monads/result"
+require "dry/transaction/errors"
+require "dry/transaction/step_adapters/around"
 
 module Dry
   module Transaction
     class StepAdapters
       # @api private
-      class Raw
-        include Dry::Monads::Either::Mixin
-
-        def call(step, input, *args)
-          result = step.operation.call(input, *args)
-
-          unless result.is_a?(Dry::Monads::Either)
-            raise ArgumentError, "step +#{step.step_name}+ must return an Either object"
-          end
-
-          result
+      class Raw < Around
+        def call(operation, options, args)
+          super(operation, options, args, &nil)
         end
       end
 

data/lib/dry/transaction/step_adapters/tee.rb

@@ -3,11 +3,11 @@ module Dry
     class StepAdapters
       # @api private
       class Tee
-        include Dry::Monads::Either::Mixin
+        include Dry::Monads::Result::Mixin
 
-        def call(step, input, *args)
-          step.operation.call(input, *args)
-          Right(input)
+        def call(operation, _options, args)
+          operation.(*args)
+          Success(args[0])
         end
       end
 

data/lib/dry/transaction/step_adapters/try.rb

@@ -1,19 +1,22 @@
+require "dry/transaction/errors"
+
 module Dry
   module Transaction
     class StepAdapters
       # @api private
       class Try
-        include Dry::Monads::Either::Mixin
+        include Dry::Monads::Result::Mixin
 
-        def call(step, input, *args)
-          unless step.options[:catch]
-            raise ArgumentError, "+try+ steps require one or more exception classes provided via +catch:+"
+        def call(operation, options, args)
+          unless options[:catch]
+            raise MissingCatchListError.new(options[:step_name])
           end
 
-          Right(step.operation.call(input, *args))
-        rescue *Array(step.options[:catch]) => e
-          e = step.options[:raise].new(e.message) if step.options[:raise]
-          Left(e)
+          result = operation.(*args)
+          Success(result)
+        rescue *Array(options[:catch]) => e
+          e = options[:raise].new(e.message) if options[:raise]
+          Failure(e)
         end
       end
 

data/lib/dry/transaction/step_adapters.rb

@@ -8,7 +8,9 @@ module Dry
   end
 end
 
+require "dry/transaction/step_adapters/check"
 require "dry/transaction/step_adapters/map"
 require "dry/transaction/step_adapters/raw"
 require "dry/transaction/step_adapters/tee"
 require "dry/transaction/step_adapters/try"
+require "dry/transaction/step_adapters/around"

data/lib/dry/transaction/version.rb

@@ -1,6 +1,6 @@
 module Dry
   # Business transaction DSL.
   module Transaction
-    VERSION = "0.10.2".freeze
+    VERSION = "0.11.0".freeze
   end
 end