sophia-ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 533b4d801eea26b4985fa2dd294d317ad439947f
-  data.tar.gz: a8d25941d1559a6b623070eb68c329bca7f03ecf
+  metadata.gz: 03126fdd239f628aa86ab992b6c6c4e539b76f09
+  data.tar.gz: 82ef09e5e5613ea32528e79a57e806049e641ecf
 SHA512:
-  metadata.gz: 2e61b3eae94389f15920484f179857d3d588ba61642a6a5994cc23a8ed0d2a04550b1fd870ee5615e547dd3502e6b1969b8d044b978e409f9f67ab68bca2d357
-  data.tar.gz: d213cd87d5c61e594da3d9343ac31d9cc179dff9e6ebbb2a3dd5f90627f17543f1c53f058b3d57c5d6f3e4121306c0b820a86dd15ee73ad1d028a1256c5bbbc9
+  metadata.gz: a8fd0a625c9885df5906d3c1869d0cf9ee9bd90c94ad9c4e28946c609d370cd357415e4c8d44142ade1fbd239f77ad23ac282a69e4a35ba09c717bc5e92a4559
+  data.tar.gz: 9e3bac14487e3580639c6ecf51e1d2ef6ffe40167062f8853b41477fb2683b1e067512cb3f26c524516f8ee0f2b22073b6aaade6aebdec44a3f47015c2841273

data/ext/sophia.c

@@ -4,17 +4,18 @@
 #define GetSophia(object, sophia) {                         \
         Data_Get_Struct((object), Sophia, (sophia));        \
         if ((sophia) == NULL) {                             \
-            rb_raise(rb_eStandardError, "closed object");   \
+            rb_raise(rb_eSophiaError, "closed object");   \
         }                                                   \
         if ((sophia)->env == NULL) {                        \
-            rb_raise(rb_eStandardError, "closed object");   \
+            rb_raise(rb_eSophiaError, "closed object");   \
         }                                                   \
         if ((sophia)->db == NULL) {                         \
-            rb_raise(rb_eStandardError, "closed object");   \
+            rb_raise(rb_eSophiaError, "closed object");   \
         }                                                   \
 }
 
 static VALUE rb_cSophia;
