ransack 1.4.1 → 1.5.0

data/lib/ransack/adapters/active_record/3.0/context.rb

@@ -29,8 +29,14 @@ module Ransack
             relation = relation.except(:order)
             .reorder(viz.accept(search.sorts))
           end
-          opts[:distinct] ?
-          relation.select("DISTINCT #{@klass.quoted_table_name}.*") : relation
+          if opts[:distinct]
+            relation.select(
+              Ransack::Constants::DISTINCT + @klass.quoted_table_name +
+              '.*'.freeze
+              )
+          else
+            relation
+          end
         end
 
         def attribute_method?(str, klass = @klass)
@@ -44,11 +50,12 @@ module Ransack
             while !found_assoc && remainder.unshift(segments.pop) &&
               segments.size > 0 do
               assoc, poly_class = unpolymorphize_association(
-                segments.join('_')
+                segments.join(Ransack::Constants::UNDERSCORE)
                 )
               if found_assoc = get_association(assoc, klass)
                 exists = attribute_method?(
-                  remainder.join('_'), poly_class || found_assoc.klass
+                  remainder.join(Ransack::Constants::UNDERSCORE),
+                  poly_class || found_assoc.klass
                   )
               end
             end
@@ -96,13 +103,15 @@ module Ransack
             found_assoc = nil
             while remainder.unshift(segments.pop) && segments.size > 0 &&
               !found_assoc do
-              assoc, klass = unpolymorphize_association(segments.join('_'))
+              assoc, klass = unpolymorphize_association(
+                segments.join(Ransack::Constants::UNDERSCORE)
+                )
               if found_assoc = get_association(assoc, parent)
                 join = build_or_find_association(
                   found_assoc.name, parent, klass
                   )
                 parent, attr_name = get_parent_and_attribute_name(
-                  remainder.join('_'), join
+                  remainder.join(Ransack::Constants::UNDERSCORE), join
                   )
               end
             end
@@ -128,24 +137,31 @@ module Ransack
           buckets = relation.joins_values.group_by do |join|
             case join
             when String
-              'string_join'
+              Ransack::Constants::STRING_JOIN
             when Hash, Symbol, Array
-              'association_join'
+              Ransack::Constants::ASSOCIATION_JOIN
             when ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
-              'stashed_join'
+              Ransack::Constants::STASHED_JOIN
             when Arel::Nodes::Join
-              'join_node'
+              Ransack::Constants::JOIN_NODE
             else
               raise 'unknown class: %s' % join.class.name
             end
           end
 
-          association_joins         = buckets['association_join'] || []
-          stashed_association_joins = buckets['stashed_join'] || []
-          join_nodes                = buckets['join_node'] || []
-          string_joins              = (buckets['string_join'] || [])
-                                      .map { |x| x.strip }
-                                      .uniq
+          association_joins =
+            buckets[Ransack::Constants::ASSOCIATION_JOIN] || []
+
+          stashed_association_joins =
+            buckets[Ransack::Constants::STASHED_JOIN] || []
+
+          join_nodes =
+            buckets[Ransack::Constants::JOIN_NODE] || []
+
+          string_joins =
+            (buckets[Ransack::Constants::STRING_JOIN] || [])
+            .map { |x| x.strip }
+            .uniq
 
           join_list = relation.send :custom_join_sql, (string_joins + join_nodes)
 

data/lib/ransack/adapters/active_record/3.1/context.rb

@@ -28,9 +28,14 @@ module Ransack
             relation = relation.except(:order)
               .reorder(viz.accept(search.sorts))
           end
-          opts[:distinct] ?
-            relation.select("DISTINCT #{@klass.quoted_table_name}.*") :
+          if opts[:distinct]
+            relation.select(
+              Ransack::Constants::DISTINCT + @klass.quoted_table_name +
+              '.*'.freeze
+              )
+          else
             relation
+          end
         end
 
         def attribute_method?(str, klass = @klass)
@@ -44,11 +49,12 @@ module Ransack
             while !found_assoc && remainder.unshift(segments.pop) &&
             segments.size > 0 do
               assoc, poly_class = unpolymorphize_association(
-                segments.join('_')
+                segments.join(Ransack::Constants::UNDERSCORE)
                 )
               if found_assoc = get_association(assoc, klass)
                 exists = attribute_method?(
-                  remainder.join('_'), poly_class || found_assoc.klass
+                  remainder.join(Ransack::Constants::UNDERSCORE),
+                  poly_class || found_assoc.klass
                   )
               end
             end
