wallaby 5.1.8 → 6.0.1

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

@@ -1,77 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelServiceProvider
-      class Querier
-        # @private
-        # Build up query using the results
-        class Transformer < Parslet::Transform
-          SIMPLE_OPERATORS = {
-            ':' => :eq,
-            ':=' => :eq,
-            ':!' => :not_eq,
-            ':!=' => :not_eq,
-            ':<>' => :not_eq,
-            ':~' => :matches,
-            ':^' => :matches,
-            ':$' => :matches,
-            ':!~' => :does_not_match,
-            ':!^' => :does_not_match,
-            ':!$' => :does_not_match,
-            ':>' => :gt,
-            ':>=' => :gteq,
-            ':<' => :lt,
-            ':<=' => :lteq
-          }.freeze
-
-          SEQUENCE_OPERATORS = {
-            ':' => :in,
-            ':=' => :in,
-            ':!' => :not_in,
-            ':!=' => :not_in,
-            ':<>' => :not_in,
-            ':()' => :between,
-            ':!()' => :not_between
-          }.freeze
-
-          # For single keyword
-          rule keyword: simple(:value) do
-            value.try :to_str
-          end
-
-          # For multiple keywords
-          rule keyword: sequence(:value) do
-            value.presence.try :map, :to_str
-          end
-
-          # For operators
-          rule left: simple(:left), op: simple(:op), right: simple(:right) do
-            oped = op.try :to_str
-            operator = SIMPLE_OPERATORS[oped]
-            # skip if the operator is unknown
-            next unless operator
-            lefted = left.try :to_str
-            convert =
-              case oped
-              when ':~', ':!~' then "%#{right}%"
-              when ':^', ':!^' then "#{right}%"
-              when ':$', ':!$' then "%#{right}"
-              end
-            { left: lefted, op: operator, right: convert || right }
-          end
-
-          # For operators that have multiple items
-          rule left: simple(:left), op: simple(:op), right: sequence(:right) do
-            oped = op.try :to_str
-            operator = SEQUENCE_OPERATORS[oped]
-            next unless operator
-            lefted = left.try :to_str
-            convert = if %w(:() :!()).include?(oped)
-                        Range.new right.try(:first), right.try(:last)
-                      end
-            { left: lefted, op: operator, right: convert || right }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Wallaby
-  class ActiveRecord
-    class ModelServiceProvider
-      # @private
-      # Validator
-      class Validator
-        # @param model_decorator [Wallaby::ModelDecorator]
-        def initialize(model_decorator)
-          @model_decorator = model_decorator
-        end
-
-        # @param resource [Object] resource object
-        # @return [Boolean] whether the resource object is valid
-        def valid?(resource)
-          resource.attributes.each do |field_name, values|
-            metadata = @model_decorator.fields[field_name]
-            next if valid_range_type? values, metadata
-            resource.errors.add field_name, 'required for range data'
-          end
-          resource.errors.blank?
-        end
-
-        private
-
-        # @param values [Array]
-        # @return [Boolean] whether the values are valid range values
-        def valid_range_type?(values, metadata)
-          !metadata \
-            || !%w(daterange tsrange tstzrange).include?(metadata[:type]) \
-            || !values.try(:any?, &:blank?)
-        end
-      end
-    end
-  end
-end

data/lib/concerns/wallaby/resources_helper_methods.rb

@@ -1,44 +0,0 @@
-module Wallaby
-  # This is a collection of the helper methods used in controller and helper
-  module ResourcesHelperMethods
-    extend ActiveSupport::Concern
-
-    protected
-
-    # Shorthand of params[:id]
-    # @return [String, nil] ID param
-    def resource_id
-      params[:id]
-    end
-
-    # @return [#each] a collection of all the records
-    def collection
-      @collection ||= paginate current_model_service.collection params
-    end
-
-    # @return [Object] either persisted or unpersisted resource instance
-    def resource
-      @resource ||= begin
-        # white-listed params
-        whitelisted = action_name.in?(SAVE_ACTIONS) ? resource_params : {}
-        if resource_id.present?
-          current_model_service.find resource_id, whitelisted
-        else
-          current_model_service.new whitelisted
-        end
-      end
-    end
-
-    # @return [Wallaby::ModelDecorator, nil] current model decorator
-    def current_model_decorator
-      @current_model_decorator ||= helpers.model_decorator current_model_class
-    end
-
-    # A wrapper method for authorizer
-    # @todo to add support to pundit in the future
-    # @return [Ability]
-    def authorizer
-      current_ability
-    end
-  end
-end

