sander6-daijobu 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Sander Hartlage
+
+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.rdoc

@@ -0,0 +1,7 @@
+= Daijobu
+
+A library for easing serialization and deserialzation of data stuffed into Tokyo Cabinet, including flexible and fallback schemes. This will all make more sense once the documentation is written for real.
+
+== Copyright
+
+Copyright (c) 2009 Sander Hartlage. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "daijobu"
+    gem.summary     = "A helper for de/serialization of objects into and out of Tokyo Cabinets"
+    gem.email       = "sander@outside.in"
+    gem.homepage    = "http://github.com/sander6/daijobu"
+    gem.authors     = ["Sander Hartlage"]
+    gem.files       = %w{
+      LICENSE
+      Rakefile
+      README.rdoc
+      lib/daijobu.rb
+      lib/daijobu/adapter.rb
+      lib/daijobu/client.rb
+      lib/daijobu/errors.rb
+      lib/daijobu/scheme.rb
+      lib/daijobu/scheme_set.rb
+      lib/adapters/mem_cache.rb
+      lib/adapters/tokyo_cabinet.rb
+      lib/adapters/tokyo_tyrant.rb
+      lib/schemes/eval.rb
+      lib/schemes/json.rb
+      lib/schemes/marshal.rb
+      lib/schemes/yaml.rb
+    }
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "daijobu #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/lib/daijobu.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__))
+require 'daijobu/errors'
+require 'daijobu/client'
+require 'daijobu/scheme_set'
+require 'daijobu/scheme'
+require 'daijobu/schemes/marshal'
+require 'daijobu/schemes/json'
+require 'daijobu/schemes/yaml'
+require 'daijobu/schemes/eval'
+require 'daijobu/adapter'
+require 'daijobu/adapters/mem_cache'
+require 'daijobu/adapters/tokyo_cabinet'
+require 'daijobu/adapters/tokyo_tyrant'

data/lib/daijobu/adapter.rb

@@ -0,0 +1,17 @@
+module Daijobu
+  module Adapter
+    
+    def self.get(casket)
+      if defined?(MemCache) && casket.is_a?(MemCache)
+        Daijobu::Adapter::MemCacheAdapter.new(casket)
+      elsif defined?(Rufus::Tokyo::Cabinet) && casket.is_a?(Rufus::Tokyo::Cabinet)
+        Daijobu::Adapter::TokyoCabinetAdapter.new(casket)
+      elsif defined?(Rufus::Tokyo::Tyrant) && casket.is_a?(Rufus::Tokyo::Tyrant)
+        Daijobu::Adapter::TokyoTyrantAdapter.new(casket)
+      else
+        raise Daijobu::InvalidAdapter
+      end
+    end
+    
+  end
+end

data/lib/daijobu/client.rb

@@ -0,0 +1,28 @@
+module Daijobu
+  class Client
+
+    def initialize(casket, *schemes)
+      @adapter      = Daijobu::Adapter.get(casket)
+      @schemes      = Daijobu::SchemeSet.new(*schemes)
+    end
+
+    def [](key)
+      parse(@adapter.get(key))
+    end
+
+    def []=(key, value)
+      @adapter.set(key, unparse(value))
+    end
+
+    private
+
+    def parse(str)
+      @schemes.parse(str)
+    end
+
+    def unparse(obj)
+      @schemes.unparse(obj)
+    end
+
+  end
+end

data/lib/daijobu/errors.rb

@@ -0,0 +1,11 @@
+module Daijobu
+  
+  class Error < StandardError; end
+
+  class UnknownScheme < Daijobu::Error; end
+
+  class InvalidAdapter < Daijobu::Error; end
+  
+  class NoFallbackScheme < Daijobu::Error; end
+  
+end

data/lib/daijobu/scheme.rb

@@ -0,0 +1,20 @@
+module Daijobu
+  module Scheme
+    
+    def self.get(name)
+      case name
+      when :marshal
+        Daijobu::Scheme::Marshal.new
+      when :json
+        Daijobu::Scheme::JSON.new
+      when :yaml
+        Daijobu::Scheme::YAML.new
+      when :eval
+        Daijobu::Scheme::Eval.new
+      else
+        raise Daijobu::UnknownScheme
+      end
+    end
+    
+  end
+end

