wallaby 5.1.8 → 6.0.1

data/lib/paginators/wallaby/abstract_resource_paginator.rb

@@ -1,28 +0,0 @@
-module Wallaby
-  # Model paginator
-  class AbstractResourcePaginator
-    # @return [Class] model class for paginator
-    def self.model_class
-      return unless self < ::Wallaby.configuration.mapping.resource_paginator
-      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)
-
-    # Paginator constructor
-    # @param model_class [Class] model class
-    # @param collection [#to_a] a collection of all the resources
-    # @param params [ActionController::Parameters] parameters
-    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

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

data/lib/parsers/wallaby/parser.rb

@@ -1,33 +0,0 @@
-module Wallaby
-  # @private
-  # 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

@@ -1,81 +0,0 @@
-module Wallaby
-  # Abstract responder
-  class AbstractResponder < ActionController::Responder
-    include ::Responders::FlashResponder
-
-    delegate :params, :headers, to: :request
-
-    # @return [String] HTML
-    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
-
-    # @return [String] CSV
-    def to_csv
-      set_layout_to_none
-      headers['Content-Disposition'] = "attachment; filename=\"#{file_name}\""
-      default_render
-    end
-
-    # @return [String] JSON
-    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
-
-    # For create action
-    # - if has errors, render the form again
-    # - else redirect to show page
-    def create_action
-      if has_errors?
-        render :new, options
-      else
-        redirect_to resource_location
-      end
-    end
-
-    # For update action
-    # - if has errors, render the form again
-    # - else redirect to show page
-    def update_action
-      if has_errors?
-        render :edit, options
-      else
-        redirect_to resource_location
-      end
-    end
-
-    # For destroy action
-    # - redirect to show page
-    def destroy_action
-      redirect_to resource_location
-    end
-
-    # @return [String] file name
-    def file_name
-      timestamp = Time.zone.now.to_s(:number)
-      "#{params[:resources]}-exported-#{timestamp}.#{format}"
-    end
-
-    # Set layout to nothing
-    def set_layout_to_none
-      options[:layout] = false
-    end
-
-    # @see FlashResponder
-    def set_flash_message
-      set_flash_message! if set_flash_message?
-    end
-  end
-end

data/lib/responders/wallaby/resources_responder.rb

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

data/lib/routes/wallaby/resources_router.rb

@@ -1,45 +0,0 @@
-module Wallaby
-  # @private
-  # This is the core of wallaby that dynamically dispatches request to
-  # appropriate controller and action.
-  class ResourcesRouter
-    # @see http://edgeguides.rubyonrails.org/routing.html#routing-to-rack-applications
-    # It tries to find out the controller that has the same model class from
-    # converted resources name. Otherwise, it falls back to generic controller
-    # `Wallaby::ResourcesController`.
-    # @param env [Hash] @see http://www.rubydoc.info/github/rack/rack/master/file/SPEC
-    def call(env)
-      params = env[ActionDispatch::Http::Parameters::PARAMETERS_KEY]
-      controller = find_controller_by(params[:resources]) || default_controller
-      params[:action] = find_action_by params
-
-      controller.action(params[:action]).call env
-    rescue ::AbstractController::ActionNotFound, ModelNotFound => e
-      params[:error] = e
-      default_controller.action(:not_found).call env
-    end
-
-    private
-
-    # @param resources_name [String] resource name in plural
-    # @return [Class] controller class
-    def find_controller_by(resources_name)
-      model_class = Map.model_class_map resources_name
-      Map.controller_map model_class
-    end
-
-    # @param params [ActionController::Parameters]
-    # @return [String, Symbol] action name
-    def find_action_by(params)
-      # Action name comes from either the defaults or :action param
-      # @see Wallaby::Engine.routes
-      (params.delete(:defaults) || params)[:action]
-    end
-
-    # TODO: change to reflect the mount path changes
-    # @return [Class] controller class from configuration
-    def default_controller
-      Wallaby.configuration.mapping.resources_controller
-    end
-  end
-end

data/lib/servicers/wallaby/abstract_model_servicer.rb

