mini-fast-sys 0.0.1

data/ransack-4.4.1/lib/ransack/helpers/form_helper.rb

@@ -0,0 +1,311 @@
+module Ransack
+  module Helpers
+    module FormHelper
+
+      # +search_form_for+
+      #
+      #   <%= search_form_for(@q) do |f| %>
+      #
+      def search_form_for(record, options = {}, &proc)
+        search = extract_search_and_set_url(record, options, 'search_form_for')
+        options[:html] ||= {}
+        html_options = build_html_options(search, options, :get)
+        finalize_form_options(options, html_options)
+        form_for(record, options, &proc)
+      end
+
+      # +search_form_with+
+      #
+      #   <%= search_form_with(model: @q) do |f| %>
+      #
+      def search_form_with(record_or_options = {}, options = {}, &proc)
+        if record_or_options.is_a?(Hash) && record_or_options.key?(:model)
+          # Called with keyword arguments: search_form_with(model: @q)
+          options = record_or_options
+          record = options.delete(:model)
+        else
+          # Called with positional arguments: search_form_with(@q)
+          record = record_or_options
+        end
+        search = extract_search_and_set_url(record, options, 'search_form_with')
+        options[:html] ||= {}
+        html_options = build_html_options(search, options, :get)
+        finalize_form_with_options(options, html_options)
+        form_with(model: search, **options, &proc)
+      end
+
+      # +turbo_search_form_for+
+      #
+      #   <%= turbo_search_form_for(@q) do |f| %>
+      #
+      # This is a turbo-enabled version of search_form_for that submits via turbo streams
+      # instead of traditional HTML GET requests. Useful for seamless integration with
+      # paginated results and other turbo-enabled components.
+      #
+      def turbo_search_form_for(record, options = {}, &proc)
+        search = extract_search_and_set_url(record, options, 'turbo_search_form_for')
+        options[:html] ||= {}
+        turbo_options = build_turbo_options(options)
+        method = options.delete(:method) || :post
+        html_options = build_html_options(search, options, method).merge(turbo_options)
+        finalize_form_options(options, html_options)
+        form_for(record, options, &proc)
+      end
+
+      # +sort_link+
+      #
+      #   <%= sort_link(@q, :name, [:name, 'kind ASC'], 'Player Name') %>
+      #
+      #   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
+        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 extract_search_and_set_url(record, options, method_name)
+          if record.is_a? Ransack::Search
+            search = record
+            options[:url] ||= polymorphic_path(
+              search.klass, format: options.delete(:format)
+            )
+            search
+          elsif record.is_a?(Array) &&
+          (search = record.detect { |o| o.is_a?(Ransack::Search) })
+            options[:url] ||= polymorphic_path(
+              options_for(record), format: options.delete(:format)
+            )
+            search
+          else
+            raise ArgumentError,
+            "No Ransack::Search object was provided to #{method_name}!"
+          end
+        end
+
+        def build_turbo_options(options)
+          data_options = {}
+          if options[:turbo_frame]
+            data_options[:turbo_frame] = options.delete(:turbo_frame)
+          end
+          data_options[:turbo_action] = options.delete(:turbo_action) || 'advance'
+          { data: data_options }
+        end
+
+        def build_html_options(search, options, method)
+          {
+            class:  html_option_for(options[:class], search),
+            id:     html_option_for(options[:id], search),
+            method: method
+          }
+        end
+
+        def finalize_form_options(options, html_options)
+          options[:as] ||= Ransack.options[:search_key]
+          options[:html].reverse_merge!(html_options)
+          options[:builder] ||= FormBuilder
+        end
+
+        def finalize_form_with_options(options, html_options)
+          options[:scope] ||= Ransack.options[:search_key]
+          options[:html].reverse_merge!(html_options)
+          options[:builder] ||= FormBuilder
+        end
+
+        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)
+          return [search[1], search[0]] if search.is_a?(Array)
+          [search, nil]
+        end
+
+        def url(routing_proxy, options_for_url)
+          if routing_proxy && respond_to?(routing_proxy)
+            send(routing_proxy).url_for(options_for_url)
+          else
+            url_for(options_for_url)
+          end
+        end
+
+      class SortLink
+        def initialize(search, attribute, args, params)
+          @search         = search
+          @params         = parameters_hash(params)
+          @field          = attribute.to_s
+          @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) ||
+                            Ransack.options[:hide_sort_order_indicators]
+          @default_order  = @options.delete :default_order
+        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('&nbsp;'.freeze)
+          .html_safe
+        end
+
+        def url_options
+          @params.except(:host).merge(
+            @options.except(:class, :data, :host).merge(
+              @search.context.search_key => search_and_sort_params))
+        end
+
+        def html_options(args)
+          if args.empty?
+            html_options = @options
+          else
+            deprecation_message = "Passing two trailing hashes to `sort_link` is deprecated, merge the trailing hashes into a single one."
+            caller_location = caller_locations(2, 2).first
+            warn "#{deprecation_message} (called at #{caller_location.path}:#{caller_location.lineno})"
+            html_options = extract_options_and_mutate_args!(args)
+          end
+
+          html_options.merge(
+            class: [['sort_link'.freeze, @current_dir], html_options[:class]]
+                   .compact.join(' '.freeze)
+          )
+        end
+
+        private
+
+          def parameters_hash(params)
+            if params.respond_to?(:to_unsafe_h)
+              params.to_unsafe_h
+            else
+              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)
+            return args.shift if args[0].is_a?(String)
+            Translate.attribute(@field, context: @search.context)
+          end
+
+          def extract_options_and_mutate_args!(args)
+            return args.shift.with_indifferent_access if args[0].is_a?(Hash)
+            {}
+          end
+
+          def search_and_sort_params
+            search_params.merge(s: sort_params)
+          end
+
+          def search_params
+            query_params = @params[@search.context.search_key]
+            query_params.is_a?(Hash) ? query_params : {}
+          end
+
+          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])] + recursive_sort_params_build(fields.drop 1)
+          end
+
+          def parse_sort(field)
+            attr_name, new_dir = field.to_s.split(/\s+/)
+            if no_sort_direction_specified?(new_dir)
+              new_dir = detect_previous_sort_direction_and_invert_it(attr_name)
+            end
+            "#{attr_name} #{new_dir}"
+          end
+
+          def detect_previous_sort_direction_and_invert_it(attr_name)
+            if sort_dir = existing_sort_direction(attr_name)
+              direction_text(sort_dir)
+            else
+              default_sort_order(attr_name) || 'asc'.freeze
+            end
+          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)
+            return @default_order[attr_name] if Hash === @default_order
+            @default_order
+          end
+
+          def order_indicator
+            return if @hide_indicator
+            return default_arrow if no_sort_direction_specified?
+            if @current_dir == 'desc'.freeze
+              up_arrow
+            else
+              down_arrow
+            end
+          end
+
+          def no_sort_direction_specified?(dir = @current_dir)
+            dir != 'asc'.freeze && dir != 'desc'.freeze
+          end
+
+          def direction_text(dir)
+            return 'asc'.freeze if dir == 'desc'.freeze
+            'desc'.freeze
+          end
+      end
+    end
+  end
+end

