ransack 1.6.6 → 2.4.0

data/lib/ransack/helpers/form_helper.rb

@@ -15,8 +15,7 @@ module Ransack
         elsif record.is_a?(Array) &&
         (search = record.detect { |o| o.is_a?(Ransack::Search) })
           options[:url] ||= polymorphic_path(
-            record.map { |o| o.is_a?(Ransack::Search) ? o.klass : o },
-            format: options.delete(:format)
+            options_for(record), format: options.delete(:format)
             )
         else
           raise ArgumentError,
@@ -24,13 +23,9 @@ module Ransack
         end
         options[:html] ||= {}
         html_options = {
-          :class => options[:class].present? ?
-            "#{options[:class]}" :
-            "#{search.klass.to_s.underscore}_search",
-          :id => options[:id].present? ?
-            "#{options[:id]}" :
-            "#{search.klass.to_s.underscore}_search",
-          :method => :get
+          class:  html_option_for(options[:class], search),
+          id:     html_option_for(options[:id], search),
+          method: :get
         }
         options[:as] ||= Ransack.options[:search_key]
         options[:html].reverse_merge!(html_options)
@@ -43,23 +38,53 @@ module Ransack
       #
       #   <%= sort_link(@q, :name, [:name, 'kind ASC'], 'Player Name') %>
       #
-      def sort_link(search_object, attribute, *args)
+      #   You can also use a block:
+      #
+      #   <%= sort_link(@q, :name, [:name, 'kind ASC']) do %>
+      #     <strong>Player Name</strong>
+      #   <% end %>
+      #
+      def sort_link(search_object, attribute, *args, &block)
         search, routing_proxy = extract_search_and_routing_proxy(search_object)
         unless Search === search
           raise TypeError, 'First argument must be a Ransack::Search!'
         end
-        s = SortLink.new(search, attribute, args, params)
+        args[args.first.is_a?(Array) ? 1 : 0, 0] = capture(&block) if block_given?
+        s = SortLink.new(search, attribute, args, params, &block)
         link_to(s.name, url(routing_proxy, s.url_options), s.html_options(args))
       end
 
+      # +sort_url+
+      # <%= sort_url(@q, :created_at, default_order: :desc) %>
+      #
+      def sort_url(search_object, attribute, *args)
+        search, routing_proxy = extract_search_and_routing_proxy(search_object)
+        unless Search === search
+          raise TypeError, 'First argument must be a Ransack::Search!'
+        end
+        s = SortLink.new(search, attribute, args, params)
+        url(routing_proxy, s.url_options)
+      end
+
       private
 
+        def options_for(record)
+          record.map { |r| parse_record(r) }
+        end
+
+        def parse_record(object)
+          return object.klass if object.is_a?(Ransack::Search)
+          object
+        end
+
+        def html_option_for(option, search)
+          return option.to_s if option.present?
+          "#{search.klass.to_s.underscore}_search"
+        end
+
         def extract_search_and_routing_proxy(search)
-          if search.is_a? Array
-            [search.second, search.first]
-          else
-            [search, nil]
-          end
+          return [search[1], search[0]] if search.is_a?(Array)
+          [search, nil]
         end
 
         def url(routing_proxy, options_for_url)
@@ -73,22 +98,33 @@ module Ransack
       class SortLink
         def initialize(search, attribute, args, params)
           @search         = search
-          @params         = params
+          @params         = parameters_hash(params)
           @field          = attribute.to_s
-          sort_fields     = extract_sort_fields_and_mutate_args!(args).compact
+          @sort_fields    = extract_sort_fields_and_mutate_args!(args).compact
           @current_dir    = existing_sort_direction
           @label_text     = extract_label_and_mutate_args!(args)
           @options        = extract_options_and_mutate_args!(args)
-          @hide_indicator = @options.delete :hide_indicator
+          @hide_indicator = @options.delete(:hide_indicator) ||
+                            Ransack.options[:hide_sort_order_indicators]
           @default_order  = @options.delete :default_order
-          @sort_params    = build_sort(sort_fields)
-          @sort_params    = @sort_params.first if @sort_params.size == 1
+        end
+
+        def up_arrow
+          Ransack.options[:up_arrow]
+        end
+
+        def down_arrow
+          Ransack.options[:down_arrow]
+        end
+
+        def default_arrow
+          Ransack.options[:default_arrow]
         end
 
         def name
           [ERB::Util.h(@label_text), order_indicator]
           .compact
