ccp 0.2.9 → 0.3.0

data/ccp.gemspec

@@ -5,6 +5,7 @@ require "ccp/version"
 Gem::Specification.new do |s|
   s.name        = "ccp"
   s.version     = Ccp::VERSION
+  s.license     = 'MIT'
   s.authors     = ["maiha"]
   s.email       = ["maiha@wota.jp"]
   s.homepage    = "http://github.com/maiha/ccp"

data/lib/ccp.rb

@@ -14,5 +14,6 @@ module Ccp
   autoload :Receivers,         'ccp/receivers'
   autoload :Persistent,        'ccp/persistent'
   autoload :Serializers,       'ccp/serializers'
+  autoload :Storage,           'ccp/storage'
   autoload :Kvs,               'ccp/kvs'
 end

data/lib/ccp/kvs/core.rb

@@ -4,6 +4,8 @@ module Ccp
       def get(k)   ; raise NotImplementedError, "subclass resposibility"; end
       def set(k,v) ; raise NotImplementedError, "subclass resposibility"; end
       def del(k)   ; raise NotImplementedError, "subclass resposibility"; end
+      def keys     ; raise NotImplementedError, "subclass resposibility"; end
+      def read!    ; keys.inject({}){|h,k| h[k] = get(k); h }           ; end
 
       def open(*)  ; end
       def close    ; end
@@ -16,6 +18,10 @@ module Ccp
       def put(k,v) ; set(k,v) ; end
       def out(k)   ; del(k)   ; end
 
+      def codec!(c); @codec = Ccp::Serializers[c] ; self  ; end
+      def encode(v); @codec ? @codec.encode(v)        : v ; end
+      def decode(v); (v && @codec) ? @codec.decode(v) : v ; end
+
       def ext; self.class.name.split(/::/).last.to_s.downcase; end
       def self.included(klass)
         klass.class_eval do

data/lib/ccp/kvs/hash.rb

@@ -3,14 +3,16 @@ module Ccp
     class Hash
       include Core
 
+      delegate :keys, :to=>"@db"
+
       def initialize
         @db = {}
       end
 
-      def get(k)   ; @db[k.to_s]          ; end
-      def set(k,v) ; @db[k.to_s] = v.to_s ; end
-      def del(k)   ; @db.delete(k.to_s)   ; end
-      def count    ; @db.size             ; end
+      def get(k)   ; decode(@db[k.to_s])         ; end
+      def set(k,v) ; @db[k.to_s] = encode(v).to_s; end
+      def del(k)   ; decode(@db.delete(k.to_s))  ; end
+      def count    ; @db.size                    ; end
     end
   end
 end

data/lib/ccp/kvs/tch.rb

@@ -7,6 +7,8 @@ module Ccp
       def set(k,v) ; W{ super }; end
       def del(k)   ; W{ super }; end
       def count    ; R{ super }; end
+      def keys     ; R{ super }; end
+      def read!    ; R{ super }; end
     end
   end
 end

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

@@ -19,10 +19,6 @@ module Ccp
         ######################################################################
         ### kvs
 
