pump 0.5.1 → 0.6.0

data/lib/pump/xml.rb

@@ -1,84 +1,25 @@
-require "pump/xml/tag"
-require "pump/xml/value"
-require "pump/xml/tag_array"
-require "pump/xml/dsl"
+require "pump/encoder"
 require 'active_support/core_ext/string/inflections'
 
 module Pump
-  class Xml
-
-    attr_reader :root_tag_name, :tag_config, :options
-
-    # Creates a new XML-encoder with a root tag named after +root_tag_name+.
-    #
-    # @example Create a simple encoder for a person with a name attribute:
-    #   Pump::Xml.new :person do
-    #     tag :name
-    #   end
-    #
-    # @example Create the same without usage of the DSL:
-    #   Pump::Xml.new :person, [{:name => :name}]
-    #
-    # @example Create the same but without the xml instruct
-    #   Pump::Xml.new :person, :instruct => false do
-    #     tag :name
-    #   end
-    #
-    # @example The same again without DSL:
-    #
-    #   Pump::Xml.new :person, [{:name => :name}], :instruct => false
-    #
-    # @param [String, Symbol] root_tag_name     the name of the used root tag
-    # @param [Array<Hash>] tag_config           optional config for all tags
-    # @param [Hash] options                     optional options for the whole encoder
-    # @yield an optional block to create the encoder with the Pump::Xml::Dsl
-    #
-    # @return [self]
-    def initialize(root_tag_name, tag_config=nil, options={}, &blk)
-      unless Array === tag_config
-        raise ArgumentError unless block_given?
-        @options = tag_config || {}
-        @tag_config = Dsl.new(&blk).config
-      else
-        @tag_config    = tag_config
-        @options       = options
-      end
-      @root_tag_name = root_tag_name
-
-      compile
-    end
-
-    # Encode a object or an array of objects to an XML-string.
-    #
-    # @param [Object, Array<Object>] object object or an array of objects to
-    #    encode to XML. The only requirement: The given objects must respond
-    #    to all methods configured during initalization of the Pump::Xml instance.
-    #
-    # @return [String]
-    def encode(object)
-      object.is_a?(Array) ? encode_array(object) : encode_single(object)
-    end
+  class Xml < Pump::Encoder
 
     private
 
-    def compile
-      instance_eval(compile_string)
-    end
-
     def compile_string
       <<-EOV
-        def encode_single(object)
-          "#{Tag.new(root_tag_name, {}, sub_tags, tag_options)}"
+        def encode_single(object, options)
+          "#{Tag.new(root_name, {}, sub_tags, tag_options)}"
         end
 
-        def encode_array(objects)
-          "#{TagArray.new(root_tag_name, {}, sub_tags, tag_options)}"
+        def encode_array(objects, options)
+          "#{TagArray.new(root_name, {}, sub_tags, tag_options)}"
         end
       EOV
     end
 
     def sub_tags
-      tag_config.map do |config|
+      encoder_config.map do |config|
         build_tag(config)
       end
     end
@@ -97,11 +38,15 @@ module Pump
     end
 
     def tag_options
-      {:instruct => add_instruct?, :extra_indent => options[:extra_indent], :array_root => options[:array_root] }
+      {:instruct => add_instruct?, :extra_indent => encoder_options[:extra_indent], :array_root => encoder_options[:array_root] }
     end
 
     def add_instruct?
-      options.has_key?(:instruct) ? options[:instruct] : true
+      encoder_options.has_key?(:instruct) ? encoder_options[:instruct] : true
     end
   end
-end
+end
+
+require "pump/xml/tag"
+require "pump/xml/value"
+require "pump/xml/tag_array"

data/pump.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version       = Pump::VERSION
   gem.authors       = ["Sebastian Munz"]
   gem.email         = ["sebastian@yo.lk"]
-  gem.description   = %q{Fast but inflexible XML encoding for ruby objects.}
-  gem.summary       = %q{Fast but inflexible XML encoding for ruby objects.}
+  gem.description   = %q{Fast but inflexible XML and JSON encoding for ruby objects.}
+  gem.summary       = %q{Fast but inflexible XML and JSON encoding for ruby objects.}
   gem.homepage      = "https://github.com/yolk/pump"
   gem.license       = 'MIT'
 
