mini-fast-sys 0.0.1

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

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