granite 0.7.0

data/lib/granite/projector/error.rb

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

data/lib/granite/projector/helpers.rb

@@ -0,0 +1,59 @@
+require 'granite/projector/error'
+
+module Granite
+  class Projector
+    class ActionNotMountedError < Error
+      def initialize(projector)
+        super("Seems like #{projector.class} was not mounted. \
+Do you have #{projector.action_class.name.underscore}##{projector.projector_name} declared in routes?", projector)
+      end
+    end
+
+    module Helpers
+      extend ActiveSupport::Concern
+
+      def view_context
+        Granite.view_context
+      end
+      alias h view_context
+
+      def action_url(action, **options)
+        action_path = controller_actions[action.to_sym].fetch(:as, action)
+        params = required_params.merge(projector_action: action_path)
+
+        Rails.application.routes.url_for(
+          options.reverse_merge(url_options).merge!(params),
+          corresponding_route.name
+        )
+      end
+
+      def action_path(action, **options)
+        action_url(action, **options, only_path: true)
+      end
+
+      private
+
+      def required_params
+        corresponding_route.required_parts
+          .map { |name| [name, action.public_send(name)] }
+          .to_h
+      end
+
+      def corresponding_route
+        @corresponding_route ||= fetch_corresponding_route
+      end
+
+      def route_id
+        [action_class.name.underscore, projector_name]
+      end
+
+      def url_options
+        h&.url_options || {}
+      end
+
+      def fetch_corresponding_route
+        Rails.application.routes.routes.granite_cache[*route_id] || fail(ActionNotMountedError, self)
+      end
+    end
+  end
+end

data/lib/granite/projector/translations.rb

@@ -0,0 +1,52 @@
+module Granite
+  class Projector
+    module Translations
+      extend ActiveSupport::Concern
+
+      class TranslationsWrapper
+        include ActionView::Helpers::TranslationHelper
+      end
+
+      def translate(*args)
+        TranslationsWrapper.new.translate(*self.class.scope_translation_args_by_projector(args))
+      end
+      alias t translate
+
+      module ClassMethods
+        def scope_translation_args_by_projector(args, action_name: nil)
+          options = args.extract_options!
+
+          lookups = expand_relative_key(args.first, action_name).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, action_name = nil)
+          return [key] unless key.is_a?(String) && key.start_with?('.')
+
+          base_keys = extract_base_keys(key, action_name)
+
+          action_class.lookup_ancestors.map do |klass|
+            base_keys.map do |base_key|
+              :"#{klass.i18n_scope}.#{klass.model_name.i18n_key}.#{base_key}"
+            end
+          end.flatten + base_keys
+        end
+
+        def extract_base_keys(key, action_name)
+          undotted_key = key.sub(/^\./, '')
+          base_keys = [:"#{projector_name}.#{undotted_key}"]
+          base_keys.unshift :"#{projector_name}.#{action_name}.#{undotted_key}" if action_name
+          base_keys
+        end
+      end
+    end
+  end
+end

data/lib/granite/projector/translations/helper.rb

@@ -0,0 +1,22 @@
+require 'granite/projector/translations/view_helper'
+
+module Granite
+  class Projector
+    module Translations
+      module Helper
+        extend ActiveSupport::Concern
+
+        included do
+          delegate :scope_translation_args_by_projector, to: :projector_class
+          helper_method :scope_translation_args_by_projector
+          helper ViewHelper
+        end
+
+        def translate(*args)
+          super(*scope_translation_args_by_projector(args, action_name: action_name))
+        end
+        alias t translate
+      end
+    end
+  end
+end

data/lib/granite/projector/translations/view_helper.rb

@@ -0,0 +1,12 @@
+module Granite
+  class Projector
+    module Translations
+      module ViewHelper
+        def translate(*args)
+          super(*scope_translation_args_by_projector(args, action_name: action_name))
+        end
+        alias t translate
+      end
+    end
+  end
+end

data/lib/granite/rails.rb

@@ -0,0 +1,11 @@
+module Granite
+  # Core module for Rails extension. Implements some framework initialization,
+  # like setting up proper load paths.
+  class Railtie < ::Rails::Engine
+    isolate_namespace Granite
+
+    initializer 'granite.business_actions_paths', before: :set_autoload_paths do |app|
+      app.config.paths.add 'apq', eager_load: true, glob: '{actions,projectors}{,/concerns}'
+    end
+  end
+end

