ccp 0.3.5 → 0.4.0

data/lib/ccp/kvs/tch.rb

@@ -1,17 +1,33 @@
-require 'tokyocabinet'
+begin
+  require 'tokyocabinet'
+rescue LoadError
+  load_error = true
+end
+
+unless load_error
+  require 'ccp/kvs/tokyo'
 
-module Ccp
-  module Kvs
-    class Tch < Tokyo::Cabinet
-      def get(k)   ; R{ super }; end
-      def set(k,v) ; W{ super }; end
-      def del(k)   ; W{ super }; end
-      def count    ; R{ super }; end
-      def keys     ; R{ super }; end
-      def first_key; R{ super }; end
-      def first    ; R{ super }; end
-      def read     ; R{ super }; end
-      def write(h) ; W{ super }; end
+  module Ccp
+    module Kvs
+      class Tch < Tokyo::Cabinet
+        # core
+        def get(k)        ; R{ super }; end
+        def set(k,v)      ; W{ super }; end
+        def del(k)        ; W{ super }; end
+        def count         ; R{ super }; end
+        def read          ; R{ super }; end
+        def write(h)      ; W{ super }; end
+
+        # enum
+        def each(&b)      ; R{ super }; end
+        def each_pair(&b) ; R{ super }; end
+        def each_key(&b)  ; R{ super }; end
+        def keys          ; R{ super }; end
+        def first_key     ; R{ super }; end
+        def first         ; R{ super }; end
+      end
     end
   end
+
+  Ccp::Kvs << Ccp::Kvs::Tch
 end

data/lib/ccp/kvs/tokyo/cabinet.rb

@@ -101,11 +101,6 @@ module Ccp
           end
         end
 
-        def each_keys(&block)
-          STDERR.puts "DEPRECATION WARNING: #{self.class}#each_keys is deprecated and will be removed in 0.4.0, use each_key instead"
-          each_key(&block)
-        end
-
         def keys
           array = []
           each_key do |key|

data/lib/ccp/storage.rb

@@ -65,11 +65,5 @@ module Ccp
         return @kvs.read
       end
     end
-
-    # backward compat (until 0.3.6)
-    def read!
-      STDERR.puts "DEPRECATION WARNING: #{self.class}#read! will be removed in 0.3.6, use read instead"
-      read
-    end
   end
 end

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.3.5"
+  VERSION = "0.4.0"
 end

data/spec/kvs/enum_spec.rb

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+codecs = %w( json msgpack )
+exts   = %w( tch kch )
+
+codecs.product(exts).each do |codec, ext|
+  klass = Ccp::Kvs[ext]
+  describe "#{klass}(#{codec})" do
+    before { FileUtils.rm_rf(tmp_path) if tmp_path.directory? }
+    let(:kvs) { klass.new(tmp_path + "kvs.#{ext}") }
+
+    before {
+      kvs.codec!(codec)
+
+      kvs.touch
+      kvs["1"] = 10
+      kvs["2"] = 20
+      kvs["3"] = 30
+      kvs["4"] = 40
+      kvs.del("3")
+      # => {"1"=>10, "2"=>20, "4"=>40}
+    }
+
+    specify "(given)" do
+      kvs.read.should == {"1"=>10, "2"=>20, "4"=>40}
+    end
+
+    ######################################################################
+    ### enumerable
+
+    describe "#each" do
+      specify do
+        hash = {}
+        kvs.each do |k,v|
+          hash[k] = v
+        end
+        hash.should == {"1"=>10, "2"=>20, "4"=>40}
+      end
+    end
+
+    describe "#each_pair" do
+      specify do
+        hash = {}
+        kvs.each_pair do |k,v|
+          hash[k] = v
+        end
+        hash.should == {"1"=>10, "2"=>20, "4"=>40}
+      end
+    end
+
+    describe "#each_key" do
+      specify do
+        array = []
+        kvs.each_key do |k|
+          array << k
+        end
+        array.sort.should == %w( 1 2 4 )
+      end
+    end
+
+    describe "#keys" do
+      specify do
+        kvs.keys.sort.should == %w( 1 2 4 )
+      end
+    end
+
+    describe "#first_key" do
+      specify do
+        kvs.first_key.should =~ /^[124]$/
+      end
+    end
+
+    describe "#first" do
+      specify do
+        k,v = kvs.first
+        (k.to_i*10).should == v
+      end
+    end
+
+    ######################################################################
+    ### usecase
+
+    describe "#each with break" do
+      specify do
+        head = []
+        i = 0
+        kvs.each do |k,v|
+          i += 1
+          break if i > 1
+          head << v
+        end
+
+        head.should == [10]
+      end
+    end
+
+    describe "#each with raise" do
+      specify do
+        head = []
+        i = 0
+
+        lambda {
+          kvs.each do |k,v|
+            i += 1
+            raise "ok" if i > 1
+            head << v
+          end
+        }.should raise_error(/ok/)
+
+        head.should == [10]
+      end
+    end
+
+    describe "#each with next" do
+      specify do
+        tail = []
+        i = 0
+        kvs.each do |k,v|
+          i += 1
+          next if i <= 1
+          tail << v
+        end
+
+        tail.sort.should == [20, 40]
+      end
+    end
+
+  end
+
+end

