granite 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 171acd12e388c4b1016581a76445ff1ae6dc9051
+  data.tar.gz: be9fdc3c8d64c3caab3c4ee0f944cbe3892d965d
+SHA512:
+  metadata.gz: 4773a166e6b738430fa0300894bb4889c603404a2cba4dfc2a703000de1f7cb1679742abaf9e9ec2872f4edf1b397524abc3b0bc89b7c4ca99a57e44c5c33bbd
+  data.tar.gz: 61a75b1ecd04c0a43c13e8b06714080fdc31bdeeda6f6b0d52fabb19d9723fbfd73bf10a5747f4306962c96c8a214910e5796c74d9fe2dc63d84cdee463c69f9

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2018 Toptal
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/app/controllers/granite/controller.rb

@@ -0,0 +1,44 @@
+require 'granite/projector/translations/helper'
+require 'action_controller'
+
+module Granite
+  class Controller < Granite.base_controller_class
+    include Granite::Projector::Translations::Helper
+
+    singleton_class.__send__(:attr_accessor, :projector_class)
+    singleton_class.delegate :projector_path, :projector_name, :action_class, to: :projector_class
+    delegate :projector_path, :projector_name, :action_class, :projector_class, to: 'self.class'
+
+    abstract!
+
+    before_action :authorize_action!
+
+    def projector
+      @projector ||= begin
+        action_projector_class = action_class.public_send(projector_name)
+        if respond_to?(:projector_performer, true)
+          action_projector_class = action_projector_class.as(projector_performer)
+        end
+        action_projector_class.new(projector_params)
+      end
+    end
+    helper_method :projector
+
+    delegate :action, to: :projector
+    helper_method :action
+
+    def self.local_prefixes
+      [projector_path]
+    end
+
+    private
+
+    def projector_params
+      params
+    end
+
+    def authorize_action!
+      action.authorize!
+    end
+  end
+end

data/lib/generators/USAGE

@@ -0,0 +1,25 @@
+Description:
+    Generates a sample granite action.
+
+Example:
+    `rails generate granite user/create`
+
+    Will create:
+      apq/actions/ba/user/business_action.rb
+      apq/actions/ba/user/create.rb
+      spec/apq/actions/ba/user/create_spec.rb
+
+    `rails generate granite user/create -C`
+    `rails generate granite user/create --collection`
+
+    Will create:
+      apq/actions/ba/user/create.rb
+      spec/apq/actions/ba/user/create_spec.rb
+
+    `rails generate granite user/create simple`
+
+    Will create:
+      apq/actions/ba/user/create/simple/
+      apq/actions/ba/user/business_action.rb
+      apq/actions/ba/user/create.rb
+      spec/apq/actions/ba/user/create_spec.rb

data/lib/generators/granite/install_controller_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators/base'
+
+module Granite
+  module Generators
+    class InstallControllerGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../../..', __FILE__)
+
+      desc 'Creates a Granite::Controller for further customization'
+
+      def copy_controller
+        copy_file 'app/controllers/granite/controller.rb'
+      end
+    end
+  end
+end

data/lib/generators/granite_generator.rb

@@ -0,0 +1,32 @@
+class GraniteGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+
+  argument :projector, type: :string, required: false
+  class_option :collection, type: :boolean, aliases: '-C', desc: 'Generate collection action'
+
+  def create_action
+    template 'granite_action.rb.erb', "apq/actions/ba/#{file_path}.rb"
+    template 'granite_business_action.rb.erb', "apq/actions/ba/#{class_path.join('/')}/business_action.rb" unless options.collection?
+    template 'granite_base_action.rb.erb', 'apq/actions/base_action.rb', skip: true
+    template 'granite_action_spec.rb.erb', "spec/apq/actions/ba/#{file_path}_spec.rb"
+    empty_directory "apq/actions/ba/#{file_path}/#{projector}" if projector
+  end
+
+  private
+
+  def base_class_name
+    if options.collection?
+      'BaseAction'
+    else
+      "BA::#{class_path.join('/').camelize}::BusinessAction"
+    end
+  end
+
+  def subject_name
+    class_path.last
+  end
+
+  def subject_class_name
+    subject_name.classify
+  end
+end

