Class: QueryInterface::Client::LazyQuery

Inherits:
Object
  • Object
show all
Defined in:
lib/query-interface-client/lazy_query.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(model, transformations = nil, result_model = nil) ⇒ LazyQuery

Returns a new instance of LazyQuery.



7
8
9
10
11
12
13
14
15
16
 
# File 'lib/query-interface-client/lazy_query.rb', line 7

def initialize(model, transformations=nil, result_model=nil)
  self.model = model
  if transformations
    self.transformations = transformations.map {|item| item.dup}
  else
    self.transformations = []
  end
  self.result = nil
  self.result_model = result_model
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &block) ⇒ Object 



148
149
150
 
# File 'lib/query-interface-client/lazy_query.rb', line 148

def method_missing(method_name, *args, &block)
  evaluate.send(method_name, *args, &block)
end

Instance Attribute Details

#model ⇒ Object

Returns the value of attribute model.



5
6
7
 
# File 'lib/query-interface-client/lazy_query.rb', line 5

def model
  @model
end

#result ⇒ Object

Returns the value of attribute result.



5
6
7
 
# File 'lib/query-interface-client/lazy_query.rb', line 5

def result
  @result
end

#result_model ⇒ Object

Returns the value of attribute result_model.



5
6
7
 
# File 'lib/query-interface-client/lazy_query.rb', line 5

def result_model
  @result_model
end

#transformations ⇒ Object

Returns the value of attribute transformations.



5
6
7
 
# File 'lib/query-interface-client/lazy_query.rb', line 5

def transformations
  @transformations
end

Instance Method Details

#add_transformation(type, parameter = nil) ⇒ Object 



34
35
36
 
# File 'lib/query-interface-client/lazy_query.rb', line 34

def add_transformation(type, parameter=nil)
  self.transformations << {transformation: type, parameter: parameter}
end

#context(association, model = nil) ⇒ Object 



60
61
62
63
64
65
 
# File 'lib/query-interface-client/lazy_query.rb', line 60

def context(association, model=nil)
  self.copy.tap do |query|
    query.result_model = (model ? model : association.to_s.singularize.camelize.constantize)
    query.add_transformation(:context, association)
  end
end

#copy(options = {}) ⇒ Object 



30
31
32
 
# File 'lib/query-interface-client/lazy_query.rb', line 30

def copy(options = {})
  self.class.new(self.model, self.transformations, self.result_model)
end

#count ⇒ Object 



109
110
111
112
113
114
115
116
117
118
 
# File 'lib/query-interface-client/lazy_query.rb', line 109

def count
  if self.result
    self.result.count
  else
    query = self.copy
    query.add_transformation(:count)
    r = query.do_raw_query()
    r[:parsed_data][:data][:count]
  end
end

#do_query ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/query-interface-client/lazy_query.rb', line 120

def do_query
  parsed_data = self.do_raw_query[:parsed_data]
  if parsed_data[:data].is_a?(Array)
    self.instantiate_collection(parsed_data)
  else
    self.instantiate(
      self.parse(parsed_data[:data]).
        merge(_metadata: parsed_data[:metadata], _errors: parsed_data[:errors])
      )
  end
end

#do_raw_query ⇒ Object 



132
133
134
 
# File 'lib/query-interface-client/lazy_query.rb', line 132

def do_raw_query
  self.model.get_raw(:query, transformations: JSON.dump(self.transformations))
end

#evaluate ⇒ Object 



86
87
88
 
# File 'lib/query-interface-client/lazy_query.rb', line 86

def evaluate
  self.result ||= self.do_query()
end

#exclude(conditions = {}) ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/query-interface-client/lazy_query.rb', line 38

def exclude(conditions={})
  self.copy.tap do |query|
    conditions.each do |key, value|
      query.add_transformation(:exclude, {field: key, value: value})
    end
  end
end

#filter(conditions = {}) ⇒ Object 



46
47
48
49
50
51
52
 
# File 'lib/query-interface-client/lazy_query.rb', line 46

def filter(conditions={})
  self.copy.tap do |query|
    conditions.each do |key, value|
      query.add_transformation(:filter, {field: key, value: value})
    end
  end
end

#first(*args) ⇒ Object 



136
137
138
 
# File 'lib/query-interface-client/lazy_query.rb', line 136

def first(*args)
  one(:first, *args)
end

#ids ⇒ Object 



103
104
105
106
107
 
# File 'lib/query-interface-client/lazy_query.rb', line 103

def ids
  query = self.copy
  query.add_transformation(:map_ids)
  query.do_raw_query()[:parsed_data][:data]
end

#instance(id) ⇒ Object 



54
55
56
57
58
 
# File 'lib/query-interface-client/lazy_query.rb', line 54

def instance(id)
  self.copy.tap do |query|
    query.add_transformation(:instance, id)
  end
end

#instantiate(data) ⇒ Object 



22
23
24
 
# File 'lib/query-interface-client/lazy_query.rb', line 22

def instantiate(data)
  (self.result_model ? self.result_model.new(data) : self.model.new(data))
end

#instantiate_collection(parsed_data) ⇒ Object 



26
27
28
 
# File 'lib/query-interface-client/lazy_query.rb', line 26

def instantiate_collection(parsed_data)
  (self.result_model ? self.result_model.new_collection(parsed_data) : self.model.new_collection(parsed_data))
end

#last(*args) ⇒ Object 



140
141
142
 
# File 'lib/query-interface-client/lazy_query.rb', line 140

def last(*args)
  one(:last, *args)
end

#order(*fields) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/query-interface-client/lazy_query.rb', line 78

def order(*fields)
  self.copy.tap do |query|
    fields.each do |field|
      query.add_transformation(:order, field)
    end
  end
end

#paginate(page: 1, per_page: 10) ⇒ Object 



94
95
96
97
98
99
100
101
 
# File 'lib/query-interface-client/lazy_query.rb', line 94

def paginate(page: 1, per_page: 10)
  query = self.copy
  query.add_transformation(:paginate, {page: page, per_page: per_page})
  raw = query.do_raw_query()
  result = raw[:parsed_data][:data]
  objects = result[:objects].map { |h| query.instantiate(h) }
  RsPaginator::Collection.new(objects, page, per_page, result[:total])
end

#parse(data) ⇒ Object 



18
19
20
 
# File 'lib/query-interface-client/lazy_query.rb', line 18

def parse(data)
  (self.result_model ? self.result_model.parse(data) : self.model.parse(data))
end

#to_json(*args) ⇒ Object 



144
145
146
 
# File 'lib/query-interface-client/lazy_query.rb', line 144

def to_json(*args)
  evaluate.to_json(*args)
end

#to_param ⇒ Object 



90
91
92
 
# File 'lib/query-interface-client/lazy_query.rb', line 90

def to_param
  persisted? ? to_key.join('-') : nil
end

#with(*fields, **opts) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
 
# File 'lib/query-interface-client/lazy_query.rb', line 67

def with(*fields, **opts)
  self.copy.tap do |query|
    fields.each do |field|
      query.add_transformation(:with, {field: field})
    end
    opts.each do |field, param|
      query.add_transformation(:with, {field: field, param: param})
    end
  end
end