gnista 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bab3ebb294b61581358c5cec1b5c35d58278068f
+  data.tar.gz: 46ce784095d0f7ebfa35ed4292c8666572ba6f71
+SHA512:
+  metadata.gz: b6758ef75988f46af845a974ab7e50398fc87251c1b070dfa4d2fd96679d0de075df5f3fb3bc2446b506b591811317943536173805ae0a1afc0a316abe9f9ccc
+  data.tar.gz: dc6f0af77d91f73180f466556b1275e9c7b86650a849aedf4e4cb524ff4b16f8ac48b5eec1c710d0230fa7b6b84c8f3aba8436f4fff8de0e3392726c84aa6672

data/HISTORY.md

@@ -0,0 +1,5 @@
+# Version 0.0.1
+
+Release date 2013-09-11
+
+### Changed / Added / Fixed / Removed

data/LICENSE.txt

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2013 Emanuel Andersson
+
+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,73 @@
+# Gnista
+
+Gnista is a wrapper for the database/hashstore [Sparkey](http://github.com/spotify/sparkey) written for Ruby. Gnista packs all the native features of Sparkey into a shiny red package, easy to use.
+
+## Setup
+
+You will need Sparkey, obviously. It's really easy to install. Head over to [http://github.com/spotify/sparkey](http://github.com/spotify/sparkey) and install it, I'll wait..
+
+Now, add this line to your application's Gemfile:
+
+    gem 'gnista'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gnista
+
+## Usage
+
+You can read about Sparkey [here](http://github.com/spotify/sparkey).
+
+```ruby
+require 'gnista'
+
+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.put "key", "value" # put entry
+logwriter.del "key" # delete entry
+
+logwriter.flush
+
+logreader = Gnista::Logreader.new "mylog.log"
+logreader.each {|key,value| puts key, value }
+
+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"
+hash.each {|key,value| puts key, value }
+hash.get "key" # => "value" or nil
+
+hash.maxkeylen # largest key length
+hash.maxkeylen # largest value length
+hash.length
+hash.collisions
+
+# Don't forget to close!
+logwriter.close
+logreader.close
+hash.close
+```
+
+
+## Contributing
+
+Use the following commands to build the native extensions and test:
+
+	$ rake make
+	$ rake test
+
+Then:
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'ext' << 'test'
+  test.pattern = 'test/**/test_*'
+  test.verbose = false
+end
+
+task :make do |t|
+  sh "cd ext/gnista && ruby extconf.rb && make"
+end
+
+task :clean do |t|
+  sh "rm -f ext/gnista/*.bundle"
+  sh "rm -f ext/gnista/Makefile"
+  sh "rm -f ext/gnista/*.log"
+  sh "rm -f ext/gnista/*.o"
+  sh "rm -rf pkg"
+end

data/ext/gnista/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+extension_name = 'gnista'
+dir_config(extension_name)
+
+have_library('sparkey') or raise
+have_header('sparkey/sparkey.h') or raise
+
+create_makefile(extension_name)

data/ext/gnista/gnista.c

@@ -0,0 +1,534 @@
+#include <ruby.h>
+#include <sparkey/sparkey.h>
+
+typedef int bool;
+#define true 1
+#define false 0
+
+
+typedef struct instance_logwriter {
+  	sparkey_logwriter *logwriter;
+  	int open;
+} instance_logwriter;
+
+typedef struct instance_logreader {
+  	sparkey_logreader *logreader;
+  	int open;
+} instance_logreader;
+
+typedef struct instance_hashreader {
+  	sparkey_hashreader *hashreader;
+  	int open;
+} instance_hashreader;
+
+/********************************************************************************/
+/**************** ERROR HANDLING ************************************************/
+
+VALUE GnistaException = Qnil;
+
+static void raise_sparkey(sparkey_returncode returncode) {
+	const char *error_msg = sparkey_errstring(returncode);
+	rb_raise(GnistaException, "%s", error_msg);
+}
+
+static void check_open(bool open) {
+	if (!open) {
+		rb_raise(GnistaException, "Closed");
+	}
+}
+
+/********************************************************************************/
+/**************** LOGWRITER *****************************************************/
+
+static void dealloc_logwriter(void *p) {
+	instance_logwriter *i_logwriter = p;
+
+	if (i_logwriter->open) {
+	    sparkey_returncode returncode;
+		returncode = sparkey_logwriter_close(&i_logwriter->logwriter);
+
+		if (returncode != SPARKEY_SUCCESS) {
+			raise_sparkey(returncode);
+		}
+	}
+
+	free(i_logwriter);
+}
+
+static VALUE alloc_logwriter(VALUE klass) {
+	instance_logwriter *i_logwriter = ALLOC(instance_logwriter);
+  	return Data_Wrap_Struct(klass, 0, dealloc_logwriter, i_logwriter);
+}
+
+static instance_logwriter* get_logwriter(VALUE self) {
+	instance_logwriter *i_logwriter;
+	Data_Get_Struct(self, instance_logwriter, i_logwriter);
+	return i_logwriter;
+}
+
+static VALUE method_logwriter_initialize(VALUE self, VALUE args) {
+	sparkey_returncode returncode;
+	instance_logwriter *i_logwriter = get_logwriter(self);
+	int len = RARRAY_LEN(args);
+
+	if (len > 2 || len == 0) {
+		rb_raise(rb_eArgError, "Wrong number of arguments");
+	}
+
+	Check_Type(rb_ary_entry(args, 0), T_STRING);
+
+	if (len == 2) {
+		if (TYPE(rb_ary_entry(args, 1)) == T_SYMBOL && (rb_to_id(rb_ary_entry(args, 1)) == rb_intern("append"))) {
+			returncode = sparkey_logwriter_append(&i_logwriter->logwriter, RSTRING_PTR(rb_ary_entry(args, 0)));
+		} else if (TYPE(rb_ary_entry(args, 1)) == T_FIXNUM) {
+			returncode = sparkey_logwriter_create(&i_logwriter->logwriter, RSTRING_PTR(rb_ary_entry(args, 0)), SPARKEY_COMPRESSION_SNAPPY, NUM2INT(rb_ary_entry(args, 1)));
+		} else {
+			rb_raise(rb_eArgError, "Invalid arguments");
+		}
+	} else {
+		returncode = sparkey_logwriter_create(&i_logwriter->logwriter, RSTRING_PTR(rb_ary_entry(args, 0)), SPARKEY_COMPRESSION_NONE, 0);
+	}
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+		i_logwriter->open = false;
+	} else {
+		i_logwriter->open = true;
+	}
+
+	return self;
+}
+
+static VALUE method_logwriter_close(VALUE self) {
+	sparkey_returncode returncode;
+	instance_logwriter *i_logwriter = get_logwriter(self);
+	check_open(i_logwriter->open);
+
+	returncode = sparkey_logwriter_close(&i_logwriter->logwriter);
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	i_logwriter->open = false;
+
+	return Qnil;
+}
+
+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);
+
+	returncode = sparkey_logwriter_put(i_logwriter->logwriter, RSTRING_LEN(key), (uint8_t*)RSTRING_PTR(key), RSTRING_LEN(val), (uint8_t*)RSTRING_PTR(val));
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	return Qnil;
+}
+
+static VALUE method_logwriter_delete(VALUE self, VALUE key) {
+	sparkey_returncode returncode;
+	instance_logwriter *i_logwriter = get_logwriter(self);
+	check_open(i_logwriter->open);
+
+	returncode = sparkey_logwriter_delete(i_logwriter->logwriter, RSTRING_LEN(key), (uint8_t*)RSTRING_PTR(key));
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	return Qnil;
+}
+
+static VALUE method_logwriter_flush(VALUE self) {
+	sparkey_returncode returncode;
+	instance_logwriter *i_logwriter = get_logwriter(self);
+	check_open(i_logwriter->open);
+
+	returncode = sparkey_logwriter_flush(i_logwriter->logwriter);
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	return Qnil;
+}
+
+static VALUE method_logwriter_open(VALUE self) {
+	instance_logwriter *i_logwriter = get_logwriter(self);
+
+	if (i_logwriter->open) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+/********************************************************************************/
+/**************** LOGREADER *****************************************************/
+
+static void dealloc_logreader(void *p) {
+	instance_logreader *i_logreader = p;
+
+	if (i_logreader->open) {
+		sparkey_logreader_close(&i_logreader->logreader);
+	}
+
+	free(i_logreader);
+}
+
+static VALUE alloc_logreader(VALUE klass) {
+	instance_logreader *i_logreader = ALLOC(instance_logreader);
+  	return Data_Wrap_Struct(klass, 0, dealloc_logreader, i_logreader);
+}
+
+static instance_logreader* get_logreader(VALUE self) {
+	instance_logreader *i_logreader;
+	Data_Get_Struct(self, instance_logreader, i_logreader);
+	return i_logreader;
+}
+
+static VALUE method_logreader_initialize(VALUE self, VALUE filename) {
+	sparkey_returncode returncode;
+	instance_logreader *i_logreader = get_logreader(self);
+	Check_Type(filename, T_STRING);
+
+	returncode = sparkey_logreader_open(&i_logreader->logreader, RSTRING_PTR(filename));
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+		i_logreader->open = false;
+	} else {
+		i_logreader->open = true;
+	}
+
+	return self;
+}
+
+static VALUE method_logreader_close(VALUE self) {
+	instance_logreader *i_logreader = get_logreader(self);
+	check_open(i_logreader->open);
+	sparkey_logreader_close(&i_logreader->logreader);
+	i_logreader->open = false;
+
+	return Qnil;
+}
+
+static VALUE method_logreader_each(VALUE self) {
+	sparkey_returncode returncode;
+	sparkey_logiter *logiter;
+	instance_logreader *i_logreader = get_logreader(self);
+	check_open(i_logreader->open);
+
+	returncode = sparkey_logiter_create(&logiter, i_logreader->logreader);
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	while (1) {
+		returncode = sparkey_logiter_next(logiter, i_logreader->logreader);
+
+		if (sparkey_logiter_state(logiter) != SPARKEY_ITER_ACTIVE) {
+		 	break;
+		}
+
+		uint64_t wanted_keylen = sparkey_logiter_keylen(logiter);
+		uint8_t *keybuf = malloc(wanted_keylen);
+		uint64_t actual_keylen;
+		returncode = sparkey_logiter_fill_key(logiter, i_logreader->logreader, wanted_keylen, keybuf, &actual_keylen);
+
+		if (returncode != SPARKEY_SUCCESS) {
+			raise_sparkey(returncode);
+		} else if (wanted_keylen != actual_keylen) {
+			rb_raise(GnistaException, "Corrupted read in logreader.");
+		}
+
+		uint64_t wanted_valuelen = sparkey_logiter_valuelen(logiter);
+		uint8_t *valuebuf = malloc(wanted_valuelen);
+		uint64_t actual_valuelen;
+		returncode = sparkey_logiter_fill_value(logiter, i_logreader->logreader, wanted_valuelen, valuebuf, &actual_valuelen);
+
+		if (returncode != SPARKEY_SUCCESS) {
+			raise_sparkey(returncode);
+		} else if (wanted_valuelen != actual_valuelen) {
+			rb_raise(GnistaException, "Corrupted read in logreader.");
+		}
+
+		rb_yield_values(2, rb_str_new((char *)keybuf, actual_keylen), rb_str_new((char *)valuebuf, actual_valuelen));
+
+		free(keybuf);
+		free(valuebuf);
+	}
+
+	sparkey_logiter_close(&logiter);
+
+	return Qnil;
+}
+
+static VALUE method_logreader_open(VALUE self) {
+	instance_logreader *i_logreader = get_logreader(self);
+
+	if (i_logreader->open) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+/********************************************************************************/
+/**************** HASH **********************************************************/
+
+static void dealloc_hashreader(void *p) {
+	instance_hashreader *i_hashreader = p;
+
+	if (i_hashreader->open) {
+		sparkey_hash_close(&i_hashreader->hashreader);
+	}
+
+	free(i_hashreader);
+}
+
+static VALUE alloc_hashreader(VALUE klass) {
+	instance_hashreader *i_hashreader = ALLOC(instance_hashreader);
+  	return Data_Wrap_Struct(klass, 0, dealloc_hashreader, i_hashreader);
+}
+
+static instance_hashreader* get_hashreader(VALUE self) {
+	instance_hashreader *i_hashreader;
+	Data_Get_Struct(self, instance_hashreader, i_hashreader);
+	return i_hashreader;
+}
+
+static VALUE method_hash_write(VALUE klass, VALUE args) {
+	sparkey_returncode returncode;
+	int len = RARRAY_LEN(args);
+	int hash_size = 0;
+
+	if (len > 3 || len < 2) {
+		rb_raise(rb_eArgError, "Wrong number of arguments");
+	}
+
+	Check_Type(rb_ary_entry(args, 0), T_STRING);
+	Check_Type(rb_ary_entry(args, 1), T_STRING);
+
+	if (len == 3) {
+		Check_Type(rb_ary_entry(args, 2), T_FIXNUM);
+		hash_size = NUM2INT(rb_ary_entry(args, 2));
+	}
+
+	returncode = sparkey_hash_write(RSTRING_PTR(rb_ary_entry(args, 0)), RSTRING_PTR(rb_ary_entry(args, 1)), hash_size);
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	return Qnil;
+}
+
+static VALUE method_hash_initialize(VALUE self, VALUE hash_filename, VALUE log_filename) {
+	sparkey_returncode returncode;
+	instance_hashreader *i_hashreader = get_hashreader(self);
+
+	Check_Type(hash_filename, T_STRING);
+	Check_Type(log_filename, T_STRING);
+
+	returncode = sparkey_hash_open(&i_hashreader->hashreader, RSTRING_PTR(hash_filename), RSTRING_PTR(log_filename));
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+		i_hashreader->open = false;
+	} else {
+		i_hashreader->open = true;
+	}
+
+	return Qnil;
+}
+
+static VALUE method_hash_close(VALUE self) {
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	check_open(i_hashreader->open);
+	sparkey_hash_close(&i_hashreader->hashreader);
+	i_hashreader->open = false;
+
+	return Qnil;
+}
+
+static VALUE method_hash_each(VALUE self) {
+	sparkey_returncode returncode;
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	sparkey_logiter *logiter;
+	check_open(i_hashreader->open);
+
+	returncode = sparkey_logiter_create(&logiter, sparkey_hash_getreader(i_hashreader->hashreader));
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	while (1) {
+		returncode = sparkey_logiter_hashnext(logiter, i_hashreader->hashreader);
+
+		if (sparkey_logiter_state(logiter) != SPARKEY_ITER_ACTIVE) {
+		 	break;
+		}
+
+		uint64_t wanted_keylen = sparkey_logiter_keylen(logiter);
+		uint8_t *keybuf = malloc(wanted_keylen);
+		uint64_t actual_keylen;
+		returncode = sparkey_logiter_fill_key(logiter, sparkey_hash_getreader(i_hashreader->hashreader), wanted_keylen, keybuf, &actual_keylen);
+
+		if (returncode != SPARKEY_SUCCESS) {
+			raise_sparkey(returncode);
+		} else if (wanted_keylen != actual_keylen) {
+			rb_raise(GnistaException, "Corrupt entry in logreader.");
+		}
+
+		uint64_t wanted_valuelen = sparkey_logiter_valuelen(logiter);
+		uint8_t *valuebuf = malloc(wanted_valuelen);
+		uint64_t actual_valuelen;
+		returncode = sparkey_logiter_fill_value(logiter, sparkey_hash_getreader(i_hashreader->hashreader), wanted_valuelen, valuebuf, &actual_valuelen);
+
+		if (returncode != SPARKEY_SUCCESS) {
+			raise_sparkey(returncode);
+		} else if (wanted_valuelen != actual_valuelen) {
+			rb_raise(GnistaException, "Corrupt entry in logreader.");
+		}
+
+		rb_yield_values(2, rb_str_new((char *)keybuf, actual_keylen), rb_str_new((char *)valuebuf, actual_valuelen));
+
+		free(keybuf);
+		free(valuebuf);
+	}
+
+	sparkey_logiter_close(&logiter);
+
+	return Qnil;
+}
+
+static VALUE method_hash_get(VALUE self, VALUE key) {
+	sparkey_returncode returncode;
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	sparkey_logiter *logiter;
+	check_open(i_hashreader->open);
+
+	returncode = sparkey_logiter_create(&logiter, sparkey_hash_getreader(i_hashreader->hashreader));
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	}
+
+	key = StringValue(key);
+
+	returncode = sparkey_hash_get(i_hashreader->hashreader, (uint8_t*)RSTRING_PTR(key), RSTRING_LEN(key), logiter);
+
+	if (sparkey_logiter_state(logiter) != SPARKEY_ITER_ACTIVE) {
+	 	return Qnil;
+	}
+
+	uint64_t wanted_valuelen = sparkey_logiter_valuelen(logiter);
+	uint8_t *valuebuf = malloc(wanted_valuelen);
+	uint64_t actual_valuelen;
+	returncode = sparkey_logiter_fill_value(logiter, sparkey_hash_getreader(i_hashreader->hashreader), wanted_valuelen, valuebuf, &actual_valuelen);
+
+	if (returncode != SPARKEY_SUCCESS) {
+		raise_sparkey(returncode);
+	} else if (wanted_valuelen != actual_valuelen) {
+		rb_raise(GnistaException, "Corrupt entry in hash.");
+	}
+
+	sparkey_logiter_close(&logiter);
+
+	return rb_str_new((char *)valuebuf, actual_valuelen);
+}
+
+static VALUE method_hash_maxkeylen(VALUE self) {
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	uint64_t maxkeylen;
+	check_open(i_hashreader->open);
+
+	maxkeylen = sparkey_logreader_maxkeylen(sparkey_hash_getreader(i_hashreader->hashreader));
+
+	return INT2NUM(maxkeylen);
+}
+
+static VALUE method_hash_maxvaluelen(VALUE self) {
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	uint64_t maxvaluelen;
+	check_open(i_hashreader->open);
+
+	maxvaluelen = sparkey_logreader_maxvaluelen(sparkey_hash_getreader(i_hashreader->hashreader));
+
+	return INT2NUM(maxvaluelen);
+}
+
+static VALUE method_hash_length(VALUE self) {
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	uint64_t numentries;
+	check_open(i_hashreader->open);
+
+	numentries = sparkey_hash_numentries(i_hashreader->hashreader);
+
+	return INT2NUM(numentries);
+}
+
+static VALUE method_hash_collisions(VALUE self) {
+	instance_hashreader *i_hashreader = get_hashreader(self);
+	uint64_t collisions;
+	check_open(i_hashreader->open);
+
+	collisions = sparkey_hash_numcollisions(i_hashreader->hashreader);
+
+	return INT2NUM(collisions);
+}
+
+static VALUE method_hash_open(VALUE self) {
+	instance_hashreader *i_hashreader = get_hashreader(self);
+
+	if (i_hashreader->open) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+/********************************************************************************/
+/**************** INITIALIZE GNISTA *********************************************/
+
+void Init_gnista() {
+	VALUE Gnista = rb_define_module("Gnista");
+	VALUE Logwriter = rb_define_class_under(Gnista, "Logwriter", rb_cObject);
+	VALUE Logreader = rb_define_class_under(Gnista, "Logreader", rb_cObject);
+	VALUE Hash = rb_define_class_under(Gnista, "Hash", rb_cObject);
+
+	rb_define_alloc_func(Logwriter, alloc_logwriter);
+	rb_define_method(Logwriter, "initialize", method_logwriter_initialize, -2);
+	rb_define_method(Logwriter, "close", method_logwriter_close, 0);
+	rb_define_method(Logwriter, "put", method_logwriter_put, 2);
+	rb_define_method(Logwriter, "delete", method_logwriter_delete, 1);
+	rb_define_method(Logwriter, "flush", method_logwriter_flush, 0);
+	rb_define_method(Logwriter, "open?", method_logwriter_open, 0);
+
+	rb_define_alloc_func(Logreader, alloc_logreader);
+	rb_define_method(Logreader, "initialize", method_logreader_initialize, 1);
+	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_alloc_func(Hash, alloc_hashreader);
+	rb_define_singleton_method(Hash, "write", method_hash_write, -2);
+	rb_define_method(Hash, "initialize", method_hash_initialize, 2);
+	rb_define_method(Hash, "close", method_hash_close, 0);
+	rb_define_method(Hash, "each", method_hash_each, 0);
+	rb_define_method(Hash, "get", method_hash_get, 1);
+	rb_define_method(Hash, "maxkeylen", method_hash_maxkeylen, 0);
+	rb_define_method(Hash, "maxvaluelen", method_hash_maxvaluelen, 0);
+	rb_define_method(Hash, "length", method_hash_length, 0);
+	rb_define_method(Hash, "collisions", method_hash_collisions, 0);
+	rb_define_method(Hash, "open?", method_hash_open, 0);
+
+	GnistaException = rb_define_class("GnistaException", rb_eException);
+}

data/lib/gnista/version.rb

@@ -0,0 +1,3 @@
+module Gnista
+  VERSION = "0.0.1"
+end

data/lib/gnista.rb

@@ -0,0 +1,12 @@
+require 'gnista/gnista'
+require "gnista/version"
+
+module Gnista
+  class Logwriter
+    alias_method :del, :delete
+  end
+
+  class Hash
+    alias_method :size, :length
+  end
+end

data/test/test_commands.rb

@@ -0,0 +1,134 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'fileutils'
+require File.expand_path("../../lib/gnista", __FILE__)
+
+describe Gnista do
+
+  log_path = '/tmp/test.log'
+  hash_path = '/tmp/test.hash'
+
+  before do
+    @logwriter = Gnista::Logwriter.new log_path
+    @logreader = Gnista::Logreader.new log_path
+  end
+
+  after do
+    @logwriter.close
+    @logreader.close
+    FileUtils.rm log_path
+  end
+
+  it "can use put command" do
+    res = @logwriter.put "key1", "value1"
+    res.must_be_nil
+  end
+
+  it "can use delete command" do
+    res = @logwriter.delete "key10"
+    res.must_be_nil
+  end
+
+  it "can use flush command" do
+    @logwriter.flush.must_be_nil
+  end
+
+  it "can iterate each log entry" do
+    @logwriter.put "key1", "value1"
+    @logwriter.put "key2", "value2"
+
+    a = true
+    @logreader.each do |key,value|
+      if a
+        key.must_equal "key1"
+        value.must_equal "value1"
+        a = false
+      else
+        key.must_equal "key2"
+        value.must_equal "value2"
+      end
+    end
+
+  end
+
+  it "can read hash max key/value length" do
+    @logwriter.put "abc", "a"
+    @logwriter.put "a", "abcd"
+    @logwriter.flush
+    Gnista::Hash.write hash_path, log_path
+
+    hash = Gnista::Hash.new hash_path, log_path
+
+    hash.maxkeylen.must_equal 3
+    hash.maxvaluelen.must_equal 4
+    FileUtils.rm hash_path
+  end
+
+  it "can iterate each hash entry" do
+    @logwriter.put "key1", "value1"
+    @logwriter.put "key2", "value2"
+    @logwriter.flush
+    Gnista::Hash.write hash_path, log_path
+
+    hash = Gnista::Hash.new hash_path, log_path
+
+    a = true
+    hash.each do |key,value|
+      if a
+        key.must_equal "key1"
+        value.must_equal "value1"
+        a = false
+      else
+        key.must_equal "key2"
+        value.must_equal "value2"
+      end
+    end
+
+    hash.close
+    FileUtils.rm hash_path
+  end
+
+  it "can get from hash" do
+    @logwriter.put "key1", "value1"
+    @logwriter.put "key2", "value2"
+    @logwriter.delete "key2"
+    @logwriter.flush
+    Gnista::Hash.write hash_path, log_path
+
+    hash = Gnista::Hash.new hash_path, log_path
+    ret = hash.get "key1"
+    ret.must_equal "value1"
+
+    ret = hash.get "key2"
+    ret.must_be_nil
+    FileUtils.rm hash_path
+  end
+
+  it "can get the hash length" do
+    @logwriter.put "key1", "value1"
+    @logwriter.put "key2", "value2"
+    @logwriter.put "key3", "value3"
+    @logwriter.flush
+    Gnista::Hash.write hash_path, log_path
+
+    hash = Gnista::Hash.new hash_path, log_path
+    hash.length.must_equal 3
+    FileUtils.rm hash_path
+  end
+
+  it "can get the hash collisions count" do
+    # This is hard to test
+  end
+
+  it "can be open or closed" do
+    @logwriter.open?.must_equal true
+    @logreader.open?.must_equal true
+    Gnista::Hash.write hash_path, log_path
+    hash = Gnista::Hash.new hash_path, log_path
+    hash.open?.must_equal true
+    hash.close
+    hash.open?.must_equal false
+    FileUtils.rm hash_path
+  end
+
+end

data/test/test_gnista.rb

@@ -0,0 +1,57 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'fileutils'
+require File.expand_path("../../lib/gnista", __FILE__)
+
+describe Gnista do
+
+  log_path = '/tmp/test.log'
+  hash_path = '/tmp/test.hash'
+
+  it "can create a Logwriter with only a filename" do
+    @logwriter = Gnista::Logwriter.new log_path
+    @logwriter.must_be_instance_of Gnista::Logwriter
+    @logwriter.close
+    FileUtils.rm log_path
+  end
+
+  it "can create a Logwriter with a filename and a compression number" do
+    @logwriter = Gnista::Logwriter.new log_path, 4000
+    @logwriter.must_be_instance_of Gnista::Logwriter
+    @logwriter.close
+    FileUtils.rm log_path
+  end
+
+  it "can append a Logwriter" do
+    @logwriter = Gnista::Logwriter.new log_path
+    @logwriter.close
+
+    @logwriter = Gnista::Logwriter.new log_path, :append
+    @logwriter.must_be_instance_of Gnista::Logwriter
+    @logwriter.close
+    FileUtils.rm log_path
+  end
+
+  it "can create a Logreader with a filename" do
+    @logwriter = Gnista::Logwriter.new log_path
+    @logwriter.close
+
+    @logreader = Gnista::Logreader.new log_path
+    @logreader.must_be_instance_of Gnista::Logreader
+    @logreader.close
+    FileUtils.rm log_path
+  end
+
+  it "can write and read a Hash with a log-file and a hash-file" do
+    @logwriter = Gnista::Logwriter.new log_path
+    @logwriter.close
+
+    Gnista::Hash.write hash_path, log_path
+    @hash = Gnista::Hash.new hash_path, log_path
+    @hash.must_be_instance_of Gnista::Hash
+    @hash.close
+    FileUtils.rm hash_path
+    FileUtils.rm log_path
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: gnista
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Emanuel Andersson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: Gnista is a wrapper for the database/hashstore Sparkey written for Ruby.
+  Gnista packs all the native features of Sparkey into a shiny red package, easy to
+  use.
+email:
+- manusdude@gmail.com
+executables: []
+extensions:
+- ext/gnista/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE.txt
+- HISTORY.md
+- Rakefile
+- ext/gnista/extconf.rb
+- ext/gnista/gnista.c
+- test/test_gnista.rb
+- test/test_commands.rb
+- lib/gnista.rb
+- lib/gnista/version.rb
+homepage: http://github.com/emnl/gnista
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext
+- 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: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for Spotify's Sparkey
+test_files:
+- test/test_gnista.rb
+- test/test_commands.rb