-          .join(Constants::NON_BREAKING_SPACE)
+          .join('&nbsp;'.freeze)
           .html_safe
         end
 
@@ -100,49 +136,54 @@ module Ransack
 
         def html_options(args)
           html_options = extract_options_and_mutate_args!(args)
-          html_options.merge(class:
-            [[Constants::SORT_LINK, @current_dir], html_options[:class]]
-            .compact.join(Constants::SPACE)
-            )
+          html_options.merge(
+            class: [['sort_link'.freeze, @current_dir], html_options[:class]]
+                   .compact.join(' '.freeze)
+          )
         end
 
         private
 
-          def extract_sort_fields_and_mutate_args!(args)
-            if args.first.is_a? Array
-              args.shift
+          def parameters_hash(params)
+            if ::ActiveRecord::VERSION::MAJOR >= 5 && params.respond_to?(:to_unsafe_h)
+              params.to_unsafe_h
             else
-              [@field]
+              params
             end
           end
 
+          def extract_sort_fields_and_mutate_args!(args)
+            return args.shift if args[0].is_a?(Array)
+            [@field]
+          end
+
           def extract_label_and_mutate_args!(args)
-            if args.first.is_a? String
-              args.shift
-            else
-              Translate.attribute(@field, :context => @search.context)
-            end
+            return args.shift if args[0].is_a?(String)
+            Translate.attribute(@field, context: @search.context)
           end
 
           def extract_options_and_mutate_args!(args)
-            if args.first.is_a? Hash
-              args.shift.with_indifferent_access
-            else
-              {}
-            end
+            return args.shift.with_indifferent_access if args[0].is_a?(Hash)
+            {}
           end
 
           def search_and_sort_params
-            search_params.merge(:s => @sort_params)
+            search_params.merge(s: sort_params)
           end
 
           def search_params
             @params[@search.context.search_key].presence || {}
           end
 
-          def build_sort(fields)
+          def sort_params
+            sort_array = recursive_sort_params_build(@sort_fields)
+            return sort_array[0] if sort_array.length == 1
+            sort_array
+          end
+
+          def recursive_sort_params_build(fields)
             return [] if fields.empty?
-            [parse_sort(fields[0])] + build_sort(fields.drop(1))
+            [parse_sort(fields[0])] + recursive_sort_params_build(fields.drop 1)
           end
 
           def parse_sort(field)
@@ -154,52 +195,41 @@ module Ransack
           end
 
           def detect_previous_sort_direction_and_invert_it(attr_name)
-            sort_dir = existing_sort_direction(attr_name)
-            if sort_dir
+            if sort_dir = existing_sort_direction(attr_name)
               direction_text(sort_dir)
             else
-              default_sort_order(attr_name) || Constants::ASC
+              default_sort_order(attr_name) || 'asc'.freeze
             end
           end
 
-          def existing_sort_direction(attr_name = @field)
-            if sort = @search.sorts.detect { |s| s && s.name == attr_name }
-              sort.dir
-            end
+          def existing_sort_direction(f = @field)
+            return unless sort = @search.sorts.detect { |s| s && s.name == f }
+            sort.dir
           end
 
           def default_sort_order(attr_name)
-            Hash === @default_order ? @default_order[attr_name] : @default_order
+            return @default_order[attr_name] if Hash === @default_order
+            @default_order
           end
 
           def order_indicator
-            if @hide_indicator || no_sort_direction_specified?
-              nil
+            return if @hide_indicator
+            return default_arrow if no_sort_direction_specified?
+            if @current_dir == 'desc'.freeze
+              up_arrow
             else
-              direction_arrow
+              down_arrow
             end
           end
 
           def no_sort_direction_specified?(dir = @current_dir)
-            !Constants::ASC_DESC.include?(dir)
-          end
-
-          def direction_arrow
-            if @current_dir == Constants::DESC
-              Constants::DESC_ARROW
-            else
-              Constants::ASC_ARROW
-            end
+            dir != 'asc'.freeze && dir != 'desc'.freeze
           end
 
           def direction_text(dir)
-            if dir == Constants::DESC
-              Constants::ASC
-            else
-              Constants::DESC
-            end
+            return 'asc'.freeze if dir == 'desc'.freeze
+            'desc'.freeze
           end
-
       end
     end
   end

data/lib/ransack/locale/ar.yml

