giga-pure-kit 0.0.1

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

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

@@ -0,0 +1,115 @@
+module Ransack
+  module Nodes
+    class Value < Node
+      attr_accessor :value
+      delegate :present?, :blank?, to: :value
+
+      def initialize(context, value = nil)
+        super(context)
+        @value = value
+      end
+
+      def persisted?
+        false
+      end
+
+      def eql?(other)
+        self.class == other.class && self.value == other.value
+      end
+      alias :== :eql?
+
+      def hash
+        value.hash
+      end
+
+      def cast(type)
+        case type
+        when :date
+          cast_to_date(value)
+        when :datetime, :timestamp, :time, :timestamptz
+          cast_to_time(value)
+        when :boolean
+          cast_to_boolean(value)
+        when :integer
+          cast_to_integer(value)
+        when :float
+          cast_to_float(value)
+        when :decimal
+          cast_to_decimal(value)
+        when :money
+          cast_to_money(value)
+        else
+          cast_to_string(value)
+        end
+      end
+
+      def cast_to_date(val)
+        if val.respond_to?(:to_date)
+          val.to_date rescue nil
+        else
+          y, m, d = *[val].flatten
+          m ||= 1
+          d ||= 1
+          Date.new(y, m, d) rescue nil
+        end
+      end
+
+      def cast_to_time(val)
+        if val.is_a?(Array)
+          Time.zone.local(*val) rescue nil
+        else
+          unless val.acts_like?(:time)
+            val = val.is_a?(String) ? Time.zone.parse(val) : val.to_time rescue val
+          end
+          val.in_time_zone rescue nil
+        end
+      end
+
+      def cast_to_boolean(val)
+        if Constants::TRUE_VALUES.include?(val)
+          true
+        elsif Constants::FALSE_VALUES.include?(val)
+          false
+        else
+          nil
+        end
+      end
+
+      def cast_to_string(val)
+        val.respond_to?(:to_s) ? val.to_s : String.new(val)
+      end
+
+      def cast_to_integer(val)
+        val.respond_to?(:to_i) && !val.blank? ? val.to_i : nil
+      end
+
+      def cast_to_float(val)
+        val.blank? ? nil : val.to_f
+      end
+
+      def cast_to_decimal(val)
+       if val.blank?
+         nil
+       elsif val.class == BigDecimal
+         val
+       elsif val.respond_to?(:to_d)
+         val.to_d
+       else
+         val.to_s.to_d
+       end
+      end
+
+      def cast_to_money(val)
+        val.blank? ? nil : val.to_f.to_s
+      end
+
+      def inspect
+        "Value <#{value}>"
+      end
+
+      def array_of_arrays?(val)
+        Array === val && Array === val.first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Ransack
+  class Predicate
+    attr_reader :name, :arel_predicate, :type, :formatter, :validator,
+                :compound, :wants_array, :case_insensitive
+
+    class << self
+
+      def names
+        Ransack.predicates.keys
+      end
+
+      def named(name)
+        Ransack.predicates[(name || Ransack.options[:default_predicate]).to_s]
+      end
+
+      def detect_and_strip_from_string!(str)
+        detect_from_string str, chomp: true
+      end
+
+      def detect_from_string(str, chomp: false)
+        return unless str
+
+        Ransack.predicates.sorted_names_with_underscores.each do |predicate, underscored|
+          if str.end_with? underscored
+            str.chomp! underscored if chomp
+            return predicate
+          end
+        end
+
+        nil
+      end
+
+    end
+
+    def initialize(opts = {})
+      @name = opts[:name]
+      @arel_predicate = opts[:arel_predicate]
+      @type = opts[:type]
+      @formatter = opts[:formatter]
+      @validator = opts[:validator] ||
+        lambda { |v| v.respond_to?(:empty?) ? !v.empty? : !v.nil? }
+      @compound = opts[:compound]
+      @wants_array = opts.fetch(:wants_array,
+        @compound || Constants::IN_NOT_IN.include?(@arel_predicate))
+      @case_insensitive = opts[:case_insensitive]
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+      self.name == other.name
+    end
+    alias :== :eql?
+
+    def hash
+      name.hash
+    end
+
+    def format(val)
+      if formatter
+        formatter.call(val)
+      else
+        val
+      end
+    end
+
+    def validate(vals, type = @type)
+      vals.any? { |v| validator.call(type ? v.cast(type) : v.value) }
+    end
+
+    def negative?
+      @name.include?("not_".freeze)
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+module Ransack
+  class Ransacker
+
+    attr_reader :name, :type, :formatter, :args
+
+    delegate :call, to: :@callable
+
+    def initialize(klass, name, opts = {}, &block)
+      @klass, @name = klass, name
+
+      @type = opts[:type] || :string
+      @args = opts[:args] || [:parent]
+      @formatter = opts[:formatter]
+      @callable = opts[:callable] || block ||
+                  (@klass.method(name) if @klass.respond_to?(name)) ||
+                  proc { |parent| parent.table[name] }
+    end
+
+    def attr_from(bindable)
+      call(*args.map { |arg| bindable.send(arg) })
+    end
+
+  end
+end

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

