Class: ReactiveRecord::ScopeDescription

Inherits:
Object
  • Object
show all
Defined in:
lib/reactive_record/scope_description.rb

Overview

Keeps track of the details (client side) of a scope. The main point is to provide knowledge of what models the scope is joined with, and the client side filter proc

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(model, name, opts) ⇒ ScopeDescription

Returns a new instance of ScopeDescription.



7
8
9
10
11
12
13
14
15
16
 
# File 'lib/reactive_record/scope_description.rb', line 7

def initialize(model, name, opts)
  sself = self
  model.singleton_class.send(:define_method, "_#{name}_synchromesh_scope_description_") do
    sself
  end
  @filter_proc = filter_proc(opts)
  @name = name
  @model = model
  build_joins opts[:joins]
end

Class Method Details

.find(target_model, name) ⇒ Object 



18
19
20
 
# File 'lib/reactive_record/scope_description.rb', line 18

def self.find(target_model, name)
  target_model.send "_#{name}_synchromesh_scope_description_"
end

Instance Method Details

#build_error(path, model, attribute) ⇒ Object 



91
92
93
94
 
# File 'lib/reactive_record/scope_description.rb', line 91

def build_error(path, model, attribute)
  "Could not find joins association '#{model.name}.#{attribute}' "\
  "for '#{path}' while processing scope #{@model.name}.#{@name}."
end

#build_joins(joins_list) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/reactive_record/scope_description.rb', line 64

def build_joins(joins_list)
  if !@filter_proc || joins_list == []
    @joins = { all: [] }
  elsif joins_list.nil?
    @joins = { @model => [[]], all: [] }
  elsif joins_list == :all
    @joins = { all: [[]] }
  else
    joins_list = [joins_list] unless joins_list.is_a? Array
    map_joins_path joins_list
  end
end

#collector? ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
 
# File 'lib/reactive_record/scope_description.rb', line 26

def collector?
  @is_collector
end

#crawl(item, method = nil, *vector) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/reactive_record/scope_description.rb', line 96

def crawl(item, method = nil, *vector)
  if !method && item.is_a?(Collection)
    item.all
  elsif !method
    item
  elsif item.respond_to? :collect
    item.collect { |record| crawl(record.send(method), *vector) }
  else
    crawl(item.send(method), *vector)
  end
end

#filter? ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/reactive_record/scope_description.rb', line 22

def filter?
  @filter_proc.respond_to?(:call)
end

#filter_proc(opts) ⇒ Object

private methods



56
57
58
59
60
61
62
 
# File 'lib/reactive_record/scope_description.rb', line 56

def filter_proc(opts)
  return true unless opts.key?(:client) || opts.key?(:select)
  client_opt = opts[:client] || opts[:select]
  @is_collector = opts.key?(:select)
  return client_opt if !client_opt || client_opt.respond_to?(:call)
  raise 'Scope option :client or :select must be a proc, false, or nil'
end

#filter_records(related_records, args) ⇒ Object 



44
45
46
47
48
49
50
51
52
 
# File 'lib/reactive_record/scope_description.rb', line 44

def filter_records(related_records, args)
  if collector?
    Set.new(related_records.to_a.instance_exec(*args, &@filter_proc))
  else
    Set.new(related_records.select { |r| r.instance_exec(*args, &@filter_proc) })
  end
rescue Exception => e
  raise "Client side scope #{@model}.#{@name} raised error: #{e.message}"
end

#joins_with?(record) ⇒ Boolean

Returns:

  • (Boolean) 


30
31
32
33
34
 
# File 'lib/reactive_record/scope_description.rb', line 30

def joins_with?(record)
  @joins.detect do |klass, vector|
    vector.any? && (klass == :all || record.class == klass || record.class < klass)
  end
end

#map_joins_path(paths) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/reactive_record/scope_description.rb', line 77

def map_joins_path(paths)
  @joins = Hash.new { |h, k| h[k] = Array.new }.merge(@model => [[]])
  paths.each do |path|
    vector = []
    path.split('.').inject(@model) do |model, attribute|
      association = model.reflect_on_association(attribute)
      raise build_error(path, model, attribute) unless association
      vector = [association.inverse_of, *vector]
      @joins[association.klass] << vector
      association.klass
    end
  end
end

#related_records_for(record) ⇒ Object 



36
37
38
39
40
41
42
 
# File 'lib/reactive_record/scope_description.rb', line 36

def related_records_for(record)
  ReactiveRecord::Base.catch_db_requests([]) do
    (@joins[record.class.base_class] || @joins[:all]).collect do |vector|
      crawl(record, *vector)
    end.flatten.compact
  end
end