data/lib/decorators/wallaby/abstract_resource_decorator.rb

@@ -1,79 +0,0 @@
-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.configuration.mapping.resource_decorator
-        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.configuration.mapping.resource_decorator
-        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
-
-    # @param resource [Object] resource object
-    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
-    # @param method_id [String,Symbol]
-    # @param args [Array]
-    def method_missing(method_id, *args)
-      return super unless @resource.respond_to? method_id
-      @resource.public_send method_id, *args
-    end
-
-    # @param method_id [String,Symbol]
-    # @param _include_private [Boolean]
-    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,7 +0,0 @@
-module Wallaby
-  # Resource Decorator
-  # @see Wallaby::AbstractResourceDecorator
-  # @overwritable
-  class ResourceDecorator < AbstractResourceDecorator
-  end
-end

data/lib/errors/wallaby/general_error.rb

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

data/lib/errors/wallaby/invalid_error.rb

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

data/lib/errors/wallaby/model_not_found.rb

@@ -1,9 +0,0 @@
-module Wallaby
-  # Model not found error
-  class ModelNotFound < NotFound
-    # @return [String] not found error message
-    def message
-      I18n.t 'errors.not_found.model', model: super
-    end
-  end
-end

data/lib/errors/wallaby/not_authenticated.rb

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

data/lib/errors/wallaby/not_found.rb

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

data/lib/errors/wallaby/not_implemented.rb

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

data/lib/errors/wallaby/resource_not_found.rb

@@ -1,9 +0,0 @@
-module Wallaby
-  # Resource not found error
-  class ResourceNotFound < NotFound
-    # @return [String] resource not found error message
-    def message
-      I18n.t 'errors.not_found.resource', resource: super
-    end
-  end
-end

data/lib/errors/wallaby/unprocessable_entity.rb

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

data/lib/forms/wallaby/form_builder.rb

@@ -1,55 +0,0 @@
-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
-
-    # 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: 'errors' do
-        errors.each do |message|
-          concat content_tag :li, content_tag(:small, raw(message))
-        end
-      end
-    end
-
-    # Extend label to accept proc type `text` argument
-    # @see ActionView::Helpers::FormBuilder#label
-    def label(method, text = nil, options = {}, &block)
-      text = instance_exec(&text) if text.is_a?(Proc)
-      super
-    end
-
-    # Extend select to accept proc type `choices` argument
-    # @see ActionView::Helpers::FormBuilder#select
-    def select(method, choices = nil, options = {}, html_options = {}, &block)
-      choices = instance_exec(&choices) if choices.is_a?(Proc)
-      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
-      # when same method is called
-      self.class.delegate method, to: :@template
-      @template.public_send method, *args, &block
-    end
-
-    # 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,49 +0,0 @@
-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 when options contains
-    # values of both `:resources` and `:action`
-    # @param options [String, Hash]
-    # @return [String] url
-    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
-
-    # Add turbolinks options when it's enabled
-    # @see ActionView::Helpers::AssetTagHelper#stylesheet_link_tag
-    # @param sources [Array<String>] source name under `app/assets/stylesheets`
-    # @return [String] a list of stylesheet link tags
-    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
-
-    # Add turbolinks options when it's enabled
-    # @see ActionView::Helpers::AssetTagHelper#javascript_include_tag
-    # @param sources [Array<String>] source name under `app/assets/javascripts`
-    # @return [String] a list of javascript script tags
-    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

@@ -1,60 +0,0 @@
-module Wallaby
-  # NOTE: Global helper methods should go in here
-  module BaseHelper
-    include StylingHelper
-    include LinksHelper
-
-    # @see Utils.to_model_label
-    # @return [String] label for given model class
-    def to_model_label(model_class)
-      Utils.to_model_label model_class
-    end
-
-    # @see Map.resources_name_map
-    # @return [String] resources name for given model class
-    def to_resources_name(model_class)
-      Map.resources_name_map model_class
-    end
-
-    # Generate body class from the following sources:
-    # - `:action` parameter
-    # - converted current resources name (e.g. `order__item` from `Order::Item`)
-    # - `:custom_body_class` content
-    # @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 by inheritance.
-    # @param classes [Array<Class>]
-    #   a list of all the classes that wallaby supports
-    # @return [Array<Wallaby::Node>] 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
-
-    # Turn the tree of classes into a nested `ul` list.
-    # @param array [Array<Wallaby::Node>] 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