wallaby 5.0.1 → 5.1.3

data/lib/adaptors/wallaby/active_record/model_service_provider.rb

@@ -0,0 +1,137 @@
+module Wallaby
+  class ActiveRecord
+    # Model service provider
+    # @see Wallaby::ModelServiceProvider
+    class ModelServiceProvider < ::Wallaby::ModelServiceProvider
+      # @see Wallaby::ModelServiceProvider#permit
+      def permit(params)
+        return {} if params[param_key].blank?
+        # using fetch could avoid ActionController::ParameterMissing
+        params.fetch(param_key, {}).permit permitted_fields
+      end
+
+      # @see Wallaby::ModelServiceProvider#collection
+      def collection(params, authorizer)
+        # NOTE: pagination free here
+        # since somewhere might use it without pagination
+        query = querier.search params
+        query = query.order params[:sort] if params[:sort].present?
+        query.accessible_by authorizer
+      end
+
+      # @see Wallaby::ModelServiceProvider#paginate
+      def paginate(query, params)
+        per = params[:per] || Wallaby.configuration.pagination.page_size
+        query = query.page params[:page] if query.respond_to? :page
+        query = query.per per if query.respond_to? :per
+        query
+      end
+
+      # @see Wallaby::ModelServiceProvider#new
+      def new(permitted_params, _authorizer)
+        @model_class.new normalize permitted_params
+      rescue ::ActiveModel::UnknownAttributeError
+        @model_class.new
+      end
+
+      # @see Wallaby::ModelServiceProvider#find
+      def find(id, permitted_params, _authorizer)
+        resource = @model_class.find id
+        resource.assign_attributes normalize permitted_params
+        resource
+      rescue ::ActiveRecord::RecordNotFound
+        raise ResourceNotFound, id
+      rescue ::ActiveModel::UnknownAttributeError
+        resource
+      end
+
+      # @see Wallaby::ModelServiceProvider#create
+      def create(resource_with_new_value, params, authorizer)
+        save __callee__, resource_with_new_value, params, authorizer
+      end
+
+      # @see Wallaby::ModelServiceProvider#update
+      def update(resource_with_new_value, params, authorizer)
+        save __callee__, resource_with_new_value, params, authorizer
+      end
+
+      # @see Wallaby::ModelServiceProvider#destroy
+      def destroy(resource, _params, _authorizer)
+        resource.destroy
+      end
+
+      protected
+
+      # Save the active record
+      # @param action [String] `create`, `update`
+      # @param resource [Object]
+      # @param _params [ActionController::Parameters]
+      # @param authorizer [Object]
+      # @return resource itself
+      def save(action, resource, _params, authorizer)
+        ensure_attributes_for authorizer, action, resource
+        resource.save if valid? resource
+        resource
+      rescue ::ActiveRecord::StatementInvalid => e
+        resource.errors.add :base, e.message
+        resource
+      end
+
+      # Normalize params
+      # @param params [ActionController::Parameters]
+      def normalize(params)
+        normalizer.normalize params
+      end
+
+      # See if a resource is valid
+      # @param resource [Object]
+      # @return [Boolean]
+      def valid?(resource)
+        validator.valid? resource
+      end
+
+      # To make sure that the record can be updated with the values that are
+      # allowed to.
+      # @param authorizer [Object]
+      # @param action [String]
+      # @param resource [Object]
+      def ensure_attributes_for(authorizer, action, resource)
+        return if authorizer.blank?
+        restricted_conditions = authorizer.attributes_for action, resource
+        resource.assign_attributes restricted_conditions
+      end
+
+      # The params key
+      def param_key
+        @model_class.model_name.param_key
+      end
+
+      # The list of attributes to whitelist
+      # @return [Array]
+      def permitted_fields
+        @permitted_fields ||=
+          permitter.simple_field_names << permitter.compound_hashed_fields
+      end
+
+      # @see Wallaby::ModelServiceProvider::Permitter
+      def permitter
+        @permitter ||= Permitter.new @model_decorator
+      end
+
+      # @see Wallaby::ModelServiceProvider::Querier
+      def querier
+        @querier ||= Querier.new @model_decorator
+      end
+
+      # @see Wallaby::ModelServiceProvider::Normalizer
+      def normalizer
+        @normalizer ||= Normalizer.new @model_decorator
+      end
+
+      # @see Wallaby::ModelServiceProvider::Validator
+      def validator
+        @validator ||= Validator.new @model_decorator
+      end
+    end
+  end
+end

