wallaby 5.0.1 → 5.1.3

data/lib/adaptors/wallaby/active_record/model_decorator/title_field_finder.rb

@@ -1,18 +1,28 @@
-class Wallaby::ActiveRecord::ModelDecorator::TitleFieldFinder
-  def initialize(model_class, fields)
-    @model_class  = model_class
-    @fields       = fields
-  end
+module Wallaby
+  class ActiveRecord
+    class ModelDecorator
+      # Try to find the field that can be used as title
+      class TitleFieldFinder
+        TITLE_FIELD_TYPES = %w(string).freeze
+        TITLE_NAMES = %w(name title string text).freeze
 
-  def find
-    possible_title_fields = @fields.select do |field_name, metadata|
-      %w( string ).include? metadata[:type]
-    end
-    target_field = possible_title_fields.values.find do |metadata|
-      %w( name title string text ).any?{ |v| metadata[:name].index v }
+        def initialize(model_class, fields)
+          @model_class  = model_class
+          @fields       = fields
+        end
+
+        def find
+          possible_title_fields = @fields.select do |_field_name, metadata|
+            TITLE_FIELD_TYPES.include? metadata[:type]
+          end
+          target_field = possible_title_fields.values.find do |metadata|
+            TITLE_NAMES.any? { |v| metadata[:name].index v }
+          end
+          target_field ||= possible_title_fields.values.first
+          target_field ||= { name: @model_class.primary_key }
+          target_field[:name]
+        end
+      end
     end
-    target_field ||= possible_title_fields.values.first
-    target_field ||= { name: @model_class.primary_key }
-    target_field[:name]
   end
 end

data/lib/adaptors/wallaby/active_record/model_decorator.rb

@@ -1,81 +1,135 @@
-class Wallaby::ActiveRecord::ModelDecorator < Wallaby::ModelDecorator
-  def fields
-    @fields ||= {}.tap do |hash|
-      if model_class.table_exists?
-        hash.merge! general_fields
-        hash.merge! association_fields
-        hash.except! *foreign_keys_from_associations
-      end
-    end.with_indifferent_access
-  end
+module Wallaby
+  class ActiveRecord
+    # Modal decorator for Active Record
+    class ModelDecorator < ::Wallaby::ModelDecorator
+      # Data types to exclude for index page
+      INDEX_EXCLUSIVE_DATA_TYPES =
+        %w(binary citext hstore json jsonb text tsvector xml).freeze
 
-  def index_fields
-    @index_fields ||= fields.deep_dup
-  end
+      # Data types to exclude for form page
+      FORM_EXCLUSIVE_DATA_TYPES = %w(created_at updated_at).freeze
 
-  def show_fields
-    @show_fields  ||= fields.deep_dup
-  end
+      # Origin metadata coming from data source.
+      # It needs to be frozen so that we can keep the metadata integrity
+      # @return [Hash]
+      #   example:
+      #     {
+      #       # general field
+      #       id: { name: 'id', type: 'integer', label: 'Id', is_origin: true },
+      #       # association field
+      #       category: {
+      #         'name' => 'category',
+      #         'type' => 'belongs_to',
+      #         'label' => 'Category',
+      #         'is_origin' => true,
+      #         'is_association' => true,
+      #         'is_through' => false,
+      #         'has_scope' => false,
+      #         'foreign_key' => 'category_id',
+      #         'class' => Category
+      #       }
+      #     }
+      def fields
+        @fields ||= ::ActiveSupport::HashWithIndifferentAccess.new.tap do |hash|
+          # NOTE: There is a chance that people create Active Record class
+          # before they do the migration, so initialising the fields will raise
+          # all kinds of error. Therefore, we need to check the table existence
+          if @model_class.table_exists?
+            hash.merge! general_fields
+            hash.merge! association_fields
+            hash.except!(*foreign_keys_from_associations)
+          end
+        end.freeze
+      end
 
-  def form_fields
-    @form_fields  ||= fields.deep_dup
-  end
+      # A copy of all the fields for index page
+      # @return [Hash]
+      def index_fields
+        @index_fields ||= Utils.clone fields
+      end
 
-  def index_field_names
-    @index_field_names ||= index_fields.reject do |field_name, metadata|
-      metadata[:is_association] ||
-      %w( binary citext hstore json jsonb text tsvector xml ).include?(metadata[:type])
-    end.keys
-  end
+      # A copy of all the fields for show page
+      # @return [Hash]
+      def show_fields
+        @show_fields  ||= Utils.clone fields
+      end
 
