wallaby-core 0.2.9 → 0.3.0.beta1

data/lib/interfaces/wallaby/mode.rb

@@ -4,32 +4,32 @@ module Wallaby
   # This is the interface that all ORM modes should inherit from and implement.
   class Mode
     class << self
-      # @see Wallaby::ModelDecorator
+      # @see ModelDecorator
       # @return [Class] model decorator for the mode
       def model_decorator
         check_and_constantize __callee__
       end
 
-      # @see Wallaby::ModelFinder
+      # @see ModelFinder
       # @return [Class] model finder for the mode
       def model_finder
         check_and_constantize __callee__
       end
 
-      # @see Wallaby::ModelServiceProvider
+      # @see ModelServiceProvider
       # @return [Class] service provider for the mode
       def model_service_provider
         check_and_constantize __callee__
       end
 
-      # @see Wallaby::ModelPaginationProvider
+      # @see ModelPaginationProvider
       # @return [Class] pagination provider for the mode
       # @since wallaby-5.2.0
       def model_pagination_provider
         check_and_constantize __callee__
       end
 
-      # @see Wallaby::ModelPaginationProvider
+      # @see ModelPaginationProvider
       # @return [Class] pagination provider for the mode
       # @since wallaby-5.2.0
       def default_authorization_provider
@@ -37,7 +37,7 @@ module Wallaby
       end
 
       # Return a list of authorization providers for authorizer to detect which one to use.
-      # @see Wallaby::ModelAuthorizationProvider
+      # @see ModelAuthorizationProvider
       # @return [ActiveSupport::HashWithIndifferentAccess<String, Class>] authorization provider hash
       # @since wallaby-5.2.0
       def model_authorization_providers(classes = ModelAuthorizationProvider.descendants)
@@ -51,7 +51,7 @@ module Wallaby
           end
       end
 
-      private
+      protected
 
       # @return [Class] constantized class
       def check_and_constantize(method_id)
@@ -61,7 +61,7 @@ module Wallaby
         class_name.constantize.tap do |klass|
           next if klass < parent_class
 
-          raise InvalidError, Locale.t('mode.inherit_required', klass: klass, parent: parent_class)
+          raise InvalidError, "#{class_name} must inherit from #{parent_class}."
         end
       rescue NameError => e
         Logger.error e

data/lib/interfaces/wallaby/model_authorization_provider.rb

@@ -9,8 +9,8 @@ module Wallaby
       attr_writer :provider_name
 
       # @!attribute [r] provider_name
-      # This is the provider name that can be set in Wallaby::ModelAuthorizer subclasses.
-      # @see Wallaby::ModelAuthorizer.provider_name
+      # This is the provider name (e.g. `:default`/`:cancancan`/`:pundit`)
+      # that can be set in {ModelAuthorizer} subclasses's {ModelAuthorizer.provider_name}.
       # @return [String/Symbol] provider name
       def provider_name
         @provider_name ||= name.demodulize.gsub(/(Authorization)?Provider/, EMPTY_STRING).underscore
@@ -18,37 +18,38 @@ module Wallaby
 
       # @note Template method to check and see if current provider is in used.
       # @param _context [ActionController::Base, ActionView::Base]
-      # @raise [Wallaby::NotImplemented]
+      # @raise [NotImplemented]
       def available?(_context)
         raise NotImplemented
       end
-    end
-
-    # @!attribute [r] context
-    # @return [ActionController::Base, ActionView::Base]
-    attr_reader :context
 
-    # @!attribute [r] user
-    # @return [Object]
-    attr_reader :user
+      # @note Template method to get the required data from context.
+      # @param _context [ActionController::Base, ActionView::Base]
+      # @raise [NotImplemented]
+      def options_from(_context)
+        raise NotImplemented
+      end
+    end
 
     # @!attribute [r] options
     # @return [Hash]
     attr_reader :options
 
-    # @param context [ActionController::Base, ActionView::Base]
     # @param options [Hash]
-    def initialize(context, **options)
-      @context = context
-      @options = options
-      @user = context.try :wallaby_user
+    def initialize(options = {})
+      @options = options || {}
+    end
+
+    # @return [Object, nil] user object
+    def user
+      options[:user]
     end
 
     # @note It can be overridden in subclasses for customization purpose.
     # This is the template method to check user's permission for given action on given subject.
     # @param _action [Symbol, String]
     # @param _subject [Object, Class]
-    # @raise [Wallaby::NotImplemented]
+    # @raise [NotImplemented]
     def authorize(_action, _subject)
       raise NotImplemented
     end