data/lib/adaptors/wallaby/active_record.rb

@@ -1,2 +1,5 @@
-class Wallaby::ActiveRecord < Wallaby::Mode
+module Wallaby
+  # Active Record mode
+  class ActiveRecord < Mode
+  end
 end

data/lib/decorators/wallaby/abstract_resource_decorator.rb

@@ -0,0 +1,74 @@
+module Wallaby
+  # Resource Decorator base class
+  class AbstractResourceDecorator
+    class << self
+      # Guess the model class from class name
+      # @return [Class]
+      def model_class
+        return unless self < ::Wallaby::ResourceDecorator
+        Map.model_class_map name.gsub 'Decorator', EMPTY_STRING
+      end
+
+      # Get the model decorator for the model class
+      # It should be the same as #model_decorator
+      # @return Wallaby::ModelDecorator
+      def model_decorator
+        return unless self < ::Wallaby::ResourceDecorator
+        Map.model_decorator_map model_class
+      end
+
+      delegation_methods =
+        ModelDecorator.instance_methods \
+          - ::Object.instance_methods - %i(model_class)
+      delegate(*delegation_methods, to: :model_decorator, allow_nil: true)
+    end
+
+    attr_reader :resource, :model_decorator
+
+    def initialize(resource)
+      @resource = resource
+      @model_decorator = Map.model_decorator_map model_class
+    end
+
+    # @return [Class] resource's class
+    def model_class
+      @resource.class
+    end
+
+    # Guess the title for given resource
+    # It falls back to primary key value when no text field is found
+    # `.to_s` at the end is to ensure String is returned that won't cause any
+    # issue when `#to_label` is used in a link_to block. Coz integer is ignored.
+    # @return [String]
+    def to_label
+      (@model_decorator.guess_title(@resource) || primary_key_value).to_s
+    end
+
+    # Return the validation errors
+    # @return [Hash, Array]
+    def errors
+      @model_decorator.form_active_errors(@resource)
+    end
+
+    # @return [Object] primary key value
+    def primary_key_value
+      @resource.public_send primary_key
+    end
+
+    delegation_methods =
+      ModelDecorator.instance_methods \
+        - ::Object.instance_methods - %i(model_class)
+    delegate(*delegation_methods, to: :model_decorator)
+    delegate :to_s, :to_param, to: :resource
+
+    # We delegate missing methods to resource
+    def method_missing(method_id, *args)
+      return super unless @resource.respond_to? method_id
+      @resource.public_send method_id, *args
+    end
+
+    def respond_to_missing?(method_id, _include_private)
+      @resource.respond_to?(method_id) || super
+    end
+  end
+end

data/lib/decorators/wallaby/resource_decorator.rb

@@ -1,78 +1,7 @@
-class Wallaby::ResourceDecorator
-  class << self
-    def model_class
-      if self < Wallaby::ResourceDecorator
-        @model_class ||= Wallaby::Utils.to_model_class name.gsub('Decorator', ''), name
-      end
-    end
-
-    def model_decorator
-      if self < Wallaby::ResourceDecorator
-        @model_decorator ||= Wallaby::DecoratorFinder.new_model model_class
-      end
-    end
-
-    def decorate(resource)
-      return resource if resource.is_a? Wallaby::ResourceDecorator
-      new resource
-    end
-
-    delegate *begin
-      Wallaby::ModelDecorator.instance_methods \
-        - Object.instance_methods - %i( model_class )
-    end, to: :model_decorator, allow_nil: true
-  end
-
-  def initialize(resource)
-    @resource         = resource
-    @model_decorator  = self.class.model_decorator || Wallaby::DecoratorFinder.new_model(model_class)
-  end
-
-  def method_missing(method_id, *args)
-    if @resource.respond_to? method_id
-      @resource.public_send method_id, *args
-    else
-      super
-    end
-  end
-
-  delegate :to_s, :to_param, :to_params, to: :@resource
-  delegate *begin
-    Wallaby::ModelDecorator.instance_methods \
-      - %i( index_fields index_field_names show_fields show_field_names form_fields form_field_names ) \
-      - Object.instance_methods
-  end, to: :@model_decorator
-  attr_reader :model_decorator
-
-  def model_class
-    @resource.class
-  end
-
-  def resource
-    @resource
-  end
-
-  def to_label
-    @model_decorator.guess_title(@resource) || primary_key_value
-  end
-
-  def errors
-    @model_decorator.form_active_errors(@resource)
-  end
-
-  def primary_key_value
-    @resource.public_send primary_key
-  end
-
-  [ '', 'index_', 'show_', 'form_' ].each do |prefix|
-    class_eval <<-RUBY
-      def #{ prefix }fields
-        @#{ prefix }fields ||= @model_decorator.#{ prefix }fields.dup.freeze
-      end
-
-      def #{ prefix }field_names
-        @#{ prefix }field_names ||= @model_decorator.#{ prefix }field_names.dup.freeze
-      end
-    RUBY
+module Wallaby
+  # Resource Decorator
+  # @see Wallaby::AbstractResourceDecorator
+  # @overwritable
+  class ResourceDecorator < AbstractResourceDecorator
   end
 end

