wallaby-core 0.1.0

data/lib/services/wallaby/engine_name_finder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Service object to find the engine name by given request environment variables.
+  class EngineNameFinder
+    class << self
+      # Use script name to find out the corresponding named route and its engine name.
+      #
+      # When it can't find the engine name, it will return empty string. Reason is to prevent it from being run again.
+      # @param env [Hash, String] request env or script name
+      # @return [String] engine name or empty string if not found
+      def find(env)
+        script_name = env[SCRIPT_NAME] || env[PATH_INFO] if env.is_a? Hash
+        script_name = env if env.is_a? String
+        return EMPTY_STRING if script_name.blank?
+
+        named_route = Rails.application.routes.routes.find { |route| route.path.match(script_name) }
+        named_route.try(:name) || EMPTY_STRING
+      end
+    end
+  end
+end

data/lib/services/wallaby/engine_url_for.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # {Wallaby::ApplicationHelper#url_for} helper for Wallaby engine
+  class EngineUrlFor
+    # A constant to map actions to their route paths defined in Wallaby routes.
+    ACTION_TO_PATH_MAP =
+      Wallaby::ERRORS.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |error, map|
+        map[error] = :"#{error}_path"
+      end.merge(
+        home: :root_path,
+        index: :resources_path,
+        new: :new_resource_path,
+        show: :resource_path,
+        edit: :edit_resource_path
+      ).freeze
+
+    class << self
+      # Generate URL that Wallaby engine supports (e.g. home/resourceful/errors)
+      # @see https://github.com/reinteractive/wallaby/blob/master/config/routes.rb config/routes.rb
+      # @param engine_name [string]
+      # @param parameters [ActionController::Parameters, Hash]
+      # @return [String] path string for wallaby engine
+      # @return [nil] nil if given engine name cannot be found
+      def handle(engine_name:, parameters:)
+        route = Rails.application.routes.named_routes[engine_name]
+        return unless route
+
+        params = { script_name: route.path.spec.to_s }.merge(parameters).symbolize_keys
+
+        ModuleUtils.try_to(
+          Engine.routes.url_helpers, action_path_from(params), params
+        )
+      end
+
+      protected
+
+      # Find out the named path from given params
+      # @return [Symbol] named path
+      def action_path_from(params)
+        action = params[:action] || params.fetch(:_recall, {})[:action]
+        ACTION_TO_PATH_MAP[action]
+      end
+    end
+  end
+end

data/lib/services/wallaby/link_options_normalizer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Link renderer
+  class LinkOptionsNormalizer
+    # Normalize options for `link_to` to use
+    # @param html_options [Hash] HTML options
+    # @param block [Proc] a block
+    # @param defaults [Hash]
+    # @return [Array<Hash, Proc>] html_options and the block
+    def self.normalize(html_options, block, defaults)
+      block ||= defaults[:block]
+      html_options[:title] ||= defaults[:block].call
+      # allow empty class to be set
+      html_options[:class] = defaults[:class] if !html_options.key?(:class) && defaults[:class]
+      [html_options, block]
+    end
+  end
+end

data/lib/services/wallaby/map/mode_mapper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class Map
+    # To generate a hash map (`model` => `mode`).
+    # This will be used to tell if a model can be handled by Wallaby
+    class ModeMapper
+      # @param mode_classes [Array<Class>] model classes
+      def initialize(mode_classes)
+        @mode_classes = mode_classes
+      end
+
+      # This will walk through each mode (e.g. **ActiveRecord**/**Her**) then pull out all the models,
+      # and then form a hash of (`model` => `mode`).
+      # @return [Hash] { model_class => mode }
+      def map
+        return {} if @mode_classes.blank?
+
+        @mode_classes.each_with_object({}) do |mode_class, map|
+          mode_class.model_finder.new.all.each do |model_class|
+            map[model_class] = mode_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/services/wallaby/map/model_class_collector.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class Map
+    # To collect model classes that are configured to be handled by Wallaby
+    class ModelClassCollector
+      # @param configuration [Configuration]
+      # @param models [Array<Class>]
+      def initialize(configuration, models = nil)
+        @configuration = configuration
+        @models = models || []
+      end
+
+      # @return [Array<Class>] model class
+      def collect
+        return @models - excluded_models if configured_models.blank?
+
+        invalid_models_check
+        configured_models
+      end
+
+      private
+
+      # Check if the models are valid, raise if invalid
+      def invalid_models_check
+        invalid_models = configured_models - @models
+        return if invalid_models.blank?
+
+        message = I18n.t 'errors.invalid.models', models: invalid_models.to_sentence
+        raise InvalidError, message
+      end
+
+      # @return [Wallaby::Configuration::Models]
+      def models
+        @configuration.models
+      end
+
+      # @return [Array<Class>] a list of models to exclude
+      def excluded_models
+        models.excludes
+      end
+
+      # @return [Array<Class>] a list of models to set
+      def configured_models
+        models.presence
+      end
+    end
+  end
+end