@@ -109,13 +115,15 @@ module Ransack
             found_assoc = nil
             while remainder.unshift(segments.pop) && segments.size > 0 &&
               !found_assoc do
-              assoc, klass = unpolymorphize_association(segments.join('_'))
+              assoc, klass = unpolymorphize_association(
+                segments.join(Ransack::Constants::UNDERSCORE)
+                )
               if found_assoc = get_association(assoc, parent)
                 join = build_or_find_association(
                   found_assoc.name, parent, klass
                   )
                 parent, attr_name = get_parent_and_attribute_name(
-                  remainder.join('_'), join
+                  remainder.join(Ransack::Constants::UNDERSCORE), join
                   )
               end
             end
@@ -142,24 +150,31 @@ module Ransack
           buckets = relation.joins_values.group_by do |join|
             case join
             when String
-              'string_join'
+              Ransack::Constants::STRING_JOIN
             when Hash, Symbol, Array
-              'association_join'
+              Ransack::Constants::ASSOCIATION_JOIN
             when ::ActiveRecord::Associations::JoinDependency::JoinAssociation
-              'stashed_join'
+              Ransack::Constants::STASHED_JOIN
             when Arel::Nodes::Join
-              'join_node'
+              Ransack::Constants::JOIN_NODE
             else
               raise 'unknown class: %s' % join.class.name
             end
           end
 
-          association_joins         = buckets['association_join'] || []
-          stashed_association_joins = buckets['stashed_join'] || []
-          join_nodes                = buckets['join_node'] || []
-          string_joins              = (buckets['string_join'] || [])
-                                      .map { |x| x.strip }
-                                      .uniq
+          association_joins =
+            buckets[Ransack::Constants::ASSOCIATION_JOIN] || []
+
+          stashed_association_joins =
+            buckets[Ransack::Constants::STASHED_JOIN] || []
+
+          join_nodes =
+            buckets[Ransack::Constants::JOIN_NODE] || []
+
+          string_joins =
+            (buckets[Ransack::Constants::STRING_JOIN] || [])
+            .map { |x| x.strip }
+            .uniq
 
           join_list = relation.send :custom_join_ast,
             relation.table.from(relation.table), string_joins

data/lib/ransack/adapters/active_record/context.rb

@@ -34,8 +34,7 @@ module Ransack
           viz = Visitor.new
           relation = @object.where(viz.accept(search.base))
           if search.sorts.any?
-            relation = relation.except(:order)
-            .reorder(viz.accept(search.sorts))
+            relation = relation.except(:order).reorder(viz.accept(search.sorts))
           end
           opts[:distinct] ? relation.distinct : relation
         end
@@ -47,15 +46,16 @@ module Ransack
           elsif (segments = str.split(/_/)).size > 1
             remainder = []
             found_assoc = nil
-            while !found_assoc && remainder.unshift(
-              segments.pop) && segments.size > 0 do
+            while !found_assoc && remainder.unshift(segments.pop) &&
+            segments.size > 0 do
               assoc, poly_class = unpolymorphize_association(
-                segments.join('_')
+                segments.join(Ransack::Constants::UNDERSCORE)
                 )
               if found_assoc = get_association(assoc, klass)
-                exists = attribute_method?(remainder.join('_'),
+                exists = attribute_method?(
+                  remainder.join(Ransack::Constants::UNDERSCORE),
                   poly_class || found_assoc.klass
-                )
+                  )
               end
             end
           end
@@ -78,7 +78,7 @@ module Ransack
           end
         end
 
-        if ::ActiveRecord::VERSION::STRING >= '4.1'
+        if ::ActiveRecord::VERSION::STRING >= '4.1'.freeze
 
           def join_associations
             raise NotImplementedError,
@@ -133,16 +133,20 @@ module Ransack
 
           if ransackable_attribute?(str, klassify(parent))
             attr_name = str
-          elsif (segments = str.split(/_/)).size > 1
+          elsif (segments = str.split(Ransack::Constants::UNDERSCORE)).size > 1
             remainder = []
             found_assoc = nil
-            while remainder.unshift(
-              segments.pop) && segments.size > 0 && !found_assoc do
-              assoc, klass = unpolymorphize_association(segments.join('_'))
+            while remainder.unshift(segments.pop) && segments.size > 0 &&
+            !found_assoc do
+              assoc, klass = unpolymorphize_association(
+                segments.join(Ransack::Constants::UNDERSCORE)
+                )
               if found_assoc = get_association(assoc, parent)
