redis-bloomfilter 0.0.3 → 1.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YWU5ZWE2Mjg1OTVmMGVlZWQ0ZTZmNzkwNTE3MDJiNjI1OTI0MzMzYQ==
-  data.tar.gz: !binary |-
-    Zjg5NDkwNDdmOWZiOThlMWYxZTkyOWI1OGE2ODcxZmU1ZjZkMTZiYQ==
+SHA256:
+  metadata.gz: 03a3466f74223e60731f3054278118e7ce0d3745826469b3f752e0b916e664e1
+  data.tar.gz: 840df14ff183236d0c1dd78e954b43635c39469e82c845787b7741526edb4890
 SHA512:
-  metadata.gz: !binary |-
-    OTQ2YmM1Zjk2NTg4NjE4N2MwMjVlZDEyMmE3ZGE2MTlmMmE2NWM3YzdmYjJh
-    YjdjODBkM2QzN2NiNTgzNmUyMmY4OWNiNTBiNjhiYTU5OGRkNTI1NDNlOWNh
-    ZDJhYWNmMmZjOGQ5M2QxNjYyYzdmMmI4YmEzZjM4NzU0YjIwMzA=
-  data.tar.gz: !binary |-
-    YzkzMjg5ZTRhZDNlNGI1YTBlMzMwMjY4NDQ0N2RhMTM4MmE2ZmZmMTY1ZjQ3
-    NTg0MzM3NmM2MGE0N2JkYWMzMDI0NDdjZTFlMzMyMDMzNmU2ZmYzYTZkMjhl
-    ZjMxMTllZTVmZGY4YmMxZGUzYzExZGYyNWNmZmNlZTRiZTlmZGQ=
+  metadata.gz: 82d34182fd1599a6c88f87b6d04cfc0d1e01fe001920b8e7e6371e7bfb824549c21697853516b8f34b90c238616ed88a4b3d1e9c5e9e109430d87b20e0400f5e
+  data.tar.gz: 6595a1a50381052cd7bfdc4d4c73cf2710deab362168fd08aff1d1c14abb58a0a7ccfa219a04067b7b5f4175e351180d33f0d69f3477d591fad66a2cc168facf

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.1
+  - 2.6
+  - 2.5
+  - 2.4
+  - 2.3
 
 services:
   - redis

data/Gemfile

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

data/Rakefile

@@ -1,9 +1,11 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+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
+task default: :spec
+task test: :spec

data/benchmark/bf_100_000_flat.rb

@@ -1,23 +1,25 @@
-$:.push File.expand_path("../lib", __FILE__)
-require "redis-bloomfilter"
-require "benchmark"
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'redis-bloomfilter'
+require 'benchmark'
 items = 100_000
 error_rate = 0.01
-%w(lua ruby).each do |driver|
+%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
+      size: items,
+      error_rate: error_rate,
+      key_name: "bloom-filter-bench-flat-#{driver}",
+      driver: driver
     }
   )
   bf.clear
-  puts "---------------------------------------------"
+  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)) }}
+    x.report('insert:  ') { items.times { |_i| bf.insert(rand(items)) } }
+    x.report('include?:') { items.times { |_i| bf.include?(rand(items)) } }
   end
   puts
-end
+end

data/benchmark/bf_10_000.rb

@@ -1,11 +1,13 @@
-$:.push File.expand_path("../lib", __FILE__)
-require "redis-bloomfilter"
-require "benchmark"
-require "set"
+# frozen_string_literal: true
+
+$LOAD_PATH.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
+  @charset.sample(length).join
 end
 
 items = ARGV[0].nil? ? 10_000 : ARGV[0].to_i
@@ -16,10 +18,10 @@ error_rate = 0.01
 
   bf = Redis::Bloomfilter.new(
     {
-      :size       => items, 
-      :error_rate => error_rate, 
-      :key_name   => "bloom-filter-bench-#{driver}",
-      :driver     => driver
+      size: items,
+      error_rate: error_rate,
+      key_name: "bloom-filter-bench-#{driver}",
+      driver: driver
     }
   )
   bf.clear
@@ -27,7 +29,7 @@ error_rate = 0.01
   first_error_at = 0
   visited = Set.new
 
-  Benchmark.bm(7) do |x| 
+  Benchmark.bm(7) do |x|
     x.report do
       items.times do |i|
         item = rand_word
@@ -38,7 +40,7 @@ error_rate = 0.01
         end
         visited << item
         bf.insert item
-        #print ".(#{"%.1f" % ((i.to_f/items.to_f) * 100)}%) " if i % 1000 == 0
+        # print ".(#{"%.1f" % ((i.to_f/items.to_f) * 100)}%) " if i % 1000 == 0
       end
     end
   end
