redis-bloomfilter 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in redis-bloomfilter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Francesco Laurita
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+redis-bloomfilter
+=============
+Requires the redis gem.
+
+Adds Redis::Bloomfilter class which can be used as ditributed bloom filter implementation on Redis.
+
+A Bloom filter is a space-efficient probabilistic data structure that is used to test whether an element is a member of a set.
+
+
+Installation
+----------------
+    $ gem install redis-bloomfilter
+
+Testing
+----------------
+    $ bundle install
+    $ rake
+
+Drivers
+-----------------
+The library contains a set of different drivers.
+  * A pure Ruby implementation
+  * A server-side version based on lua available for Redis v. >= 2.6
+
+How to use
+-----------------
+```ruby
+require "redis-bloomfilter"
+
+# It creates a Bloom Filter using the default ruby driver
+# Number of elements expected : 10000
+# Max error rate: 1%
+# Key name on Redis: my-bloom-filter
+# Redis: 127.0.0.1:6379 or an already existing connection
+@bf = Redis::Bloomfilter.new(
+  :size => 10_000, 
+  :error_rate => 0.01, 
+  :key_name => 'my-bloom-filter'
+)
+
+# Insert an element
+@bf.insert "foo"
+# Check if an element exists
+puts @bf.include?("foo") # => true
+puts @bf.include?("bar") # => false
+
+# Empty the BF and delete the key stored on redis
+@bf.clear
+
+# Using Lua's driver: only available on Redis >= 2.6.0
+# This driver should be prefered because is faster
+@bf = Redis::Bloomfilter.new(
+  :size => 10_000, 
+  :error_rate => 0.01, 
+  :key_name   => 'my-bloom-filter-lua',
+  :driver     => 'lua'
+)
+
+# Specify a redis connection:
+# @bf = Redis::Bloomfilter.new(
+#   :size => 10_000, 
+#   :error_rate => 0.01, 
+#   :key_name   => 'my-bloom-filter-lua',
+#   :driver     => 'lua',
+#   :redis      => Redis.new(:host => "10.0.1.1", :port => 6380)
+# )
+```
+
+Performance & Memory Usage
+-----------------
+```
+---------------------------------------------
+Benchmarking lua driver with 1000000 items
+              user     system      total        real
+insert:   38.620000  17.690000  56.310000 (160.377977)
+include?: 43.420000  20.600000  64.020000 (175.055146)
+
+---------------------------------------------
+Benchmarking ruby driver with 1000000 items
+              user     system      total        real
+insert:  125.910000  20.250000 146.160000 (195.973994)
+include?:121.230000  36.260000 157.490000 (231.360137)
+```
+The lua version is about ~3 times faster than the pure-Ruby version
+
+Lua code is taken from https://github.com/ErikDubbelboer/redis-lua-scaling-bloom-filter
+
+1.000.000 ~= 1.5Mb occuped on Redis
+
+Contributing to redis-bloomfilter
+----------------
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+----------------
+
+Copyright (c) 2013 Francesco Laurita. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+end
+
+task :default => :spec
+task :test    => :spec

data/benchmark/bf_100_000_flat.rb

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "redis-bloomfilter"
+require "benchmark"
+items = 100_000
+error_rate = 0.01
+%w(lua ruby).each do |driver|
+  bf = Redis::Bloomfilter.new(
+    {
+      :size       => items, 
+      :error_rate => error_rate, 
+      :key_name   => "bloom-filter-bench-flat-#{driver}",
+      :driver     => driver
+    }
+  )
+  bf.clear
+  puts "---------------------------------------------"
+  puts "Benchmarking #{driver} driver with #{items} items"
+  Benchmark.bm(7) do |x|
+    x.report("insert:  ") {items.times { |i| bf.insert(rand(items)) }}
+    x.report("include?:") {items.times { |i| bf.include?(rand(items)) }}
+  end
+  puts
+end

