ransack 2.1.1 → 2.3.0

data/lib/ransack/locale/es.yml

@@ -6,11 +6,11 @@ es:
     or: "o"
     any: "cualquier"
     all: "todos"
-    combinator: "combinado"
+    combinator: "combinador"
     attribute: "atributo"
     value: "valor"
     condition: "condición"
-    sort: "ordernar"
+    sort: "ordenar"
     asc: "ascendente"
     desc: "descendente"
     predicates:
@@ -19,12 +19,12 @@ es:
       eq_all: "es igual a todos"
       not_eq: "no es igual a"
       not_eq_any: "no es igual a cualquier"
-      not_eq_all: "no es iguala todos"
-      matches: "coincidir"
-      matches_any: "coincidir a cualquier"
-      matches_all: "coincidir a todos"
-      does_not_match: "no coincide"
-      does_not_match_any: "no coincide con ninguna"
+      not_eq_all: "no es igual a todos"
+      matches: "coincide con"
+      matches_any: "coincide con cualquier"
+      matches_all: "coincide con todos"
+      does_not_match: "no coincide con"
+      does_not_match_any: "no coincide con ninguno"
       does_not_match_all: "no coincide con todos"
       lt: "menor que"
       lt_any: "menor que cualquier"
@@ -48,23 +48,23 @@ es:
       cont_any: "contiene cualquier"
       cont_all: "contiene todos"
       not_cont: "no contiene"
-      not_cont_any: "no contiene ninguna"
-      not_cont_all: "no contiene toda"
+      not_cont_any: "no contiene ninguno"
+      not_cont_all: "no contiene todos"
       start: "comienza con"
       start_any: "comienza con cualquier"
-      start_all: "comienza con toda"
-      not_start: "no inicia con"
+      start_all: "comienza con todos"
+      not_start: "no comienza con"
       not_start_any: "no comienza con cualquier"
-      not_start_all: "no inicia con toda"
-      end: "termina con"
-      end_any: "termina con cualquier"
-      end_all: "termina con todo"
-      not_end: "no termina con"
-      not_end_any: "no termina con cualquier"
-      not_end_all: "no termina con todo"
+      not_start_all: "no comienza con todos"
+      end: "termina en"
+      end_any: "termina en cualquier"
+      end_all: "termina en todos"
+      not_end: "no termina en"
+      not_end_any: "no termina en cualquier"
+      not_end_all: "no termina en todos"
       'true': "es verdadero"
       'false': "es falso"
-      present: "es presente"
+      present: "está presente"
       blank: "está en blanco"
-      'null': "es nula"
-      not_null: "no es nula"
+      'null': "es nulo"
+      not_null: "no es nulo"

data/lib/ransack/locale/fa.yml

@@ -0,0 +1,70 @@
+fa:
+  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/fi.yml

@@ -0,0 +1,71 @@
+fi:
+  ransack:
+    search: "haku"
+    predicate: "predikaatti"
+    and: "ja"
+    or: "tai"
+    any: "jokin"
+    all: "kaikki"
+    combinator: "kombinaattori"
+    attribute: "attribuutti"
+    value: "arvo"
+    condition: "ehto"
+    sort: "järjestys"
+    asc: "nouseva"
+    desc: "laskeva"
+    predicates:
+      eq: "sama kuin"
+      eq_any: "sama kuin jokin"
+      eq_all: "sama kuin kaikki"
+      not_eq: "eri kuin"
+      not_eq_any: "eri kuin jokin"
+      not_eq_all: "eri kuin kaikki"
+      matches: "täsmää"
+      matches_any: "täsmää jonkun kanssa"
+      matches_all: "täsmää kaikkien kanssa"
+      does_not_match: "ei täsmää"
+      does_not_match_any: "ei täsmää minkään kanssa"
+      does_not_match_all: "ei täsmää kaikkien kanssa"
+      lt: "vähemmän kuin"
+      lt_any: "vähemmän kuin jokin"
+      lt_all: "vähemmän kuin mikään"
+      lteq: "vähemmän tai sama kuin"
+      lteq_any: "vähemmän tai sama kuin jokin"
+      lteq_all: "vähemmän tai sama kuin mikään"
+      gt: "suurempi kuin"
+      gt_any: "suurempi kuin jokin"
+      gt_all: "suurempi kuin mikään"
+      gteq: "suurempi tai yhtä suuri kuin"
+      gteq_any: "suurempi tai yhtä suuri kuin jokin"
+      gteq_all: "suurempi tai yhtä suuri kuin mikään"
+      in: "kohteessa"
+      in_any: "jossakin kohteessa"
+      in_all: "kaikissa kohteissa"
+      not_in: "ei kohteessa"
+      not_in_any: "ei jossakin kohteista"
+      not_in_all: "ei missään kohteista"
+      cont: "sisältää"
+      cont_any: "sisältää jonkin"
+      cont_all: "sisältää kaikki"
+      not_cont: "ei sisällä"
+      not_cont_any: "ei sisällä jotakin"
+      not_cont_all: "ei sisällä mitään"
+      start: "alkaa"
+      start_any: "alkaa jollakin"
+      start_all: "alkaa kaikilla"
+      not_start: "ei ala"
+      not_start_any: "ei ala jollakin"
+      not_start_all: "ei ala millään"
+      end: "päättyy"
+      end_any: "päättyy jollakin"
+      end_all: "päättyy millään"
+      not_end: "ei pääty"
+      not_end_any: "ei pääty jollakin"
+      not_end_all: "ei pääty millään"
+      'true': "on tosi"
+      'false': "ei ole tosi"
+      present: "on läsnä"
+      blank: "on tyhjä"
+      'null': "on määrittämätön"
+      not_null: "on määritetty"
+

