granite 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b350a3ec5e67ddb8963e53fd5662b907281bd99ae80bf2c56d1e38bc5aab1e91
-  data.tar.gz: e50e8205ed1c15b743c19162a707aaeb9e22aa56956b7cfc468c9c2ddaba9211
+  metadata.gz: aba08b5ac13d97ee80cad10e32e2099a7367a89ac7a93e9b9288f3a7bb41e11a
+  data.tar.gz: 1ecd0722b2a7560140cccbdb06583360f7537a46f996b188dc1a3ed4d9340982
 SHA512:
-  metadata.gz: e0bd294852f36a6e3995cc8bd2637093be985032d32645350f04fdad67c6897dafde07770ec53f720af43bb7b6470fe59643a3ba4784d97a829e35c8bc609fc7
-  data.tar.gz: 15c8c6b16d6514fd6b3699e99615e06b1f2ee523cd978bb3725891c969a991f81e72fba821d5e52064a4afe48c4875fd4aa4c77a5e499eb03f69b103a678b874
+  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.0.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

data/lib/rubocop/granite/plugin.rb

@@ -0,0 +1,32 @@
+require 'lint_roller'
+require 'granite/version'
+
+module RuboCop
+  module Granite
+    # Plugin integration for RuboCop's plugin system (1.72+).
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-granite',
+          version: ::Granite::VERSION,
+          homepage: 'https://github.com/toptal/granite',
+          description: 'Custom RuboCop configuration for Granite'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).parent.parent.parent.expand_path
+
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: project_root.join('config', 'rubocop-default.yml').to_s
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/granite.rb

@@ -1,9 +1,4 @@
 module RuboCop
   module Granite # :nodoc:
-    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'rubocop-default.yml').freeze
-    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
   end
 end

data/lib/rubocop-granite.rb

@@ -1,6 +1,4 @@
 require 'rubocop'
 
 require_relative 'rubocop/granite'
-require_relative 'rubocop/granite/inject'
-
-RuboCop::Granite::Inject.defaults!
+require_relative 'rubocop/granite/plugin'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: granite
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Toptal Engineering
@@ -225,14 +225,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.72.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.72.1
 - !ruby/object:Gem::Dependency
   name: rubocop-rails
   requirement: !ruby/object:Gem::Requirement
@@ -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
@@ -359,11 +363,12 @@ files:
 - lib/granite/version.rb
 - lib/rubocop-granite.rb
 - lib/rubocop/granite.rb
-- lib/rubocop/granite/inject.rb
+- lib/rubocop/granite/plugin.rb
 homepage: https://github.com/toptal/granite
 licenses:
 - MIT
 metadata:
+  default_lint_roller_plugin: RuboCop::Granite::Plugin
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -379,7 +384,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Another business actions architecture for Rails apps
 test_files: []

data/lib/rubocop/granite/inject.rb

@@ -1,18 +0,0 @@
-# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
-# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md
-module RuboCop
-  module Granite
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.load_file(path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        Rails.logger.debug { "configuration from #{path}" } if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end