sander6-daijobu 0.2.1 → 0.3.0

data/README.rdoc

@@ -13,33 +13,61 @@ Make a new, inappropriately-named Daijobu::Client object and give it your store
 
 You can now use the regular hash getter and setter methods ([] and []=) without worrying about serialization.
 
-The supported schemes are :marshal (using Marshal), :json (using JSON from the json gem), :yaml (using YAML), :eval (using Kernel::eval), and :raw (using nothing).
+The out-of-the-box schemes are :marshal (using Marshal), :json (using JSON from the json gem), :yaml (using YAML), :eval (using Kernel::eval), and :raw (using nothing).
+
+You can specify your own schemes by making new Daijobu::Parser objects. Just instantiate a new Parser and tell it how you want to parse and unparse.
+
+    parser = Daijobu::Parser.new({
+      :parse    => Proc.new { |str| str.deserialize },
+      :unparse  => Proc.new { |obj| obj.serialize }
+    })
+
+If you don't like passing procs as keyword arguments, you can give a block and define the #parse and #unparse methods yourself.
+
+    parser = Daijobu::Parser.new do
+      def parse(str)
+        str.deserialize_using_some_fancy_method
+      end
+      def unparse(obj)
+        obj.serialize_using_some_fancy_method
+      end
+    end
+
+Alternately, you can make a new Parser with a delegate object, and specify which methods of the delegate should be used for parsing and unparsing. For example, the :marshal parser is this:
+
+    parser = Daijobu::Parser(Marshal, :parse => :load, :unparse => :dump)
+
+Then just pass this parser object as your scheme.
+
+    daijobu = Daijobu::Client.new(rufus, :schemes => parser)
 
 Because some schemes are very strict, and sometimes what gets dumped can't be parsed back (for example, unparsing an integer using JSON), you can specify a set of schemes. If one doesn't work, it'll try the next in the list until it succeeds in parsing.
 
     Daijobu::Client.new(rufus, :schemes => [:json, :yaml, :eval])
 
-Daijobu doesn't do any real format-checking; if, say, Marshal.load throws an error, for whatever reason, it'll just rescue and move on to the next scheme. The success of this gem all hinges on the fact that the supported serialization formats don't have much to do with one another (except for JSON and YAML, of course), and you shouldn't ever end up parsing Ruby code as JSON accidentally, or at least not in unintended ways.
+Daijobu doesn't do any real format-checking; if, say, Marshal.load throws an error, for whatever reason, it'll just rescue and move on to the next scheme. Therefore, if you define your own parser and want to use fallbacks, the #parse and #unparse methods should raise some kind of error (besides a Daijobu::Error) if they fail.
 
 You can set different read and write schemes, too. This would be useful, say, if you wanted to change the serialization format.
 
     Daijobu::Client.new(rufus, :read => :json, :write => :raw)
 
-One last cool thing that I threw in just because: the key names in a key-value store are often namespaced. You can call these namespaces as methods on a Client object to automatically prepend that namespace to any keys asked for.
+One last cool thing that I threw in just because: the key names in a key-value store are often namespaced, so you can call these namespaces as methods on a Client object to automatically prepend that namespace to any keys asked for.
 
-    daijobu = Daijobu::Client.new(rufus, :read => :json, :write => :raw)
     daijobu.namespace['123'] # => looks for 'namespace:123'
     daijobu.name.space['123'] # => looks for 'name:space:123'
 
