ransack 1.7.0 → 2.4.1

data/lib/ransack/locale/sk.yml

@@ -0,0 +1,70 @@
+sk:
+  ransack:
+    search: "vyhľadávanie"
+    predicate: "predikát"
+    and: "a"
+    or: "alebo"
+    any: "akýkoľvek"
+    all: "každý"
+    combinator: "kombinátor"
+    attribute: "atribút"
+    value: "hodnota"
+    condition: "podmienka"
+    sort: "poradie"
+    asc: "vzostupne"
+    desc: "zostupne"
+    predicates:
+      eq: "sa rovná"
+      eq_any: "sa rovná akémukoľvek"
+      eq_all: "sa rovná všetkým"
+      not_eq: "sa nerovná"
+      not_eq_any: "sa nerovná akémukoľvek"
+      not_eq_all: "sa nerovná všetkým"
+      matches: "zodpovedá"
+      matches_any: "zodpovedá akémukoľvek"
+      matches_all: "zodpovedá všetkým"
+      does_not_match: "nezodpovedá"
+      does_not_match_any: "nezodpovedá akémukoľvek"
+      does_not_match_all: "nezodpovedá všetkým"
+      lt: "menší ako"
+      lt_any: "menší ako akýkoľvek"
+      lt_all: "menší ako všetky"
+      lteq: "menší alebo rovný"
+      lteq_any: "menší alebo rovný akémukoľvek"
+      lteq_all: "menší alebo rovný všetkým"
+      gt: "väčší ako"
+      gt_any: "väčší ako akýkoľvek"
+      gt_all: "väčší ako všetky"
+      gteq: "väčší alebo rovný"
+      gteq_any: "väčší alebo rovný akémukoľvek"
+      gteq_all: "väčší alebo rovný všetkým"
+      in: "v"
+      in_any: "v akejkoľvek"
+      in_all: "vo všetkých"
+      not_in: "nie je v"
+      not_in_any: "nie je v akejkoľvek"
+      not_in_all: "nie je vo všetkých"
+      cont: "obsahuje"
+      cont_any: "obsahuje akúkoľvek"
+      cont_all: "obsahuje všetky"
+      not_cont: "neobsahuje"
+      not_cont_any: "neobsahuje akúkoľvek"
+      not_cont_all: "neobsahuje všetky"
+      start: "začína na"
+      start_any: "začína s akoukoľvek"
+      start_all: "začína so všetkými"
+      not_start: "nezačíná s"
+      not_start_any: "nezačíná s akoukoľvek"
+      not_start_all: "nezačíná so všetkými"
+      end: "končí s"
+      end_any: "končí s akoukoľvek"
+      end_all: "končí so všetkými"
+      not_end: "nekončí s"
+      not_end_any: "nekončí s akoukoľvek"
+      not_end_all: "nekončí so všetkými"
+      'true': "je pravdivé"
+      'false': "nie je pravdivé"
+      present: "je vyplnené"
+      blank: "je prázdne"
+      'null': "je null"
+      not_null: "nie je null"

data/lib/ransack/locale/tr.yml

