Class: Fingerprint::RecordSet

Inherits:
Object
  • Object
show all
Defined in:
lib/fingerprint/record.rb

Direct Known Subclasses

SparseRecordSet

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ RecordSet

Returns a new instance of RecordSet.



98
99
100
101
102
103
104
105
106
 
# File 'lib/fingerprint/record.rb', line 98

def initialize
  @records = []
  @paths = {}
  @keys = {}
  
  @configuration = nil

  @callback = nil
end

Instance Attribute Details

#configuration ⇒ Object (readonly)

Returns the value of attribute configuration.



112
113
114
 
# File 'lib/fingerprint/record.rb', line 112

def configuration
  @configuration
end

#keys ⇒ Object (readonly)

Returns the value of attribute keys.



110
111
112
 
# File 'lib/fingerprint/record.rb', line 110

def keys
  @keys
end

#paths ⇒ Object (readonly)

Returns the value of attribute paths.



109
110
111
 
# File 'lib/fingerprint/record.rb', line 109

def paths
  @paths
end

#records ⇒ Object (readonly)

Returns the value of attribute records.



108
109
110
 
# File 'lib/fingerprint/record.rb', line 108

def records
  @records
end

Class Method Details

.load(io) ⇒ Object 



94
95
96
 
# File 'lib/fingerprint/record.rb', line 94

def self.load(io)
  self.new.tap{|record_set| record_set.parse(io)}
end

.load_file(path) ⇒ Object 



88
89
90
91
92
 
# File 'lib/fingerprint/record.rb', line 88

def self.load_file(path)
  File.open(path, "r") do |io|
    self.load(io)
  end
end

.parse(input) ⇒ Object 



198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/fingerprint/record.rb', line 198

def self.parse(input)
  mode = nil
  path = nil
  metadata = nil

  markers = {}
  MODES.each do |key, value|
    markers[value] = key
  end

  # Parse original fingerprint
  input.each_line do |line|
    # Skip comments and blank lines
    next if line.match(/^\s*#/) || line.match(/^\s*$/)

    if line.match(/^([A-Z])\s+(.*)$/)
      if path
        yield mode, path, metadata
      end

      mode = markers[$1] || :unknown

      path = $2
      metadata = {}
    elsif line.match(/^\s+([a-zA-Z\.0-9]+)\s+(.*)$/)
      metadata[$1] = $2
    else
      $stderr.puts "Unhandled line: #{line}"
    end
  end

  if path
    yield mode, path, metadata
  end
end

Instance Method Details

#<<(record) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/fingerprint/record.rb', line 114

def <<(record)
  @records << record
  if record.mode == :configuration
    # What should we do if we get multiple configurations?
    @configuration = record
  else
    @paths[record.path] = record
    record.keys.each do |key|
      @keys[key] ||= {}
      
      @keys[key][record[key]] = record
    end
  end
end

#compare(other) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/fingerprint/record.rb', line 161

def compare(other)
  main = lookup(other.path)

  # Did we find a corresponding other at the same path?
  if main
    # Keep track of how many keys were checked..
    checked = 0

    # Are all the keys of the other record equivalent to the main record?
    other.keys.each do |key|
      if main[key]
        checked += 1

        # Is the key the same?
        if main[key] != other[key]
          return :keys_different, "Key #{key.gsub(/^key\./, '')} does not match"
        end
      end
    end

    # Are the records the same size? We put this check second because we do this as a last resort to
    # ensure that the file hasn't been deliberately tampered with.
    if main.metadata['size'] and other.metadata['size'] and main.metadata['size'] != other.metadata['size']
      return :size_different, "File size differs"
    end

    if checked == 0
      return :no_keys, "No valid keys to check"
    else
      # At least one key could be validated.
      return :valid, "Valid"
    end
  else
    return :not_found, "File not found"
  end
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


133
134
135
 
# File 'lib/fingerprint/record.rb', line 133

def empty?
  @paths.empty?
end

#find(record) ⇒ Object 



153
154
155
156
157
158
159
 
# File 'lib/fingerprint/record.rb', line 153

def find(record)
  result = lookup(record.path)

  return result if result

  return find_by_key(record)
end

#find_by_key(record) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/fingerprint/record.rb', line 141

def find_by_key(record)
  record.keys.each do |key|
    value = record[key]
    
    result = @keys[key][value]

    return result if result
  end

  return nil
end

#include?(path) ⇒ Boolean

Returns:

  • (Boolean) 


129
130
131
 
# File 'lib/fingerprint/record.rb', line 129

def include?(path)
  @paths.include?(path)
end

#lookup(path) ⇒ Object 



137
138
139
 
# File 'lib/fingerprint/record.rb', line 137

def lookup(path)
  return @paths[path]
end

#parse(input) ⇒ Object 



234
235
236
237
238
 
# File 'lib/fingerprint/record.rb', line 234

def parse(input)
  self.class.parse(input) do |mode, path, metadata|
    self << Record.new(mode, path, metadata)
  end
end

#write(output) ⇒ Object 



240
241
242
243
244
 
# File 'lib/fingerprint/record.rb', line 240

def write(output)
  @records.each do |record|
    record.write(output)
  end
end