@@ -57,7 +58,7 @@ module Wallaby
     # This is the template method to check if user has permission for given action on given subject.
     # @param _action [Symbol, String]
     # @param _subject [Object, Class]
-    # @raise [Wallaby::NotImplemented]
+    # @raise [NotImplemented]
     def authorized?(_action, _subject)
       raise NotImplemented
     end
@@ -66,7 +67,7 @@ module Wallaby
     # This is the template method to check if user has no permission for given action on given subject.
     # @param action [Symbol, String]
     # @param subject [Object, Class]
-    # @raise [Wallaby::NotImplemented]
+    # @raise [NotImplemented]
     def unauthorized?(action, subject)
       !authorized?(action, subject)
     end
@@ -75,7 +76,7 @@ module Wallaby
     # This is the template method to restrict user's access to certain scope.
     # @param _action [Symbol, String]
     # @param _scope [Object]
-    # @raise [Wallaby::NotImplemented]
+    # @raise [NotImplemented]
     def accessible_for(_action, _scope)
       raise NotImplemented
     end
@@ -84,7 +85,7 @@ module Wallaby
     # This is the template method to restrict user's modification to certain fields of given subject.
     # @param _action [Symbol, String]
     # @param _subject [Object]
-    # @raise [Wallaby::NotImplemented]
+    # @raise [NotImplemented]
     def attributes_for(_action, _subject)
       raise NotImplemented
     end
@@ -93,7 +94,7 @@ module Wallaby
     # This is the template method to restrict user's mass assignment to certain fields of given subject.
     # @param _action [Symbol, String]
     # @param _subject [Object]
-    # @raise [Wallaby::NotImplemented]
+    # @raise [NotImplemented]
     def permit_params(_action, _subject)
       raise NotImplemented
     end

data/lib/interfaces/wallaby/model_decorator.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Model Decorator interface, designed to maintain metadata for all fields from the data source (database/api)
-  # @see Wallaby::ResourceDecorator for more information on how to customize metadata
+  # Model Decorator interface, designed to hold and maintain metadata for all fields from the data source (database/api)
+  # @see {ResourceDecorator} for more information on how to customize metadata
   class ModelDecorator
     include Fieldable
 
+    MISSING_METHODS_RELATED_TO_FIELDS =
+      /\A(?<prefix>[a-zA-Z]\w*_)(?<method_partial>fields=?|field_names=?|metadata_of|label_of|type_of)\Z/.freeze
+
     # Initialize with model class
     # @param model_class [Class]
     def initialize(model_class)
@@ -16,6 +19,12 @@ module Wallaby
     # @return [Class]
     attr_reader :model_class
 
+    # @see AllFields
+    # @!attribute [r] all_fields
+    def all_fields
+      AllFields.new self
+    end
+
     # @!attribute [r] fields
     # @note to be implemented in subclasses.
     # Origin fields metadata.
@@ -39,21 +48,6 @@ module Wallaby
       raise NotImplemented
     end
 
-    # @!attribute [w] index_fields
-    def index_fields=(fields)
-      @index_fields = fields.with_indifferent_access
-    end
-
-    # @!attribute [w] index_field_names
-    attr_writer :index_field_names
-
-    # @!attribute [r] index_field_names
-    # A list of field names for `index` page
-    # @return [Array<String, Symbol>]
-    def index_field_names
-      @index_field_names ||= reposition index_fields.keys, primary_key
-    end
-
     # @!attribute [r] show_fields
     # @note to be implemented in subclasses.
     # Fields metadata for `show` page.
@@ -62,21 +56,6 @@ module Wallaby
       raise NotImplemented
     end
 
-    # @!attribute [w] show_fields
-    def show_fields=(fields)
-      @show_fields = fields.with_indifferent_access
-    end
-
-    # @!attribute [w] show_field_names
-    attr_writer :show_field_names
-
-    # @!attribute [r] show_field_names
-    # A list of field names for `show` page
-    # @return [Array<String, Symbol>]
-    def show_field_names
-      @show_field_names ||= reposition show_fields.keys, primary_key
-    end
-
     # @!attribute [r] form_fields
     # @note to be implemented in subclasses.
     # Fields metadata for form (`new`/`edit`) page.
@@ -85,19 +64,11 @@ module Wallaby
       raise NotImplemented
     end
 