data/lib/granite/routing.rb

@@ -0,0 +1,4 @@
+require 'action_dispatch'
+require 'granite/routing/caching'
+require 'granite/routing/mapping'
+require 'granite/routing/mapper'

data/lib/granite/routing/cache.rb

@@ -0,0 +1,24 @@
+module Granite
+  module Routing
+    class Cache
+      attr_reader :routes
+
+      def initialize(routes)
+        @routes = routes
+      end
+
+      def [](action, projector)
+        projector = projector.to_s
+        Array(grouped_routes[action.to_s]).detect do |route|
+          route.required_defaults[:granite_projector] == projector
+        end
+      end
+
+      private
+
+      def grouped_routes
+        @grouped_routes ||= routes.group_by { |r| r.required_defaults[:granite_action] }
+      end
+    end
+  end
+end

data/lib/granite/routing/caching.rb

@@ -0,0 +1,18 @@
+require 'granite/routing/cache'
+
+module Granite
+  module Routing
+    module Caching
+      def granite_cache
+        @granite_cache ||= Cache.new(self)
+      end
+
+      def clear_cache!
+        @granite_cache = nil
+        super
+      end
+    end
+  end
+end
+
+ActionDispatch::Journey::Routes.prepend Granite::Routing::Caching

data/lib/granite/routing/declarer.rb

@@ -0,0 +1,25 @@
+module Granite
+  module Routing
+    module Declarer
+      class << self
+        def declare(routing, route, **options)
+          routing.match route.path,
+                        via: :all,
+                        **options,
+                        to: dispatcher,
+                        as: route.as,
+                        granite_action: route.action_path,
+                        granite_projector: route.projector_name
+        end
+
+        def dispatcher
+          @dispatcher ||= Dispatcher.new
+        end
+
+        def reset_dispatcher
+          dispatcher.reset!
+        end
+      end
+    end
+  end
+end

data/lib/granite/routing/mapper.rb

@@ -0,0 +1,15 @@
+require 'granite/routing/declarer'
+require 'granite/routing/route'
+
+module Granite
+  module Routing
+    module Mapper
+      def granite(projector_path, **options)
+        route = Route.new(projector_path, options.extract!(:path, :as, :projector_prefix))
+        Declarer.declare(self, route, options)
+      end
+    end
+  end
+end
+
+ActionDispatch::Routing::Mapper.include Granite::Routing::Mapper

data/lib/granite/routing/mapping.rb

@@ -0,0 +1,23 @@
+module Granite
+  module Routing
+    module Mapping
+      # Override the `ActionDispatch::Routing::Mapper::Mapping#app` method to
+      # be able to mount custom Dispatcher objects. Otherwise, the only way to
+      # point a dispatcher to business actions is to mount it as a Rack app
+      # but we want to use regular Rails flow.
+      def app(*)
+        if to.is_a?(Granite::Dispatcher)
+          ActionDispatch::Routing::Mapper::Constraints.new(
+            to,
+            to.constraints,
+            ActionDispatch::Routing::Mapper::Constraints::SERVE
+          )
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+ActionDispatch::Routing::Mapper::Mapping.prepend Granite::Routing::Mapping

data/lib/granite/routing/route.rb

@@ -0,0 +1,29 @@
+module Granite
+  module Routing
+    class Route
+      attr_reader :projector_path, :action_path, :projector_name
+
+      def initialize(projector_path, path: nil, as: nil, projector_prefix: false)
+        @projector_path = projector_path
+        @action_path, @projector_name = projector_path.split('#')
+        @path = path
+        @as = as
+
+        @action_name = @action_path.split('/').last
+        @action_name = "#{@projector_name}_#{@action_name}" if projector_prefix
+      end
+
+      def path
+        "#{@path || action_name}(/:projector_action)"
+      end
+
+      def as
+        @as || action_name
+      end
+
+      private
+
+      attr_reader :action_name
+    end
+  end
+end

data/lib/granite/rspec.rb

@@ -0,0 +1,5 @@
+require 'granite/rspec/action_helpers'
+require 'granite/rspec/have_projector'
+require 'granite/rspec/projector_helpers'
+require 'granite/rspec/raise_validation_error'
+require 'granite/rspec/satisfy_preconditions'

data/lib/granite/rspec/action_helpers.rb

