wallaby 5.0.1 → 5.1.3

data/lib/services/wallaby/lookup_context_wrapper.rb

@@ -1,40 +1,33 @@
-class Wallaby::LookupContextWrapper
-  delegate *begin # origin methods
-    ActionView::LookupContext.instance_methods \
-      - Object.instance_methods - %i( find_template )
-  end, to: :@lookup_context
+module Wallaby
+  # Lookup context wrapper.
+  # This is to take care of missing template in production to return string
+  # template.
+  # @see Wallaby::PartialRenderer
+  class LookupContextWrapper
+    origin_methods = ::ActionView::LookupContext.instance_methods \
+      - ::Object.instance_methods - %i(find_template)
+    delegate(*origin_methods, to: :@lookup_context)
 
-  def initialize(lookup_context)
-    @lookup_context = lookup_context
-  end
+    def initialize(lookup_context)
+      @lookup_context = lookup_context
+    end
 
-  def find_template(*args)
-    key = args.join '/'
-    caching key do
-      @lookup_context.find_template *args
+    def find_template(*args)
+      @lookup_context.find_template(*args)
+    rescue ::ActionView::MissingTemplate
+      raise if Rails.env.development?
+      BlankTemplate.new
     end
-  end
 
-  protected
-  def caching(key)
-    @templates ||= {}
-    unless @templates.has_key? key
-      @templates[key] = begin
-        yield
-      rescue ActionView::MissingTemplate
-        raise if Rails.env.development?
-        BlankTemplate.new
+    # Blank template to return nil. It should be used by production
+    class BlankTemplate < ::ActionView::Template::HTML
+      def initialize
+        super nil
       end
-    end
-    @templates[key]
-  end
 
-  class BlankTemplate < ActionView::Template::HTML
-    def initialize
-      super nil
-    end
+      def render(*args); end
 
-    def render(*args)
+      def virtual_path(*args); end
     end
   end
 end

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

@@ -0,0 +1,19 @@
+module Wallaby
+  class Map
+    # To map model class to mode class so that we know how to handle a model
+    class ModeMapper
+      def initialize(mode_classes)
+        @mode_classes = mode_classes
+      end
+
+      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

@@ -0,0 +1,41 @@
+module Wallaby
+  class Map
+    # To collect model classes that are configured to be handled by Wallaby
+    class ModelClassCollector
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def collect
+        return all_models - excluded_models if configured_models.blank?
+        invalid_models_check
+        configured_models
+      end
+
+      private
+
+      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
+
+      def models
+        @configuration.models
+      end
+
+      def all_models
+        Map.mode_map.keys
+      end
+
+      def excluded_models
+        models.excludes
+      end
+
+      def configured_models
+        models.presence
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Wallaby
+  class Map
+    # To map model class to a klass
+    class ModelClassMapper
+      def initialize(base_class)
+        @base_class = base_class
+      end
+
+      def map
+        (@base_class.try(:subclasses) || EMPTY_HASH)
+          .each_with_object({}) do |klass, map|
+          next if anonymous? klass
+          map[klass.model_class] = block_given? ? yield(klass) : klass
+        end
+      end
+
+      protected
+
+      def anonymous?(klass)
+        klass.name.blank?
+      end
+    end
+  end
+end

data/lib/services/wallaby/map.rb

@@ -1,53 +1,90 @@
-class Wallaby::Map
-  def self.mode_map(modes = nil)
-    Rails.cache.fetch 'wallaby/map/mode_map' do
-      {}.tap do |map|
-        (modes || Wallaby::Mode.subclasses).each do |mode_class|
-          mode_class.model_finder.new.all.each do |model_class|
-            map[model_class] = mode_class
-          end
-        end
-      end
+module Wallaby
+  # Global storage of all the maps for model classes
+  class Map
+    # { model => mode }
+    def self.mode_map
+      @mode_map ||= ModeMapper.new(Mode.subclasses).map.freeze
     end
-  end
 
-  def self.model_classes(configuration = nil)
-    Rails.cache.fetch 'wallaby/map/model_classes' do
-      models          = (configuration || Wallaby.configuration).models
-      full_list       = mode_map.keys
-      configed_models = models.presence
+    # [ model classes ]
+    def self.model_classes
+      @model_classes ||=
+        ModelClassCollector.new(::Wallaby.configuration).collect.freeze
+    end
 
