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

Returns a new instance of Log.



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/tempo/models/log.rb', line 155

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 



194
195
196
197
198
199
200
 
# File 'lib/tempo/models/log.rb', line 194

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 



186
187
188
189
190
191
192
 
# File 'lib/tempo/models/log.rb', line 186

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 



202
203
204
 
# File 'lib/tempo/models/log.rb', line 202

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) 


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

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 



141
142
143
 
# File 'lib/tempo/models/log.rb', line 141

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 



145
146
147
148
149
150
151
152
 
# File 'lib/tempo/models/log.rb', line 145

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



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

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



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

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 



206
207
208
209
210
211
 
# File 'lib/tempo/models/log.rb', line 206

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

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

load all the records for a single day



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

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



85
86
87
88
89
90
91
92
93
 
# File 'lib/tempo/models/log.rb', line 85

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



97
98
99
100
101
102
103
104
105
106
 
# File 'lib/tempo/models/log.rb', line 97

def load_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
    load_day_record time, options
    return time
  end
end

.next_id(time) ⇒ Object 



213
214
215
216
217
218
 
# File 'lib/tempo/models/log.rb', line 213

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



67
68
69
70
71
 
# File 'lib/tempo/models/log.rb', line 67

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



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

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

Instance Method Details

#freeze_dry ⇒ Object 



176
177
178
179
180
 
# File 'lib/tempo/models/log.rb', line 176

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