data/lib/daijobu/scheme_set.rb

@@ -0,0 +1,52 @@
+module Daijobu
+  class SchemeSet
+    
+    DEFAULT = [ :marshal, :json, :yaml, :eval ]
+    
+    attr_reader :current
+    
+    def initialize(*schemes)
+      @schemes = (schemes.empty? ? DEFAULT : schemes).collect { |scheme| Daijobu::Scheme.get(scheme) }
+      @current = 0
+    end
+  
+    def next
+      scheme = @schemes[@current]
+      raise NoFallbackScheme unless scheme
+      @current += 1
+      return scheme
+    end
+  
+    def reset
+      @current = 0
+    end
+
+    def parse(str)
+      begin
+        obj = self.next.parse(str)
+      rescue => e
+        if e.kind_of?(Daijobu::Error)
+          raise e
+        else
+          obj = parse(str)
+        end
+      end
+      self.reset
+      obj
+    end
+    
+    def unparse(obj)
+      begin
+        str = self.next.unparse(obj)
+      rescue => e
+        if e.kind_of?(Daijobu::Error)
+          raise e
+        else
+          str = unparse(str)
+        end
+      end
+      self.reset
+      str
+    end
+  end
+end

data/spec/daijobu/adapter_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Daijobu::Adapter do
+
+  describe ".get" do
+    
+    before do
+      Daijobu::Adapter.stubs(:defined?).returns(true)
+      MemCache              = Class.new unless defined?(MemCache)
+      Rufus::Tokyo::Cabinet = Class.new unless defined?(Rufus::Tokyo::Cabinet)
+      Rufus::Tokyo::Tyrant  = Class.new unless defined?(Rufus::Tokyo::Tyrant)
+      @casket = stub("fake casket")
+    end
+    
+    describe "with a MemCache instance" do
+      before do
+        @casket.stubs(:is_a?).with(MemCache).returns(true)
+        @casket.stubs(:is_a?).with(Rufus::Tokyo::Cabinet).returns(false)
+        @casket.stubs(:is_a?).with(Rufus::Tokyo::Tyrant).returns(false)
+      end
+
+      it "should return a MemCache adapter" do
+        Daijobu::Adapter.get(@casket).should be_an_instance_of(Daijobu::Adapter::MemCacheAdapter)
+      end
+    end
+    
+    describe "with a Rufus::Tokyo::Cabinet instance" do
+      before do
+        @casket.stubs(:is_a?).with(MemCache).returns(false)
+        @casket.stubs(:is_a?).with(Rufus::Tokyo::Cabinet).returns(true)
+        @casket.stubs(:is_a?).with(Rufus::Tokyo::Tyrant).returns(false)
+      end
+
+      it "should return a Tokyo Cabinet adapter" do
+        Daijobu::Adapter.get(@casket).should be_an_instance_of(Daijobu::Adapter::TokyoCabinetAdapter)
+      end
+    end
+    
+    describe "with a Rufus::Tokyo::Tyrant instance" do
+      before do
+        @casket.stubs(:is_a?).with(MemCache).returns(false)
+        @casket.stubs(:is_a?).with(Rufus::Tokyo::Cabinet).returns(false)
+        @casket.stubs(:is_a?).with(Rufus::Tokyo::Tyrant).returns(true)
+      end
+
+      it "should return a Tokyo Tyrant adapter" do
+        Daijobu::Adapter.get(@casket).should be_an_instance_of(Daijobu::Adapter::TokyoTyrantAdapter)
+      end      
+    end
+    
+    describe "with anything else" do
+      it "should raise an error" do
+        lambda { Daijobu::Adapter.get(:bogus) }.should raise_error(Daijobu::InvalidAdapter)
+      end
+    end
+    
+  end
+  
+end

data/spec/daijobu/adapters/mem_cache_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Adapter::MemCacheAdapter do
+  
+  before do
+    @stubby   = stub('fake store')
+    @adapter  = Daijobu::Adapter::MemCacheAdapter.new(@stubby)
+  end
+  
+  describe "#get" do
+    it "should call #get on the store and read as raw" do
+      @stubby.expects(:get).with('key', true)
+      @adapter.get('key')
+    end
+  end
+  
+  describe "set" do
+    it "should call #set on the store and write as raw" do
+      @stubby.expects(:set).with('key', 'value', 0, true)
+      @adapter.set('key', 'value')
+    end
+  end
+  
+end