-    # @!attribute [w] form_fields
-    def form_fields=(fields)
-      @form_fields = fields.with_indifferent_access
-    end
-
-    # @!attribute [w] form_field_names
-    attr_writer :form_field_names
-
     # @!attribute [r] form_field_names
     # A list of field names for form (`new`/`edit`) page
     # @return [Array<String, Symbol>]
     def form_field_names
-      @form_field_names ||= reposition form_fields.keys, primary_key
+      @form_field_names ||= form_fields.keys - [primary_key.to_s]
     end
 
     # @!attribute [r] filters
@@ -141,11 +112,26 @@ module Wallaby
     end
 
     # @return [String]
-    # @see Wallaby::Map.resources_name_map
+    # @see Map.resources_name_map
     def resources_name
       Map.resources_name_map model_class
     end
 
+    # Delegate missing methods to {Fieldable} if possible
+    def method_missing(method_id, *args, &block)
+      method_name = method_id.to_s
+      return super unless method_name.match?(MISSING_METHODS_RELATED_TO_FIELDS)
+
+      matched = MISSING_METHODS_RELATED_TO_FIELDS.match(method_name)
+      try("prefix_#{matched[:method_partial]}", *args, matched[:prefix], &block)
+    end
+
+    # Check if method looks like: `_fields`, `_field_names` that can be processed by {Fieldable}
+    def respond_to_missing?(method_id, _include_private)
+      method_name = method_id.to_s
+      method_name.match?(MISSING_METHODS_RELATED_TO_FIELDS) || super
+    end
+
     protected
 
     # Move primary key to the front for given field names.
@@ -153,7 +139,9 @@ module Wallaby
     # @param primary_key [String, Symbol] primary key name
     # @return [Array<String, Symbol>]
     # a new list of field names that primary key goes first
-    def reposition(field_names, primary_key)
+    def reposition(field_names, primary_key = self.primary_key)
+      return field_names if primary_key.blank?
+
       field_names.unshift(primary_key.to_s).uniq
     end
 
@@ -161,17 +149,17 @@ module Wallaby
     # @param type [String, Symbol, nil]
     # @return [String, Symbol] type
     # @raise [ArgumentError] when type is nil
-    def ensure_type_is_present(field_name, type, metadata_prefix = '')
+    def ensure_type_is_present(field_name, type, prefix = '')
       type || raise(::ArgumentError, <<~INSTRUCTION
-        The type for field `#{field_name}` is missing in metadata `#{metadata_prefix}_fields`.
+        The type for field `#{field_name}` is missing in metadata `#{prefix}_fields`.
         The possible causes are:
 
-        1. Check type's value from metadata `#{metadata_prefix}_fields[:#{field_name}][:type]`.
+        1. Check type's value from metadata `#{prefix}_fields[:#{field_name}][:type]`.
           If it is missing, specify the type as below:
 
-          #{metadata_prefix}field_name[:#{field_name}][:type] = 'string'
+          #{prefix}fields[:#{field_name}][:type] = 'string'
 
-        2. If metadata `#{metadata_prefix}_fields` is blank, maybe table hasn't be created yet
+        2. If metadata `#{prefix}_fields` is blank, maybe table hasn't be created yet
           or there is some error in the decorator class declaration.
       INSTRUCTION
       )

data/lib/interfaces/wallaby/model_finder.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module Wallaby
-  # Model finder interface
+  # see {#all}
   class ModelFinder
-    # Need to implement this method to get all the available model for a mode
-    # @return [Array<Class>] a list of model class
+    # @note Template method to return all the available models for a {Mode}
+    # @return [Array<Class>] a list of model classes
     def all
       raise NotImplemented
     end

data/lib/interfaces/wallaby/model_pagination_provider.rb

@@ -5,13 +5,9 @@ module Wallaby
   class ModelPaginationProvider
     # @param collection [#to_a]
     # @param params [ActionController::Parameters]
-    # @param options [Hash] options
-    # @param model_decorator [Wallaby::ModelDecorator, nil]
-    def initialize(collection, params, options: {}, model_decorator: nil)
+    def initialize(collection, params)
       @collection = collection
       @params = params
-      @options = options
-      @model_decorator = model_decorator
     end
 
     # If a collection has pagination feature
@@ -47,7 +43,7 @@ module Wallaby
     # Find out the offset `from`
     # @return [Integer]
     def from
-      total.zero? ? total : (page_number - 1) * page_size + 1
+      total.zero? ? total : ((page_number - 1) * page_size) + 1
     end
 
     # Find out the offset `to`

data/lib/interfaces/wallaby/model_service_provider.rb

