wallaby 5.1.8 → 6.0.1

data/lib/services/wallaby/map/mode_mapper.rb

@@ -1,21 +0,0 @@
-module Wallaby
-  class Map
-    # To map model class to mode class so that we know how to handle a model
-    class ModeMapper
-      # @param model_class [Class] model class
-      def initialize(mode_classes)
-        @mode_classes = mode_classes
-      end
-
-      # @return [Hash] { model_class => mode }
-      def map
-        return {} if @mode_classes.blank?
-        @mode_classes.each_with_object({}) do |mode_class, map|
-          mode_class.model_finder.new.all.each do |model_class|
-            map[model_class] = mode_class
-          end
-        end
-      end
-    end
-  end
-end

data/lib/services/wallaby/map/model_class_collector.rb

@@ -1,48 +0,0 @@
-module Wallaby
-  class Map
-    # To collect model classes that are configured to be handled by Wallaby
-    class ModelClassCollector
-      # @param configuration [Configuration]
-      def initialize(configuration)
-        @configuration = configuration
-      end
-
-      # @return [Array<Class>] model class
-      def collect
-        return all_models - excluded_models if configured_models.blank?
-        invalid_models_check
-        configured_models
-      end
-
-      private
-
-      # Check if the models are valid, raise if invalid
-      def invalid_models_check
-        invalid_models = configured_models - all_models
-        return if invalid_models.blank?
-        message = "#{invalid_models.to_sentence} are invalid models."
-        raise InvalidError, message
-      end
-
-      # @return [Wallaby::Configuration::Models]
-      def models
-        @configuration.models
-      end
-
-      # @return [Array<Class>] all the models that modes recognize
-      def all_models
-        Map.mode_map.keys
-      end
-
-      # @return [Array<Class>] a list of models to exclude
-      def excluded_models
-        models.excludes
-      end
-
-      # @return [Array<Class>] a list of models to set
-      def configured_models
-        models.presence
-      end
-    end
-  end
-end

data/lib/services/wallaby/map/model_class_mapper.rb

@@ -1,38 +0,0 @@
-module Wallaby
-  class Map
-    # @private
-    # To find out all descendant classes and convert them if necessary.
-    class ModelClassMapper
-      def initialize(base_class)
-        @base_class = base_class
-      end
-
-      # @return [Array] a list of non-anonymous descendant classes
-      def map
-        classes_array.each_with_object({}) do |klass, map|
-          next if anonymous? klass
-          begin
-            map[klass.model_class] = block_given? ? yield(klass) : klass
-          rescue Wallaby::ModelNotFound
-            Rails.logger.error Utils.translate_class(
-              self, :missing_model_class, model: klass.name
-            )
-          end
-        end
-      end
-
-      protected
-
-      # @param klass [Class]
-      # @return [Boolean] whether the class is anonymous
-      def anonymous?(klass)
-        Utils.anonymous_class? klass
-      end
-
-      # @return [Array<Class>] all descendants
-      def classes_array
-        @base_class.try(:descendants) || EMPTY_ARRAY
-      end
-    end
-  end
-end

data/lib/services/wallaby/partial_renderer.rb

@@ -1,67 +0,0 @@
-module Wallaby
-  # @private
-  # Partial renderer
-  class PartialRenderer
-    class << self
-      # Render form partial
-      # @param view [ActionView] view
-      # @param options [String] partial name
-      # @param locals [Hash]
-      # @return [String] HTML
-      def render(view, options = {}, locals = {}, action_name = nil, &block)
-        decorated = locals[:object]
-        field_name = locals[:field_name].to_s
-        action_name ||= Utils.to_partial_name view.params[:action]
-
-        partial_arguments_check decorated, field_name
-
-        locals[:metadata] =
-          decorated.public_send :"#{action_name}_metadata_of", field_name
-        locals[:value] = decorated.public_send field_name
-
-        view.render(options, locals, &block) \
-          || view.render('string', locals, &block)
-      end
-
-      # Render form partial
-      # @param view [ActionView] view
-      # @param options [String] partial name
-      # @param locals [Hash]
-      # @return [String] HTML
-      def render_form(view, options = {}, locals = {}, &block)
-        form = locals[:form]
-        field_name = locals[:field_name].to_s
-
-        form_arguments_check form, field_name
-
-        decorated = locals[:object] = form.object
-        locals[:metadata] = decorated.form_metadata_of locals[:field_name]
-        locals[:value] = decorated.public_send locals[:field_name]
-
-        view.render(options, locals, &block) \
-          || view.render('string', locals, &block)
-      end
-
-      private
-
-      # Check and see if object and field_name are valid
-      # @param object [Object]
-      # @param field_name [String]
-      def partial_arguments_check(object, field_name)
-        raise ArgumentError, 'Field name is required.' if field_name.blank?
-        raise ArgumentError, 'Object is not decorated.' \
-          unless object.is_a? ResourceDecorator
-      end
-
-      # Check and see if form and field_name are valid
-      # @param form [Object]
-      # @param field_name [String]
-      def form_arguments_check(form, field_name)
-        raise ArgumentError, 'Form is required.' if form.blank?
-        raise ArgumentError, 'Field name is required.' if field_name.blank?
-        raise ArgumentError, 'Object is not decorated.' \
-          unless form.object.is_a? ResourceDecorator
-      end
-    end
-  end
-end