@@ -0,0 +1,70 @@
+ar:
+  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': "عدم"
+      not_null: "غير مساو لقيمة عدم"

data/lib/ransack/locale/az.yml

@@ -0,0 +1,70 @@
+az:
+  ransack:
+    search: "axtar"
+    predicate: "təsdiqlə"
+    and: "və"
+    or: "və ya"
+    any: "hər hansı"
+    all: "hamısı"
+    combinator: "birləşdirici"
+    attribute: "xüsusiyyət"
+    value: "dəyər"
+    condition: "şərt"
+    sort: "sırala"
+    asc: "artan"
+    desc: "azalan"
+    predicates:
+      eq: "bərabər"
+      eq_any: "hər hansı birinə bərabər"
+      eq_all: "hamısına bərabər"
+      not_eq: "bərabər deyil"
+      not_eq_any: "hər hansı birinə bərabər deyil"
+      not_eq_all: "heç birinə bərabər deyil"
+      matches: "uyğunlaşan"
+      matches_any: "hər hansı biri ilə uyğunlaşan"
+      matches_all: "hamısı ilə uyğunlaşan"
+      does_not_match: "uyğunlaşmayan"
+      does_not_match_any: "hər hansı biri ilə uyğunlaşmayan"
+      does_not_match_all: "heç biri ilə uyğunlaşmayan"
+      lt: "daha kiçik"
+      lt_any: "hər hansı birindən kiçik"
+      lt_all: "hamısından kiçik"
+      lteq: "daha kiçik və ya bərabər"
+      lteq_any: "daha kiçik və ya hər hansı birinə bərabər"
+      lteq_all: "daha kiçik və ya hamısına bərabər"
+      gt: "daha böyük "
+      gt_any: "hər hansı birindən daha böyük"
+      gt_all: "hamısından daha böyük"
+      gteq: "daha böyük və ya bərabər"
+      gteq_any: "daha böyük və ya hər hansı birine bərabər"
+      gteq_all: "daha böyük və ya hamısıne bərabər"
+      in: "içində"
+      in_any: "hər hansı birində"
+      in_all: "hamısında"
+      not_in: "içində deyil"
+      not_in_any: "hər hansı birində deyil"
+      not_in_all: "heç birində deyil"
+      cont: "ehtiva edən"
+      cont_any: "hər hansı birini ehtiva edən"
+      cont_all: "hamısını ehtiva edən"
+      not_cont: "ehtiva etməyən"
+      not_cont_any: "hər hansı birini ehtiva etməyən"
+      not_cont_all: "heç birini birini ehtiva etməyən"
+      start: "ilə başlayan"
+      start_any: "hər hansı biri ilə başlayan"
+      start_all: "hamısı ilə başlayan"
+      not_start: "ilə başlamayan"
+      not_start_any: "hər hansı biri ilə başlamayan"
+      not_start_all: "hiçbiri ilə başlamayan"
+      end: "ilə bitən"
+      end_any: "hər hansı biri ilə bitən"
+      end_all: "hamısı ilə bitən"
+      not_end: "ilə bitməyən"
+      not_end_any: "hər hansı biri ilə bitməyən"
+      not_end_all: "heç biri ilə bitməyən"
+      'true': "doğru"
+      'false': "yanlış"
+      present: "mövcüd"
+      blank: "boş"
+      'null': "keçərsiz"
+      not_null: "keçərli"

data/lib/ransack/locale/bg.yml

@@ -0,0 +1,70 @@
+bg:
+  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': "е нула"
+      not_null: "не е нула"

data/lib/ransack/locale/ca.yml