-                join = build_or_find_association(found_assoc.name, parent, klass)
+                join = build_or_find_association(
+                  found_assoc.name, parent, klass
+                  )
                 parent, attr_name = get_parent_and_attribute_name(
-                  remainder.join('_'), join
+                  remainder.join(Ransack::Constants::UNDERSCORE), join
                   )
               end
             end
@@ -171,27 +175,31 @@ module Ransack
           buckets = relation.joins_values.group_by do |join|
             case join
             when String
-              'string_join'
+              STRING_JOIN
             when Hash, Symbol, Array
-              'association_join'
+              ASSOCIATION_JOIN
             when JoinDependency, JoinDependency::JoinAssociation
-              'stashed_join'
+              STASHED_JOIN
             when Arel::Nodes::Join
-              'join_node'
+              JOIN_NODE
             else
               raise 'unknown class: %s' % join.class.name
             end
           end
 
-          association_joins         = buckets['association_join'] || []
+          association_joins =
+            buckets[Ransack::Constants::ASSOCIATION_JOIN] || []
 
-          stashed_association_joins = buckets['stashed_join'] || []
+          stashed_association_joins =
+            buckets[Ransack::Constants::STASHED_JOIN] || []
 
-          join_nodes                = buckets['join_node'] || []
+          join_nodes =
+            buckets[Ransack::Constants::JOIN_NODE] || []
 
-          string_joins              = (buckets['string_join'] || [])
-                                      .map { |x| x.strip }
-                                      .uniq
+          string_joins =
+            (buckets[Ransack::Constants::STRING_JOIN] || [])
+            .map { |x| x.strip }
+            .uniq
 
           join_list = relation.send :custom_join_ast,
             relation.table.from(relation.table), string_joins
@@ -204,14 +212,14 @@ module Ransack
             join_dependency.alias_tracker.aliases[join.left.name.downcase] = 1
           end
 
-          if ::ActiveRecord::VERSION::STRING >= '4.1'
+          if ::ActiveRecord::VERSION::STRING >= '4.1'.freeze
             join_dependency
           else
             join_dependency.graft(*stashed_association_joins)
           end
         end
 
-        if ::ActiveRecord::VERSION::STRING >= '4.1'
+        if ::ActiveRecord::VERSION::STRING >= '4.1'.freeze
 
           def build_or_find_association(name, parent = @base, klass = nil)
             found_association = @join_dependency.join_root.children

data/lib/ransack/configuration.rb

@@ -24,7 +24,7 @@ module Ransack
 
       self.predicates[name] = Predicate.new(opts)
 