data/lib/services/wallaby/prefixes_builder.rb

@@ -1,72 +0,0 @@
-module Wallaby
-  # @private
-  # Prefix builder
-  class PrefixesBuilder
-    # @param origin_prefixes [Array<string>] a list of all the prefixes
-    # @param controller_path [String] controller path
-    # @param resources_name [String] resources name
-    # @param params [ActionController::Parameters]
-    def initialize(origin_prefixes, controller_path, resources_name, params)
-      @origin_prefixes = origin_prefixes
-      @controller_path = controller_path
-      @resources_name = resources_name
-      @params = params
-    end
-
-    # @return [Array<String>] a list of all the prefixes
-    def build
-      prefixes = minimal_prefixes
-      prefixes.unshift mounted_prefix if resource_path != @controller_path
-      suffix = build_suffix(@params)
-      prefixes.each_with_object([]) do |prefix, result|
-        result << "#{prefix}/#{suffix}" << prefix if prefix
-      end
-    end
-
-    protected
-
-    # @return [Array<String>] a list of prefixes starting from wallaby
-    def minimal_prefixes
-      # this should contains only the current controller's path and wallaby path
-      index = @origin_prefixes.index wallaby_path
-      @origin_prefixes.slice 0..index
-    end
-
-    # @return [String] a prefix of the mouted path.
-    #   Given mounted path `admin`, and current resources `products`, it returns
-    #   `admin/products`
-    def mounted_prefix
-      prefix = mounted_path.try(:slice, 1..-1) || ''
-      prefix << SLASH unless prefix.empty?
-      prefix << resource_path if resource_path
-    end
-
-    # Consolidate action name (new/create/edit/update) as `form`
-    # @param params [ActionController::Parameters]
-    # @return [String]
-    def build_suffix(params)
-      Utils.to_partial_name params[:action]
-    end
-
-    # @return [String] path of `wallaby/resources`
-    def wallaby_path
-      ResourcesController.controller_path
-    end
-
-    # @return [String] the path that Wallaby has mounted to
-    def mounted_path
-      # TODO: need to find out if this will fail
-      # when wallaby is mounted more than once on different namespace?
-      Rails.application.routes.named_routes[:wallaby_engine].try do |route|
-        route.path.spec.to_s
-      end
-    end
-
-    # Convert the resources name
-    # (e.g. `namespace::products` to `namespace/products`)
-    # @return [String] a path of the resources
-    def resource_path
-      @resource_path ||= @resources_name.try :gsub, COLONS, SLASH
-    end
-  end
-end

data/lib/services/wallaby/sorting/hash_builder.rb

@@ -1,22 +0,0 @@
-module Wallaby
-  module Sorting
-    # @private
-    # Turn a string e.g.`'name asc,id desc'` into sort
-    # hash e.g.`{name: 'asc', id: 'desc'}`
-    class HashBuilder
-      SORT_REGEX = /(([^\s,]+)\s+(asc|desc))\s*,?\s*/i
-
-      # Turn a string e.g.`'name asc,id desc'` into sort
-      # hash e.g.`{name: 'asc', id: 'desc'}`
-      # @param sort_string [String]
-      # @return [Hash] { field_name => 'asc|desc' }
-      def self.build(sort_string)
-        ::ActiveSupport::HashWithIndifferentAccess.new.tap do |hash|
-          (sort_string || EMPTY_STRING).scan SORT_REGEX do |_, key, order|
-            hash[key] = order
-          end
-        end
-      end
-    end
-  end
-end

data/lib/services/wallaby/sorting/link_builder.rb

@@ -1,50 +0,0 @@
-module Wallaby
-  module Sorting
-    # @private
-    # Build the sorting link
-    class LinkBuilder
-      delegate :model_class, to: :@model_decorator
-
-      # @param model_decorator [Wallaby::ModelDecorator]
-      # @param params [ActionController::Parameters]
-      # @param helper [ActionView::Helpers]
-      def initialize(model_decorator, params, helper)
-        @model_decorator = model_decorator
-        @params = params
-        @helper = helper
-      end
-
-      # To turn sort string into a hash for later usage
-      # @return [Hash]
-      def current_sort
-        @current_sort ||= HashBuilder.build @params[:sort]
-      end
-
-      # Build sort link for given field name
-      # @param field_name [String]
-      # @return [String] link
-      def build(field_name)
-        metadata = @model_decorator.index_metadata_of field_name
-        label = Utils.to_field_label field_name, metadata
-        return label unless sortable? field_name, metadata
-        sort_field_name = metadata[:sort_field_name] || field_name
-        url_params = next_builder.next_params sort_field_name
-        @helper.index_link(model_class, url_params: url_params) { label }
-      end
-
-      private
-
-      # @see Wallaby::Sorting::NextBuilder
-      def next_builder
-        @next_builder ||= NextBuilder.new @params, current_sort
-      end
-
-      # @return [Boolean]
-      #   whether it's non-association field or custom sorting field
-      def sortable?(field_name, metadata)
-        @model_decorator.fields[field_name] && !metadata[:is_association] \
-          || metadata[:sort_field_name]
-      end
-    end
-  end
-end