@@ -0,0 +1,70 @@
+tr:
+  ransack:
+    search: "ara"
+    predicate: "doğrula"
+    and: "ve"
+    or: "veya"
+    any: "herhangi"
+    all: "hepsi"
+    combinator: "birleştirici"
+    attribute: "nitelik"
+    value: "değer"
+    condition: "şart"
+    sort: "sırala"
+    asc: "artan"
+    desc: "azalan"
+    predicates:
+      eq: "eşit"
+      eq_any: "herhangi birine eşit"
+      eq_all: "hepsine eşit"
+      not_eq: "eşit değil"
+      not_eq_any: "herhangi birine eşit değil"
+      not_eq_all: "hiçbirine eşit değil"
+      matches: "eşleşen"
+      matches_any: "herhangi biri ile eşleşen"
+      matches_all: "hepsi ile eşleşen"
+      does_not_match: "eşleşmeyen"
+      does_not_match_any: "herhangi biri ile eşleşmeyen"
+      does_not_match_all: "hiçbiri ile eşleşmeyen"
+      lt: "daha küçük"
+      lt_any: "herhangi birinden küçük"
+      lt_all: "hepsinden küçük"
+      lteq: "daha küçük veya eşit"
+      lteq_any: "daha küçük veya herhangi birine eşit"
+      lteq_all: "daha küçük veya hepsine eşit"
+      gt: "daha büyük "
+      gt_any: "herhangi birinden daha büyük"
+      gt_all: "hepsinden daha büyük"
+      gteq: "daha büyük veya eşit"
+      gteq_any: "daha büyük veya herhangi birine eşit"
+      gteq_all: "daha büyük veya hepsine eşit"
+      in: "içinde"
+      in_any: "herhangi birinde"
+      in_all: "hepsinde"
+      not_in: "içinde değil"
+      not_in_any: "herhangi birinde değil"
+      not_in_all: "hiçbirinde değil"
+      cont: "içeren"
+      cont_any: "herhangi birini içeren"
+      cont_all: "hepsini içeren"
+      not_cont: "içermeyen"
+      not_cont_any: "herhangi birini içermeyen"
+      not_cont_all: "hiçbirini birini içermeyen"
+      start: "ile başlayan"
+      start_any: "herhangi biriyle başlayan"
+      start_all: "hepsiyle başlayan"
+      not_start: "ile başlamayan"
+      not_start_any: "herhangi biriyle başlamayan"
+      not_start_all: "hiçbiriyle başlamayan"
+      end: "ile biten"
+      end_any: "herhangi biriyle biten"
+      end_all: "hepsi ile biten"
+      not_end: "ile bitmeyen"
+      not_end_any: "herhangi biriyle bitmeyen"
+      not_end_all: "hiçbiriyle bitmeyen"
+      'true': "doğru"
+      'false': "yanlış"
+      present: "mevcut"
+      blank: "boş"
+      'null': "geçersiz"
+      not_null: "geçerli"

data/lib/ransack/locale/{zh.yml → zh-CN.yml}

@@ -1,4 +1,4 @@
-zh:
+zh-CN:
   ransack:
     search: "搜索"
     predicate: "基于(predicate)"
@@ -50,18 +50,18 @@ zh:
       not_cont: "不包含"
       not_cont_any: "不包含任意一个值"
       not_cont_all: "不包含所有值"
-      start: "以改值开始"
-      start_any: "以任意一个值开始"
-      start_all: "以所有值开始"
-      not_start: "不以改值开始"
-      not_start_any: "不以任意一个值开始"
-      not_start_all: "不以所有值开始"
-      end: "以改值结尾"
-      end_any: "以任意一个值结尾"
-      end_all: "以所有值结尾"
-      not_end: "不以改值结尾"
-      not_end_any: "不以任意一个值结尾"
-      not_end_all: "不以所有值结尾"
+      start: "始于"
+      start_any: "始于任一值"
+      start_all: "始于任意值"
+      not_start: "非始于"
+      not_start_any: "非始于任一值"
+      not_start_all: "非始于任意值"
+      end: "止于"
+      end_any: "止于任一值"
+      end_all: "止于任意值"
+      not_end: "非止于"
+      not_end_any: "非止于任一值"
+      not_end_all: "非止于任意值"
       'true': "等于true"
       'false': "等于false"
       present: "有值"

data/lib/ransack/locale/zh-TW.yml