data/lib/services/wallaby/map/model_class_mapper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class Map
+    # Generate a map.
+    class ModelClassMapper
+      # Iterate all classes and generate a hash using their model classes as the key
+      # @see #map
+      # @param class_array [Array<Class>]
+      # @return [Hash] model class => descendant class
+      def self.map(class_array, &block)
+        new.send :map, class_array, &block
+      end
+
+      protected
+
+      # @return [Hash] model class => descendant class
+      def map(class_array)
+        (class_array || EMPTY_ARRAY).each_with_object({}) do |klass, map|
+          next if anonymous?(klass) || base_class?(klass) || !klass.model_class
+
+          map[klass.model_class] = block_given? ? yield(klass) : klass
+        end
+      end
+
+      # @see Wallaby::ModuleUtils.anonymous_class?
+      def anonymous?(klass)
+        ModuleUtils.anonymous_class? klass
+      end
+
+      # @param klass [Class]
+      # @return [Boolean] whether the class is base or not
+      def base_class?(klass)
+        ModuleUtils.try_to klass, :base_class?
+      end
+    end
+  end
+end

data/lib/services/wallaby/prefixes_builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # To extend prefixes to provide more possibility
+  class PrefixesBuilder
+    # @param origin_prefixes [Array<string>] a list of all the origin prefixes
+    # @param action_name [String] action name
+    # @param resources_name [String] resources name
+    # @param script_name [String] script name
+    # @param theme_name [String] theme name
+    def self.build(origin_prefixes:, action_name:, resources_name:, script_name:, theme_name:)
+      new(
+        origin_prefixes: origin_prefixes,
+        action_name: action_name,
+        resources_name: resources_name,
+        script_name: script_name,
+        theme_name: theme_name
+      ).send :build
+    end
+
+    private
+
+    # Constructor
+    def initialize(origin_prefixes:, action_name:, resources_name:, script_name:, theme_name:)
+      @origin_prefixes = origin_prefixes
+      @action_name = action_name
+      @resources_name = resources_name
+      @script_name = script_name
+      @theme_name = theme_name
+    end
+
+    # @return [Array<String>] prefixes
+    def build
+      prefixes = minimal_prefixes
+      prefixes.unshift mounted_prefix unless prefixes.include? resources_path
+      prefixes.uniq.compact.each_with_object([]) do |prefix, result|
+        result << "#{prefix}/#{suffix}" << prefix
+      end
+    end
+
+    # @return [Array<String>] prefixes starting from wallaby controller path
+    def minimal_prefixes
+      index = @origin_prefixes.index ResourcesController.controller_path
+      @origin_prefixes.slice(0..index).tap do |prefixes|
+        insert_index = prefixes.length > 1 ? -2 : 0
+        prefixes.insert insert_index, @theme_name if @theme_name.present?
+      end
+    end
+
+    # @return [String] a prefix of the mouted path
+    def mounted_prefix
+      prefix = (@script_name || '').sub(%r{^/}, '')
+      prefix << SLASH if prefix.present?
+      prefix << resources_path if resources_path
+    end
+
+    # @return [String]
+    def suffix
+      @suffix ||= CellUtils.to_action_prefix @action_name
+    end
+
+    def resources_path
+      @resources_path ||= @resources_name.try :gsub, COLONS, SLASH
+    end
+  end
+end

data/lib/services/wallaby/sorting/hash_builder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Sorting
+    # Turn a string e.g.`'name asc,id desc'` into sort hash e.g.`{name: 'asc', id: 'desc'}`
+    class HashBuilder
+      SORT_REGEX = /(([^\s,]+)\s+(asc|desc))\s*,?\s*/i.freeze
+
+      # Turn a string e.g.`'name asc,id desc'` into sort hash e.g.`{name: 'asc', id: 'desc'}`
+      # @param sort_string [String]
+      # @return [Hash] { field_name => 'asc|desc' }
+      def self.build(sort_string)
+        ::ActiveSupport::HashWithIndifferentAccess.new.tap do |hash|
+          (sort_string || EMPTY_STRING).scan(SORT_REGEX) { |_, key, order| hash[key] = order }
+        end
+      end
+    end
+  end
+end

