dry-transaction 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19a5598d0c611fa9cd909c25cd76fccee443f925
-  data.tar.gz: f7dd7277b815393f51b7eb8cac00db2d8011ab83
+  metadata.gz: 92a7c9469ad9306d832f60efe3bd036a9ddd9db6
+  data.tar.gz: 5ee2b52c8fabcc6d1e0e83ec7c1725a07bce23a7
 SHA512:
-  metadata.gz: 3310c5583f9fc9c3d84dad54db9b71908227309e4325adc9f38d3a26aca64a699a66e75d0a3d05173beaf002d246fea7ed434300793ad1308bd6638fbb404505
-  data.tar.gz: 6dea0341d58c8da07a06bb1ec2fbb82ca793a47969f6f4acacf29dd445996910fdbcc9f096f0d286b4aabcef6343a946262f3b98197155059010294e3f9eb448
+  metadata.gz: bebec4fe3081d08e5d2c7942dd0d2ece14f6494419cb9c36ee7e8ea1e6c992bf6ffd4eba692248b51f68e9c0cb8072d9f3e7cb597145b1a95b33703e3f0820a8
+  data.tar.gz: f50379b4acf9cc3d54d8748cd8edcf149ed1f972529876ed8f19ac971ebb60e8d5e29b3922817009cdcbc4397788e0d37f970e3f01d5e296b9e00994f26febdc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dry-transaction (0.9.0)
+    dry-transaction (0.10.0)
       dry-container (>= 0.2.8)
       dry-matcher (>= 0.5.0)
       dry-monads (>= 0.0.1)
@@ -15,10 +15,10 @@ GEM
     codeclimate-test-reporter (0.5.0)
       simplecov (>= 0.7.1, < 1.0.0)
     coderay (1.1.1)
-    concurrent-ruby (1.0.2)
+    concurrent-ruby (1.0.5)
     diff-lcs (1.2.5)
     docile (1.1.5)
-    dry-configurable (0.4.0)
+    dry-configurable (0.7.0)
       concurrent-ruby (~> 1.0)
     dry-container (0.6.0)
       concurrent-ruby (~> 1.0)
@@ -27,7 +27,7 @@ GEM
     dry-matcher (0.6.0)
     dry-monads (0.2.0)
       dry-equalizer
-    json (1.8.3)
+    json (1.8.6)
     method_source (0.8.2)
     parser (2.3.1.4)
       ast (~> 2.2)
@@ -72,7 +72,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.13.1)
+  bundler (~> 1.15)
   byebug
   codeclimate-test-reporter
   dry-transaction!
@@ -84,4 +84,4 @@ DEPENDENCIES
   yard
 
 BUNDLED WITH
-   1.13.2
+   1.15.1

data/README.md

@@ -1,15 +1,19 @@
 [gitter]: https://gitter.im/dry-rb/chat
-[gem]: https://rubygems.org/gems/dry-transaction
+[gem]: https://img.shields.io/gem/v/dry-transaction.svg]
 [travis]: https://travis-ci.org/dry-rb/dry-transaction
-[code_climate]: https://codeclimate.com/github/dry-rb/dry-transaction
-[inch]: http://inch-ci.org/github/dry-rb/dry-transaction
+[gemnasium]: https://gemnasium.com/dry-rb/dry-transaction
+[codeclimate]: https://codeclimate.com/github/dry-rb/dry-transaction
+[coveralls]: https://coveralls.io/r/dry-rb/dry-transaction
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-transaction
 
-# dry-transaction [![Join the Gitter chat](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+# dry-transaction [![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dry-rb/chat)
 
