bloom_fit 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f1a3e06592409a17a287562a4f51910e4c103cc7e7a95fa18b051e684ec2f72
-  data.tar.gz: 85dab6561d4626f1ece379cbdd63678befac1e19d8f3cc403a270a13da5ca049
+  metadata.gz: f542d198165a81ecdc9307e3d2b9a9168608197c117245cb89b087f5fde31081
+  data.tar.gz: 60c9bed4dfbf8b6d5e8d4cb47350b9ec31ee22ce9eae3fbcc92628cc8e4aed53
 SHA512:
-  metadata.gz: 2553c5c3ce8bff634d2d2f79bc58d9d05ee96426e681c3bdb3295c762fc01c9b2de0fe5aa97cc6755037a7c8a80cc4d367c31b6457e8b087489d36797ad1a598
-  data.tar.gz: 803c578af7494501775e52bb4db1ea46b5311c7280d20aaa632185d486dcd35ce60390a48d3ca4af2cb6adec4b9cbcc7aa7c922fcc5d9e58b0d7cdeb60a12fa7
+  metadata.gz: 55e33f10d0c71aa77bece3ba974995144f44cfc644d7bbf773de9b5ea562078df4511905de6ae87f15a9b95c12975fd423c1fbe6fccfb22c4a0073b2cdf66362
+  data.tar.gz: a2cca2d8c5c2ea66979ad93030b75fc7e64f5258650dc43b13e1cbf7080ee32ae44f77ac205b9055d3174d2e95dbe32fff61b949e27fc5f3306a3a332673bf57

data/README.md

@@ -25,7 +25,7 @@ BloomFit is a fork of [bloomfilter-rb].
 
 MRI/C implementation which creates an in-memory filter which can be saved and reloaded from disk.
 