data/spec/kvs/kvs_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 
 kvs_args = {}
 kvs_args["tch"] = "#{tmp_path}/kvs/foo.tch"
+kvs_args["kch"] = "#{tmp_path}/kvs/foo.kch"
 
 Ccp::Kvs.each do |klass|
   describe klass do

data/spec/kvs/kyoto/cabinet_spec.rb

@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Ccp::Kvs::Kyoto::Cabinet do
+  let(:tmp) { tmp_path + "kvs/kyoto/cabinet" }
+  let(:kch) { tmp + "foo.kch" }
+  let(:kvs) { subject }
+
+  subject { Ccp::Kvs::Kyoto::Cabinet.new(kch) }
+  before  { FileUtils.rm_rf(tmp) if tmp.directory? }
+  after   { subject.close }
+
+  def put(key, val)
+    kvs.touch
+    system("kchashmgr set #{kvs.path} #{key} #{val}")
+  end
+
+  def del(key)
+    kvs.touch
+    system("kchashmgr remove #{kvs.path} #{key}")
+  end
+
+  ######################################################################
+  ### count
+
+  describe "#count" do
+    context "(not opened)" do
+      specify { lambda { subject.count }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for read)" do
+      specify {
+        kvs.touch
+        kvs.R!()
+        kvs.count.should == 0
+      }
+
+      specify {
+        kvs.touch
+        kvs.R{ kvs.count.should == 0 }
+      }
+    end
+
+    context "(for write)" do
+      specify {
+        kvs.W!()
+        kvs.count.should == 0
+      }
+
+      specify {
+        kvs.W{ kvs.count.should == 0 }
+      }
+    end
+  end
+
+  ######################################################################
+  ### get
+
+  describe "#get" do
+    context "(not opened)" do
+      specify { lambda { kvs.get("foo") }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for read)[no records]" do
+      before  { kvs.touch; kvs.R! }
+      specify { kvs.get("foo").should == nil }
+    end
+
+    context "(for read block)[no records]" do
+      before  { kvs.touch }
+      specify { kvs.R { kvs.get("foo").should == nil } }
+    end
+
+    context "(for read)[exists]" do
+      before  { put(:foo, 1); kvs.R! }
+      specify { kvs.get("foo").should == "1" }
+    end
+
+    context "(for read block)[exists]" do
+      before  { put(:foo, 1); kvs.R! }
+      specify { kvs.R { kvs.get("foo").should == "1" } }
+    end
+
+    context "(for write)[no records]" do
+      before  { kvs.W! }
+      specify { kvs.get("foo").should == nil }
+    end
+
+    context "(for write block)[no records]" do
+      specify { kvs.W { kvs.get("foo").should == nil } }
+    end
+
+    context "(for write)[exists]" do
+      before  { put(:foo, 1); kvs.W! }
+      specify { kvs.get("foo").should == "1" }
+    end
+
+    context "(for write block)[exists]" do
+      before  { put(:foo, 1); kvs.W! }
+      specify { kvs.W { kvs.get("foo").should == "1" } }
+    end
+  end
+
+  ######################################################################
+  ### set
+
+  describe "#set" do
+    before { kvs.touch }
+
+    context "(not opened)" do
+      specify { lambda { kvs.set("foo", 2) }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for read)" do
+      before  { kvs.R! }
+      specify { lambda { kvs.set("foo", 2) }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for read block)" do
+      specify { lambda { kvs.R{ kvs.set("foo", 2) } }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for write)" do
+      before  { kvs.W! }
+      specify { lambda { kvs.set("foo", 2) }.should_not raise_error }
+    end
+
+    context "(for write block)" do
+      specify { lambda { kvs.W{ kvs.set("foo", 2) }.should_not raise_error } }
+    end
+  end
+
+  ######################################################################
+  ### del
+
+  describe "#del" do
+    before { kvs.touch; put(:foo, 3) }
+
+    context "(not opened)" do
+      specify { lambda { kvs.del("foo") }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for read)" do
+      before  { kvs.R! }
+      specify { lambda { kvs.del("foo") }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for read block)" do
+      specify { lambda { kvs.R{ kvs.del("foo") } }.should raise_error(Ccp::Kvs::NotAllowed) }
+    end
+
+    context "(for write)" do
+      before  { kvs.W! }
+      specify {
+        kvs.get("foo").should == "3"
+        kvs.del("foo").should == "3"
+        kvs.get("foo").should == nil
+      }
+    end
+
+    context "(for write block)" do
+      specify {
+        kvs.W {
+          kvs.get("foo").should == "3"
+          kvs.del("foo").should == "3"
+          kvs.get("foo").should == nil
+        }
+      }
+    end
+
+    context "(for write)[no records]" do
+      before  { del(:foo); kvs.W! }
+      specify {
+        kvs.get("foo").should == nil
+        kvs.del("foo").should == nil
+      }
+    end
+
+    context "(for write block)[no records]" do
+      before  { del(:foo) }
+      specify {
+        kvs.W {
+          kvs.get("foo").should == nil
+          kvs.del("foo").should == nil
+        }
+      }
+    end
+  end
+
+  ######################################################################
+  ### read / write
+
+  describe "#read" do
+    specify do
+      put(:foo, 1)
+      put(:bar, 2)
+
+      kvs.R!
+      kvs.read.should == {"foo" => "1", "bar" => "2"}
+    end
+  end
+
+  describe "#write" do
+    specify do
+      kvs.W!
+      kvs.write("foo" => "1", "bar" => "2")
+
+      kvs.get("foo").should == "1"
+      kvs.get("bar").should == "2"
+    end
+  end
+
+  ######################################################################
+  ### each
+
+  describe "#each" do
+    specify do
+      put(:foo, 1)
+      put(:bar, 2)
+
+      kvs.R!
+
+      hash = {}
+      kvs.each{|k,v| hash[k] = v}
+      hash.should == {"foo" => "1", "bar" => "2"}
+    end
+  end
+
+  ######################################################################
+  ### keys
+
+  describe "#keys" do
+    specify do
+      put(:foo, 1)
+      put(:bar, 2)
+      put(:baz, 3)
+
+      kvs.R!
+      kvs.keys.sort.should == %w( bar baz foo )
+    end
+  end
+
+  ######################################################################
+  ### first
+
+  describe "#first" do
+    specify do
+      put(:foo, 1)
+      put(:bar, 2)
+
+      kvs.R!
+      first = kvs.first
+      first.should be_kind_of(Array)
+      first.size.should == 2
+      first[0].should =~ /^(foo|bar)$/
+      first[1].should =~ /^(1|2)$/
+    end
+  end
+
+  describe "#first_key" do
+    specify do
+      put(:foo, 1)
+      put(:bar, 2)
+
+      kvs.R!
+      kvs.first_key.should =~ /^(foo|bar)$/
+    end
+  end
+
+  ######################################################################
+  ### exist?
+
+  describe "#exist?" do
+    specify do
+      put(:foo, 1)
+
+      kvs.R!
+      kvs.exist?(:foo).should be
+      kvs.exist?(:bar).should_not be
+    end
+  end
+end