ccp 0.2.8 → 0.2.9

data/lib/ccp/serializers.rb

@@ -1,19 +1,38 @@
-module Ccp::Serializers
-  NotFound = Class.new(RuntimeError)
-
-  autoload :Core , 'ccp/serializers/core'
-  autoload :Json , 'ccp/serializers/json'
-  autoload :Yaml , 'ccp/serializers/yaml'
-
-  def self.lookup(name)
-    case name
-    when :json, 'json'; Ccp::Serializers::Json
-    when :yaml, 'yaml'; Ccp::Serializers::Yaml
-    else
-      Ccp::Serializers::Core.instance_methods.each do |key|
-        name.must.duck(key) { raise NotFound, "%s: %s" % [name.class, name] }
-      end
-      return name
+require 'ccp/serializers/core'
+
+module Ccp
+  module Serializers
+    NotFound = Class.new(RuntimeError)
+    
+    DICTIONARY = {}             # cache for (extname -> Serializer)
+
+    include Enumerable
+    delegate :delete, :to=>"DICTIONARY"
+
+    def each(&block)
+      DICTIONARY.each_value(&block)
     end
+
+    def [](name)
+      return name.must.coerced(Core, Symbol => :to_s, String => proc{|key| DICTIONARY[key]}) {
+        raise NotFound, "%s(%s) for %s" % [name, name.class, DICTIONARY.keys.inspect]
+      }
+    end
+
+    def []=(key, val)
+      DICTIONARY[key.to_s] = val.must(Core)
+    end
+
+    alias :lookup :[]
+    extend self
   end
 end
+
+require 'ccp/serializers/json'
+require 'ccp/serializers/yaml'
+require 'ccp/serializers/msgpack'
+
+Ccp::Serializers[:json]    = Ccp::Serializers::Json
+Ccp::Serializers[:yaml]    = Ccp::Serializers::Yaml
+Ccp::Serializers[:msgpack] = Ccp::Serializers::Msgpack
+

data/lib/ccp/serializers/core.rb

@@ -1,13 +1,16 @@
-module Ccp::Serializers::Core
-  def ext
-    raise NotImplementedError, "subclass resposibility"
-  end
-
-  def encode(val)
-    raise NotImplementedError, "subclass resposibility"
-  end
+module Ccp
+  module Serializers
+    module Core
+      def ext         ; self.class.name.split(/::/).last.to_s.downcase; end
+      def encode(val) ; raise NotImplementedError, "subclass resposibility"; end
+      def decode(val) ; raise NotImplementedError, "subclass resposibility"; end
 
-  def decode(val)
-    raise NotImplementedError, "subclass resposibility"
+      def self.included(klass)
+        klass.extend klass
+        klass.module_eval do
+          def self.ext; name.split(/::/).last.to_s.downcase; end
+        end
+      end
+    end
   end
 end

data/lib/ccp/serializers/json.rb

@@ -1,15 +1,19 @@
-module Ccp::Serializers::Json
-  include Ccp::Serializers::Core
+module Ccp
+  module Serializers
+    module Json
+      include Core
 
-  def self.ext
-    "json"
-  end
-
-  def self.encode(val)
-    JSON.dump(val)
-  end
+      # use Yajl if possible
+      begin
+        require 'yajl'
+        Engine = Yajl
+      rescue LoadError
+        require 'json'
+        Engine = JSON
+      end
 
-  def self.decode(val)
-    JSON.load(val)
+      def encode(val) ; Engine.dump(val) ; end
+      def decode(val) ; Engine.load(val) ; end
+    end
   end
 end

data/lib/ccp/serializers/msgpack.rb

@@ -0,0 +1,12 @@
+require 'msgpack'
+
+module Ccp
+  module Serializers
+    module Msgpack
+      include Core
+
+      def encode(obj); MessagePack.pack(obj)  ; end
+      def decode(obj); MessagePack.unpack(obj); end
+    end
+  end
+end

data/lib/ccp/serializers/yaml.rb

@@ -1,15 +1,12 @@
-module Ccp::Serializers::Yaml
-  include Ccp::Serializers::Core
+require 'yaml'
 
-  def self.ext
-    "yaml"
-  end
-
-  def self.encode(val)
-    val.to_yaml
-  end
+module Ccp
+  module Serializers
+    module Yaml
+      include Core
 
-  def self.decode(val)
-    YAML.load(val)
+      def encode(val) ; val.to_yaml    ; end
+      def decode(val) ; YAML.load(val) ; end
+    end
   end
 end

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/spec/kvs/core_spec.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Ccp::Kvs::Core do
+  subject { Object.new.extend Ccp::Kvs::Core }
+
+  it { should respond_to("ext") }
+  it { should respond_to("get") }
+  it { should respond_to("set") }
+  it { should respond_to("del") }
+  it { should respond_to("touch") }
+end

