wallaby 5.0.1 → 5.1.3

data/lib/interfaces/wallaby/model_decorator.rb

@@ -1,58 +1,184 @@
-class Wallaby::ModelDecorator
-  attr_reader :model_class
+module Wallaby
+  # Model Decorator interface, designed to maintain metadata information for all
+  # the fields coming from data source (database/api)
+  # @see Wallaby::ResourceDecorator for more information on how to customise
+  #   metadata information
+  class ModelDecorator
+    attr_reader :model_class
+    attr_writer \
+      :field_names, :index_field_names, :show_field_names, :form_field_names
 
-  def initialize(model_class)
-    @model_class = model_class
-  end
+    def initialize(model_class)
+      @model_class = model_class
+    end
 
-  [ '', 'index_', 'show_', 'form_' ].each do |prefix|
-    class_eval <<-RUBY
-      def #{ prefix }fields
-        fail Wallaby::NotImplemented
-      end
-
-      def #{ prefix }fields=(#{ prefix }fields)
-        @#{ prefix }fields = #{ prefix }fields.with_indifferent_access
-      end
-
-      def #{ prefix }field_names
-        @#{ prefix }field_names ||= #{ prefix }fields.keys.tap do |names|
-          names.delete primary_key
-          names.unshift primary_key
-        end
-      end
-
-      def #{ prefix }field_names=(#{ prefix }field_names)
-        @#{ prefix }field_names = #{ prefix }field_names
-      end
-
-      def #{ prefix }metadata_of(field_name)
-        #{ prefix }fields[field_name] || {}
-      end
-
-      def #{ prefix }label_of(field_name)
-        #{ prefix }metadata_of(field_name)[:label]
-      end
-
-      def #{ prefix }type_of(field_name)
-        #{ prefix }metadata_of(field_name)[:type]
-      end
-    RUBY
-  end
+    # @return [Hash] metadata information for all fields that index/show/form
+    #   will copy
+    def fields
+      raise NotImplemented
+    end
 
-  def form_active_errors(resource)
-    fail Wallaby::NotImplemented
-  end
+    # @param fields [Hash] metadata information for all fields
+    def fields=(fields)
+      @fields = ::ActiveSupport::HashWithIndifferentAccess.new fields
+    end
 
-  def primary_key
-    fail Wallaby::NotImplemented
-  end
+    # @return [Array] field names
+    def field_names
+      @field_names ||= reposition fields.keys, primary_key
+    end
 