@@ -0,0 +1,8 @@
+module Granite::ActionHelpers
+  extend ActiveSupport::Concern
+
+  delegate :perform!, to: :subject
+end
+
+RSpec.configuration.define_derived_metadata(file_path: %r{spec/apq/actions/}) { |metadata| metadata[:type] ||= :granite_action }
+RSpec.configuration.include Granite::ActionHelpers, type: :granite_action

data/lib/granite/rspec/have_projector.rb

@@ -0,0 +1,24 @@
+# @scope Business Actions
+#
+# Checks if the business action has the expected projector
+#
+# Example:
+#
+# ```ruby
+# is_expected.to have_projector(:simple)
+# ```
+RSpec::Matchers.define :have_projector do |expected_projector|
+  match do |action|
+    @expected_projector = expected_projector
+    @action_class = action.class
+    @action_class._projectors.names.include?(expected_projector)
+  end
+
+  failure_message do
+    "expected #{@action_class.name} to have a projector named #{@expected_projector}"
+  end
+
+  failure_message_when_negated do
+    "expected #{@action_class.name} not to have a projector named #{@expected_projector}"
+  end
+end

data/lib/granite/rspec/projector_helpers.rb

@@ -0,0 +1,54 @@
+module Granite::ProjectorHelpers
+  extend ActiveSupport::Concern
+
+  included do
+    include RSpec::Rails::ControllerExampleGroup
+    include RSpec::Rails::RequestExampleGroup
+    before { Granite::Routing::Declarer.dispatcher.unmemoize_all }
+  end
+
+  module ClassMethods
+    def draw_routes(&block)
+      before(:all) do
+        routes = Rails.application.routes
+        routes.disable_clear_and_finalize = true
+        routes.draw(&block)
+      end
+
+      after(:all) do
+        Rails.application.routes.disable_clear_and_finalize = false
+        Rails.application.reload_routes!
+        Rails.application.routes.routes.clear_cache!
+      end
+    end
+
+    def projector(&block)
+      setup_controller(&block)
+      setup_view_context
+      let(:projector) { controller.projector }
+    end
+
+    private
+
+    def setup_controller
+      singleton_class.class_eval do
+        def controller_class
+        end
+      end
+
+      before do
+        @controller = yield.controller_class.new
+        @controller.class.instance_variable_set(:@controller_path, yield.projector_path)
+        @controller.request = @request
+      end
+    end
+
+    def setup_view_context
+      before { Granite.view_context = controller.view_context }
+      after { Granite.view_context = nil }
+    end
+  end
+end
+
+RSpec.configuration.define_derived_metadata(file_path: %r{spec/apq/projectors/}) { |metadata| metadata[:type] ||= :granite_projector }
+RSpec.configuration.include Granite::ProjectorHelpers, type: :granite_projector

data/lib/granite/rspec/raise_validation_error.rb

@@ -0,0 +1,52 @@
+# @scope BusinessActions
+#
+# Checks if code in block raises `Granite::Action::ValidationError`.
+#
+# Modifiers:
+# * `on_attribute(attribute)` -- error relates to attribute specified;
+# * `of_type` -- checks the error has a message with the specified symbol;
+#
+# Examples:
+#
+# ```ruby
+# expect { code }.to raise_validation_error.of_type(:some_error_key)
+# expect { code }.to raise_validation_error.on_attribute(:skill_sets).of_type(:some_other_key)
+# ```
+#
+RSpec::Matchers.define :raise_validation_error do
+  chain :on_attribute do |attribute|
+    @attribute = attribute
+  end
+
+  chain :of_type do |error_type|
+    @error_type = error_type
+  end
+
+  match do |block|
+    begin
+      block.call
+      false
+    rescue Granite::Action::ValidationError => e
+      @details = e.errors.details
+      @details_being_checked = @details[@attribute || :base]
+      @result = @details_being_checked&.any? { |x| x[:error] == @error_type }
+    end
+  end
+
+  description do
+    expected = "raise validation error on attribute :#{@attribute || :base}"
+    expected << " of type #{@error_type.inspect}" if @error_type
+    expected << ", but raised #{@details.inspect}" unless @result
+    expected
+  end
+
+  failure_message do
+    "expected to #{description}"
+  end
+
+  failure_message_when_negated do
+    "expected not to #{description}"
+  end
+
+  supports_block_expectations
+end