data/spec/daijobu/adapters/tokyo_cabinet_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Adapter::TokyoCabinetAdapter do
+  
+  before do
+    @stubby   = stub('fake store')
+    @adapter  = Daijobu::Adapter::TokyoCabinetAdapter.new(@stubby)
+  end
+  
+  describe "#get" do
+    it "should call #[] on the store" do
+      @stubby.expects(:[]).with('key')
+      @adapter.get('key')
+    end
+  end
+  
+  describe "set" do
+    it "should call #set on the store" do
+      @stubby.expects(:[]=).with('key', 'value')
+      @adapter.set('key', 'value')
+    end
+  end
+  
+end

data/spec/daijobu/adapters/tokyo_tyrant_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Adapter::TokyoTyrantAdapter do
+  
+  before do
+    @stubby   = stub('fake store')
+    @adapter  = Daijobu::Adapter::TokyoTyrantAdapter.new(@stubby)
+  end
+  
+  describe "#get" do
+    it "should call #[] on the store" do
+      @stubby.expects(:[]).with('key')
+      @adapter.get('key')
+    end
+  end
+  
+  describe "set" do
+    it "should call #set on the store and write as raw" do
+      @stubby.expects(:[]=).with('key', 'value')
+      @adapter.set('key', 'value')
+    end
+  end
+  
+end

data/spec/daijobu/client_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Daijobu::Client do
+  
+  before do
+    @casket = Rufus::Tokyo::Cabinet.new('*')
+  end
+  
+  describe "initialization" do
+    
+    it "should set the adapter based on the casket object given" do
+      Daijobu::Adapter.expects(:get).with(@casket)
+      Daijobu::Client.new(@casket)
+    end
+    
+    it "should set the schemes based on the scheme list given" do
+      Daijobu::SchemeSet.expects(:new).with(:json, :yaml)
+      Daijobu::Client.new(@casket, :json, :yaml)
+    end
+
+  end
+
+  describe "methods" do
+    before do
+      @daijobu = Daijobu::Client.new(@casket)
+    end
+
+    describe "for getting and setting" do
+      before do
+        @adapter = @daijobu.instance_variable_get(:@adapter)
+        @stringy = "woohoo!"
+      end
+      
+      describe "#[]" do            
+        it "should call #get on the adapter" do
+          @adapter.expects(:get).with('key')
+          @daijobu['key']
+        end
+      end
+
+      describe "#[]=" do
+        before do
+          @daijobu.stubs(:unparse).returns(@stringy)
+        end
+        
+        it "should call set on the adapter" do
+          @adapter.expects(:set).with('key', @stringy)
+          @daijobu['key'] = @stringy
+        end
+      end
+    end
+    
+
+    describe "for parsing and unparsing" do
+      before do
+        @schemes = @daijobu.instance_variable_get(:@schemes)
+        @stringy = "woohoo!"
+      end
+      
+      describe "#parse" do
+        it "should call parse on the schemes" do
+          @schemes.expects(:parse).with(@stringy)
+          @daijobu.__send__(:parse, @stringy)
+        end
+      end
+    
+      describe "#unparse" do
+        it "should call unparse on the schemes" do
+          @schemes.expects(:unparse).with(@stringy)
+          @daijobu.__send__(:unparse, @stringy)
+        end
+      end
+    end
+  end
+  
+end

data/spec/daijobu/errors_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Daijobu::Error do
+  
+  it "should be a standard error" do
+    Daijobu::Error.ancestors.should include(StandardError)
+  end
+  
+end
+
+describe Daijobu::UnknownScheme do
+
+  it "should be a Daijobu error" do
+    Daijobu::UnknownScheme.ancestors.should include(Daijobu::Error)
+  end
+  
+end
+
+describe Daijobu::InvalidAdapter do
+
+  it "should be a Daijobu error" do
+    Daijobu::InvalidAdapter.ancestors.should include(Daijobu::Error)
+  end
+  
+end
+ 
+describe Daijobu::NoFallbackScheme do
+
+  it "should be a Daijobu error" do
+    Daijobu::NoFallbackScheme.ancestors.should include(Daijobu::Error)
+  end
+  
+end