@@ -0,0 +1,70 @@
+zh-TW:
+  ransack:
+    search: "搜尋"
+    predicate: "基於"
+    and: "而且"
+    or: "或者"
+    any: "任何"
+    all: "所有"
+    combinator: "條件組合"
+    attribute: "屬性"
+    value: "數值"
+    condition: "條件"
+    sort: "排序"
+    asc: "升冪排序"
+    desc: "降冪排序"
+    predicates:
+      eq: "等於"
+      eq_any: "等於任何一個值"
+      eq_all: "等於所有值"
+      not_eq: "不等於"
+      not_eq_any: "不等於任何一個值"
+      not_eq_all: "不等於所有值"
+      matches: "符合"
+      matches_any: "符合任何一個條件"
+      matches_all: "符合所有條件"
+      does_not_match: "不符合"
+      does_not_match_any: "不符合任何一個條件"
+      does_not_match_all: "不符合所有條件"
+      lt: "小於"
+      lt_any: "小於任何一個值"
+      lt_all: "小於所有值"
+      lteq: "小於或等於"
+      lteq_any: "小於或等於任何一個值"
+      lteq_all: "小於或等於所有值"
+      gt: "大於"
+      gt_any: "大於任何一個值"
+      gt_all: "大於所有值"
+      gteq: "大於或等於"
+      gteq_any: "大於或等於任何一個值"
+      gteq_all: "大於或等於所有值"
+      in: "被包含於"
+      in_any: "被包含於任何一個值"
+      in_all: "被包含於所有值"
+      not_in: "不被包含於"
+      not_in_any: "不被包含於任何一個值"
+      not_in_all: "不被包含於所有值"
+      cont: "包含"
+      cont_any: "包含任何一個值"
+      cont_all: "包含所有值"
+      not_cont: "不包含"
+      not_cont_any: "不包含任何一個值"
+      not_cont_all: "不包含所有值"
+      start: "以某個值開始"
+      start_any: "以任何一個值開始"
+      start_all: "以所有值開始"
+      not_start: "不以某個值開始"
+      not_start_any: "不以任何一值開始"
+      not_start_all: "不以所有值開始"
+      end: "以某個值結尾"
+      end_any: "以任何一個值結尾"
+      end_all: "以所有值結尾"
+      not_end: "不以某個值結尾"
+      not_end_any: "不以任何一個值結尾"
+      not_end_all: "不以所有值結尾"
+      'true': "為真"
+      'false': "為假"
+      present: "有值"
+      blank: "為空"
+      'null': "為 null"
+      not_null: "不為 null"

data/lib/ransack/nodes/attribute.rb

@@ -5,7 +5,7 @@ module Ransack
 
       attr_reader :name, :ransacker_args
 
-      delegate :blank?, :present?, :==, :to => :name
+      delegate :blank?, :present?, :to => :name
       delegate :engine, :to => :context
 
       def initialize(context, name = nil, ransacker_args = [])
@@ -16,7 +16,6 @@ module Ransack
 
       def name=(name)
         @name = name
-        context.bind(self, name) unless name.blank?
       end
 
       def valid?
@@ -25,6 +24,10 @@ module Ransack
         .include?(attr_name.split('.').last)
       end
 
+      def associated_collection?
+        parent.respond_to?(:reflection) && parent.reflection.collection?
+      end
+
       def type
         if ransacker
           return ransacker.type

data/lib/ransack/nodes/bindable.rb

@@ -27,14 +27,26 @@ module Ransack
 
       private
 
-        def get_arel_attribute
-          if ransacker
-            ransacker.attr_from(self)
-          else
-            context.table_for(parent)[attr_name]
-          end
+      def get_arel_attribute
+        if ransacker
+          ransacker.attr_from(self)
+        else
+          get_attribute
         end
+      end
 
+      def get_attribute
+        if is_alias_attribute?
+          context.table_for(parent)[parent.base_klass.attribute_aliases[attr_name]]
+        else
+          context.table_for(parent)[attr_name]
+        end
+      end
+
+      def is_alias_attribute?
+        Ransack::SUPPORTS_ATTRIBUTE_ALIAS &&
+        parent.base_klass.attribute_aliases.key?(attr_name)
+      end
     end
   end
 end

data/lib/ransack/nodes/condition.rb

@@ -9,9 +9,10 @@ module Ransack
 
       class << self
         def extract(context, key, values)
-          attributes, predicate = extract_attributes_and_predicate(key, context)
+          attributes, predicate, combinator =
+            extract_values_for_condition(key, context)
+
           if attributes.size > 0 && predicate
