granite 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5b0fbb3a452b278fc48f954b8f05367a8ede9446e302c1b3a9deb60c8a35cae
-  data.tar.gz: 81b02115112d340abfb5bbb097ffee571cee9e6171c70da575e6d7af31d24ff8
+  metadata.gz: aba08b5ac13d97ee80cad10e32e2099a7367a89ac7a93e9b9288f3a7bb41e11a
+  data.tar.gz: 1ecd0722b2a7560140cccbdb06583360f7537a46f996b188dc1a3ed4d9340982
 SHA512:
-  metadata.gz: a44c19051bb35dc1e50498ae8ec8c640b2dbdca5f0f108de591c140c6bd626ea03cb1ab4e2b834cd5e71e3b3041e53386f6aa8c3d09634c720ac8314b26092be
-  data.tar.gz: 2d9b15191e799d152fb890a6addbaf2f8fac6e6fafcff8bf939e50003ed8fa8dc45edad8b98ea2c7bccde82831396eb5a5dee5027c9a5d988f480f9179db745f
+  metadata.gz: e27e82dd4dd6ba332792a01058fee3511f849eeaa708629c9bbf8a967323c96c751733f3a499ce8807814f09ccc4b3eec76485935a92fb9868df1b26faa57662
+  data.tar.gz: 6c3a899e08cf9b20342fe4accdf020ab7199674a522ae54a4ee79ddd66cdeb21852798ae995b3908ebc214b674e1184fa8b603d7e526a67c2f10fd392ef089d9

data/lib/granite/action/steps/inline_step_adapter.rb

@@ -0,0 +1,27 @@
+module Granite
+  class Action
+    module Steps
+      # Adapts `inline_step` interface to match that of a step action as needed.
+      class InlineStepAdapter
+        def initialize(action, block)
+          @action = action
+          @block = block
+        end
+
+        def perform!(**options)
+          @action.instance_exec(**options, &@block)
+        end
+
+        def assign_attributes(_attributes) end
+
+        def errors
+          {}
+        end
+
+        def failed_preconditions
+          []
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/steps/inline_step_definition.rb

@@ -0,0 +1,23 @@
+module Granite
+  class Action
+    module Steps
+      # Step definition for inline steps. Can be converted to step instance using {#to_step} method.
+      class InlineStepDefinition
+        attr_reader :options
+
+        def initialize(block, **options)
+          @block = block
+          @options = options
+        end
+
+        def to_step(action, _attributes)
+          InlineStepAdapter.new(action, @block)
+        end
+
+        def perform_with
+          :perform!
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/steps/step_definition.rb

@@ -0,0 +1,31 @@
+module Granite
+  class Action
+    module Steps
+      # Step definition for class steps. Can be converted to step instance using {#to_step} method.
+      class StepDefinition
+        attr_reader :options
+
+        def initialize(klass, required: true, attributes: {}, **options)
+          @klass = klass
+          @options = options
+          @required = required
+          @attribute_definitions = attributes
+        end
+
+        def to_step(parent, attributes)
+          subject_association = @klass.reflect_on_association(:subject)
+          subject = parent.public_send(subject_association.name) if subject_association
+          @klass.with(parent.ctx).new(*subject, attributes.merge(evaluated_attributes(parent)))
+        end
+
+        def perform_with
+          @required ? :perform! : :try_perform!
+        end
+
+        def evaluated_attributes(parent)
+          @attribute_definitions.to_h { |key, value| [key, parent.evaluate(value)] }
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/steps.rb

