fuzzyhash 0.0.7 → 0.0.8

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 0
-:patch: 7
+:patch: 8
 :major: 0

data/lib/fuzzy_hash.rb

@@ -1,112 +1,135 @@
+require 'set'
+
 class FuzzyHash
+
+  def self.always_fuzzy(init_hash = nil)
+    hash = new(init_hash)
+    hash.classes_to_fuzz = nil    
+    hash
+  end
+  
+  attr_accessor :classes_to_fuzz
   
-  def initialize(init_hash = nil)
-    @regexes = []
+  def initialize(init_hash = nil, classes_to_fuzz = nil)
+    @fuzzies = []
     @hash_reverse = {}
-    @regexes_reverse = {}
+    @fuzzies_reverse = {}
     @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
   
   def clear
-    @hash.clear
-    @regexes.clear
-    @hash_reverse.clear
-    @regexes_reverse.clear
+    hash.clear
+    fuzzies.clear
+    hash_reverse.clear
+    fuzzies_reverse.clear
   end
   
   def size
-    @hash.size + @regexes.size
+    hash.size + fuzzies.size
   end
   alias_method :count, :size
   
   
   def ==(o)
     o.is_a?(FuzzyHash)
-    o.instance_variable_get(:@hash) == @hash &&
-    o.instance_variable_get(:@regexes) == @regexes
+    o.send(:hash) == hash &&
+    o.send(:fuzzies) == fuzzies
   end
   
   def empty?
-    @hash.empty? && @regexes.empty?
+    hash.empty? && fuzzies.empty?
   end
   
   def keys
-    @hash.keys + @regexes.collect{|r| r.first}
+    hash.keys + fuzzies.collect{|r| r.first}
   end
   
   def values
-    @hash.values + @regexes.collect{|r| r.last}
+    hash.values + fuzzies.collect{|r| r.last}
   end
   
   def each
-    @hash.each{|k,v| yield k,v }
-    @regexes.each{|v| yield v.first, v.last }
+    hash.each{|k,v| yield k,v }
+    fuzzies.each{|v| yield v.first, v.last }
   end
   
   def delete_value(value)
-    @hash.delete(@hash_reverse[value]) || ((rr = @regexes_reverse[value]) && @regexes.delete_at(rr[0]))
+    hash.delete(hash_reverse[value]) || ((rr = fuzzies_reverse[value]) && fuzzies.delete_at(rr[0]))
   end
   
   def []=(key, value)
-    case key
-    when Regexp
-      @regexes << [key, value]
-      @regex_test = nil
-      @regexes_reverse[value] = [@regexes.size - 1, 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.hash == key.hash}
+
+      fuzzies << [key, value]
+      reset_fuzz_test!
+      fuzzies_reverse[value] = [fuzzies.size - 1, key, value]
     else
-      @hash[key] = value
-      @hash_reverse[value] = key
+      hash[key] = value
+      hash_reverse.delete_if{|k,v| v.hash == key.hash}
+      hash_reverse[value] = key
     end
     value
   end
   
   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 @regexes_reverse.key?(src)
-      key = @regexes_reverse[src]
-      @regexes[rkey[0]] = [rkey[1], dest]
-      @regexes_reverse.delete(src)
-      @regexes_reverse[dest] = [rkey[0], rkey[1], 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
   
   def [](key)
-    @hash.key?(key) ? @hash[key] : (lookup = regex_lookup(key)) && lookup && lookup.first
+    hash.key?(key) ? hash[key] : (lookup = fuzzy_lookup(key)) && lookup && lookup.first
   end
   
   def match_with_result(key)
-    if @hash.key?(key)
-      [@hash[key], key]
+    if hash.key?(key)
+      [hash[key], key]
     else
-      regex_lookup(key)
+      fuzzy_lookup(key)
     end
   end
   
   private
-  def regex_test
-    unless @regex_test
-      @regex_test = Object.new
-      @regex_test.instance_variable_set(:'@regexes', @regexes)
+  attr_reader :fuzzies, :hash_reverse, :fuzzies_reverse, :hash
+  attr_writer :fuzz_test
+  
+  def reset_fuzz_test!
+    self.fuzz_test = nil
+  end
+  
+  def fuzz_test
+    unless @fuzz_test
+      @fuzz_test = Object.new
+      @fuzz_test.instance_variable_set(:'@fuzzies', fuzzies)
       method = "
         def match(str)
           case str
       "
-      @regexes.each_with_index do |reg, index|
-        method << "when #{reg.first.inspect}: [@regexes[#{index}][1], str]\n"
+      fuzzies.each_with_index do |reg, index|
+        method << "when #{reg.first.inspect}: [@fuzzies[#{index}][1], str]\n"
       end
       method << "end\nend\n"
-      @regex_test.instance_eval method
+      
+      @fuzz_test.instance_eval method
     end
-    @regex_test
+    @fuzz_test
   end
   
-  def regex_lookup(key)
-    if !@regexes.empty? && key.is_a?(String) && (value = regex_test.match(key))
+  def fuzzy_lookup(key)
+    if !fuzzies.empty? && (value = fuzz_test.match(key))
       value
     end
   end

data/spec/fuzzy_hash_spec.rb

@@ -8,12 +8,26 @@ describe "Fuzzy hash" do
     l['asd'].should == 'qwe'
   end
   
+  it "should accept strings, but the second time you set the same string, it should overwrite" do
+    l = FuzzyHash.new
+    l['asd'] = 'asd'
+    l['asd'] = 'qwe'
+    l['asd'].should == 'qwe'
+  end
+
   it "should accept regexs too" do
     l = FuzzyHash.new
     l[/asd.*/] = 'qwe'
     l['asdqweasd'].should == 'qwe'
   end
 
+  it "should accept regexs too, but the second time you set the same regex, it should overwrite" do
+    l = FuzzyHash.new
+    l[/asd/] = 'asd'
+    l[/asd/] = 'qwe'
+    l['asdqweasd'].should == 'qwe'
+  end
+
   it "should accept regexs too with the match" do
     l = FuzzyHash.new
     l[/asd.*/] = 'qwe'
@@ -45,6 +59,19 @@ describe "Fuzzy hash" do
     l['false'].should == 'everything else'
   end
 
+  it "always fuzzy should accept .. well.. anything" do
+    l = FuzzyHash.always_fuzzy
+    l[1..3] = '1 to 3'
+    l[4] = 'four'
+    l[5..10] = '5 and up'
+    l[/.*/] = 'whatev'
+    
+    l[2].should  == '1 to 3'
+    l[4].should  == 'four'
+    l[8].should  == '5 and up'
+    l['something'].should == 'whatev'
+  end
+
   it "should pick between the correct regex" do
     hash = FuzzyHash.new
     hash[/^\d+$/] = 'number'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fuzzyhash
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-25 00:00:00 -04:00
+date: 2009-10-11 00:00:00 -04:00
 default_executable: 
 dependencies: []