-      return full_list - models.excludes unless configed_models
+    # { model => controller }
+    def self.controller_map(model_class)
+      @controller_map ||= ModelClassMapper.new(ResourcesController).map
+      @controller_map[model_class] ||= ResourcesController
+    end
 
-      invalid_models = configed_models - full_list
-      if invalid_models.length > 0
-        fail Wallaby::InvalidError, "#{ invalid_models.to_sentence } are invalid models."
+    # { model => model decorator }
+    def self.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
       end
-      configed_models
     end
-  end
 
-  def self.controller_map
-    model_class_map Wallaby::ResourcesController, __callee__
-  end
+    # { model => resource decorator }
+    def self.resource_decorator_map(model_class)
+      @resource_decorator_map ||= ModelClassMapper.new(ResourceDecorator).map
+      @resource_decorator_map[model_class] ||= begin
+        ResourceDecorator if mode_map[model_class]
+      end
+    end
 
-  def self.decorator_map
-    model_class_map Wallaby::ResourceDecorator, __callee__
-  end
+    # { model => servicer }
+    def self.servicer_map(model_class)
+      @servicer_map ||= ModelClassMapper.new(ModelServicer).map
+      @servicer_map[model_class] ||= begin
+        ModelServicer if mode_map[model_class]
+      end
+    end
 
-  def self.servicer_map
-    model_class_map Wallaby::ModelServicer, __callee__
-  end
+    # { model => service_provider }
+    def self.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
+      end
+    end
 
-  def self.model_class_map(base_class, method_id)
-    Rails.cache.fetch "wallaby/map/#{ method_id }" do
-      {}.tap do |map|
-        base_class.subclasses
-        .reject{ |klass| klass.name.blank? }
-        .each do |klass|
-          map[klass.model_class] = klass
-        end
+    # { model => paginator }
+    def self.paginator_map(model_class)
+      @paginator_map ||= ModelClassMapper.new(ResourcePaginator).map
+      @paginator_map[model_class] ||= begin
+        ResourcePaginator if mode_map[model_class]
       end
     end
+
+    # { model => pagination_provider }
+    def self.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 }
+    def self.resources_name_map(model_class)
+      @resources_name_map ||= {}
+      @resources_name_map[model_class] ||= Utils.to_resources_name model_class
+    end
+
+    # { resources name => model }
+    def self.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 self.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
   end
 end

data/lib/services/wallaby/partial_renderer.rb

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

@@ -0,0 +1,54 @@
+module Wallaby
+  # Prefix builder
+  class PrefixesBuilder
+    def initialize(origin_prefixes, controller_path, resources_name, params)
+      @origin_prefixes = origin_prefixes
+      @controller_path = controller_path
+      @resources_name = resources_name
+      @params = params
+    end
+
+    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
+
+    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
+
+    def mounted_prefix
+      prefix = mounted_path.try(:slice, 1..-1) || ''
+      prefix << SLASH unless prefix.empty?
+      prefix << resource_path if resource_path
+    end
+
+    def build_suffix(params)
+      Utils.to_partial_name params[:action]
+    end
+
+    def wallaby_path
+      ResourcesController.controller_path
+    end
+
+    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
+
+    def resource_path
+      @resource_path ||= @resources_name.try :gsub, COLONS, SLASH
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Wallaby
+  module Sorting
+    # Turn a string `'name asc,id desc'` into sort hash
+    class HashBuilder
+      SORT_REGEX = /(([^\s,]+)\s+(asc|desc))\s*,?\s*/i
+
+      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

@@ -0,0 +1,45 @@
+module Wallaby
+  module Sorting
+    # Build the sorting link
+    class LinkBuilder
+      delegate :model_class, to: :@model_decorator
+
+      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? 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
+
+      # If it's non-association field or custom sorting field
+      def sortable?(metadata)
+        metadata[:is_origin] && !metadata[:is_association] \
+          || metadata[:sort_field_name]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Wallaby
+  module Sorting
+    # Pass field_name to generate sort param
+    class NextBuilder
+      ASC = 'asc'.freeze
+      DESC = 'desc'.freeze
+
+      def initialize(params, hash = nil)
+        @params = params
+        @hash = hash || HashBuilder.build(params[:sort])
+      end
+
+      def next_params(field_name)
+        params = clean_params
+        update params, :sort, complete_sorting_str_with(field_name)
+        params
+      end
+
+      protected
+
+      def clean_params
+        @params.except :resources, :controller, :action
+      end
+
+      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
+
+      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
+
+      def next_value_for(current)
+        case current
+        when ASC then DESC
+        when DESC then nil
+        else ASC
+        end
+      end
+
+      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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,17 @@
+module Wallaby
+  # Node to present tree structure
+  class Node
+    attr_reader :klass
+    attr_accessor :parent
+
+    delegate :name, to: :klass
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def children
+      @children ||= []
+    end
+  end
+end