-[![Gem Version](https://img.shields.io/gem/v/dry-transaction.svg)][gem]
+[![Gem Version](https://badge.fury.io/rb/dry-transaction.svg)][gem]
 [![Build Status](https://travis-ci.org/dry-rb/dry-transaction.svg?branch=master)][travis]
-[![Code Climate](https://img.shields.io/codeclimate/github/dry-rb/dry-transaction.svg)][code_climate]
-[![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-transaction.svg)][inch]
+[![Dependency Status](https://gemnasium.com/dry-rb/dry-transaction.svg)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/dry-rb/dry-transaction/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/dry-rb/dry-transaction/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-transaction.svg?branch=master)][inchpages]
 
 dry-transaction is a business transaction DSL. It provides a simple way to define a complex business transaction that includes processing by many different objects.
 

data/lib/dry/transaction.rb

@@ -1,26 +1,35 @@
 require "dry/monads/either"
 require "dry/transaction/version"
-require "dry/transaction/dsl"
-require "dry/transaction/api"
+require "dry/transaction/step_adapters"
+require "dry/transaction/builder"
 
 module Dry
-  # Define a business transaction.
+  # Business transaction DSL
+  module Transaction
+    def self.included(klass)
+      klass.send :include, Dry::Transaction()
+    end
+  end
+
+  # Build a module to make your class a business transaction.
   #
   # A business transaction is a series of callable operation objects that
   # receive input and produce an output.
   #
-  # The operations should be addressable via `#[]` in a container object that
-  # you pass when creating the transaction. The operations must respond to
-  # `#call(input, *args)`.
+  # The operations can be instance methods, or objects addressable via `#[]` in
+  # a container object that you pass when mixing in this module. The operations
+  # must respond to `#call(input, *args)`.
   #
   # Each operation will be called in the order it was specified in your
   # transaction, with its output passed as the input to the next operation.
   # Operations will only be called if the previous step was a success.
   #
-  # A step is successful when it returns a [dry-monads](dry-monads) `Right` object
-  # wrapping its output value. A step is a failure when it returns a `Left`
-  # object.  If your operations already return a `Right` or `Left`, they can be
-  # added to your operation as plain `step` steps.
+  # A step is successful when it returns a [dry-monads](dry-monads) `Right`
+  # object wrapping its output value. A step is a failure when it returns a
+  # `Left` object.  If your operations already return a `Right` or `Left`, they
+  # can be added to your operation as plain `step` steps.
+  #
+  # Add operation to your transaction with the `step` method.
   #
   # If your operations don't already return `Right` or `Left`, then they can be
   # added to the transaction with the following steps:
@@ -34,46 +43,29 @@ module Dry
   # [dry-monads]: https://rubygems.org/gems/dry-monads
   #
   # @example
-  #   container = {do_first: some_obj, do_second: some_obj}
+  #   class MyTransaction
+  #     include Dry::Transaction(container: MyContainer)
+  #
+  #     step :first_step, with: "my_container.operations.first"
+  #     step :second_step
   #
-  #   my_transaction = Dry.Transaction(container: container) do
-  #     step :do_first
-  #     step :do_second
+  #     def second_step(input)
+  #       result = do_something_with(input)
+  #       Right(result)
+  #     end
   #   end
   #
+  #   my_transaction = MyTransaction.new
   #   my_transaction.call(some_input)
   #
-  # @param options [Hash] the options hash
-  # @option options [#[]] :container the operations container
-  # @option options [#[]] :step_adapters (Dry::Transaction::StepAdapters) a custom container of step adapters
-  # @option options [Dry::Matcher] :matcher (Dry::Transaction::ResultMatcher) a custom matcher object for result matching block API
+  # @param container [#[]] the operations container
+  # @param step_adapters [#[]] (Dry::Transaction::StepAdapters) a
+  # custom container of step adapters
   #
-  # @return [Dry::Transaction] the transaction object
+  # @return [Module] the transaction module
   #
   # @api public
-  def self.Transaction(options = {}, &block)
-    Transaction::DSL.new(options, &block).call
-  end
-
-  # This is the class that actually stores the transaction.
-  # To be precise, it stores a series of steps that make up a transaction and
-  # a matcher for handling the result of the transaction.
-  #
-  # Never instantiate this class directly, it is intended to be created through
-  # the provided DSL.
-  class Transaction
-    include API
-
-    # @api private
-    attr_reader :steps
-
-    # @api private
-    attr_reader :matcher
-
-    # @api private
-    def initialize(steps, matcher)
-      @steps = steps
-      @matcher = matcher
-    end
+  def self.Transaction(container: nil, step_adapters: Transaction::StepAdapters)
+    Transaction::Builder.new(container: container, step_adapters: step_adapters)
   end
 end

data/lib/dry/transaction/builder.rb

@@ -0,0 +1,26 @@
+require "dry/monads/either"
+require "dry/transaction/step"
+require "dry/transaction/dsl"
+require "dry/transaction/instance_methods"
+require "dry/transaction/operation_resolver"
+
+module Dry
+  module Transaction
+    class Builder < Module
+      attr_reader :dsl_mod
+      attr_reader :resolver_mod
+
+      def initialize(container: nil, step_adapters:)
+        @dsl_mod = DSL.new(step_adapters: step_adapters)
+        @resolver_mod = OperationResolver.new(container)
+      end
+
+      def included(klass)
+        klass.extend(dsl_mod)
+        klass.send(:include, InstanceMethods)
+        klass.send(:prepend, resolver_mod)
+        klass.send(:include, Dry::Monads::Either::Mixin)
+      end
+    end
+  end
+end

data/lib/dry/transaction/dsl.rb

@@ -1,51 +1,43 @@
-require "dry/transaction/result_matcher"
-require "dry/transaction/step"
-require "dry/transaction/step_adapters"
-require "dry/transaction/step_definition"
-
 module Dry
-  class Transaction
-    # @api private
-    class DSL < BasicObject
-      attr_reader :container
-      attr_reader :step_adapters
-      attr_reader :steps
-      attr_reader :matcher
-
-      def initialize(options, &block)
-        @container = options.fetch(:container)
-        @step_adapters = options.fetch(:step_adapters) { StepAdapters }
-        @steps = []
-        @matcher = options.fetch(:matcher) { ResultMatcher }
+  module Transaction
+    class DSL < Module
+      def initialize(step_adapters:)
+        @step_adapters = step_adapters
 
-        instance_eval(&block)
+        define_steps
+        define_dsl
       end
 
-      def respond_to_missing?(method_name)
-        step_adapters.key?(method_name)
+      def inspect
+        "Dry::Transaction::DSL(#{@step_adapters.keys.sort.join(', ')})"
       end
 
-      def method_missing(method_name, *args, &block)
-        return super unless step_adapters.key?(method_name)
-
-        step_adapter = step_adapters[method_name]
-        step_name = args.first
-        options = args.last.is_a?(::Hash) ? args.last : {}
-        with = options.delete(:with)
+      private
 
-        if with.respond_to?(:call)
-          operation_name = step_name
-          operation = StepDefinition.new(container, &with)
-        else
-          operation_name = with || step_name
-          operation = container[operation_name]
+      def define_steps
+        module_eval do
+          define_method(:steps) do
+            @steps ||= []
+          end
         end
-
-        steps << Step.new(step_adapter, step_name, operation_name, operation, options, &block)
       end
 
-      def call
-        Transaction.new(steps, matcher)
+      def define_dsl
+        module_exec(@step_adapters) do |step_adapters|
+          step_adapters.keys.each do |adapter_name|
+            define_method(adapter_name) do |step_name, with: nil, **options|
+              operation_name = with || step_name
+
+              steps << Step.new(
+                step_adapters[adapter_name],
+                step_name,
+                operation_name,
+                nil, # operations are resolved only when transactions are instantiated
+                options,
+              )
+            end
+          end
+        end
       end
     end
   end

data/lib/dry/transaction/instance_methods.rb

@@ -0,0 +1,95 @@
+require "dry/monads"
+require "dry/transaction/result_matcher"
+
+module Dry
+  module Transaction
+    module InstanceMethods
+      attr_reader :steps
+      attr_reader :operations
+
+      def initialize(steps: (self.class.steps), **operations)
+        @steps = steps.map { |step|
+          operation = methods.include?(step.step_name) ? method(step.step_name) : operations[step.step_name]
+          step.with(operation: operation)
+        }
+        @operations = operations
+      end
+
+      def call(input, &block)
+        assert_step_arity
+
+        result = steps.inject(Dry::Monads.Right(input), :bind)
+
+        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)
+          }
+        end
+      end
+
+      def subscribe(listeners)
+        if listeners.is_a?(Hash)
+          listeners.each do |step_name, listener|
+            steps.detect { |step| step.step_name == step_name }.subscribe(listener)
+          end
+        else
+          steps.each do |step|
+            step.subscribe(listeners)
+          end
+        end
+      end
+
+      def with_step_args(**step_args)
+        assert_valid_step_args(step_args)
+
+        new_steps = steps.map { |step|
+          if step_args[step.step_name]
+            step.with(call_args: step_args[step.step_name])
+          else
+            step
+          end
+        }
+
+        self.class.new(steps: new_steps, **operations)
+      end
+
+      private
+
+      def respond_to_missing?(name, _include_private = false)
+        steps.any? { |step| step.step_name == name }
+      end
+
+      def method_missing(name, *args, &block)
+        step = steps.detect { |s| s.step_name == name }
+        super unless step
+
+        operation = operations[step.step_name]
+        raise NotImplementedError, "no operation +#{step.operation_name}+ defined for step +#{step.step_name}+" unless operation
+
+        operation.(*args, &block)
+      end
+
+      def assert_valid_step_args(step_args)
+        step_args.each_key do |step_name|
+          unless steps.any? { |step| step.step_name == step_name }
+            raise ArgumentError, "+#{step_name}+ is not a valid step name"
+          end
+        end
+      end
+
+      def assert_step_arity
+        steps.each do |step|
+          num_args_required = step.arity >= 0 ? step.arity : ~step.arity
+          num_args_supplied = step.call_args.length + 1 # add 1 for main `input`
+
+          if num_args_required > num_args_supplied
+            raise ArgumentError, "not enough arguments supplied for step +#{step.step_name}+"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/operation.rb

@@ -0,0 +1,16 @@
+require "dry/monads/either"
+require "dry/matcher"
+require "dry/matcher/either_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)
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/operation_resolver.rb

@@ -0,0 +1,19 @@
+module Dry
+  module Transaction
+    class OperationResolver < Module
+      def initialize(container)
+        module_exec(container) do |ops_container|
+          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[step.operation_name] }
+
+              [step.step_name, operation]
+            }.to_h
+
+            super(**kwargs, **operation_kwargs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/result_matcher.rb

@@ -1,7 +1,7 @@
-require "dry-matcher"
+require "dry/matcher"
 
 module Dry
-  class Transaction
+  module Transaction
     ResultMatcher = Dry::Matcher.new(
       success: Dry::Matcher::Case.new(
         match: -> result { result.right? },