data/benchmark/bf_10_000.rb

@@ -0,0 +1,53 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "redis-bloomfilter"
+require "benchmark"
+require "set"
+
+def rand_word(length = 8)
+  @charset ||= ('a'..'z').to_a
+  @charset.shuffle.first(length).join
+end
+
+items = ARGV[0].nil? ? 10_000 : ARGV[0].to_i
+error_rate = 0.01
+
+['lua', 'ruby', 'ruby-test'].each do |driver|
+  puts "Testing #{driver} driver..."
+
+  bf = Redis::Bloomfilter.new(
+    {
+      :size       => items, 
+      :error_rate => error_rate, 
+      :key_name   => "bloom-filter-bench-#{driver}",
+      :driver     => driver
+    }
+  )
+  bf.clear
+  error = 0
+  first_error_at = 0
+  visited = Set.new
+
+  Benchmark.bm(7) do |x| 
+    x.report do
+      items.times do |i|
+        item = rand_word
+
+        if bf.include?(item) != visited.include?(item)
+          error += 1
+          first_error_at = i if error == 1
+        end
+        visited << item
+        bf.insert item
+        #print ".(#{"%.1f" % ((i.to_f/items.to_f) * 100)}%) " if i % 1000 == 0
+      end
+    end
+  end
+  bf.clear
+  puts "Bloomfilter no of Bits: #{bf.options[:bits]} in Mb: #{(bf.options[:bits].to_f / 8 / 1024 / 1024)}"
+  puts "Bloomfilter no of hashes used: #{bf.options[:hashes]}"
+  puts "Items added: #{items}"
+  puts "First error found at: #{first_error_at}"
+  puts "Error found: #{error}"
+  puts "Error rate: #{(error.to_f / items)}"
+  puts
+end

data/examples/basic.rb

@@ -0,0 +1,39 @@
+require "redis-bloomfilter"
+
+# It creates a Bloom Filter using the default ruby driver
+# Number of elements expected : 10000
+# Max error rate: 1%
+# Key name on Redis: my-bloom-filter
+# Redis: 127.0.0.1:6379 or an already existing connection
+@bf = Redis::Bloomfilter.new(
+  :size => 10_000, 
+  :error_rate => 0.01, 
+  :key_name => 'my-bloom-filter'
+)
+
+# Insert an element
+@bf.insert "foo"
+# Check if an element exists
+puts @bf.include?("foo") # => true
+puts @bf.include?("bar") # => false
+
+# Empty the BF and delete the key stored on redis
+@bf.clear
+
+# Using Lua's driver: only available on Redis >= 2.6.0
+# This driver should be prefered because is faster
+@bf = Redis::Bloomfilter.new(
+  :size => 10_000, 
+  :error_rate => 0.01, 
+  :key_name   => 'my-bloom-filter-lua',
+  :driver     => 'lua'
+)
+
+# Specify a redis connection:
+# @bf = Redis::Bloomfilter.new(
+#   :size => 10_000, 
+#   :error_rate => 0.01, 
+#   :key_name   => 'my-bloom-filter-lua',
+#   :driver     => 'lua',
+#   :redis      => Redis.new(:host => "10.0.1.1", :port => 6380)
+# )

data/lib/bloomfilter_driver/lua.rb