data/lib/generators/templates/granite_action.rb.erb

@@ -0,0 +1,22 @@
+class BA::<%= class_name %> < <%= base_class_name %>
+<% if projector -%>
+  projector :<%= projector %>
+
+<% end -%>
+  allow_if { false }
+
+  precondition do
+  end
+<% if options.collection? -%>
+
+  def subject
+    @subject ||= <%= subject_class_name %>.new
+  end
+<% end -%>
+
+  private
+
+  def execute_perform!(*)
+    subject.save!
+  end
+end

data/lib/generators/templates/granite_action_spec.rb.erb

@@ -0,0 +1,45 @@
+require 'rails_helper'
+
+RSpec.describe BA::<%= class_name %> do
+<% if options.collection? -%>
+  subject(:action) { described_class.as(performer).new(attributes) }
+
+<% else -%>
+  subject(:action) { described_class.as(performer).new(<%= subject_name %>, attributes) }
+
+  let(:<%= subject_name %>) { <%= subject_class_name %>.new }
+<% end -%>
+  let(:performer) { double }
+  let(:attributes) { {} }
+
+  describe 'policies' do
+    it { is_expected.to be_allowed }
+
+    context 'when user is not authorized' do
+      it { is_expected.not_to be_allowed }
+    end
+  end
+
+  describe 'preconditions' do
+    it { is_expected.to satisfy_preconditions }
+
+    context 'when preconditions fail' do
+      it { is_expected.not_to satisfy_preconditions }
+    end
+  end
+
+  describe 'validations' do
+  end
+
+  describe '#perform!' do
+<% if options.collection? -%>
+    specify do
+      expect { perform! }.to change { <%= subject_class_name %>.count }.by(1)
+    end
+<% else -%>
+    specify do
+      expect { perform!(<%= subject_name %>) }.to change { <%= subject_name %>.reload.attributes }.to(attributes)
+    end
+<% end -%>
+  end
+end

data/lib/generators/templates/granite_base_action.rb.erb

@@ -0,0 +1,2 @@
+class BaseAction < Granite::Action
+end

data/lib/generators/templates/granite_business_action.rb.erb

@@ -0,0 +1,3 @@
+class BA::<%= class_path.join('/').camelize %>::BusinessAction < BaseAction
+  subject :<%= subject_name %>
+end

data/lib/granite.rb

@@ -0,0 +1,24 @@
+require 'active_support/dependencies'
+require 'action_controller'
+
+require 'granite/config'
+require 'granite/context'
+
+module Granite
+  def self.config
+    Granite::Config.instance
+  end
+
+  def self.context
+    Granite::Context.instance
+  end
+
+  singleton_class.delegate(*Granite::Config.delegated, to: :config)
+  singleton_class.delegate(*Granite::Context.delegated, to: :context)
+end
+
+require 'granite/dispatcher'
+require 'granite/action'
+require 'granite/projector'
+require 'granite/routing'
+require 'granite/rails' if defined?(::Rails)

data/lib/granite/action.rb

