class Ransack::Context

Attributes

arel_visitor[R]
auth_object[RW]
base[R]
engine[R]
klass[R]
object[R]
search_key[RW]

Public Class Methods

for(object, options = {}) click to toggle source
# File lib/ransack/context.rb, line 19
def for(object, options = {})
  context = Class === object ?
    for_class(object, options) :
    for_object(object, options)
  context or raise ArgumentError,
    "Don't know what context to use for #{object}"
end
for_class(klass, options = {}) click to toggle source
# File lib/ransack/adapters/active_record/ransack/context.rb, line 9
def for_class(klass, options = {})
  if klass < ActiveRecord::Base
    Adapters::ActiveRecord::Context.new(klass, options)
  end
end
for_object(object, options = {}) click to toggle source
# File lib/ransack/adapters/active_record/ransack/context.rb, line 15
def for_object(object, options = {})
  case object
  when ActiveRecord::Relation
    Adapters::ActiveRecord::Context.new(object.klass, options)
  end
end
new(object, options = {}) click to toggle source
# File lib/ransack/adapters/active_record/ransack/context.rb, line 24
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]

  if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
    @base = @join_dependency.join_root
    @engine = @base.base_klass.arel_engine
  else
    @base = @join_dependency.join_base
    @engine = @base.arel_engine
  end

  @default_table = Arel::Table.new(
    @base.table_name, as: @base.aliased_table_name, type_caster: self
    )
  @bind_pairs = Hash.new do |hash, key|
    parent, attr_name = get_parent_and_attribute_name(key.to_s)
    if parent && attr_name
      hash[key] = [parent, attr_name]
    end
  end
end

Public Instance Methods

association_path(str, base = @base) click to toggle source
# File lib/ransack/context.rb, line 89
def association_path(str, base = @base)
  base = klassify(base)
  str ||= Constants::EMPTY
  path = []
  segments = str.split(/_/)
  association_parts = []
  if (segments = str.split(/_/)).size > 0
    while segments.size > 0 &&
    !base.columns_hash[segments.join(Constants::UNDERSCORE)] &&
    association_parts << segments.shift do
      assoc, klass = unpolymorphize_association(
        association_parts.join(Constants::UNDERSCORE)
        )
      if found_assoc = get_association(assoc, base)
        path += association_parts
        association_parts = []
        base = klassify(klass || found_assoc)
      end
    end
  end

  path.join(Constants::UNDERSCORE)
end
bind(object, str) click to toggle source
# File lib/ransack/context.rb, line 57
def bind(object, str)
  object.parent, object.attr_name = @bind_pairs[str]
end
chain_scope(scope, args) click to toggle source
# File lib/ransack/context.rb, line 44
def chain_scope(scope, args)
  return unless @klass.method(scope) && args != false
  @object = if scope_arity(scope) < 1 && args == true
              @object.public_send(scope)
            else
              @object.public_send(scope, *args)
            end
end
contextualize(str) click to toggle source

Convert a string representing a chain of associations and an attribute into the attribute itself

# File lib/ransack/context.rb, line 39
def contextualize(str)
  parent, attr_name = @bind_pairs[str]
  table_for(parent)[attr_name]
end
klassify(obj) click to toggle source
# File lib/ransack/adapters/active_record/ransack/context.rb, line 50
def klassify(obj)
  if Class === obj && ::ActiveRecord::Base > obj
    obj
  elsif obj.respond_to? :klass
    obj.klass
  elsif obj.respond_to? :active_record  # Rails 3
    obj.active_record
  elsif obj.respond_to? :base_klass     # Rails 4
    obj.base_klass
  else
    raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
  end
end
ransackable_association?(str, klass) click to toggle source
# File lib/ransack/context.rb, line 126
def ransackable_association?(str, klass)
  klass.ransackable_associations(auth_object).include? str
end
ransackable_attribute?(str, klass) click to toggle source
# File lib/ransack/context.rb, line 121
def ransackable_attribute?(str, klass)
  klass.ransackable_attributes(auth_object).include?(str) ||
  klass.ransortable_attributes(auth_object).include?(str)
end
ransackable_scope?(str, klass) click to toggle source
# File lib/ransack/context.rb, line 130
def ransackable_scope?(str, klass)
  klass.ransackable_scopes(auth_object).any? { |s| s.to_s == str }
end
scope_arity(scope) click to toggle source
# File lib/ransack/context.rb, line 53
def scope_arity(scope)
  @klass.method(scope).arity
end
searchable_associations(str = Constants::EMPTY) click to toggle source
# File lib/ransack/context.rb, line 142
def searchable_associations(str = Constants::EMPTY)
  traverse(str).ransackable_associations(auth_object)
end
searchable_attributes(str = Constants::EMPTY) click to toggle source
# File lib/ransack/context.rb, line 134
def searchable_attributes(str = Constants::EMPTY)
  traverse(str).ransackable_attributes(auth_object)
end
sortable_attributes(str = Constants::EMPTY) click to toggle source
# File lib/ransack/context.rb, line 138
def sortable_attributes(str = Constants::EMPTY)
  traverse(str).ransortable_attributes(auth_object)
end
traverse(str, base = @base) click to toggle source
# File lib/ransack/context.rb, line 61
def traverse(str, base = @base)
  str ||= Constants::EMPTY

  if (segments = str.split(/_/)).size > 0
    remainder = []
    found_assoc = nil
    while !found_assoc && segments.size > 0 do
      # 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
    raise UntraversableAssociationError,
      "No association matches #{str}" unless found_assoc
  end

  klassify(base)
end
unpolymorphize_association(str) click to toggle source
# File lib/ransack/context.rb, line 113
def unpolymorphize_association(str)
  if (match = str.match(/_of_([^_]+?)_type$/))
    [match.pre_match, Kernel.const_get(match.captures.first)]
  else
    [str, nil]
  end
end