-(COMING SOON) If you'd like to specify an expected item count and a false-positive rate that you can tolerate:
+(COMING SOON) If you'd like to specify an expected item count and a false-positive rate that you can tolerate. Visit the [Bloom Filter Calculator](https://hur.st/bloomfilter/) to learn more.
 
 ```ruby
 require "bloom_fit"

data/ext/cbloomfilter/cbloomfilter.c

@@ -11,8 +11,8 @@
 # define RSTRING_PTR(x) (RSTRING(x)->ptr)
 #endif
 
-/* Reuse the standard CRC table for consistent seeds */
-static unsigned int *seeds = crc_table;
+/* Reuse the standard CRC table for consistent salts */
+static unsigned int *salts = crc_table;
 
 static VALUE cBloomFilter;
 
@@ -20,25 +20,64 @@ struct BloomFilter {
     int m; /* # of buckets in a bloom filter */
     int b; /* # of bits in a bloom filter bucket */
     int k; /* # of hash functions */
-    int r; /* # raise on bucket overflow? */
     unsigned char *ptr; /* bits data */
     int bytes; /* size of byte data */
 };
 
-unsigned long djb2(unsigned char *str, int len) {
+unsigned long djb2(const char *str, int len) {
     unsigned long hash = 5381;
-    unsigned char *c;
-    c = (unsigned char *) str;
-    while (len > 0) {
-        hash = ((hash << 5) ^ hash) ^ (*c);
-        --len;
-        ++c;
+    for (int i = 0; i < len; i++) {
+        hash = ((hash << 5) + hash) + str[i];
     }
     return hash;
 }
 
-void bits_free(struct BloomFilter *bf) {
+static void bf_free(void *ptr) {
+    struct BloomFilter *bf = ptr;
+
+    if (bf == NULL) {
+        return;
+    }
+
     ruby_xfree(bf->ptr);
+    ruby_xfree(bf);
+}
+
+static size_t bf_memsize(const void *ptr) {
+    const struct BloomFilter *bf = ptr;
+
+    if (bf == NULL) {
+        return 0;
+    }
+
+    return sizeof(*bf) + (bf->ptr == NULL ? 0 : (size_t) bf->bytes);
+}
+
+static const rb_data_type_t bf_type = {
+    "CBloomFilter",
+    {0, bf_free, bf_memsize,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static struct BloomFilter *bf_ptr(VALUE obj) {
+    struct BloomFilter *bf;
+
+    TypedData_Get_Struct(obj, struct BloomFilter, &bf_type, bf);
+
+    return bf;
+}
+
+static VALUE bf_alloc(VALUE klass) {
+    struct BloomFilter *bf;
+    VALUE obj = TypedData_Make_Struct(klass, struct BloomFilter, &bf_type, bf);
+
+    bf->m = 0;
+    bf->b = 0;
+    bf->k = 0;
+    bf->ptr = NULL;
+    bf->bytes = 0;
+
+    return obj;
 }
 
 void bucket_unset(struct BloomFilter *bf, int index) {
@@ -66,9 +105,7 @@ void bucket_set(struct BloomFilter *bf, int index) {
     unsigned int c = bf->ptr[byte_offset];
     c += bf->ptr[byte_offset + 1] << 8;
     unsigned int mask = ((1 << bf->b) - 1) << bit_offset;
-    if ((c & mask) == mask) {
-        if (bf->r == 1) rb_raise(rb_eRuntimeError, "bucket got filled up");
-    } else {
+    if ((c & mask) != mask) {
         c = c + ((1 << bit_offset) & ((1 << 8) -1)) | c;
         bf->ptr[byte_offset] = c & ((1 << 8) - 1);
         bf->ptr[byte_offset + 1] = (c & ((1 << 16) - 1)) >> 8;
@@ -85,36 +122,18 @@ int bucket_check(struct BloomFilter *bf, int index) {
     return (c & mask) >> bit_offset;
 }
 
-int bucket_get(struct BloomFilter *bf, int index) {
-    int byte_offset = (index * bf->b) / 8;
-    int bit_offset = (index * bf->b) % 8;
-    unsigned int c = bf->ptr[byte_offset];
-    c += bf->ptr[byte_offset + 1] << 8;
-
-    unsigned int mask = ((1 << bf->b) - 1) << bit_offset;
-    return (c & mask) >> bit_offset;
-}
-
-static VALUE bf_s_new(int argc, VALUE *argv, VALUE self) {
+static VALUE bf_initialize(int argc, VALUE *argv, VALUE self) {
     struct BloomFilter *bf;
-    VALUE arg1, arg2, arg3, arg4, obj;
-    int m, k, b, r;
+    VALUE arg1, arg2;
+    int m, k, b;
 
-    obj = Data_Make_Struct(self, struct BloomFilter, NULL, bits_free, bf);
+    bf = bf_ptr(self);
 
     /* default = Fugou approach :-) */
-    arg1 = INT2FIX(100000000);
+    arg1 = INT2FIX(1000);
     arg2 = INT2FIX(4);
-    arg3 = INT2FIX(1);
-    arg4 = INT2FIX(0);
 
     switch (argc) {
-        case 4:
-      if (argv[3] == Qtrue) {
-        arg4 = INT2FIX(1);
-      }
-        case 3:
-      arg3 = argv[2];
         case 2:
       arg2 = argv[1];
         case 1:
@@ -124,11 +143,8 @@ static VALUE bf_s_new(int argc, VALUE *argv, VALUE self) {
 
     m = FIX2INT(arg1);
     k = FIX2INT(arg2);
-    b = FIX2INT(arg3);
-    r = FIX2INT(arg4);
+    b = 1;
 
-    if (b < 1 || b > 8)
-        rb_raise(rb_eArgError, "bucket size");
     if (m < 1)
         rb_raise(rb_eArgError, "array size");
     if (k < 1)
@@ -137,53 +153,39 @@ static VALUE bf_s_new(int argc, VALUE *argv, VALUE self) {
     bf->b = b;
     bf->m = m;
     bf->k = k;
-    bf->r = r;
 
+    ruby_xfree(bf->ptr);
+    bf->ptr = NULL;
+    bf->bytes = 0;
     bf->bytes = ((m * b) + 15) / 8;
     bf->ptr = ALLOC_N(unsigned char, bf->bytes);
 
     /* initialize the bits with zeros */
     memset(bf->ptr, 0, bf->bytes);
-    rb_iv_set(obj, "@hash_value", rb_hash_new());
+    rb_iv_set(self, "@hash_value", rb_hash_new());
 
-    return obj;
+    return self;
 }
 
 static VALUE bf_clear(VALUE self) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    struct BloomFilter *bf = bf_ptr(self);
     memset(bf->ptr, 0, bf->bytes);
     return Qtrue;
 }
 
 static VALUE bf_m(VALUE self) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    struct BloomFilter *bf = bf_ptr(self);
     return INT2FIX(bf->m);
 }
 
 static VALUE bf_k(VALUE self) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    struct BloomFilter *bf = bf_ptr(self);
     return INT2FIX(bf->k);
 }
 
-static VALUE bf_b(VALUE self) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
-    return INT2FIX(bf->b);
-}
-
-static VALUE bf_r(VALUE self) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
-    return bf->r == 0 ? Qfalse : Qtrue;
-}
-
 static VALUE bf_set_bits(VALUE self){
-    struct BloomFilter *bf;
+    struct BloomFilter *bf = bf_ptr(self);
     int i,j,count = 0;
-    Data_Get_Struct(self, struct BloomFilter, bf);
     for (i = 0; i < bf->bytes; i++) {
         for (j = 0; j < 8; j++) {
             count += (bf->ptr[i] >> j) & 1;
@@ -194,11 +196,11 @@ static VALUE bf_set_bits(VALUE self){
 
 static VALUE bf_insert(VALUE self, VALUE key) {
     VALUE skey;
-    unsigned long hash, index;
+    unsigned long hash;
+    int index;
     int i, len, m, k;
     char *ckey;
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    struct BloomFilter *bf = bf_ptr(self);
 
     skey = rb_obj_as_string(key);
     ckey = StringValuePtr(skey);
@@ -209,7 +211,7 @@ static VALUE bf_insert(VALUE self, VALUE key) {
 
     hash = (unsigned long) djb2(ckey, len);
     for (i = 0; i <= k - 1; i++) {
-        index = (unsigned long) (hash ^ seeds[i]) % (unsigned int) (m);
+        index = (int) ((hash ^ salts[i]) % (unsigned int) (m));
 
         /*  set a bit at the index */
         bucket_set(bf, index);
@@ -219,10 +221,9 @@ static VALUE bf_insert(VALUE self, VALUE key) {
 }
 
 static VALUE bf_merge(VALUE self, VALUE other) {
-    struct BloomFilter *bf, *target;
+    struct BloomFilter *bf = bf_ptr(self);
+    struct BloomFilter *target = bf_ptr(other);
     int i;
-    Data_Get_Struct(self, struct BloomFilter, bf);
-    Data_Get_Struct(other, struct BloomFilter, target);
     for (i = 0; i < bf->bytes; i++) {
         bf->ptr[i] |= target->ptr[i];
     }
@@ -230,19 +231,17 @@ static VALUE bf_merge(VALUE self, VALUE other) {
 }
 
 static VALUE bf_and(VALUE self, VALUE other) {
-    struct BloomFilter *bf, *bf_other, *target;
+    struct BloomFilter *bf = bf_ptr(self);
+    struct BloomFilter *bf_other = bf_ptr(other);
+    struct BloomFilter *target;
     VALUE klass, obj, args[5];
     int i;
 
-    Data_Get_Struct(self, struct BloomFilter, bf);
-    Data_Get_Struct(other, struct BloomFilter, bf_other);
     args[0] = INT2FIX(bf->m);
     args[1] = INT2FIX(bf->k);
-    args[2] = INT2FIX(bf->b);
-    args[3] = INT2FIX(bf->r);
     klass = rb_funcall(self,rb_intern("class"),0);
-    obj = bf_s_new(4,args,klass);
-    Data_Get_Struct(obj, struct BloomFilter, target);
+    obj = rb_class_new_instance(2, args, klass);
+    target = bf_ptr(obj);
     for (i = 0; i < bf->bytes; i++){
         target->ptr[i] = bf->ptr[i] & bf_other->ptr[i];
     }
@@ -251,19 +250,17 @@ static VALUE bf_and(VALUE self, VALUE other) {
 }
 
 static VALUE bf_or(VALUE self, VALUE other) {
-    struct BloomFilter *bf, *bf_other, *target;
+    struct BloomFilter *bf = bf_ptr(self);
+    struct BloomFilter *bf_other = bf_ptr(other);
+    struct BloomFilter *target;
     VALUE klass, obj, args[5];
     int i;
 
-    Data_Get_Struct(self, struct BloomFilter, bf);
-    Data_Get_Struct(other, struct BloomFilter, bf_other);
     args[0] = INT2FIX(bf->m);
     args[1] = INT2FIX(bf->k);
-    args[2] = INT2FIX(bf->b);
-    args[3] = INT2FIX(bf->r);
     klass = rb_funcall(self,rb_intern("class"),0);
-    obj = bf_s_new(4,args,klass);
-    Data_Get_Struct(obj, struct BloomFilter, target);
+    obj = rb_class_new_instance(2, args, klass);
+    target = bf_ptr(obj);
     for (i = 0; i < bf->bytes; i++){
         target->ptr[i] = bf->ptr[i] | bf_other->ptr[i];
     }
@@ -271,86 +268,59 @@ static VALUE bf_or(VALUE self, VALUE other) {
     return obj;
 }
 
-static VALUE bf_delete(VALUE self, VALUE key) {
-    unsigned long hash, index;
-    int i, len, m, k;
-    char *ckey;
-    VALUE skey;
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
-
-    skey = rb_obj_as_string(key);
-    ckey = StringValuePtr(skey);
-    len = (int) (RSTRING_LEN(skey)); /* length of the string in bytes */
-
-    m = bf->m;
-    k = bf->k;
-
-    hash = (unsigned long) djb2(ckey, len);
-    for (i = 0; i <= k - 1; i++) {
-        index = (unsigned long) (hash ^ seeds[i]) % (unsigned int) (m);
-
-        /*  set a bit at the index */
-        bucket_unset(bf, index);
-    }
-
-    return Qnil;
-}
-
-
 static VALUE bf_include(int argc, VALUE* argv, VALUE self) {
-    unsigned long hash, index;
-    int i, len, m, k, tests_idx, vlen;
+    unsigned long hash;
+    int i, len, m, k;
+    int index;
+    long tests_idx, vlen;
     char *ckey;
     VALUE tests, key, skey;
     struct BloomFilter *bf;
 
     rb_scan_args(argc, argv, "*", &tests);
 
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    bf = bf_ptr(self);
     vlen = RARRAY_LEN(tests);
-    for(tests_idx = 0; tests_idx < vlen; tests_idx++) {
-      key = rb_ary_entry(tests, tests_idx);
-      skey = rb_obj_as_string(key);
-      ckey = StringValuePtr(skey);
-      len = (int) (RSTRING_LEN(skey)); /* length of the string in bytes */
-
-      m = bf->m;
-      k = bf->k;
-
-      hash = (unsigned long) djb2(ckey, len);
-      for (i = 0; i <= k - 1; i++) {
-          index = (unsigned long) (hash ^ seeds[i]) % (unsigned int) (m);
-
-          /* check the bit at the index */
-          if (!bucket_check(bf, index)) {
-              return Qfalse; /* i.e., it is a new entry ; escape the loop */
-          }
-      }
-
-      return Qtrue;
+    for (tests_idx = 0; tests_idx < vlen; tests_idx++) {
+        key = rb_ary_entry(tests, tests_idx);
+        skey = rb_obj_as_string(key);
+        ckey = StringValuePtr(skey);
+        len = (int) (RSTRING_LEN(skey)); /* length of the string in bytes */
+
+        m = bf->m;
+        k = bf->k;
+
+        hash = (unsigned long) djb2(ckey, len);
+        for (i = 0; i <= k - 1; i++) {
+            index = (int) ((hash ^ salts[i]) % (unsigned int) (m));
+
+            /* check the bit at the index */
+            if (!bucket_check(bf, index)) {
+                return Qfalse; /* i.e., it is a new entry ; escape the loop */
+            }
+        }
     }
+
+    return Qtrue;
 }
 
 static VALUE bf_to_s(VALUE self) {
-    struct BloomFilter *bf;
+    struct BloomFilter *bf = bf_ptr(self);
     unsigned char *ptr;
     int i;
     VALUE str;
 
-    Data_Get_Struct(self, struct BloomFilter, bf);
     str = rb_str_new(0, bf->m);
 
     ptr = (unsigned char *) RSTRING_PTR(str);
     for (i = 0; i < bf->m; i++)
-        *ptr++ = bucket_get(bf, i) ? '1' : '0';
+        *ptr++ = bucket_check(bf, i) ? '1' : '0';
 
     return str;
 }
 
 static VALUE bf_bitmap(VALUE self) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    struct BloomFilter *bf = bf_ptr(self);
 
     VALUE str = rb_str_new(0, bf->bytes);
     unsigned char* ptr = (unsigned char *) RSTRING_PTR(str);
@@ -361,8 +331,7 @@ static VALUE bf_bitmap(VALUE self) {
 }
 
 static VALUE bf_load(VALUE self, VALUE bitmap) {
-    struct BloomFilter *bf;
-    Data_Get_Struct(self, struct BloomFilter, bf);
+    struct BloomFilter *bf = bf_ptr(self);
     unsigned char* ptr = (unsigned char *) RSTRING_PTR(bitmap);
 
     memcpy(bf->ptr, ptr, bf->bytes);
@@ -372,15 +341,13 @@ static VALUE bf_load(VALUE self, VALUE bitmap) {
 
 void Init_cbloomfilter(void) {
     cBloomFilter = rb_define_class("CBloomFilter", rb_cObject);
-    rb_define_singleton_method(cBloomFilter, "new", bf_s_new, -1);
+    rb_define_alloc_func(cBloomFilter, bf_alloc);
+    rb_define_method(cBloomFilter, "initialize", bf_initialize, -1);
     rb_define_method(cBloomFilter, "m", bf_m, 0);
     rb_define_method(cBloomFilter, "k", bf_k, 0);
-    rb_define_method(cBloomFilter, "b", bf_b, 0);
-    rb_define_method(cBloomFilter, "r", bf_r, 0);
     rb_define_method(cBloomFilter, "set_bits", bf_set_bits, 0);
     /* rb_define_method(cBloomFilter, "s", bf_s, 0); */
     rb_define_method(cBloomFilter, "insert", bf_insert, 1);
-    rb_define_method(cBloomFilter, "delete", bf_delete, 1);
     rb_define_method(cBloomFilter, "include?", bf_include, -1);
     rb_define_method(cBloomFilter, "clear", bf_clear, 0);
     rb_define_method(cBloomFilter, "merge!", bf_merge, 1);
@@ -392,6 +359,5 @@ void Init_cbloomfilter(void) {
     rb_define_method(cBloomFilter, "load", bf_load, 1);
 
     /* functions that have not been implemented, yet */
-
     //  rb_define_method(cBloomFilter, "<=>", bf_cmp, 1);
 }

data/ext/cbloomfilter/extconf.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby 
 require "mkmf"
 
 create_makefile("cbloomfilter")

data/lib/bloom_fit/version.rb

@@ -1,3 +1,3 @@
 class BloomFit
-  VERSION = "0.1.1".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/bloom_fit.rb

@@ -1,42 +1,35 @@
-require 'cbloomfilter'
-require 'bloom_fit/version'
+require "cbloomfilter"
+require "bloom_fit/version"
 
 class BloomFit
-  BloomFit::ConfigurationMismatch = Class.new(ArgumentError)
+  class ConfigurationMismatch < ArgumentError
+  end
 
   attr_reader :bf
 
-  def initialize(opts = {})
-    @opts = {
-      :size    => 100,
-      :hashes  => 4,
-      :bucket  => 1,
-      :raise   => false
-    }.merge(opts)
+  def initialize(size: 1_000, hashes: 4)
+    @size = size
+    @hashes = hashes
 
     # arg 1: m => size : number of buckets in a bloom filter
     # arg 2: k => hashes : number of hash functions
-    # arg 3: b => bucket : number of bits per bucket
-    # arg 4: r => raise : whether to raise on bucket overflow
-
-    @bf = CBloomFilter.new(@opts[:size], @opts[:hashes], @opts[:bucket], @opts[:raise])
+    @bf = CBloomFilter.new(@size, @hashes)
   end
 
   def insert(key)
     @bf.insert(key)
   end
-  alias :[]= :insert
+  alias []= insert
 
   def include?(*keys)
     @bf.include?(*keys)
   end
-  alias :key? :include?
-  alias :[] :include?
+  alias key? include?
+  alias [] include?
 
-  def delete(key); @bf.delete(key); end
-  def clear; @bf.clear; end
-  def size; @bf.set_bits; end
-  def merge!(o); @bf.merge!(o.bf); end
+  def clear = @bf.clear
+  def size = @bf.set_bits
+  def merge!(other) = @bf.merge!(other.bf)
 
   # Returns the number of bits that are set to 1 in the filter.
   def set_bits
@@ -46,20 +39,20 @@ class BloomFit
   # Computes the intersection of two Bloom filters.
   # It assumes that both filters have the same size -
   # if this is not true +BloomFit::ConfigurationMismatch+ is raised.
-  def &(o)
-    raise BloomFit::ConfigurationMismatch.new unless same_parameters?(o)
+  def &(other)
+    raise BloomFit::ConfigurationMismatch unless same_parameters?(other)
     result = self.class.new
-    result.instance_variable_set(:@bf,@bf.&(o.bf))
+    result.instance_variable_set(:@bf, @bf.&(other.bf))
     result
   end
 
   # Computes the union of two Bloom filters.
   # It assumes that both filters have the same size -
   # if this is not true +BloomFit::ConfigurationMismatch+ is raised.
-  def |(o)
-    raise BloomFit::ConfigurationMismatch.new unless same_parameters?(o)
+  def |(other)
+    raise BloomFit::ConfigurationMismatch unless same_parameters?(other)
     result = self.class.new
-    result.instance_variable_set(:@bf,@bf.|(o.bf))
+    result.instance_variable_set(:@bf, @bf.|(other.bf))
     result
   end
 
@@ -68,40 +61,39 @@ class BloomFit
   end
 
   def marshal_load(ary)
-    opts, bitmap = *ary
+    size, hashes, bitmap = *ary
 
-    initialize(opts)
-    @bf.load(bitmap) if !bitmap.nil?
+    initialize(size:, hashes:)
+    @bf.load(bitmap) if bitmap
   end
 
   def marshal_dump
-    [@opts, @bf.bitmap]
+    [@size, @hashes, @bf.bitmap]
   end
 
   def self.load(filename)
-    Marshal.load(File.open(filename, 'r'))
+    Marshal.load(File.open(filename, "r"))
   end
 
   def save(filename)
-    File.open(filename, 'w') do |f|
+    File.open(filename, "w") do |f|
       f << Marshal.dump(self)
     end
   end
 
   def stats
-    fp = ((1.0 - Math.exp(-(@opts[:hashes] * size).to_f / @opts[:size])) ** @opts[:hashes]) * 100
-    printf "Number of filter buckets (m): %d\n", @opts[:size]
-    printf "Number of bits per buckets (b): %d\n", @opts[:bucket]
+    fp = ((1.0 - Math.exp(-(@hashes * size).to_f / @size))**@hashes) * 100
+    printf "Number of filter buckets (m): %d\n", @size
     printf "Number of set bits (n): %d\n", set_bits
-    printf "Number of filter hashes (k) : %d\n", @opts[:hashes]
+    printf "Number of filter hashes (k) : %d\n", @hashes
     printf "Predicted false positive rate = %.2f%%\n", fp
   end
 
   protected
 
-  # Returns true if parameters of the +o+ther filter are
+  # Returns true if parameters of the +other+ filter are
   # the same.
-  def same_parameters?(o)
-    @bf.m == o.bf.m && @bf.k == o.bf.k && @bf.b == o.bf.b
+  def same_parameters?(other)
+    bf.m == other.bf.m && bf.k == other.bf.k
   end
 end

data/spec/bloom_fit_spec.rb

@@ -1,17 +1,17 @@
 require "helper"
 
 describe BloomFit do
-  it "should clear" do
-    bf = BloomFit.new(:size => 100, :hashes => 2, :bucket => 3, :raise => false)
+  it "clears" do
+    bf = BloomFit.new(size: 100, hashes: 2)
     bf.insert("test")
     expect(bf.include?("test")).to be true
     bf.clear
     expect(bf.include?("test")).to be false
   end
 
-  it "should merge" do
-    bf1 = BloomFit.new(:size => 100, :hashes => 2, :bucket => 3, :raise => false)
-    bf2 = BloomFit.new(:size => 100, :hashes => 2, :bucket => 3, :raise => false)
+  it "merges" do
+    bf1 = BloomFit.new(size: 100, hashes: 2)
+    bf2 = BloomFit.new(size: 100, hashes: 2)
     bf2.insert("test")
     expect(bf1.include?("test")).to be false
     bf1.merge!(bf2)
@@ -19,134 +19,111 @@ describe BloomFit do
     expect(bf2.include?("test")).to be true
   end
 
-  context "behave like a bloom filter" do
-    it "should test set membership" do
-      bf = BloomFit.new(:size => 100, :hashes => 2, :bucket => 3, :raise => false)
-      bf.insert("test")
-      bf.insert("test1")
-
-      expect(bf.include?("test")).to be true
-      expect(bf.include?("abcd")).to be false
-      expect(bf.include?("test", "test1")).to be true
-    end
+  it "tests set membership" do
+    bf = BloomFit.new(size: 100, hashes: 2)
+    bf.insert("test")
+    bf.insert("test1")
 
-    it "should work with any object's to_s" do
-      subject.insert(:test)
-      subject.insert(:test1)
-      subject.insert(12345)
+    expect(bf.include?("test")).to be true
+    expect(bf.include?("abcd")).to be false
+    expect(bf.include?("test", "test1")).to be true
+    expect(bf.include?("test1", "abcd")).to be false
+  end
 
-      expect(subject.include?("test")).to be true
-      expect(subject.include?("abcd")).to be false
-      expect(subject.include?("test", "test1", '12345')).to be true
-    end
+  it "works with any object's to_s" do
+    subject.insert(:test)
+    subject.insert(:test1)
+    subject.insert(12_345)
 
-    it "should return the number of bits set to 1" do
-      bf = BloomFit.new(:hashes => 4)
-      bf.insert("test")
-      expect(bf.set_bits).to be == 4
-      bf.delete("test")
-      expect(bf.set_bits).to be == 0
+    expect(subject.include?("test")).to be true
+    expect(subject.include?("abcd")).to be false
+    expect(subject.include?("12345")).to be true
+  end
 
-      bf = BloomFit.new(:hashes => 1)
-      bf.insert("test")
-      expect(bf.set_bits).to be == 1
-    end
+  it "returns the number of bits set to 1" do
+    bf = BloomFit.new(hashes: 4)
+    bf.insert("test")
+    expect(bf.set_bits).to eq 4
 
-    it "should return intersection with other filter" do
-      bf1 = BloomFit.new
-      bf1.insert("test")
-      bf1.insert("test1")
+    bf = BloomFit.new(hashes: 1)
+    bf.insert("test")
+    expect(bf.set_bits).to eq 1
+  end
 
-      bf2 = BloomFit.new
-      bf2.insert("test")
-      bf2.insert("test2")
+  it "returns intersection with other filter" do
+    bf1 = BloomFit.new
+    bf1.insert("test")
+    bf1.insert("test1")
 
-      bf3 = bf1 & bf2
-      expect(bf3.include?("test")).to be true
-      expect(bf3.include?("test1")).to be false
-      expect(bf3.include?("test2")).to be false
-    end
+    bf2 = BloomFit.new
+    bf2.insert("test")
+    bf2.insert("test2")
 
-    it "should raise an exception when intersection is to be computed for incompatible filters" do
-      bf1 = BloomFit.new(:size => 10)
-      bf1.insert("test")
+    bf3 = bf1 & bf2
+    expect(bf3.include?("test")).to be true
+    expect(bf3.include?("test1")).to be false
+    expect(bf3.include?("test2")).to be false
+  end
 
-      bf2 = BloomFit.new(:size => 20)
-      bf2.insert("test")
+  it "raises an exception when intersection is to be computed for incompatible filters" do
+    bf1 = BloomFit.new(size: 10)
+    bf1.insert("test")
 
-      expect { bf1 & bf2 }.to raise_error(BloomFit::ConfigurationMismatch)
-    end
+    bf2 = BloomFit.new(size: 20)
+    bf2.insert("test")
 
-    it "should return union with other filter" do
-      bf1 = BloomFit.new
-      bf1.insert("test")
-      bf1.insert("test1")
+    expect { bf1 & bf2 }.to raise_error(BloomFit::ConfigurationMismatch)
+  end
 
-      bf2 = BloomFit.new
-      bf2.insert("test")
-      bf2.insert("test2")
+  it "returns union with other filter" do
+    bf1 = BloomFit.new
+    bf1.insert("test")
+    bf1.insert("test1")
 
-      bf3 = bf1 | bf2
-      expect(bf3.include?("test")).to be true
-      expect(bf3.include?("test1")).to be true
-      expect(bf3.include?("test2")).to be true
-    end
+    bf2 = BloomFit.new
+    bf2.insert("test")
+    bf2.insert("test2")
 
-    it "should raise an exception when union is to be computed for incompatible filters" do
-      bf1 = BloomFit.new(:size => 10)
-      bf1.insert("test")
+    bf3 = bf1 | bf2
+    expect(bf3.include?("test")).to be true
+    expect(bf3.include?("test1")).to be true
+    expect(bf3.include?("test2")).to be true
+  end
 
-      bf2 = BloomFit.new(:size => 20)
-      bf2.insert("test")
+  it "raises an exception when union is to be computed for incompatible filters" do
+    bf1 = BloomFit.new(size: 10)
+    bf1.insert("test")
 
-      expect {bf1 | bf2}.to raise_error(BloomFit::ConfigurationMismatch)
-    end
+    bf2 = BloomFit.new(size: 20)
+    bf2.insert("test")
 
-    it "should output current stats" do
-      subject.insert('test')
-      expect { subject.stats }.not_to raise_error
-    end
+    expect { bf1 | bf2 }.to raise_error(BloomFit::ConfigurationMismatch)
   end
 
-  context "behave like counting bloom filter" do
-    it "should delete / decrement keys" do
-      subject.insert("test")
-      expect(subject.include?("test")).to be true
-
-      subject.delete("test")
-      expect(subject.include?("test")).to be false
-    end
+  it "outputs current stats" do
+    subject.insert("test")
+    expect { subject.stats }.not_to raise_error
   end
 
-  context "serialize" do
-    after(:each) { File.unlink('bf.out') }
+  context "serialization" do
+    after { File.unlink("bf.out") }
 
-    it "should marshall" do
+    it "marshalls" do
       bf = BloomFit.new
-      expect { bf.save('bf.out') }.not_to raise_error
+      expect { bf.save("bf.out") }.not_to raise_error
     end
 
-    it "should load from marshalled" do
-      subject.insert('foo')
-      subject.insert('bar')
-      subject.save('bf.out')
+    it "loads from marshalled" do
+      subject.insert("foo")
+      subject.insert("bar")
+      subject.save("bf.out")
 
-      bf2 = BloomFit.load('bf.out')
-      expect(bf2.include?('foo')).to be true
-      expect(bf2.include?('bar')).to be true
-      expect(bf2.include?('baz')).to be false
+      bf2 = BloomFit.load("bf.out")
+      expect(bf2.include?("foo")).to be true
+      expect(bf2.include?("bar")).to be true
+      expect(bf2.include?("baz")).to be false
 
       expect(subject.send(:same_parameters?, bf2)).to be true
     end
-
-    it "should serialize to a file size proporational its bucket size" do
-      fs_size = 0
-      8.times do |i|
-        bf = BloomFit.new(size: 10_000, bucket: i+1)
-        bf.save('bf.out')
-        prev_size, fs_size = fs_size, File.size('bf.out')
-        expect(prev_size).to be < fs_size
-      end
-    end
   end
 end

data/spec/helper.rb

@@ -1,2 +1 @@
-require "bundler/setup"
 require "bloom_fit"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bloom_fit
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ilya Grigorik
@@ -11,63 +11,7 @@ authors:
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: irb
-  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
-  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-compiler
-  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: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3'
+dependencies: []
 email:
 - ilya@grigorik.com
 - valdzone@gmail.com
@@ -79,12 +23,12 @@ extensions:
 extra_rdoc_files: []
 files:
 - README.md
-- Rakefile
 - ext/cbloomfilter/cbloomfilter.c
 - ext/cbloomfilter/crc32.h
 - ext/cbloomfilter/extconf.rb
 - lib/bloom_fit.rb
 - lib/bloom_fit/version.rb
+- lib/cbloomfilter.bundle
 - spec/bloom_fit_spec.rb
 - spec/helper.rb
 homepage: https://github.com/rmm5t/bloom_fit
@@ -103,7 +47,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -114,6 +58,4 @@ rubygems_version: 4.0.9
 specification_version: 4
 summary: BloomFit helps you build correctly sized Bloom filters from expected set
   size and target false positive rate.
-test_files:
-- spec/bloom_fit_spec.rb
-- spec/helper.rb
+test_files: []

data/Rakefile

@@ -1,12 +0,0 @@
-require "bundler/gem_tasks"
-require "bundler/setup"
-require "rspec/core/rake_task"
-require "rake/extensiontask"
-
-Rake::ExtensionTask.new("cbloomfilter")
-RSpec::Core::RakeTask.new(:spec)
-Rake::Task[:spec].prerequisites << :clean
-Rake::Task[:spec].prerequisites << :compile
-
-desc "Default: run unit tests."
-task default: :spec