giga-pure-kit 0.0.1

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

@@ -0,0 +1,209 @@
+require 'ransack/constants'
+require 'ransack/predicate'
+
+module Ransack
+  module Configuration
+
+    mattr_accessor :predicates, :options
+
+    class PredicateCollection
+      attr_reader :sorted_names_with_underscores
+
+      def initialize
+        @collection = {}
+        @sorted_names_with_underscores = []
+      end
+
+      delegate :[], :keys, :has_key?, to: :@collection
+
+      def []=(key, value)
+        @sorted_names_with_underscores << [key, '_' + key]
+        @sorted_names_with_underscores.sort! { |(a, _), (b, _)| b.length <=> a.length }
+
+        @collection[key] = value
+      end
+    end
+
+    self.predicates = PredicateCollection.new
+
+    self.options = {
+      search_key: :q,
+      ignore_unknown_conditions: true,
+      hide_sort_order_indicators: false,
+      up_arrow: '&#9660;'.freeze,
+      down_arrow: '&#9650;'.freeze,
+      default_arrow: nil,
+      sanitize_scope_args: true,
+      postgres_fields_sort_option: nil,
+      strip_whitespace: true
+    }
+
+    def configure
+      yield self
+    end
+
+    def add_predicate(name, opts = {})
+      name = name.to_s
+      opts[:name] = name
+      compounds = opts.delete(:compounds)
+      compounds = true if compounds.nil?
+      compounds = false if opts[:wants_array]
+
+      self.predicates[name] = Predicate.new(opts)
+
+      Constants::SUFFIXES.each do |suffix|
+        compound_name = name + suffix
+        self.predicates[compound_name] = Predicate.new(
+          opts.merge(
+            name: compound_name,
+            arel_predicate: arel_predicate_with_suffix(
+              opts[:arel_predicate], suffix
+              ),
+            compound: true
+          )
+        )
+      end if compounds
+    end
+
+    # The default `search_key` name is `:q`. The default key may be overridden
+    # in an initializer file like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Name the search_key `:query` instead of the default `:q`
+    #   config.search_key = :query
+    # end
+    #
+    # Sometimes there are situations when the default search parameter name
+    # cannot be used, for instance if there were two searches on one page.
+    # Another name can be set using the `search_key` option with Ransack
+    # `ransack`, `search` and `@search_form_for` methods in controllers & views.
+    #
+    # In the controller:
+    # @search = Log.ransack(params[:log_search], search_key: :log_search)
+    #
+    # In the view:
+    # <%= f.search_form_for @search, as: :log_search %>
+    #
+    def search_key=(name)
+      self.options[:search_key] = name
+    end
+
+    # By default Ransack ignores errors if an unknown predicate, condition or
+    # attribute is passed into a search. The default may be overridden in an
+    # initializer file like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Raise if an unknown predicate, condition or attribute is passed
+    #   config.ignore_unknown_conditions = false
+    # end
+    #
+    def ignore_unknown_conditions=(boolean)
+      self.options[:ignore_unknown_conditions] = boolean
+    end
+
+    # By default Ransack ignores empty predicates. Ransack can also fallback to
+    # a default predicate by setting it in an initializer file
+    # like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Use the 'eq' predicate if an unknown predicate is passed
+    #   config.default_predicate = 'eq'
+    # end
+    #
+    def default_predicate=(name)
+      self.options[:default_predicate] = name
+    end
+
+    # By default, Ransack displays sort order indicator arrows with HTML codes:
+    #
+    #   up_arrow:   '&#9660;'
+    #   down_arrow: '&#9650;'
+    #
+    # There is also a default arrow which is displayed if a column is not sorted.
+    # By default this is nil so nothing will be displayed.
+    #
+    # Any of the defaults may be globally overridden in an initializer file
+    # like `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Globally set the up arrow to an icon, and the down and default arrows to unicode.
+    #   config.custom_arrows = {
+    #     up_arrow:   '<i class="fa fa-long-arrow-up"></i>',
+    #     down_arrow: 'U+02193',
+    #     default_arrow: 'U+11047'
+    #   }
+    # end
+    #
+    def custom_arrows=(opts = {})
+      self.options[:up_arrow] = opts[:up_arrow].freeze if opts[:up_arrow]
+      self.options[:down_arrow] = opts[:down_arrow].freeze if opts[:down_arrow]
+      self.options[:default_arrow] = opts[:default_arrow].freeze if opts[:default_arrow]
+    end
+
+    # Ransack sanitizes many values in your custom scopes into booleans.
+    # [1, '1', 't', 'T', 'true', 'TRUE'] all evaluate to true.
+    # [0, '0', 'f', 'F', 'false', 'FALSE'] all evaluate to false.
+    #
+    # This default may be globally overridden in an initializer file like
+    # `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Accept my custom scope values as what they are.
+    #   config.sanitize_custom_scope_booleans = false
+    # end
+    #
+    def sanitize_custom_scope_booleans=(boolean)
+      self.options[:sanitize_scope_args] = boolean
+    end
+
+    # The `NULLS FIRST` and `NULLS LAST` options can be used to determine
+    # whether nulls appear before or after non-null values in the sort ordering.
+    #
+    # User may want to configure it like this:
+    #
+    # Ransack.configure do |c|
+    #   c.postgres_fields_sort_option = :nulls_first # or e.g. :nulls_always_last
+    # end
+    #
+    # See this feature: https://www.postgresql.org/docs/13/queries-order.html
+    #
+    def postgres_fields_sort_option=(setting)
+      self.options[:postgres_fields_sort_option] = setting
+    end
+
+    # By default, Ransack displays sort order indicator arrows in sort links.
+    # The default may be globally overridden in an initializer file like
+    # `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Hide sort link order indicators globally across the application
+    #   config.hide_sort_order_indicators = true
+    # end
+    #
+    def hide_sort_order_indicators=(boolean)
+      self.options[:hide_sort_order_indicators] = boolean
+    end
+
+    # By default, Ransack displays strips all whitespace when searching for a string.
+    # The default may be globally changed in an initializer file like
+    # `config/initializers/ransack.rb` as follows:
+    #
+    # Ransack.configure do |config|
+    #   # Enable whitespace stripping for string searches
+    #   config.strip_whitespace = true
+    # end
+    #
+    def strip_whitespace=(boolean)
+      self.options[:strip_whitespace] = boolean
+    end
+
+    def arel_predicate_with_suffix(arel_predicate, suffix)
+      if arel_predicate === Proc
+        proc { |v| "#{arel_predicate.call(v)}#{suffix}" }
+      else
+        "#{arel_predicate}#{suffix}"
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,176 @@
+module Ransack
+  module Constants
+    OR                  = 'or'.freeze
+    AND                 = 'and'.freeze
+
+    CAP_SEARCH          = 'Search'.freeze
+    SEARCH              = 'search'.freeze
+    SEARCHES            = 'searches'.freeze
+
+    ATTRIBUTE           = 'attribute'.freeze
+    ATTRIBUTES          = 'attributes'.freeze
+    COMBINATOR          = 'combinator'.freeze
+
+    TWO_COLONS          = '::'.freeze
+    UNDERSCORE          = '_'.freeze
+    LEFT_PARENTHESIS    = '('.freeze
+    Q                   = 'q'.freeze
+    I                   = 'i'.freeze
+    DOT_ASTERIX         = '.*'.freeze
+
+    STRING_JOIN         = 'string_join'.freeze
+    ASSOCIATION_JOIN    = 'association_join'.freeze
+    STASHED_JOIN        = 'stashed_join'.freeze
+    JOIN_NODE           = 'join_node'.freeze
+
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+    BOOLEAN_VALUES = (TRUE_VALUES + FALSE_VALUES).freeze
+
+    AND_OR              = ['and'.freeze, 'or'.freeze].freeze
+    IN_NOT_IN           = ['in'.freeze, 'not_in'.freeze].freeze
+    SUFFIXES            = ['_any'.freeze, '_all'.freeze].freeze
+    AREL_PREDICATES     = [
+      'eq'.freeze, 'not_eq'.freeze,
+      'matches'.freeze, 'does_not_match'.freeze,
+      'lt'.freeze, 'lteq'.freeze,
+      'gt'.freeze, 'gteq'.freeze,
+      'in'.freeze, 'not_in'.freeze
+    ].freeze
+    A_S_I               = ['a'.freeze, 's'.freeze, 'i'.freeze].freeze
+
+    EQ                  = 'eq'.freeze
+    NOT_EQ              = 'not_eq'.freeze
+    EQ_ANY              = 'eq_any'.freeze
+    NOT_EQ_ALL          = 'not_eq_all'.freeze
+    CONT                = 'cont'.freeze
+
+    RANSACK_SLASH_SEARCHES = 'ransack/searches'.freeze
+    RANSACK_SLASH_SEARCHES_SLASH_SEARCH = 'ransack/searches/search'.freeze
+
+    DISTINCT = 'DISTINCT '.freeze
+
+    DERIVED_PREDICATES = [
+      [CONT, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['not_cont'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['i_cont'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v.downcase)}%" },
+        case_insensitive: true
+        }
+      ],
+      ['not_i_cont'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v.downcase)}%" },
+        case_insensitive: true
+        }
+      ],
+      ['start'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['not_start'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['end'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
+        }
+      ],
+      ['not_end'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
+        }
+      ],
+      ['true'.freeze, {
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| true }
+        }
+      ],
+      ['not_true'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| true }
+        }
+      ],
+      ['false'.freeze, {
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| false }
+        }
+      ],
+      ['not_false'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| false }
+        }
+      ],
+      ['present'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ_ALL : EQ_ANY },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''.freeze].freeze }
+        }
+      ],
+      ['blank'.freeze, {
+        arel_predicate: proc { |v| v ? EQ_ANY : NOT_EQ_ALL },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''.freeze].freeze }
+        }
+      ],
+      ['null'.freeze, {
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| nil }
+        }
+      ],
+      ['not_null'.freeze, {
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| nil } }
+      ]
+    ].freeze
+
+  module_function
+    # replace % \ to \% \\
+    def escape_wildcards(unescaped)
+      case ActiveRecord::Base.connection.adapter_name
+      when "Mysql2".freeze
+        # Necessary for MySQL
+        unescaped.to_s.gsub(/([\\%_])/, '\\\\\\1')
+      when "PostGIS".freeze, "PostgreSQL".freeze
+        # Necessary for PostgreSQL
+        unescaped.to_s.gsub(/([\\%_.])/, '\\\\\\1')
+      else
+        unescaped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+require 'ransack/visitor'
+
+module Ransack
+  class Context
+    attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
+    attr_accessor :auth_object, :search_key
+    attr_reader :arel_visitor
+
+    class << self
+
+      def for_class(klass, options = {})
+        if klass < ActiveRecord::Base
+          Adapters::ActiveRecord::Context.new(klass, options)
+        end
+      end
+
+      def for_object(object, options = {})
+        case object
+        when ActiveRecord::Relation
+          Adapters::ActiveRecord::Context.new(object.klass, options)
+        end
+      end
+
+      def for(object, options = {})
+        context =
+          if Class === object
+            for_class(object, options)
+          else
+            for_object(object, options)
+          end
+        context or raise ArgumentError,
+          "Don't know what context to use for #{object}"
+      end
+
+    end # << self
+
+    def initialize(object, options = {})
+      @object = relation_for(object)
+      @klass = @object.klass
+      @join_dependency = join_dependency(@object)
+      @join_type = options[:join_type] || Polyamorous::OuterJoin
+      @search_key = options[:search_key] || Ransack.options[:search_key]
+      @associations_pot = {}
+      @tables_pot = {}
+      @lock_associations = []
+
+      @base = @join_dependency.instance_variable_get(:@join_root)
+    end
+
+    def bind_pair_for(key)
+      @bind_pairs ||= {}
+
+      @bind_pairs[key] ||= begin
+        parent, attr_name = get_parent_and_attribute_name(key.to_s)
+        [parent, attr_name] if parent && attr_name
+      end
+    end
+
+    def klassify(obj)
+      if Class === obj && ::ActiveRecord::Base > obj
+        obj
+      elsif obj.respond_to? :klass
+        obj.klass
+      else
+        raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
+      end
+    end
+
+    # Convert a string representing a chain of associations and an attribute
+    # into the attribute itself
+    def contextualize(str)
+      parent, attr_name = bind_pair_for(str)
+      table_for(parent)[attr_name]
+    end
+
+    def chain_scope(scope, args)
+      return unless @klass.method(scope) && args != false
+      @object = if scope_arity(scope) < 1 && args == true
+                  @object.public_send(scope)
+                elsif scope_arity(scope) == 1 && args.is_a?(Array)
+                  # For scopes with arity 1, pass the array as a single argument instead of splatting
+                  @object.public_send(scope, args)
+                else
+                  @object.public_send(scope, *args)
+                end
+    end
+
+    def scope_arity(scope)
+      @klass.method(scope).arity
+    end
+
+    def bind(object, str)
+      return nil unless str
+      object.parent, object.attr_name = bind_pair_for(str)
+    end
+
+    def traverse(str, base = @base)
+      str ||= ''.freeze
+      segments = str.split(Constants::UNDERSCORE)
+      unless segments.empty?
+        remainder = []
+        found_assoc = nil
+        until found_assoc || segments.empty?
+          # Strip the _of_Model_type text from the association name, but hold
+          # onto it in klass, for use as the next base
+          assoc, klass = unpolymorphize_association(
+            segments.join(Constants::UNDERSCORE)
+          )
+          if found_assoc = get_association(assoc, base)
+            base = traverse(
+              remainder.join(Constants::UNDERSCORE), klass || found_assoc.klass
+            )
+          end
+
+          remainder.unshift segments.pop
+        end
+        unless found_assoc
+          raise(UntraversableAssociationError,
+                "No association matches #{str}")
+        end
+      end
+
+      klassify(base)
+    end
+
+    def association_path(str, base = @base)
+      base = klassify(base)
+      str ||= ''.freeze
+      path = []
+      segments = str.split(Constants::UNDERSCORE)
+      association_parts = []
+      unless segments.empty?
+        while !segments.empty? &&
+              !base.columns_hash[segments.join(Constants::UNDERSCORE)] &&
+              association_parts << segments.shift
+          assoc, klass = unpolymorphize_association(
+            association_parts.join(Constants::UNDERSCORE)
+          )
+          next unless found_assoc = get_association(assoc, base)
+          path += association_parts
+          association_parts = []
+          base = klassify(klass || found_assoc)
+        end
+      end
+
+      path.join(Constants::UNDERSCORE)
+    end
+
+    def unpolymorphize_association(str)
+      if (match = str.match(/_of_([^_]+?)_type$/))
+        [match.pre_match, Kernel.const_get(match.captures.first)]
+      else
+        [str, nil]
+      end
+    end
+
+    def ransackable_alias(str)
+      klass._ransack_aliases.fetch(str, klass._ransack_aliases.fetch(str.to_sym, str))
+    end
+
+    def ransackable_attribute?(str, klass)
+      klass.ransackable_attributes(auth_object).any? { |s| s.to_sym == str.to_sym } ||
+        klass.ransortable_attributes(auth_object).any? { |s| s.to_sym == str.to_sym }
+    end
+
+    def ransackable_association?(str, klass)
+      klass.ransackable_associations(auth_object).any? { |s| s.to_sym == str.to_sym }
+    end
+
+    def ransackable_scope?(str, klass)
+      klass.ransackable_scopes(auth_object).any? { |s| s.to_sym == str.to_sym }
+    end
+
+    def ransackable_scope_skip_sanitize_args?(str, klass)
+      klass.ransackable_scopes_skip_sanitize_args.any? { |s| s.to_sym == str.to_sym }
+    end
+
+    def searchable_attributes(str = ''.freeze)
+      traverse(str).ransackable_attributes(auth_object)
+    end
+
+    def sortable_attributes(str = ''.freeze)
+      traverse(str).ransortable_attributes(auth_object)
+    end
+
+    def searchable_associations(str = ''.freeze)
+      traverse(str).ransackable_associations(auth_object)
+    end
+  end
+end