+static VALUE rb_eSophiaError;
 
 typedef struct {
     void* env;
@@ -67,20 +68,20 @@ sophia_initialize(int argc, VALUE *argv, VALUE self)
     sophia->env = sp_env();
 
     if (sophia->env == NULL) {
-        rb_raise(rb_eStandardError, "sp_env(3)");
+        rb_raise(rb_eSophiaError, "sp_env(3)");
     }
 
     if (sp_ctl(sophia->env, SPDIR, SPO_CREAT|SPO_RDWR, RSTRING_PTR(file))) {
-        rb_raise(rb_eStandardError, sp_error(sophia->env));
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
     }
 
     sophia->db = sp_open(sophia->env);
 
     if (sophia->db == NULL) {
-        rb_raise(rb_eStandardError, sp_error(sophia->env));
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
     }
 
-    return Qnil;
+    return self;
 }
 
 /*
@@ -96,14 +97,14 @@ sophia_close(VALUE self)
 
     if (sophia->db) {
         if (sp_destroy(sophia->db)) {
-            rb_raise(rb_eStandardError, sp_error(sophia->env));
+            rb_raise(rb_eSophiaError, sp_error(sophia->env));
         }
         sophia->db = NULL;
     }
 
     if (sophia->env) {
         if (sp_destroy(sophia->env)) {
-            rb_raise(rb_eStandardError, sp_error(sophia->env));
+            rb_raise(rb_eSophiaError, sp_error(sophia->env));
         }
         sophia->env = NULL;
     }
@@ -111,6 +112,27 @@ sophia_close(VALUE self)
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   Sophia.open("/path/to/db") -> sophia
+ *   Sophia.open("/path/to/db") { |sophia| block } -> block
+ */
+static VALUE
+sophia_s_open(int argc, VALUE *argv, VALUE self)
+{
+    VALUE sophia = sophia_alloc(self);
+
+    if (NIL_P(sophia_initialize(argc, argv, sophia))) {
+        return Qnil;
+    }
+
+    if (rb_block_given_p()) {
+        return rb_ensure(rb_yield, sophia, sophia_close, sophia);
+    }
+
+    return sophia;
+}
+
 /*
  * call-seq:
  *   sophia.closed? -> true or false
@@ -150,7 +172,7 @@ sophia_set(VALUE self, VALUE key, VALUE value)
     if (sp_set(sophia->db,
                RSTRING_PTR(key), RSTRING_LEN(key),
                RSTRING_PTR(value), RSTRING_LEN(value))) {
-        rb_raise(rb_eStandardError, sp_error(sophia->env));
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
     }
 
     return value;
@@ -181,10 +203,10 @@ sophia_get(VALUE self, VALUE key, VALUE ifnone)
             return ifnone;
         }
     } else if (result == -1) {
-        rb_raise(rb_eStandardError, sp_error(sophia->env));
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
     }
 
-    rb_raise(rb_eStandardError, "error");
+    rb_raise(rb_eSophiaError, "error");
     return Qnil;
 }
 
@@ -203,18 +225,165 @@ sophia_fetch(int argc, VALUE *argv, VALUE self)
     return sophia_get(self, key, ifnone);
 }
 
+static VALUE
+sophia_delete(VALUE self, VALUE key)
+{
+    Sophia *sophia;
+    int     result;
+    VALUE      val;
+
+    GetSophia(self, sophia);
+
+    ExportStringValue(key);
+
+    val = sophia_aref(self, key);
+
+    result = sp_delete(sophia->db,
+                       RSTRING_PTR(key), RSTRING_LEN(key));
+    if (result == 0) {
+        return val;
+    } else if (result == -1) {
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
+    }
+
+    rb_raise(rb_eSophiaError, "error");
+    return Qnil;
+}
+
+static VALUE
+sophia_length(VALUE self)
+{
+    Sophia *sophia;
+    int length = 0;
+    void   *cursor;
+
+    GetSophia(self, sophia);
+
+    cursor = sp_cursor(sophia->db, SPGT, NULL, 0);
+    if (cursor == NULL) {
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
+    }
+	while (sp_fetch(cursor)) {
+        length += 1;
+    }
+    sp_destroy(cursor);
+
+    return INT2FIX(length);
+}
+
+static VALUE
+sophia_empty_p(VALUE self)
+{
+    Sophia *sophia;
+    int     result;
+    void   *cursor;
+
+    GetSophia(self, sophia);
+
+    cursor = sp_cursor(sophia->db, SPGT, NULL, 0);
+    if (cursor == NULL) {
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
+    }
+    result = sp_fetch(cursor);
+    sp_destroy(cursor);
+
+    return result == 0 ?  Qtrue : Qfalse;
+}
+
+static VALUE
+sophia_each_pair(VALUE self)
+{
+    Sophia *sophia;
+    void   *cursor;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    GetSophia(self, sophia);
+
+    cursor = sp_cursor(sophia->db, SPGT, NULL, 0);
+    if (cursor == NULL) {
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
+    }
+    while (sp_fetch(cursor)) {
+        rb_yield(rb_assoc_new(rb_str_new(sp_key(cursor), sp_keysize(cursor)),
+                              rb_str_new(sp_value(cursor), sp_valuesize(cursor))));
+    }
+    sp_destroy(cursor);
+
+    return self;
+}
+
+static VALUE
+sophia_each_key(VALUE self)
+{
+    Sophia *sophia;
+    void   *cursor;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    GetSophia(self, sophia);
+
+    cursor = sp_cursor(sophia->db, SPGT, NULL, 0);
+    if (cursor == NULL) {
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
+    }
+    while (sp_fetch(cursor)) {
+        rb_yield(rb_str_new(sp_key(cursor), sp_keysize(cursor)));
+    }
+    sp_destroy(cursor);
+
+    return self;
+}
+
+static VALUE
+sophia_each_value(VALUE self)
+{
+    Sophia *sophia;
+    void   *cursor;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    GetSophia(self, sophia);
+
+    cursor = sp_cursor(sophia->db, SPGT, NULL, 0);
+    if (cursor == NULL) {
+        rb_raise(rb_eSophiaError, sp_error(sophia->env));
+    }
+    while (sp_fetch(cursor)) {
+        rb_yield(rb_str_new(sp_value(cursor), sp_valuesize(cursor)));
+    }
+    sp_destroy(cursor);
+
+    return self;
+}
+
 void
 Init_sophia()
 {
     rb_cSophia = rb_define_class("Sophia", rb_cObject);
+    rb_include_module(rb_cSophia, rb_mEnumerable); /* include Enumerable */
     rb_define_alloc_func(rb_cSophia, sophia_alloc);