@@ -1,72 +0,0 @@
-module Wallaby
-  # Abstract model servicer
-  class AbstractModelServicer
-    # @return [Class] model class that comes from its class name
-    def self.model_class
-      return unless self < ::Wallaby.configuration.mapping.model_servicer
-      Map.model_class_map name.gsub('Servicer', EMPTY_STRING)
-    end
-
-    # @param model_class [Class, nil] model class
-    # @param authorizer [Ability]
-    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
-
-    # @param params [ActionController::Parameters]
-    # @return [ActionController::Parameters]
-    def permit(params)
-      @provider.permit params
-    end
-
-    # @param params [ActionController::Parameters]
-    # @return [ActiveRecord::Relation]
-    def collection(params)
-      @provider.collection params, @authorizer
-    end
-
-    # @param query [ActiveRecord::Relation]
-    # @param params [ActionController::Parameters]
-    # @return [ActiveRecord::Relation]
-    def paginate(query, params)
-      @provider.paginate query, params
-    end
-
-    # @param params [ActionController::Parameters]
-    # @return [Object] initialized object
-    def new(params)
-      @provider.new params, @authorizer
-    end
-
-    # @param id [Object]
-    # @param params [ActionController::Parameters]
-    # @return [Object] resource object
-    def find(id, params)
-      @provider.find id, params, @authorizer
-    end
-
-    # @param resource [Object]
-    # @param params [ActionController::Parameters]
-    # @return [Object] resource object
-    def create(resource, params)
-      @provider.create resource, params, @authorizer
-    end
-
-    # @param resource [Object]
-    # @param params [ActionController::Parameters]
-    # @return [Object] resource object
-    def update(resource, params)
-      @provider.update resource, params, @authorizer
-    end
-
-    # @param resource [Object]
-    # @param params [ActionController::Parameters]
-    # @return [Object] resource object
-    def destroy(resource, params)
-      @provider.destroy resource, params, @authorizer
-    end
-  end
-end

data/lib/servicers/wallaby/model_servicer.rb

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

data/lib/services/wallaby/link_options_normalizer.rb

@@ -1,20 +0,0 @@
-module Wallaby
-  # @private
-  # Link renderer
-  class LinkOptionsNormalizer
-    # Normalize options for `link_to` to use
-    # @param html_options [Hash] html options
-    # @param block [Proc] a block
-    # @param defaults [Hash]
-    # @return [Array<Hash, Proc>] html_options and the block
-    def self.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

data/lib/services/wallaby/lookup_context_wrapper.rb

@@ -1,42 +0,0 @@
-module Wallaby
-  # Lookup context wrapper.
-  #
-  # This is to take care of missing template in production.
-  # It will return `string` template
-  # if it doesn't know how to handle the template.
-  # @see Wallaby::PartialRenderer
-  class LookupContextWrapper
-    origin_methods = ::ActionView::LookupContext.instance_methods \
-      - ::Object.instance_methods - %i(find_template)
-    delegate(*origin_methods, to: :@lookup_context)
-
-    # @param lookup_context [ActionView::LookupContext]
-    def initialize(lookup_context)
-      @lookup_context = lookup_context
-    end
-
-    # @see ActionView::LookupContext#find_template
-    # @param args [Array] a list of arguments
-    def find_template(*args)
-      @lookup_context.find_template(*args)
-    rescue ::ActionView::MissingTemplate
-      raise if Rails.env.development?
-      BlankTemplate.new
-    end
-
-    # Blank template to return nil. It should be used by production
-    class BlankTemplate < ::ActionView::Template::HTML
-      def initialize
-        super nil
-      end
-
-      # @param args [Array] a list of arguments
-      # @return [nil]
-      def render(*args); end
-
-      # @param args [Array] a list of arguments
-      # @return [nil]
-      def virtual_path(*args); end
-    end
-  end
-end

data/lib/services/wallaby/map.rb