@@ -19,6 +19,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency 'activesupport'
+  gem.add_dependency 'oj'
   gem.add_development_dependency 'rspec',       '>= 2.12.0'
   gem.add_development_dependency 'guard-rspec', '>=2.2.2'
 end

data/spec/pump/array_spec.rb

@@ -4,6 +4,10 @@ class Array
   def to_xml(options={})
     "<Array#to_xml />"
   end
+
+  def to_json(options={})
+    "{Array#to_json}"
+  end
 end
 
 class ArrayObjectWithoutInclude
@@ -39,11 +43,19 @@ describe Pump::Array do
     [].respond_to?(:pump_to_xml).should eql(true)
   end
 
+  it "should extend ::Array by default with pump_to_json" do
+    [].respond_to?(:pump_to_json).should eql(true)
+  end
+
   context "with objects without include" do
     subject{ [ArrayObjectWithoutInclude.new] }
 
     it "should return default to_xml" do
-      subject.pump_to_xml.should eql("<Array#to_xml />")
+      subject.pump_to_xml.should eql(subject.to_xml)
+    end
+
+    it "should return default to_json" do
+      subject.pump_to_json.should eql(subject.to_json)
     end
   end
 
@@ -51,7 +63,11 @@ describe Pump::Array do
     subject{ [ArrayObjectWithInclude.new] }
 
     it "should return default to_xml" do
-      subject.pump_to_xml.should eql("<Array#to_xml />")
+      subject.pump_to_xml.should eql(subject.to_xml)
+    end
+
+    it "should return default to_json" do
+      subject.pump_to_json.should eql(subject.to_json)
     end
   end
 
@@ -69,5 +85,21 @@ describe Pump::Array do
     it "should encode with default encoder on unknown set" do
       subject.pump_to_xml(:set => :bla).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<array-objects type=\"array\">\n  <array-object>\n    <name>Tintin</name>\n  </array-object>\n</array-objects>\n")
     end
+
+    it "should encode json with default encoder" do
+      subject.pump_to_json.should eql("[{\"array_object\":{\"name\":\"Tintin\"}}]")
+    end
+
+    it "should encode json with specified encoder" do
+      subject.pump_to_json(:set => :with_age).should eql("[{\"array_object\":{\"name\":\"Tintin\",\"age\":27}}]")
+    end
+
+    it "should encode json with default encoder on unknown set" do
+      subject.pump_to_json(:set => :bla).should eql("[{\"array_object\":{\"name\":\"Tintin\"}}]")
+    end
+
+    it "should pass down options to encoder" do
+      subject.pump_to_json(:exclude_root_in_json => true).should eql("[{\"name\":\"Tintin\"}]")
+    end
   end
 end