@@ -4,7 +4,7 @@ module Wallaby
   # Model service provider interface
   class ModelServiceProvider
     # @param model_class [Class]
-    # @param model_decorator [Wallaby::ModelDecorator, nil] model decorator
+    # @param model_decorator [ModelDecorator, nil] model decorator
     def initialize(model_class, model_decorator)
       raise ::ArgumentError, 'model class required' unless model_class
 
@@ -12,11 +12,11 @@ module Wallaby
       @model_decorator = model_decorator
     end
 
-    # To whitelist params for a model class
+    # To allowlist params for a model class
     # @param _params [ActionController::Parameters]
     # @param _action [String, Symbol]
-    # @param _authorizer [Wallaby::ModelAuthorizer]
-    # @return [ActionController::Parameters] whitelisted params
+    # @param _authorizer [ModelAuthorizer]
+    # @return [ActionController::Parameters] allowlisted params
     def permit(_params, _action, _authorizer)
       raise NotImplemented
     end

data/lib/paginators/wallaby/model_paginator.rb

@@ -18,7 +18,7 @@ module Wallaby
     attr_reader :model_class
 
     # @!attribute [r] provider
-    # @return [Wallaby::ModelPaginationProvider] the instance that does the job
+    # @return [ModelPaginationProvider] the instance that does the job
     # @since wallaby-5.2.0
     attr_reader :provider
 

data/lib/responders/wallaby/json_api_responder.rb

@@ -35,14 +35,14 @@ module Wallaby
     def single(resource)
       {
         id: resource.id,
-        type: params[:resources],
+        type: params[:resources] || Inflector.to_resources_name(resource.class),
         attributes: attributes_of(resource)
       }
     end
 
     def collection_data
       {
-        data: resource.map(&method(:single)),
+        data: resource.map { |r| single(r) },
         links: {
           self: controller.url_for(resources: params[:resources], action: 'index')
         }
@@ -64,8 +64,8 @@ module Wallaby
         errors: decorated.errors.each_with_object([]) do |(field, message), json|
           json.push(
             status: 422,
-            source: { pointer: "/data/attributes/#{field}" },
-            detail: message
+            source: { pointer: "/data/attributes/#{field.try(:attribute) || field}" },
+            detail: field.try(:message) || message
           )
         end
       }
@@ -75,7 +75,12 @@ module Wallaby
       decorated = controller.decorate resource
       field_names = index? ? decorated.index_field_names : decorated.show_field_names
       field_names.each_with_object({}) do |name, attributes|
-        attributes[name] = decorated.public_send name
+        attributes[name] = decorated.try(name).try do |value|
+          is_attached = defined?(::ActiveStorage::Attached) && value.is_a?(::ActiveStorage::Attached)
+          # NOTE: 19/04/20 `ActiveStorage::Attached#as_json` causes a dead loop.
+          # Therefore, it's better to render the filename instead of letting it call `#as_json`
+          is_attached ? value.attachment.try(:blob).try(:filename) : value
+        end
       end
     end
 

data/lib/responders/wallaby/resources_responder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'csv'
+
 module Wallaby
   # Resources responder
   class ResourcesResponder < ActionController::Responder
@@ -16,12 +18,15 @@ module Wallaby
     # @return [String] file name with export timestamp
     def file_name_to_export
       timestamp = Time.zone.now.to_s(:number)
