jsonbuilder 0.0.7 → 0.1.0

data/lib/builder/abstract.rb

@@ -4,6 +4,13 @@ module Builder
       false
     end
 
+    def new!
+      self.class.new
+    end
+
+    def serialization_method!
+    end
+
     def target!
     end
 

data/lib/builder/hash_structure.rb

@@ -12,19 +12,16 @@ module Builder
 
     # NOTICE: you have to call this method to use array in json
     def array_mode(key = nil, &block)
-      raise RuntimeError.new("cannot call inside array_mode block") if @array_mode
-      @array_mode = true
       if eval("#{_current}").is_a?(::Hash)
         key ||= :entry
         eval("#{_current}.merge!(key => [])")
-        @path.push(key.to_sym)
-        yield(self)
-        @path.pop
+        _move_current(key.to_sym) do
+          _array_mode(&block)
+        end
       else
         eval("#{_current} = []")
-        yield(self)
+        _array_mode(&block)
       end
-      @array_mode = false
     end
 
     def target!
@@ -35,17 +32,38 @@ module Builder
       end
     end
 
+    def serialization_method!
+      :to_hash
+    end
+
+    def root!(key, *attrs, &block)
+      @include_root = true
+      method_missing(key, *attrs, &block)
+    end
+
+    def content!(key, default_content_key, *attrs, &block)
+      @default_content_key = default_content_key.to_sym
+      method_missing(key, *attrs, &block)
+    end
+
     def <<(_target)
       if @array_mode
+        key = @path.pop
         eval("#{_current} << _target")
+        @path.push(key)
       else
-        eval("#{_current} ||= {}")
-        eval("#{_current}.merge!(_target)")
+        if _target.is_a?(String)
+          puts _current
+          eval("#{_current} = _target")
+        else
+          eval("#{_current} ||= {}")
+          eval("#{_current}.merge!(_target)")
+        end
       end
     end
 
-    def text!(text)
-      raise RuntimeError.new("cannot call inside array_mode block") if @array_mode
+    def text!(text, default_content_key = nil)
+      @default_content_key = default_content_key.to_sym unless default_content_key.nil?
       if eval("#{_current}").is_a?(::Hash)
         eval("#{_current}.merge!({@default_content_key => text})")
       else
@@ -61,10 +79,10 @@ module Builder
     def method_missing(key, *args, &block)
       key = args.first.is_a?(Symbol) ? "#{key}:#{args.shift}".to_sym : key.to_sym
       args[0] = {@default_content_key => args[0]} if args.size > 1 && !args[0].is_a?(::Hash)
-      unless @root
-        _root(key, args, &block)
-      else
+      if @root
         _child(key, args, &block)
+      else
+        _root(key, args, &block)
       end
       target!
     end
@@ -80,10 +98,10 @@ module Builder
     end
 
     def _child(key, args, &block)
-      eval("#{_current} ||= {}")
-      @path.push(key)
-      _set_args(args, &block)
-      @path.pop
+      eval("#{_current} ||= {}") unless @array_mode
+      _move_current(key) do
+        _set_args(args, &block)
+      end
     end
 
     def _set_args(args, &block)
@@ -95,11 +113,34 @@ module Builder
           eval("#{_current} = arg")
         end
       end
-      yield(self) if block_given?
+      if @array_mode && block_given?
+        @array_mode = false
+        yield(self)
+        @array_mode = true
+      elsif block_given?
+        yield(self)
+      end
     end
 
     def _current