data/lib/errors/wallaby/model_not_found.rb

@@ -1,4 +1,8 @@
 module Wallaby
-  class ModelNotFound < GeneralError
+  # Model not found error
+  class ModelNotFound < NotFound
+    def message
+      I18n.t 'errors.not_found.model', model: super
+    end
   end
 end

data/lib/errors/wallaby/not_found.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class NotFound < GeneralError
+  end
+end

data/lib/errors/wallaby/resource_not_found.rb

@@ -1,4 +1,8 @@
 module Wallaby
-  class ResourceNotFound < GeneralError
+  # Resource not found error
+  class ResourceNotFound < NotFound
+    def message
+      I18n.t 'errors.not_found.resource', resource: super
+    end
   end
 end

data/lib/forms/wallaby/form_builder.rb

@@ -1,30 +1,53 @@
-class Wallaby::FormBuilder < ActionView::Helpers::FormBuilder
-  def error_class(field_name)
-    'has-error' if has_error? field_name
-  end
+module Wallaby
+  # Custom form builder to add more helper functions
+  class FormBuilder < ::ActionView::Helpers::FormBuilder
+    # Return error class if there is error
+    # @param field_name [String/Symbol]
+    # @return [String]
+    def error_class(field_name)
+      'has-error' if object.errors[field_name].present?
+    end
 
-  def error_messages(field_name)
-    errors = Array object.errors[ field_name ]
-    return if errors.blank?
+    # Build up the HTML for displaying error messages
+    # @param field_name [String/Symbol]
+    # @return [String] HTML
+    def error_messages(field_name)
+      errors = Array object.errors[field_name]
+      return if errors.blank?
 
-    content_tag :ul, class: 'text-danger' do
-      errors.each do |message|
-        concat content_tag :li, content_tag(:small, raw(message))
+      content_tag :ul, class: 'errors' do
+        errors.each do |message|
+          concat content_tag :li, content_tag(:small, raw(message))
+        end
       end
     end
-  end
 
-  protected
-  def method_missing(method, *args, &block)
-    if @template.respond_to? method
+    # Extend label to accept proc type `text` argument
+    def label(method, text = nil, options = {}, &block)
+      text = instance_exec(&text) if text.respond_to? :call
+      super
+    end
+
+    # Extend select to accept proc type `choices` argument
+    def select(method, choices = nil, options = {}, html_options = {}, &block)
+      choices = instance_exec(&choices) if choices.respond_to? :call
+      super
+    end
+
+    protected
+
+    # Try to delegate method to `@template`
+    def method_missing(method, *args, &block)
+      return super unless @template.respond_to? method
+      # Delegate the method so that we don't come in here the next time
+      # same method is called
       self.class.delegate method, to: :@template
       @template.public_send method, *args, &block
-    else
-      super
     end
-  end
 
-  def has_error?(field_name)
-    object.errors[field_name].present?
+    # Pair with #method_missing
+    def respond_to_missing?(method, _include_private)
+      @template.respond_to?(method) || super
+    end
   end
 end

data/lib/helpers/wallaby/application_helper.rb

