granite 0.7.0

data/lib/granite/action/policies.rb

@@ -0,0 +1,92 @@
+require 'granite/action/error'
+require 'granite/action/policies/any_strategy'
+require 'granite/action/policies/always_allow_strategy'
+require 'granite/action/policies/required_performer_strategy'
+
+module Granite
+  class Action
+    class NotAllowedError < Error
+      def initialize(action)
+        if action.performer.respond_to?(:id) && action.performer.id.present?
+          performer_id = "##{action.performer.id}"
+        end
+
+        super("#{action.class} action is not allowed " \
+              "for #{action.performer.class}#{performer_id}", action)
+      end
+    end
+
+    # Policies module used for abilities definition. Basically
+    # policies are defined as blocks which are executed in action
+    # instance context, so performer, object and all the attributes
+    # are available inside the block.
+    #
+    # By default action is allowed to be performed only by default performer.
+    #
+    module Policies
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_policies, :_policies_strategy, instance_writer: false
+        self._policies = []
+        self._policies_strategy = AnyStrategy
+      end
+
+      module ClassMethods
+        # The simplies policy. Takes block and executes it returning
+        # boolean result. Multiple policies are reduced with ||
+        #
+        #   class Action < Granite::Action
+        #     allow_if { performer.is_a?(Recruiter) }
+        #     allow_if { performer.is_a?(AdvancedRecruiter) }
+        #   end
+        #
+        # The first argument in block is a current action performer,
+        # so it is possible to use a short-cut performer methods:
+        #
+        #   class Action < Granite::Action
+        #     allow_if(&:staff?)
+        #   end
+        #
+        def allow_if(&block)
+          self._policies += [block]
+        end
+
+        def allow_self
+          allow_if { performer == subject }
+        end
+      end
+
+      def try_perform!(*)
+        authorize!
+        super
+      end
+
+      def perform(*)
+        authorize!
+        super
+      end
+
+      def perform!(*)
+        authorize!
+        super
+      end
+
+      # Returns true if any of defined policies returns true
+      #
+      def allowed?
+        unless instance_variable_defined?(:@allowed)
+          @allowed = _policies_strategy.allowed?(self)
+        end
+        @allowed
+      end
+
+      # Raises Granite::Action::NotAllowedError if action is not allowed
+      #
+      def authorize!
+        fail Granite::Action::NotAllowedError, self unless allowed?
+        self
+      end
+    end
+  end
+end

data/lib/granite/action/policies/always_allow_strategy.rb

@@ -0,0 +1,13 @@
+module Granite
+  class Action
+    module Policies
+      # A Granite policies strategy which allows an action to be performed unconditionally.
+      # No defined policies are evaluated.
+      class AlwaysAllowStrategy
+        def self.allowed?(_action)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/policies/any_strategy.rb

@@ -0,0 +1,12 @@
+module Granite
+  class Action
+    module Policies
+      # Granite BA policy which allows action to be performed if at least one defined policy evaluates to true
+      class AnyStrategy
+        def self.allowed?(action)
+          action._policies.any? { |policy| action.instance_exec(action.performer, &policy) }
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/policies/required_performer_strategy.rb

@@ -0,0 +1,14 @@
+module Granite
+  class Action
+    module Policies
+      # A Granite policies strategy which requires a performer to be present
+      #
+      # and at least one defined policy to be evaluated to true
+      class RequiredPerformerStrategy < AnyStrategy
+        def self.allowed?(action)
+          action.performer.present? && super
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/preconditions.rb

