granite 0.7.0

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

@@ -0,0 +1,15 @@
+require 'granite/action/represents/attribute'
+
+module Granite
+  class Action
+    module Represents
+      class Reflection < ActiveData::Model::Attributes::Reflections::Represents
+        class << self
+          def attribute_class
+            @attribute_class ||= Granite::Action::Represents::Attribute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/subject.rb

@@ -0,0 +1,73 @@
+module Granite
+  class Action
+    class SubjectNotFoundError < ArgumentError
+      def initialize(action_class)
+        super "Unable to initialize #{action_class} without subject provided"
+      end
+    end
+
+    class SubjectTypeMismatchError < ArgumentError
+      def initialize(action_class, candidate, expected)
+        super "Unable to initialize #{action_class} with #{candidate} as subject, expecting instance of #{expected}"
+      end
+    end
+
+    module Subject
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_subject
+      end
+
+      module ClassMethods
+        def subject(name, *args, &block)
+          reflection = reflect_on_association(name)
+          reflection ||= references_one name, *args, &block
+
+          alias_association :subject, reflection.name
+          alias_attribute :id, reflection.reference_key
+
+          self._subject = name
+        end
+      end
+
+      def initialize(*args)
+        if self.class._subject.blank?
+          super
+          return
+        end
+
+        reflection = self.class.reflect_on_association(self.class._subject)
+        attributes = extract_initialize_attributes(args)
+
+        subject_attributes = extract_subject_attributes!(attributes, reflection)
+        assign_subject(args, subject_attributes, reflection)
+
+        super attributes
+      end
+
+      private
+
+      def extract_initialize_attributes(args)
+        if args.last.respond_to?(:to_unsafe_hash)
+          args.pop.to_unsafe_hash
+        else
+          args.extract_options!
+        end.symbolize_keys
+      end
+
+      def assign_subject(args, attributes, reflection)
+        assign_attributes(attributes)
+
+        self.subject = args.first unless args.empty?
+        fail SubjectNotFoundError, self.class unless subject
+      rescue ActiveData::AssociationTypeMismatch
+        raise SubjectTypeMismatchError.new(self.class, args.first.class.name, reflection.klass)
+      end
+
+      def extract_subject_attributes!(attributes, reflection)
+        attributes.extract!(:subject, :id, reflection.name, reflection.reference_key)
+      end
+    end
+  end
+end

data/lib/granite/action/transaction.rb

@@ -0,0 +1,40 @@
+module Granite
+  class Action
+    class Rollback < defined?(ActiveRecord) ? ActiveRecord::Rollback : StandardError
+    end
+
+    module Transaction
+      extend ActiveSupport::Concern
+
+      private
+
+      def transactional(&block)
+        if transactional?
+          yield
+        else
+          @_transactional = true
+          result = transaction(&block) || false
+          @_transactional = nil
+          result
+        end
+      end
+
+      def transactional?
+        # Fuck the police!
+        !(!@_transactional)
+      end
+
+      def transaction(&block)
+        if defined?(ActiveRecord::Base)
+          ActiveRecord::Base.transaction(&block)
+        else
+          begin
+            yield
+          rescue Granite::Action::Rollback
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/translations.rb

@@ -0,0 +1,39 @@
+module Granite
+  class Action
+    module Translations
+      extend ActiveSupport::Concern
+
+      def translate(*args)
+        I18n.translate(*self.class.scope_translation_args(args))
+      end
+      alias t translate
+
+      module ClassMethods
+        def scope_translation_args(args)
+          options = args.extract_options!
+
+          lookups = expand_relative_key(args.first).map(&:to_sym)
+          lookups += [options[:default]]
+          lookups = lookups.flatten.compact
+
+          key = lookups.shift
+          options[:default] = lookups
+
+          [key, options]
+        end
+
+        private
+
+        def expand_relative_key(key)
+          return [key] unless key.is_a?(String) && key.start_with?('.')
+
+          base_key = key.sub(/^\./, '')
+
+          lookup_ancestors.map do |klass|
+            :"#{klass.i18n_scope}.#{klass.model_name.i18n_key}.#{base_key}"
+          end.flatten + [base_key]
+        end
+      end
+    end
+  end
+end