-      "#{request.params[:resources]}-exported-#{timestamp}.#{format}"
+      filename =
+        (request.params[:resources] || controller.controller_path)
+        .gsub(/#{SLASH}|#{COLONS}/o, HYPHEN)
+      "#{filename}-exported-#{timestamp}.#{format}"
     end
 
     # @return [Boolean] true if there is exception or resource has errors
     # @return [Boolean] false otherwise
-    def has_errors? # rubocop:disable Naming/PredicateName
+    def has_errors?
       resource.nil? || resource.is_a?(Exception) || controller.decorate(resource).errors.present?
     end
   end

data/lib/routes/wallaby/engines/base_route.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Engines
+    class BaseRoute
+      include ActiveModel::Model
+
+      # @!attribute context
+      # @return [ActionController::Base, ActionView::Base]
+      attr_accessor :context
+      # @!attribute params
+      # @return [Hash, ActionController::Parameters]
+      attr_accessor :params
+      # @!attribute params
+      # @return [Hash, ActionController::Parameters]
+      attr_accessor :options
+
+      protected
+
+      # @param route [ActionDispatch::Journey::Route]
+      def params_for(route)
+        # ensure all required keys (e.g. `id`) are included
+        required_params_from_recall = recall.slice(*route.required_keys)
+        required_resources_name =
+          route.required_keys.include?(:resources) ? { resources: resources_name } : {}
+
+        route
+          .requirements
+          .merge(required_params_from_recall)
+          .merge(required_resources_name)
+          .merge(complete_params)
+      end
+
+      # @return [String] given action param or current request's action
+      def action_name
+        @action_name ||= (params[:action] || recall[:action]).try(:to_s)
+      end
+
+      # @return [Class] model class option or converted model class from recall resources name
+      def model_class
+        @model_class ||= options[:model_class] || Map.model_class_map(resources_name)
+      end
+
+      # @return [String] resources name for given model
+      def resources_name
+        @resources_name ||=
+          params[:resources] ||
+          (options[:model_class] && Inflector.to_resources_name(options[:model_class])) ||
+          recall[:resources]
+      end
+
+      # Recall is the path params of current request
+      # @see https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/metal/url_for.rb#L35
+      # @return [Hash]
+      def recall
+        @recall ||= context.url_options[:_recall] || {}
+      end
+
+      # @return [Hash] query params from the request path
+      def with_query_params
+        options[:with_query] ? context.request.query_parameters : {}
+      end
+
+      # Symbolize param keys and normalize action
+      # @return [Hash]
+      def normalize_params(*args)
+        ParamsUtils
+          .presence(*args)
+          .deep_symbolize_keys
+          .tap do |normalized_params|
+            # convert :action (e.g. 'index') to string for requirements comparison
+            # :action value in route requirements is string (e.g. action: 'index')
+            normalized_params[:action] = action_name
+          end
+      end
+    end
+  end
+end

data/lib/routes/wallaby/engines/custom_app_route.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Wallaby
+  module Engines
+    # The general route of {Engine} looks like as follow:
+    #
+    #     /admin/order::items
+    #
+    # Therefore, to override this route, dev needs to define a resources as below
+    # before mounting {Engine}:
+    #
+    #     namespace :admin do
+    #       # NOTE: in order for the route to work properly,
+    #       # the colon before words need to be escaped in the path option
+    #       resources :items, path: 'order:\:item', module: :order
+    #     end
+    #     wallaby_mount at: '/admin'
+    #
+    # So to find out if any route has been overriden with current request, e.g. `/admin/order::items/1/edit`,
+    # we will look into the following conditions:
+    #
+    # - begins with `/admin`
+    # - same **action** as the given **action**
+    # - default **controller** exists (as {ResourcesRouter} does not define static **controller**)
+    #
+    # Then we use this route's params and pass it to the origin `url_for`.
+    class CustomAppRoute < BaseRoute
+      # @return [true] if the route matches the condition exists
+      # @return [false] otherwise
+      def exist?
+        route.present?
+      end
+
+      def url
+        context.url_for(params_for(route), super: true)
+      end
+
+      protected
+
+      delegate :script_name, to: :context
+
+      # @return [ActionDispatch::Journey::Route]
+      #   the application route that overrides the route handled by {Engine}
+      def route
+        @route ||=
+          Rails.application.routes.routes.find do |route|
+            prefix_matched?(route) && requirements_matched?(route)
+          end
+      end
+
+      # @return [true] if route's path begins with the prefix as where {Engine} route to,
+      #   e.g. `/admin/order::items`
+      # @return [false] otherwise
+      def prefix_matched?(route)
+        path = route.path.spec.to_s
+        path == script_name || path.start_with?(script_name + SLASH)
+      end
+
+      # @return [true] if the params matches route's requirements
+      # @return [false] otherwise
+      def requirements_matched?(route)
+        return false if route.requirements.blank?
+
+        route_params =
+          params_for(route).tap do |params|
+            params[:controller] = same_controller? ? context.controller_path : possible_controller_path
+          end
+
+        route.requirements <= route_params
+      end
+
+      # @return [true] if the given params is under the same controller as current request
+      # @return [false] otherwise
+      def same_controller?
+        context.current_model_class == model_class || context.current_resources_name == resources_name
+      end
+
+      # @return [String] possible controller path
+      def possible_controller_path
+        "#{script_name}/#{resources_name}"
+      end
+
+      # @return [Hash]
+      def complete_params
+        @complete_params ||=
+          normalize_params(with_query_params, params).tap do |normalized_params|
+            normalized_params.delete(:resources) if same_controller?
+          end
+      end
+    end
+  end
+end