@@ -0,0 +1,107 @@
+require 'granite/action/preconditions/base_precondition'
+require 'granite/action/preconditions/embedded_precondition'
+
+module Granite
+  class Action
+    # Conditions module is used to define preconditions for actions.
+    # Each precondition is also defined as validation, so it always run
+    # before action execution. Precondition name is by default
+    # I18n key for +:base+ error, if precondition fails. Along with
+    # preconditions question methods with the same names are created.
+    #
+    module Preconditions
+      extend ActiveSupport::Concern
+
+      class PreconditionsCollection
+        def initialize(*preconditions)
+          @preconditions = preconditions.flatten
+        end
+
+        def +(other)
+          self.class.new(*@preconditions, other)
+        end
+
+        def execute!(context)
+          @preconditions.each { |precondition| precondition.execute!(context) }
+        end
+      end
+
+      included do
+        class_attribute :_preconditions, instance_writer: false
+        self._preconditions = PreconditionsCollection.new
+      end
+
+      module ClassMethods
+        # Define preconditions for current action.
+        #
+        # @param options [Hash] hash with
+        # @option message [String, Symbol] error message
+        # @option group [Symbol] procondition group(s)
+        # @param block [Block] which returns truthy value when precondition
+        #   should pass.
+        def precondition(*args, &block)
+          options = args.extract_options!
+          if block
+            add_precondition(BasePrecondition, options, &block)
+          else
+            common_options = options.extract!(:if, :unless)
+            args.each do |type|
+              precondition common_options.merge(type => {})
+            end
+            options.each do |key, value|
+              value = Array.wrap(value)
+              precondition_options = value.extract_options!
+              add_precondition(klass(key), *value, precondition_options.merge!(common_options))
+            end
+          end
+        end
+
+        private
+
+        def klass(key)
+          key = key.to_s.camelize
+          Granite.precondition_namespaces.reduce(nil) do |memo, ns|
+            memo || "#{ns.to_s.camelize}::#{key}Precondition".safe_constantize
+          end || fail(NameError, "No precondition class for #{key}Precondition")
+        end
+
+        def add_precondition(klass, *args, &block)
+          self._preconditions += klass.new(*args, &block)
+        end
+      end
+
+      attr_reader :failed_preconditions
+
+      def initialize(*)
+        @failed_preconditions = []
+        super
+      end
+
+      # Check if all preconditions are satisfied
+      #
+      # @return [Boolean] wheter all preconditions are satisfied
+      def satisfy_preconditions?
+        errors.clear
+        failed_preconditions.clear
+        run_preconditions!
+      end
+
+      # Adds passed error message and options to `errors` object
+      def decline_with(*args)
+        errors.add(:base, *args)
+        failed_preconditions << args.first
+      end
+
+      private
+
+      def run_preconditions!
+        _preconditions.execute! self
+        errors.empty?
+      end
+
+      def run_validations!
+        run_preconditions! && super
+      end
+    end
+  end
+end

data/lib/granite/action/preconditions/base_precondition.rb

@@ -0,0 +1,25 @@
+module Granite
+  class Action
+    module Preconditions
+      class BasePrecondition
+        def initialize(*args, &block)
+          @options = args.extract_options!
+          @args = args
+          @block = block
+        end
+
+        def execute!(context)
+          return if @options[:if] && !context.instance_exec(&@options[:if])
+          return if @options[:unless] && context.instance_exec(&@options[:unless])
+          _execute(context)
+        end
+
+        private
+
+        def _execute(context)
+          context.instance_exec(&@block)
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/preconditions/embedded_precondition.rb

@@ -0,0 +1,42 @@
+require 'granite/action/preconditions/base_precondition'
+
+module Granite
+  class Action
+    module Preconditions
+      # Checks related business actions for precondition errors and adds them to current action.
+      #
+      #   memoize def child_action
+      #     ...
+      #   end
+      #   precondition embedded: :child_action
+      #
+      #   memoize def child_action
+      #     ...
+      #   end
+      #   memoize def child_actions
+      #     ...
+      #   end
+      #   precondition embedded: [:child_action, :child_actions]
+      #
+      class EmbeddedPrecondition < BasePrecondition
+        private
+
+        def _execute(context)
+          associations = Array.wrap(@args.first)
+          associations.each do |name|
+            actions = Array.wrap(context.__send__(name))
+            actions.each do |action|
+              decline_action(context, action)
+            end
+          end
+        end
+
+        def decline_action(context, action)
+          return if action.satisfy_preconditions?
+          action.errors[:base].each { |error| context.errors.add(:base, error) }
+          action.failed_preconditions.each { |error| context.failed_preconditions << error }
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/projectors.rb