-            combinator = key.match(/_(or|and)_/) ? $1 : nil
             condition = self.new(context)
             condition.build(
               :a => attributes,
@@ -31,20 +32,34 @@ module Ransack
 
         private
 
-        def extract_attributes_and_predicate(key, context = nil)
-          str = key.dup
-          name = Predicate.detect_and_strip_from_string!(str)
-          predicate = Predicate.named(name)
-          unless predicate || Ransack.options[:ignore_unknown_conditions]
-            raise ArgumentError, "No valid predicate for #{key}"
-          end
-          if context.present? && context.attribute_method?(str)
-            attributes = [str]
-          else
-            attributes = str.split(/_and_|_or_/)
+          def extract_values_for_condition(key, context = nil)
+            str = key.dup
+            name = Predicate.detect_and_strip_from_string!(str)
+            predicate = Predicate.named(name)
+
+            unless predicate || Ransack.options[:ignore_unknown_conditions]
+              raise ArgumentError, "No valid predicate for #{key}"
+            end
+
+            if context.present?
+              str = context.ransackable_alias(str)
+            end
+
+            combinator =
+            if str.match(/_(or|and)_/)
+              $1
+            else
+              nil
+            end
+
+            if context.present? && context.attribute_method?(str)
+              attributes = [str]
+            else
+              attributes = str.split(/_and_|_or_/)
+            end
+
+            [attributes, predicate, combinator]
           end
-          [attributes, predicate]
-        end
       end
 
       def valid?
@@ -64,14 +79,12 @@ module Ransack
       def attributes=(args)
         case args
         when Array
-          args.each do |attr|
-            attr = Attribute.new(@context, attr)
-            self.attributes << attr if attr.valid?
+          args.each do |name|
+            build_attribute(name)
           end
         when Hash
           args.each do |index, attrs|
-            attr = Attribute.new(@context, attrs[:name], attrs[:ransacker_args])
-            self.attributes << attr if attr.valid?
+            build_attribute(attrs[:name], attrs[:ransacker_args])
           end
         else
           raise ArgumentError,
@@ -114,9 +127,32 @@ module Ransack
       alias :m= :combinator=
       alias :m :combinator
 
-      def build_attribute(name = nil)
-        Attribute.new(@context, name).tap do |attribute|
-          self.attributes << attribute
+
+      # == build_attribute
+      #
+      #  This method was originally called from Nodes::Grouping#new_condition
+      #  only, without arguments, without #valid? checking, to build a new
+      #  grouping condition.
+      #
+      #  After refactoring in 235eae3, it is now called from 2 places:
+      #
+      #  1. Nodes::Condition#attributes=, with +name+ argument passed or +name+
+      #     and +ransacker_args+. Attributes are included only if #valid?.
+      #
+      #  2. Nodes::Grouping#new_condition without arguments. In this case, the
+      #     #valid? conditional needs to be bypassed, otherwise nothing is
+      #     built. The `name.nil?` conditional below currently does this.
+      #
+      #  TODO: Add test coverage for this behavior and ensure that `name.nil?`
+      #  isn't fixing issue #701 by introducing untested regressions.
+      #
+      def build_attribute(name = nil, ransacker_args = [])
+        Attribute.new(@context, name, ransacker_args).tap do |attribute|
+          @context.bind(attribute, attribute.name)
+          self.attributes << attribute if name.nil? || attribute.valid?
+          if predicate && !negative?
+            @context.lock_association(attribute.parent)
+          end
         end
       end
 
@@ -168,6 +204,10 @@ module Ransack
 
       def predicate_name=(name)
         self.predicate = Predicate.named(name)
+        unless negative?
+          attributes.each { |a| context.lock_association(a.parent) }
+        end
+        @predicate
       end
       alias :p= :predicate_name=
 
@@ -196,20 +236,33 @@ module Ransack
           val = predicate.format(val)
           val
         end
-        predicate.wants_array ? formatted : formatted.first
+        if predicate.wants_array
+          formatted
+        else
+          formatted.first
+        end
       end
 
       def arel_predicate_for_attribute(attr)
         if predicate.arel_predicate === Proc
           values = casted_values_for_attribute(attr)
-          predicate.arel_predicate.call(
-            predicate.wants_array ? values : values.first
-            )
+          unless predicate.wants_array
+            values = values.first
+          end
+          predicate.arel_predicate.call(values)
         else
           predicate.arel_predicate
         end
       end
 
+      def attr_value_for_attribute(attr)
+        return attr.attr if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+
+        predicate.case_insensitive ? attr.attr.lower : attr.attr
+      rescue
+        attr.attr
+      end
+
 
       def default_type
         predicate.type || (attributes.first && attributes.first.type)
@@ -224,10 +277,14 @@ module Ransack
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Constants::COMMA_SPACE)
+        .join(', '.freeze)
         "Condition <#{data}>"
       end
 