-You can set the separator (defaults to ':' because that's what I was using) on the Daijobu::NamespaceProxy class.
+You can set the separator (defaults to ':' because that's what I was using) on the Daijobu::Client class.
 
-    Daijobu::NamespaceProxy.default_separator = '/'
-    daijobu.name.space['123'] # => looks for 'name/space/123'
+    Daijobu::Client.default_separator = '/'
+    daijobu.name.space['123'] # => 'name/space/123'
 
-And a last bit of syntatical sugar: you can leave off the brackets when asking for namespaced keys.
+Or you can set it per-invocation:
 
-    daijobu.namespace '123' # => looks for 'namespace:123'
-    daijobu.name.space '123' # => looks for 'name:space:123'
+    daijobu.name('/').space(':')['123'] # => 'name/space:123'
+    
+If this is the case, it'll keep using the last separator mentioned for subsequent namespacing.
+
+    daijobu.some('/').long(':').name.space['123'] # => 'some/long:name:space:123'
 
 === "Anything else I should know?"
 
@@ -53,8 +81,6 @@ I plan to eventually switch out my home-rolled adapters for a more complete and
 
 Until then, I'm thinking of putting in support for user-defined adapters as a stopgap, basically any object that responds to #get(key) and #set(key, value).
 
-Less of a priority is support for user-defined serialization schemes that respond to #parse(string) and #unparse(object).
-
 I also plan to take a look at ActiveRecord::Base#serialize to see if I can do something with that, because reading and writing YAML is like dying every day.
 
 === "What's with the name?"

data/lib/daijobu.rb

@@ -1,14 +1,8 @@
 $:.unshift(File.dirname(__FILE__))
 require 'daijobu/errors'
 require 'daijobu/client'
-require 'daijobu/namespace_proxy'
+require 'daijobu/parser'
 require 'daijobu/scheme_set'
-require 'daijobu/scheme'
-require 'daijobu/schemes/eval'
-require 'daijobu/schemes/json'
-require 'daijobu/schemes/marshal'
-require 'daijobu/schemes/raw'
-require 'daijobu/schemes/yaml'
 require 'daijobu/adapter'
 require 'daijobu/adapters/mem_cache'
 require 'daijobu/adapters/tokyo_cabinet'

data/lib/daijobu/client.rb

@@ -3,6 +3,18 @@ module Daijobu
   # The unfortunately-named Daijobu::Client is the serialization wrapper for key-value stores.
   class Client
 
+    @@default_separator = ':'
+    
+    # Getter for the default separator. Default is ':'
+    def self.default_separator
+      @@default_separator
+    end
+    
+    # Setter for the default separator. I use ':', but a lot of people like '/'.
+    def self.default_separator=(separator)
+      @@default_separator = separator
+    end
+
     # Client.new takes a key-value store as its first argument, and then a hash of serialization schemes.
     #
     # Options:
@@ -13,6 +25,8 @@ module Daijobu
       @adapter        = Daijobu::Adapter.get(casket)
       @read_schemes   = Daijobu::SchemeSet.new(options[:schemes] || options[:read])
       @write_schemes  = Daijobu::SchemeSet.new(options[:schemes] || options[:write])
+      @namespace      = nil
+      @separator      = nil
     end
 
     # Getter for keys. The actual getting method is handled by the specific Adapter object.
@@ -26,20 +40,26 @@ module Daijobu
       @adapter.set(key.to_s, __unparse__(value))
     end
 
-    # Any missing method is assumed to be a namespace for keys to get. The NamespaceProxy object
-    # returned also implements the same kind of method_missing, so namespaces can be chained together.
+    # Any missing method is assumed to be a namespace for keys to get. Returns self, so
+    # namespaces can be chained together.
+    #
+    #     client.namespace['key']             # => gets key 'namespace:key'
+    #     client.name.space['key']            # => gets key 'name:space:key'
+    #     client.namespace['key'] = 'value'   # => sets key 'namespace:key'
     #
-    #     client.namespace['key']           # => gets key 'namespace:key'
-    #     client.name.space['key']          # => gets key 'name:space:key'
-    #     client.namespace['key'] = 'value' # => sets key 'namespace:key'
+    # If you have mixed separators in your keys, or don't want to fiddle around with the
+    # class-level default_separator, you can pass the separator to use as an argument to
+    # any missing method.
     #
-    # As an added bit of syntactic sugar, you can leave the brackets off when getting keys this way.
+    #     client.name('/').space('-')['key']  # => gets key 'name/space-key'
     #
-    #     client.namespace 'key' # => same as client.namespace['key']
+    # The last separator mentioned will be use for subsequent separating.
     #
-    # See NamespaceProxy for more details about setting the separator.
-    def method_missing(name, *args)
-      args.empty? ? Daijobu::NamespaceProxy.new(self, name) : Daijobu::NamespaceProxy.new(self, name)[*args]
+    #     client.some('/').really(':').long.name('-').space['key'] # => gets key 'some/really:long:name-space-key'
+    def method_missing(namespace, separator = nil, *args, &block)
+      @namespace = "#{@namespace}#{@separator}#{namespace}"
+      @separator = separator || @separator || @@default_separator
+      self
     end
 
     private

data/lib/daijobu/errors.rb

@@ -14,4 +14,8 @@ module Daijobu
   # Raised when all of the (un)parsing schemes fail.
   class NoFallbackScheme < Daijobu::Error; end
   
+  class MissingDelegate < Daijobu::Error; end
+  
+  class InvalidStrategy < Daijobu::Error; end
+  
 end

data/lib/daijobu/parser.rb

@@ -0,0 +1,126 @@
+module Daijobu
+  
+  # A Daijobu::Parser handles serialization and deserialization of strings and objects.
+  # It can either send methods to a delegate object that serializes (for example, the
+  # Marshal modules), or define its own schemes.
+  class Parser
+
+    # Returns a new Parser from a fixed default set designed to handle the most common
+    # serialization schemes. Pass the name of the Parser you want as a symbol.
+    #
+    #     :marshal  => a parser for Ruby binary format, using the Marshal module
+    #     :json     => a parser for JSON, using the JSON module (requires the json gem)
+    #     :yaml     => a parser for YAML, using the YAML module
+    #     :eval     => a parser for Ruby code, using #eval and #inspect
+    #     :raw      => a parser for raw strings that doesn't actually do anything
+    def self.get(name)
+      respond_to?(name) ? __send__(name) : raise(UnknownScheme)
+    end
+    
+    # Returns a new Parser for serializing Ruby binary.
+    #
+    #     :parse    => Marshal.load(string)
+    #     :unparse  => Marshal.dump(object)
+    def self.marshal
+      new(Marshal, :parse => :load, :unparse => :dump)
+    end
+    
+    # Returns a new Parser for serializing JSON.
+    #
+    #     :parse    => JSON.parse(string)
+    #     :unparse  => JSON.unparse(object)    
+    def self.json
+      require 'json'
+      new(JSON, :parse => :parse, :unparse => :unparse)
+    end
+    
+    # Returns a new Parser for serializing YAML.
+    #
+    #     :parse    => YAML.load(string)
+    #     :unparse  => YAML.dump(object)
+    def self.yaml
+      require 'yaml'
+      new(YAML, :parse => :load, :unparse => :dump)
+    end
+    
+    # Returns a new Parser for serializing Ruby code.
+    #
+    #     :parse    => Kernel.eval(string)
+    #     :unparse  => object.inspect
+    def self.eval
+      new(:parse => Proc.new { |str| Kernel::eval(str) }, :unparse => Proc.new { |obj| obj.inspect })
+    end
+    
+    # Returns a new Parser that does nothing.
+    #
+    #     :parse    => string
+    #     :unparse  => object
+    def self.raw
+      new(:parse => Proc.new { |str| str }, :unparse => Proc.new { |obj| obj })
+    end
+    
+    # Takes a delegate object an a hash specifying which methods of the delegate should be used for
+    # parsing and unparsing. For example, say there was some module called Parsley that had methods
+    # #load and #dump for deserialization and serialization, respectively. To make a new parser
+    # using Parsley, you would say
+    #
+    #     parser = Daijobu::Parser.new(Parsely, :parse => :load, :unparse => :dump)
+    #
+    # Alternately, you can pass procs as the parse and unparse keys. The parse proc should accept a
+    # String, and the unparse proc should accept any Object. For fallback schemes to work, these procs
+    # should raise any error (except a Daijobu::Error) if they fail in any way. This isn't strictly
+    # necessary if you're only using one serialization scheme.
+    #
+    #     parser = Daijobu::Parser.new({
+    #       :parse    => Proc.new { |string| string.do_something_fancy },
+    #       :unparse  => Proc.new { |object| object.undo_something_fancy }
+    #     })
+    # 
+    # Or, if you don't like passing procs as keyword arguments (I sure don't), you can give a block
+    # and define the parse and unparse methods (and technically anything else you want) on the
+    # parser object directly.
+    #
+    #     parser = Daijobu::Parser.new do
+    #       def parse(string)
+    #         raise SomeKindOfError unless string.passes_some_conditions?
+    #         string.turn_into_an_object_somehow
+    #       end
+    #       def uparse(object)
+    #         raise ADifferentKindOfError unless object.can_be_dumped?
+    #         object.dump_to_string_using_some_clever_method
+    #       end
+    #     end
+    def initialize(*args, &block)
+      strategies        = args.last.is_a?(Hash) ? args.pop : {}
+      @delegate         = args.shift
+      @parse_strategy   = strategies[:parse]
+      @unparse_strategy = strategies[:unparse]
+      (class << self; self; end).class_eval(&block) if block_given?
+    end
+
+    # Parses the string. Parsing nil always returns nil.
+    def parse(str)
+      str.nil? ? nil : strategize(@parse_strategy, str)
+    end
+    
+    # Unparses the object.
+    def unparse(obj)
+      strategize(@unparse_strategy, obj)
+    end
+    
+    private
+    
+    # Either sends the symbol to the delegate, or calls the proc for the given strategy.
+    def strategize(strategy, arg)
+      case strategy
+      when Symbol
+        raise MissingDelegate unless @delegate
+        @delegate.__send__(strategy, arg)
+      when Proc
+        strategy.call(arg)
+      else
+        raise InvalidStrategy
+      end
+    end
+  end
+end

data/lib/daijobu/scheme_set.rb

@@ -7,12 +7,15 @@ module Daijobu
     
     attr_reader :current
 
-    # SchemeSet.new takes a single symbol or array of symbols and initializes a new Scheme
+    # SchemeSet.new takes a single symbol or array of symbols and initializes a new Parser
     # object of the appropriate type for each one.
     def initialize(schemes = nil)
+      @schemes = []
       schemes = Array(schemes)
       schemes = DEFAULT if schemes.empty?
-      @schemes = schemes.collect { |scheme| Daijobu::Scheme.get(scheme) }
+      schemes.each do |scheme|
+        @schemes << (scheme.is_a?(Daijobu::Parser) ? scheme : Daijobu::Parser.get(scheme))
+      end
       @current = 0
     end
   
@@ -34,7 +37,7 @@ module Daijobu
       @current = 0
     end
 
-    # Tries the parse (load) the string with each scheme in turn.
+    # Tries to parse (load) the string with each scheme in turn.
     # Assumes (defensibly) that parsing failed if any non Daijobu::Error exceptions are raised
     # and moves on to the next scheme.
     def parse(str)
@@ -51,7 +54,7 @@ module Daijobu
       obj
     end
     
-    # Tries the unparse (dump) the string with each scheme in turn.
+    # Tries to unparse (dump) the object with each scheme in turn.
     # Assumes (defensibly) that unparsing failed if any non Daijobu::Error exceptions are raised
     # and moves on to the next scheme.    
     def unparse(obj)

data/spec/daijobu/client_spec.rb

@@ -105,22 +105,29 @@ describe Daijobu::Client do
       end
     end
     
-    describe "method_missing" do
+    describe "namespacing via missing methods" do
       
-      describe "with no arguments" do
-        it "should return a namespace proxy with namespace as the missing method" do
-          proxy = @daijobu.prefix
-          proxy.should be_an_instance_of(Daijobu::NamespaceProxy)
-          proxy.instance_variable_get(:@namespace).should == 'prefix'
-        end
+      it "should return self" do
+        @daijobu.namespace.should == @daijobu
+      end
+      
+      it "should append the method name as a key namespace" do
+        @daijobu.namespace.instance_variable_get(:@namespace).should == 'namespace'
+      end
+      
+      it "should chain namespaces together for multiple invocations" do
+        @daijobu.name.space.instance_variable_get(:@namespace).should == 'name:space'
       end
       
       describe "with arguments" do
-        it "should call #[] on the proxy with the arguments" do
-          proxy = stub('fake-daijobu-proxy!')
-          Daijobu::NamespaceProxy.expects(:new).with(@daijobu, :prefix).returns(proxy)
-          proxy.expects(:[]).with('key')
-          @daijobu.prefix('key')
+        it "should set the separator to the given argument" do
+          @daijobu.namespace('/').instance_variable_get(:@separator).should == '/'
+        end
+        
+        it "should use the last mentioned separator for subsequent namespacing" do
+          namespacey = @daijobu.some('/').long.name('-').space
+          namespacey.instance_variable_get(:@namespace).should == 'some/long/name-space'
+          namespacey.instance_variable_get(:@separator).should == '-'
         end
       end
     end

data/spec/daijobu/parser_spec.rb

@@ -0,0 +1,211 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Daijobu::Parser do
+  
+  before do
+    @string = '{ "serialized" : "structure" }'
+    @object = Object.new
+  end
+  
+  describe ".get" do
+    it "should return a Daijobu::Parser object" do
+      Daijobu::Parser.get(:marshal).should be_an_instance_of(Daijobu::Parser)
+    end
+    
+    it "should raise an error when passed a name it doesn't know about" do
+      lambda { Daijobu::Parser.get(:buckwild) }.should raise_error(Daijobu::UnknownScheme)
+    end
+    
+    it "should send the given name as a method to itself" do
+      Daijobu::Parser.stubs(:respond_to?).returns(true)
+      Daijobu::Parser.expects(:buckwild)
+      Daijobu::Parser.get(:buckwild)
+    end
+    
+    describe ".marshal" do
+      it "should return a new parser that delegates parsing as :load and unparsing as :dump to Marshal" do
+        Daijobu::Parser.expects(:new).with(Marshal, { :parse => :load, :unparse => :dump })
+        Daijobu::Parser.marshal
+      end
+    end
+    
+    describe ".json" do
+      it "should return a new parser that delegates parsing as :parse and unparsing as :unparse to JSON" do
+        Daijobu::Parser.expects(:new).with(JSON, { :parse => :parse, :unparse => :unparse })
+        Daijobu::Parser.json
+      end
+    end
+    
+    describe ".yaml" do
+      it "should return a new parser that delegates parsing as :load and unparsing as :dump to YAML" do
+        Daijobu::Parser.expects(:new).with(YAML, { :parse => :load, :unparse => :dump })
+        Daijobu::Parser.yaml
+      end
+    end
+    
+    describe ".eval" do
+      it "should return a new parser that delegates parsing and unparsing as some procs" do
+        Daijobu::Parser.expects(:new).with(instance_of(Hash))
+        Daijobu::Parser.eval
+      end
+      
+      describe "should return a parser that" do
+        before do
+          @parser = Daijobu::Parser.eval
+        end
+
+        it "should eval the string given to parse" do
+          Kernel.expects(:eval).with(@string)
+          @parser.parse(@string)
+        end
+        
+        it "should inspect the object to unparse" do
+          @object.expects(:inspect)
+          @parser.unparse(@object)
+        end
+      end
+    end
+    
+    describe ".raw" do
+      it "should return a new parser that delegates parsing and unparsing as some procs" do
+        Daijobu::Parser.expects(:new).with(instance_of(Hash))
+        Daijobu::Parser.raw
+      end
+      
+      describe "should return a parser that" do
+        before do
+          @parser = Daijobu::Parser.raw
+        end
+        
+        it "should return the string given to parse" do
+          @parser.parse(@string).should == @string
+        end
+        
+        it "should return the object given to unparse" do
+          @parser.unparse(@object).should == @object
+        end
+      end
+    end
+  end
+  
+  describe "parsing" do
+    it "should return nil when trying to parse nil" do
+      @parser = Daijobu::Parser.new
+      @parser.parse(nil).should be_nil
+    end
+    
+    describe "with a symbol strategy" do
+      before do
+        @symbol = :load
+      end
+      
+      describe "without a delegate" do
+        before do
+          @parser = Daijobu::Parser.new(:parse => @symbol)
+          @parser.instance_variable_get(:@parse_strategy).should == @symbol
+        end
+        
+        it "should raise an error" do
+          lambda { @parser.parse(@string) }.should raise_error(Daijobu::MissingDelegate)
+        end
+      end
+      
+      describe "with a delegate" do
+        before do
+          @delegate = Object.new
+          @parser   = Daijobu::Parser.new(@delegate, :parse => @symbol)
+        end
+        
+        it "should send the symbol and the argument to the delegate" do
+          @delegate.expects(@symbol).with(@string)
+          @parser.parse(@string)
+        end
+      end
+    end
+    
+    describe "with a proc strategy" do
+      before do
+        @proc   = Proc.new { |string| string.downcase }
+        @parser = Daijobu::Parser.new(:parse => @proc)
+      end
+      
+      it "should call the proc with the argument" do
+        @proc.expects(:call).with(@string)
+        @parser.parse(@string)
+      end
+    end
+  end
+  
+  describe "unparsing" do
+    describe "with a symbol strategy" do
+      before do
+        @symbol = :dump
+      end
+      
+      describe "without a delegate" do
+        before do
+          @parser = Daijobu::Parser.new(:unparse => @symbol)
+        end
+        
+        it "should raise an error" do
+          lambda { @parser.unparse(@object) }.should raise_error(Daijobu::MissingDelegate)
+        end
+      end
+      
+      describe "with a delegate" do
+        before do
+          @delegate = Object.new
+          @parser   = Daijobu::Parser.new(@delegate, :unparse => @symbol)
+        end
+        
+        it "should send the symbol and the argument to the delegate" do
+          @delegate.expects(@symbol).with(@object)
+          @parser.unparse(@object)
+        end
+      end
+    end
+    
+    describe "with a proc strategy" do
+      before do
+        @proc   = Proc.new { |object| object.inspect }
+        @parser = Daijobu::Parser.new(:unparse => @proc)
+      end
+      
+      it "should call the proc with the argument" do
+        @proc.expects(:call).with(@string)
+        @parser.unparse(@string)
+      end
+    end
+  end
+  
+  describe "when given a block" do
+    before do
+      @parser = Daijobu::Parser.new do
+        def parse(str)
+          eval(str)
+        end
+        
+        def unparse(obj)
+          obj.inspect
+        end
+
+        def test
+          "Make sure this shows up."
+        end
+      end      
+    end
+    
+    it "should add the defined methods to the parser instance" do
+      @parser.should respond_to(:parse)
+      @parser.should respond_to(:unparse)
+      @parser.should respond_to(:test)
+    end
+    
+    it "should redefine the parse or unparse methods as defined" do
+      @parser.expects(:eval).with(@string)
+      @parser.parse(@string)
+      @object.expects(:inspect)
+      @parser.unparse(@object)
+    end
+  end
+end

data/spec/daijobu/scheme_set_spec.rb

@@ -2,7 +2,17 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Daijobu::SchemeSet do
   
-  describe "initialization" do
+  describe "on initialization" do
+    it "should have the default set of schemes" do      
+      Daijobu::Parser.expects(:get).with(:marshal)
+      Daijobu::Parser.expects(:get).with(:json)
+      Daijobu::Parser.expects(:get).with(:yaml)
+      Daijobu::Parser.expects(:get).with(:eval)
+      Daijobu::SchemeSet.new
+    end  
+  end
+
+  describe "initialization" do    
     before do
       @scheme_set = Daijobu::SchemeSet.new
     end
@@ -10,15 +20,7 @@ describe Daijobu::SchemeSet do
     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
-    
+        
     it "should accept an array of schemes" do
       lambda { Daijobu::SchemeSet.new([:json, :yaml]) }.should_not raise_error
     end
@@ -35,8 +37,6 @@ describe Daijobu::SchemeSet do
     
     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
   
@@ -96,7 +96,7 @@ describe Daijobu::SchemeSet do
 
     describe "assuming that the string can be parsed" do
       before do
-        Daijobu::Scheme::JSON.any_instance.stubs(:parse).returns(@hashy)
+        Daijobu::Parser.any_instance.stubs(:parse).returns(@hashy)
       end
       
       it "should reset" do
@@ -111,7 +111,7 @@ describe Daijobu::SchemeSet do
     
     describe "assuming that the string can't be parsed" do
       before do
-        Daijobu::Scheme::JSON.any_instance.stubs(:parse).raises(Daijobu::Error)
+        Daijobu::Parser.any_instance.stubs(:parse).raises(Daijobu::Error)
       end
       
       it "should raise the given error" do
@@ -150,7 +150,7 @@ describe Daijobu::SchemeSet do
 
     describe "assuming that the object can be unparsed" do
       before do
-        Daijobu::Scheme::JSON.any_instance.stubs(:unparse).returns(@stringy)
+        Daijobu::Parser.any_instance.stubs(:unparse).returns(@stringy)
       end
       
       it "should return the unparsed entity" do
@@ -165,7 +165,7 @@ describe Daijobu::SchemeSet do
     
     describe "assuming that the object can't be unparsed" do
       before do
-        Daijobu::Scheme::JSON.any_instance.stubs(:unparse).raises(Daijobu::Error)
+        Daijobu::Parser.any_instance.stubs(:unparse).raises(Daijobu::Error)
       end
       
       it "should raise the given error" do

data/spec/spec_helper.rb

@@ -7,6 +7,8 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'daijobu'
 
 # Some fake contants for the classes and stuff referred to.
+YAML                  = Module.new unless defined?(YAML)
+JSON                  = Module.new unless defined?(JSON)
 MemCache              = Class.new unless defined?(MemCache)
 Rufus                 = Module.new unless defined?(Rufus)
 Rufus::Tokyo          = Module.new unless defined?(Rufus::Tokyo)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sander6-daijobu
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Sander Hartlage
@@ -30,17 +30,11 @@ files:
 - lib/daijobu/adapter.rb
 - lib/daijobu/client.rb
 - lib/daijobu/errors.rb
-- lib/daijobu/namespace_proxy.rb
-- lib/daijobu/scheme.rb
+- lib/daijobu/parser.rb
 - lib/daijobu/scheme_set.rb
 - lib/daijobu/adapters/mem_cache.rb
 - lib/daijobu/adapters/tokyo_cabinet.rb
 - lib/daijobu/adapters/tokyo_tyrant.rb
-- lib/daijobu/schemes/eval.rb
-- lib/daijobu/schemes/json.rb
-- lib/daijobu/schemes/marshal.rb
-- lib/daijobu/schemes/raw.rb
-- lib/daijobu/schemes/yaml.rb
 has_rdoc: false
 homepage: http://github.com/sander6/daijobu
 post_install_message: 
@@ -74,12 +68,6 @@ test_files:
 - spec/daijobu/adapters/tokyo_tyrant_spec.rb
 - spec/daijobu/client_spec.rb
 - spec/daijobu/errors_spec.rb
-- spec/daijobu/namespace_proxy_spec.rb
+- spec/daijobu/parser_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/raw_spec.rb
-- spec/daijobu/schemes/yaml_spec.rb
 - spec/spec_helper.rb

data/lib/daijobu/namespace_proxy.rb

@@ -1,44 +0,0 @@
-module Daijobu
-  class NamespaceProxy
-    
-    @@default_separator = ':'
-    
-    # Getter for the default separator. Default is ':'
-    def self.default_separator
-      @@default_separator
-    end
-    
-    # Setter for the default separator. I use ':', but a lot of people like '/'.
-    def self.default_separator=(separator)
-      @@default_separator = separator
-    end
-
-    # NamespaceProxy.new takes an owner (a Daijobu::Client), a namespace, and a separator (defaults 
-    # to @@default_separator).
-    # NamespaceProxy objects are typically created using Daijobu::Client#method_missing, so you're
-    # rarely going to instantiate one of these on your own.
-    def initialize(owner, namespace, separator = @@default_separator)
-      @owner = owner
-      @namespace = namespace.to_s
-      @separator = separator
-    end
-
-    # Sends #[] back to the owner, prepending the key given with the namespace and separator.
-    def [](key)
-      @owner["#{@namespace}#{@separator}#{key}"]
-    end
-
-    # Sends #[]= back to the owner, prepending the key given with the namespace and separator.    
-    def []=(key, value)
-      @owner["#{@namespace}#{@separator}#{key}"] = value
-    end
-
-    # Any missing method is assumed to be yet another namespace.
-    def method_missing(namespace, *args)
-      separator = args.shift || @@default_separator
-      @namespace = "#{@namespace}#{@separator}#{namespace}"
-      @separator = separator
-      self
-    end
-  end
-end

data/lib/daijobu/scheme.rb

@@ -1,33 +0,0 @@
-module Daijobu
-
-  # The Scheme module is the parent of the various serialization schemes.
-  module Scheme
-    
-    # Given a name, returns a new instance of the corresponding scheme.
-    #
-    #   :marshal  => Daijobu::Scheme::Marshal
-    #   :json     => Daijobu::Scheme::JSON
-    #   :yaml     => Daijobu::Scheme::YAML
-    #   :eval     => Daijobu::Scheme::Eval
-    #   :raw      => Daijobu::Scheme::Raw
-    #
-    # Raises Daijobu::UnknownScheme if given a name it can't handle. 
-    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
-      when :raw
-        Daijobu::Scheme::Raw.new
-      else
-        raise Daijobu::UnknownScheme
-      end
-    end
-    
-  end
-end

data/lib/daijobu/schemes/eval.rb

@@ -1,21 +0,0 @@
-module Daijobu
-  module Scheme
-    
-    # Daijobu::Scheme::Eval is the serialization for pure Ruby code.
-    # Theoretically, then, anything could be put into and taken out of a key-value-store,
-    # provided that they're always rehydrated into an appropriate binding.
-    class Eval
-      
-      # Parses by #eval'ing the string.
-      def parse(str)
-        str.nil? ? nil : eval(str)
-      end
-      
-      # Unparses by #inspect'ing the object. 
-      def unparse(obj)
-        obj.inspect
-      end
-      
-    end
-  end
-end

data/lib/daijobu/schemes/json.rb

@@ -1,26 +0,0 @@
-require 'json'
-
-module Daijobu
-  module Scheme
-    
-    # Daijobu::Scheme::JSON is the serialization for JSON.
-    # Uses the native (C) json gem, which is respectably fast.
-    class JSON
-      
-      # Parses the string using JSON.parse.
-      # JSON is pretty strict, and it dies whenever the object doesn't have an enclosing
-      # structure (i.e. an array or tuple). You might have problems parsing bare strings,
-      # integers, booleans, and nulls. It's weird, though, because JSON doesn't seem to have
-      # a problem unparsing these things. Just a heads-up.
-      def parse(str)
-        str.nil? ? nil : ::JSON.parse(str)
-      end
-      
-      # Unparses the object using JSON.unparse.
-      def unparse(obj)
-        ::JSON.unparse(obj)
-      end
-      
-    end
-  end
-end

data/lib/daijobu/schemes/marshal.rb

@@ -1,19 +0,0 @@
-module Daijobu
-  module Scheme
-    
-    # Daijobu::Scheme::Marshal is the serialization for Ruby binary code.
-    class Marshal
-      
-      # Parses the string using Marshal.load.
-      def parse(str)
-        str.nil? ? nil : ::Marshal.load(str)
-      end
-      
-      # Unparses the object using Marshal.dump.
-      def unparse(obj)
-        ::Marshal.dump(obj)
-      end
-      
-    end
-  end
-end

data/lib/daijobu/schemes/raw.rb

@@ -1,21 +0,0 @@
-module Daijobu
-  module Scheme
-    
-    # Daijobu::Scheme::Raw is the serialization for nothing. Seriously, it doesn't do anything.
-    # It's rather dubious why you'd use this scheme for reading (if you're just going to be reading
-    # as raw, why use this gem at all?), but writing raw is useful sometimes.
-    class Raw
-
-      # Doesn't parse anything. Just returns the string.
-      def parse(str)
-        str
-      end
-      
-      # Doesn't unparse anything. Just returns the object.
-      def unparse(obj)
-        obj
-      end
-      
-    end
-  end
-end

data/lib/daijobu/schemes/yaml.rb

@@ -1,25 +0,0 @@
-require 'yaml'
-
-module Daijobu
-  module Scheme
-    
-    # Daijobu::Scheme::YAML is the serialization for YAML.
-    # Due to the strictness of the JSON module, you'll often have more luck parsing JSON containing 
-    # bare objects (strings, integers, booleans, etc. without an enclosing structure) using YAML
-    # than with JSON, but YAML's a lot slower. That being said, it makes a good fallback scheme to use
-    # when JSON starts dying.
-    class YAML
-      
-      # Parses the string using YAML.load.
-      def parse(str)
-        str.nil? ? nil : ::YAML.load(str)
-      end
-      
-      # Unparses the object using YAML.dump.
-      def unparse(obj)
-        ::YAML.dump(obj)
-      end
-      
-    end
-  end
-end

data/spec/daijobu/namespace_proxy_spec.rb

@@ -1,60 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Daijobu::NamespaceProxy do
-  
-  before do
-    @daijobu = stub('fake-daijobu-client!')
-  end
-  
-  describe "initialization" do
-
-    it "should set the owner as the given owner" do
-      Daijobu::NamespaceProxy.new(@daijobu, 'prefix').instance_variable_get(:@owner).should == @daijobu
-    end
-    
-    it "should set the namespace as the given namespace" do
-      Daijobu::NamespaceProxy.new(@daijobu, 'prefix').instance_variable_get(:@namespace).should == 'prefix'
-    end
-    
-    it "should be indifferent to strings or symbols as the namespace" do
-      Daijobu::NamespaceProxy.new(@daijobu, :prefix).instance_variable_get(:@namespace).should == 'prefix'
-    end
-    
-    it "should initialize with the class-level default separator" do
-      Daijobu::NamespaceProxy.new(@daijobu, 'prefix').instance_variable_get(:@separator).should == Daijobu::NamespaceProxy.default_separator
-    end
-    
-    it "should set the separator as the given separator" do
-      Daijobu::NamespaceProxy.new(@daijobu, 'prefix', '/').instance_variable_get(:@separator).should == '/'
-    end
-    
-  end
-
-  describe "methods" do
-    before do
-      @proxy = Daijobu::NamespaceProxy.new(@daijobu, 'prefix')
-    end
-    
-    describe "#[]" do
-      it "should send #[] with the namespaced key to the owner" do
-        @daijobu.expects(:[]).with('prefix:key')
-        @proxy['key']
-      end
-    end
-    
-    describe "#[]=" do
-      it "should send #[]= with the namespaced key to the owner" do
-        @daijobu.expects(:[]=).with('prefix:key', 'value')
-        @proxy['key'] = 'value'
-      end
-    end
-    
-    describe "method_missing" do
-      it "should return a new proxy with compounded namespace" do
-        new_proxy = @proxy.another_prefix
-        new_proxy.should be_an_instance_of(Daijobu::NamespaceProxy)
-        new_proxy.instance_variable_get(:@namespace).should == 'prefix:another_prefix'
-      end
-    end
-  end
-end

data/spec/daijobu/scheme_spec.rb

@@ -1,39 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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/raw_spec.rb

@@ -1,35 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Daijobu::Scheme::Raw do
-  
-  before do
-    @scheme = Daijobu::Scheme::Raw.new
-  end
-  
-  describe "#parse" do
-    before do
-      @stringy = '{ "thing" => 10 }'
-    end
-    
-    it "should do nothing to the given string" do
-      @scheme.parse(@stringy).should == @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 do nothing to the given object" do
-      @scheme.unparse(@hashy).should == @hashy
-    end    
-  end
-  
-end

data/spec/daijobu/schemes/yaml_spec.rb

@@ -1,37 +0,0 @@
-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