@@ -0,0 +1,113 @@
+require 'granite/action/steps/inline_step_adapter'
+require 'granite/action/steps/inline_step_definition'
+require 'granite/action/steps/step_definition'
+
+module Granite
+  class Action
+    # Implements steps DSL for Granite actions & other steps.
+    module Steps
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :step_definitions
+        self.step_definitions = {}
+      end
+
+      # Defines `step` and `inline_step` methods.
+      module ClassMethods
+        # Defines class based step in this action/step. If a block is passed it will be evaluated in the context of
+        # `step_class` to further customize the step.
+        # @param name [Symbol] name of the inline step, that should describe what this inline step performs.
+        #   Can be used to retrieve step instance using `action.step_name`.
+        # @param step_class [Class<Granite::Action>] class that will be used to perform this step.
+        # @param required [Boolean, :no_nested_preconditions] if set to `true` step will define its preconditions &
+        #   validations on parent action and will be called using `perform!`. If set to `:no_nested_preconditions`
+        #   step will define its validations on parent action but not preconditions and will be called using
+        #   `perform!`. If set to `false` step will not define its preconditions & validations on parent action and
+        #   will be called using `try_perform!`.
+        # @param options [Hash] any further options will be passed to nested validation & to step definition.
+        # @option options [Boolean, Symbol, Proc] :if will only perform/validate step if condition is satisfied
+        # @option options [Boolean, Symbol, Proc] :unless will only perform/validate step unless condition is
+        #   satisfied
+        # @option options [Hash{Symbol=>Boolean, Symbol, Proc}] :attributes additional attributes that will be
+        #   evaluated and passed when initializing step
+        def step(name, step_class, required: true, **options, &block)
+          if block
+            step_class = Class.new(step_class, &block)
+            const_set(name.to_s.classify, step_class)
+          end
+
+          add_step name, StepDefinition.new(step_class, **options, required:)
+          return unless required
+
+          validation_options = options.slice(:if, :unless)
+          precondition embedded: name, **validation_options unless required == :no_nested_preconditions
+          assign_data(**validation_options) { @steps[name].assign_data }
+          validates_nested name, **validation_options
+        end
+
+        # Defines inline step in this action/step. Any block passed to this method will be evaluated in the context
+        # of parent action/step when it's performed making it convenient method to define a block of code that needs
+        # to be executed when parent action/step is performed.
+        # @param name [Symbol] name of the inline step, that should describe what this inline step performs.
+        # @param options (Hash) any further options will be passed to step definition. These can be used to skip a
+        #   step completely under certain conditions by passing `if` or `unless` named parameters.
+        def inline_step(name, **options, &block)
+          add_step name, InlineStepDefinition.new(block, **options)
+        end
+
+        private
+
+        def add_step(name, definition)
+          self.step_definitions = step_definitions.merge(name => definition)
+          define_method(name) { @steps[name] }
+        end
+      end
+
+      def assign_attributes(attributes)
+        if @steps
+          @steps.each_value { |step| step.assign_attributes(attributes) }
+        else
+          @steps = {}
+          step_definitions.each { |identifier, definition| @steps[identifier] = definition.to_step(self, attributes) }
+        end
+
+        super
+      end
+
+      private
+
+      def execute_perform!(*)
+        @steps.each do |name, step|
+          definition = step_definitions[name]
+          step.public_send(definition.perform_with) if conditions_satisfied?(**definition.options)
+        end
+      end
+
+      def emerge_represented_attributes_errors!
+        super
+
+        @steps.each do |step_name, step|
+          keys_for_errors(step.errors).each { |attribute| emerge_errors!(step_name, attribute) }
+        end
+      end
+
+      def keys_for_errors(errors)
+        if errors.is_a?(ActiveModel::Errors)
+          errors.attribute_names
+        else
+          errors.keys
+        end
+      end
+
+      def emerge_errors!(nested_name, attribute)
+        key = :"#{nested_name}.#{attribute}"
+
+        errors.where(key).each do |error|
+          errors.import(error, attribute:)
+        end
+        errors.delete(key)
+      end
+    end
+  end
+end

data/lib/granite/action/subject.rb

@@ -62,10 +62,10 @@ module Granite
       end
 
       def assign_subject(args, attributes, reflection)
+        attributes = attributes.merge(reflection.name => args.first) unless args.empty?
         assign_attributes(attributes)
 
-        self.subject = args.first unless args.empty?
-        raise SubjectNotFoundError, self.class unless subject
+        raise SubjectNotFoundError, self.class if subject.nil?
       rescue Granite::Form::AssociationTypeMismatch
         raise SubjectTypeMismatchError.new(self.class, args.first.class.name, reflection.klass)
       end

data/lib/granite/action.rb

@@ -11,6 +11,7 @@ require 'granite/action/precondition'
 require 'granite/action/preconditions'
 require 'granite/action/policies'
 require 'granite/action/projectors'
+require 'granite/action/steps'
 require 'granite/action/subject'
 require 'granite/action/translations'
 
@@ -73,17 +74,9 @@ module Granite
       _run_initialize_callbacks
     end
 
-    if ActiveModel.version < Gem::Version.new('6.1.0')
-      def merge_errors(other_errors)
-        errors.messages.deep_merge!(other_errors.messages) do |_, this, other|
-          (this + other).uniq
-        end
-      end
-    else
-      def merge_errors(other_errors)
-        other_errors.each do |error|
-          errors.import(error) unless errors.messages[error.attribute].include?(error.message)
-        end
+    def merge_errors(other_errors)
+      other_errors.each do |error|
+        errors.import(error) unless errors.messages[error.attribute].include?(error.message)
       end
     end
 

data/lib/granite/version.rb

@@ -1,3 +1,3 @@
 module Granite
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: granite
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Toptal Engineering
@@ -321,6 +321,10 @@ files:
 - lib/granite/action/preconditions/embedded_precondition.rb
 - lib/granite/action/preconditions/object_precondition.rb
 - lib/granite/action/projectors.rb
+- lib/granite/action/steps.rb
+- lib/granite/action/steps/inline_step_adapter.rb
+- lib/granite/action/steps/inline_step_definition.rb
+- lib/granite/action/steps/step_definition.rb
 - lib/granite/action/subject.rb
 - lib/granite/action/transaction.rb
 - lib/granite/action/transaction_manager.rb
@@ -380,7 +384,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Another business actions architecture for Rails apps
 test_files: []