wallaby-core 0.1.0

data/lib/concerns/wallaby/decoratable.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Decorator related attributes
+  module Decoratable
+    # Configurable attribute
+    module ClassMethods
+      # @!attribute [w] resource_decorator
+      def resource_decorator=(resource_decorator)
+        ModuleUtils.inheritance_check resource_decorator, application_decorator
+        @resource_decorator = resource_decorator
+      end
+
+      # @!attribute [r] resource_decorator
+      # Resource decorator will be used for its metadata info and decoration methods.
+      #
+      # If Wallaby doesn't get it right, please specify the **resource_decorator**.
+      # @example To set resource decorator
+      #   class Admin::ProductionsController < Admin::ApplicationController
+      #     self.resource_decorator = ProductDecorator
+      #   end
+      # @return [Class] resource decorator
+      # @raise [ArgumentError] when **resource_decorator** doesn't inherit from **application_decorator**
+      # @see Wallaby::ResourceDecorator
+      # @since 5.2.0
+      attr_reader :resource_decorator
+
+      # @!attribute [w] application_decorator
+      def application_decorator=(application_decorator)
+        ModuleUtils.inheritance_check resource_decorator, application_decorator
+        @application_decorator = application_decorator
+      end
+
+      # @!attribute [r] application_decorator
+      # The **application_decorator** is as the base class of {#resource_decorator}.
+      # @example To set application decorator:
+      #   class Admin::ApplicationController < Wallaby::ResourcesController
+      #     self.application_decorator = AnotherApplicationDecorator
+      #   end
+      # @raise [ArgumentError] when **resource_decorator** doesn't inherit from **application_decorator**
+      # @return [Class] application decorator
+      # @see Wallaby::ResourceDecorator
+      # @since 5.2.0
+      def application_decorator
+        @application_decorator ||= ModuleUtils.try_to superclass, :application_decorator
+      end
+    end
+
+    # Get current model decorator. It comes from
+    #
+    # - model decorator for {Wallaby::Decoratable::ClassMethods#resource_decorator resource_decorator}
+    # - otherwise, model decorator for {Wallaby::Decoratable::ClassMethods#application_decorator application_decorator}
+    #
+    # Model decorator stores the information of **metadata** and **field_names** for **index**/**show**/**form** action.
+    # @return [Wallaby::ModelDecorator] current model decorator for this request
+    def current_model_decorator
+      @current_model_decorator ||=
+        current_decorator.try(:model_decorator) || \
+        Map.model_decorator_map(current_model_class, controller_to_get(:application_decorator))
+    end
+
+    # Get current resource decorator. It comes from
+    #
+    # - {Wallaby::Decoratable::ClassMethods#resource_decorator resource_decorator}
+    # - otherwise, {Wallaby::Decoratable::ClassMethods#application_decorator application_decorator}
+    # @return [Wallaby::ResourceDecorator] current resource decorator for this request
+    def current_decorator
+      @current_decorator ||=
+        (controller_to_get(:resource_decorator) || \
+        Map.resource_decorator_map(current_model_class, controller_to_get(:application_decorator))).tap do |decorator|
+          Rails.logger.info %(  - Current decorator: #{decorator})
+        end
+    end
+
+    # Get current fields metadata for current action name.
+    # @return [Hash] current fields metadata
+    def current_fields
+      @current_fields ||=
+        ModuleUtils.try_to current_model_decorator, :"#{FORM_ACTIONS[action_name] || action_name}_fields"
+    end
+
+    # Wrap resource(s) with decorator(s).
+    # @param resource [Object, Enumerable]
+    # @return [Wallaby::ResourceDecorator, Enumerable<Wallaby::ResourceDecorator>] decorator(s)
+    def decorate(resource)
+      return resource if resource.is_a? ResourceDecorator
+      return resource.map { |item| decorate item } if resource.respond_to? :map
+
+      decorator = Map.resource_decorator_map resource.class, controller_to_get(:application_decorator)
+      decorator ? decorator.new(resource) : resource
+    end
+
+    # @param resource [Object, Wallaby::ResourceDecorator]
+    # @return [Object] the unwrapped resource object
+    def extract(resource)
+      return resource.resource if resource.is_a? ResourceDecorator
+
+      resource
+    end
+  end
+end

data/lib/concerns/wallaby/defaultable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Defaults related methods
+  module Defaultable
+    protected
+
+    # Set default options for create action
+    # @param options [Hash]
+    # @return [Hash] updated options with default values
+    def set_defaults_for(action, options)
+      case action.try(:to_sym)
+      when :create, :update then assign_create_and_update_defaults_with options
+      when :destroy then assign_destroy_defaults_with options
+      end
+      options
+    end
+
+    # @param options [Hash]
+    # @return [Hash] updated options with default values
+    def assign_create_and_update_defaults_with(options)
+      options[:params] ||= resource_params
+      options[:location] ||= -> { helpers.show_path resource, is_resource: params[:resource] }
+    end
+
+    # @param options [Hash]
+    # @return [Hash] updated options with default values
+    def assign_destroy_defaults_with(options)
+      options[:params] ||= params
+      options[:location] ||=
+        if params[:resource]
+          helpers.show_path resource, is_resource: params[:resource]
+        else
+          helpers.index_path current_model_class
+        end
+    end
+  end
+end

data/lib/concerns/wallaby/engineable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Engine related helper methods for both controller and view
+  module Engineable
+    # Configurable attribute
+    module ClassMethods
+      # @!attribute [w] engine_name
+      attr_writer :engine_name
+
+      # @!attribute [r] engine_name
+      # The engine name will be used to handle URLs.
+      #
+      # So when to set this engine name? When Wallaby doesn't know what is the correct engine helper to use.
+      # @example To set an engine name:
+      #   class Admin::ApplicationController < Wallaby::ResourcesController
+      #     self.engine_name = 'admin_engine'
+      #   end
+      # @return [String, Symbol, nil] engine name
+      # @since 5.2.0
+      def engine_name
+        @engine_name ||= ModuleUtils.try_to superclass, :engine_name
+      end
+    end
+
+    # This engine helper is used to access URL helpers of Wallaby engine.
+    #
+    # Considering **Wallaby** is mounted at the following paths:
+    #
+    # ```
+    # mount Wallaby::Engine, at: '/admin'
+    # mount Wallaby::Engine, at: '/inner', as: :inner_engine, defaults: { resources_controller: InnerController }
+    # ```
+    #
+    # If `/inner` is current script name, `current_engine` is same as `inner_engine`.
+    # Then it's possible to access URL helpers like this:
+    #
+    # ```
+    # current_engine.resources_path resources: 'products'
+    # ```
+    # @return [ActionDispatch::Routing::RoutesProxy] engine for current request
+    def current_engine
+      @current_engine ||= ModuleUtils.try_to self, current_engine_name
+    end
+
+    # Find out the engine name under current script name.
+    #
+    # Considering **Wallaby** is mounted at the following paths:
+    #
+    # ```
+    # mount Wallaby::Engine, at: '/admin'
+    # mount Wallaby::Engine, at: '/inner', as: :inner_engine, defaults: { resources_controller: InnerController }
+    # ```
+    #
+    # If `/inner` is current script name, then `current_engine_name` returns `'inner_engine'`.
+    # @return [String] engine name for current request
+    def current_engine_name
+      @current_engine_name ||= controller_to_get(__callee__, :engine_name) || EngineNameFinder.find(request.env)
+    end
+  end
+end

data/lib/concerns/wallaby/fieldable.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Field helper for model decorator
+  module Fieldable
+    # @param field_name [String, Symbol] field name
+    # @return [Hash] metadata information for a given field
+    def metadata_of(field_name)
+      fields[field_name] || {}
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String] label for a given field
+    def label_of(field_name)
+      metadata_of(field_name)[:label] || field_name.to_s.humanize
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String, Symbol] type for a given field
+    def type_of(field_name)
+      validate_presence_of field_name, metadata_of(field_name)[:type]
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [Hash] index metadata information for a given field
+    def index_metadata_of(field_name)
+      index_fields[field_name] || {}
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String] index label for a given field
+    def index_label_of(field_name)
+      index_metadata_of(field_name)[:label] || field_name.to_s.humanize
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String, Symbol] index type for a given field
+    def index_type_of(field_name)
+      validate_presence_of field_name, index_metadata_of(field_name)[:type]
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [Hash] show metadata information for a given field
+    def show_metadata_of(field_name)
+      show_fields[field_name] || {}
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String] show label for a given field
+    def show_label_of(field_name)
+      show_metadata_of(field_name)[:label] || field_name.to_s.humanize
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String, Symbol] show type for a given field
+    def show_type_of(field_name)
+      validate_presence_of field_name, show_metadata_of(field_name)[:type]
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [Hash] form metadata information for a given field
+    def form_metadata_of(field_name)
+      form_fields[field_name] || {}
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String] form label for a given field
+    def form_label_of(field_name)
+      form_metadata_of(field_name)[:label] || field_name.to_s.humanize
+    end
+
+    # @param field_name [String, Symbol] field name
+    # @return [String, Symbol] form type for a given field
+    def form_type_of(field_name)
+      validate_presence_of field_name, form_metadata_of(field_name)[:type]
+    end
+  end
+end