-  def form_field_names
-    @form_field_names ||= form_fields.reject do |field_name, metadata|
-      %W( #{ primary_key } updated_at created_at ).include?(field_name) ||
-      metadata[:has_scope] ||
-      metadata[:is_through]
-    end.keys
-  end
+      # A copy of all the fields for form page
+      # @return [Hash]
+      def form_fields
+        @form_fields  ||= Utils.clone fields
+      end
 
-  def form_active_errors(resource)
-    resource.errors
-  end
+      # Fields name for index page
+      # @return [Array]
+      def index_field_names
+        @index_field_names ||= begin
+          index_fields.reject do |_field_name, metadata|
+            metadata[:is_association] \
+              || INDEX_EXCLUSIVE_DATA_TYPES.include?(metadata[:type])
+          end.keys
+        end
+      end
 
-  def primary_key
-    @model_class.primary_key
-  end
+      # Fields name for form page
+      # @return [Array]
+      def form_field_names
+        @form_field_names ||= begin
+          form_fields.reject do |field_name, metadata|
+            field_name == primary_key \
+              || FORM_EXCLUSIVE_DATA_TYPES.include?(field_name) \
+              || metadata[:has_scope] || metadata[:is_through]
+          end.keys
+        end
+      end
 
-  def guess_title(resource)
-    resource.public_send title_field_finder.find
-  end
+      # Errors for resource
+      # @return [ActiveModel::Errors]
+      def form_active_errors(resource)
+        resource.errors
+      end
 
-  protected
-  def field_builder
-    @field_builder ||= Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder.new @model_class
-  end
+      # Primary key for the resource
+      # @return [String]
+      def primary_key
+        @model_class.primary_key
+      end
 
-  def title_field_finder
-    @title_field_finder ||= Wallaby::ActiveRecord::ModelDecorator::TitleFieldFinder.new @model_class, general_fields
-  end
+      # To guess the title for resource.
+      # It will go through the fields and try to find out the one that looks
+      # like a name or text to represent this resource. Otherwise, it will fall
+      # back to primary key.
+      # @param resource [Object]
+      # @return [String] the title of given resource
+      def guess_title(resource)
+        resource.public_send title_field_finder.find
+      end
 
-  delegate :general_fields, :association_fields, to: :field_builder
+      protected
 
-  def foreign_keys_from_associations(associations = association_fields)
-    associations.inject([]) do |keys, (field_name, metadata)|
-      keys << metadata[:foreign_key]      if metadata[:foreign_key]
-      keys << metadata[:polymorphic_type] if metadata[:polymorphic_type]
-      keys
-    end
-  end
+      # @see Wallaby::ModelDecorator::FieldsBuilder
+      def field_builder
+        @field_builder ||= FieldsBuilder.new @model_class
+      end
 
-  def many_associations(associations = association_fields)
-    associations.select do |field_name, metadata|
-      /many/ =~ metadata[:type] && !metadata[:is_through]
-    end
-  end
+      # @see Wallaby::ModelDecorator::TitleFieldFinder
+      def title_field_finder
+        @title_field_finder ||=
+          TitleFieldFinder.new @model_class, general_fields
+      end
+
+      delegate :general_fields, :association_fields, to: :field_builder
 
-  def belongs_to_associations(associations = association_fields)
-    associations.select do |field_name, metadata|
-      'belongs_to' == metadata[:type]
+      # Find out all the foreign keys for a list of fields
+      # @param fields [Hash] metadata of fields
+      # @return [Array] a list of foreign keys
+      def foreign_keys_from_associations(fields = association_fields)
+        fields.each_with_object([]) do |(_field_name, metadata), keys|
+          keys << metadata[:foreign_key] if metadata[:foreign_key]
+          keys << metadata[:polymorphic_type] if metadata[:polymorphic_type]
+          keys
+        end
+      end
     end
   end
 end

data/lib/adaptors/wallaby/active_record/model_finder.rb

@@ -1,22 +1,51 @@
-class Wallaby::ActiveRecord::ModelFinder < Wallaby::ModelFinder
-  def base
-    Rails.cache.fetch 'wallaby/active_record/model_finder/base' do
-      if defined? ::ApplicationRecord
-        ::ApplicationRecord
-      else
+module Wallaby
+  class ActiveRecord
+    # Model finder
+    class ModelFinder < ::Wallaby::ModelFinder
+      # @return [Array] a list of ActiveRecord subclasses
+      def all
+        self.class.base.descendants.reject do |model_class|
+          abstract?(model_class) || anonymous?(model_class) \
+            || schema?(model_class) || habtm?(model_class)
+        end.sort_by(&:to_s)
+      end
+
+      # Base class should be either ApplicationRecord or ActiveRecord::Base
+      def self.base
+        return ::ApplicationRecord if defined? ::ApplicationRecord
         ::ActiveRecord::Base
       end
-    end
-  end
 
-  def all
-    Rails.cache.fetch 'wallaby/active_record/model_finder' do
-      base.subclasses.reject do |model_class|
-        model_class.abstract_class? ||
-        model_class.to_s.start_with?('#<') ||
-        model_class.name == 'ActiveRecord::SchemaMigration' ||
+      private
+
+      # Is model class abstract?
+      # @param [Class] model class
+      # @return [Boolean]
+      def abstract?(model_class)
+        model_class.abstract_class?
+      end
+
+      # Is model class anonymous?
+      # @param [Class] model class
+      # @return [Boolean]
+      def anonymous?(model_class)
+        model_class.to_s.start_with? '#<Class'
+      end
+
+      # Is model class the shcema migration class?
+      # @param [Class] model class
+      # @return [Boolean]
+      def schema?(model_class)
+        model_class.name == 'ActiveRecord::SchemaMigration'
+      end
+
+      # Check and see if given model class is intermediate class that generated
+      # for has and belongs to many assocation
+      # @param [Class] model class
+      # @return [Boolean]
+      def habtm?(model_class)
         model_class.name.index('HABTM')
-      end.sort_by &:to_s
+      end
     end
   end
 end

data/lib/adaptors/wallaby/active_record/model_pagination_provider.rb

@@ -0,0 +1,30 @@
+module Wallaby
+  class ActiveRecord
+    # Model pagination provider
+    class ModelPaginationProvider < ::Wallaby::ModelPaginationProvider
+      # Check if collection has pagination feature
+      # @return [Boolean]
+      def paginatable?
+        @collection.respond_to? :total_count
+      end
+
+      # Total count for the query
+      # @return [Integer]
+      def total
+        @collection.total_count
+      end
+
+      # Page size
+      # @return [Integer]
+      def page_size
+        @params[:per].try(:to_i) || Wallaby.configuration.pagination.page_size
+      end
+
+      # Page number
+      # @return [Integer]
+      def page_number
+        [@params[:page].to_i, 1].max
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Wallaby
+  class ActiveRecord
+    class ModelServiceProvider
+      # Normalizer
+      class Normalizer
+        def initialize(model_decorator)
+          @model_decorator = model_decorator
+        end
+
+        def normalize(params)
+          params.each do |field_name, values|
+            metadata = @model_decorator.fields[field_name] || EMPTY_HASH
+            type = (metadata[:type] || EMPTY_STRING)[/range|point|binary/]
+            next unless type
+            send "normalize_#{type}_values", params, field_name, values
+          end
+        end
+
+        def normalize_range_values(params, field_name, values)
+          normalized = Array(values).map(&:presence).compact
+          params[field_name] =
+            if normalized.present? && values.length == 2
+              values.first...values.last
+            end
+        end
+
+        def normalize_point_values(params, field_name, values)
+          normalized = Array(values).map(&:presence).compact
+          params[field_name] =
+            normalized.present? &&
+            values.map(&:to_f) || nil
+        end
+
+        def normalize_binary_values(params, field_name, values)
+          params[field_name] =
+            values.is_a?(::ActionDispatch::Http::UploadedFile) &&
+            values.read || nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Wallaby
+  class ActiveRecord
+    class ModelServiceProvider
+      # Filter the params
+      class Permitter
+        def initialize(model_decorator)
+          @model_decorator = model_decorator
+        end
+
+        def simple_field_names
+          field_names =
+            non_range_fields.keys +
+            belongs_to_fields.map do |_, metadata|
+              [metadata[:foreign_key], metadata[:polymorphic_type]]
+            end.flatten.compact
+          fields = [@model_decorator.primary_key, 'created_at', 'updated_at']
+          field_names.reject { |field_name| fields.include? field_name }
+        end
+
+        def compound_hashed_fields
+          field_names =
+            range_fields.keys +
+            many_association_fields.map { |_, metadata| metadata[:foreign_key] }
+          field_names.each_with_object({}) { |name, hash| hash[name] = [] }
+        end
+
+        protected
+
+        def non_association_fields
+          @model_decorator
+            .fields.reject { |_, metadata| metadata[:is_association] }
+        end
+
+        def non_range_fields
+          non_association_fields
+            .reject { |_, metadata| /range|point/ =~ metadata[:type] }
+        end
+
+        def range_fields
+          non_association_fields.select do |_, metadata|
+            /range|point/ =~ metadata[:type]
+          end
+        end
+
+        def association_fields
+          @model_decorator.fields.select do |_, metadata|
+            metadata[:is_association] &&
+              !metadata[:has_scope] && !metadata[:is_through]
+          end
+        end
+
+        def many_association_fields
+          association_fields.select { |_, metadata| /many/ =~ metadata[:type] }
+        end
+
+        def belongs_to_fields
+          association_fields.select do |_field_name, metadata|
+            metadata[:type] == 'belongs_to'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Wallaby
+  class ActiveRecord
+    class ModelServiceProvider
+      class Querier
+        # 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
+
+          rule keyword: simple(:value) do
+            value.try :to_str
+          end
+
+          rule keyword: sequence(:value) do
+            value.presence.try :map, :to_str
+          end
+
+          rule left: simple(:left), op: simple(:op), right: simple(:right) do
+            oped = op.try :to_str
+            operator = SIMPLE_OPERATORS[oped]
+            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
+
+          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/querier.rb

@@ -0,0 +1,102 @@
+module Wallaby
+  class ActiveRecord
+    class ModelServiceProvider
+      # Query builder
+      class Querier
+        TEXT_FIELDS = %w(string text citext).freeze
+
+        def initialize(model_decorator)
+          @model_decorator = model_decorator
+          @model_class = @model_decorator.model_class
+        end
+
+        def search(params)
+          filter_name, keywords, field_queries = extract params
+          scope = filtered_by filter_name
+          query = text_search keywords
+          query = field_search field_queries, query
+          scope.where query
+        end
+
+        private
+
+        def parser
+          @parser ||= Parser.new
+        end
+
+        def transformer
+          @transformer ||= Transformer.new
+        end
+
+        def table
+          @model_class.arel_table
+        end
+
+        def extract(params)
+          expressions = to_expressions params
+          keywords = expressions.select { |v| v.is_a? String }
+          field_queries = expressions.select { |v| v.is_a? Hash }
+          filter_name = params[:filter]
+          [filter_name, keywords, field_queries]
+        end
+
+        def to_expressions(params)
+          parsed = parser.parse(params[:q] || EMPTY_STRING)
+          converted = transformer.apply parsed
+          converted.is_a?(Array) ? converted : [converted]
+        end
+
+        def filtered_by(filter_name)
+          valid_filter_name =
+            Utils.find_filter_name(filter_name, @model_decorator.filters)
+          scope = find_scope(valid_filter_name)
+          if scope.blank? then unscoped
+          elsif scope.respond_to?(:call) then @model_class.instance_exec(&scope)
+          elsif @model_class.respond_to?(scope)
+            @model_class.public_send(scope)
+          else unscoped
+          end
+        end
+
+        def find_scope(filter_name)
+          filter = @model_decorator.filters[filter_name] || {}
+          filter[:scope] || filter_name
+        end
+
+        def unscoped
+          @model_class.where nil
+        end
+
+        def text_search(keywords, query = nil)
+          return query if keywords.blank?
+          text_fields.each do |field_name|
+            sub_query = nil
+            keywords.each do |keyword|
+              exp = table[field_name].matches("%#{keyword}%")
+              sub_query = sub_query.try(:and, exp) || exp
+            end
+            query = query.try(:or, sub_query) || sub_query
+          end
+          query
+        end
+
+        def field_search(field_queries, query)
+          field_queries.each do |exp|
+            next unless @model_decorator.fields[exp[:left]]
+            sub_query = table[exp[:left]].public_send(exp[:op], exp[:right])
+            query = query.try(:and, sub_query) || sub_query
+          end
+          query
+        end
+
+        def text_fields
+          index_field_names = @model_decorator.index_field_names.map(&:to_s)
+          @model_decorator.fields.select do |field_name, metadata|
+            index_field_names.include?(field_name) &&
+              TEXT_FIELDS.include?(metadata[:type].to_s)
+          end.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Wallaby
+  class ActiveRecord
+    class ModelServiceProvider
+      # Validator
+      class Validator
+        def initialize(model_decorator)
+          @model_decorator = model_decorator
+        end
+
+        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
+
+        def valid_range_type?(values, metadata)
+          !metadata \
+            || !%w(daterange tsrange tstzrange).include?(metadata[:type]) \
+            || !values.try(:any?, &:blank?)
+        end
+      end
+    end
+  end
+end