data/spec/daijobu/scheme_set_spec.rb

@@ -0,0 +1,190 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Daijobu::SchemeSet do
+  
+  describe "initialization" do
+    before do
+      @scheme_set = Daijobu::SchemeSet.new
+    end
+    
+    it "should set current to 0" do
+      @scheme_set.current.should == 0
+    end
+    
+    it "should have the default set of schemes" do
+      schemes = @scheme_set.instance_variable_get(:@schemes)
+      schemes[0].should be_an_instance_of(Daijobu::Scheme::Marshal)
+      schemes[1].should be_an_instance_of(Daijobu::Scheme::JSON)
+      schemes[2].should be_an_instance_of(Daijobu::Scheme::YAML)
+      schemes[3].should be_an_instance_of(Daijobu::Scheme::Eval)
+    end
+    
+  end
+
+  describe "initialization with a specified scheme pattern" do
+    before do
+      @scheme_set = Daijobu::SchemeSet.new(:eval, :yaml)
+    end
+    
+    it "should have the proper schemes in the given order" do
+      schemes = @scheme_set.instance_variable_get(:@schemes)
+      schemes[0].should be_an_instance_of(Daijobu::Scheme::Eval)
+      schemes[1].should be_an_instance_of(Daijobu::Scheme::YAML)      
+    end
+  end
+  
+  describe "#next" do
+    before do
+      @scheme_set = Daijobu::SchemeSet.new
+      @schemes    = @scheme_set.instance_variable_get(:@schemes)
+    end
+    
+    it "should return the first of the schemes if #next hasn't been called since the last reset" do
+      @scheme_set.next.should == @schemes[0]
+    end
+    
+    it "should advance @current by 1" do
+      old = @scheme_set.current
+      @scheme_set.next
+      @scheme_set.current.should == old + 1
+    end
+    
+    it "should return the next of the schemes on each subsequent calling" do
+      @scheme_set.next.should == @schemes[0]
+      @scheme_set.next.should == @schemes[1]
+      @scheme_set.next.should == @schemes[2]
+      @scheme_set.next.should == @schemes[3]
+    end
+    
+    it "should raise an error when there are no schemes left to try" do
+      lambda { (@schemes.size + 1).times { @scheme_set.next } }.should raise_error(Daijobu::NoFallbackScheme)      
+    end
+  end
+  
+  describe "#reset" do
+    before do
+      @scheme_set   = Daijobu::SchemeSet.new
+      @schemes      = @scheme_set.instance_variable_get(:@schemes)
+      @first_scheme = @scheme_set.next
+      @scheme_set.current.should_not == 0
+    end
+    
+    it "should reset current to 0" do
+      @scheme_set.reset
+      @scheme_set.current.should == 0
+    end
+    
+    it "should then make the next subsequent calling of #next return the first scheme" do
+      @scheme_set.reset
+      @scheme_set.next.should == @first_scheme
+    end
+  end
+  
+  describe "#parse" do
+    before do
+      @scheme_set = Daijobu::SchemeSet.new(:json)
+      @stringy    = '{ "thing" : 10 }'
+      @hashy      = { "thing" => 10 }
+    end
+
+    describe "assuming that the string can be parsed" do
+      before do
+        Daijobu::Scheme::JSON.any_instance.stubs(:parse).returns(@hashy)
+      end
+      
+      it "should reset" do
+        @scheme_set.expects(:reset)
+        @scheme_set.parse(@stringy)
+      end
+      
+      it "should return the parsed entity" do
+        @scheme_set.parse(@stringy).should == @hashy
+      end
+    end
+    
+    describe "assuming that the string can't be parsed" do
+      before do
+        Daijobu::Scheme::JSON.any_instance.stubs(:parse).raises(Daijobu::Error)
+      end
+      
+      it "should raise the given error" do
+        lambda { @scheme_set.parse(@stringy) }.should raise_error(Daijobu::Error)
+      end
+    end
+  end
+  
+  describe "#parse, when the first (or any earlier) scheme doesn't work" do
+    before do
+      @stringy    = '{ "thing" : 10 }'
+      @hashy      = { "thing" => 10 }
+
+      @scheme_set     = Daijobu::SchemeSet.new(:marshal, :yaml, :json)
+      @schemes        = @scheme_set.instance_variable_get(:@schemes)
+      @marshal_scheme = @schemes[0]
+      @yaml_scheme    = @schemes[1]
+      @json_scheme    = @schemes[2]
+    end
+    
+    it "should keep trying to parse with subsequent schemes" do
+      @marshal_scheme.expects(:parse).raises(TypeError)
+      @yaml_scheme.expects(:parse).raises(ArgumentError)
+      @json_scheme.expects(:parse).returns(@stringy)
+
+      @scheme_set.parse(@stringy)
+    end
+  end
+  
+  describe "#unparse" do
+    before do
+      @scheme_set = Daijobu::SchemeSet.new(:json)
+      @stringy    = '{ "thing" : 10 }'
+      @hashy      = { "thing" => 10 }
+    end
+
+    describe "assuming that the object can be unparsed" do
+      before do
+        Daijobu::Scheme::JSON.any_instance.stubs(:unparse).returns(@stringy)
+      end
+      
+      it "should return the unparsed entity" do
+        @scheme_set.unparse(@hashy).should == @stringy
+      end
+      
+      it "should reset" do
+        @scheme_set.expects(:reset)
+        @scheme_set.unparse(@hashy)
+      end
+    end
+    
+    describe "assuming that the object can't be unparsed" do
+      before do
+        Daijobu::Scheme::JSON.any_instance.stubs(:unparse).raises(Daijobu::Error)
+      end
+      
+      it "should raise the given error" do
+        lambda { @scheme_set.unparse(@hashy) }.should raise_error(Daijobu::Error)
+      end
+    end
+  end
+
+  describe "#unparse, when the first (or any earlier) scheme doesn't work" do
+    before do
+      @stringy    = '{ "thing" : 10 }'
+      @hashy      = { "thing" => 10 }
+
+      @scheme_set     = Daijobu::SchemeSet.new(:marshal, :yaml, :json)
+      @schemes        = @scheme_set.instance_variable_get(:@schemes)
+      @marshal_scheme = @schemes[0]
+      @yaml_scheme    = @schemes[1]
+      @json_scheme    = @schemes[2]
+    end
+    
+    it "should keep trying to unparse with subsequent schemes" do
+      @marshal_scheme.expects(:unparse).raises(TypeError)
+      @yaml_scheme.expects(:unparse).raises(ArgumentError)
+      @json_scheme.expects(:unparse).returns(@stringy)
+
+      @scheme_set.unparse(@hashy)
+    end
+  end
+end