+      def negative?
+        predicate.negative?
+      end
+
       private
 
       def valid_combinator?

data/lib/ransack/nodes/grouping.rb

@@ -44,16 +44,12 @@ module Ransack
             self.conditions << condition if condition.valid?
           end
         end
-        self.conditions.uniq!
+        remove_duplicate_conditions!
       end
       alias :c= :conditions=
 
       def [](key)
-        if condition = conditions.detect { |c| c.key == key.to_s }
-          condition
-        else
-          nil
-        end
+        conditions.detect { |c| c.key == key.to_s }
       end
 
       def []=(key, value)
@@ -68,7 +64,6 @@ module Ransack
       def respond_to?(method_id)
         super or begin
           method_name = method_id.to_s
-          writer = method_name.sub!(/\=$/, Constants::EMPTY)
           attribute_method?(method_name) ? true : false
         end
       end
@@ -113,8 +108,8 @@ module Ransack
       alias :g= :groupings=
 
       def method_missing(method_id, *args)
-        method_name = method_id.to_s
-        writer = method_name.sub!(/\=$/, Constants::EMPTY)
+        method_name = method_id.to_s.dup
+        writer = method_name.sub!(/\=$/, ''.freeze)
         if attribute_method?(method_name)
           if writer
             write_attribute(method_name, *args)
@@ -169,7 +164,7 @@ module Ransack
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Constants::COMMA_SPACE)
+        .join(', '.freeze)
         "Grouping <#{data}>"
       end
 
@@ -191,10 +186,21 @@ module Ransack
       end
 
       def strip_predicate_and_index(str)
-        string = str.split(/\(/).first
+        string = str[/(.+?)\(/, 1] || str.dup
         Predicate.detect_and_strip_from_string!(string)
         string
       end
+
+      def remove_duplicate_conditions!
+        # If self.conditions.uniq! is called without passing a block, then
+        # conditions differing only by ransacker_args within attributes are
+        # wrongly considered equal and are removed.
+        self.conditions.uniq! do |c|
+          c.attributes.map { |a| [a.name, a.ransacker_args] }.flatten +
+          [c.predicate.name] +
+          c.values.map { |v| v.value }
+        end
+      end
     end
   end
 end

data/lib/ransack/nodes/sort.rb

@@ -3,7 +3,7 @@ module Ransack
     class Sort < Node
       include Bindable
 
-      attr_reader :name, :dir
+      attr_reader :name, :dir, :ransacker_args
       i18n_word :asc, :desc
 
       class << self
@@ -16,7 +16,7 @@ module Ransack
 
       def build(params)
         params.with_indifferent_access.each do |key, value|
-          if key.match(/^(name|dir)$/)
+          if key.match(/^(name|dir|ransacker_args)$/)
             self.send("#{key}=", value)
           end
         end
@@ -32,19 +32,23 @@ module Ransack
 
       def name=(name)
         @name = name
-        context.bind(self, name) unless name.blank?
+        context.bind(self, name)
       end
 
       def dir=(dir)
         dir = dir.downcase if dir
         @dir =
-          if Constants::ASC_DESC.include?(dir)
+          if dir == 'asc'.freeze || dir == 'desc'.freeze
             dir
           else
-            Constants::ASC
+            'asc'.freeze
           end
       end
 
+      def ransacker_args=(ransack_args)
+        @ransacker_args = ransack_args
+      end
+
     end
   end
 end