data/ransack-4.4.1/lib/ransack/helpers.rb

@@ -0,0 +1,2 @@
+require 'ransack/helpers/form_builder'
+require 'ransack/helpers/form_helper'

data/ransack-4.4.1/lib/ransack/invalid_search_error.rb

@@ -0,0 +1,3 @@
+module Ransack
+  class InvalidSearchError < ArgumentError; end
+end

data/ransack-4.4.1/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/ransack-4.4.1/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/ransack-4.4.1/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/ransack-4.4.1/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/ransack-4.4.1/lib/ransack/locale/cs.yml

@@ -0,0 +1,70 @@
+cs:
+  ransack:
+    search: "vyhledávání"
+    predicate: "predikát"
+    and: "a"
+    or: "nebo"
+    any: "kteroukoliv"
+    all: "každou"
+    combinator: "kombinátor"
+    attribute: "atribut"
+    value: "hodnota"
+    condition: "podmínka"
+    sort: "řazení"
+    asc: "vzestupné"
+    desc: "sestupné"
+    predicates:
+      eq: "rovno"
+      eq_any: "rovno kterékoliv"
+      eq_all: "rovno všem"
+      not_eq: "nerovno"
+      not_eq_any: "nerovno kterékoliv"
+      not_eq_all: "nerovno všem"
+      matches: "odpovídá"
+      matches_any: "odpovídá kterékoliv"
+      matches_all: "odpovídá všem"
+      does_not_match: "neodpovídá"
+      does_not_match_any: "neodpovídá kterékoliv"
+      does_not_match_all: "neodpovídá všem"
+      lt: "menší než"
+      lt_any: "menší než kterákoliv"
+      lt_all: "menší než všechny"
+      lteq: "menší nebo rovno než"
+      lteq_any: "menší nebo rovno než kterákoliv"
+      lteq_all: "menší nebo rovno než všechny"
+      gt: "větší než"
+      gt_any: "větší než kterákoliv"
+      gt_all: "větší než všechny"
+      gteq: "větší nebo rovno než"
+      gteq_any: "větší nebo rovno než kterákoliv"
+      gteq_all: "větší nebo rovno než všechny"
+      in: "v"
+      in_any: "v kterékoliv"
+      in_all: "ve všech"
+      not_in: "není v"
+      not_in_any: "není v kterékoliv"
+      not_in_all: "není ve všech"
+      cont: "obsahuje"
+      cont_any: "obsahuje kterékoliv"
+      cont_all: "obsahuje všechny"
+      not_cont: "neobsahuje"
+      not_cont_any: "neobsahuje kteroukoliv"
+      not_cont_all: "neobsahuje všechny"
+      start: "začíná s"
+      start_any: "začíná s kteroukoliv"
+      start_all: "začíná se všemi"
+      not_start: "nezačíná s"
+      not_start_any: "nezačíná s kteroukoliv"
+      not_start_all: "nezačíná se všemi"
+      end: "končí s"
+      end_any: "končí s kteroukoliv"
+      end_all: "končí se všemi"
+      not_end: "nekončí s"
+      not_end_any: "nekončí s kteroukoliv"
+      not_end_all: "nekončí se všemi"
+      'true': "je pravdivé"
+      'false': "není pravdivé"
+      present: "je vyplněné"
+      blank: "je prázdné"
+      'null': "je null"
+      not_null: "není null"