data/spec/daijobu/scheme_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Daijobu::Scheme do
+  
+  describe ".get" do
+    
+    describe "with :marshal" do
+      it "should return a marshal scheme" do
+        Daijobu::Scheme.get(:marshal).should be_an_instance_of(Daijobu::Scheme::Marshal)
+      end
+    end
+
+    describe "with :json" do
+      it "should return a json scheme" do
+        Daijobu::Scheme.get(:json).should be_an_instance_of(Daijobu::Scheme::JSON)
+      end
+    end
+
+    describe "with :yaml" do
+      it "should return a yaml scheme" do
+        Daijobu::Scheme.get(:yaml).should be_an_instance_of(Daijobu::Scheme::YAML)
+      end
+    end
+
+    describe "with :eval" do
+      it "should return a eval scheme" do
+        Daijobu::Scheme.get(:eval).should be_an_instance_of(Daijobu::Scheme::Eval)
+      end
+    end
+    
+    describe "with anything else" do
+      it "should raise an error" do
+        lambda { Daijobu::Scheme.get(:xml) }.should raise_error(Daijobu::UnknownScheme)
+      end
+    end
+    
+  end
+  
+end

data/spec/daijobu/schemes/eval_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Scheme::Eval do
+  
+  before do
+    @scheme = Daijobu::Scheme::Eval.new
+  end
+  
+  describe "#parse" do
+    before do
+      @stringy = '{ "thing" => 10 }'
+    end
+    
+    it "should parse the given string using Kernel::eval" do
+      @scheme.expects(:eval).with(@stringy)
+      @scheme.parse(@stringy)
+    end
+    
+    describe "when the input string is nil" do
+      it "should return nil" do
+        @scheme.parse(nil).should be_nil
+      end
+    end
+  end
+  
+  describe "#unparse" do
+    before do
+      @hashy = { "thing" => 10 }
+    end
+    
+    it "should inspect the given object" do
+      @hashy.expects(:inspect)
+      @scheme.unparse(@hashy)
+    end    
+  end
+  
+end