@@ -0,0 +1,116 @@
+require "digest/sha1"
+class Redis
+  module BloomfilterDriver
+
+    # It loads lua script into redis.
+    # BF implementation is done by lua scripting
+    # The alghoritm is executed directly on redis
+    # Credits for lua code goes to Erik Dubbelboer
+    # https://github.com/ErikDubbelboer/redis-lua-scaling-bloom-filter
+    class Lua
+      attr_accessor :redis
+
+      def initialize(options = {})
+        @options = options
+        @redis = @options[:redis]
+        lua_load
+      end
+
+      def insert(data)
+        set data, 1
+      end
+
+      def remove(data)
+        set data, 0
+      end
+
+      def include?(key)
+        r = @redis.evalsha(@check_fnc_sha, :keys => [@options[:key_name]], :argv => [@options[:size], @options[:error_rate], key])
+        r == 1 ? true : false
+      end
+
+      def clear
+        @redis.keys("#{@options[:key_name]}:*").each {|k|@redis.del k}    
+      end
+
+      protected
+        # It loads the script inside Redis
+        # Taken from https://github.com/ErikDubbelboer/redis-lua-scaling-bloom-filter
+        # This is a scalable implementation of BF. It means the initial size can vary
+        def lua_load
+          add_fnc = %q(
+            local entries   = ARGV[1]
+            local precision = ARGV[2]
+            local set_value = ARGV[4]
+            local index     = math.ceil(redis.call('INCR', KEYS[1] .. ':count') / entries)
+            local key       = KEYS[1] .. ':' .. index
+            local bits = math.floor(-(entries * math.log(precision * math.pow(0.5, index))) / 0.480453013)
+            local k = math.floor(0.693147180 * bits / entries)
+            local hash = redis.sha1hex(ARGV[3])
+            local h = { }
+            h[0] = tonumber(string.sub(hash, 0 , 8 ), 16)
+            h[1] = tonumber(string.sub(hash, 8 , 16), 16)
+            h[2] = tonumber(string.sub(hash, 16, 24), 16)
+            h[3] = tonumber(string.sub(hash, 24, 32), 16)
+            for i=1, k do
+              redis.call('SETBIT', key, (h[i % 2] + i * h[2 + (((i + (i % 2)) % 4) / 2)]) % bits, set_value)
+            end
+          )
+          
+          check_fnc = %q(
+
+            local entries   = ARGV[1]
+            local precision = ARGV[2]
+            local index     = redis.call('GET', KEYS[1] .. ':count')
+            if not index then
+              return 0
+            end
+            index     = math.ceil(redis.call('GET', KEYS[1] .. ':count') / entries)
+            local hash = redis.sha1hex(ARGV[3])
+            local h = { }
+            h[0] = tonumber(string.sub(hash, 0 , 8 ), 16)
+            h[1] = tonumber(string.sub(hash, 8 , 16), 16)
+            h[2] = tonumber(string.sub(hash, 16, 24), 16)
+            h[3] = tonumber(string.sub(hash, 24, 32), 16)
+            local maxk = math.floor(0.693147180 * math.floor((entries * math.log(precision * math.pow(0.5, index))) / -0.480453013) / entries)
+            local b    = { }
+            for i=1, maxk do
+              table.insert(b, h[i % 2] + i * h[2 + (((i + (i % 2)) % 4) / 2)])
+            end
+            for n=1, index do
+              local key   = KEYS[1] .. ':' .. n
+              local found = true
+              local bits = math.floor((entries * math.log(precision * math.pow(0.5, n))) / -0.480453013)
+              local k = math.floor(0.693147180 * bits / entries)
+
+              for i=1, k do
+                if redis.call('GETBIT', key, b[i] % bits) == 0 then
+                  found = false
+                  break
+                end
+              end
+
+              if found then
+                return 1
+              end
+            end
+
+            return 0
+          )
+          
+          @add_fnc_sha   = Digest::SHA1.hexdigest(add_fnc)
+          @check_fnc_sha = Digest::SHA1.hexdigest(check_fnc)
+
+          loaded = @redis.script(:exists, [@add_fnc_sha, @check_fnc_sha]).uniq
+          if loaded.count != 1 || loaded.first != true
+            @add_fnc_sha   = @redis.script(:load, add_fnc)
+            @check_fnc_sha = @redis.script(:load, check_fnc)
+          end
+        end
+
+        def set(data, val)
+          @redis.evalsha(@add_fnc_sha, :keys => [@options[:key_name]], :argv => [@options[:size], @options[:error_rate], data, val])
+        end
+    end
+  end
+end