@@ -0,0 +1,100 @@
+module Granite
+  class Action
+    module Projectors
+      extend ActiveSupport::Concern
+
+      class ProjectorsCollection
+        def initialize(action_class)
+          @action_class = action_class
+          @storage = {}
+          @cache = {}
+        end
+
+        def fetch(name)
+          @cache[name.to_sym] ||= setup_projector(name)
+        end
+
+        def store(name, options, &block)
+          old_options, old_blocks = fetch_options_and_blocks(name)
+          @storage[name.to_sym] = [
+            old_options.merge(options || {}),
+            old_blocks + [block].compact
+          ]
+        end
+
+        def names
+          @storage.keys | (@action_class.superclass < Granite::Action ? @action_class.superclass._projectors.names : [])
+        end
+
+        private
+
+        def setup_projector(name)
+          options, blocks = fetch_options_and_blocks(name)
+
+          projector_name = "#{name}_projector".classify
+          controller_name = "#{name}_controller".classify
+
+          projector = Class.new(projector_superclass(name, projector_name, options))
+          projector.action_class = @action_class
+
+          redefine_const(projector_name, projector)
+          redefine_const(controller_name, projector.controller_class)
+
+          blocks.each do |block|
+            projector.class_eval(&block)
+          end
+
+          projector
+        end
+
+        def redefine_const(name, klass)
+          if @action_class.const_defined?(name, false)
+            @action_class.__send__(:remove_const, name)
+            # TODO: this remove is confusing, would be better to raise? - ask @pyromaniac
+          end
+          @action_class.const_set(name, klass)
+        end
+
+        def fetch_options_and_blocks(name)
+          name = name.to_sym
+          options, blocks = @storage[name.to_sym]
+          options ||= {}
+          blocks ||= []
+
+          [options, blocks]
+        end
+
+        def projector_superclass(name, projector_name, options)
+          superclass = options[:class_name].presence.try(:constantize)
+          superclass ||= @action_class.superclass._projectors.fetch(name) if @action_class.superclass < Granite::Action
+
+          superclass || projector_name.safe_constantize || Granite::Projector
+        end
+      end
+
+      module ClassMethods
+        def _projectors
+          @_projectors ||= ProjectorsCollection.new(self)
+        end
+
+        def projector_names
+          _projectors.names
+        end
+
+        def projector(name, options = {}, &block)
+          _projectors.store(name, options, &block)
+
+          class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def self.#{name}
+              _projectors.fetch(:#{name})
+            end
+
+            def #{name}
+              @#{name} ||= self.class._projectors.fetch(:#{name}).new(self)
+            end
+          METHOD
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/represents.rb

@@ -0,0 +1,26 @@
+require 'granite/action/represents/reflection'
+
+module Granite
+  class Action
+    module Represents
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        private
+
+        def represents(*fields, &block)
+          options = fields.extract_options!.symbolize_keys
+
+          fields.each do |field|
+            add_attribute Granite::Action::Represents::Reflection, field, options, &block
+
+            before_validation do
+              attribute(field).sync if __send__ "#{field}_changed?"
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/represents/attribute.rb

@@ -0,0 +1,90 @@
+module Granite
+  class Action
+    module Represents
+      class Attribute < ActiveData::Model::Attributes::Attribute
+        delegate :writer, :reader, :reader_before_type_cast, to: :reflection
+
+        def initialize(*_args)
+          super
+
+          set_default_value
+          set_default_value_before_type_cast
+        end
+
+        def sync
+          reference.public_send(writer, read)
+        end
+
+        def typecast(value)
+          return value if value.class == type
+
+          typecaster.call(value, self) unless value.nil?
+        end
+
+        def type
+          return reflection.options[:type] if reflection.options[:type].present?
+          active_data_type || type_from_type_for_attribute || super
+        end
+
+        def typecaster
+          @typecaster ||= begin
+                            type_class = type.instance_of?(Class) ? type : type.class
+                            @typecaster = ActiveData.typecaster(type_class.ancestors.grep(Class))
+                          end
+        end
+
+        private
+
+        def reference
+          owner.__send__(reflection.reference)
+        end
+
+        def set_default_value
+          return unless reference.respond_to?(reader)
+
+          variable_cache(:value) do
+            normalize(enumerize(reference.public_send(reader)))
+          end
+        end
+
+        def set_default_value_before_type_cast
+          return unless reference.respond_to?(reader_before_type_cast)
+
+          variable_cache(:value_before_type_cast) do
+            defaultize(reference.public_send(reader_before_type_cast))
+          end
+        end
+
+        def active_data_type
+          return nil unless reference.is_a?(ActiveData::Model)
+
+          reference_attribute = reference.attribute(name)
+
+          return Granite::Action::Types::Collection.new(reference_attribute.type) if [
+            ActiveData::Model::Attributes::ReferenceMany,
+            ActiveData::Model::Attributes::Collection,
+            ActiveData::Model::Attributes::Dictionary
+          ].any? { |klass| reference_attribute.is_a? klass }
+
+          reference_attribute.type # TODO: create `type_for_attribute` method inside of ActiveData
+        end
+
+        def type_from_type_for_attribute
+          return nil unless reference.respond_to?(:type_for_attribute)
+
+          attribute_type = reference.type_for_attribute(name.to_s)
+
+          return Granite::Action::Types::Collection.new(convert_type_to_value_class(attribute_type.subtype)) if attribute_type.respond_to?(:subtype)
+
+          convert_type_to_value_class(attribute_type)
+        end
+
+        def convert_type_to_value_class(attribute_type)
+          return attribute_type.value_class if attribute_type.respond_to?(:value_class)
+
+          ActiveData::Model::Associations::PersistenceAdapters::ActiveRecord::TYPES[attribute_type.type&.to_sym]
+        end
+      end
+    end
+  end
+end