@@ -1,128 +0,0 @@
-module Wallaby
-  # @private
-  # Global mappings
-  class Map
-    class << self
-      # { model => mode }
-      # @return [Hash] { model => mode }
-      def mode_map
-        @mode_map ||= ModeMapper.new(Mode.descendants).map.freeze
-      end
-
-      # @return [Array] [ model classes ]
-      def model_classes
-        @model_classes ||= ModelClassCollector.new(configuration).collect.freeze
-      end
-
-      # { model => controller }
-      # @param model_class [Class]
-      # @return [Class] controller class
-      #   default to `mapping.resources_controller`
-      def controller_map(model_class)
-        @controller_map ||=
-          ModelClassMapper.new(mapping.resources_controller).map
-        @controller_map[model_class] ||= mapping.resources_controller
-      end
-
-      # { model => model decorator }
-      # @param model_class [Class]
-      # @return [Wallaby::ModelDecorator] model decorator instance
-      def model_decorator_map(model_class)
-        @model_decorator_map ||= {}
-        @model_decorator_map[model_class] ||= begin
-          mode = mode_map[model_class]
-          mode.model_decorator.new model_class if mode # rubocop:disable Style/SafeNavigation, Metrics/LineLength
-        end
-      end
-
-      # { model => resource decorator }
-      # @param model_class [Class]
-      # @return [Class] resource decorator class
-      #   default to `mapping.resource_decorator`
-      def resource_decorator_map(model_class)
-        @resource_decorator_map ||=
-          ModelClassMapper.new(mapping.resource_decorator).map
-        @resource_decorator_map[model_class] ||= begin
-          mapping.resource_decorator if mode_map[model_class]
-        end
-      end
-
-      # { model => servicer }
-      # @param model_class [Class]
-      # @return [Class] resource servicer class
-      #   default to `mapping.resource_servicer`
-      def servicer_map(model_class)
-        @servicer_map ||= ModelClassMapper.new(mapping.model_servicer).map
-        @servicer_map[model_class] ||= begin
-          mapping.model_servicer if mode_map[model_class]
-        end
-      end
-
-      # { model => service_provider }
-      # @param model_class [Class]
-      # @return [Wallaby::ModelServiceProvider] model service provider instance
-      def service_provider_map(model_class)
-        @service_provider_map ||= {}
-        @service_provider_map[model_class] ||= begin
-          mode = mode_map[model_class]
-          mode.model_service_provider.new model_class if mode # rubocop:disable Style/SafeNavigation, Metrics/LineLength
-        end
-      end
-
-      # { model => paginator }
-      # @param model_class [Class]
-      # @return [Hash] { model => paginator }
-      def paginator_map(model_class)
-        @paginator_map ||= ModelClassMapper.new(mapping.resource_paginator).map
-        @paginator_map[model_class] ||= begin
-          mapping.resource_paginator if mode_map[model_class]
-        end
-      end
-
-      # { model => pagination_provider }
-      # @param model_class [Class]
-      # @return [Class] model pagination provider class
-      def pagination_provider_map(model_class)
-        @pagination_provider_map ||= {}
-        @pagination_provider_map[model_class] ||=
-          mode_map[model_class].try(:model_pagination_provider)
-      end
-
-      # { model => resources name }
-      # @param model_class [Class]
-      # @return [String] resources name
-      def resources_name_map(model_class)
-        @resources_name_map ||= {}
-        @resources_name_map[model_class] ||= Utils.to_resources_name model_class
-      end
-
-      # { resources name => model }
-      # @param resources_name [String]
-      # @return [Class] model class
-      def model_class_map(resources_name)
-        @model_class_map ||= {}
-        @model_class_map[resources_name] ||= Utils.to_model_class resources_name
-      end
-
-      # Clear all the class variables to nil
-      def clear
-        @mode_map, @model_classes, @controller_map, @model_decorator_map,
-        @resource_decorator_map, @servicer_map, @service_provider_map,
-        @paginator_map, @pagination_provider_map, @model_class_map,
-        @resources_name_map = []
-      end
-
-      private
-
-      # shorthand method
-      def configuration
-        ::Wallaby.configuration
-      end
-
-      # shorthand method
-      def mapping
-        configuration.mapping
-      end
-    end
-  end
-end