@@ -0,0 +1,106 @@
+require 'active_data'
+require 'active_record/errors'
+require 'active_record/validations'
+require 'active_support/callbacks'
+
+require 'granite/action/types'
+require 'granite/action/represents'
+require 'granite/action/error'
+require 'granite/action/performing'
+require 'granite/action/performer'
+require 'granite/action/preconditions'
+require 'granite/action/policies'
+require 'granite/action/projectors'
+require 'granite/action/translations'
+require 'granite/action/subject'
+
+module Granite
+  class Action
+    class ValidationError < Error
+      delegate :errors, to: :action
+
+      def initialize(action)
+        errors = action.errors.full_messages.join(', ')
+        super(I18n.t(:"#{action.class.i18n_scope}.errors.messages.action_invalid", action: action.class, errors: errors, default: :'errors.messages.action_invalid'), action)
+      end
+    end
+
+    # We are using a lot of stacked additional logic for `assign_attributes`
+    # At least, represented and nested attributes modules in ActiveData
+    # are having such a method redefiniions. Both are prepended to the
+    # Granite action, so we have to prepend our patch as well in order
+    # to put it above all other, so it will handle the attributes first.
+    module AssignAttributes
+      def assign_attributes(attributes)
+        attributes = attributes.to_unsafe_hash if attributes.respond_to?(:to_unsafe_hash)
+        attributes = attributes.stringify_keys
+        if attributes.key?(model_name.param_key)
+          attributes = attributes.merge(attributes.delete(model_name.param_key))
+        end
+        super(attributes)
+      end
+    end
+
+    include ActiveSupport::Callbacks
+    include ActiveData::Model
+    include ActiveData::Model::Representation
+    include ActiveData::Model::Associations
+    include ActiveData::Model::Dirty
+    include ActiveModel::Validations::Callbacks
+    include Performing
+    include Subject
+    include Performer
+    include Preconditions
+    include Policies
+    include Projectors
+    include Translations
+    include Represents
+    prepend AssignAttributes
+
+    handle_exception ActiveRecord::RecordInvalid do |e|
+      errors.messages.deep_merge!(e.record.errors.messages) do |_, this, other|
+        (this + other).uniq
+      end
+    end
+
+    handle_exception ActiveData::ValidationError do |e|
+      errors.messages.deep_merge!(e.model.errors.messages) do |_, this, other|
+        (this + other).uniq
+      end
+    end
+
+    handle_exception Granite::Action::ValidationError do |e|
+      errors.messages.deep_merge!(e.action.errors.messages) do |_, this, other|
+        (this + other).uniq
+      end
+    end
+
+    def self.i18n_scope
+      :granite_action
+    end
+
+    # Almost the same as Dirty `#changed?` method, but
+    # doesn't check subject reference key
+    def attributes_changed?(except: [])
+      except = Array.wrap(except).push(self.class.reflect_on_association(:subject).reference_key)
+      changed_attributes.except(*except).present?
+    end
+
+    # Check if action is allowed to execute by current performer (see {Granite.performer})
+    # and satisfy all defined preconditions
+    #
+    # @return [Boolean] whether action is performable
+    def performable?
+      unless instance_variable_defined?(:@performable)
+        @performable = allowed? && satisfy_preconditions?
+      end
+      @performable
+    end
+
+    protected
+
+    def raise_validation_error(original_error = nil)
+      fail ValidationError, self, original_error&.backtrace
+    end
+  end
+end

data/lib/granite/action/error.rb

@@ -0,0 +1,14 @@
+require 'granite/error'
+
+module Granite
+  class Action
+    class Error < Granite::Error
+      attr_reader :action
+
+      def initialize(message, action = nil)
+        @action = action
+        super(message)
+      end
+    end
+  end
+end

data/lib/granite/action/performer.rb

@@ -0,0 +1,23 @@
+require 'granite/performer_proxy'
+
+module Granite
+  class Action
+    # Performer module is responsible for setting performer for action.
+    #
+    module Performer
+      extend ActiveSupport::Concern
+
+      included do
+        include PerformerProxy
+        attr_reader :performer
+      end
+
+      def initialize(*args)
+        @performer = self.class.proxy_performer
+        super
+      end
+
+      delegate :id, to: :performer, prefix: true, allow_nil: true
+    end
+  end
+end

data/lib/granite/action/performing.rb