@@ -50,4 +52,4 @@ error_rate = 0.01
   puts "Error found: #{error}"
   puts "Error rate: #{(error.to_f / items)}"
   puts
-end
+end

data/examples/basic.rb

@@ -1,4 +1,6 @@
-require "redis-bloomfilter"
+# frozen_string_literal: true
+
+require 'redis-bloomfilter'
 
 # It creates a Bloom Filter using the default ruby driver
 # Number of elements expected : 10000
@@ -6,16 +8,16 @@ require "redis-bloomfilter"
 # 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'
+  size: 10_000,
+  error_rate: 0.01,
+  key_name: 'my-bloom-filter'
 )
 
 # Insert an element
-@bf.insert "foo"
+@bf.insert 'foo'
 # Check if an element exists
-puts @bf.include?("foo") # => true
-puts @bf.include?("bar") # => false
+puts @bf.include?('foo') # => true
+puts @bf.include?('bar') # => false
 
 # Empty the BF and delete the key stored on redis
 @bf.clear
@@ -23,16 +25,16 @@ puts @bf.include?("bar") # => false
 # 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'
+  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, 
+#   :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

@@ -1,7 +1,8 @@
-require "digest/sha1"
+# frozen_string_literal: true
+
+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
@@ -20,97 +21,94 @@ class Redis
         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
+        r = @redis.evalsha(@check_fnc_sha, keys: [@options[:key_name]], argv: [@options[:size], @options[:error_rate], key])
+        r == 1
       end
 
       def clear
-        @redis.keys("#{@options[:key_name]}:*").each {|k|@redis.del k}    
+        @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)
+
+      # 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 = "
+          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 = "
+
+          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)
-            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)
+              if redis.call('GETBIT', key, b[i] % bits) == 0 then
+                found = false
+                break
+              end
             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)])
+            if found then
+              return 1
             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
+          end
 
-              if found then
-                return 1
-              end
-            end
+          return 0
+        "
 
-            return 0
-          )
-          
-          @add_fnc_sha   = Digest::SHA1.hexdigest(add_fnc)
-          @check_fnc_sha = Digest::SHA1.hexdigest(check_fnc)
+        @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
+        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
+      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
+end

data/lib/bloomfilter_driver/ruby.rb

@@ -1,8 +1,9 @@
-require "digest/sha1"
+# frozen_string_literal: true
+
+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
@@ -11,58 +12,53 @@ class Redis
       end
 
       # Insert a new element
-      def insert(data) 
+      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
+        return false if @redis.getbit(@options[:key_name], indexes.shift).zero?
 
         result = @redis.pipelined do
-          indexes.each {|idx| @redis.getbit(@options[:key_name], idx)}
+          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
+      # Hashing strategy:
+      # https://www.eecs.harvard.edu/~michaelm/postscripts/tr-02-05.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 do |i|
+          v = (h[i % 2] + i * h[2 + (((i + (i % 2)) % 4) / 2)]) % @options[:bits]
+          idxs << v
         end
+        idxs
+      end
 
-        def set(key, val)
-          @redis.pipelined do
-            indexes_for(key).each {|i| @redis.setbit @options[:key_name], i, val}
-          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
+end

data/lib/bloomfilter_driver/ruby_test.rb

@@ -1,6 +1,8 @@
-require "digest/md5"
-require "digest/sha1"
-require "zlib"
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'digest/sha1'
+require 'zlib'
 class Redis
   module BloomfilterDriver
     # It uses different hash strategy
@@ -13,24 +15,19 @@ class Redis
       end
 
       # Insert a new element
-      def insert(data) 
+      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
+        return false if @redis.getbit(@options[:key_name], indexes.shift).zero?
 
         result = @redis.pipelined do
-          indexes.each {|idx| @redis.getbit(@options[:key_name], idx)}
+          indexes.each { |idx| @redis.getbit(@options[:key_name], idx) }
         end
 
         !result.include?(0)
@@ -42,31 +39,32 @@ class Redis
       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]
+      def indexes_for(key, engine = nil)
+        engine ||= @options[:hash_engine]
+        @options[:hashes].times do |i|
+          yield send("engine_#{engine}", key.to_s, i)
         end
+      end
 