data/lib/services/wallaby/sorting/next_builder.rb

@@ -1,75 +0,0 @@
-module Wallaby
-  module Sorting
-    # @private
-    # Pass field_name to generate sort param for its next sort order
-    # (e.g. from empty to `asc`, from `asc` to `desc`, from `desc` to empty)
-    class NextBuilder
-      ASC = 'asc'.freeze
-      DESC = 'desc'.freeze
-
-      # @param params [ActionController::Parameters]
-      # @param hash [Hash, nil] sorting hash
-      def initialize(params, hash = nil)
-        @params = params
-        @hash = hash || HashBuilder.build(params[:sort])
-      end
-
-      # Update the `sort` parameter.
-      # @example for param `{sort: 'name asc'}`, it will update the parameters
-      #   to `{sort: 'name desc'}`
-      # @param field_name [String] field name
-      # @return [ActionController::Parameters]
-      #   updated parameters that update the sort order for given field
-      def next_params(field_name)
-        params = clean_params
-        update params, :sort, complete_sorting_str_with(field_name)
-        params
-      end
-
-      protected
-
-      # @return [ActionController::Parameters] whitelisted parameters
-      def clean_params
-        @params.except :resources, :controller, :action
-      end
-
-      # @param field_name [String] field name
-      # @return [String] a sort order string, e.g. `'name asc'`
-      def complete_sorting_str_with(field_name)
-        hash = @hash.except field_name
-        current_sort = @hash[field_name]
-
-        update hash, field_name, next_value_for(current_sort)
-        rebuild_str_from hash
-      end
-
-      # @param hash [Hash] sort order hash
-      # @return [String] a sort order string, e.g. `'name asc'`
-      def rebuild_str_from(hash)
-        hash.each_with_object('') do |(name, sort), str|
-          str << (str == EMPTY_STRING ? str : COMMA)
-          str << name << SPACE << sort
-        end
-      end
-
-      # @param current [String, nil] current sort order
-      # @return [String, nil] next state of sort order
-      def next_value_for(current)
-        case current
-        when ASC then DESC
-        when DESC then nil
-        else ASC
-        end
-      end
-
-      # Update the value for given key. Remove the key if value is blank
-      # @param hash [Hash] sort order hash
-      # @param key [String] key name
-      # @param value [Object, nil] value
-      def update(hash, key, value)
-        return hash.delete key if value.blank?
-        hash[key] = value
-      end
-    end
-  end
-end

data/lib/services/wallaby/url_for.rb

@@ -1,36 +0,0 @@
-module Wallaby
-  # Url helper
-  class UrlFor
-    class << self
-      # Handle wallaby engine url properly.
-      # @param wallaby_engine [ActionDispatch::Routing::RoutesProxy]
-      # @param options [ActionController::Parameters, Hash]
-      # @return [String] url string for wallaby engine
-      def handle(wallaby_engine, options)
-        # NOTE: DEPRECATION WARNING: You are calling a `*_path` helper with the
-        # `only_path` option explicitly set to `false`.
-        # This option will stop working on path helpers in Rails 5.
-        # Use the corresponding `*_url` helper instead.
-        hash = normalize_params(options).except(:only_path)
-        case hash[:action]
-        when 'index', 'create' then wallaby_engine.resources_path hash
-        when 'new' then wallaby_engine.new_resource_path hash
-        when 'edit' then wallaby_engine.edit_resource_path hash
-        else wallaby_engine.resource_path hash
-        end
-      end
-
-      private
-
-      # We will need to normalize params and return a hash
-      # so that the url helper
-      # could build up the url properly.
-      # @param options [ActionController::Parameters, Hash]
-      # @return [Hash]
-      def normalize_params(options)
-        return options unless options.is_a? ActionController::Parameters
-        options.permit(:resources, :action, :id).to_h
-      end
-    end
-  end
-end

data/lib/tree/wallaby/node.rb

@@ -1,19 +0,0 @@
-module Wallaby
-  # Node to present tree structure
-  class Node
-    attr_reader :klass
-    attr_accessor :parent
-
-    delegate :name, to: :klass
-
-    # @param klass [Class]
-    def initialize(klass)
-      @klass = klass
-    end
-
-    # @return [Array<Class>] a list of children classes
-    def children
-      @children ||= []
-    end
-  end
-end