wallaby-core 0.1.0

data/lib/interfaces/wallaby/model_finder.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model finder interface
+  class ModelFinder
+    # Need to implement this method to get all the available model for a mode
+    # @return [Array<Class>] a list of model class
+    def all
+      raise NotImplemented
+    end
+  end
+end

data/lib/interfaces/wallaby/model_pagination_provider.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model pagination provider interface
+  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)
+      @collection = collection
+      @params = params
+      @options = options
+      @model_decorator = model_decorator
+    end
+
+    # If a collection has pagination feature
+    # @return [Boolean]
+    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
+      total.zero? ? total : (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,84 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model service provider interface
+  class ModelServiceProvider
+    # @param model_class [Class]
+    # @param model_decorator [Wallaby::ModelDecorator, nil] model decorator
+    def initialize(model_class, model_decorator)
+      raise ::ArgumentError, 'model class required' unless model_class
+
+      @model_class = model_class
+      @model_decorator = model_decorator
+    end
+
+    # To whitelist params for a model class
+    # @param _params [ActionController::Parameters]
+    # @param _action [String, Symbol]
+    # @param _authorizer [Wallaby::ModelAuthorizer]
+    # @return [ActionController::Parameters] whitelisted params
+    def permit(_params, _action, _authorizer)
+      raise NotImplemented
+    end
+
+    # Fetch collection by params
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    # @return [#to_a]
+    def collection(_params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Paginate the resources
+    # @param _query
+    # @param _params [ActionController::Parameters]
+    # @return [#to_a]
+    def paginate(_query, _params)
+      raise NotImplemented
+    end
+
+    # Initialize the model class using params
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    # @return a resource object
+    def new(_params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Find a resource using id
+    # @param _id [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    # @return a resource object
+    def find(_id, _params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Save the newly initialized resource
+    # @param _resource [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    # @return a resource object
+    def create(_resource, _params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Update the persisted resource
+    # @param _resource [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    # @return a resource object
+    def update(_resource, _params, _authorizer)
+      raise NotImplemented
+    end
+
+    # Destroy the given resource
+    # @param _resource [Object]
+    # @param _params [ActionController::Parameters]
+    # @param _authorizer
+    # @return a resource object
+    def destroy(_resource, _params, _authorizer)
+      raise NotImplemented
+    end
+  end
+end

data/lib/paginators/wallaby/model_paginator.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model paginator to provide support for pagination on index page
+  class ModelPaginator
+    extend Baseable::ClassMethods
+
+    class << self
+      # @!attribute [w] model_class
+      attr_writer :model_class
+
+      # @!attribute [r] model_class
+      # Return associated model class, e.g. return **Product** for **ProductPaginator**.
+      #
+      # If Wallaby can't recognise the model class for Paginator, it's required to be configured as below example:
+      # @example To configure model class
+      #   class Admin::ProductPaginator < Admin::ApplicationPaginator
+      #     self.model_class = Product
+      #   end
+      # @example To configure model class for version below 5.2.0
+      #   class Admin::ProductPaginator < Admin::ApplicationPaginator
+      #     def self.model_class
+      #       Product
+      #     end
+      #   end
+      # @return [Class] assoicated model class
+      # @return [nil] if current class is marked as base class
+      # @return [nil] if current class is the same as the value of {Wallaby::Configuration::Mapping#model_paginator}
+      # @return [nil] if current class is {Wallaby::ModelPaginator}
+      # @return [nil] if assoicated model class is not found
+      def model_class
+        return unless self < ModelPaginator
+        return if base_class? || self == Wallaby.configuration.mapping.model_paginator
+
+        @model_class ||= Map.model_class_map(name.gsub(/(^#{namespace}::)|(Paginator$)/, EMPTY_STRING))
+      end
+
+      # @!attribute provider_class
+      # @return [Class] pagination provider class
+      # @since 5.2.0
+      attr_accessor :provider_class
+    end
+
+    # @!attribute [r] model_class
+    # @return [Class]
+    attr_reader :model_class
+
+    # @!attribute [r] provider
+    # @return [Wallaby::ModelServiceProvider]
+    # @since 5.2.0
+    attr_reader :provider
+
+    # During initialization, Wallaby will assign a pagination provider for this paginator
+    # to carry out the actual execution.
+    #
+    # Therefore, all its actions can be completely replaced by user's own implemnetation.
+    # @param model_class [Class]
+    # @param collection [#to_a] a collection of the resources
+    # @param params [ActionController::Parameters]
+    def initialize(model_class, collection, params)
+      @model_class = self.class.model_class || model_class
+      raise ArgumentError, I18n.t('errors.required', subject: 'model_class') unless @model_class
+
+      @collection = collection
+      @params = params
+      @provider = Map.pagination_provider_map(@model_class).new(@collection, @params)
+    end
+
+    delegate(*ModelPaginationProvider.instance_methods(false), to: :provider)
+    # @!method paginatable?
+    #   (see Wallaby::ModelPaginationProvider#paginatable?)
+
+    # @!method first_page?
+    #   (see Wallaby::ModelPaginationProvider#first_page?)
+
+    # @!method prev_page?
+    #   (see Wallaby::ModelPaginationProvider#prev_page?)
+
+    # @!method last_page?
+    #   (see Wallaby::ModelPaginationProvider#last_page?)
+
+    # @!method next_page?
+    #   (see Wallaby::ModelPaginationProvider#next_page?)
+
+    # @!method from
+    #   (see Wallaby::ModelPaginationProvider#from)
+
+    # @!method to
+    #   (see Wallaby::ModelPaginationProvider#to)
+
+    # @!method total
+    #   (see Wallaby::ModelPaginationProvider#total)
+
+    # @!method page_size
+    #   (see Wallaby::ModelPaginationProvider#page_size)
+
+    # @!method page_number
+    #   (see Wallaby::ModelPaginationProvider#page_number)
+
+    # @!method first_page_number
+    #   (see Wallaby::ModelPaginationProvider#first_page_number)
+
+    # @!method last_page_number
+    #   (see Wallaby::ModelPaginationProvider#last_page_number)
+
+    # @!method prev_page_number
+    #   (see Wallaby::ModelPaginationProvider#prev_page_number)
+
+    # @!method next_page_number
+    #   (see Wallaby::ModelPaginationProvider#next_page_number)
+
+    # @!method number_of_pages
+    #   (see Wallaby::ModelPaginationProvider#number_of_pages)
+  end
+end

data/lib/paginators/wallaby/resource_paginator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resource paginator
+  class ResourcePaginator < ModelPaginator
+    base_class!
+
+    def self.inherited(_sub_class)
+      Utils.deprecate 'deprecation.resource_paginator_inheirtance', caller: caller
+    end
+  end
+end

data/lib/parsers/wallaby/parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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/renderers/wallaby/cell.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # In order to improve the rendering performance, cell is designed as simple partial component.
+  # @since 5.2.0
+  class Cell
+    # @!attribute [r] context
+    # @return [Object] view context
+    attr_reader :context
+
+    # @!attribute [r] local_assigns
+    # @return [Hash] a list of local_assigns containing {#object}, {#field_name}, {#value}, {#metadata} and {#form}
+    attr_reader :local_assigns
+
+    # @!attribute [r] buffer
+    # @return [String] output string buffer
+    attr_reader :buffer
+
+    delegate(*ERB::Util.singleton_methods, to: ERB::Util)
+
+    # @param context [ActionView::Context] view context
+    # @param local_assigns [Hash] local variables
+    def initialize(context, local_assigns)
+      @context = context
+      @local_assigns = local_assigns
+    end
+
+    # @!attribute [r] object
+    # @return [Object] object
+    def object
+      local_assigns[:object]
+    end
+
+    # @!attribute [w] object
+    def object=(object)
+      local_assigns[:object] = object
+    end
+
+    # @!attribute [r] field_name
+    # @return [String] field name
+    def field_name
+      local_assigns[:field_name]
+    end
+
+    # @!attribute [w] field_name
+    def field_name=(field_name)
+      local_assigns[:field_name] = field_name
+    end
+
+    # @!attribute [r] value
+    # @return [String] value
+    def value
+      local_assigns[:value]
+    end
+
+    # @!attribute [w] value
+    def value=(value)
+      local_assigns[:value] = value
+    end
+
+    # @!attribute [r] metadata
+    # @return [String] metadata
+    def metadata
+      local_assigns[:metadata]
+    end
+
+    # @!attribute [w] metadata
+    def metadata=(metadata)
+      local_assigns[:metadata] = metadata
+    end
+
+    # @!attribute [r] form
+    # @return [ActionView::Helpers::FormBuilder] form object
+    def form
+      local_assigns[:form]
+    end
+
+    # @!attribute [w] form
+    def form=(form)
+      local_assigns[:form] = form
+    end
+
+    # @note this is a template method that can be overridden by subclasses
+    # Produce output for this cell component.
+    #
+    # Please note that the output doesn't include the buffer produced by {#concat}.
+    # Therefore, use {#render_complete} method instead when the cell is rendered.
+    def render; end
+
+    # This method produces the complete rendered string including the buffer produced by {#concat}.
+    # @return [String] output of the cell
+    def render_complete(&block)
+      @buffer = EMPTY_STRING.dup # reset buffer before rendering
+      last_part = render(&block)
+      @buffer << last_part.to_s
+    end
+
+    # Append string to output buffer
+    # @param string [String] string to concat
+    def concat(string)
+      (@buffer ||= EMPTY_STRING.dup) << string
+    end
+
+    # @overload at(name)
+    #   Get view instance variable value
+    #   @example To get view instance variable value
+    #     at('name') # => get value of `@name` from the view
+    #   @param name [String, Symbol] view instance variable name without `@`
+    # @overload at(name, value)
+    #   Set view instance variable value
+    #   @example To set view instance variable value
+    #     at('name', value) # => set value of `@name` in the view
+    #   @param name [String, Symbol] view instance variable name without `@`
+    #   @param value [object] value
+    # @return [object] view instance variable value
+    def at(*args)
+      raise ArgumentError unless args.length.in? [1, 2]
+      return context.instance_variable_get :"@#{args.first}" if args.length == 1
+
+      context.instance_variable_set :"@#{args.first}", args.last
+    end
+
+    private
+
+    # Delegate missing method to {#context}
+    def method_missing(method_id, *args, &block)
+      return super unless context.respond_to? method_id
+
+      context.public_send method_id, *args, &block
+    end
+
+    # Delegate missing method check to {#context}
+    def respond_to_missing?(method_id, _include_private)
+      context.respond_to?(method_id) || super
+    end
+  end
+end