data/lib/bloomfilter_driver/ruby.rb

@@ -0,0 +1,68 @@
+require "digest/sha1"
+class Redis
+  module BloomfilterDriver
+    class Ruby
+      
+      # Faster Ruby version.
+      # This driver should be used if Redis version < 2.6
+      attr_accessor :redis
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Insert a new element
+      def insert(data) 
+        set data, 1
+      end
+
+      # It checks if a key is part of the set
+      def include?(key)
+
+        indexes = []
+        indexes_for(key).each { |idx| indexes << idx }
+        return false if @redis.getbit(@options[:key_name], indexes.shift) == 0
+
+        result = @redis.pipelined do
+          indexes.each {|idx| @redis.getbit(@options[:key_name], idx)}
+        end
+
+        !result.include?(0)
+      end
+
+      # It removes an element from the filter
+      def remove(data)
+        set data, 0
+      end
+
+      # It deletes a bloomfilter
+      def clear
+        @redis.del @options[:key_name]
+      end
+
+      protected
+        # Hashing strategy: 
+        # http://www.eecs.harvard.edu/~kirsch/pubs/bbbf/esa06.pdf
+        def indexes_for data
+          sha = Digest::SHA1.hexdigest(data.to_s)
+          h = []
+          h[0] = sha[0...8].to_i(16)
+          h[1] = sha[8...16].to_i(16)
+          h[2] = sha[16...24].to_i(16)
+          h[3] = sha[24...32].to_i(16)
+          idxs = []
+
+          (@options[:hashes]).times {|i|
+            v = (h[i % 2] + i * h[2 + (((i + (i % 2)) % 4) / 2)]) % @options[:bits]
+            idxs << v
+          }
+          idxs
+        end
+
+        def set(key, val)
+          @redis.pipelined do
+            indexes_for(key).each {|i| @redis.setbit @options[:key_name], i, val}
+          end
+        end
+    end
+  end
+end

data/lib/bloomfilter_driver/ruby_test.rb

@@ -0,0 +1,72 @@
+require "digest/md5"
+require "digest/sha1"
+require "zlib"
+class Redis
+  module BloomfilterDriver
+    # It uses different hash strategy
+    # Usefule for benchmarking
+    class RubyTest
+      attr_accessor :redis
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Insert a new element
+      def insert(data) 
+        set data, 1
+      end
+
+      # Insert a new element
+      def remove(data) 
+        set data, 0
+      end
+
+      # It checks if a key is part of the set
+      def include?(key)
+        indexes = []
+        indexes_for(key) { |idx| indexes << idx }
+
+        return false if @redis.getbit(@options[:key_name], indexes.shift) == 0
+
+        result = @redis.pipelined do
+          indexes.each {|idx| @redis.getbit(@options[:key_name], idx)}
+        end
+
+        !result.include?(0)
+      end
+
+      # It deletes a bloomfilter
+      def clear
+        @redis.del @options[:key_name]
+      end
+
+      protected
+        def indexes_for(key, engine = nil)
+          engine ||= @options[:hash_engine]
+          @options[:hashes].times do |i|
+            yield self.send("engine_#{engine}", key.to_s, i)
+          end
+        end
+
+        # A set of different hash functions
+        def engine_crc32(data, i)
+          Zlib.crc32("#{i}-#{data}").to_i(16) % @options[:bits]
+        end
+
+        def engine_md5(data, i)
+          Digest::MD5.hexdigest("#{i}-#{data}").to_i(16) % @options[:bits]
+        end
+
+        def engine_sha1(data, i)
+          Digest::SHA1.hexdigest("#{i}-#{data}").to_i(16) % @options[:bits]
+        end
+
+        def set(data, val)
+          @redis.pipelined do
+            indexes_for(data) { |i| @redis.setbit @options[:key_name], i, val }
+          end
+        end
+    end
+  end
+end

