Class: Tempo::Model::Log

Inherits:
Base
  • Object
show all
Defined in:
lib/tempo/models/log.rb

Direct Known Subclasses

TimeRecord

Instance Attribute Summary collapse

Attributes inherited from Base

#id

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#delete, find, index, instances_have_attributes?, method_missing, respond_to?, run_find_by_method, run_sort_by_method

Constructor Details

#initialize(options = {}) ⇒ Log

class << self



188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/tempo/models/log.rb', line 188

def initialize(options={})
  @start_time = options.fetch(:start_time, Time.now)
  @start_time = Time.new(@start_time) if @start_time.kind_of? String

  self.class.load_day_record(@start_time)
  @d_id = self.class.day_id @start_time

  id_candidate = options[:id]
  if !id_candidate
    @id = self.class.next_id @start_time
  elsif self.class.ids(@start_time).include? id_candidate
    raise IdentityConflictError, "Id #{id_candidate} already exists"
  else
    @id = id_candidate
  end

  self.class.add_id @start_time, @id
  self.class.add_to_index self
  self.class.add_to_days_index self
end

Instance Attribute Details

#d_id ⇒ Object (readonly)

Returns the value of attribute d_id.



11
12
13
 
# File 'lib/tempo/models/log.rb', line 11

def d_id
  @d_id
end

#start_time ⇒ Object

Returns the value of attribute start_time.



10
11
12
 
# File 'lib/tempo/models/log.rb', line 10

def start_time
  @start_time
end

Class Method Details

.add_id(time, id) ⇒ Object 



227
228
229
230
231
232
233
 
# File 'lib/tempo/models/log.rb', line 227

def add_id(time, id)
  dsym = date_symbol time
  @ids = {} unless @ids.kind_of? Hash
  @ids[dsym] ||= []
  @ids[dsym] << id
  @ids[dsym].sort!
end

.add_to_days_index(member) ⇒ Object 



219
220
221
222
223
224
225
 
# File 'lib/tempo/models/log.rb', line 219

def add_to_days_index(member)
  @days_index = {} unless @days_index.kind_of? Hash
  dsym = date_symbol member.start_time
  @days_index[dsym] ||= []
  @days_index[dsym] << member
  @days_index[dsym].sort! { |a,b| a.start_time <=> b.start_time }
end

.clear_all ⇒ Object

Normally not necessary to perform, only used when cleaning (and testing) records



143
144
145
146
147
148
149
 
# File 'lib/tempo/models/log.rb', line 143

def clear_all
  @ids = {}
  @index = []
  @days_index = {}
  @id_counter = {}
  @current = nil
end

.d_id_from_file(file) ⇒ Object 



49
50
51
 
# File 'lib/tempo/models/log.rb', line 49

def d_id_from_file(file)
  /(\d+)\.yaml/.match(file)[1]
end

.date_symbol(time) ⇒ Object 



235
236
237
 
# File 'lib/tempo/models/log.rb', line 235

def date_symbol(time)
  day_id(time).to_sym
end

.day_id(time) ⇒ Object

day_ids can be run through without change Time will be converted into “YYYYmmdd” ex: 1-1-2014 => “20140101”

Raises:

  • (ArgumentError) 


167
168
169
170
171
172
 
# File 'lib/tempo/models/log.rb', line 167

def day_id(time)
  return time if time.to_s =~ /^\d{8}$/

  raise ArgumentError, "Invalid Time" if not time.kind_of? Time
  time.strftime("%Y%m%d")
end

.day_id_to_time(d_id) ⇒ Object 



174
175
176
 
# File 'lib/tempo/models/log.rb', line 174

def day_id_to_time(d_id)
  time = Time.new(d_id[0..3].to_i, d_id[4..5].to_i, d_id[6..7].to_i)
end

.days_index ⇒ Object

all instances are saved in the index inherited from base. Additionally, the days index organizes all instances into arrays by day. This is used for saving to file.



38
39
40
41
 
# File 'lib/tempo/models/log.rb', line 38

def days_index
  @days_index = {} unless @days_index.kind_of? Hash
  @days_index
end

.delete(instance) ⇒ Object 



178
179
180
181
182
183
184
185
 
# File 'lib/tempo/models/log.rb', line 178

def delete(instance)
  id = instance.id
  dsym = date_symbol instance.d_id

  index.delete instance
  days_index[dsym].delete instance
  @ids[dsym].delete id
end

.delete_day_record(time, options = {}) ⇒ Object

delete the file for a single day this is necessary for removing a single entry on a day since updates will skip over days with no entries



135
136
137
138
139
 
# File 'lib/tempo/models/log.rb', line 135

def delete_day_record(time, options={})
  options[:time] = time
  options[:destroy] = true
  FileRecord::FileUtility.new(self, options).file_path
end

.dir(time) ⇒ Object

Returns the immediate directory for the log Tempo::Model::MessageLog => tempo_message_logs



55
56
57
 
# File 'lib/tempo/models/log.rb', line 55

def dir(time)
  FileRecord::FileUtility.new(self).log_directory
end

.file(time) ⇒ Object

Passthrough function, returns the log filename for a given date



