gnista 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18a1c35381152407bbbdd6694e04424893936c13
-  data.tar.gz: 94f3a0363f878f04a6d2b4572a1a10b56ec93f2f
+  metadata.gz: 36552dd994d8f7ed18d1f26290fca5eaab21608f
+  data.tar.gz: 778bd89aef04ff8f9ef1e2e1e7e2b3d24c0c4cd5
 SHA512:
-  metadata.gz: b5d83b90fbe736a4d9f7ae3f22c268ccd5ab1d930276fc84f78ee2f93cf51ef9c53403a503e539320f6d1fd5d9f6498ee0601e064f3c1d091b2dc67d4c520ca8
-  data.tar.gz: 3c5e593188384bd0f7d2e61652c35d4f04ba32e1033ee2141e4e8ac549fea19129752f28db81c87bda863ec8788df53bd3e36509cba11d905fa9e7d6e72cd01b
+  metadata.gz: 8ebbd55366f654164ea6b182b90526a64691423331580572253b316c1beb2b5a07b396db8c65e301de84c077e6884cc2759e5f10208ab163af3d02fdaed39024
+  data.tar.gz: bf3ce23592e12a42f12f11ff678a483efdd9ceb2128330ad2446eb645fbd858ea5a225b7e7ffb6f0a11081c1497133d7058858fd7a2fb52cb2fa4a1f53b4bc88

data/HISTORY.md