data/lib/redis-bloomfilter.rb

@@ -0,0 +1,6 @@
+require "redis"
+require "redis/connection/hiredis"
+require "redis/bloomfilter"
+require "bloomfilter_driver/ruby"
+require "bloomfilter_driver/lua"
+require "bloomfilter_driver/ruby_test"

data/lib/redis/bloomfilter.rb

@@ -0,0 +1,78 @@
+class Redis
+  class Bloomfilter
+
+    VERSION = "0.0.1"
+
+    def self.version
+      "redis-bloomfilter version #{VERSION}"
+    end
+
+    attr_reader :options
+    attr_reader :driver
+
+    # Usage: Redis::Bloomfilter.new :size => 1000, :error_rate => 0.01
+    # It creates a bloomfilter with a capacity of 1000 items and an error rate of 1%
+    def initialize(options = {})
+      @options = {
+        :size         => 1000,
+        :error_rate   => 0.01,
+        :key_name     => 'redis-bloomfilter',
+        :hash_engine  => 'md5',
+        :redis        => Redis.current,
+        :driver       => 'ruby'
+      }.merge options
+
+      raise ArgumentError, "options[:size] && options[:error_rate] cannot be nil" if options[:error_rate].nil? || options[:size].nil?
+
+      #Size provided, compute hashes and bits
+
+      @options[:size]       = options[:size]
+      @options[:error_rate] = options[:error_rate] ? options[:error_rate] : @options[:error_rate]
+      @options[:bits]       = Bloomfilter.optimal_m options[:size], @options[:error_rate]
+      @options[:hashes]     = Bloomfilter.optimal_k options[:size], @options[:bits]
+
+      @redis = @options[:redis] || Redis.current
+      @options[:hash_engine] = options[:hash_engine] if options[:hash_engine]
+      driver_class = Redis::BloomfilterDriver.const_get(driver_name)
+      @driver = driver_class.new @options
+      @driver.redis = @redis 
+    end
+
+    # Methods used to calculate M and K
+    # Taken from http://en.wikipedia.org/wiki/Bloom_filter#Probability_of_false_positives
+    def self.optimal_m num_of_elements, false_positive_rate = 0.01
+      (-1 * (num_of_elements) * Math.log(false_positive_rate) / (Math.log(2) ** 2)).round
+    end
+
+    def self.optimal_k num_of_elements, bf_size
+      h = (Math.log(2) * (bf_size / num_of_elements)).round
+      h+=1 if h == 0
+      h
+    end
+
+    # Insert a new element
+    def insert(data)
+      @driver.insert data
+    end
+
+    # It checks if a key is part of the set
+    def include?(key)
+      @driver.include?(key)
+    end
+
+    def remove(key)
+      @driver.remove key if @driver.respond_to? :remove
+    end
+
+    # It deletes a bloomfilter
+    def clear
+      @driver.clear
+    end
+
+    protected
+      def driver_name
+        @options[:driver].downcase.split('-').collect{|t| t.gsub(/(\w+)/){|s|s.capitalize}}.join
+      end
+
+  end
+end

data/redis-bloomfilter.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis-bloomfilter"
+
+Gem::Specification.new do |s|
+  s.name        = "redis-bloomfilter"
+  s.version     = Redis::Bloomfilter::VERSION
+  s.authors     = ["Francesco Laurita"]
+  s.email       = ["francesco.laurita@gmail.com"]
+  s.homepage    = "https://github.com/taganaka/redis-bloomfilter"
+  s.summary     = %q{Distributed Bloom Filter implementation on Redis}
+  s.description = %q{
+    Adds Redis::Bloomfilter class which can be used as ditributed bloom filter implementation on Redis.
+    A Bloom filter is a space-efficient probabilistic data structure that is used to test whether an element is a member of a set.
+  }
+
+  s.rubyforge_project = "redis-bloomfilter"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "hiredis", "~> 0.4.5"
+  s.add_dependency "redis", "~> 3.0.4"
+
+  s.add_development_dependency "rspec"
+
+end

data/spec/redis_bloomfilter_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "set"
+
+
+def test_error_rate(bf,elems)
+  visited = Set.new
+  error = 0
+  elems.times do |i|
+    a = rand(elems)
+    error += 1 if bf.include?(a) != visited.include?(a)
+    visited << a
+    bf.insert a
+  end
+  error.to_f / elems
+end
+
+def factory options, driver
+  options[:driver] = driver
+  Redis::Bloomfilter.new options
+end
+
+describe Redis::Bloomfilter do
+
+  it 'should return the right version' do
+    Redis::Bloomfilter.version.should eq "redis-bloomfilter version #{Redis::Bloomfilter::VERSION}"
+  end
+
+  it 'should check for the initialize options' do
+    expect { Redis::Bloomfilter.new }.to raise_error(ArgumentError)
+    expect { Redis::Bloomfilter.new :size => 123 }.to raise_error(ArgumentError)
+    expect { Redis::Bloomfilter.new :error_rate => 0.01 }.to raise_error(ArgumentError)
+    expect { Redis::Bloomfilter.new :size => 123,:error_rate => 0.01, :driver => 'bibu' }.to raise_error(NameError)
+  end
+
+  it 'should create a Redis::Bloomfilter object' do
+    bf = factory({:size => 1000, :error_rate => 0.01, :key_name => 'ossom'}, 'ruby')
+    bf.should be
+    bf.options[:size].should eq 1000
+    bf.options[:bits].should eq 9585
+    bf.options[:hashes].should eq 6
+    bf.options[:key_name].should eq 'ossom'
+    bf.clear
+  end
+
+  %w(ruby lua ruby-test).each do |driver|
+    it 'should work' do
+      bf = factory({:size => 1000, :error_rate => 0.01, :key_name => '__test_bf'},driver)
+      bf.clear
+      bf.include?("asdlol").should be false
+      bf.insert "asdlol"
+      bf.include?("asdlol").should be true
+      bf.clear
+      bf.include?("asdlol").should be false
+    end
+
+    it 'should honor the error rate' do
+      bf = factory({:size => 100, :error_rate => 0.01, :key_name => '__test_bf'},driver)
+      bf.clear
+      e = test_error_rate bf, 180
+      e.should be < bf.options[:error_rate]
+      bf.clear
+    end
+
+    it 'should remove an elemnt from the filter' do 
+
+      bf = factory({:size => 100, :error_rate => 0.01, :key_name => '__test_bf'},driver)
+      bf.insert "asdlolol"
+      bf.include?("asdlolol").should be true
+      bf.remove "asdlolol"
+      bf.include?("asdlolol").should be false
+      
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'redis-bloomfilter'

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: redis-bloomfilter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Francesco Laurita
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "\n    Adds Redis::Bloomfilter class which can be used as ditributed
+  bloom filter implementation on Redis.\n    A Bloom filter is a space-efficient probabilistic
+  data structure that is used to test whether an element is a member of a set.\n  "
+email:
+- francesco.laurita@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/bf_100_000_flat.rb
+- benchmark/bf_10_000.rb
+- examples/basic.rb
+- lib/bloomfilter_driver/lua.rb
+- lib/bloomfilter_driver/ruby.rb
+- lib/bloomfilter_driver/ruby_test.rb
+- lib/redis-bloomfilter.rb
+- lib/redis/bloomfilter.rb
+- redis-bloomfilter.gemspec
+- spec/redis_bloomfilter_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/taganaka/redis-bloomfilter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: redis-bloomfilter
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Distributed Bloom Filter implementation on Redis
+test_files:
+- spec/redis_bloomfilter_spec.rb
+- spec/spec_helper.rb