@@ -0,0 +1,132 @@
+require 'granite/action/transaction'
+require 'granite/action/error'
+
+module Granite
+  class Action
+    # Performing module used for defining perform procedure and error
+    # handling. Perform procedure is defined as block, which is
+    # executed in action instance context so all attributes are
+    # available there. Actions by default are performed in silent way
+    # (no validation exception raised), to raise exceptions, call bang
+    # method {Granite::Action::Performing#perform!}
+    #
+    # Defined exceptions handlers are also executed in action
+    # instance context, but additionally get raised exception as
+    # parameter.
+    #
+    module Performing
+      extend ActiveSupport::Concern
+
+      include Transaction
+
+      included do
+        class_attribute :_exception_handlers, instance_writer: false
+        self._exception_handlers = {}
+
+        protected :_exception_handlers
+
+        define_callbacks :execute_perform
+      end
+
+      module ClassMethods
+        # Register default handler for exceptions thrown inside execute_perform! method.
+        # @param klass Exception class, could be parent class too [Class]
+        # @param block [Block<Exception>] with default behavior for handling specified
+        #   type exceptions. First block argument is raised exception instance.
+        #
+        # @return [Hash<Class, Proc>] Registered handlers
+        def handle_exception(klass, &block)
+          self._exception_handlers = _exception_handlers.merge(klass => block)
+        end
+
+        def perform(*)
+          fail 'Perform block declaration was removed! Please declare `private def execute_perform!(*)` method'
+        end
+      end
+
+      # Check preconditions and validations for action and associated objects, then
+      # in case of valid action run defined procedure. Procedure is wrapped with
+      # database transaction. Returns the result of execute_perform! method execution
+      # or true if method execution returned false or nil
+      #
+      # @param context [Symbol] can be optionally provided to define which
+      #   validations to test against (the context is defined on validations
+      #   using `:on`)
+      # @return [Object] result of execute_perform! method execution or false in case of errors
+      def perform(context: nil, **options)
+        transactional do
+          valid?(context) && perform_action(options)
+        end
+      end
+
+      # Check precondition and validations for action and associated objects, then
+      # raise exception in case of validation errors. In other case run defined procedure.
+      # Procedure is wraped with database transaction. After procedure execution check for
+      # errors, and raise exception if any. Returns the result of execute_perform! method execution
+      # or true if block execution returned false or nil
+      #
+      # @param context [Symbol] can be optionally provided to define which
+      #   validations to test against (the context is defined on validations
+      #   using `:on`)
+      # @return [Object] result of execute_perform! method execution
+      # @raise [Granite::Action::ValidationError] Action or associated objects are invalid
+      # @raise [NotImplementedError] execute_perform! method was not defined yet
+      def perform!(context: nil, **options)
+        transactional do
+          validate!(context)
+          perform_action!(**options)
+        end
+      end
+
+      # Performs action if preconditions are satisfied.
+      #
+      # @param context [Symbol] can be optionally provided to define which
+      #   validations to test against (the context is defined on validations
+      #   using `:on`)
+      # @return [Object] result of execute_perform! method execution
+      # @raise [Granite::Action::ValidationError] Action or associated objects are invalid
+      # @raise [NotImplementedError] execute_perform! method was not defined yet
+      def try_perform!(context: nil, **options)
+        return unless satisfy_preconditions?
+        transactional do
+          perform!(context: context, **options)
+        end
+      end
+
+      # Checks if action was successfully performed or not
+      #
+      # @return [Boolean] whether action was successfully performed or not
+      def performed?
+        @_action_performed.present?
+      end
+
+      private
+
+      def perform_action(raise_errors: false, **options)
+        apply_association_changes!
+        result = run_callbacks(:execute_perform) { execute_perform!(options) }
+        @_action_performed = true
+        result || true
+      rescue *_exception_handlers.keys => e
+        handle_exception(e)
+        raise_validation_error(e) if raise_errors
+        raise Rollback
+      end
+
+      def perform_action!(**options)
+        perform_action(raise_errors: true, **options)
+      end
+
+      def execute_perform!(**_options)
+        fail NotImplementedError, "BA perform body MUST be defined for #{self}"
+      end
+
+      def handle_exception(e)
+        klass = e.class.ancestors.detect do |ancestor|
+          ancestor <= Exception && _exception_handlers[ancestor]
+        end
+        instance_exec(e, &_exception_handlers[klass]) if klass
+      end
+    end
+  end
+end