data/lib/utils/wallaby/utils.rb

@@ -1,31 +1,76 @@
-module Wallaby::Utils
-  def self.to_resources_name(model_class)
-    return '' if model_class.blank?
-    model_class.to_s.underscore.gsub('/', '::').pluralize
-  end
+module Wallaby
+  # Utils
+  module Utils
+    def self.to_resources_name(model_class)
+      return EMPTY_STRING if model_class.blank?
+      model_class.to_s.underscore.gsub(SLASH, COLONS).pluralize
+    end
 
-  def self.to_model_label(model_class)
-    model_class_name = to_model_name model_class
-    model_class_name.titleize.gsub '/', ' / '
-  end
+    def self.to_model_label(model_class)
+      return EMPTY_STRING if model_class.blank?
+      model_class_name = to_model_name model_class
+      model_class_name.titleize.gsub(SLASH, SPACE + SLASH + SPACE)
+    end
 
-  def self.to_model_name(resources_name)
-    return '' if resources_name.blank?
-    resources_name.to_s.singularize.gsub('::', '/').camelize
-  end
+    def self.to_model_name(resources_name)
+      return EMPTY_STRING if resources_name.blank?
+      resources_name.to_s.singularize.gsub(COLONS, SLASH).camelize
+    end
 
-  def self.to_model_class(resources_name, source = nil)
-    return if resources_name.blank?
-    begin
+    def self.to_model_class(resources_name)
+      return if resources_name.blank?
       class_name = to_model_name resources_name
+      # NOTE: do not use if statement instead of rescue here
+      # we want the class_name to be eagerly loaded
       class_name.constantize
-    rescue
-      message = [ class_name, source ].compact.join(' from ')
-      fail Wallaby::ModelNotFound, message
+    rescue NameError => _error
+      raise ModelNotFound, class_name
+    end
+
+    def self.find_filter_name(filter_name, filters)
+      filter_name || # from params
+        filters.find { |_k, v| v[:default] }.try(:first) || # from default value
+        :all # last resort
+    end
+
+    def self.to_field_label(field_name, metadata)
+      field_name = field_name.to_s if field_name.is_a? Symbol
+      metadata[:label] || field_name.humanize
+    end
+
+    def self.to_partial_name(action_name)
+      FORM_ACTIONS.include?(action_name) ? 'form' : action_name
+    end
+
+    def self.to_hash(array)
+      Hash[*array.flatten(1)]
     end
-  end
 
-  def self.to_hash(array)
-    Hash[ *array.flatten(1) ]
+    # @see http://stackoverflow.com/a/8710663/1326499
+    def self.clone(object)
+      ::Marshal.load(::Marshal.dump(object))
+    end
+
+    def self.preload_all
+      ::Wallaby::ApplicationController.to_s
+      preload 'app/models/**/*.rb'
+      preload 'app/decorators/**/*.rb'
+      preload 'app/controllers/**/*.rb'
+      preload 'app/servicers/**/*.rb'
+      preload 'app/**/*.rb'
+    end
+
+    def self.preload(file_pattern)
+      Dir[file_pattern].each do |file_path|
+        begin
+          name = file_path[%r{app/[^/]+/(.+)\.rb}, 1].gsub('concerns/', '')
+          class_name = name.classify
+          class_name.constantize unless Module.const_defined? class_name
+        rescue NameError, LoadError => e
+          Rails.logger.debug ">>>>>>>>> PRELOAD ERROR: #{e.message}"
+          Rails.logger.debug e.backtrace.slice(0, 5)
+        end
+      end
+    end
   end
 end

data/lib/wallaby/configuration/features.rb

@@ -0,0 +1,12 @@
+module Wallaby
+  class Configuration
+    # Configuration for metadata
+    class Features
+      attr_writer :turbolinks_enabled
+
+      def turbolinks_enabled
+        @turbolinks_enabled ||= false
+      end
+    end
+  end
+end