mini-fast-sys 0.0.1

data/ransack-4.4.1/lib/ransack/nodes/condition.rb

@@ -0,0 +1,399 @@
+require 'ransack/invalid_search_error'
+
+module Ransack
+  module Nodes
+    class Condition < Node
+      i18n_word :attribute, :predicate, :combinator, :value
+      i18n_alias a: :attribute, p: :predicate,
+                 m: :combinator, v: :value
+
+      attr_accessor :predicate
+
+      class << self
+        def extract(context, key, values)
+          attributes, predicate, combinator =
+            extract_values_for_condition(key, context)
+
+          if attributes.size > 0 && predicate
+            condition = self.new(context)
+            condition.build(
+              a: attributes,
+              p: predicate.name,
+              m: combinator,
+              v: predicate.wants_array ? Array(values) : [values]
+            )
+            # TODO: Figure out what to do with multiple types of attributes,
+            # if anything. Tempted to go with "garbage in, garbage out" here.
+            if predicate.validate(condition.values, condition.default_type)
+              condition
+            else
+              nil
+            end
+          end
+        end
+
+        private
+
+          def extract_values_for_condition(key, context = nil)
+            str = key.dup
+            name = Predicate.detect_and_strip_from_string!(str)
+            predicate = Predicate.named(name)
+
+            unless predicate || Ransack.options[:ignore_unknown_conditions]
+              raise InvalidSearchError, "No valid predicate for #{key}"
+            end
+
+            if context.present?
+              str = context.ransackable_alias(str)
+            end
+
+            combinator =
+            if str.match(/_(or|and)_/)
+              $1
+            else
+              nil
+            end
+
+            if context.present? && context.attribute_method?(str)
+              attributes = [str]
+            else
+              attributes = str.split(/_and_|_or_/)
+            end
+
+            [attributes, predicate, combinator]
+          end
+      end
+
+      def valid?
+        attributes.detect(&:valid?) && predicate && valid_arity? &&
+          predicate.validate(values, default_type) && valid_combinator?
+      end
+
+      def valid_arity?
+        values.size <= 1 || predicate.wants_array
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+      alias :a :attributes
+
+      def attributes=(args)
+        case args
+        when Array
+          args.each do |name|
+            build_attribute(name)
+          end
+        when Hash
+          args.each do |index, attrs|
+            build_attribute(attrs[:name], attrs[:ransacker_args])
+          end
+        else
+          raise ArgumentError,
+            "Invalid argument (#{args.class}) supplied to attributes="
+        end
+      end
+      alias :a= :attributes=
+
+      def values
+        @values ||= []
+      end
+      alias :v :values
+
+      def values=(args)
+        case args
+        when Array
+          args.each do |val|
+            val = Value.new(@context, val)
+            self.values << val
+          end
+        when Hash
+          args.each do |index, attrs|
+            val = Value.new(@context, attrs[:value])
+            self.values << val
+          end
+        else
+          raise ArgumentError,
+            "Invalid argument (#{args.class}) supplied to values="
+        end
+      end
+      alias :v= :values=
+
+      def combinator
+        @attributes.size > 1 ? @combinator : nil
+      end
+
+      def combinator=(val)
+        @combinator = Constants::AND_OR.detect { |v| v == val.to_s } || nil
+      end
+      alias :m= :combinator=
+      alias :m :combinator
+
+      # == build_attribute
+      #
+      #  This method was originally called from Nodes::Grouping#new_condition
+      #  only, without arguments, without #valid? checking, to build a new
+      #  grouping condition.
+      #
+      #  After refactoring in 235eae3, it is now called from 2 places:
+      #
+      #  1. Nodes::Condition#attributes=, with +name+ argument passed or +name+
+      #     and +ransacker_args+. Attributes are included only if #valid?.
+      #
+      #  2. Nodes::Grouping#new_condition without arguments. In this case, the
+      #     #valid? conditional needs to be bypassed, otherwise nothing is
+      #     built. The `name.nil?` conditional below currently does this.
+      #
+      #  TODO: Add test coverage for this behavior and ensure that `name.nil?`
+      #  isn't fixing issue #701 by introducing untested regressions.
+      #
+      def build_attribute(name = nil, ransacker_args = [])
+        Attribute.new(@context, name, ransacker_args).tap do |attribute|
+          @context.bind(attribute, attribute.name)
+          self.attributes << attribute if name.nil? || attribute.valid?
+          if predicate && !negative?
+            @context.lock_association(attribute.parent)
+          end
+        end
+      end
+
+      def build_value(val = nil)
+        Value.new(@context, val).tap do |value|
+          self.values << value
+        end
+      end
+
+      def value
+        if predicate.wants_array
+          values.map { |v| v.cast(default_type) }
+        else
+          values.first.cast(default_type)
+        end
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          if key.match(/^(a|v|p|m)$/)
+            self.send("#{key}=", value)
+          end
+        end
+
+        self
+      end
+
+      def persisted?
+        false
+      end
+
+      def key
+        @key ||= attributes.map(&:name).join("_#{combinator}_") +
+          "_#{predicate.name}"
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.attributes == other.attributes &&
+        self.predicate == other.predicate &&
+        self.values == other.values &&
+        self.combinator == other.combinator
+      end
+      alias :== :eql?
+
+      def hash
+        [attributes, predicate, values, combinator].hash
+      end
+
+      def predicate_name=(name)
+        self.predicate = Predicate.named(name)
+        unless negative?
+          attributes.each { |a| context.lock_association(a.parent) }
+        end
+        @predicate
+      end
+      alias :p= :predicate_name=
+
+      def predicate_name
+        predicate.name if predicate
+      end
+      alias :p :predicate_name
+
+      def arel_predicate
+        raise "not implemented"
+      end
+
+      def validated_values
+        values.select { |v| predicate.validator.call(v.value) }
+      end
+
+      def casted_values_for_attribute(attr)
+        validated_values.map { |v| v.cast(predicate.type || attr.type) }
+      end
+
+      def formatted_values_for_attribute(attr)
+        formatted = casted_values_for_attribute(attr).map do |val|
+          if attr.ransacker && attr.ransacker.formatter
+            val = attr.ransacker.formatter.call(val)
+          end
+          val = predicate.format(val)
+          if val.is_a?(String) && val.include?('%')
+            val = Arel::Nodes::Quoted.new(val)
+          end
+          val
+        end
+        if predicate.wants_array
+          formatted
+        else
+          formatted.first
+        end
+      end
+
+      def arel_predicate_for_attribute(attr)
+        if predicate.arel_predicate === Proc
+          values = casted_values_for_attribute(attr)
+          unless predicate.wants_array
+            values = values.first
+          end
+          predicate.arel_predicate.call(values)
+        else
+          predicate.arel_predicate
+        end
+      end
+
+      def attr_value_for_attribute(attr)
+        return attr.attr if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+
+        predicate.case_insensitive ? attr.attr.lower : attr.attr
+      rescue
+        attr.attr
+      end
+
+      def default_type
+        predicate.type || (attributes.first && attributes.first.type)
+      end
+
+      def inspect
+        data = [
+          ['attributes'.freeze, a.try(:map, &:name)],
+          ['predicate'.freeze, p],
+          [Constants::COMBINATOR, m],
+          ['values'.freeze, v.try(:map, &:value)]
+        ]
+        .reject { |e| e[1].blank? }
+        .map { |v| "#{v[0]}: #{v[1]}" }
+        .join(', '.freeze)
+        "Condition <#{data}>"
+      end
+
+      def negative?
+        predicate.negative?
+      end
+
+      def arel_predicate
+        predicate = attributes.map { |attribute|
+          association = attribute.parent
+          parent_table = association.table
+
+          if negative? && attribute.associated_collection? && not_nested_condition(attribute, parent_table)
+            query = context.build_correlated_subquery(association)
+            context.remove_association(association)
+
+            case self.predicate_name
+            when 'not_null'
+              if self.value
+                query.where(format_predicate(attribute))
+                Arel::Nodes::In.new(context.primary_key, Arel.sql(query.to_sql))
+              else
+                query.where(format_predicate(attribute).not)
+                Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
+              end
+            when 'not_cont'
+              query.where(attribute.attr.matches(formatted_values_for_attribute(attribute)))
+              Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
+            else
+              query.where(format_predicate(attribute).not)
+              Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
+            end
+          else
+            format_predicate(attribute)
+          end
+        }.reduce(combinator_method)
+
+        if replace_right_node?(predicate)
+          # Replace right node object to plain integer value in order to avoid
+          # ActiveModel::RangeError from Arel::Node::Casted.
+          # The error can be ignored here because RDBMSs accept large numbers
+          # in condition clauses.
+          plain_value = predicate.right.value
+          predicate.right = plain_value
+        end
+
+        predicate
+      end
+
+      def not_nested_condition(attribute, parent_table)
+        parent_table.class != Arel::Nodes::TableAlias && attribute.name.starts_with?(parent_table.name)
+      end
+
+      private
+
+      def combinator_method
+        combinator === Constants::OR ? :or : :and
+      end
+
+      def format_predicate(attribute)
+        arel_pred = arel_predicate_for_attribute(attribute)
+        arel_values = formatted_values_for_attribute(attribute)
+        
+        # For LIKE predicates, wrap the value in Arel::Nodes.build_quoted to prevent
+        # ActiveRecord normalization from affecting wildcard patterns
+        if like_predicate?(arel_pred)
+          arel_values = Arel::Nodes.build_quoted(arel_values)
+        end
+        
+        predicate = attr_value_for_attribute(attribute).public_send(arel_pred, arel_values)
+
+        if in_predicate?(predicate)
+          predicate.right = predicate.right.map do |pr|
+            casted_array?(pr) ? format_values_for(pr) : pr
+          end
+        end
+
+        predicate
+      end
+
+      def in_predicate?(predicate)
+        return unless defined?(Arel::Nodes::Casted)
+        predicate.class == Arel::Nodes::In || predicate.class == Arel::Nodes::NotIn
+      end
+
+      def like_predicate?(arel_predicate)
+        arel_predicate == 'matches' || arel_predicate == 'does_not_match'
+      end
+
+      def casted_array?(predicate)
+        predicate.is_a?(Arel::Nodes::Casted) && predicate.value.is_a?(Array)
+      end
+
+      def format_values_for(predicate)
+        predicate.value.map do |val|
+          val.is_a?(String) ? Arel::Nodes.build_quoted(val) : val
+        end
+      end
+
+      def replace_right_node?(predicate)
+        return false unless predicate.is_a?(Arel::Nodes::Binary)
+
+        arel_node = predicate.right
+        return false unless arel_node.is_a?(Arel::Nodes::Casted)
+
+        relation, name = arel_node.attribute.values
+        attribute_type = relation.type_for_attribute(name).type
+        attribute_type == :integer && arel_node.value.is_a?(Integer)
+      end
+
+      def valid_combinator?
+        attributes.size < 2 || Constants::AND_OR.include?(combinator)
+      end
+    end
+  end
+end

