Define transaction methods in extension modules only (#33)

Rather than the extension modules defining `#transaction` on the operation class itself, define it within the modules themselves, which still makes it available on the operation class.

Doing this allows the user to be able to define their _own_ `#transaction` on their operation classes, and then call `super` to get to the method provided by the module, which is the standard behaviour for modules and Ruby method lookups.

Author: timriley

lib/dry/operation/extensions/active_record.rb

@@ -96,33 +96,34 @@ def initialize(connection, **options)
             @options = options
           end
 
-          def included(klass)
-            class_exec(@connection, @options) do |default_connection, options|
-              # @!method transaction(connection = ActiveRecord::Base, **options, &steps)
-              #   Wrap the given steps in an ActiveRecord transaction.
-              #
-              #   If any of the steps returns a `Dry::Monads::Result::Failure`, the
-              #   transaction will be rolled back and `:halt` will be thrown with the
-              #   failure as its value.
-              #
-              #   @param connection [#transaction] The class/object to use
-              #   @param options [Hash] Additional options for the ActiveRecord transaction
-              #   @yieldreturn [Object] the result of the block
-              #   @see Dry::Operation#steps
-              #   @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-transaction
-              klass.define_method(:transaction) do |connection = default_connection, **opts, &steps|
-                intercepting_failure do
-                  result = nil
-                  connection.transaction(**options.merge(opts)) do
-                    intercepting_failure(->(failure) {
-                                           result = failure
-                                           raise ::ActiveRecord::Rollback
-                                         }) do
-                      result = steps.()
-                    end
+          def included(_klass)
+            default_connection = @connection
+            default_options = @options
+
+            # @!method transaction(connection = ActiveRecord::Base, **options, &steps)
+            #   Wrap the given steps in an ActiveRecord transaction.
+            #
+            #   If any of the steps returns a `Dry::Monads::Result::Failure`, the
+            #   transaction will be rolled back and `:halt` will be thrown with the
+            #   failure as its value.
+            #
+            #   @param connection [#transaction] The class/object to use
+            #   @param options [Hash] Additional options for the ActiveRecord transaction
+            #   @yieldreturn [Object] the result of the block
+            #   @see Dry::Operation#steps
+            #   @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-transaction
+            define_method(:transaction) do |connection = default_connection, **opts, &steps|
+              intercepting_failure do
+                result = nil
+                connection.transaction(**default_options.merge(opts)) do
+                  intercepting_failure(->(failure) {
+                    result = failure
+                    raise ::ActiveRecord::Rollback
+                  }) do
+                    result = steps.()
                   end
-                  result
                 end
+                result
               end
             end
           end

lib/dry/operation/extensions/rom.rb

@@ -95,26 +95,26 @@ def initialize(gateway:)
             @gateway = gateway
           end
 
-          def included(klass)
-            class_exec(@gateway) do |default_gateway|
-              klass.define_method(:transaction) do |gateway: default_gateway, &steps|
-                raise Dry::Operation::ExtensionError, <<~MSG unless respond_to?(:rom)
-                  When using the ROM extension, you need to define a #rom method \
-                  that returns the ROM container
-                MSG
+          def included(_klass)
+            default_gateway = @gateway
 
-                intercepting_failure do
-                  result = nil
-                  rom.gateways[gateway].transaction do |t|
-                    intercepting_failure(->(failure) {
-                                           result = failure
-                                           t.rollback!
-                                         }) do
-                      result = steps.()
-                    end
+            define_method(:transaction) do |gateway: default_gateway, &steps|
+              raise Dry::Operation::ExtensionError, <<~MSG unless respond_to?(:rom)
+                When using the ROM extension, you need to define a #rom method \
+                that returns the ROM container
+              MSG
+
+              intercepting_failure do
+                result = nil
+                rom.gateways[gateway].transaction do |t|
+                  intercepting_failure(->(failure) {
+                                         result = failure
+                                         t.rollback!
+                                       }) do
+                    result = steps.()
                   end
-                  result
                 end
+                result
               end
             end
           end

lib/dry/operation/extensions/sequel.rb

@@ -81,26 +81,26 @@ def initialize(**options)
             @options = options
           end
 
-          def included(klass)
-            class_exec(@options) do |default_options|
-              klass.define_method(:transaction) do |**opts, &steps|
-                raise Dry::Operation::ExtensionError, <<~MSG unless respond_to?(:db)
-                  When using the Sequel extension, you need to define a #db method \
-                  that returns the Sequel database object
-                MSG
+          def included(_klass)
+            default_options = @options
 
-                intercepting_failure do
-                  result = nil
-                  db.transaction(**default_options.merge(opts)) do
-                    intercepting_failure(->(failure) {
-                      result = failure
-                      raise ::Sequel::Rollback
-                    }) do
-                      result = steps.()
-                    end
+            define_method(:transaction) do |**opts, &steps|
+              raise Dry::Operation::ExtensionError, <<~MSG unless respond_to?(:db)
+                When using the Sequel extension, you need to define a #db method \
+                that returns the Sequel database object
+              MSG
+
+              intercepting_failure do
+                result = nil
+                db.transaction(**default_options.merge(opts)) do
+                  intercepting_failure(->(failure) {
+                    result = failure
+                    raise ::Sequel::Rollback
+                  }) do
+                    result = steps.()
                   end
-                  result
                 end
+                result
               end
             end
           end