Class: Fire::Model

Inherits:
OpenStruct
  • Object
show all
Includes:
Querying, NestedParent, TarvitHelpers::NonSharedAccessors
Defined in:
lib/model/base.rb,
lib/model/querying/querying.rb

Direct Known Subclasses

NestedModel

Defined Under Namespace

Modules: Querying Classes: FireModelError, InvalidPathKeyError, PathValueMissingError

Constant Summary collapse

LEVEL_SEPARATOR = 
?/

Class Method Summary collapse

Instance Method Summary collapse

Methods included from NestedParent

#saving_data

Constructor Details

#initialize(attrs = {}) ⇒ Model

Returns a new instance of Model.



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/model/base.rb', line 12

def initialize(attrs={})
  data = self.class.prepare_hash(attrs)
  unless data[id_key]
    data[id_key] = self.class.next_id
    @persisted = false
  else
    @persisted = true
  end
  @original_data = data.clone
  super(data)
end

Class Method Details

.all_path_keys ⇒ Object 



160
161
162
 
# File 'lib/model/base.rb', line 160

def all_path_keys
  own_path_keys + default_path_keys
end

.collection_name ⇒ Object

Klass Accessors



152
153
154
 
# File 'lib/model/base.rb', line 152

def collection_name
  self.fire_collection || default_collection_name
end

.connection ⇒ Object 



156
157
158
 
# File 'lib/model/base.rb', line 156

def connection
  Fire::Connection::Request.new
end

.create(object) ⇒ Object 



176
177
178
179
180
 
# File 'lib/model/base.rb', line 176

def create(object)
  model = new(object)
  model.save
  model
end

.has_path_keys(*keys) ⇒ Object 



142
143
144
 
# File 'lib/model/base.rb', line 142

def has_path_keys(*keys)
  self.path_keys = keys
end

.id_key ⇒ Object 



197
198
199
 
# File 'lib/model/base.rb', line 197

def id_key
  self.id_key_name || :id
end

.in_collection(name) ⇒ Object

Klass Setters



138
139
140
 
# File 'lib/model/base.rb', line 138

def in_collection(name)
  self.fire_collection = name
end

.next_id ⇒ Object

Helpers



184
185
186
 
# File 'lib/model/base.rb', line 184

def next_id
  rand(36**8).to_s(36)
end

.own_path_keys ⇒ Object 



164
165
166
 
# File 'lib/model/base.rb', line 164

def own_path_keys
  self.path_keys || []
end

.path_value_param(raw_value) ⇒ Object 



188
189
190
191
 
# File 'lib/model/base.rb', line 188

def path_value_param(raw_value)
  return raw_value.to_s+?_ if raw_value.is_a?(Numeric)
  raw_value.to_s.parameterize
end

.prepare_hash(hash) ⇒ Object 



193
194
195
 
# File 'lib/model/base.rb', line 193

def prepare_hash(hash)
  HashWithIndifferentAccess[hash]
end

.set_id_key(value) ⇒ Object 



146
147
148
 
# File 'lib/model/base.rb', line 146

def set_id_key(value)
  self.id_key_name = value
end

.take(path_data) ⇒ Object

Record Methods



170
171
172
173
174
 
# File 'lib/model/base.rb', line 170

def take(path_data)
  path_object = new(path_data)
  loaded_data = connection.get(path_object.path).body
  loaded_data.nil? ? nil : new(loaded_data)
end

Instance Method Details

#==(model_object) ⇒ Object 



121
122
123
 
# File 'lib/model/base.rb', line 121

def ==(model_object)
  self.data == model_object.data
end

#cache(key, &value) ⇒ Object 



129
130
131
132
 
# File 'lib/model/base.rb', line 129

def cache(key, &value)
  @cache ||= {}
  @cache[key] ||= value.call
end

#collection_name ⇒ Object 



34
35
36
 
# File 'lib/model/base.rb', line 34

def collection_name
  self.class.collection_name
end

#custom_data(hash = self.data) ⇒ Object 



95
96
97
98
99
100
 
# File 'lib/model/base.rb', line 95

def custom_data(hash=self.data)
  res = hash.to_a.select do |(k, v)|
    !self.class.all_path_keys.include?(k)
  end
  self.class.prepare_hash(res)
end

#data ⇒ Object 



125
126
127
 
# File 'lib/model/base.rb', line 125

def data
  self.to_h
end

#delete ⇒ Object 



56
57
58
59
 
# File 'lib/model/base.rb', line 56

def delete
  self.class.connection.delete(path)
  @persisted = false
end

#delete_field(field) ⇒ Object 



44
45
46
47
48
 
# File 'lib/model/base.rb', line 44

def delete_field(field)
  self.send("#{field}=", nil)
  field_path = [path, field] * LEVEL_SEPARATOR
  self.class.connection.delete(field_path)
end

#has_data?(data) ⇒ Boolean

Returns:

  • (Boolean) 


113
114
115
116
117
118
119
 
# File 'lib/model/base.rb', line 113

def has_data?(data)
  return true if data.empty?
  self.class.prepare_hash(data).each do |k, v|
    return false unless self.send(k) == v
  end
  true
end

#id_key ⇒ Object

Record Methods



26
27
28
 
# File 'lib/model/base.rb', line 26

def id_key
  self.class.id_key
end

#id_value ⇒ Object 



30
31
32
 
# File 'lib/model/base.rb', line 30

def id_value
  send(id_key)
end

#path ⇒ Object 



65
66
67
 
# File 'lib/model/base.rb', line 65

def path
  ([ collection_name ] + path_values) * LEVEL_SEPARATOR
end

#path_changed? ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/model/base.rb', line 109

def path_changed?
  @persisted && (path_data != path_data(@original_data))
end

#path_data(hash = self.data) ⇒ Object 



102
103
104
105
106
107
 
# File 'lib/model/base.rb', line 102

def path_data(hash=self.data)
  res = hash.to_a.select do |(k, v)|
    self.class.all_path_keys.include?(k.to_sym)
  end
  self.class.prepare_hash(res)
end

#path_values ⇒ Object

Data Methods



87
88
89
90
91
92
93
 
# File 'lib/model/base.rb', line 87

def path_values
  self.class.all_path_keys.map do |pk|
    path_value = send(pk)
    raise PathValueMissingError.new(pk) if path_value.to_s.empty?
    self.class.path_value_param(path_value)
  end
end

#persisted? ⇒ Boolean

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/model/base.rb', line 61

def persisted?
  @persisted
end

#reload ⇒ Object 



69
70
71
72
73
74
 
# File 'lib/model/base.rb', line 69

def reload
  loaded_data = self.class.take(path_data).data
  @table = loaded_data
  @cache = {}
  self
end

#save ⇒ Object 



50
51
52
53
54
 
# File 'lib/model/base.rb', line 50

def save
  self.class.new(@original_data).delete if path_changed?
  self.class.connection.set(path, self.saving_data)
  @persisted = true
end

#set(attrs) ⇒ Object 



81
82
83
 
# File 'lib/model/base.rb', line 81

def set(attrs)
  @table.merge!(attrs)
end

#update(attrs) ⇒ Object 



76
77
78
79
 
# File 'lib/model/base.rb', line 76

def update(attrs)
  set(attrs)
  save
end

#update_field(field, value) ⇒ Object 



38
39
40
41
42
 
# File 'lib/model/base.rb', line 38

def update_field(field, value)
  self.send("#{field}=", value)
  field_path = [path, field] * LEVEL_SEPARATOR
  self.class.connection.set(field_path, value)
end