data/ransack-4.4.1/lib/ransack/nodes/grouping.rb

@@ -0,0 +1,206 @@
+module Ransack
+  module Nodes
+    class Grouping < Node
+      attr_reader :conditions
+      attr_accessor :combinator
+      alias :m :combinator
+      alias :m= :combinator=
+
+      i18n_word :condition, :and, :or
+      i18n_alias c: :condition, n: :and, o: :or
+
+      delegate :each, to: :values
+
+      def initialize(context, combinator = nil)
+        super(context)
+        self.combinator = combinator.to_s if combinator
+      end
+
+      def persisted?
+        false
+      end
+
+      def translate(key, options = {})
+        super or Translate.attribute(
+          key.to_s, options.merge(context: context)
+        )
+      end
+
+      def conditions
+        @conditions ||= []
+      end
+      alias :c :conditions
+
+      def conditions=(conditions)
+        case conditions
+        when Array
+          conditions.each do |attrs|
+            condition = Condition.new(@context).build(attrs)
+            self.conditions << condition if condition.valid?
+          end
+        when Hash
+          conditions.each do |index, attrs|
+            condition = Condition.new(@context).build(attrs)
+            self.conditions << condition if condition.valid?
+          end
+        end
+        remove_duplicate_conditions!
+      end
+      alias :c= :conditions=
+
+      def [](key)
+        conditions.detect { |c| c.key == key.to_s }
+      end
+
+      def []=(key, value)
+        conditions.reject! { |c| c.key == key.to_s && c&.value == value&.value }
+        self.conditions << value
+      end
+
+      def values
+        conditions + groupings
+      end
+
+      def respond_to?(method_id)
+        super or begin
+          method_name = method_id.to_s
+          attribute_method?(method_name) ? true : false
+        end
+      end
+
+      def build_condition(opts = {})
+        new_condition(opts).tap do |condition|
+          self.conditions << condition
+        end
+      end
+
+      def new_condition(opts = {})
+        attrs = opts[:attributes] || 1
+        vals = opts[:values] || 1
+        condition = Condition.new(@context)
+        attrs.times { condition.build_attribute }
+        vals.times { condition.build_value }
+        condition
+      end
+
+      def groupings
+        @groupings ||= []
+      end
+      alias :g :groupings
+
+      def groupings=(groupings)
+        case groupings
+        when Array
+          groupings.each do |attrs|
+            grouping_object = new_grouping(attrs)
+            self.groupings << grouping_object if grouping_object.values.any?
+          end
+        when Hash
+          groupings.each do |index, attrs|
+            grouping_object = new_grouping(attrs)
+            self.groupings << grouping_object if grouping_object.values.any?
+          end
+        else
+          raise ArgumentError,
+            "Invalid argument (#{groupings.class}) supplied to groupings="
+        end
+      end
+      alias :g= :groupings=
+
+      def method_missing(method_id, *args)
+        method_name = method_id.to_s.dup
+        writer = method_name.sub!(/\=$/, ''.freeze)
+        if attribute_method?(method_name)
+          if writer
+            write_attribute(method_name, *args)
+          else
+            read_attribute(method_name)
+          end
+        else
+          super
+        end
+      end
+
+      def attribute_method?(name)
+        stripped_name = strip_predicate_and_index(name)
+        return true if @context.attribute_method?(stripped_name) ||
+                       @context.attribute_method?(name)
+        case stripped_name
+        when /^(g|c|m|groupings|conditions|combinator)=?$/
+          true
+        else
+          stripped_name
+          .split(/_and_|_or_/)
+          .none? { |n| !@context.attribute_method?(n) }
+        end
+      end
+
+      def build_grouping(params = {})
+        params ||= {}
+        new_grouping(params).tap do |new_grouping|
+          self.groupings << new_grouping
+        end
+      end
+
+      def new_grouping(params = {})
+        Grouping.new(@context).build(params)
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          case key
+          when /^(g|c|m)$/
+            self.send("#{key}=", value)
+          else
+            write_attribute(key.to_s, value)
+          end
+        end
+        self
+      end
+
+      def inspect
+        data = [
+          ['conditions'.freeze, conditions], [Constants::COMBINATOR, combinator]
+        ]
+        .reject { |e| e[1].blank? }
+        .map { |v| "#{v[0]}: #{v[1]}" }
+        .join(', '.freeze)
+        "Grouping <#{data}>"
+      end
+
+      private
+
+      def write_attribute(name, val)
+        # TODO: Methods
+        if condition = Condition.extract(@context, name, val)
+          self[name] = condition
+        end
+      end
+
+      def read_attribute(name)
+        if self[name].respond_to?(:value)
+          self[name].value
+        else
+          self[name]
+        end
+      end
+
+      def strip_predicate_and_index(str)
+        string = str[/(.+?)\(/, 1] || str.dup
+        Predicate.detect_and_strip_from_string!(string)
+        string
+      end
+
+      def remove_duplicate_conditions!
+        # If self.conditions.uniq! is called without passing a block, then
+        # conditions differing only by ransacker_args within attributes are
+        # wrongly considered equal and are removed.
+        self.conditions.uniq! do |c|
+          c.attributes.map { |a| [a.name, a.ransacker_args] }.flatten +
+          [c.predicate.name] +
+          c.values.map { |v| v.value }
+        end
+      end
+    end
+  end
+end

data/ransack-4.4.1/lib/ransack/nodes/node.rb

@@ -0,0 +1,34 @@
+module Ransack
+  module Nodes
+    class Node
+      attr_reader :context
+      delegate :contextualize, to: :context
+      class_attribute :i18n_words
+      class_attribute :i18n_aliases
+      self.i18n_words = []
+      self.i18n_aliases = {}
+
+      class << self
+        def i18n_word(*args)
+          self.i18n_words += args.map(&:to_s)
+        end
+
+        def i18n_alias(opts = {})
+          self.i18n_aliases.merge! Hash[opts.map { |k, v| [k.to_s, v.to_s] }]
+        end
+      end
+
+      def initialize(context)
+        @context = context
+      end
+
+      def translate(key, options = {})
+        key = i18n_aliases[key.to_s] if i18n_aliases.has_key?(key.to_s)
+        if i18n_words.include?(key.to_s)
+          Translate.word(key)
+        end
+      end
+
+    end
+  end
+end

data/ransack-4.4.1/lib/ransack/nodes/sort.rb

@@ -0,0 +1,54 @@
+module Ransack
+  module Nodes
+    class Sort < Node
+      include Bindable
+
+      attr_reader :name, :dir, :ransacker_args
+      i18n_word :asc, :desc
+
+      class << self
+        def extract(context, str)
+          return if str.blank?
+          attr, direction = str.split(/\s+/, 2)
+          self.new(context).build(name: attr, dir: direction)
+        end
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          if key.match(/^(name|dir|ransacker_args)$/)
+            self.send("#{key}=", value)
+          end
+        end
+
+        self
+      end
+
+      def valid?
+        bound? && attr &&
+        context.klassify(parent).ransortable_attributes(context.auth_object)
+        .include?(attr_name)
+      end
+
+      def name=(name)
+        @name = context.ransackable_alias(name) || name
+        context.bind(self, @name)
+      end
+
+      def dir=(dir)
+        dir = dir.downcase if dir
+        @dir =
+          if dir == 'asc'.freeze || dir == 'desc'.freeze
+            dir
+          else
+            'asc'.freeze
+          end
+      end
+
+      def ransacker_args=(ransack_args)
+        @ransacker_args = ransack_args
+      end
+
+    end
+  end
+end