data/lib/ransack/translate.rb

@@ -6,151 +6,151 @@ I18n.load_path += Dir[
 
 module Ransack
   module Translate
-    def self.word(key, options = {})
-      I18n.translate(:"ransack.#{key}", :default => key.to_s)
-    end
-
-    def self.predicate(key, options = {})
-      I18n.translate(:"ransack.predicates.#{key}", :default => key.to_s)
-    end
-
-    def self.attribute(key, options = {})
-      unless context = options.delete(:context)
-        raise ArgumentError, "A context is required to translate attributes"
+    class << self
+      def word(key, options = {})
+        I18n.translate(:"ransack.#{key}", default: key.to_s)
       end
 
-      original_name = key.to_s
-      base_class = context.klass
-      base_ancestors = base_class.ancestors.select {
-        |x| x.respond_to?(:model_name)
-      }
-      attributes_str = original_name.dup # will be modified by ⬇
-      predicate = Predicate.detect_and_strip_from_string!(attributes_str)
-      attribute_names = attributes_str.split(/_and_|_or_/)
-      combinator = attributes_str.match(/_and_/) ? :and : :or
-      defaults = base_ancestors.map do |klass|
-        "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
+      def predicate(key, options = {})
+        I18n.translate(:"ransack.predicates.#{key}", default: key.to_s)
       end
 
-      translated_names = attribute_names.map do |name|
-        attribute_name(context, name, options[:include_associations])
-      end
+      def attribute(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate attributes"
+        end
 
-      interpolations = {
-        :attributes => translated_names.join(" #{Translate.word(combinator)} ")
-      }
+        original_name = key.to_s
+        base_class = context.klass
+        base_ancestors = base_class.ancestors.select {
+          |x| x.respond_to?(:model_name)
+        }
+        attributes_str = original_name.dup # will be modified by ⬇
+        predicate = Predicate.detect_and_strip_from_string!(attributes_str)
+        attribute_names = attributes_str.split(/_and_|_or_/)
+        combinator = attributes_str =~ /_and_/ ? :and : :or
+        defaults = base_ancestors.map do |klass|
+          "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
+        end
 
-      if predicate
-        defaults << "%{attributes} %{predicate}".freeze
-        interpolations[:predicate] = Translate.predicate(predicate)
-      else
-        defaults << "%{attributes}".freeze
-      end
+        translated_names = attribute_names.map do |name|
+          attribute_name(context, name, options[:include_associations])
+        end
 
-      defaults << options.delete(:default) if options[:default]
-      options.reverse_merge! :count => 1, :default => defaults
-      I18n.translate(defaults.shift, options.merge(interpolations))
-    end
+        interpolations = {
+          attributes: translated_names.join(" #{Translate.word(combinator)} ")
+        }
 
-    def self.association(key, options = {})
-      unless context = options.delete(:context)
-        raise ArgumentError, "A context is required to translate associations"
+        if predicate
+          defaults << "%{attributes} %{predicate}".freeze
+          interpolations[:predicate] = Translate.predicate(predicate)
+        else
+          defaults << "%{attributes}".freeze
+        end
+
+        defaults << options.delete(:default) if options[:default]
+        options.reverse_merge! count: 1, default: defaults
+        I18n.translate(defaults.shift, options.merge(interpolations))
       end
 
-      defaults =
-        if key.blank?
-          [:"ransack.models.#{i18n_key(context.klass)}",
-           :"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"]
-        else
-          [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+      def association(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate associations"
         end
-      defaults << context.traverse(key).model_name.human
-      options = { :count => 1, :default => defaults }
-      I18n.translate(defaults.shift, options)
-    end
 
-  private
+        defaults =
+          if key.blank?
+            [:"ransack.models.#{i18n_key(context.klass)}",
+             :"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"]
+          else
+            [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+          end
+        defaults << context.traverse(key).model_name.human
+        options = { :count => 1, :default => defaults }
+        I18n.translate(defaults.shift, options)
+      end
 
-    def self.attribute_name(context, name, include_associations = nil)
-      @context, @name = context, name
-      @assoc_path = context.association_path(name)
-      @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
-      associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
-      @include_associated = include_associations && associated_class
+      private
 
-      defaults = default_attribute_name << fallback_args
-      options = { :count => 1, :default => defaults }
-      interpolations = build_interpolations(associated_class)
+      def attribute_name(context, name, include_associations = nil)
+        @context, @name = context, name
+        @assoc_path = context.association_path(name)
+        @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
+        associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
+        @include_associated = include_associations && associated_class
 
-      I18n.translate(defaults.shift, options.merge(interpolations))
-    end
+        defaults = default_attribute_name << fallback_args
+        options = { count: 1, default: defaults }
+        interpolations = build_interpolations(associated_class)
 
-    def self.default_attribute_name
-      ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
-    end
+        I18n.translate(defaults.shift, options.merge(interpolations))
+      end
 
-    def self.fallback_args
-      if @include_associated
-        '%{association_name} %{attr_fallback_name}'.freeze
-      else
-        '%{attr_fallback_name}'.freeze
+      def default_attribute_name
+        ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
       end
-    end
 
-    def self.build_interpolations(associated_class)
-      {
-        :attr_fallback_name => attr_fallback_name(associated_class),
-        :association_name   => association_name
-      }
-      .reject { |_, value| value.nil? }
-    end
+      def fallback_args
+        if @include_associated
+          '%{association_name} %{attr_fallback_name}'.freeze
+        else
+          '%{attr_fallback_name}'.freeze
+        end
+      end
 
-    def self.attr_fallback_name(associated_class)
-      I18n.t(
-        :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
-        :default => default_interpolation(associated_class)
+      def build_interpolations(associated_class)
+        {
+          attr_fallback_name: attr_fallback_name(associated_class),
+          association_name: association_name
+        }.reject { |_, value| value.nil? }
+      end
+
+      def attr_fallback_name(associated_class)
+        I18n.t(
+          :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
+          default: default_interpolation(associated_class)
         )
-    end
+      end
 
-    def self.fallback_class(associated_class)
-      i18n_key(associated_class || @context.klass)
-    end
+      def fallback_class(associated_class)
+        i18n_key(associated_class || @context.klass)
+      end
 
-    def self.association_name
-      association(@assoc_path, :context => @context) if @include_associated
-    end
+      def association_name
+        association(@assoc_path, context: @context) if @include_associated
+      end
 
-    def self.default_interpolation(associated_class)
-      [
-        associated_attribute(associated_class),
-        ".attributes.#{@attr_name}".to_sym,
-        @attr_name.humanize
-      ]
-      .flatten
-    end
+      def default_interpolation(associated_class)
+        [
+          associated_attribute(associated_class),
+          ".attributes.#{@attr_name}".to_sym,
+          @attr_name.humanize
+        ].flatten
+      end
 
-    def self.associated_attribute(associated_class)
-      if associated_class
-        translated_attribute(associated_class)
-      else
-        translated_ancestor_attributes
+      def associated_attribute(associated_class)
+        if associated_class
+          translated_attribute(associated_class)
+        else
+          translated_ancestor_attributes
+        end
       end
-    end
 
-    def self.translated_attribute(associated_class)
-      key = "#{associated_class.i18n_scope}.attributes.#{
+      def translated_attribute(associated_class)
+        key = "#{associated_class.i18n_scope}.attributes.#{
         i18n_key(associated_class)}.#{@attr_name}"
-      ["#{key}.one".to_sym, key.to_sym]
-    end
+        ["#{key}.one".to_sym, key.to_sym]
+      end
 
-    def self.translated_ancestor_attributes
-      @context.klass.ancestors
-      .select { |ancestor| ancestor.respond_to?(:model_name) }
-      .map { |ancestor| translated_attribute(ancestor) }
-    end
+      def translated_ancestor_attributes
+        @context.klass.ancestors
+          .select { |ancestor| ancestor.respond_to?(:model_name) }
+          .map { |ancestor| translated_attribute(ancestor) }
+      end
 
-    def self.i18n_key(klass)
-      raise "not implemented"
+      def i18n_key(klass)
+        raise "not implemented"
+      end
     end
   end
 end