data/spec/daijobu/schemes/json_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Scheme::JSON do
+  
+  before do
+    @scheme = Daijobu::Scheme::JSON.new
+  end
+  
+  describe "#parse" do
+    before do
+      @stringy = '{ "thing" : 10 }'
+    end
+    
+    it "should parse the given string with the JSON module" do
+      ::JSON.expects(:parse).with(@stringy)
+      @scheme.parse(@stringy)
+    end
+    
+    describe "when the input string is nil" do
+      it "should return nil" do
+        @scheme.parse(nil).should be_nil
+      end
+    end
+  end
+  
+  describe "#unparse" do
+    before do
+      @hashy = { "thing" => 10 }
+    end
+    
+    it "should unparse the given object with the JSON module" do
+      ::JSON.expects(:unparse).with(@hashy)
+      @scheme.unparse(@hashy)
+    end    
+  end
+  
+end

data/spec/daijobu/schemes/marshal_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Scheme::Marshal do
+  
+  before do
+    @scheme = Daijobu::Scheme::Marshal.new
+  end
+  
+  describe "#parse" do
+    before do
+      @stringy = "\004\b{\006\"\nthingi\017"
+    end
+    
+    it "should parse the given string with the Marshal module" do
+      ::Marshal.expects(:load).with(@stringy)
+      @scheme.parse(@stringy)
+    end
+    
+    describe "when the input string is nil" do
+      it "should return nil" do
+        @scheme.parse(nil).should be_nil
+      end
+    end
+  end
+  
+  describe "#unparse" do
+    before do
+      @hashy = { "thing" => 10 }
+    end
+    
+    it "should unparse the given object with the JSON module" do
+      ::Marshal.expects(:dump).with(@hashy)
+      @scheme.unparse(@hashy)
+    end    
+  end
+
+end

data/spec/daijobu/schemes/yaml_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Daijobu::Scheme::YAML do
+
+  before do
+    @scheme = Daijobu::Scheme::YAML.new
+  end
+  
+  describe "#parse" do
+    before do
+      @stringy = '{ "thing" : 10 }'
+    end
+    
+    it "should parse the given string with the YAML module" do
+      ::YAML.expects(:load).with(@stringy)
+      @scheme.parse(@stringy)
+    end
+    
+    describe "when the input string is nil" do
+      it "should return nil" do
+        @scheme.parse(nil).should be_nil
+      end
+    end
+  end
+  
+  describe "#unparse" do
+    before do
+      @hashy = { "thing" => 10 }
+    end
+    
+    it "should unparse the given object with the JSON module" do
+      ::YAML.expects(:dump).with(@hashy)
+      @scheme.unparse(@hashy)
+    end    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'spec'
+require 'mocha'
+require 'rufus/tokyo'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'daijobu'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: sander6-daijobu
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sander Hartlage
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-14 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sander@outside.in
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/daijobu.rb
+- lib/daijobu/adapter.rb
+- lib/daijobu/client.rb
+- lib/daijobu/errors.rb
+- lib/daijobu/scheme.rb
+- lib/daijobu/scheme_set.rb
+has_rdoc: false
+homepage: http://github.com/sander6/daijobu
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: A helper for de/serialization of objects into and out of Tokyo Cabinets
+test_files: 
+- spec/daijobu/adapter_spec.rb
+- spec/daijobu/adapters/mem_cache_spec.rb
+- spec/daijobu/adapters/tokyo_cabinet_spec.rb
+- spec/daijobu/adapters/tokyo_tyrant_spec.rb
+- spec/daijobu/client_spec.rb
+- spec/daijobu/errors_spec.rb
+- spec/daijobu/scheme_set_spec.rb
+- spec/daijobu/scheme_spec.rb
+- spec/daijobu/schemes/eval_spec.rb
+- spec/daijobu/schemes/json_spec.rb
+- spec/daijobu/schemes/marshal_spec.rb
+- spec/daijobu/schemes/yaml_spec.rb
+- spec/spec_helper.rb