+
+    rb_eSophiaError = rb_define_class("SophiaError", rb_eStandardError);
+
+    rb_define_singleton_method(rb_cSophia, "open", sophia_s_open, -1);
+
     rb_define_private_method(rb_cSophia, "initialize", sophia_initialize, -1);
-    rb_define_method(rb_cSophia, "close",   sophia_close, 0);
-    rb_define_method(rb_cSophia, "closed?", sophia_closed_p, 0);
-    rb_define_method(rb_cSophia, "set",     sophia_set, 2);
-    rb_define_method(rb_cSophia, "[]=",     sophia_set, 2);
-    rb_define_method(rb_cSophia, "get",     sophia_aref, 1);
-    rb_define_method(rb_cSophia, "[]",      sophia_aref, 1);
-    rb_define_method(rb_cSophia, "fetch",   sophia_fetch, -1);
+    rb_define_method(rb_cSophia, "close",      sophia_close, 0);
+    rb_define_method(rb_cSophia, "closed?",    sophia_closed_p, 0);
+    rb_define_method(rb_cSophia, "set",        sophia_set, 2);
+    rb_define_method(rb_cSophia, "[]=",        sophia_set, 2);
+    rb_define_method(rb_cSophia, "get",        sophia_aref, 1);
+    rb_define_method(rb_cSophia, "[]",         sophia_aref, 1);
+    rb_define_method(rb_cSophia, "fetch",      sophia_fetch, -1);
+    rb_define_method(rb_cSophia, "delete",     sophia_delete, 1);
+    rb_define_method(rb_cSophia, "length",     sophia_length, 0);
+    rb_define_alias(rb_cSophia,  "size",       "length");
+    rb_define_method(rb_cSophia, "empty?",     sophia_empty_p, 0);
+    rb_define_method(rb_cSophia, "each_pair",  sophia_each_pair, 0);
+    rb_define_alias(rb_cSophia,  "each",       "each_pair");
+    rb_define_method(rb_cSophia, "each_key",   sophia_each_key, 0);
+    rb_define_method(rb_cSophia, "each_value", sophia_each_value, 0);
+
     rb_require("sophia/version");
 }

data/lib/sophia/version.rb

@@ -1,3 +1,3 @@
 class Sophia
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/test/test_sophia.rb

@@ -1,33 +1,147 @@
 require 'rubygems'
 require 'bundler/setup'
-Bundler.require
+Bundler.require :default, :test
 require 'minitest/spec'
 require 'minitest/autorun'
 require 'sophia'
 require 'tmpdir'
+require 'fileutils'
 
 describe Sophia do
+  before { @tmpdir = Dir.mktmpdir }
+  after  { FileUtils.remove_entry_secure @tmpdir }
+
+  it 'open' do
+    Sophia.open(@tmpdir).must_be_instance_of Sophia
+  end
+
+  it 'open with block' do
+    retval = rand
+    Sophia.open(@tmpdir) { |sophia| retval }.must_equal retval
+  end
+
   it 'get/set' do
