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



171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/tempo/models/log.rb', line 171

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 



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

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 



202
203
204
205
206
207
208
 
# File 'lib/tempo/models/log.rb', line 202

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

.date_symbol(time) ⇒ Object 



218
219
220
 
# File 'lib/tempo/models/log.rb', line 218

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) 


150
151
152
153
154
155
 
# File 'lib/tempo/models/log.rb', line 150

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 



157
158
159
 
# File 'lib/tempo/models/log.rb', line 157

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 



161
162
163
164
165
166
167
168
 
# File 'lib/tempo/models/log.rb', line 161

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



128
129
130
131
132
 
# File 'lib/tempo/models/log.rb', line 128

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

.dir ⇒ Object

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



51
52
53
 
# File 'lib/tempo/models/log.rb', line 51

def dir
  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



137
138
139
140
141
142
143
144
145
 
# File 'lib/tempo/models/log.rb', line 137

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 



222
223
224
225
226
227
 
# File 'lib/tempo/models/log.rb', line 222

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



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/tempo/models/log.rb', line 104

def last_day(options={})
  reg = /(\d+)\.yaml/
  recs = records options
  if recs.last
    d_id = reg.match(recs.last)[1]
    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



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

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



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

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



93
94
95
96
97
98
99
100
101
 
# File 'lib/tempo/models/log.rb', line 93

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



117
118
119
120
121
122
 
# File 'lib/tempo/models/log.rb', line 117

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 



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

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



75
76
77
78
79
 
# File 'lib/tempo/models/log.rb', line 75

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

.records(options = {}) ⇒ Object

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



57
58
59
 
# File 'lib/tempo/models/log.rb', line 57

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

.save_to_file(options = {}) ⇒ Object

send alternate directory through options



70
71
72
 
# File 'lib/tempo/models/log.rb', line 70

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

Instance Method Details

#freeze_dry ⇒ Object 



192
193
194
195
196
 
# File 'lib/tempo/models/log.rb', line 192

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