-      "@target[:\"#{@path.join('"][:"')}\"]"
+      current_path = @path.inject('') do |current_path, key|
+        current_path += key.is_a?(Integer) ? "[#{key}]" : "[:\"#{key}\"]"
+      end
+      "@target#{current_path}"
+    end
+
+    def _move_current(key, &block)
+      @path.push(key) unless @array_mode
+      yield
+      @array_mode ? @path[@path.size - 1] += 1 : @path.pop
+    end
+
+    def _array_mode(&block)
+      @array_mode = true
+      @path.push(0)
+      yield
+      @path.pop
+      @array_mode = false
     end
 
   end

data/lib/builder/json_format.rb

@@ -1,22 +1,45 @@
-require 'json'
+require 'activesupport'
 
 module Builder
   class JsonFormat < HashStructure
 
     def initialize(options = {})
-      # @default_content_key is used in such case: markup.key(value, :attr_key => attr_value)
-      # in this case, we need some key for value.
-      @default_content_key  = (options[:default_content_key] || :content).to_sym
-      @include_root = options[:include_root]
-      @target = {}
-      @array_mode = false
+      super(options)
+    end
+
+    def serialization_method!
+      :to_json
+    end
+
+    def to_s
+      target!.to_json
+    end
+
+    def <<(_target)
+      if _target.is_a?(String)
+        _target = ::ActiveSupport::JSON.decode(_target)
+        _target.symbolize_keys! if _target.is_a?(Hash)
+      end
+
+      if @array_mode
+        key = @path.pop
+        eval("#{_current} << _target")
+        @path.push(key)
+      else
+        if _target.is_a?(String)
+          eval("#{_current} = _target")
+        else
+          eval("#{_current} ||= {}")
+          eval("#{_current}.merge!(_target)")
+        end
+      end
     end
 
     def target!
       if @include_root
-        @target.to_json
+        @target
       else
-        @target[@root].to_json
+        @target[@root]
       end
     end
   end

data/lib/builder/xml_markup.rb

@@ -3,6 +3,25 @@ require 'builder/xmlmarkup'
 module Builder
   class XmlMarkup
 
+    def serialization_method!
+      :to_xml
+    end
+
+    def new!
+      Builder::XmlMarkup.new
+    end
+
+    # Rooted element only needed by XML
+    def root!(key, *attrs, &block)
+      tag!(key, *attrs, &block)
+    end
+
+    alias :single_argument_cdata! :cdata!
+
+    def cdata!(key, default_content_key = nil)
+      single_argument_cdata!(key)
+    end
+
     # Add this no-op
     def array_mode(key = nil, &block)
       yield(self)

data/lib/jsonbuilder.rb

@@ -1,8 +1,8 @@
 module JsonBuilder
   module Version
     MAJOR = 0
-    MINOR = 0
-    REVISION = 7 
+    MINOR = 1
+    REVISION = 0
     class << self
       def to_version
         "#{MAJOR}.#{MINOR}.#{REVISION}"
@@ -16,6 +16,6 @@ module JsonBuilder
 end
 
 require 'builder/abstract'
-require 'builder/hash_structure'
 require 'builder/xml_markup'
+require 'builder/hash_structure'
 require 'builder/json_format'

data/spec/builder/array_mode_spec.rb

@@ -0,0 +1,298 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Builder::HashStructure, "#array_mode" do
+
+  it "should treat an empty block as a blank Array" do
+    # XML ::
+    # <root>
+    #   <items>
+    #   </items>
+    # </root>
+    builder = Builder::HashStructure.new
+    builder.root do
+      builder.items do
+        builder.array_mode do
+        end
+      end
+    end
+    builder.target!.should == {:items => []}
+  end
+
+  it "should support tag_method (method_missing)" do
+    builder = Builder::HashStructure.new
+    builder.root do
+      builder.items do
+        builder.array_mode do
+          2.times do |i|
+            builder.item do
+              builder.text "hello world #{i}"
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {
+      :items => [{:text => "hello world 0"}, {:text => "hello world 1"}]
+    }
+  end
+
+  it "should support tag_method (method_missing) which includes cdata!" do
+    builder = Builder::HashStructure.new
+    builder.root do
+      builder.items do
+        builder.array_mode do
+          2.times do |i|
+            builder.item do
+              builder.cdata! "hello world #{i}"
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {:items=>["hello world 0", "hello world 1"]}
+  end
+
+  it "should support tag_method (method_missing) which includes attributes and contents" do
+    builder = Builder::HashStructure.new
+    builder.root do
+      builder.items do
+        builder.array_mode do
+          2.times do |i|
+            builder.item(:id => i) do
+              builder.text "hello world #{i}"
+              builder.sentence(:id => i) do
+                builder.text "Hello world!!"
+              end
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {
+      :items => [{
+        :text => "hello world 0",
+        :sentence => {:text => "Hello world!!", :id => 0},
+        :id => 0
+      },
+      {
+        :text => "hello world 1",
+        :sentence => {:text => "Hello world!!", :id => 1},
+        :id => 1
+      }]
+    }
+  end
+
+  it "should support <<(hash)" do
+    builder = Builder::HashStructure.new
+    # XML ::
+    # <root>
+    #   <items>
+    #     <item id="0">
+    #       <text>hello world 0</text>
+    #       <sentence id="0"></sentence>
+    #     </item>
+    #     <item id="0">
+    #       <text>hello world 1</text>
+    #       <sentence id="1">Hello world!!</sentence>
+    #     </item>
+    #   </items>
+    # </root>
+    builder.root do
+      builder.items do
+        builder.array_mode do
+          2.times do |i|
+            builder << builder.new!.item(:id => i) do |_builder|
+              _builder.text "hello world #{i}"
+              _builder.sentence(:id => i) do
+                _builder.text "Hello world!!"
+              end
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {
+      :items => [{
+        :text => "hello world 0",
+        :sentence => {:text => "Hello world!!", :id => 0},
+        :id => 0
+      },
+      {
+        :text => "hello world 1",
+        :sentence => {:text => "Hello world!!", :id => 1},
+        :id => 1
+      }]
+    }
+  end
+
+  # you have to make new builder instance for now
+  it "should allow root!" do
+    builder = Builder::HashStructure.new
+    # XML ::
+    # <root>
+    #   <items>
+    #     <item id="0">
+    #       <text>hello world 0</text>
+    #       <sentence id="0"></sentence>
+    #     </item>
+    #     <item id="0">
+    #       <text>hello world 1</text>
+    #       <sentence id="1">Hello world!!</sentence>
+    #     </item>
+    #   </items>
+    # </root>
+    builder.root do
+      builder.items do
+        builder.array_mode do
+          2.times do |i|
+            builder << builder.new!.root!(:item, :id => i) do |_builder|
+              _builder.text "hello world #{i}"
+              _builder.sentence(:id => i) do
+                _builder.text "Hello world!!"
+              end
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {
+      :items => [{
+        :item =>{
+          :text => "hello world 0",
+          :sentence => {:text => "Hello world!!", :id => 0},
+          :id => 0
+        }
+      },{
+        :item => {
+          :text => "hello world 1",
+          :sentence => {:text => "Hello world!!", :id => 1},
+          :id => 1
+        }
+      }]
+    }
+  end
+
+# it "should allow root! without constructing a new instance" do
+#   builder = Builder::HashStructure.new
+#   # XML ::
+#   # <root>
+#   #   <items>
+#   #     <item id="0">
+#   #       <text>hello world 0</text>
+#   #       <sentence id="0"></sentence>
+#   #     </item>
+#   #     <item id="0">
+#   #       <text>hello world 1</text>
+#   #       <sentence id="1">Hello world!!</sentence>
+#   #     </item>
+#   #   </items>
+#   # </root>
+#   builder.root do
+#     builder.items do
+#       builder.array_mode do
+#         2.times do |i|
+#           builder.root!(:item, :id => i) do
+#             builder.text "hello world #{i}"
+#             builder.sentence(:id => i) do
+#               builder.text "Hello world!!"
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+#   builder.target!.should == {
+#     :items => [{
+#       :item =>{
+#         :text => "hello world 0",
+#         :sentence => {:text => "Hello world!!", :id => 0},
+#         :id => 0
+#       }
+#     },{
+#       :item => {
+#         :text => "hello world 1",
+#         :sentence => {:text => "Hello world!!", :id => 1},
+#         :id => 1
+#       }
+#     }]
+#   }
+# end
+
+
+  it "should generate a new key if needed" do
+    builder = Builder::HashStructure.new
+    # XML ::
+    # <root>
+    #   <items site="smart.fm">
+    #     <item>
+    #       <text>hello world 0</text>
+    #     </item>
+    #     <item>
+    #       <text>hello world 1</text>
+    #     </item>
+    #   </items>
+    # </root>
+    builder.root do
+      builder.items(:site => "smart.fm") do
+        builder.array_mode(:item) do
+          2.times do |i|
+            builder.item do
+              builder.text "hello world #{i}"
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {
+      :items => {
+        :item => [{:text => "hello world 0"}, {:text=>"hello world 1"}],
+        :site=>"smart.fm"
+      }
+    }
+  end
+
+  it "should allow nested array_mode" do
+    builder = Builder::HashStructure.new
+    builder.root do
+      builder.items do
+        builder.array_mode do
+          2.times do |i|
+            builder.item(:id => i) do
+              builder.text "hello world #{i}"
+              builder.sentences do
+                builder.array_mode(:hoge) do
+                  2.times do |j|
+                    builder.sentence(:id => "#{i}_#{j}") do
+                      builder.text "hello world #{i}"
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    builder.target!.should == {
+      :items => [{
+        :text => "hello world 0",
+        :sentences => [{
+          :text => "hello world 0", :id => "0_0"
+        }, {
+          :text => "hello world 0", :id => "0_1"
+        }],
+        :id => 0
+      },
+      {
+        :text => "hello world 1",
+        :sentences => [{
+          :text => "hello world 1", :id => "1_0"
+        }, {
+          :text => "hello world 1", :id => "1_1"
+        }],
+        :id => 1
+      }]
+    }
+  end
+
+end

data/spec/builder/hash_structure_spec.rb

@@ -4,6 +4,11 @@ describe Builder::HashStructure, ".new" do
   it "should be accessible" do
     Builder::HashStructure.should respond_to(:new)
   end
+
+  it 'should create new instances of self with new!' do
+    builder = Builder::HashStructure.new
+    builder.new!.should be_a Builder::HashStructure
+  end
 end
 
 describe Builder::HashStructure do
@@ -17,6 +22,15 @@ describe Builder::HashStructure do
     builder.target!.should == {:tag => "value"}
   end
 
+  it "should remove the root tag, but keep the attributes" do
+    builder = Builder::HashStructure.new
+    # XML :: <root><tag>value</tag></root>
+    builder.root(:id => 1) do
+      builder.tag "value"
+    end
+    builder.target!.should == {:id => 1, :tag => "value"}
+  end
+
   it "should not remove the root tag when include_root is true" do
     builder = Builder::HashStructure.new(:include_root => true)
     # XML :: <root><tag>value</tag></root>
@@ -35,6 +49,15 @@ describe Builder::HashStructure do
     builder.target!.should == {:tag => {:id => 1, :content => "value"}}
   end
 
+  it "should use the specified default_content_key when both content and attributes exist" do
+    builder = Builder::HashStructure.new(:default_content_key => :text)
+    # XML :: <root><tag id="1">value</tag></root>
+    builder.root do
+      builder.tag("value", :id => 1)
+    end
+    builder.target!.should == {:tag => {:id => 1, :text => "value"}}
+  end
+
   it "should use the default_content_key when both cdata! and attributes exist" do
     builder = Builder::HashStructure.new
     # XML :: <root><tag id="1"><![CDATA[value]]></tag></root>
@@ -46,6 +69,46 @@ describe Builder::HashStructure do
     builder.target!.should == {:tag => {:id => 1, :content => "value"}}
   end
 
+  it "should allow the default_content_key to be specified as a second argument to cdata!" do
+    builder = Builder::HashStructure.new
+    # XML :: <quotes><quote id=\"1\"><![CDATA[All generalizations are false, including this one.]]></quote></quotes>
+    builder.quotes do
+      builder.quote(:id => 1) do
+        builder.cdata!("All generalizations are false, including this one.", :text)
+      end
+    end
+    builder.target!.should == {:quote => {:id => 1, :text => "All generalizations are false, including this one."}}
+  end
+
+  it "should use the specified default_content_key when it and content and attributes are specified via the content!" do
+    builder = Builder::HashStructure.new
+    # XML :: <root><tag id="1">value</tag></root>
+    builder.root do
+      builder.content!(:tag, :text, "value", :id => 1)
+    end
+    builder.target!.should == {:tag => {:id => 1, :text => "value"}}
+  end
+
+  it "should accept strings for insertion" do
+    builder = Builder::HashStructure.new
+    sub_builder = Builder::HashStructure.new
+    sub_builder.tag('value')
+
+    # XML :: <root><tag id="1">value</tag></root>
+    builder.root do
+      builder.tags do |tag|
+        builder << sub_builder.target!
+      end
+    end
+    builder.target!.should == {:tags => "value"}
+  end
+
+end
+
+describe Builder::HashStructure, '#serialization_method!' do
+  it 'should report the to_hash method' do
+    Builder::HashStructure.new.serialization_method!.should == :to_hash
+  end
 end
 
 describe Builder::HashStructure, "#target!" do
@@ -74,145 +137,13 @@ describe Builder::HashStructure, "#target!" do
 
 end
 
-describe Builder::HashStructure, "#array_mode" do
+describe Builder::HashStructure, "#root!" do
 
-  it "should support <<(hash)" do
+  it "should force the root tag" do
     builder = Builder::HashStructure.new
-    # XML ::
-    # <root>
-    #   <items>
-    #     <item>
-    #       <text>hello world 0</text>
-    #     </item>
-    #     <item>
-    #       <text>hello world 1</text>
-    #     </item>
-    #   </items>
-    # </root>
-    builder.root do
-      builder.items do
-        builder.array_mode do
-          2.times do |i|
-            _builder = Builder::HashStructure.new
-            builder << _builder.item do
-              _builder.text "hello world #{i}"
-            end
-          end
-        end
-      end
-    end
-    builder.target!.should == {
-      :items => [{:text => "hello world 0"}, {:text => "hello world 1"}]
-    }
-  end
-
-  it "should generate a new key if needed" do
-    builder = Builder::HashStructure.new
-    # XML ::
-    # <root>
-    #   <items site="smart.fm">
-    #     <item>
-    #       <text>hello world 0</text>
-    #     </item>
-    #     <item>
-    #       <text>hello world 1</text>
-    #     </item>
-    #   </items>
-    # </root>
-    builder.root do
-      builder.items(:site => "smart.fm") do
-        builder.array_mode do
-          2.times do |i|
-            _builder = Builder::HashStructure.new
-            builder << _builder.item do
-              _builder.text "hello world #{i}"
-            end
-          end
-        end
-      end
-    end
-    builder.target!.should == {
-      :items => {
-        :entry => [{:text => "hello world 0"}, {:text=>"hello world 1"}],
-        :site=>"smart.fm"
-      }
-    }
-  end
-
-  it "should treat an empty block as a blank Array" do
-    # XML ::
-    # <root>
-    #   <items>
-    #   </items>
-    # </root>
-    builder = Builder::HashStructure.new
-    builder.root do
-      builder.items do
-        builder.array_mode do
-        end
-      end
-    end
-    builder.target!.should == {:items => []}
-  end
-
-  it "should raise error if tag methods (method_missing) is used inside block"do
-    builder = Builder::HashStructure.new
-    builder.root do
-      builder.items do
-        lambda do
-          builder.array_mode do
-            builder.item("hello world")
-          end
-        end.should raise_error
-        lambda do
-          builder.array_mode do
-            builder.item do
-              builder.text("hello world")
-            end
-          end
-        end.should raise_error
-      end
-    end
-  end
-
-  it "should raise error if tag! is used inside block"do
-    builder = Builder::HashStructure.new
-    builder.root do
-      builder.items do
-        lambda do
-          builder.array_mode do
-            builder.tag!("item", "item1")
-          end
-        end.should raise_error
-      end
-    end
-  end
-
-  it "should raise error if cdata! (or text!) is used inside block"do
-    builder = Builder::HashStructure.new
-    builder.root do
-      builder.items do
-        lambda do
-          builder.array_mode do
-            builder.cdata!("text")
-          end
-        end.should raise_error
-      end
-    end
-  end
-
-  it "should raise error if array_mode is used inside block"do
-    builder = Builder::HashStructure.new
-    builder.root do
-      builder.items do
-        lambda do
-          builder.array_mode do
-            builder.array_mode do
-            end
-          end
-        end.should raise_error
-      end
+    builder.root!(:root) do
+      builder.tag "value"
     end
+    builder.target!.should == {:root => {:tag => 'value'}}
   end
-
 end

data/spec/builder/json_format_spec.rb

@@ -1,11 +1,78 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
+class TestObject
+
+  def initialize(text)
+    @text = text
+  end
+
+  def to_json(options = {})
+    builder = Builder::JsonFormat.new
+    builder.content do
+      builder.text(@text)
+    end
+    builder.target!.to_json
+  end
+end
+
 describe Builder::JsonFormat, ".new" do
   it "should be accessible" do
     Builder::JsonFormat.should respond_to(:new)
   end
 end
 
+describe Builder::JsonFormat, '#serialization_method!' do
+  it 'should report the to_json method' do
+    Builder::JsonFormat.new.serialization_method!.should == :to_json
+  end
+end
+
+describe Builder::JsonFormat do
+
+  it 'should allow string inserts to support recursive calls' do
+    builder = Builder::JsonFormat.new
+    builder.objects do
+      builder << TestObject.new("Recursive Json!").to_json
+    end
+
+    builder.to_s.should == "{\"text\": \"Recursive Json!\"}"
+  end
+
+  it 'should allow string inserts to support recursive calls' do
+    builder = Builder::JsonFormat.new
+    builder.objects do
+      builder << "\"my text\""
+    end
+
+    builder.to_s.should == "\"my text\""
+  end
+
+  it 'should allow string inserts to support recursive calls in array mode' do
+    builder = Builder::JsonFormat.new
+    builder.objects do
+      builder.texts do
+        builder.array_mode do
+          builder << "\"my text\""
+        end
+      end
+    end
+
+    builder.to_s.should == "{\"texts\": [\"my text\"]}"
+  end
+
+  it 'should allow string inserts to support recursive calls in array mode' do
+    builder = Builder::JsonFormat.new
+    builder.objects do
+      builder.key('value')
+      builder << TestObject.new("Recursive Json!").to_json
+    end
+
+    builder.target!.should == {:key => "value", :text => "Recursive Json!"}
+    # NOTICE: The order of Hash keys may change.
+    # builder.to_s.should == "{\"text\": \"Recursive Json!\", \"key\": \"value\"}"
+  end
+end
+
 describe Builder::JsonFormat, "#target!" do
 
   it "should return a String when there is only a root value" do
@@ -14,13 +81,23 @@ describe Builder::JsonFormat, "#target!" do
     builder.target!.should be_a(String)
   end
 
-  it "should return a JSON string when root has deeper structure" do
+  it "should return a Hash object when root has deeper structure" do
     builder = Builder::JsonFormat.new
     builder.root do
       builder.item("value")
     end
-    builder.target!.should be_a(String)
-    builder.target!.should =="{\"item\":\"value\"}"
+    builder.target!.should be_a(Hash)
+    builder.to_s.should =="{\"item\": \"value\"}"
+  end
+
+  it "should return a Hash object when include_root is true" do
+    builder = Builder::JsonFormat.new(:include_root => true)
+    # XML :: <root><tag>value</tag></root>
+    builder.root do
+      builder.tag "value"
+    end
+    builder.target!.should be_a(Hash)
+    builder.to_s.should == '{"root": {"tag": "value"}}'
   end
 
 end

data/spec/builder/xml_markup_spec.rb

@@ -1,5 +1,13 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
+describe Builder::XmlMarkup, "#new!" do
+
+  it "should return new instance of same class" do
+    builder = Builder::XmlMarkup.new
+    builder.new!.should be_a Builder::XmlMarkup
+  end
+end
+
 describe Builder::XmlMarkup, "#array_mode" do
 
   it "should do nothing" do
@@ -15,5 +23,34 @@ describe Builder::XmlMarkup, "#array_mode" do
     end
     builder.target!.should == builder2.target!
   end
+end
+
+describe Builder::XmlMarkup, '#serialization_method!' do
+  it 'should report the to_xml method' do
+    Builder::XmlMarkup.new.serialization_method!.should == :to_xml
+  end
+end
+
+describe Builder::XmlMarkup, "#xml_root!" do
+
+  it "should create an element as normal" do
+    builder = Builder::XmlMarkup.new
+    builder.root!("root") do
+      builder.tag "value"
+    end
+    builder.target!.should == "<root><tag>value</tag></root>"
+  end
+end
 
+describe Builder::XmlMarkup, "#cdata!" do
+
+  it "should support a second argument which does nothing" do
+    builder = Builder::XmlMarkup.new
+    builder.quotes do
+      builder.quote(:id => 1) do
+        builder.cdata!("All generalizations are false, including this one.", :text)
+      end
+    end
+    builder.target!.should == "<quotes><quote id=\"1\"><![CDATA[All generalizations are false, including this one.]]></quote></quotes>"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jsonbuilder
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors: 
 - nov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-11 00:00:00 +09:00
+date: 2009-06-24 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,6 +36,7 @@ files:
 - ChangeLog
 - Rakefile
 - spec/builder
+- spec/builder/array_mode_spec.rb
 - spec/builder/hash_structure_spec.rb
 - spec/builder/json_format_spec.rb
 - spec/builder/xml_markup_spec.rb