-  def guess_title(resource)
-    fail Wallaby::NotImplemented
-  end
+    # @return [Hash] metadata information for a given field
+    def metadata_of(field_name)
+      fields[field_name] || {}
+    end
+
+    # @return [String] label for a given field
+    def label_of(field_name)
+      metadata_of(field_name)[:label]
+    end
+
+    # @return [String, Symbol] type for a given field
+    def type_of(field_name)
+      validate_presence_of metadata_of(field_name)[:type]
+    end
+
+    # @return [Hash] metadata information for all fields that would be used on
+    #   index page
+    def index_fields
+      raise NotImplemented
+    end
+
+    # @param fields [Hash] metadata information for all fields that would be
+    #   used on index page
+    def index_fields=(fields)
+      @index_fields = ::ActiveSupport::HashWithIndifferentAccess.new fields
+    end
+
+    # @return [Array] field names of index page
+    def index_field_names
+      @index_field_names ||= reposition index_fields.keys, primary_key
+    end
+
+    # @return [Hash] index metadata information for a given field
+    def index_metadata_of(field_name)
+      index_fields[field_name] || {}
+    end
+
+    # @return [String] index label for a given field
+    def index_label_of(field_name)
+      index_metadata_of(field_name)[:label]
+    end
+
+    # @return [String, Symbol] index type for a given field
+    def index_type_of(field_name)
+      validate_presence_of index_metadata_of(field_name)[:type]
+    end
+
+    # @return [Hash] metadata information for all fields that would be used on
+    #   show page
+    def show_fields
+      raise NotImplemented
+    end
+
+    # @param fields [Hash] metadata information for all fields that would be
+    #   used on show page
+    def show_fields=(fields)
+      @show_fields = ::ActiveSupport::HashWithIndifferentAccess.new fields
+    end
+
+    # @return [Array] field names of show page
+    def show_field_names
+      @show_field_names ||= reposition show_fields.keys, primary_key
+    end
+
+    # @return [Hash] show metadata information for a given field
+    def show_metadata_of(field_name)
+      show_fields[field_name] || {}
+    end
+
+    # @return [String] show label for a given field
+    def show_label_of(field_name)
+      show_metadata_of(field_name)[:label]
+    end
+
+    # @return [String, Symbol] show type for a given field
+    def show_type_of(field_name)
+      validate_presence_of show_metadata_of(field_name)[:type]
+    end
+
+    # @return [Hash] metadata information for all fields that would be used on
+    #   form page
+    def form_fields
+      raise NotImplemented
+    end
+
+    # @param fields [Hash] metadata information for all fields that would be
+    #   used on form page
+    def form_fields=(fields)
+      @form_fields = ::ActiveSupport::HashWithIndifferentAccess.new fields
+    end
+
+    # @return [Array] field names of form page
+    def form_field_names
+      @form_field_names ||= reposition form_fields.keys, primary_key
+    end
+
+    # @return [Hash] form metadata information for a given field
+    def form_metadata_of(field_name)
+      form_fields[field_name] || {}
+    end
+
+    # @return [String] form label for a given field
+    def form_label_of(field_name)
+      form_metadata_of(field_name)[:label]
+    end
+
+    # @return [String, Symbol] form type for a given field
+    def form_type_of(field_name)
+      validate_presence_of form_metadata_of(field_name)[:type]
+    end
+
+    # @return [Hash] custom filters
+    def filters
+      @filters ||= ::ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # @return [Hash] errors
+    def form_active_errors(_resource)
+      raise NotImplemented
+    end
+
+    # @return [String] primary key
+    def primary_key
+      raise NotImplemented
+    end
+
+    # @param _resource [Object] resource
+    # @return [String] title of given resource
+    def guess_title(_resource)
+      raise NotImplemented
+    end
+
+    # @return [String] resources name mapped from model class
+    def resources_name
+      Map.resources_name_map @model_class
+    end
+
+    protected
+
+    # @param field_names [Array] field names
+    # @param primary_key [String] primary key name
+    # @return [Array] a list of field names that primary key goes first
+    def reposition(field_names, primary_key)
+      field_names.unshift(primary_key).uniq
+    end
 
-  def resources_name
-    Wallaby::Utils.to_resources_name @model_class
+    # Ensure type is present
+    # @param type [String, Symbol, nil] type of a field
+    # @return [String, Symbol] type name
+    def validate_presence_of(type)
+      type || raise(::ArgumentError, 'Type is required.')
+    end
   end
 end

data/lib/interfaces/wallaby/model_finder.rb

@@ -1,5 +1,9 @@
-class Wallaby::ModelFinder
-  def all
-    fail Wallaby::NotImplemented
+module Wallaby
+  # Model finder interface
+  class ModelFinder
+    # Need to implement this method to get all the available model for a mode
+    def all
+      raise NotImplemented
+    end
   end
 end

data/lib/interfaces/wallaby/model_pagination_provider.rb

@@ -0,0 +1,104 @@
+module Wallaby
+  # Model pagination provider interface
+  class ModelPaginationProvider
+    # @param collection
+    # @param params [ActionController::Parameters]
+    # @param options [Hash] options
+    # @param model_decorator [Wallaby::ModelDecorator, nil]
+    def initialize(collection, params, options: {}, model_decorator: nil)
+      @collection = collection
+      @params = params
+      @options = options
+      @model_decorator = model_decorator
+    end
+
+    # If a collection has pagination feature
+    def paginatable?
+      raise NotImplemented
+    end
+
+    # Check and see if it's the first page
+    # @return boolean
+    def first_page?
+      page_number > first_page_number
+    end
+
+    # Check and see if it's the previous page
+    # @return boolean
+    def prev_page?
+      page_number > first_page_number
+    end
+
+    # Check and see if it's the last page
+    # @return boolean
+    def last_page?
+      page_number < last_page_number
+    end
+
+    # Check and see if it's the next page
+    # @return boolean
+    def next_page?
+      page_number < last_page_number
+    end
+
+    # Find out the offset `from`
+    # @return [Integer]
+    def from
+      (page_number - 1) * page_size + 1
+    end
+
+    # Find out the offset `to`
+    # @return [Integer]
+    def to
+      [page_number * page_size, total].min
+    end
+
+    # Find out the total count of current query
+    # @return [Integer]
+    def total
+      raise NotImplemented
+    end
+
+    # Find out the current page size
+    # @return [Integer]
+    def page_size
+      raise NotImplemented
+    end
+
+    # Find out the current page number
+    # @return [Integer]
+    def page_number
+      raise NotImplemented
+    end
+
+    # Page number of first page
+    # @return [Integer]
+    def first_page_number
+      1
+    end
+
+    # Page number of last page
+    # @return [Integer]
+    def last_page_number
+      number_of_pages
+    end
+
+    # Page number of previous page
+    # @return [Integer]
+    def prev_page_number
+      [page_number - 1, first_page_number].max
+    end
+
+    # Page number of next page
+    # @return [Integer]
+    def next_page_number
+      [page_number + 1, last_page_number].min
+    end
+
+    # Total number of pages
+    # @return [Integer]
+    def number_of_pages
+      (total / page_size.to_f).ceil
+    end
+  end
+end

