wallaby-core 0.1.0

data/lib/renderers/wallaby/cell_resolver.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resolver to provide support for cell and partial
+  # @since 5.2.0
+  class CellResolver < ActionView::OptimizedFileSystemResolver
+    # for Rails 5.2 and below
+    begin
+      # @note this method is only applicable to Rails 5.2 and below
+      # A cell query looks like:
+      #
+      # ```
+      # app/views/wallaby/resources/index/integer{_en,}{_html,}.rb
+      # ```
+      #
+      # Wallaby adds it to the front of the whole query as below:
+      #
+      # ```
+      # {app/views/wallaby/resources/index/integer{_en,}{_html,}.rb,
+      # app/views/wallaby/resources/index/_integer{.en,}{.html,}{.erb,}}
+      # ```
+      # @param path [String]
+      # @param details [Hash]
+      #   see {https://api.rubyonrails.org/classes/ActionView/LookupContext/ViewPaths.html#method-i-detail_args_for
+      #   Detials from ViewPaths}
+      # @return [String] a path query
+      def build_query(path, details)
+        # NOTE: super is impacted by {#escape_entry}
+        origin = super
+        file_name = origin[%r{(?<=/\{,_\})[^/\{]+}]
+        return origin unless file_name
+
+        base_dir = origin.gsub(%r{/[^/]*$}, '')
+        locales = convert details[:locale]
+        formats = convert details[:formats]
+        cell = "#{base_dir}/#{file_name}{#{locales}}{#{formats}}.rb"
+        "{#{cell},#{origin}}"
+      end
+    end
+
+    # for Rails 6 and above
+    begin
+      # @note this method is only applicable to Rails 6 and above
+      # This is to extend the origin functionality to enable to return cell file.
+      # at highest precedence.
+      # @param path [String]
+      # @param details [Hash]
+      # @return [ActionView::Template] found template
+      def find_template_paths_from_details(path, details)
+        details[:handlers].unshift(:rb) if details[:handlers].try(:first) != :rb
+        super
+      end
+
+      # @note this method is only applicable to Rails 6 and above
+      # This is to extend the origin functionality to enable to query cell files.
+      # @param path [String]
+      # @param details [Hash]
+      # @return [Regexp]
+      def build_regex(path, details)
+        origin = super.source
+        Regexp.new(
+          origin
+            .gsub(%r{/\{,_\}([^/]+)\z}, '/_?\\1')
+            .gsub('\\.', '[_\\.]')
+            .gsub('raw|', 'rb|raw|')
+        )
+      end
+    end
+
+    # This is to extend the origin funcationality to enable the query
+    # to look for cell files
+    # @example extend the query
+    #   escape_entry('integer') # => '/{,_}integer'
+    # @param entry [String]
+    # @return [String] an escaped and extended query
+    def escape_entry(entry)
+      super.gsub(%r{/_([^/]+)\z}, '/{,_}\1')
+    end
+
+    private
+
+    # @example concat a list of values into a string
+    #   convert(['html', 'csv']) # => '_html,_cvs,'
+    # @param values [Array<String>]
+    def convert(values)
+      (values.map { |v| "_#{v}" } << '').join ','
+    end
+  end
+end

data/lib/renderers/wallaby/custom_lookup_context.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # A custom lookup context that uses {Wallaby::CellResolver} to find cell/partial
+  class CustomLookupContext < ::ActionView::LookupContext
+    def self.normalize(lookup, details: nil, prefixes: nil)
+      return lookup if lookup.is_a? self
+
+      CustomLookupContext.new(
+        lookup.view_paths,
+        details || lookup.instance_variable_get('@details'),
+        prefixes || lookup.prefixes
+      )
+    end
+
+    # @note for Rails 6 and above
+    # It overrides the origin method to convert paths to {Wallaby::CellResolver}
+    # @param paths [Array]
+    # @return [ActionView::PathSet]
+    def build_view_paths(paths)
+      ActionView::PathSet.new Array(paths).map(&method(:convert))
+    end
+
+    # @note for Rails 5.2 and below
+    # It overrides the origin method to convert paths to {Wallaby::CellResolver}
+    # @param paths [Array]
+    # @return [ActionView::PathSet]
+    def view_paths=(paths)
+      @view_paths = build_view_paths paths
+    end
+
+    # It overrides the oirgin method to call the origin `find_template` and cache the result during a request.
+    # @param name [String]
+    # @param prefixes [Array<String>]
+    # @param partial [Boolean]
+    # @param keys [Array<String>] keys of local variables
+    # @param options [Hash]
+    def find_template(name, prefixes = [], partial = false, keys = [], options = {})
+      prefixes = [] if partial && name.include?(SLASH) # reset the prefixes if `/` is detected
+      key = [name, prefixes, partial, keys, options].map(&:inspect).join(SLASH)
+      cached_lookup[key] ||= super
+    end
+
+    protected
+
+    # @!attribute [r] cached_lookup
+    # Cached lookup result
+    def cached_lookup
+      @cached_lookup ||= {}
+    end
+
+    # Convert path to {Wallaby::CellResolver}
+    # @param path [Object]
+    # @return [Wallaby::CellResolver]
+    def convert(path)
+      case path
+      when ActionView::OptimizedFileSystemResolver, Pathname, String
+        CellResolver.new path.to_s
+      else
+        path
+      end
+    end
+  end
+end

data/lib/renderers/wallaby/custom_partial_renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Custom partial renderer to provide support for cell rendering
+  class CustomPartialRenderer < ::ActionView::PartialRenderer
+    # When a type partial is found, it works as usual.
+    #
+    # But when a cell is found, there is an exception {Wallaby::CellHandling} raised. This error will be captured,
+    # and the cell will be rendered.
+    # @param context [ActionView::Context]
+    # @param options [Hash]
+    # @param block [Proc]
+    # @return [String] HTML output
+    def render(context, options, block)
+      super.try do |rendered|
+        ModuleUtils.try_to(rendered, :body) || # Rails 6 and above
+          rendered # Rails 5.2 and below
+      end
+    rescue CellHandling => e
+      CellUtils.render context, e.message, options[:locals], &block
+    end
+
+    # Override origin method to stop rendering when a cell is found.
+    # @return [ActionView::Template] partial template
+    # @raise [Wallaby:::CellHandling] when a cell is found
+    def find_partial(*)
+      super.tap do |partial|
+        cell = CellUtils.find_cell(partial.identifier, partial.inspect)
+        raise CellHandling, cell if cell
+      end
+    end
+  end
+end

data/lib/renderers/wallaby/custom_renderer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Custom view renderer to provide support for cell rendering
+  class CustomRenderer < ::ActionView::Renderer
+    def initialize(lookup_context)
+      super CustomLookupContext.normalize(lookup_context)
+    end
+
+    # @return [String] HTML output
+    # @see Wallaby::CustomPartialRenderer
+    def render_partial(context, options, &block) #:nodoc:
+      CustomPartialRenderer.new(lookup_context).render(context, options, block)
+    end
+  end
+end

data/lib/responders/wallaby/json_api_responder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Easter egg: simple responder for JSON API
+  class JsonApiResponder < ResourcesResponder
+    delegate :params, :headers, to: :request
+
+    # @see #to_json
+    def to_html
+      to_json
+    end
+
+    # @return [String] JSON
+    def to_json(*)
+      json_options = { content_type: 'application/vnd.api+json', status: options[:status] }
+      if exception?
+        render json_options.merge(json: exception_details)
+      else
+        render json_options.merge(action_options)
+      end
+    end
+
+    protected
+
+    def action_options
+      if !get? && has_errors?
+        { json: resource_errors, status: :unprocessable_entity }
+      elsif index?
+        { json: collection_data }
+      else
+        { json: resource_data }
+      end
+    end
+
+    def single(resource)
+      {
+        id: resource.id,
+        type: params[:resources],
+        attributes: attributes_of(resource)
+      }
+    end
+
+    def collection_data
+      {
+        data: resource.map(&method(:single)),
+        links: {
+          self: controller.url_for(resources: params[:resources], action: 'index')
+        }
+      }
+    end
+
+    def resource_data
+      {
+        data: single(resource),
+        links: {
+          self: controller.url_for(resources: params[:resources], action: 'show', id: resource.id)
+        }
+      }
+    end
+
+    def resource_errors
+      decorated = controller.decorate resource
+      {
+        errors: decorated.errors.each_with_object([]) do |(field, message), json|
+          json.push(
+            status: 422,
+            source: { pointer: "/data/attributes/#{field}" },
+            detail: message
+          )
+        end
+      }
+    end
+
+    def attributes_of(resource)
+      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
+      end
+    end
+
+    def exception_details
+      {
+        errors: [
+          {
+            status: options[:status],
+            detail: resource.try(:message)
+          }
+        ]
+      }
+    end
+
+    def index?
+      params[:action] == 'index'
+    end
+
+    def exception?
+      (resource.nil? || resource.is_a?(Exception)) && options[:template] == ERROR_PATH
+    end
+  end
+end

data/lib/responders/wallaby/resources_responder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resources responder
+  class ResourcesResponder < ActionController::Responder
+    include ::Responders::FlashResponder
+
+    # Render CSV with a file name that contains export timestamp.
+    def to_csv
+      controller.headers['Content-Disposition'] = "attachment; filename=\"#{file_name_to_export}\""
+      default_render
+    end
+
+    protected
+
+    # @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}"
+    end
+
+    # @return [Boolean] true if there is exception or resource has errors
+    # @return [Boolean] false otherwise
+    def has_errors? # rubocop:disable Naming/PredicateName
+      resource.nil? || resource.is_a?(Exception) || controller.decorate(resource).errors.present?
+    end
+  end
+end

data/lib/routes/wallaby/resources_router.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # 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 base resources controller which will come from the following sources:
+    #
+    # 1. `:resources_controller` parameter
+    # 2. resources_controller mapping configuration,
+    #   e.g. `Admin::ApplicationController` if defined or `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
+      controller.action(params[:action]).call env
+    rescue ::AbstractController::ActionNotFound, ModelNotFound => e
+      set_message_for e, env
+      default_controller(params).action(:not_found).call env
+    rescue UnprocessableEntity => e
+      set_message_for e, env
+      default_controller(params).action(:unprocessable_entity).call env
+    end
+
+    private
+
+    # Find controller class
+    # @param params [Hash]
+    # @return [Class] controller class
+    def find_controller_by(params)
+      model_class = find_model_class_by params
+      Map.controller_map(model_class, params[:resources_controller]) || default_controller(params)
+    end
+
+    # Default controller class sources from:
+    #
+    # 1. `:resources_controller` parameter
+    # 2. resources_controller mapping configuration,
+    # @param params [Hash]
+    # @return [Class] controller class
+    def default_controller(params)
+      params[:resources_controller] || Wallaby.configuration.mapping.resources_controller
+    end
+
+    # Find out the model class
+    # @param params [Hash]
+    # @return [Class]
+    # @raise [Wallaby::ModelNotFound] when model class is not found
+    # @raise [Wallaby::UnprocessableEntity] when there is no corresponding mode found for model class
+    def find_model_class_by(params)
+      model_class = Map.model_class_map params[:resources]
+      return model_class unless MODEL_ACTIONS.include? params[:action].to_sym
+      raise ModelNotFound, params[:resources] unless model_class
+      unless Map.mode_map[model_class]
+        raise UnprocessableEntity, I18n.t('errors.unprocessable_entity.model', model: model_class)
+      end
+
+      model_class
+    end
+
+    # Set flash error message
+    # @param exception [Exception]
+    # @param env [Hash] @see http://www.rubydoc.info/github/rack/rack/master/file/SPEC
+    def set_message_for(exception, env)
+      session = env[ActionDispatch::Request::Session::ENV_SESSION_KEY] || {}
+      env[ActionDispatch::Flash::KEY] ||= ActionDispatch::Flash::FlashHash.from_session_value session['flash']
+      flash = env[ActionDispatch::Flash::KEY]
+      flash[:alert] = exception.message
+    end
+  end
+end

data/lib/servicers/wallaby/model_servicer.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model servicer contains resourceful operations for Rails resourceful actions.
+  class ModelServicer
+    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 **ProductServicer**.
+      #
+      # If Wallaby can't recognise the model class for Servicer, it's required to be configured as below example:
+      # @example To configure model class
+      #   class Admin::ProductServicer < Admin::ApplicationServicer
+      #     self.model_class = Product
+      #   end
+      # @example To configure model class for version below 5.2.0
+      #   class Admin::ProductServicer < Admin::ApplicationServicer
+      #     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_servicer}
+      # @return [nil] if current class is {Wallaby::ModelServicer}
+      # @return [nil] if assoicated model class is not found
+      def model_class
+        return unless self < ModelServicer
+        return if base_class? || self == Wallaby.configuration.mapping.model_servicer
+
+        @model_class ||= Map.model_class_map(name.gsub(/(^#{namespace}::)|(Servicer$)/, EMPTY_STRING))
+      end
+
+      # @!attribute provider_class
+      # @return [Class] service provider class
+      # @since 5.2.0
+      attr_accessor :provider_class
+    end
+
+    # @!attribute [r] model_class
+    # @return [Class]
+    attr_reader :model_class
+
+    # @!attribute [r] model_decorator
+    # @return [Wallaby::ModelDecorator]
+    # @since 5.2.0
+    attr_reader :model_decorator
+
+    # @!attribute [r] authorizer
+    # @return [Wallaby::ModelAuthorizer]
+    # @since 5.2.0
+    attr_reader :authorizer
+
+    # @!attribute [r] provider
+    # @return [Wallaby::ModelServiceProvider]
+    # @since 5.2.0
+    attr_reader :provider
+
+    # @!method user
+    # @return [Object]
+    # @since 5.2.0
+    delegate :user, to: :authorizer
+
+    # During initialization, Wallaby will assign a service provider for this servicer
+    # to carry out the actual execution.
+    #
+    # Therefore, all its actions can be completely replaced by user's own implemnetation.
+    # @param model_class [Class]
+    # @param authorizer [Wallaby::ModelAuthorizer]
+    # @param model_decorator [Wallaby::ModelDecorator]
+    # @raise [ArgumentError] if param model_class is blank
+    def initialize(model_class, authorizer, model_decorator = nil)
+      @model_class = model_class || self.class.model_class
+      raise ArgumentError, I18n.t('errors.required', subject: 'model_class') unless @model_class
+
+      @model_decorator = model_decorator || Map.model_decorator_map(model_class)
+      @authorizer = authorizer
+      provider_class = self.class.provider_class || Map.service_provider_map(@model_class)
+      @provider = provider_class.new(@model_class, @model_decorator)
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # Whitelist parameters for mass assignment.
+    # @param params [ActionController::Parameters, Hash]
+    # @param action [String, Symbol]
+    # @return [ActionController::Parameters] permitted params
+    def permit(params, action = nil)
+      provider.permit params, action, authorizer
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # Return a collection by querying the datasource (e.g. database, REST API).
+    # @param params [ActionController::Parameters, Hash]
+    # @return [Enumerable] list of records
+    def collection(params)
+      provider.collection params, authorizer
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # Paginate given {#collection}.
+    # @param query [Enumerable]
+    # @param params [ActionController::Parameters]
+    # @return [Enumerable] list of records
+    delegate :paginate, to: :provider
+
+    # @note This is a template method that can be overridden by subclasses.
+    # Initialize an instance of the model class.
+    # @param params [ActionController::Parameters]
+    # @return [Object] initialized object
+    def new(params)
+      provider.new params, authorizer
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To find a record.
+    # @param id [Object]
+    # @param params [ActionController::Parameters]
+    # @return [Object] resource object
+    def find(id, params)
+      provider.find id, params, authorizer
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To create a record.
+    # @param resource [Object]
+    # @param params [ActionController::Parameters]
+    # @return [Object] resource object
+    def create(resource, params)
+      provider.create resource, params, authorizer
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To update a record.
+    # @param resource [Object]
+    # @param params [ActionController::Parameters]
+    # @return [Object] resource object
+    def update(resource, params)
+      provider.update resource, params, authorizer
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To delete a record.
+    # @param resource [Object]
+    # @param params [ActionController::Parameters]
+    # @return [Object] resource object
+    def destroy(resource, params)
+      provider.destroy resource, params, authorizer
+    end
+  end
+end