-        def engine_md5(data, i)
-          Digest::MD5.hexdigest("#{i}-#{data}").to_i(16) % @options[:bits]
-        end
+      # A set of different hash functions
+      def engine_crc32(data, i)
+        Zlib.crc32("#{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 engine_md5(data, i)
+        Digest::MD5.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
+      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
+end

data/lib/redis-bloomfilter.rb

@@ -1,7 +1,9 @@
-require "redis"
-require "redis/connection/hiredis"
-require "redis/bloomfilter"
-require "redis/bloomfilter/version"
-require "bloomfilter_driver/ruby"
-require "bloomfilter_driver/lua"
-require "bloomfilter_driver/ruby_test"
+# frozen_string_literal: true
+
+require 'redis'
+require 'redis/connection/hiredis'
+require 'redis/bloomfilter'
+require 'redis/bloomfilter/version'
+require 'bloomfilter_driver/ruby'
+require 'bloomfilter_driver/lua'
+require 'bloomfilter_driver/ruby_test'

data/lib/redis/bloomfilter.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 class Redis
   class Bloomfilter
-
     attr_reader :options
     attr_reader :driver
 
@@ -8,17 +9,17 @@ class Redis
     # 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       => nil
+        size: 1000,
+        error_rate: 0.01,
+        key_name: 'redis-bloomfilter',
+        hash_engine: 'md5',
+        redis: Redis.current,
+        driver: nil
       }.merge options
 
-      raise ArgumentError, "options[:size] && options[:error_rate] cannot be nil" if options[:error_rate].nil? || options[:size].nil?
+      raise ArgumentError, 'options[:size] && options[:error_rate] cannot be nil' if options[:error_rate].nil? || options[:size].nil?
 
-      #Size provided, compute hashes and bits
+      # Size provided, compute hashes and bits
 
       @options[:size]       = options[:size]
       @options[:error_rate] = options[:error_rate] ? options[:error_rate] : @options[:error_rate]
@@ -31,27 +32,27 @@ class Redis
       if @options[:driver].nil?
         ver = @redis.info['redis_version']
 
-        if Gem::Version.new(ver) >= Gem::Version.new('2.6.0')
-          @options[:driver] = 'lua'
-        else
-          @options[:driver] = 'ruby'
-        end
+        @options[:driver] = if Gem::Version.new(ver) >= Gem::Version.new('2.6.0')
+                              'lua'
+                            else
+                              'ruby'
+                            end
       end
 
       driver_class = Redis::BloomfilterDriver.const_get(driver_name)
       @driver = driver_class.new @options
-      @driver.redis = @redis 
+      @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
+    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
+    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 += 1 if h.zero?
       h
     end
 
@@ -65,19 +66,15 @@ class Redis
       @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
 
+    def driver_name
+      @options[:driver].downcase.split('-').collect { |t| t.gsub(/(\w+)/, &:capitalize) }.join
+    end
   end
-end
+end

data/lib/redis/bloomfilter/version.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Redis
   class Bloomfilter
-    VERSION = "0.0.3"
+    VERSION = '1.0.0'
     def self.version
       "redis-bloomfilter version #{VERSION}"
     end
   end
-end
+end

data/redis-bloomfilter.gemspec

@@ -1,31 +1,32 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "redis/bloomfilter/version"
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'redis/bloomfilter/version'
 
 Gem::Specification.new do |s|
-  s.name        = "redis-bloomfilter"
+  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{
+  s.authors     = ['Francesco Laurita']
+  s.email       = ['francesco.laurita@gmail.com']
+  s.homepage    = 'https://github.com/taganaka/redis-bloomfilter'
+  s.summary     = 'Distributed Bloom Filter implementation on Redis'
+  s.description = '
     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.licenses = ['MIT']
-  s.rubyforge_project = "redis-bloomfilter"
+  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_runtime_dependency 'hiredis', '~> 0.5', '>= 0.5.2'
-  s.add_runtime_dependency 'redis', '~> 3.0', '>= 3.0.4'
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "flexmock"
-  s.add_development_dependency "rake"
+  s.add_runtime_dependency 'hiredis', '~> 0.6.1'
+  s.add_runtime_dependency 'redis', '~> 4.0', '>= 4.0.1'
 
+  s.add_development_dependency 'flexmock'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
 end

data/spec/redis_bloomfilter_spec.rb

@@ -1,11 +1,12 @@
-require "spec_helper"
-require "set"
+# frozen_string_literal: true
 
+require 'spec_helper'
+require 'set'
 
-def test_error_rate(bf,elems)
+def test_error_rate(bf, elems)
   visited = Set.new
   error = 0
-  elems.times do |i|
+  elems.times do |_i|
     a = rand(elems)
     error += 1 if bf.include?(a) != visited.include?(a)
     visited << a
@@ -14,86 +15,78 @@ def test_error_rate(bf,elems)
   error.to_f / elems
 end
 
-def factory options, driver
+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}"
+    expect(Redis::Bloomfilter.version).to 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)
+    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 choose the right driver based on the Redis version' do
-    
-    redis_mock = flexmock("redis")
-    redis_mock.should_receive(:info).and_return({'redis_version' => '2.6.0'})
+    redis_mock = flexmock('redis')
+    redis_mock.should_receive(:info).and_return({ 'redis_version' => '2.6.0' })
     redis_mock.should_receive(:script).and_return([true, true])