data/lib/services/wallaby/sorting/link_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Sorting
+    # Build link for sorting
+    class LinkBuilder
+      SORT_STRATEGIES = { single: SingleBuilder }.with_indifferent_access.freeze
+
+      delegate :model_class, to: :@model_decorator
+      delegate :index_link, :url_for, to: :@helper
+
+      # @param model_decorator [Wallaby::ModelDecorator]
+      # @param params [ActionController::Parameters]
+      # @param helper [ActionView::Helpers]
+      def initialize(model_decorator, params, helper, strategy)
+        @model_decorator = model_decorator
+        @params = params
+        @helper = helper
+        @strategy = strategy
+      end
+
+      # To return the sort hash converted from string value, e.g. `{ 'title' => 'asc', 'updated_at' => 'desc' }`
+      # converted from `'title asc, updated_at desc'`
+      # @return [Hash] current sort hash
+      def current_sort
+        @current_sort ||= HashBuilder.build @params[:sort]
+      end
+
+      # Build sort link for given field name:
+      #
+      # ```
+      # <a title="Product" href="/admin/products?sort=published_at+asc">Name</a>
+      # ```
+      #
+      # If the field is not sortable, it returns a text, e.g.:
+      #
+      # ```
+      # Name
+      # ```
+      # @param field_name [String]
+      # @return [String] link or text
+      def build(field_name)
+        metadata = @model_decorator.index_metadata_of field_name
+        label = @model_decorator.index_label_of field_name
+        return label unless sortable? field_name, metadata
+
+        sort_field_name = metadata[:sort_field_name] || field_name
+        url_params = next_builder.next_params sort_field_name
+        url = url_for url_params.merge(with_query: true)
+        index_link(model_class, options: { url: url }) { label }
+      end
+
+      private
+
+      # @return [Wallaby::Sorting::NextBuilder]
+      def next_builder
+        @next_builder ||= begin
+          klass = SORT_STRATEGIES[@strategy] || NextBuilder
+          klass.new @params, current_sort
+        end
+      end
+
+      # @return [Boolean] true if sortable or `sort_field_name` is provided in the metadata
+      def sortable?(field_name, metadata)
+        !metadata[:sort_disabled] && (@model_decorator.fields[field_name] || metadata[:sort_field_name])
+      end
+    end
+  end
+end

data/lib/services/wallaby/sorting/next_builder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Sorting
+    # Generate sort param for given field's next sort order
+    # (e.g. from empty to `asc`, from `asc` to `desc`, from `desc` to empty)
+    class NextBuilder
+      ASC = 'asc'
+      DESC = 'desc'
+
+      # @param params [ActionController::Parameters]
+      # @param hash [Hash, nil] a hash containing sorting info, e.g. `{ name: 'asc' }`
+      def initialize(params, hash = nil)
+        @params = params
+        @hash = hash.try(:with_indifferent_access) || HashBuilder.build(params[:sort])
+      end
+
+      # Update the `sort` parameter.
+      # @example for param `{sort: 'name asc'}`, it updates the parameters to:
+      #   {sort: 'name desc'}
+      # @param field_name [String] field name
+      # @return [ActionController::Parameters]
+      #   updated parameters with new sort order for given field
+      def next_params(field_name)
+        params = @params.dup
+        params[:sort] = complete_sorting_str_with field_name
+        params
+      end
+
+      protected
+
+      # @param field_name [String] field name
+      # @return [String] a sort order string, e.g. `'name asc'`
+      def complete_sorting_str_with(field_name)
+        hash = @hash.except field_name
+        current_sort = @hash[field_name]
+        hash[field_name] = next_value_for current_sort
+        rebuild_str_from hash
+      end
+
+      # @param hash [Hash] sort order hash
+      # @return [String] a sort order string, e.g. `'name asc'`
+      def rebuild_str_from(hash)
+        hash.each_with_object(EMPTY_STRING.dup) do |(name, sort), str|
+          next unless sort
+
+          str << (str == EMPTY_STRING ? str : COMMA)
+          str << name.to_s << SPACE << sort
+        end
+      end
+
+      # @param current [String, nil] current sort order
+      # @return [String, nil] next sort order
+      def next_value_for(current)
+        case current
+        when ASC then DESC
+        when DESC then nil
+        else ASC
+        end
+      end
+    end
+  end
+end

data/lib/services/wallaby/sorting/single_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Sorting
+    # Generate sort param for only one field's next sort order
+    # (e.g. from empty to `asc`, from `asc` to `desc`, from `desc` to empty)
+    class SingleBuilder < NextBuilder
+      protected
+
+      # @param field_name [String] field name
+      # @return [String] a sort order string, e.g. `'name asc'`
+      def complete_sorting_str_with(field_name)
+        hash = {}
+        current_sort = @hash[field_name]
+        hash[field_name] = next_value_for current_sort
+        rebuild_str_from hash
+      end
+    end
+  end
+end