@@ -1,3 +1,33 @@
+# Version 0.0.4
+
+Release date 2013-09-16
+
+### Added
+
+* History for minor changes.
+* Lesson learned regarding "gem yank".
+
+# Version 0.0.3
+
+Release date 2013-09-16
+
+### Added
+
+* ```logpath``` for ```Logwriter```, ```Logreader``` and ```Hash```.
+* ```hashpath``` for ```Hash```.
+* Shorthand syntax for puts and gets. Similar to Ruby's native hash: []= and [].
+* ```empty?``` method for ```Hash```.
+* ```keys``` and ```values``` methods for ```Hash```.
+* ```has_key?``` method for ```Hash```.
+* ```maxkeylen``` and ```maxvaluelen``` for ```Logreader```.
+* ```Logreader``` and ```Hash``` mixin [Enumerable](http://ruby-doc.org/core-2.0.0/Enumerable.html).
+* ```write_batch``` implemented for ```Logwriter```.
+* Useful ```inspect``` for all classes.
+
+### Fixed
+
+* String-check for all input to ```Logwriter``` and ```Hash```.
+
 # Version 0.0.2
 
 Release date 2013-09-12

data/README.md

@@ -29,34 +29,60 @@ logwriter = Gnista::Logwriter.new "mylog.log" # no compression
 logwriter = Gnista::Logwriter.new "mylog.log", 4000 # 4k compression block size
 logwriter = Gnista::Logwriter.new "mylog.log", :append # append to existing log
 
+logwriter.logpath # => "mylog.log"
+
 logwriter.put "key", "value" # put entry
+logwriter["key"] = "value"
 logwriter.del "key" # delete entry
-
 logwriter.flush
 
+logwriter.write_batch do
+  logwriter["key1"] = "value1"
+  logwriter["key2"] = "value2"
+end
+
+
 logreader = Gnista::Logreader.new "mylog.log"
+logreader.logpath # => "mylog.log"
+
 logreader.each {|key,value,type| puts key, value, type }
 # => "key", "value"/nil, :put/:delete
 
+logreader.maxkeylen # largest key length
+logreader.maxkeylen # largest value length
+
+
 Gnista::Hash.write "mylog.hash", "mylog.log" # no preferred hash size
 Gnista::Hash.write "mylog.hash", "mylog.log", 4 # 32 bit murmurhash3_x86_32
 Gnista::Hash.write "mylog.hash", "mylog.log", 8 # lower 64-bit part of murmurhash3_x64_128
 
 hash = Gnista::Hash.new "mylog.hash", "mylog.log"
+logwriter.hashpath # => "mylog.hash"
+logwriter.logpath # => "mylog.log"
+
 hash.each {|key,value| puts key, value }
 hash.get "key" # => "value" or nil
+hash["key"]
 
-hash.maxkeylen # largest key length
-hash.maxkeylen # largest value length
+hash.maxkeylen
+hash.maxkeylen
 hash.length
 hash.collisions
+hash.empty?
+hash.include? "key"
+hash.keys # => ["key1", "key2"]
+hash.values # => ["value1", "value2"]
+
 
 # Don't forget to close!
 logwriter.close
 logreader.close
 hash.close
+
+logwriter.open? || logreader.open? || hash.open? # => false
 ```
 
+Both ```Logreader```and ```Hash``` mixin [Enumerable](http://ruby-doc.org/core-2.0.0/Enumerable.html).
 
 ## Contributing
 

data/ext/gnista/gnista.c

@@ -94,6 +94,7 @@ static VALUE method_logwriter_initialize(VALUE self, VALUE args) {
 		i_logwriter->open = false;
 	} else {
 		i_logwriter->open = true;
+		rb_iv_set(self, "@logpath", rb_ary_entry(args, 0));
 	}
 
 	return self;
@@ -119,6 +120,8 @@ static VALUE method_logwriter_put(VALUE self, VALUE key, VALUE val) {
 	sparkey_returncode returncode;
 	instance_logwriter *i_logwriter = get_logwriter(self);
 	check_open(i_logwriter->open);
+	Check_Type(key, T_STRING);
+	Check_Type(val, T_STRING);
 
 	returncode = sparkey_logwriter_put(i_logwriter->logwriter, RSTRING_LEN(key), (uint8_t*)RSTRING_PTR(key), RSTRING_LEN(val), (uint8_t*)RSTRING_PTR(val));
 
@@ -133,6 +136,7 @@ static VALUE method_logwriter_delete(VALUE self, VALUE key) {
 	sparkey_returncode returncode;
 	instance_logwriter *i_logwriter = get_logwriter(self);
 	check_open(i_logwriter->open);
+	Check_Type(key, T_STRING);
 
 	returncode = sparkey_logwriter_delete(i_logwriter->logwriter, RSTRING_LEN(key), (uint8_t*)RSTRING_PTR(key));
 
@@ -203,6 +207,7 @@ static VALUE method_logreader_initialize(VALUE self, VALUE filename) {
 		i_logreader->open = false;
 	} else {
 		i_logreader->open = true;
+		rb_iv_set(self, "@logpath", filename);
 	}
 
 	return self;
@@ -292,6 +297,26 @@ static VALUE method_logreader_open(VALUE self) {
 	}
 }
 
+static VALUE method_logreader_maxkeylen(VALUE self) {
+	instance_logreader *i_logreader = get_logreader(self);
+	uint64_t maxkeylen;
+	check_open(i_logreader->open);
+
+	maxkeylen = sparkey_logreader_maxkeylen(i_logreader->logreader);
+
+	return INT2NUM(maxkeylen);
+}
+
+static VALUE method_logreader_maxvaluelen(VALUE self) {
+	instance_logreader *i_logreader = get_logreader(self);
+	uint64_t maxvaluelen;
+	check_open(i_logreader->open);
+
+	maxvaluelen = sparkey_logreader_maxvaluelen(i_logreader->logreader);
+
+	return INT2NUM(maxvaluelen);
+}
+
 /********************************************************************************/
 /**************** HASH **********************************************************/
 
@@ -356,6 +381,8 @@ static VALUE method_hash_initialize(VALUE self, VALUE hash_filename, VALUE log_f
 		i_hashreader->open = false;
 	} else {
 		i_hashreader->open = true;
+		rb_iv_set(self, "@hashpath", hash_filename);
+		rb_iv_set(self, "@logpath", log_filename);
 	}
 
 	return Qnil;
@@ -436,6 +463,7 @@ static VALUE method_hash_get(VALUE self, VALUE key) {
 	instance_hashreader *i_hashreader = get_hashreader(self);
 	sparkey_logiter *logiter;
 	check_open(i_hashreader->open);
+	Check_Type(key, T_STRING);
 
 	returncode = sparkey_logiter_create(&logiter, sparkey_hash_getreader(i_hashreader->hashreader));
 
@@ -543,6 +571,8 @@ void Init_gnista() {
 	rb_define_method(Logreader, "close", method_logreader_close, 0);
 	rb_define_method(Logreader, "each", method_logreader_each, 0);
 	rb_define_method(Logreader, "open?", method_logreader_open, 0);
+	rb_define_method(Logreader, "maxkeylen", method_logreader_maxkeylen, 0);
+	rb_define_method(Logreader, "maxvaluelen", method_logreader_maxvaluelen, 0);
 
 	rb_define_alloc_func(Hash, alloc_hashreader);
 	rb_define_singleton_method(Hash, "write", method_hash_write, -2);

data/lib/gnista.rb

@@ -3,10 +3,65 @@ require "gnista/version"
 
 module Gnista
   class Logwriter
+    attr_reader :logpath
+
+    def write_batch
+      yield if block_given?
+      flush
+    end
+
+    def inspect
+      %(#<#{self.class} #{@logpath.inspect}>)
+    end
+
     alias_method :del, :delete
+    alias_method :[]=, :put
+    alias_method :close!, :close
+  end
+
+  class Logreader
+    include Enumerable
+
+    attr_reader :logpath
+
+    def inspect
+      %(#<#{self.class} #{@logpath.inspect}>)
+    end
+
+    alias_method :close!, :close
   end
 
   class Hash
+    include Enumerable
+
+    attr_reader :hashpath, :logpath
+
+    def keys
+      map {|key,value| key }
+    end
+
+    def values
+      map {|key,value| value }
+    end
+
+    def has_key?(key)
+      return self[key] != nil
+    end
+
+    def empty?
+      return length == 0
+    end
+
+    def inspect
+      %(#<#{self.class} #{@hashpath.inspect} #{@logpath.inspect}>)
+    end
+
     alias_method :size, :length
+    alias_method :[], :get
+    alias_method :include?, :has_key?
+    alias_method :member?, :has_key?
+    alias_method :contains?, :has_key?
+    alias_method :exists?, :has_key?
+    alias_method :close!, :close
   end
 end

data/lib/gnista/version.rb

@@ -1,3 +1,3 @@
 module Gnista
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/test/test_commands.rb

@@ -99,6 +99,7 @@ describe Gnista do
   it "can get from hash" do
     @logwriter.put "key1", "value1"
     @logwriter.put "key2", "value2"
+    @logwriter.put "key3", "value3"
     @logwriter.delete "key2"
     @logwriter.flush
     Gnista::Hash.write hash_path, log_path
@@ -109,12 +110,15 @@ describe Gnista do
 
     ret = hash.get "key2"
     ret.must_be_nil
+
+    ret = hash["key3"]
+    ret.must_equal "value3"
     FileUtils.rm hash_path
   end
 
   it "can get the hash length" do
     @logwriter.put "key1", "value1"
-    @logwriter.put "key2", "value2"
+    @logwriter["key2"] = "value2"
     @logwriter.put "key3", "value3"
     @logwriter.flush
     Gnista::Hash.write hash_path, log_path
@@ -144,4 +148,100 @@ describe Gnista do
     FileUtils.rm hash_path
   end
 
+  it "can inspect logwriter, logreader and hash" do
+    logreader = Gnista::Logreader.new log_path
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+
+    @logwriter.inspect.must_equal %(#<#{@logwriter.class} #{log_path.inspect}>)
+    logreader.inspect.must_equal %(#<#{logreader.class} #{log_path.inspect}>)
+    hash.inspect.must_equal %(#<#{hash.class} #{hash_path.inspect} #{log_path.inspect}>)
+
+    hash.close
+    logreader.close
+    FileUtils.rm hash_path
+  end
+
+  it "can get the logpath and the hashpath from logwriter, logreader and hash" do
+    logreader = Gnista::Logreader.new log_path
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+
+    @logwriter.logpath.must_equal log_path
+    logreader.logpath.must_equal log_path
+    hash.hashpath.must_equal hash_path
+    hash.logpath.must_equal log_path
+
+    hash.close
+    logreader.close
+    FileUtils.rm hash_path
+  end
+
+  it "can use empty? on hash" do
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+    hash.empty?.must_equal true
+    hash.close
+
+    @logwriter["key"] = "value"
+    @logwriter.flush
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+    hash.empty?.must_equal false
+    hash.close
+    FileUtils.rm hash_path
+  end
+
+  it "can read logreader max key/value length" do
+    @logwriter.put "abc", "a"
+    @logwriter.put "a", "abcd"
+    @logwriter.flush
+
+    logreader = Gnista::Logreader.new log_path
+
+    logreader.maxkeylen.must_equal 3
+    logreader.maxvaluelen.must_equal 4
+  end
+
+  it "can decide if hash has_key?" do
+    @logwriter["key"] = "value"
+    @logwriter.flush
+
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+
+    hash.has_key?("key").must_equal true
+    hash.include?("key1").must_equal false
+
+    hash.close
+    FileUtils.rm hash_path
+  end
+
+  it "extract keys and values from hash" do
+    @logwriter["key1"] = "value1"
+    @logwriter["key2"] = "value2"
+    @logwriter.flush
+
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+
+    hash.keys.must_equal ["key1", "key2"]
+    hash.values.must_equal ["value1", "value2"]
+
+    hash.close
+    FileUtils.rm hash_path
+  end
+
+  it "can write_batch with logwriter" do
+    @logwriter.write_batch do
+      @logwriter["key1"] = "value1"
+    end
+
+    logreader = Gnista::Logreader.new log_path
+    _,value,_ = logreader.first
+    value.must_equal "value1"
+
+    logreader.close!
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gnista
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Emanuel Andersson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-12 00:00:00.000000000 Z
+date: 2013-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler