mini-fast-sys 0.0.1

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

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

@@ -0,0 +1,156 @@
+require 'i18n'
+
+I18n.load_path += Dir[
+  File.join(File.dirname(__FILE__), 'locale'.freeze, '*.yml'.freeze)
+]
+
+module Ransack
+  module Translate
+    class << self
+      def word(key, options = {})
+        I18n.translate(:"ransack.#{key}", default: key.to_s)
+      end
+
+      def predicate(key, options = {})
+        I18n.translate(:"ransack.predicates.#{key}", default: key.to_s)
+      end
+
+      def attribute(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate attributes"
+        end
+
+        original_name = key.to_s
+        base_class = context.klass
+        base_ancestors = base_class.ancestors.select {
+          |x| x.respond_to?(:model_name)
+        }
+        attributes_str = original_name.dup # will be modified by ⬇
+        predicate = Predicate.detect_and_strip_from_string!(attributes_str)
+        attribute_names = attributes_str.split(/_and_|_or_/)
+        combinator = attributes_str =~ /_and_/ ? :and : :or
+        defaults = base_ancestors.map do |klass|
+          "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
+        end
+        defaults << options.delete(:default) if options[:default]
+
+        translated_names = attribute_names.map do |name|
+          attribute_name(context, name, options[:include_associations])
+        end
+
+        interpolations = {
+          attributes: translated_names.join(" #{Translate.word(combinator)} ")
+        }
+
+        if predicate
+          defaults << "%{attributes} %{predicate}".freeze
+          interpolations[:predicate] = Translate.predicate(predicate)
+        else
+          defaults << "%{attributes}".freeze
+        end
+
+        options.reverse_merge! count: 1, default: defaults
+        I18n.translate(defaults.shift, **options.merge(interpolations))
+      end
+
+      def association(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate associations"
+        end
+
+        defaults =
+          if key.blank?
+            [:"ransack.models.#{i18n_key(context.klass)}",
+             :"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"]
+          else
+            [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+          end
+        defaults << context.traverse(key).model_name.human
+        options = { count: 1, default: defaults }
+        I18n.translate(defaults.shift, **options)
+      end
+
+      private
+
+      def attribute_name(context, name, include_associations = nil)
+        @context, @name = context, name
+        @assoc_path = context.association_path(name)
+        @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
+        associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
+        @include_associated = include_associations && associated_class
+
+        defaults = default_attribute_name << fallback_args
+        options = { count: 1, default: defaults }
+        interpolations = build_interpolations(associated_class)
+
+        I18n.translate(defaults.shift, **options.merge(interpolations))
+      end
+
+      def default_attribute_name
+        ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
+      end
+
+      def fallback_args
+        if @include_associated
+          '%{association_name} %{attr_fallback_name}'.freeze
+        else
+          '%{attr_fallback_name}'.freeze
+        end
+      end
+
+      def build_interpolations(associated_class)
+        {
+          attr_fallback_name: attr_fallback_name(associated_class),
+          association_name: association_name
+        }.reject { |_, value| value.nil? }
+      end
+
+      def attr_fallback_name(associated_class)
+        I18n.t(
+          :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
+          default: default_interpolation(associated_class)
+        )
+      end
+
+      def fallback_class(associated_class)
+        i18n_key(associated_class || @context.klass)
+      end
+
+      def association_name
+        association(@assoc_path, context: @context) if @include_associated
+      end
+
+      def default_interpolation(associated_class)
+        [
+          associated_attribute(associated_class),
+          ".attributes.#{@attr_name}".to_sym,
+          @attr_name.humanize
+        ].flatten
+      end
+
+      def associated_attribute(associated_class)
+        if associated_class
+          translated_attribute(associated_class)
+        else
+          translated_ancestor_attributes
+        end
+      end
+
+      def translated_attribute(associated_class)
+        key = "#{associated_class.i18n_scope}.attributes.#{
+        i18n_key(associated_class)}.#{@attr_name}"
+        ["#{key}.one".to_sym, key.to_sym]
+      end
+
+      def translated_ancestor_attributes
+        @context.klass.ancestors
+          .select { |ancestor| ancestor.respond_to?(:model_name) }
+          .map { |ancestor| translated_attribute(ancestor) }
+      end
+
+      def i18n_key(klass)
+        klass.model_name.i18n_key
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module Ransack
+  VERSION = '4.4.1'
+end

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

@@ -0,0 +1,87 @@
+module Ransack
+  class Visitor
+
+    def accept(object)
+      visit(object)
+    end
+
+    def can_accept?(object)
+      respond_to? DISPATCH[object.class]
+    end
+
+    def visit_Array(object)
+      object.map { |o| accept(o) }.compact
+    end
+
+    def visit_Ransack_Nodes_Condition(object)
+      object.arel_predicate if object.valid?
+    end
+
+    def visit_Ransack_Nodes_Grouping(object)
+      if object.combinator == Constants::OR
+        visit_or(object)
+      else
+        visit_and(object)
+      end
+    end
+
+    def visit_and(object)
+      nodes = object.values.map { |o| accept(o) }.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
+      else
+        nodes.first
+      end
+    end
+
+    def visit_or(object)
+      nodes = object.values.map { |o| accept(o) }.compact
+      nodes.inject(&:or)
+    end
+
+    def quoted?(object)
+      case object
+      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+        false
+      else
+        true
+      end
+    end
+
+    def visit(object)
+      send(DISPATCH[object.class], object)
+    end
+
+    def visit_Ransack_Nodes_Sort(object)
+      if object.valid?
+        if object.attr.is_a?(Arel::Attributes::Attribute)
+          object.attr.send(object.dir)
+        else
+          ordered(object)
+        end
+      else
+        scope_name = :"sort_by_#{object.name}_#{object.dir}"
+        scope_name if object.context.object.respond_to?(scope_name)
+      end
+    end
+
+    DISPATCH = Hash.new do |hash, klass|
+      hash[klass] = "visit_#{
+        klass.name.gsub(Constants::TWO_COLONS, Constants::UNDERSCORE)
+        }"
+    end
+
+    private
+
+      def ordered(object)
+        case object.dir
+        when 'asc'.freeze
+          Arel::Nodes::Ascending.new(object.attr)
+        when 'desc'.freeze
+          Arel::Nodes::Descending.new(object.attr)
+        end
+      end
+  end
+end

data/ransack-4.4.1/lib/ransack.rb

@@ -0,0 +1,33 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/deprecation'
+require 'active_support/deprecator'
+
+require 'active_support/core_ext'
+require 'ransack/configuration'
+require 'polyamorous/polyamorous'
+
+module Ransack
+  extend Configuration
+  class UntraversableAssociationError < StandardError; end
+end
+
+Ransack.configure do |config|
+  Ransack::Constants::AREL_PREDICATES.each do |name|
+    config.add_predicate name, arel_predicate: name
+  end
+  Ransack::Constants::DERIVED_PREDICATES.each do |args|
+    config.add_predicate(*args)
+  end
+end
+
+require 'ransack/search'
+require 'ransack/ransacker'
+require 'ransack/translate'
+require 'ransack/active_record'
+require 'ransack/context'
+require 'ransack/version'
+
+ActiveSupport.on_load(:action_controller) do
+  require 'ransack/helpers'
+  ActionController::Base.helper Ransack::Helpers::FormHelper
+end

data/ransack-4.4.1/spec/console.rb

@@ -0,0 +1,13 @@
+Bundler.setup
+require 'factory_bot'
+require 'faker'
+require 'ransack'
+
+Dir[File.expand_path('../../spec/{helpers,support,factories}/*.rb', __FILE__)]
+.each do |f|
+  require f
+end
+
+Faker::Config.random = Random.new(0)
+
+Schema.create