@@ -0,0 +1,195 @@
+require 'ransack/nodes/bindable'
+require 'ransack/nodes/node'
+require 'ransack/nodes/attribute'
+require 'ransack/nodes/value'
+require 'ransack/nodes/condition'
+require 'ransack/nodes/sort'
+require 'ransack/nodes/grouping'
+require 'ransack/context'
+require 'ransack/naming'
+require 'ransack/invalid_search_error'
+
+module Ransack
+  class Search
+    include Naming
+
+    attr_reader :base, :context
+
+    delegate :object, :klass, to: :context
+    delegate :new_grouping, :new_condition,
+             :build_grouping, :build_condition,
+             :translate, to: :base
+
+    def initialize(object, params = {}, options = {})
+      strip_whitespace = options.fetch(:strip_whitespace, Ransack.options[:strip_whitespace])
+      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+      if params.is_a? Hash
+        params = params.dup
+        params = params.transform_values { |v| v.is_a?(String) && strip_whitespace ? v.strip : v }
+        params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
+      else
+        params = {}
+      end
+      @context = options[:context] || Context.for(object, options)
+      @context.auth_object = options[:auth_object]
+      @base = Nodes::Grouping.new(
+        @context, options[:grouping] || Constants::AND
+        )
+      @scope_args = {}
+      @sorts ||= []
+      @ignore_unknown_conditions = options[:ignore_unknown_conditions] == false ? false : true
+      build(params.with_indifferent_access)
+    end
+
+    def result(opts = {})
+      @context.evaluate(self, opts)
+    end
+
+    def build(params)
+      collapse_multiparameter_attributes!(params).each do |key, value|
+        if ['s'.freeze, 'sorts'.freeze].freeze.include?(key)
+          send("#{key}=", value)
+        elsif @context.ransackable_scope?(key, @context.object)
+          add_scope(key, value)
+        elsif base.attribute_method?(key)
+          base.send("#{key}=", value)
+        elsif !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
+          raise InvalidSearchError, "Invalid search term #{key}"
+        end
+      end
+      self
+    end
+
+    def sorts=(args)
+      case args
+      when Array
+        args.each do |sort|
+          if sort.kind_of? Hash
+            sort = Nodes::Sort.new(@context).build(sort)
+          else
+            sort = Nodes::Sort.extract(@context, sort)
+          end
+          self.sorts << sort if sort
+        end
+      when Hash
+        args.each do |index, attrs|
+          sort = Nodes::Sort.new(@context).build(attrs)
+          self.sorts << sort
+        end
+      when String
+        self.sorts = [args]
+      else
+        raise InvalidSearchError,
+        "Invalid argument (#{args.class}) supplied to sorts="
+      end
+    end
+    alias :s= :sorts=
+
+    def sorts
+      @sorts
+    end
+    alias :s :sorts
+
+    def build_sort(opts = {})
+      new_sort(opts).tap do |sort|
+        self.sorts << sort
+      end
+    end
+
+    def new_sort(opts = {})
+      Nodes::Sort.new(@context).build(opts)
+    end
+
+    def method_missing(method_id, *args)
+      method_name = method_id.to_s
+      getter_name = method_name.sub(/=$/, ''.freeze)
+      if base.attribute_method?(getter_name)
+        base.send(method_id, *args)
+      elsif @context.ransackable_scope?(getter_name, @context.object)
+        if method_name =~ /=$/
+          add_scope getter_name, args
+        else
+          @scope_args[method_name]
+        end
+      else
+        super
+      end
+    end
+
+    def inspect
+      details = [
+        [:class, klass.name],
+        ([:scope, @scope_args] if @scope_args.present?),
+        [:base, base.inspect]
+      ]
+      .compact
+      .map { |d| d.join(': '.freeze) }
+      .join(', '.freeze)
+
+      "Ransack::Search<#{details}>"
+    end
+
+    private
+
+    def add_scope(key, args)
+      sanitized_args = if Ransack.options[:sanitize_scope_args] && !@context.ransackable_scope_skip_sanitize_args?(key, @context.object)
+        sanitized_scope_args(args)
+      else
+        args
+      end
+
+      if @context.scope_arity(key) == 1
+        @scope_args[key] = args.is_a?(Array) ? args[0] : args
+      else
+        @scope_args[key] = args.is_a?(Array) ? sanitized_args : args
+      end
+      @context.chain_scope(key, sanitized_args)
+    end
+
+    def sanitized_scope_args(args)
+      if args.is_a?(Array)
+        args = args.map(&method(:sanitized_scope_args))
+      end
+
+      if Constants::TRUE_VALUES.include? args
+        true
+      elsif Constants::FALSE_VALUES.include? args
+        false
+      else
+        args
+      end
+    end
+
+    def collapse_multiparameter_attributes!(attrs)
+      attrs.keys.each do |k|
+        if k.include?(Constants::LEFT_PARENTHESIS)
+          real_attribute, position = k.split(/\(|\)/)
+          cast =
+          if Constants::A_S_I.include?(position.last)
+            position.last
+          else
+            nil
+          end
+          position = position.to_i - 1
+          value = attrs.delete(k)
+          attrs[real_attribute] ||= []
+          attrs[real_attribute][position] =
+          if cast
+            if value.blank? && cast == Constants::I
+              nil
+            else
+              value.send("to_#{cast}")
+            end
+          else
+            value
+          end
+        elsif Hash === attrs[k]
+          collapse_multiparameter_attributes!(attrs[k])
+        end
+      end
+
+      attrs
+    end
+
+  end
+end