Class: FuzzyHash

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(init_hash = nil, classes_to_fuzz = nil) ⇒ FuzzyHash

Returns a new instance of FuzzyHash.



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

def initialize(init_hash = nil, classes_to_fuzz = nil)
  @fuzzies = []
  @hash_reverse = {}
  @fuzzies_reverse = {}
  @fuzzy_hash = {}
  @hash = {}
  @classes_to_fuzz = classes_to_fuzz || [Regexp]
  @classes_to_fuzz = Set.new(@classes_to_fuzz)
  init_hash.each{ |key,value| self[key] = value } if init_hash
end

Instance Attribute Details

#classes_to_fuzz ⇒ Object

Returns the value of attribute classes_to_fuzz.



11
12
13
 
# File 'lib/fuzzy_hash.rb', line 11

def classes_to_fuzz
  @classes_to_fuzz
end

Class Method Details

.always_fuzzy(init_hash = nil) ⇒ Object 



5
6
7
8
9
 
# File 'lib/fuzzy_hash.rb', line 5

def self.always_fuzzy(init_hash = nil)
  hash = new(init_hash)
  hash.classes_to_fuzz = nil    
  hash
end

Instance Method Details

#==(o) ⇒ Object 



37
38
39
40
41
 
# File 'lib/fuzzy_hash.rb', line 37

def ==(o)
  o.is_a?(FuzzyHash)
  o.send(:hash) == hash &&
  o.send(:fuzzies) == fuzzies
end

#[](key) ⇒ Object 



96
97
98
99
100
 
# File 'lib/fuzzy_hash.rb', line 96

def [](key)
  (hash.key?(key) && hash[key])  ||
    ((lookup = fuzzy_lookup(key)) && lookup && lookup.first) ||
    fuzzy_hash[key]
end

#[]=(key, value) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/fuzzy_hash.rb', line 64

def []=(key, value)
  if classes_to_fuzz.nil? || classes_to_fuzz.include?(key.class)
    fuzzies.delete_if{|f| f.first.hash == key.hash}
    fuzzies_reverse.delete_if{|k, v| v[1].hash == key.hash}
    hash_reverse.delete_if{|k,v| v.hash == key.hash}

    fuzzy_hash[key] = value
    fuzzies << [key, value]
    reset_fuzz_test!
    fuzzies_reverse[value] = [fuzzies.size - 1, key, value]
  else
    hash[key] = value
    hash_reverse.delete_if{|k,v| v.hash == key.hash}
    hash_reverse[value] = key
  end
  value
end

#clear ⇒ Object 



24
25
26
27
28
29
 
# File 'lib/fuzzy_hash.rb', line 24

def clear
  hash.clear
  fuzzies.clear
  hash_reverse.clear
  fuzzies_reverse.clear
end

#delete_value(value) ⇒ Object 



60
61
62
 
# File 'lib/fuzzy_hash.rb', line 60

def delete_value(value)
  hash.delete(hash_reverse[value]) || ((rr = fuzzies_reverse[value]) && fuzzies.delete_at(rr[0]))
end

#each ⇒ Object 



55
56
57
58
 
# File 'lib/fuzzy_hash.rb', line 55

def each
  hash.each{|k,v| yield k,v }
  fuzzies.each{|v| yield v.first, v.last }
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


43
44
45
 
# File 'lib/fuzzy_hash.rb', line 43

def empty?
  hash.empty? && fuzzies.empty?
end

#keys ⇒ Object 



47
48
49
 
# File 'lib/fuzzy_hash.rb', line 47

def keys
  hash.keys + fuzzy_hash.keys
end

#match_with_result(key) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/fuzzy_hash.rb', line 102

def match_with_result(key)
  if hash.key?(key)
    [hash[key], key]
  else
    fuzzy_lookup(key)
  end
end

#replace(src, dest) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/fuzzy_hash.rb', line 82

def replace(src, dest)
  if hash_reverse.key?(src)
    key = hash_reverse[src]
    hash[key] = dest
    hash_reverse.delete(src)
    hash_reverse[dest] = key
  elsif fuzzies_reverse.key?(src)
    key = fuzzies_reverse[src]
    fuzzies[rkey[0]] = [rkey[1], dest]
    fuzzies_reverse.delete(src)
    fuzzies_reverse[dest] = [rkey[0], rkey[1], dest]
  end
end

#size ⇒ Object Also known as: count 



31
32
33
 
# File 'lib/fuzzy_hash.rb', line 31

def size
  hash.size + fuzzies.size
end

#values ⇒ Object 



51
52
53
 
# File 'lib/fuzzy_hash.rb', line 51

def values
  hash.values + fuzzies.collect{|r| r.last}
end