data/lib/concerns/wallaby/paginatable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Paginator related attributes
+  module Paginatable
+    # Configurable attribute
+    module ClassMethods
+      # @!attribute [w] model_paginator
+      def model_paginator=(model_paginator)
+        ModuleUtils.inheritance_check model_paginator, application_paginator
+        @model_paginator = model_paginator
+      end
+
+      # @!attribute [r] model_paginator
+      # If Wallaby doesn't get it right, please specify the **model_paginator**.
+      # @example To set model paginator
+      #   class Admin::ProductionsController < Admin::ApplicationController
+      #     self.model_paginator = ProductPaginator
+      #   end
+      # @return [Class] model paginator
+      # @raise [ArgumentError] when **model_paginator** doesn't inherit from **application_paginator**
+      # @see Wallaby::ModelPaginator
+      # @since 5.2.0
+      attr_reader :model_paginator
+
+      # @!attribute [w] application_paginator
+      def application_paginator=(application_paginator)
+        ModuleUtils.inheritance_check model_paginator, application_paginator
+        @application_paginator = application_paginator
+      end
+
+      # @!attribute [r] application_paginator
+      # The **application_paginator** is as the base class of {#model_paginator}.
+      # @example To set application decorator:
+      #   class Admin::ApplicationController < Wallaby::ResourcesController
+      #     self.application_paginator = AnotherApplicationPaginator
+      #   end
+      # @return [Class] application decorator
+      # @raise [ArgumentError] when **model_paginator** doesn't inherit from **application_paginator**
+      # @see Wallaby::ModelPaginator
+      # @since 5.2.0
+      def application_paginator
+        @application_paginator ||= ModuleUtils.try_to superclass, :application_paginator
+      end
+    end
+
+    # Model paginator for current modal class. It comes from:
+    #
+    # - controller configuration {Wallaby::Paginatable::ClassMethods#model_paginator .model_paginator}
+    # - a generic paginator based on {Wallaby::Paginatable::ClassMethods#application_paginator .application_paginator}
+    # @return [Class] model paginator class
+    def current_paginator
+      @current_paginator ||=
+        (controller_to_get(:model_paginator) \
+          || Map.paginator_map(current_model_class, controller_to_get(:application_paginator))).try do |klass|
+          Rails.logger.info %(  - Current paginator: #{klass})
+          klass.new current_model_class, collection, params
+        end
+    end
+
+    # To paginate the collection but only when either `page` or `per` param is given,
+    # or HTML response is requested
+    # @param query [#each]
+    # @param options [Hash]
+    # @option options [Boolean] :paginate whether collection should be paginated
+    # @return [#each]
+    # @see Wallaby::ModelServicer#paginate
+    def paginate(query, options)
+      options[:paginate] ? current_servicer.paginate(query, params) : query
+    end
+  end
+end

data/lib/concerns/wallaby/rails_overridden_methods.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # This is a collection of the helper methods that overrides the rails methods
+  module RailsOverriddenMethods
+    protected
+
+    # Override {https://github.com/rails/rails/blob/master/actionview/lib/action_view/view_paths.rb
+    # ActionView::ViewPaths::ClassMethods#_prefixes} to extend the prefixes for **ActionView::ViewPaths** to look up
+    # in below precedence from high to low:
+    #
+    # - :mounted_path/:resources_name/:action_prefix (e.g. `admin/products/index`)
+    # - :mounted_path/:resources_name (e.g. `admin/products`)
+    # - :controller_path/:action_prefix
+    # - :controller_path
+    # - :parent_controller_path/:action_prefix
+    # - :parent_controller_path
+    # - :more_parent_controller_path/:action_prefix
+    # - :more_parent_controller_path
+    # - :theme_name/:action_prefix
+    # - :theme_name
+    # - wallaby/resources/:action_prefix
+    # - wallaby/resources
+    # @return [Array<String>]
+    def _prefixes
+      @_prefixes ||= PrefixesBuilder.build(
+        origin_prefixes: super,
+        theme_name: current_theme_name,
+        resources_name: current_resources_name,
+        script_name: request.env[SCRIPT_NAME],
+        action_name: params[:action]
+      )
+    end
+
+    # Override to provide support for cell lookup
+    # @return [Wallaby::CustomLookupContext]
+    def lookup_context
+      @_lookup_context ||= # rubocop:disable Naming/MemoizedInstanceVariableName
+        CustomLookupContext.normalize(super, prefixes: _prefixes)
+    end
+  end
+end

data/lib/concerns/wallaby/resourcable.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resources related attributes
+  module Resourcable
+    # Configurable attribute
+    module ClassMethods
+      # @!attribute [w] model_class
+      attr_writer :model_class
+
+      # @!attribute [r] model_class
+      # This attribute will be used by the dynamic router to find out which
+      # controller to dispatch to. For example:
+      #
+      # `/admin/products` will be dispatched to the controller that has the
+      # model class `Product`.
+      # @return [Class] the model class for controller.
+      # @example It can be customized as below:
+      #   ```
+      #   self.model_class = Product
+      #   ```
+      #   Or
+      #   ```
+      #   def self.model_class; Product; end
+      #   ```
+      # @example To set model paginator
+      #   class Admin::ProductionsController < Admin::ApplicationController
+      #     self.model_class = ProductResources
+      #   end
+      # @return [Class] model paginator
+      # @raise [ArgumentError] when **model_class** doesn't inherit from **application_paginator**
+      # @see Wallaby::ModelResources
+      def model_class
+        return unless self < ResourcesController
+        return if base_class? || self == Wallaby.configuration.mapping.resources_controller
+
+        @model_class ||= Map.model_class_map(name.gsub(/(^#{namespace}::)|(Controller$)/, EMPTY_STRING))
+      end
+    end
+
+    # @return [String] resources name for current request
+    def current_resources_name
+      @current_resources_name ||= params[:resources]
+    end
+
+    # @return [Class] model class for current request
+    def current_model_class
+      @current_model_class ||=
+        controller_to_get(__callee__, :model_class) || Map.model_class_map(current_resources_name || controller_path)
+    end
+
+    # Shorthand of params[:id]
+    # @return [String, nil] ID param
+    def resource_id
+      params[:id]
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a method to return collection for index page.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def collection
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   collection! options do |query| # NOTE: this is better than using `super`
+    #     # NOTE: make sure a collection is returned
+    #     query.where(active: true)
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def collection
+    #   # NOTE: pagination should happen here if needed
+    #   # NOTE: make sure `@collection` and conditional assignment (the OR EQUAL) operator are used
+    #   @collection ||= paginate Product.active
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0)
+    # @option options [ActionController::Parameters, Hash] :params parameters for collection query
+    # @option options [Boolean] :paginate see {Wallaby::Paginatable#paginate}
+    # @yield [collection] (since 5.2.0) a block to run to extend collection, e.g. call chain with more queries
+    # @return [#each] a collection of records
+    def collection(options = {}, &block)
+      @collection ||=
+        ModuleUtils.yield_for(
+          begin
+            options[:paginate] = true unless options.key?(:paginate)
+            options[:params] ||= params
+            paginate current_servicer.collection(options.delete(:params)), options
+          end,
+          &block
+        )
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a method to return resource for pages except `index`.
+    #
+    # `WARN: It does not do mass assignment since 5.2.0.`
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def resource
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   resource! options do |object| # NOTE: this is better than using `super`
+    #     object.preload_status_from_api
+    #     # NOTE: make sure object is returned
+    #     object
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def resource
+    #   # NOTE: make sure `@resource` and conditional assignment (the OR EQUAL) operator are used
+    #   @resource ||= resource_id.present? ? Product.find_by_slug(resource_id) : Product.new(arrival: true)
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0)
+    # @option options [Array<String>] :non_find_actions action names that shouldn't use resource find.
+    #   (Default to `%w(index new create)`)
+    # @option options [ActionController::Parameters, Hash] :find_params parameters/options for resource finding
+    # @option options [ActionController::Parameters, Hash] :new_params parameters/options for new resource
+    # @yield [resource] (since 5.2.0) a block to run to extend resource, e.g. making change to the resource.
+    #   Please make sure to return the resource at the end of block
+    # @return [Object] either persisted or unpersisted resource instance
+    # @raise [ResourceNotFound] if resource is nil
+    def resource(options = {}, &block)
+      @resource ||=
+        ModuleUtils.yield_for(
+          # this will testify both resource and resources
+          if resource_id.present? || !(options[:non_find_actions] || NON_FIND_ACTIONS).include?(action_name)
+            current_servicer.find resource_id, options[:find_params]
+          else
+            current_servicer.new options[:new_params]
+          end,
+          &block
+        )
+    end
+  end
+end