data/spec/pump/{xml/dsl_spec.rb → dsl_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Pump::Xml::Dsl do
-  subject { Pump::Xml::Dsl.new {} }
+describe Pump::Dsl do
+  subject { Pump::Dsl.new {} }
 
   describe ".new" do
     it "requires one block" do
-      lambda{ Pump::Xml::Dsl.new }.should raise_error(ArgumentError)
+      lambda{ Pump::Dsl.new }.should raise_error(ArgumentError)
       lambda{ subject }.should_not raise_error
     end
   end
@@ -14,88 +14,88 @@ describe Pump::Xml::Dsl do
     its(:config) { should eql([]) }
 
     context "with tag" do
-      subject { Pump::Xml::Dsl.new { tag :name } }
+      subject { Pump::Dsl.new { tag :name } }
       its(:config) { should eql([{:name => :name}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { tag :name, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { tag :name, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:name => :name, :attributes => {:a => 'b'}, :options => false}]) }
       end
 
       context "with :from option" do
-        subject { Pump::Xml::Dsl.new { tag :name, :from => :method_name } }
+        subject { Pump::Dsl.new { tag :name, :from => :method_name } }
         its(:config) { should eql([{:name => :method_name}]) }
       end
 
       context "with dashs in tag name" do
-        subject { Pump::Xml::Dsl.new { tag :"first-name" } }
+        subject { Pump::Dsl.new { tag :"first-name" } }
         its(:config) { should eql([{:"first-name" => :first_name}]) }
       end
     end
 
     context "with string" do
-      subject { Pump::Xml::Dsl.new { string :name } }
+      subject { Pump::Dsl.new { string :name } }
       its(:config) { should eql([{:name => :name}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { string :name, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { string :name, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:name => :name, :attributes => {:a => 'b'}, :options => false}]) }
       end
     end
 
     context "with integer" do
-      subject { Pump::Xml::Dsl.new { integer :name } }
+      subject { Pump::Dsl.new { integer :name } }
       its(:config) { should eql([{:name => :name, :attributes => {:type => 'integer'}, :xmlsafe => true}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { integer :name, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { integer :name, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:name => :name, :attributes => {:type => 'integer', :a => 'b'}, :options => false, :xmlsafe => true}]) }
       end
     end
 
     context "with float" do
-      subject { Pump::Xml::Dsl.new { float :name } }
+      subject { Pump::Dsl.new { float :name } }
       its(:config) { should eql([{:name => :name, :attributes => {:type => 'float'}, :xmlsafe => true}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { float :name, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { float :name, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:name => :name, :attributes => {:type => 'float', :a => 'b'}, :options => false, :xmlsafe => true}]) }
       end
     end
 
     context "with boolean" do
-      subject { Pump::Xml::Dsl.new { boolean :name } }
+      subject { Pump::Dsl.new { boolean :name } }
       its(:config) { should eql([{:name => :name, :attributes => {:type => 'boolean'}, :xmlsafe => true}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { boolean :name, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { boolean :name, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:name => :name, :attributes => {:type => 'boolean', :a => 'b'}, :options => false, :xmlsafe => true}]) }
       end
     end
 
     context "with date" do
-      subject { Pump::Xml::Dsl.new { date :at } }
+      subject { Pump::Dsl.new { date :at } }
       its(:config) { should eql([{:at => :at, :attributes => {:type => 'date'}, :xmlsafe => true}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { date :at, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { date :at, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:at => :at, :attributes => {:type => 'date', :a => 'b'}, :options => false, :xmlsafe => true}]) }
       end
     end
 
     context "with (date)time" do
-      subject { Pump::Xml::Dsl.new { time :at } }
+      subject { Pump::Dsl.new { time :at } }
       its(:config) { should eql([{:at => :at, :typecast => :xmlschema, :attributes => {:type => 'datetime'}, :xmlsafe => true}]) }
 
       context "with attributes and options" do
-        subject { Pump::Xml::Dsl.new { time :at, :attributes => {:a => 'b'}, :options => false } }
+        subject { Pump::Dsl.new { time :at, :attributes => {:a => 'b'}, :options => false } }
         its(:config) { should eql([{:at => :at, :attributes => {:a => 'b', :type => 'datetime'}, :options => false, :typecast => :xmlschema, :xmlsafe => true}]) }
       end
     end
 
     context "with nested tags" do
       subject do
-        Pump::Xml::Dsl.new do
+        Pump::Dsl.new do
           tag :person, :option => 'x' do
             string :name
             integer :age
@@ -115,7 +115,7 @@ describe Pump::Xml::Dsl do
 
   context "with array tag" do
     subject do
-      Pump::Xml::Dsl.new do
+      Pump::Dsl.new do
         array(:children) do
           tag :name
         end
@@ -128,7 +128,7 @@ describe Pump::Xml::Dsl do
 
     context "with options" do
       subject do
-        Pump::Xml::Dsl.new do
+        Pump::Dsl.new do
           array(:children, :from => :kids, :child_root => :ugly_kid_joe) do
             tag :name
           end

data/spec/pump/encoder_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Pump::Encoder do
+  describe ".new" do
+    it "requires two parameters or one and a block" do
+      lambda{ Pump::Encoder.new }.should raise_error(ArgumentError)
+      lambda{ Pump::Encoder.new('record') }.should raise_error(ArgumentError)
+      lambda{ Pump::Encoder.new('record', []) }.should_not raise_error
+      lambda{ Pump::Encoder.new('record') {} }.should_not raise_error
+    end
+
+    describe "with block given" do
+      subject do
+        Pump::Encoder.new('human', :instruct => false) do
+          tag :name
+        end
+      end
+
+      its(:encoder_config) { should eql([{:name=>:name}])}
+    end
+
+    describe "with base given in options" do
+      let(:base) { Pump::Encoder.new('person', [{:name => :name}, {:role => :role}], {:option => true}) }
+
+      context "adding other param" do
+        subject{ Pump::Encoder.new('person', [{:age => :age}], :base => base) }
+        its(:encoder_config) { should eql([{:name => :name}, {:role => :role}, {:age => :age}])}
+        its(:encoder_options) { should eql({:option => true}) }
+        its(:base) { should eql(base) }
+
+        it "leaves base config untouched" do
+          subject
+          base.encoder_config.should eql([{:name => :name}, {:role => :role}])
+        end
+      end
+
+      context "adding other param with block" do
+        subject{ Pump::Encoder.new('person', :base => base) { tag :age } }
+        its(:encoder_config) { should eql([{:name => :name}, {:role => :role}, {:age => :age}])}
+
+        it "leaves base config untouched" do
+          subject
+          base.encoder_config.should eql([{:name => :name}, {:role => :role}])
+        end
+      end
+
+      context "alter exisiting param" do
+        subject{ Pump::Encoder.new('person', [{:name => :full_name}], :base => base) }
+        its(:encoder_config) { should eql([{:name => :full_name}, {:role => :role}])}
+
+        it "leaves base config untouched" do
+          subject
+          base.encoder_config.should eql([{:name => :name}, {:role => :role}])
+        end
+      end
+
+      context "alter exisiting param with block" do
+        subject do
+          Pump::Encoder.new('person', :base => base) do
+            string :last_name
+            tag :role, :static_value => nil
+          end
+        end
+        its(:encoder_config) { should eql([{:name => :name}, {:role=>:role, :static_value=>nil}, {:last_name => :last_name}])}
+
+        it "leaves base config untouched" do
+          subject
+          base.encoder_config.should eql([{:name => :name}, {:role => :role}])
+        end
+      end
+
+      context "adding an option" do
+        context "adding other param" do
+          subject{ Pump::Encoder.new('person', [], {:other_option => false, :base => base}) }
+          its(:encoder_options) { should eql({:other_option => false, :option => true}) }
+
+          it "leaves base options untouched" do
+            subject
+            base.encoder_options.should eql({:option => true})
+          end
+        end
+      end
+
+      context "adding and overwriting an option" do
+        context "adding other param" do
+          subject{ Pump::Encoder.new('person', [], {:option => 47, :other_option => false, :base => base}) }
+          its(:encoder_options) { should eql({:other_option => false, :option => 47}) }
+
+          it "leaves base options untouched" do
+            subject
+            base.encoder_options.should eql({:option => true})
+          end
+        end
+      end
+    end
+  end
+end

data/spec/pump/json_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+describe Pump::Json do
+  describe "#encode" do
+    let(:person) { Struct.new(:name, :age, :last_name).new('Benny', 9, 'Hellman') }
+    let(:json) { Pump::Json.new('person', [{:name => :name}]) }
+
+    it "requires one object" do
+      lambda{ json.encode }.should raise_error(ArgumentError)
+      lambda{ json.encode(person) }.should_not raise_error
+    end
+
+    it "returns json string" do
+      json.encode(person).should eql("{\"person\":{\"name\":\"Benny\"}}")
+    end
+
+    context "with array" do
+
+      context "with one entry" do
+        let(:people) { [person] }
+
+        it "returns json string" do
+          json.encode(people).should eql("[{\"person\":{\"name\":\"Benny\"}}]")
+        end
+      end
+
+      context "with multiple entries" do
+        let(:people) { [person, Struct.new(:name, :age).new('Carlo', 5)] }
+
+        it "returns xml string" do
+          json.encode(people).should eql("[{\"person\":{\"name\":\"Benny\"}},{\"person\":{\"name\":\"Carlo\"}}]")
+        end
+
+        context "with exclude_root_in_json option" do
+          it "returns json string without root" do
+            json.encode(people, :exclude_root_in_json => true).should eql("[{\"name\":\"Benny\"},{\"name\":\"Carlo\"}]")
+          end
+        end
+      end
+
+      context "with empty array" do
+        let(:people) { [] }
+
+        it "returns xml string" do
+          json.encode(people).should eql("[]")
+        end
+      end
+    end
+
+    context "with blank name" do
+      let(:person) { Struct.new(:name, :age).new('', 9) }
+
+      it do
+        json.encode(person).should eql("{\"person\":{\"name\":\"\"}}")
+      end
+    end
+
+    context "with nil name" do
+      let(:person) { Struct.new(:name, :age).new(nil, 9) }
+
+      it do
+        json.encode(person).should eql("{\"person\":{\"name\":null}}")
+      end
+    end
+
+    context "with conditionals" do
+      let(:person) { Struct.new(:name, :age, :is_young, :is_old).new('Gorbatschow', 82, false, true) }
+
+      context "simple if" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :if => :is_young}]) }
+
+        it "skips key-value on false" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
+        end
+      end
+
+      context "simple unless" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :unless => :is_old}]) }
+
+        it "skips key-value on false" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
+        end
+      end
+
+      context "chained" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :unless => 'age.nil?'}]) }
+        let(:people) { [person, Struct.new(:name, :age).new('Schewardnadse', nil)] }
+
+        it "skips key-value on false" do
+          json.encode(people).should eql("[{\"person\":{\"name\":\"Gorbatschow\",\"age\":82}},{\"person\":{\"name\":\"Schewardnadse\"}}]")
+        end
+      end
+    end
+
+    context "with static_value set" do
+      let(:person) { Struct.new(:name, :age, :is_yount).new('Gorbatschow', 82, false) }
+
+      context "replace with other value" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => 12}]) }
+
+        it "returns given static_value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":12}}")
+        end
+      end
+
+      context "replace with nil value" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => nil}]) }
+
+        it "returns given static_value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":null}}")
+        end
+      end
+
+      context "replace with other value but with failed condition" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => 12, :if => :is_yount}]) }
+
+        it "returns given static_value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
+        end
+      end
+
+      context "replace with other value but with succssful condition" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => 12, :unless => :is_yount}]) }
+
+        it "returns given static_value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":12}}")
+        end
+      end
+    end
+
+    context "deep hash-like nesting" do
+      let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}]}], :instruct => false) }
+
+      it "returns static string" do
+        json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":{\"name\":\"Benny\",\"age\":9}}}")
+      end
+
+      context "with static_value = nil" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => nil}], :instruct => false) }
+
+        it "uses static value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":null}}")
+        end
+      end
+
+      context "with static_value = {}" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => {}}], :instruct => false) }
+
+        it "uses static value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":{}}}")
+        end
+      end
+    end
+
+    context "deep array-like nesting" do
+      let(:person) {
+        Struct.new(:name, :children).new('Gustav', [
+          Struct.new(:name).new('Lilly'),
+          Struct.new(:name).new('Lena')
+      ]) }
+
+      let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
+                                            :array => [{:name => :name}]}], :instruct => false) }
+
+      it "returns json string" do
+        json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[{\"name\":\"Lilly\"},{\"name\":\"Lena\"}]}}")
+      end
+
+      context "with static_value = nil" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
+                                            :array => [{:name => :name}], :static_value => nil}], :instruct => false) }
+        it "uses static value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
+        end
+      end
+
+      context "with static_value = []" do
+        let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
+                                            :array => [{:name => :name}], :static_value => []}], :instruct => false) }
+        it "uses static value" do
+          json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
+        end
+      end
+    end
+
+    context "with underscore option" do
+      context "not set" do
+        let(:json) { Pump::Json.new('my-person', [{"first-name" => :name}]) }
+
+        it "returns json string with underscores" do
+          json.encode(person).should eql("{\"my_person\":{\"first_name\":\"Benny\"}}")
+        end
+      end
+
+      context "set to false" do
+        let(:json) { Pump::Json.new('my-person', [{"first-name" => :name}], :underscore => false) }
+
+        it "returns json string with dashes" do
+          json.encode(person).should eql("{\"my-person\":{\"first-name\":\"Benny\"}}")
+        end
+      end
+
+      context "set to true" do
+        let(:json) { Pump::Json.new('my-person', [{"first-name" => :name}], :underscore => true) }
+
+        it "returns json string with underscores" do
+          json.encode(person).should eql("{\"my_person\":{\"first_name\":\"Benny\"}}")
+        end
+      end
+    end
+
+    context "with exclude_root_in_json option" do
+      it "returns json string without root" do
+        json.encode(person, :exclude_root_in_json => true).should eql("{\"name\":\"Benny\"}")
+      end
+    end
+  end
+end