giga-pure-kit 0.0.1

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

@@ -0,0 +1,277 @@
+require 'action_view'
+
+module ActionView::Helpers::Tags
+  # TODO: Find a better way to solve this issue!
+  # This patch is needed since this Rails commit:
+  # https://github.com/rails/rails/commit/c1a118a
+  class Base
+    private
+
+    def value
+      if @allow_method_names_outside_object
+        object.send @method_name if object && object.respond_to?(@method_name, true)
+      else
+        object.send @method_name if object
+      end
+    end
+  end
+end
+
+RANSACK_FORM_BUILDER = 'RANSACK_FORM_BUILDER'.freeze
+
+require 'simple_form' if
+  (ENV[RANSACK_FORM_BUILDER] || ''.freeze).match('SimpleForm'.freeze)
+
+module Ransack
+  module Helpers
+    class FormBuilder < (ENV[RANSACK_FORM_BUILDER].try(:constantize) ||
+      ActionView::Helpers::FormBuilder)
+
+      def label(method, *args, &block)
+        options = args.extract_options!
+        text = args.first
+        i18n = options[:i18n] || {}
+        text ||= object.translate(
+          method, i18n.reverse_merge(include_associations: true)
+          ) if object.respond_to? :translate
+        super(method, text, options, &block)
+      end
+
+      def submit(value = nil, options = {})
+        value, options = nil, value if value.is_a?(Hash)
+        value ||= Translate.word(:search).titleize
+        super(value, options)
+      end
+
+      def attribute_select(options = nil, html_options = nil, action = nil)
+        options ||= {}
+        html_options ||= {}
+        action ||= Constants::SEARCH
+        default = options.delete(:default)
+        raise ArgumentError, formbuilder_error_message(
+          "#{action}_select") unless object.respond_to?(:context)
+        options[:include_blank] = true unless options.has_key?(:include_blank)
+        bases = [''.freeze].freeze + association_array(options[:associations])
+        if bases.size > 1
+          collection = attribute_collection_for_bases(action, bases)
+          object.name ||= default if can_use_default?(
+            default, :name, mapped_values(collection.flatten(2))
+            )
+          template_grouped_collection_select(collection, options, html_options)
+        else
+          collection = collection_for_base(action, bases.first)
+          object.name ||= default if can_use_default?(
+            default, :name, mapped_values(collection)
+            )
+          template_collection_select(:name, collection, options, html_options)
+        end
+      end
+
+      def sort_direction_select(options = {}, html_options = {})
+        unless object.respond_to?(:context)
+          raise ArgumentError,
+          formbuilder_error_message('sort_direction'.freeze)
+        end
+        template_collection_select(:dir, sort_array, options, html_options)
+      end
+
+      def sort_select(options = {}, html_options = {})
+        attribute_select(options, html_options, 'sort'.freeze) +
+        sort_direction_select(options, html_options)
+      end
+
+      def sort_fields(*args, &block)
+        search_fields(:s, args, block)
+      end
+
+      def sort_link(attribute, *args)
+        @template.sort_link @object, attribute, *args
+      end
+
+      def sort_url(attribute, *args)
+        @template.sort_url @object, attribute, *args
+      end
+
+      def condition_fields(*args, &block)
+        search_fields(:c, args, block)
+      end
+
+      def grouping_fields(*args, &block)
+        search_fields(:g, args, block)
+      end
+
+      def attribute_fields(*args, &block)
+        search_fields(:a, args, block)
+      end
+
+      def predicate_fields(*args, &block)
+        search_fields(:p, args, block)
+      end
+
+      def value_fields(*args, &block)
+        search_fields(:v, args, block)
+      end
+
+      def search_fields(name, args, block)
+        args << {} unless args.last.is_a?(Hash)
+        args.last[:builder] ||= options[:builder]
+        args.last[:parent_builder] = self
+        options = args.extract_options!
+        objects = args.shift
+        objects ||= @object.send(name)
+        objects = [objects] unless Array === objects
+        name = "#{options[:object_name] || object_name}[#{name}]"
+        objects.inject(ActiveSupport::SafeBuffer.new) do |output, child|
+          output << @template.fields_for("#{name}[#{options[:child_index] ||
+          nested_child_index(name)}]", child, options, &block)
+        end
+      end
+
+      def predicate_select(options = {}, html_options = {})
+        options[:compounds] = true if options[:compounds].nil?
+        default = options.delete(:default) || Constants::CONT
+
+        keys =
+        if options[:compounds]
+          Predicate.names
+        else
+          Predicate.names.reject { |k| k.match(/_(any|all)$/) }
+        end
+        if only = options[:only]
+          if only.respond_to? :call
+            keys = keys.select { |k| only.call(k) }
+          else
+            only = Array.wrap(only).map(&:to_s)
+            keys = keys.select {
+              |k| only.include? k.sub(/_(any|all)$/, ''.freeze)
+            }
+          end
+        end
+        collection = keys.map { |k| [k, Translate.predicate(k)] }
+        object.predicate ||= Predicate.named(default) if
+          can_use_default?(default, :predicate, keys)
+        template_collection_select(:p, collection, options, html_options)
+      end
+
+      def combinator_select(options = {}, html_options = {})
+        template_collection_select(
+          :m, combinator_choices, options, html_options)
+      end
+
+      private
+
+      def template_grouped_collection_select(collection, options, html_options)
+        @template.grouped_collection_select(
+          @object_name, :name, collection, :last, :first, :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+          )
+      end
+
+      def template_collection_select(name, collection, options, html_options)
+        @template.collection_select(
+          @object_name, name, collection, :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+          )
+      end
+
+      def can_use_default?(default, attribute, values)
+        object.respond_to?("#{attribute}=") && default &&
+          values.include?(default.to_s)
+      end
+
+      def mapped_values(values)
+        values.map { |v| v.is_a?(Array) ? v.first : nil }.compact
+      end
+
+      def sort_array
+        [
+          ['asc'.freeze,  object.translate('asc'.freeze)].freeze,
+          ['desc'.freeze, object.translate('desc'.freeze)].freeze
+        ].freeze
+      end
+
+      def combinator_choices
+        if Nodes::Condition === object
+          [
+            [Constants::OR,  Translate.word(:any)],
+            [Constants::AND, Translate.word(:all)]
+          ]
+        else
+          [
+            [Constants::AND, Translate.word(:all)],
+            [Constants::OR,  Translate.word(:any)]
+          ]
+        end
+      end
+
+      def association_array(obj, prefix = nil)
+        ([prefix] + association_object(obj))
+        .compact
+        .flat_map { |v| [prefix, v].compact.join(Constants::UNDERSCORE) }
+      end
+
+      def association_object(obj)
+        case obj
+        when Array
+          obj
+        when Hash
+          association_hash(obj)
+        else
+          [obj]
+        end
+      end
+
+      def association_hash(obj)
+        obj.map do |key, value|
+          case value
+          when Array, Hash
+            association_array(value, key.to_s)
+          else
+            [key.to_s, [key, value].join(Constants::UNDERSCORE)]
+          end
+        end
+      end
+
+      def attribute_collection_for_bases(action, bases)
+        bases.map { |base| get_attribute_element(action, base) }.compact
+      end
+
+      def get_attribute_element(action, base)
+        begin
+          [
+            Translate.association(base, context: object.context),
+            collection_for_base(action, base)
+          ]
+        rescue UntraversableAssociationError
+          nil
+        end
+      end
+
+      def attribute_collection_for_base(attributes, base = nil)
+        attributes.map do |c|
+          [
+            attr_from_base_and_column(base, c),
+            Translate.attribute(
+              attr_from_base_and_column(base, c), context: object.context
+            )
+          ]
+        end
+      end
+
+      def collection_for_base(action, base)
+        attribute_collection_for_base(
+          object.context.send("#{action}able_attributes", base), base)
+      end
+
+      def attr_from_base_and_column(base, column)
+        [base, column].reject(&:blank?).join(Constants::UNDERSCORE)
+      end
+
+      def formbuilder_error_message(action)
+        "#{action.sub(Constants::SEARCH, Constants::ATTRIBUTE)
+          } must be called inside a search FormBuilder!"
+      end
+
+    end
+  end
+end

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: "غير مساو لقيمة عدم"