@@ -1,30 +1,40 @@
-module Wallaby::ApplicationHelper
-  def clean_params
-    params.except :resources, :action
-  end
+module Wallaby
+  # Application helper
+  module ApplicationHelper
+    # Override `actionview/lib/action_view/routing_url_for.rb#url_for`
+    # to handle the url_for properly for wallaby engine
+    def url_for(options = nil)
+      # possible Hash or Parameters
+      if options.respond_to?(:to_h) \
+        && options[:resources].present? && options[:action].present?
+        UrlFor.handle wallaby_engine, options
+      else
+        super options
+      end
+    end
 
-  # override `actionview/lib/action_view/routing_url_for.rb#url_for`
-  def url_for(options = nil)
-    if options.is_a?(Hash) && options.slice(:action, :resources).length == 2
-      return wallaby_resourceful_url_for options
+    # Add turbolinks options when it's enabled
+    def stylesheet_link_tag(*sources)
+      default_options =
+        if Wallaby.configuration.features.turbolinks_enabled
+          { 'data-turbolinks-track' => true }
+        else
+          {}
+        end
+      options = default_options.merge!(sources.extract_options!.stringify_keys)
+      super(*sources, options)
     end
-    super
-  end
 
-  def wallaby_resourceful_url_for(options = {})
-    # DEPRECATION WARNING: You are calling a `*_path` helper with the `only_path` option explicitly set to `false`. This option will stop working on path helpers in Rails 5. Use the corresponding `*_url` helper instead.
-    options = options.except :only_path
-    case options[:action]
-    when 'index', 'create'
-      wallaby_engine.resources_path options
-    when 'new'
-      wallaby_engine.new_resource_path options
-    when 'edit'
-      wallaby_engine.edit_resource_path options
-    when 'show', 'update', 'destroy'
-      wallaby_engine.resource_path options
-    else
-      wallaby_engine.url_for options
+    # Add turbolinks options when it's enabled
+    def javascript_include_tag(*sources)
+      default_options =
+        if Wallaby.configuration.features.turbolinks_enabled
+          { 'data-turbolinks-track' => true, 'data-turbolinks-eval' => false }
+        else
+          {}
+        end
+      options = default_options.merge!(sources.extract_options!.stringify_keys)
+      super(*sources, options)
     end
   end
 end

data/lib/helpers/wallaby/base_helper.rb

@@ -0,0 +1,52 @@
+module Wallaby
+  # NOTE: Global helper methods should go in here
+  module BaseHelper
+    include StylingHelper
+    include LinksHelper
+
+    # @see Utils.to_model_label
+    def to_model_label(model_class)
+      Utils.to_model_label model_class
+    end
+
+    # @see Map.resources_name_map
+    def to_resources_name(model_class)
+      Map.resources_name_map model_class
+    end
+
+    # @return [String] css classes for body tag
+    def body_class
+      [
+        params[:action],
+        current_resources_name.try(:gsub, COLONS, '__'),
+        content_for(:custom_body_class)
+      ].compact.join SPACE
+    end
+
+    # Turn a list of classes into tree structure
+    # @param classes [Array] a list of all the classes that wallaby supports
+    # @return [Array] a tree structure of given classes
+    def model_classes(classes = Map.model_classes)
+      nested_hash = classes.each_with_object({}) do |klass, hash|
+        hash[klass] = Node.new(klass)
+      end
+      nested_hash.each do |klass, node|
+        node.parent = parent = nested_hash[klass.superclass]
+        parent.children << node if parent
+      end
+      nested_hash.values.select { |v| v.parent.nil? }
+    end
+
+    # @param array [Array] root classes
+    # @return [String] HTML for the whole tree
+    def model_tree(array)
+      return EMPTY_STRING.html_safe if array.blank?
+      content_tag :ul, class: 'dropdown-menu' do
+        array.sort_by(&:name).each do |node|
+          content = index_link(node.klass).try :<<, model_tree(node.children)
+          concat content_tag(:li, content)
+        end
+      end
+    end
+  end
+end

data/lib/helpers/wallaby/form_helper.rb