data/lib/granite/action/types.rb

@@ -0,0 +1 @@
+require 'granite/action/types/collection'

data/lib/granite/action/types/collection.rb

@@ -0,0 +1,13 @@
+module Granite
+  class Action
+    module Types
+      class Collection
+        attr_reader :subtype
+
+        def initialize(subtype)
+          @subtype = subtype
+        end
+      end
+    end
+  end
+end

data/lib/granite/config.rb

@@ -0,0 +1,23 @@
+require 'singleton'
+require 'active_support/core_ext/object/try'
+
+module Granite
+  class Config
+    include Singleton
+
+    attr_accessor :base_controller
+    attr_writer :precondition_namespaces
+
+    def base_controller_class
+      base_controller&.constantize || ActionController::Base
+    end
+
+    def precondition_namespaces
+      @precondition_namespaces ||= %w[Granite::Action::Preconditions]
+    end
+
+    def self.delegated
+      public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
+    end
+  end
+end

data/lib/granite/context.rb

@@ -0,0 +1,28 @@
+require 'singleton'
+
+module Granite
+  class Context
+    include Singleton
+
+    def view_context
+      Thread.current[:granite_view_context]
+    end
+
+    def view_context=(context)
+      Thread.current[:granite_view_context] = context
+    end
+
+    def with_view_context(context)
+      old_view_context = view_context
+      self.view_context = context
+
+      yield
+    ensure
+      self.view_context = old_view_context
+    end
+
+    def self.delegated
+      public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
+    end
+  end
+end

data/lib/granite/dispatcher.rb

@@ -0,0 +1,64 @@
+require 'memoist'
+require 'action_controller/metal/exceptions'
+
+class Granite::Dispatcher
+  extend Memoist
+
+  # Make dispatcher object pristine, clean memoist cache.
+  def reset!
+    unmemoize_all
+  end
+
+  def call(*)
+    # Pretend to be a Rack app, however we are still dispatcher, so this method should never be called
+    # see lib/granite/routing/mapping.rb for more info.
+    fail 'Dispatcher can\'t be used as a Rack app.'
+  end
+
+  def serve(req)
+    controller, action = detect_controller_class_and_action_name(req)
+    controller.action(action).call(req.env)
+  end
+
+  def constraints
+    [->(req) { detect_controller_class_and_action_name(req).all?(&:present?) }]
+  end
+
+  def controller(params, *_args)
+    projector(params.slice(:granite_action, :granite_projector).symbolize_keys)&.controller_class
+  end
+
+  def prepare_params!(params, *_args)
+    params
+  end
+
+  private
+
+  def detect_controller_class_and_action_name(req)
+    [
+      controller(req.params),
+      action_name(
+        req.request_method_symbol,
+        req.params.slice(:granite_action, :granite_projector, :projector_action).symbolize_keys
+      )
+    ]
+  end
+
+  memoize def action_name(request_method_symbol, granite_action:, granite_projector:, projector_action: '')
+    projector = projector(granite_action: granite_action, granite_projector: granite_projector)
+    return unless projector
+
+    projector.action_for(request_method_symbol, projector_action)
+  end
+
+  memoize def projector(granite_action:, granite_projector:)
+    action = business_action(granite_action)
+
+    action.public_send(granite_projector) if action.respond_to?(granite_projector)
+  end
+
+  memoize def business_action(granite_action)
+    granite_action.camelize.safe_constantize ||
+      fail(ActionController::RoutingError, "Granite action '#{granite_action}' is mounted but class '#{granite_action.camelize}' can't be found")
+  end
+end

data/lib/granite/error.rb

@@ -0,0 +1,4 @@
+module Granite
+  class Error < StandardError
+  end
+end

data/lib/granite/performer_proxy.rb

