Class: Locomotive::Steam::Adapters::Memory::Query

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Enumerable
Defined in:
lib/locomotive/steam/adapters/memory/query.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dataset, locale = nil, &block) ⇒ Query

Returns a new instance of Query.



19
20
21
22
23
24
25
26
27
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 19

def initialize(dataset, locale = nil, &block)
  @dataset    = dataset
  @conditions = []
  @sorting    = nil
  @limit      = nil
  @offset     = 0
  @locale     = locale
  instance_eval(&block) if block_given?
end

Instance Attribute Details

#conditions ⇒ Object (readonly)

Returns the value of attribute conditions.



17
18
19
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 17

def conditions
  @conditions
end

Class Method Details

.key(name, operator) ⇒ Object

filtered



103
104
105
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 103

def self.key(name, operator)
  "#{name}.#{operator}"
end

Instance Method Details

#+(query) ⇒ Object 



34
35
36
37
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 34

def +(query)
  @conditions += query.conditions
  self
end

#==(other) ⇒ Object 



57
58
59
60
61
62
63
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 57

def ==(other)
  if other.kind_of? Array
    all == other
  else
    super
  end
end

#all ⇒ Object 



65
66
67
68
69
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 65

def all
  # TODO: instrumentation here
  # Locomotive::Common::Logger.debug "[dataset][#{@dataset.name}] conditions = #{@conditions.map(&:inspect).join(' AND ')}"
  limited sorted(filtered)
end

#filtered ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 89

def filtered
  @dataset.all.dup.find_all do |entry|
    accepted = true

    @conditions.each do |_condition|
      unless _condition.matches?(entry)
        accepted = false
        break # no to go further
      end
    end
    accepted
  end
end

#key(name, operator) ⇒ Object Also known as: k 



107
108
109
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 107

def key(name, operator)
  self.class.key(name, operator)
end

#limit(num) ⇒ Object 



43
44
45
46
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 43

def limit(num)
  @limit = num
  self
end

#limited(entries) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 77

def limited(entries)
  return [] if @limit == 0
  return entries if @offset == 0 && @limit.nil?

  subentries = entries.drop(@offset || 0)
  if @limit.kind_of? Integer
    subentries.take(@limit)
  else
    subentries
  end
end

#offset(num) ⇒ Object 



48
49
50
51
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 48

def offset(num)
  @offset = num
  self
end

#only(*fields) ⇒ Object 



53
54
55
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 53

def only(*fields)
  self
end

#order_by(*args) ⇒ Object 



39
40
41
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 39

def order_by(*args)
  @sorting = Order.new(*args)
end

#sorted(entries) ⇒ Object 



71
72
73
74
75
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 71

def sorted(entries)
  return entries if @sorting.blank?

  entries.sort_by { |entry| @sorting.apply_to(entry, @locale) }
end

#where(conditions = {}) ⇒ Object 



29
30
31
32
 
# File 'lib/locomotive/steam/adapters/memory/query.rb', line 29

def where(conditions = {})
  @conditions += conditions.map { |name, value| Condition.new(name, value, @locale) }
  self
end