@@ -1,21 +1,45 @@
-module Wallaby::FormHelper
-  def form_type_partial_render(options = {}, locals = {}, &block)
-    form        = locals[:form]
-    field_name  = locals[:field_name].to_s
-
-    fail ArgumentError unless form.present? && field_name.present? && form.object.is_a?(Wallaby::ResourceDecorator)
-
-    locals[:object]   = object = form.object
-    locals[:metadata] = object.form_metadata_of locals[:field_name]
-    locals[:value]    = object.public_send locals[:field_name]
+module Wallaby
+  # Form helper
+  module FormHelper
+    # @param options [Hash, String]
+    # @param locals [Hash] local variables for the partial
+    def form_type_partial_render(options = {}, locals = {}, &block)
+      PartialRenderer.render_form self, options, locals, &block
+    end
 
-    render(options, locals, &block) or render('string', locals, &block)
-  end
+    # To generate remote url for auto select plugin.
+    # @see app/assets/javascripts/wallaby/auto_select.js
+    # @param url [String, nil]
+    #   if url is nil, it will fall back to default remote url
+    # @param model_class [Class]
+    # @param wildcard [String] wildcard that auto_select uses to replace with
+    #   the typed keyword
+    def remote_url(url, model_class, wildcard = 'QUERY')
+      url ||
+        index_path(
+          model_class, url_params: {
+            q: wildcard, per: Wallaby.configuration.pagination.page_size
+          }
+        )
+    end
 
-  def model_choices(model_decorator)
-    collection = model_servicer(model_decorator).collection Hash.new, current_ability
-    decorate(collection).map do |decorated|
-      [ decorated.to_label, decorated.primary_key_value ]
+    # To generate dropdown options (class => url) for polymorphic class.
+    # @see app/assets/javascripts/wallaby/auto_select.js
+    # This function will pull out remote urls from `metadata[:remote_urls]`
+    # (Class => url).
+    # @param metadata [Hash]
+    # @param wildcard [String]
+    # @param select_options [Hash]
+    # @return [String] HTML
+    def polymorphic_options(metadata, wildcard = 'QUERY', select_options = {})
+      urls = metadata[:remote_urls] || {}
+      options = (metadata[:polymorphic_list] || []).map do |klass|
+        [
+          klass, klass,
+          { data: { url: remote_url(urls[klass], klass, wildcard) } }
+        ]
+      end
+      options_for_select options, select_options
     end
   end
 end

data/lib/helpers/wallaby/index_helper.rb

@@ -0,0 +1,59 @@
+module Wallaby
+  # Helper methods for index page
+  module IndexHelper
+    # Wrap the collection with paginator
+    # @param model_class [Class]
+    # @param collection [#map]
+    # @param params [ActionController::Parameters]
+    # @return [Wallaby::ResourcePaginator]
+    def paginate(model_class, collection, params)
+      Map.paginator_map(model_class).new model_class, collection, params
+    end
+
+    # Just a label
+    # @return [String]
+    def all_label
+      t 'filters.all'
+    end
+
+    # Label for a given name
+    # @param filter_name [String, Symbol]
+    # @param filters [Hash]
+    # @return [String]
+    def filter_label(filter_name, filters)
+      filters[filter_name].try(:[], :label) || filter_name.to_s.humanize
+    end
+
+    # Export link for a given model_class
+    # @param model_class [Class]
+    # @return [String] HTML anchor link
+    def export_link(model_class)
+      url_params = index_params.except(:page, :per).merge(format: 'csv')
+      index_link model_class, url_params: url_params do
+        t 'links.export', ext: 'CSV'
+      end
+    end
+
+    # Link for a given model class and filter name
+    # @param model_class [Class]
+    # @param filter_name [String, Symbol]
+    # @param filters [Hash]
+    # @return [String] HTML anchor link
+    def filter_link(model_class, filter_name, filters)
+      is_all = filter_name == :all
+      config = filters[filter_name] || {}
+      label = is_all ? all_label : filter_label(filter_name, filters)
+      url_params = if config[:default] then index_params.except(:filter)
+                   else index_params.merge(filter: filter_name)
+                   end
+      index_link(model_class, url_params: url_params) { label }
+    end
+
+    # Sort link builder
+    # @return [Sorting::LinkBuilder]
+    def sort_link_builder
+      @sort_link_builder ||=
+        Sorting::LinkBuilder.new current_model_decorator, index_params, self
+    end
+  end
+end