@@ -0,0 +1,70 @@
+ca:
+  ransack:
+    search: "cercar"
+    predicate: "predicat"
+    and: "i"
+    or: "o"
+    any: "qualsevol"
+    all: "tots"
+    combinator: "combinador"
+    attribute: "atribut"
+    value: "valor"
+    condition: "condició"
+    sort: "ordenar"
+    asc: "ascendent"
+    desc: "descendent"
+    predicates:
+      eq: "és igual a"
+      eq_any: "és igual a qualsevol"
+      eq_all: "és igual a tots"
+      not_eq: "no és igual a"
+      not_eq_any: "no és igual a qualsevol"
+      not_eq_all: "no és igual a tots"
+      matches: "coincideix"
+      matches_any: "coincideix a qualsevol"
+      matches_all: "coincideix a tots"
+      does_not_match: "no coincideix"
+      does_not_match_any: "no coincideix amb cap"
+      does_not_match_all: "no coincideix amb tots"
+      lt: "menor que"
+      lt_any: "menor que qualsevol"
+      lt_all: "menor o igual a"
+      lteq: "menor que o igual a"
+      lteq_any: "menor o igual a qualsevol"
+      lteq_all: "menor o igual a tots"
+      gt: "major que"
+      gt_any: "major que qualsevol"
+      gt_all: "major que tots"
+      gteq: "major que o igual a"
+      gteq_any: "major que o igual a qualsevol"
+      gteq_all: "major que o igual a tots"
+      in: "en"
+      in_any: "en qualsevol"
+      in_all: "en tots"
+      not_in: "no en"
+      not_in_any: "no en qualsevol"
+      not_in_all: "no en tots"
+      cont: "conté"
+      cont_any: "conté qualsevol"
+      cont_all: "conté tots"
+      not_cont: "no conté"
+      not_cont_any: "no conté cap"
+      not_cont_all: "no conté tota"
+      start: "comença per"
+      start_any: "comença per qualsevol"
+      start_all: "comença per tot"
+      not_start: "no comença per"
+      not_start_any: "no comença per qualsevol"
+      not_start_all: "no comença per tot"
+      end: "acaba en"
+      end_any: "acaba en qualsevol"
+      end_all: "acaba en tot"
+      not_end: "no acaba en"
+      not_end_any: "no acaba en qualsevol"
+      not_end_all: "no acaba en tot"
+      'true': "és verdader"
+      'false': "és fals"
+      present: "és present"
+      blank: "està en blanc"
+      'null': "és nul"
+      not_null: "no és nul"

data/lib/ransack/locale/da.yml

@@ -0,0 +1,70 @@
+da:
+  ransack:
+    search: "søg"
+    predicate: "predicate"
+    and: "og"
+    or: "eller"
+    any: "anhver"
+    all: "alle"
+    combinator: "kombinering"
+    attribute: "attribut"
+    value: "værdi"
+    condition: "betingelse"
+    sort: "sorter"
+    asc: "opstigende"
+    desc: "faldende"
+    predicates:
+      eq: "lig med"
+      eq_any: "lig med enhver"
+      eq_all: "lig med alle"
+      not_eq: "ikke lig med"
+      not_eq_any: "ikke lig med nogen"
+      not_eq_all: "ikke lig med alle"
+      matches: "matcher"
+      matches_any: "matcher enhver"
+      matches_all: "matcher alle"
+      does_not_match: "matcher ikke"
+      does_not_match_any: "matcher ikke nogen"
+      does_not_match_all: "matcher ikke alle"
+      lt: "mindre end"
+      lt_any: "mindre end nogen"
+      lt_all: "mindre end alle"
+      lteq: "mindre end eller lig med"
+      lteq_any: "mindre end eller lig med nogen"
+      lteq_all: "mindre end eller lig med alle"
+      gt: "større end"
+      gt_any: "større end nogen"
+      gt_all: "større end alle"
+      gteq: "større end eller lig med"
+      gteq_any: "større end eller lig med nogen"
+      gteq_all: "større end eller lig med alle"
+      in: "i"
+      in_any: "i nogen"
+      in_all: "i alle"
+      not_in: "ikke i"
+      not_in_any: "ikke i nogen"
+      not_in_all: "ikke i alle"
+      cont: "indeholder"
+      cont_any: "indeholder nogen"
+      cont_all: "indeholder alle"
+      not_cont: "indeholder ikke"
+      not_cont_any: "indeholder ikke nogen"
+      not_cont_all: "indeholder ikke alle"
+      start: "starter med"
+      start_any: "starter med nogen"
+      start_all: "starter med alle"
+      not_start: "starter ikke med"
+      not_start_any: "starter ikke med nogen"
+      not_start_all: "starter ikke med alle"
+      end: "slutter med"
+      end_any: "slutter med nogen"
+      end_all: "slutter med alle"
+      not_end: "slutter ikke med"
+      not_end_any: "slutter ikke med nogen"
+      not_end_all: "slutter ikke med alle"
+      'true': "er sand"
+      'false': "er falsk"
+      present: "er til stede"
+      blank: "er blank"
+      'null': "er nul"
+      not_null: "er ikke nul"