-      ['_any', '_all'].each do |suffix|
+      Ransack::Constants::SUFFIXES.each do |suffix|
         compound_name = name + suffix
         self.predicates[compound_name] = Predicate.new(
           opts.merge(

data/lib/ransack/constants.rb

@@ -1,122 +1,157 @@
 module Ransack
   module Constants
+    ASC                 = 'asc'.freeze
+    DESC                = 'desc'.freeze
+    ASC_ARROW           = '▲'.freeze
+    DESC_ARROW          = '▼'.freeze
+    OR                  = 'or'.freeze
+    AND                 = 'and'.freeze
+    SORT                = 'sort'.freeze
+    SORT_LINK           = 'sort_link'.freeze
+    SEARCH              = 'search'.freeze
+    DEFAULT_SEARCH_KEY  = 'q'.freeze
+    ATTRIBUTE           = 'attribute'.freeze
+    DISTINCT            = 'DISTINCT '.freeze
+    COMBINATOR          = 'combinator'.freeze
+    SPACE               = ' '.freeze
+    COMMA_SPACE         = ', '.freeze
+    UNDERSCORE          = '_'.freeze
+    NON_BREAKING_SPACE  = ' '.freeze
+    EMPTY               = ''.freeze
+    STRING_JOIN         = 'string_join'.freeze
+    ASSOCIATION_JOIN    = 'association_join'.freeze
+    STASHED_JOIN        = 'stashed_join'.freeze
+    JOIN_NODE           = 'join_node'.freeze
+
     TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
     FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
     BOOLEAN_VALUES = TRUE_VALUES + FALSE_VALUES
 
-    AREL_PREDICATES = %w(eq not_eq matches does_not_match lt lteq gt gteq in not_in)
+    S_SORTS             = %w(s sorts).freeze
+    ASC_DESC            = %w(asc desc).freeze
+    AND_OR              = %w(and or).freeze
+    IN_NOT_IN           = %w(in not_in).freeze
+    SUFFIXES            = %w(_any _all).freeze
+    AREL_PREDICATES     = %w(
+      eq not_eq matches does_not_match lt lteq gt gteq in not_in
+    ).freeze
+
+    EQ                  = 'eq'.freeze
+    NOT_EQ              = 'not_eq'.freeze
+    EQ_ANY              = 'eq_any'.freeze
+    NOT_EQ_ALL          = 'not_eq_all'.freeze
 
     DERIVED_PREDICATES = [
-      ['cont', {
-        :arel_predicate => 'matches',
+      ['cont'.freeze, {
+        :arel_predicate => 'matches'.freeze,
         :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
-      ['i_cont', {
-        :arel_predicate => 'i_matches',
+      ['i_cont'.freeze, {
+        :arel_predicate => 'i_matches'.freeze,
         :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
       }
       ],
-      ['not_cont', {
-        :arel_predicate => 'does_not_match',
+      ['not_cont'.freeze, {
+        :arel_predicate => 'does_not_match'.freeze,
         :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
-      ['i_not_cont', {
-        :arel_predicate => 'i_does_not_match',
+      ['i_not_cont'.freeze, {
+        :arel_predicate => 'i_does_not_match'.freeze,
         :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
       }
       ],
-      ['start', {
-        :arel_predicate => 'matches',
+      ['start'.freeze, {
+        :arel_predicate => 'matches'.freeze,
         :formatter => proc { |v| "#{escape_wildcards(v)}%" }
         }
       ],
-      ['not_start', {
-        :arel_predicate => 'does_not_match',
+      ['not_start'.freeze, {
+        :arel_predicate => 'does_not_match'.freeze,
         :formatter => proc { |v| "#{escape_wildcards(v)}%" }
         }
       ],
-      ['end', {
-        :arel_predicate => 'matches',
+      ['end'.freeze, {
+        :arel_predicate => 'matches'.freeze,
         :formatter => proc { |v| "%#{escape_wildcards(v)}" }
         }
       ],
-      ['not_end', {
-        :arel_predicate => 'does_not_match',
+      ['not_end'.freeze, {
+        :arel_predicate => 'does_not_match'.freeze,
         :formatter => proc { |v| "%#{escape_wildcards(v)}" }
         }
       ],
-      ['true', {
-        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
+      ['true'.freeze, {
+        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
         :formatter => proc { |v| true }
         }
       ],
-      ['not_true', {
-        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
+      ['not_true'.freeze, {
+        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
         :formatter => proc { |v| true }
         }
       ],
-      ['false', {
-        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
+      ['false'.freeze, {
+        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
         :formatter => proc { |v| false }
         }
       ],
-      ['not_false', {
-        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
+      ['not_false'.freeze, {
+        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
         :formatter => proc { |v| false }
         }
       ],
-      ['present', {
-        :arel_predicate => proc { |v| v ? 'not_eq_all' : 'eq_any' },
+      ['present'.freeze, {
+        :arel_predicate => proc { |v| v ? NOT_EQ_ALL : EQ_ANY },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, ''] }
+        :formatter => proc { |v| [nil, Ransack::Constants::EMPTY] }
         }
       ],
-      ['blank', {
-        :arel_predicate => proc { |v| v ? 'eq_any' : 'not_eq_all' },
+      ['blank'.freeze, {
+        :arel_predicate => proc { |v| v ? EQ_ANY : NOT_EQ_ALL },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, ''] }
+        :formatter => proc { |v| [nil, Ransack::Constants::EMPTY] }
         }
       ],
-      ['null', {
-        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
+      ['null'.freeze, {
+        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v)},
         :formatter => proc { |v| nil }
         }
       ],
-      ['not_null', {
-        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
+      ['not_null'.freeze, {
+        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
         :compounds => false,
         :type => :boolean,
         :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
         :formatter => proc { |v| nil } }
       ]
-    ]
+    ].freeze
 
   module_function
     # replace % \ to \% \\
     def escape_wildcards(unescaped)
       case ActiveRecord::Base.connection.adapter_name
-      when "Mysql2", "PostgreSQL"
+      when "Mysql2".freeze, "PostgreSQL".freeze
         # Necessary for PostgreSQL and MySQL
         unescaped.to_s.gsub(/([\\|\%|.])/, '\\\\\\1')
       else