45
46
47
 
# File 'lib/tempo/models/log.rb', line 45

def file(time)
  FileRecord::FileUtility.new(self, {time: time}).filename
end

.find_by_id(id, time) ⇒ Object

takes and integer, and time or day_id and returns the instance that matches both the id and d_id



154
155
156
157
158
159
160
161
162
 
# File 'lib/tempo/models/log.rb', line 154

def find_by_id(id, time)
  time = day_id time
  ids = find "id", id
  d_ids = find "d_id", time

  #return the first and only match in the union
  #of the arrays
  (ids & d_ids)[0]
end

.id_counter(time) ⇒ Object

Maintain arrays of unique ids for each day. days are represented as symbols in the hash, for example Jan 1, 2013 would be :“130101” id counter is managed through the private methods increase_id_counter and next_id below



21
22
23
24
25
 
# File 'lib/tempo/models/log.rb', line 21

def id_counter(time)
  dsym = date_symbol time
  @id_counter = {} unless @id_counter.kind_of? Hash
  @id_counter[ dsym ] ||= 1
end

.ids(time) ⇒ Object

Returns an array of ids for the given day



28
29
30
31
32
 
# File 'lib/tempo/models/log.rb', line 28

def ids(time)
  dsym = date_symbol time
  @ids = {} unless @ids.kind_of? Hash
  @ids[dsym] ||= []
end

.increase_id_counter(time) ⇒ Object 



239
240
241
242
243
244
 
# File 'lib/tempo/models/log.rb', line 239

def increase_id_counter(time)
  dsym = date_symbol time
  @id_counter = {} unless @id_counter.kind_of? Hash
  @id_counter[ dsym ] ||= 0
  @id_counter[ dsym ] = @id_counter[ dsym ].next
end

.last_day(options = {}) ⇒ Object

Return a Time object for the last record’s date



112
113
114
115
116
117
118
119
120
 
# File 'lib/tempo/models/log.rb', line 112

def last_day(options={})
  recs = records options
  if recs.last
    d_id = d_id_from_file(recs.last)
    time = day_id_to_time d_id if d_id
    return time
  end
  return nil
end

.last_record(options = {}) ⇒ Object

returns the loaded record with the latest start time Only loads records if options is true, otherwise assumes records are already loaded



72
73
74
75
 
# File 'lib/tempo/models/log.rb', line 72

def last_record(options={})
  load_last_day(options) if options[:load]
  sort_by_start_time.last
end

.load_day_record(time, options = {}) ⇒ Object

load all the records for a single day



91
92
93
94
95
96
97
 
# File 'lib/tempo/models/log.rb', line 91

def load_day_record(time, options={})
  dsym = date_symbol time
  if not days_index.has_key? dsym
    @days_index[ dsym ] = []
    read_from_file time, options
  end
end

.load_days_records(time_1, time_2, options = {}) ⇒ Object

load the records for each day from time 1 to time 2



101
102
103
104
105
106
107
108
109
 
# File 'lib/tempo/models/log.rb', line 101

def load_days_records(time_1, time_2, options={})

  return if time_1.nil? || time_2.nil?

  days = (time_2.to_date - time_1.to_date).to_i
  return if days < 0

  (days + 1).times { |i| load_day_record(time_1.add_days(i), options)}
end

.load_last_day(options = {}) ⇒ Object

load the records for the most recently recorded day



124
125
126
127
128
129
 
# File 'lib/tempo/models/log.rb', line 124

def load_last_day(options={})
  time = last_day options
  return nil unless time
  load_day_record time, options
  return time
end

.next_id(time) ⇒ Object 



246
247
248
249
250
251
 
# File 'lib/tempo/models/log.rb', line 246

def next_id(time)
  while ids(time).include? id_counter time
    increase_id_counter time
  end
  id_counter time
end

.read_from_file(time, options = {}) ⇒ Object

send alternate directory through options



83
84
85
86
87
 
# File 'lib/tempo/models/log.rb', line 83

def read_from_file(time, options={})
  dsym = date_symbol time
  @days_index[ dsym ] = [] if not days_index.has_key? dsym
  FileRecord::Record.read_log(self, time, options)
end

.record_d_ids(options = {}) ⇒ Object 



65
66
67
 
# File 'lib/tempo/models/log.rb', line 65

def record_d_ids(options={})
  records(options).each_with_object(Array.new) {|file,d_ids| d_ids << d_id_from_file(file)}
end

.records(options = {}) ⇒ Object

Load all records from a directory into an array send alternate directory through options



61
62
63
 
# File 'lib/tempo/models/log.rb', line 61

def records(options={})
  FileRecord::FileUtility.new(self, options).log_records
end

.save_to_file(options = {}) ⇒ Object

send alternate directory through options



78
79
80
 
# File 'lib/tempo/models/log.rb', line 78

def save_to_file(options={})
  FileRecord::Record.save_log(self, options)
end

Instance Method Details

#freeze_dry ⇒ Object 



209
210
211
212
213
 
# File 'lib/tempo/models/log.rb', line 209

def freeze_dry
  record = super
  record.delete(:d_id)
  record
end