-    path = Dir.mktmpdir
-    sophia = Sophia.new path
+    sophia = Sophia.new @tmpdir
     sophia['key'] = 'value'
+
     sophia['key'].must_equal 'value'
   end
 
   it 'fetch' do
-    path = Dir.mktmpdir
-    sophia = Sophia.new path
+    sophia = Sophia.new @tmpdir
+    sophia['key'] = 'value'
+
+    sophia.fetch('key').must_equal 'value'
+  end
+
+  it 'fetch not exists key' do
+    sophia = Sophia.new @tmpdir
+
+    sophia.fetch('key').must_be_nil
+  end
+
+  it 'fetch with default value' do
+    sophia = Sophia.new @tmpdir
 
     sophia.fetch('key', '123').must_equal '123'
   end
 
-  it 'fetch block' do
-    path = Dir.mktmpdir
-    sophia = Sophia.new path
+  it 'fetch with block' do
+    sophia = Sophia.new @tmpdir
 
     sophia.fetch('key') { |key|
       key.must_equal 'key'
       '456'
     }.must_equal '456'
   end
+
+  it 'delete' do
+    sophia = Sophia.new @tmpdir
+    sophia['key'] = 'val'
+
+    sophia.delete('key').must_equal 'val'
+  end
+
+  it 'delete not exists key' do
+    sophia = Sophia.new @tmpdir
+
+    sophia.delete('key').must_be_nil
+  end
+
+  it 'length' do
+    sophia = Sophia.new @tmpdir
+
+    sophia.length.must_equal 0
+  end
+
+  it 'length with key' do
+    sophia = Sophia.new @tmpdir
+    sophia['key'] = 'val'
+
+    sophia.length.must_equal 1
+  end
+
+  it 'empty?' do
+    sophia = Sophia.new @tmpdir
+
+    sophia.must_be :empty?
+  end
+
+  it 'empty? with key' do
+    sophia = Sophia.new @tmpdir
+    sophia['key'] = 'val'
+
+    sophia.wont_be :empty?
+  end
+
+  it 'access to closed sophia db' do
+    sophia = Sophia.new @tmpdir
+    sophia.close
+
+    lambda { sophia['key'] = 'val' }.must_raise SophiaError
+  end
+
+  it 'each' do
+    sophia = Sophia.new @tmpdir
+    sophia['key1'] = 'val1'
+    sophia['key2'] = 'val2'
+    keys, vals = [], []
+    sophia.each { |k, v| keys << k; vals << v }
+
+    keys.must_equal %w[key1 key2]
+    vals.must_equal %w[val1 val2]
+  end
+
+  it 'each_key' do
+    sophia = Sophia.new @tmpdir
+    sophia['key1'] = 'val1'
+    sophia['key2'] = 'val2'
+    keys = []
+    sophia.each_key { |k| keys << k }
+
+    keys.must_equal %w[key1 key2]
+  end
+
+  it 'each_value' do
+    sophia = Sophia.new @tmpdir
+    sophia['key1'] = 'val1'
+    sophia['key2'] = 'val2'
+    vals = []
+    sophia.each_value { |v| vals << v }
+
+    vals.must_equal %w[val1 val2]
+  end
+
+  it 'find' do
+    sophia = Sophia.new @tmpdir
+    sophia['key1'] = 'val1'
+    sophia['key2'] = 'val2'
+    sophia['key3'] = 'val3'
+    sophia['key4'] = 'val4'
+    expect = %w[key2 val2]
+
+    sophia.find { |key, val|
+      [key, val] == expect
+    }.must_equal expect
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sophia-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - miyucy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-19 00:00:00.000000000 Z
+date: 2013-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -126,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.4
+rubygems_version: 2.1.9
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for the Sophia key/value store