-        def get(k)   ; @db[k]        ; end
-        def set(k,v) ; @db[k] = v    ; end
-        def del(k)   ; @db.delete(k) ; end
-
         def path
           file = @source.to_s.sub(/#.*$/, '') # parse "foo.tch#mode=r"
           Pathname(file)
@@ -30,7 +26,11 @@ module Ccp
 
         private
           def tokyo_error!(label = nil)
-            raise Ccp::Kvs::Tokyo::Error, "%s%s" % [label, error_message]
+            raise Ccp::Kvs::Tokyo::Error, "%s%s (%s)" % [label, error_message, @source]
+          end
+
+          def tokyo_error?
+            @db.ecode != HDB::ESUCCESS
           end
 
           def error_message

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

@@ -16,7 +16,7 @@ module Ccp
           tryR("get")
           v = @db[k.to_s]
           if v
-            return v
+            return decode(v)
           else
             if @db.ecode == HDB::ENOREC
               return nil
@@ -28,15 +28,17 @@ module Ccp
 
         def set(k,v)
           tryW("set")
-          @db[k.to_s] = v.to_s or tokyo_error!("set(%s): " % k)
+          val = encode(v)
+          @db[k.to_s] = val or
+            tokyo_error!("set(%s): " % k)
         end
 
         def del(k)
           tryW("del")
-          v = get(k)
+          v = @db[k.to_s]
           if v
-            if @db.delete(k.to_s) 
-              return v
+            if @db.delete(k.to_s)
+              return decode(v)
             else
               tokyo_error!("del(%s): " % k)
             end
@@ -50,6 +52,37 @@ module Ccp
           return @db.rnum
         end
 
+        ######################################################################
+        ### iterator
+
+        def each(&block)
+          each_keys do |key|
+            block.call(get(key))
+          end
+        end
+
+        def each_pair(&block)
+          each_keys do |key|
+            block.call(key, get(key))
+          end
+        end
+
+        def each_keys(&block)
+          tryR("each_keys")
+          @db.iterinit
+          while key = @db.iternext
+            block.call(key)
+          end
+        end
+
+        def keys
+          array = []
+          each_keys do |key|
+            array << key
+          end
+          return array
+        end
+
       end
     end
   end

data/lib/ccp/storage.rb

@@ -0,0 +1,62 @@
+module Ccp
+  class Storage
+    NotFound = Class.new(RuntimeError)
+
+    def self.load(path)
+      array = path.split(".")
+      kvs   = Ccp::Kvs[array.pop]
+      codec = Ccp::Serializers[array.pop]
+      return new(path, kvs, codec)
+    end
+
+    attr_reader :source, :kvs, :codec, :path
+    delegate :get, :set, :del, :keys, :read!, :to=>"@kvs"
+
+    def initialize(source, kvs, codec)
+      @source = source
+      @codec  = codec
+      @path   = Pathname(source)
+      @kvs    = kvs.new(source).codec!(codec)
+      @tables = {}
+    end
+
+    ######################################################################
+    ### meta kvs
+
+    def table_names
+      tables                    # force to update @tables
+      @tables.keys
+    end
+
+    def tables
+      files = Dir.chdir(@path) { Dir["**/*.#{@kvs.ext}"] }
+      files.map{|file|
+        name = file.sub(/(\.#{@codec.ext})?(\.#{@kvs.ext})?$/, '')
+        table(name, file)
+      }
+    end
+
+    def table(name, file = nil)
+      @tables[name.to_s] ||= (
+        file ||= "%s.%s.%s" % [name, @codec.ext, @kvs.ext]
+        Storage.new((@path + file).to_s, @kvs.class, @codec)
+      )
+    end
+
+    ######################################################################
+    ### kvs
+
+    def read!
+      if @path.directory?
+        tables
+        hash = {}
+        @tables.each_pair do |k, kvs|
+          hash[k] = kvs.read!
+        end
+        return hash
+      else
+        return @kvs.read!
+      end
+    end
+  end
+end

data/lib/ccp/version.rb

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

data/spec/kvs/core_spec.rb

@@ -8,5 +8,6 @@ describe Ccp::Kvs::Core do
   it { should respond_to("get") }
   it { should respond_to("set") }
   it { should respond_to("del") }
+  it { should respond_to("keys") }
   it { should respond_to("touch") }
 end

data/spec/kvs/kvs_spec.rb

@@ -1,15 +1,14 @@
 # -*- 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
+kvs_args = {}
+kvs_args["tch"] = "#{tmp_path}/kvs/foo.tch"
+
+Ccp::Kvs.each do |klass|
+  describe klass do
     before  { FileUtils.rm_rf(tmp_path) if tmp_path.directory? }
 
-    its(:ext) { should == kvs.class.ext }
+    let(:kvs) { kvs_args[klass.ext] ? klass.new(*kvs_args[klass.ext]) : klass.new }
 
     describe "#get, #set, #out" do
       let(:key) { raise "Sub context responsibility" }
@@ -34,11 +33,59 @@ kvss.each do |kvs|
         it { should be }
       end
 
-      context ":foo => 2" do
+      context ":foo => '2'" do
         let(:key) { :foo }
-        let(:val) { 2    }
+        let(:val) { "2"  }
         it { should be }
       end
     end
+
+    describe "#get, #set, #ou (with msgpack)t" do
+      let(:key) { raise "Sub context responsibility" }
+      let(:val) { raise "Sub context responsibility" }
+
+      before { kvs.codec! :msgpack }
+
+      subject {
+        k = kvs
+        k.touch
+        k.count.should == 0
+        k.get(key).should == nil
+        k.set(key, val)
+        k.get(key).should == val
+        k.count.should == 1
+        k.out(key).should == val
+        k.get(key).should == nil
+        k
+      }
+
+      context "nil" do
+        let(:key) { :foo }
+        let(:val) { nil  }
+        it { should be }
+      end
+
+      context ":foo => [true, nil]" do
+        let(:key) { :foo }
+        let(:val) { [true, nil]  }
+        it { should be }
+      end
+    end
+
+    describe "#read!" do
+      specify do
+        kvs.touch
+        kvs.codec! :json
+        kvs.set(:a, 1)
+        kvs.set(:b, ["x", 0])
+        kvs.read!.should == {"a"=>1, "b"=>["x", 0]}
+      end
+    end
+
+    describe "#codec!" do
+      specify "return self" do
+        kvs.codec!(:msgpack).should == kvs
+      end
+    end
   end
 end

data/spec/kvs/tokyo/cabinet_spec.rb

@@ -140,11 +140,11 @@ describe Ccp::Kvs::Tokyo::Cabinet do
 
     context "(for write)" do
       before  { kvs.W! }
-      specify { kvs.set("foo", 2).should == "2" }
+      specify { lambda { kvs.set("foo", 2) }.should_not raise_error }
     end
 
     context "(for write block)" do
-      specify { kvs.W{ kvs.set("foo", 2) }.should == "2" }
+      specify { lambda { kvs.W{ kvs.set("foo", 2) }.should_not raise_error } }
     end
   end
 
@@ -205,4 +205,17 @@ describe Ccp::Kvs::Tokyo::Cabinet do
     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
 end

data/spec/storage/loadable_spec.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Ccp::Storage do
+  specify ".load" do
+    Ccp::Storage.should respond_to(:load)
+  end
+
+  describe ".load" do
+    context "('tmp/foo.json.tch')" do
+      subject { Ccp::Storage.load('tmp/foo.json.tch') }
+      its(:source) { should == 'tmp/foo.json.tch' }
+      its(:kvs)    { should be_kind_of(Ccp::Kvs::Tch) }
+      its(:codec)  { should == Ccp::Serializers::Json }
+
+      describe "table(:foo)" do
+        subject { Ccp::Storage.load('tmp/foo.json.tch').table(:bar) }
+        its(:source) { should == 'tmp/foo.json.tch/bar.json.tch' }
+        its(:kvs)    { should be_kind_of(Ccp::Kvs::Tch) }
+        its(:codec)  { should == Ccp::Serializers::Json }
+      end
+    end
+
+    context "('tmp/foo.msgpack.tch')" do
+      subject { Ccp::Storage.load('tmp/foo.msgpack.tch') }
+      its(:source) { should == 'tmp/foo.msgpack.tch' }
+      its(:kvs)    { should be_kind_of(Ccp::Kvs::Tch) }
+      its(:codec)  { should == Ccp::Serializers::Msgpack }
+    end
+  end
+
+  describe "#read!" do
+    before { FileUtils.rm_rf(tmp_path) if tmp_path.directory? }
+
+    context "(file)" do
+      let(:tch) { tmp_path + "foo.json.tch" }
+      subject { Ccp::Storage.new(tch, Ccp::Kvs::Tch, Ccp::Serializers::Json) }
+      before  {
+        tch.parent.mkpath
+        system("tchmgr create #{tch}")
+        system("tchmgr put #{tch} a '[1,2]'")
+        system("tchmgr put #{tch} b 0.1")
+      }
+      specify do
+        subject.read!.should == {"a" => [1, 2], "b" => 0.1}
+      end
+    end
+    
+    context "(directory)" do
+      let(:tch) { tmp_path + "foo.json.tch" }
+      subject { Ccp::Storage.new(tch, Ccp::Kvs::Tch, Ccp::Serializers::Json) }
+      before  {
+        tch.mkpath
+        system("tchmgr create #{tch}/a.json.tch")
+        system("tchmgr put    #{tch}/a.json.tch x '[1,2]'")
+        system("tchmgr put    #{tch}/a.json.tch y []")
+        system("tchmgr create #{tch}/b.json.tch")
+        system("tchmgr put    #{tch}/b.json.tch y 0.1")
+      }
+      specify do
+        subject.read!.should == {
+          "a" => {"x" => [1, 2], "y" => []},
+          "b" => {"y" => 0.1},
+        }
+      end
+    end
+
+  end
+
+#  it { should respond_to(:tables) }
+#  it { should respond_to(:table) }
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 9
-  version: 0.2.9
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-08-22 00:00:00 Z
+date: 2013-08-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
@@ -220,6 +220,7 @@ files:
 - lib/ccp/serializers/json.rb
 - lib/ccp/serializers/msgpack.rb
 - lib/ccp/serializers/yaml.rb
+- lib/ccp/storage.rb
 - lib/ccp/utils.rb
 - lib/ccp/utils/colorize.rb
 - lib/ccp/utils/fixture_options.rb
@@ -243,7 +244,6 @@ files:
 - spec/kvs/core_spec.rb
 - spec/kvs/kvs_spec.rb
 - spec/kvs/lookup_spec.rb
-- spec/kvs/tch_spec.rb
 - spec/kvs/tokyo/cabinet_spec.rb
 - spec/kvs/tokyo/info_spec.rb
 - spec/models.rb
@@ -264,9 +264,10 @@ files:
 - spec/serializers/lookup_spec.rb
 - spec/serializers/serializer_spec.rb
 - spec/spec_helper.rb
+- spec/storage/loadable_spec.rb
 homepage: http://github.com/maiha/ccp
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: []
 

data/spec/kvs/tch_spec.rb

@@ -1,19 +0,0 @@
-# -*- 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