-    redis_mock_2_5 = flexmock("redis_2_5")
-    redis_mock_2_5.should_receive(:info).and_return({'redis_version' => '2.5.0'})
+    redis_mock_2_5 = flexmock('redis_2_5')
+    redis_mock_2_5.should_receive(:info).and_return({ 'redis_version' => '2.5.0' })
 
-    bf = factory({:size => 1000, :error_rate => 0.01, :key_name => 'ossom', :redis => redis_mock}, nil)
-    bf.driver.should be_kind_of(Redis::BloomfilterDriver::Lua)
+    bf = factory({ size: 1000, error_rate: 0.01, key_name: 'ossom', redis: redis_mock }, nil)
+    expect(bf.driver).to be_kind_of(Redis::BloomfilterDriver::Lua)
 
-    bf = factory({:size => 1000, :error_rate => 0.01, :key_name => 'ossom', :redis => redis_mock_2_5}, nil)
-    bf.driver.should be_kind_of(Redis::BloomfilterDriver::Ruby)
+    bf = factory({ size: 1000, error_rate: 0.01, key_name: 'ossom', redis: redis_mock_2_5 }, nil)
+    expect(bf.driver).to be_kind_of(Redis::BloomfilterDriver::Ruby)
   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 = factory({ size: 1000, error_rate: 0.01, key_name: 'ossom' }, 'ruby')
+    expect(bf).to be
+    expect(bf.options[:size]).to eq 1000
+    expect(bf.options[:bits]).to eq 9585
+    expect(bf.options[:hashes]).to eq 6
+    expect(bf.options[:key_name]).to eq 'ossom'
     bf.clear
   end
 
-  %w(ruby lua ruby-test).each do |driver|
+  %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 = 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
+      expect(bf.include?('asdlol')).to be false
+      bf.insert 'asdlol'
+      expect(bf.include?('asdlol')).to be true
       bf.clear
-      bf.include?("asdlol").should be false
+      expect(bf.include?('asdlol')).to be false
     end
 
     it 'should honor the error rate' do
-      bf = factory({:size => 100, :error_rate => 0.01, :key_name => '__test_bf'},driver)
+      bf = factory({ size: 100, error_rate: 0.02, key_name: '__test_bf' }, driver)
       bf.clear
       e = test_error_rate bf, 180
-      e.should be <= bf.options[:error_rate]
+      expect(e.round(2)).to be <= bf.options[:error_rate].round(2)
       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
-      
+    it 'should add an element to the filter' do
+      bf = factory({ size: 100, error_rate: 0.01, key_name: '__test_bf' }, driver)
+      bf.insert 'asdlolol'
+      expect(bf.include?('asdlolol')).to be true
     end
   end
 
   it 'should be a scalable bloom filter' do
-    bf = factory({:size => 10, :error_rate => 0.01, :key_name => '__test_bf'},'lua')
+    bf = factory({ size: 100, error_rate: 0.02, key_name: '__test_bf' }, 'lua')
     bf.clear
-    e = test_error_rate(bf, 100)
-    e.should be <= bf.options[:error_rate]
+    e = test_error_rate(bf, 150)
+    expect(e).to be <= bf.options[:error_rate]
     bf.clear
-    
   end
-
-end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # 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
@@ -5,7 +7,6 @@
 #
 # 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
   config.mock_with :flexmock
@@ -17,6 +18,5 @@ RSpec.configure do |config|
   config.order = 'random'
 end
 
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require "redis-bloomfilter"
-
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'redis-bloomfilter'

metadata

@@ -1,98 +1,92 @@
 --- !ruby/object:Gem::Specification
 name: redis-bloomfilter
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Francesco Laurita
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-24 00:00:00.000000000 Z
+date: 2018-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hiredis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.5'
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.6.1
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-    - - ! '>='
+        version: '4.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-    - - ! '>='
+        version: '4.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 4.0.1
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: flexmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: flexmock
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "\n    Adds Redis::Bloomfilter class which can be used as ditributed
+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:
@@ -101,9 +95,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -130,17 +124,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: redis-bloomfilter
-rubygems_version: 2.2.2
+rubygems_version: 2.7.2
 signing_key: 
 specification_version: 4
 summary: Distributed Bloom Filter implementation on Redis