data/spec/kvs/kvs_spec.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+kvss = []
+kvss << Ccp::Kvs::Hash.new
+kvss << Ccp::Kvs::Tch.new("#{tmp_path}/kvs/foo.tch")
+       
+kvss.each do |kvs|
+  describe kvs do
+    before  { FileUtils.rm_rf(tmp_path) if tmp_path.directory? }
+
+    its(:ext) { should == kvs.class.ext }
+
+    describe "#get, #set, #out" do
+      let(:key) { raise "Sub context responsibility" }
+      let(:val) { raise "Sub context responsibility" }
+
+      subject {
+        k = kvs
+        k.touch
+        k.count.should == 0
+        k.get(key).should == nil
+        k.set(key, val)
+        k.get(key).should == val.to_s
+        k.count.should == 1
+        k.out(key).should == val.to_s
+        k.get(key).should == nil
+        k
+      }
+
+      context "'foo' => '1'" do
+        let(:key) { "foo" }
+        let(:val) { "1"   }
+        it { should be }
+      end
+
+      context ":foo => 2" do
+        let(:key) { :foo }
+        let(:val) { 2    }
+        it { should be }
+      end
+    end
+  end
+end

data/spec/kvs/lookup_spec.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'fileutils'
+
+describe Ccp::Kvs do
+  # API
+  it { should respond_to(:lookup) }
+
+  describe "#reload!" do
+    def add_kvs(const_name)
+      # define a new kvs
+      ext = const_name.downcase
+      kvs = Class.new
+      kvs.class_eval <<-EOF
+        include Ccp::Kvs::Core
+        def ext; '#{ext}'; end
+      EOF
+      Ccp::Kvs[ext] = kvs
+    end
+
+    def del_serialier(const_name)
+      ext = const_name.downcase
+      Ccp::Serializers.delete(ext)
+    end
+
+    specify do
+      # given
+      lambda { subject.lookup(:foo) }.should raise_error(Ccp::Kvs::NotFound)
+
+      begin
+        # main
+        add_kvs("Foo")
+        subject.lookup(:foo).should be_kind_of(Class)
+      ensure
+        del_serialier("Foo")
+      end
+    end
+  end
+
+  describe "#lookup" do
+    context ":hash" do
+      it "should return Ccp::Kvs::Hash" do
+        subject.lookup(:hash).should == Ccp::Kvs::Hash
+      end
+    end
+
+    context ":xxx" do
+      it "should raise NotFound" do
+        lambda {
+          subject.lookup(:xxx)
+        }.should raise_error(Ccp::Kvs::NotFound)
+      end
+    end
+  end
+end

data/spec/kvs/tch_spec.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+__END__
+
+describe Ccp::Kvs::Tch do
+  let(:kvs) { s = Ccp::Kvs::Tch.new; s.open(source); s }
+  let(:tmp) { tmp_path + "kvs/tch" }
+  before { FileUtils.rm_rf(tmp) if tmp.directory? }
+
+  describe "#open" do
+    subject { inform }
+
+    context "foo.tch" do
+      let(:source) { tmp + "foo.tch" }
+      its(:path) { should == "" }
+    end
+  end
+end

data/spec/kvs/tokyo/cabinet_spec.rb

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Ccp::Kvs::Tokyo::Cabinet do
+  let(:tmp) { tmp_path + "kvs/tokyo/cabinet" }
+  let(:tch) { tmp + "foo.tch" }
+  let(:kvs) { subject }
+
+  subject { Ccp::Kvs::Tokyo::Cabinet.new(tch) }
+  before  { FileUtils.rm_rf(tmp) if tmp.directory? }
+  after   { subject.close }
+
+  def put(key, val)
+    kvs.touch
+    system("tchmgr put #{kvs.path} #{key} #{val}")
+  end
+
+  def del(key)
+    kvs.touch
+    system("tchmgr out #{kvs.path} #{key}")
+  end
+
+  ######################################################################
+  ### info
+
+  describe "#info" do
+    context "(no files)" do
+      specify do
+        lambda { subject.info }.should raise_error(Ccp::Kvs::NotConnected)
+      end
+    end
+
+    context "(file exists)" do
+      specify do
+        subject.touch
+        subject.info.should be_kind_of(Ccp::Kvs::Tokyo::Info)
+      end
+    end
+  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 { kvs.set("foo", 2).should == "2" }
+    end
+
+    context "(for write block)" do
+      specify { kvs.W{ kvs.set("foo", 2) }.should == "2" }
+    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
+
+end