@@ -0,0 +1,34 @@
+require 'granite/performer_proxy/proxy'
+
+module Granite
+  # This concern contains class methods used for actions and projectors
+  #
+  module PerformerProxy
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def as(performer)
+        Proxy.new(self, performer)
+      end
+
+      def with_proxy_performer(performer)
+        key = proxy_performer_key
+        old_performer = Thread.current[key]
+        Thread.current[key] = performer
+        yield
+      ensure
+        Thread.current[key] = old_performer
+      end
+
+      def proxy_performer
+        Thread.current[proxy_performer_key]
+      end
+
+      private
+
+      def proxy_performer_key
+        :"granite_proxy_performer_#{hash}"
+      end
+    end
+  end
+end

data/lib/granite/performer_proxy/proxy.rb

@@ -0,0 +1,31 @@
+module Granite
+  module PerformerProxy
+    # Proxy helps to wrap the following method call with
+    # performer-enabled context.
+    #
+    class Proxy
+      def initialize(klass, performer)
+        @klass = klass
+        @performer = performer
+      end
+
+      def inspect
+        "<#{@klass}PerformerProxy #{@performer}>"
+      end
+
+      def method_missing(method, *args, &block)
+        if @klass.respond_to?(method)
+          @klass.with_proxy_performer(@performer) do
+            @klass.public_send(method, *args, &block)
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(*args)
+        @klass.respond_to?(*args)
+      end
+    end
+  end
+end

data/lib/granite/projector.rb

@@ -0,0 +1,48 @@
+require 'granite/projector/controller_actions'
+require 'granite/projector/error'
+require 'granite/projector/helpers'
+require 'granite/projector/translations'
+require 'granite/performer_proxy'
+
+module Granite
+  class Projector
+    include PerformerProxy
+    include ControllerActions
+    include Helpers
+    include Translations
+
+    singleton_class.__send__(:attr_accessor, :action_class)
+    delegate :action_class, :projector_name, to: 'self.class'
+    attr_reader :action
+
+    def self.controller_class
+      return Granite::Controller unless superclass.respond_to?(:controller_class)
+
+      @controller_class ||= Class.new(superclass.controller_class).tap do |klass|
+        klass.projector_class = self
+      end
+    end
+
+    def self.projector_path
+      @projector_path ||= name.remove(/Projector$/).underscore
+    end
+
+    def self.projector_name
+      @projector_name ||= name.demodulize.remove(/Projector$/).underscore
+    end
+
+    def initialize(*args)
+      @action = if args.first.is_a?(Granite::Action) # Temporary solutions for backwards compatibility.
+                  args.first
+                else
+                  build_action(*args)
+                end
+    end
+
+    private
+
+    def build_action(*args)
+      action_class.as(self.class.proxy_performer).new(*args)
+    end
+  end
+end

data/lib/granite/projector/controller_actions.rb

@@ -0,0 +1,47 @@
+require 'action_dispatch/routing'
+
+module Granite
+  class Projector
+    module ControllerActions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :controller_actions
+        self.controller_actions = {}
+
+        ActionDispatch::Routing::HTTP_METHODS.each do |method|
+          define_singleton_method method do |name, options = {}, &block|
+            action(name, options.merge(method: method), &block)
+          end
+        end
+      end
+
+      module ClassMethods
+        def action(name, options = {}, &block)
+          if block
+            self.controller_actions = controller_actions.merge(name.to_sym => options)
+            controller_class.__send__(:define_method, name, &block)
+            class_eval <<-METHOD, __FILE__, __LINE__ + 1
+              def #{name}_url(options = {})
+                action_url(:#{name}, options)
+              end
+
+              def #{name}_path(options = {})
+                action_path(:#{name}, options)
+              end
+            METHOD
+          else
+            controller_actions[name.to_sym]
+          end
+        end
+
+        def action_for(http_method, action)
+          controller_actions.find do |controller_action, controller_action_options|
+            controller_action_options.fetch(:as, controller_action).to_s == action &&
+              Array(controller_action_options.fetch(:method)).include?(http_method)
+          end&.first
+        end
+      end
+    end
+  end
+end