data/lib/interfaces/wallaby/model_service_provider.rb

@@ -0,0 +1,71 @@
+module Wallaby
+  # Model service provider interface
+  class ModelServiceProvider
+    # @param model_class [Class] model class
+    # @param model_decorator [Wallaby::ModelDecorator, nil] model decorator
+    def initialize(model_class, model_decorator = nil)
+      raise ::ArgumentError, 'model class required' unless model_class
+      @model_class = model_class
+      @model_decorator = model_decorator || Map.model_decorator_map(model_class)
+    end
+
+    # To whitelist params for a model class
+    # @param _params [ActionController::Parameters]
+    def permit(_params)
+      raise NotImplemented
+    end
+
+    # Fetch collection by params
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    def collection(_params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Paginate the records
+    # @param _query
+    # @param _params [ActionController::Parameters]
+    def paginate(_query, _params)
+      raise NotImplemented
+    end
+
+    # Initialize the model class using params
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    def new(_params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Find a record using id
+    # @param _id [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    def find(_id, _params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Save the newly initialized resource
+    # @param _resource [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    def create(_resource, _params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Update the persisted resource
+    # @param _resource [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    def update(_resource, _params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Destroy the given resource
+    # @param _resource [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    def destroy(_resource, _params, _authorizer)
+      raise NotImplemented
+    end
+  end
+end

data/lib/paginators/wallaby/abstract_resource_paginator.rb

@@ -0,0 +1,23 @@
+module Wallaby
+  # Model paginator
+  class AbstractResourcePaginator
+    def self.model_class
+      return unless self < ::Wallaby::ResourcePaginator
+      Map.model_class_map name.gsub('Paginator', EMPTY_STRING)
+    end
+
+    # Delegate methods to pagination provider
+    instance_methods =
+      ModelPaginationProvider.instance_methods - ::Object.instance_methods
+    delegate(*instance_methods, to: :@provider)
+
+    def initialize(model_class, collection, params)
+      @model_class = model_class || self.class.model_class
+      raise ArgumentError, 'model class required' unless @model_class
+      @collection = collection
+      @params = params
+      @provider =
+        Map.pagination_provider_map(@model_class).new(@collection, @params)
+    end
+  end
+end

data/lib/paginators/wallaby/resource_paginator.rb

@@ -0,0 +1,6 @@
+module Wallaby
+  # Resource paginator
+  # @see Wallaby::AbstractResourcePaginator
+  class ResourcePaginator < AbstractResourcePaginator
+  end
+end

data/lib/parsers/wallaby/parser.rb

@@ -0,0 +1,32 @@
+module Wallaby
+  # a parser to handle colon query
+  class Parser < Parslet::Parser
+    root(:statement)
+    rule(:statement) { expression >> (space >> expression).repeat }
+    rule(:expression) { colon_query | general_keyword }
+    rule(:colon_query) do
+      name.as(:left) >> operator.as(:op) >> keywords.as(:right)
+    end
+    rule(:name) { (space.absent? >> colon.absent? >> any).repeat(1) }
+    rule(:operator) { colon >> match('[^\s\'\"\:\,0-9a-zA-Z]').repeat(0, 3) }
+    rule(:keywords) { general_keyword >> (comma >> general_keyword).repeat }
+    rule(:general_keyword) { quoted_keyword | keyword }
+
+    # basic elements
+    rule(:quoted_keyword) do
+      open_quote >>
+        (close_quote.absent? >> any).repeat.as(:keyword) >>
+        close_quote
+    end
+    rule(:keyword) { ((space | comma).absent? >> any).repeat.as(:keyword) }
+
+    # atomic entities
+    rule(:comma) { str(',') }
+    rule(:space) { match('\s').repeat(1) }
+    rule(:colon) { str(':') }
+
+    # open-close elements
+    rule(:open_quote) { match('[\'\"]').capture(:quote) }
+    rule(:close_quote) { dynamic { |_src, ctx| str(ctx.captures[:quote]) } }
+  end
+end

data/lib/responders/wallaby/abstract_responder.rb

@@ -0,0 +1,68 @@
+module Wallaby
+  # abstract responder for later usage
+  class AbstractResponder < ActionController::Responder
+    include ::Responders::FlashResponder
+
+    delegate :params, :headers, to: :request
+
+    def to_html
+      set_flash_message
+      if post? then create_action
+      elsif patch? || put? then update_action
+      elsif delete? then destroy_action
+      else default_render
+      end
+    end
+
+    def to_csv
+      set_layout_to_none
+      headers['Content-Disposition'] = "attachment; filename=\"#{file_name}\""
+      default_render
+    end
+
+    def to_json
+      set_layout_to_none
+      return default_render unless post? || patch? || put? || delete?
+      if has_errors? then \
+        render :bad_request, options.merge(status: :bad_request)
+      else render :form, options
+      end
+    end
+
+    private
+
+    def create_action
+      if has_errors?
+        render :new, options
+      else
+        redirect_to resource_location
+      end
+    end
+
+    def update_action
+      if has_errors?
+        render :edit, options
+      else
+        redirect_to resource_location
+      end
+    end
+
+    def destroy_action
+      redirect_to resource_location
+    end
+
+    def file_name
+      timestamp = Time.zone.now.to_s(:number)
+      "#{params[:resources]}-exported-#{timestamp}.#{format}"
+    end
+
+    def set_layout_to_none
+      options[:layout] = false
+    end
+
+    def set_flash_message
+      # @see FlashResponder
+      set_flash_message! if set_flash_message?
+    end
+  end
+end

data/lib/responders/wallaby/resources_responder.rb

@@ -0,0 +1,6 @@
+module Wallaby
+  # Resources responder for later usage
+  # @overwritable
+  class ResourcesResponder < AbstractResponder
+  end
+end

data/lib/servicers/wallaby/abstract_model_servicer.rb

@@ -0,0 +1,48 @@
+module Wallaby
+  # Model servicer
+  class AbstractModelServicer
+    def self.model_class
+      return unless self < ::Wallaby::ModelServicer
+      Map.model_class_map name.gsub('Servicer', EMPTY_STRING)
+    end
+
+    def initialize(model_class = nil, authorizer = nil)
+      @model_class = model_class || self.class.model_class
+      raise ArgumentError, 'model class required' unless @model_class
+      @authorizer = authorizer
+      @provider = Map.service_provider_map @model_class
+    end
+
+    def permit(params)
+      @provider.permit params
+    end
+
+    def collection(params)
+      @provider.collection params, @authorizer
+    end
+
+    def paginate(query, params)
+      @provider.paginate query, params
+    end
+
+    def new(params)
+      @provider.new params, @authorizer
+    end
+
+    def find(id, params)
+      @provider.find id, params, @authorizer
+    end
+
+    def create(resource, params)
+      @provider.create resource, params, @authorizer
+    end
+
+    def update(resource, params)
+      @provider.update resource, params, @authorizer
+    end
+
+    def destroy(resource, params)
+      @provider.destroy resource, params, @authorizer
+    end
+  end
+end

data/lib/servicers/wallaby/model_servicer.rb

@@ -0,0 +1,5 @@
+module Wallaby
+  # Model servicer
+  class ModelServicer < AbstractModelServicer
+  end
+end

data/lib/services/wallaby/link_options_normalizer.rb

@@ -0,0 +1,16 @@
+module Wallaby
+  # Link renderer
+  class LinkOptionsNormalizer
+    class << self
+      def normalize(html_options, block, defaults)
+        block ||= defaults[:block]
+        html_options[:title] ||= defaults[:block].call
+        # allow empty class to be set
+        if !html_options.key?(:class) && defaults[:class]
+          html_options[:class] = defaults[:class]
+        end
+        [html_options, block]
+      end
+    end
+  end
+end