jsonbuilder 0.0.5 → 0.0.6

data/README

@@ -1,6 +1,7 @@
 = jsonbuilder
 
-  by nov <nov@cerego.com>
+  by nov http://github.com/nov <nov@cerego.com> and
+     birkirb http://github.com/birkirb
 
 == Description
 
@@ -16,47 +17,49 @@
 
 === Gem Installation
 
-	gem install jsonbuilder
+  gem install jsonbuilder --source http://gems.rubyforge.org
+
+     OR for the lastest development version
+
+  gem install nov-jsonbuilder --source http://gems.github.com
 
 == Features/Problems
 
-  JsonMarkup returns Hash, not Json text.
-  You need to call to_json for returned target.
+  The Hash builder will return a hash structured in a similar way as the corresponding xml
+  built by XmlMarkup. The Json builder will return the same kind of hash as a JSON string
 
   USAGE:
-  def to_markup(markup, options = {})
-    markup = case format
-    when :xml
-      Builder::XmlMarkup.new
-    when :json
-      Builder::JsonMarkup.new
-    end
-    markup.user(
+  def serialize(builder, options = {})
+    builder.user(
       :id => id,
       :url => url
     )
-    markup.array_mode do
-      markup.images do
+    builder.array_mode do
+      builder.images do
         package.images.each do |image|
-          markup << image.to_markup(format, :only_url => true)
+          builder << image.builder(builder.class.new, :only_url => true)
         end
       end
     end
-    markup.target!
+    builder.target!
   end
-  
+
   def to_xml(options = {})
-    self.to_markup(:xml, options)
+    self.serialize(Builder::XMmlMarkup.new, options)
   end
-  
+
+  def to_hash(options = {})
+    self.serialize(Builder::Hash.new, options)
+  end
+
   def to_json(options = {})
-    self.to_markup(:json, options).to_json
+    self.serialize(Builder::Json.new, options)
   end
 
 == Synopsis
 
 == Copyright
 
-Author::    nov <nov@matake.jp>
+Author::    nov <nov@matake.jp> and birkirb
 Copyright:: Copyright (c) 2009 nov
 License::   MIT License

data/Rakefile

@@ -60,6 +60,7 @@ spec = Gem::Specification.new do |s|
   s.files = %w(README ChangeLog Rakefile) +
     Dir.glob("{spec,lib}/**/*") + 
     Dir.glob("examples/**/*.rb")
+  s.add_dependency('builder')
 end
 
 Rake::GemPackageTask.new(spec) do |p|

data/lib/builder/abstract.rb

@@ -0,0 +1,23 @@
+module Builder
+
+  class Abstract
+    def nil?
+      false
+    end
+
+    def target!
+    end
+
+    def comment!
+    end
+
+    def declare!
+    end
+
+    def instruct!
+    end
+
+    def comment!
+    end
+  end
+end

data/lib/builder/{jsonmarkup.rb → hash.rb}

@@ -1,13 +1,5 @@
 module Builder
-
-  class XmlMarkup
-    # Do nothing
-    def array_mode(key = nil, &block)
-      yield(self)
-    end
-  end
-
-  class JsonMarkup
+  class Hash < Abstract
 
     def initialize(options = {})
       # @default_content_key is used in such case: markup.key(value, :attr_key => attr_value)
@@ -18,15 +10,11 @@ module Builder
       @array_mode = false
     end
 
-    def nil?
-      false
-    end
-
     # NOTICE: you have to call this method to use array in json
     def array_mode(key = nil, &block)
       @array_mode = true
-      if eval("#{_current}").is_a?(Hash)
-        key ||= :entries
+      if eval("#{_current}").is_a?(::Hash)
+        key ||= :entry
         eval("#{_current}.merge!(key => [])")
         @path.push(key.to_sym)
         yield(self)
@@ -46,12 +34,6 @@ module Builder
       end
     end
 
-    # Do nothing
-    def comment!; end
-    def declare!; end
-    def instruct!; end
-    def comment!; end
-
     def <<(_target)
       if @array_mode
         eval("#{_current} << _target")
@@ -62,7 +44,7 @@ module Builder
     end
 
     def text!(text)
-      if eval("#{_current}").is_a?(Hash)
+      if eval("#{_current}").is_a?(::Hash)
         eval("#{_current}.merge!({@default_content_key => text})")
       else
         eval("#{_current} = text")
@@ -76,7 +58,7 @@ 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)
+      args[0] = {@default_content_key => args[0]} if args.size > 1 && !args[0].is_a?(::Hash)
       unless @root
         _root(key, args, &block)
       else
@@ -105,7 +87,7 @@ module Builder
     def _set_args(args, &block)
       args.each do |arg|
         case arg
-        when Hash
+        when ::Hash
           self << arg
         else
           eval("#{_current} = arg")
@@ -119,5 +101,4 @@ module Builder
     end
 
   end
-
-end
+end

data/lib/builder/json.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Builder
+
+  class Json < Hash
+
+    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
+    end
+
+    def target!
+      if @include_root
+        @target.to_json
+      else
+        @target[@root].to_json
+      end
+    end
+  end
+
+end

data/lib/builder/xml_markup.rb

@@ -0,0 +1,9 @@
+module Builder
+  class XmlMarkup
+
+    # Add this no-op
+    def array_mode(key = nil, &block)
+      yield(self)
+    end
+  end
+end

data/lib/jsonbuilder.rb

@@ -2,7 +2,7 @@ module JsonBuilder
   module Version
     MAJOR = 0
     MINOR = 0
-    REVISION = 5
+    REVISION = 6
     class << self
       def to_version
         "#{MAJOR}.#{MINOR}.#{REVISION}"
@@ -15,4 +15,7 @@ module JsonBuilder
   end
 end
 
-require 'builder/jsonmarkup'
+require 'builder/abstract'
+require 'builder/hash'
+require 'builder/xml_markup'
+require 'builder/json'

data/spec/builder/hash_spec.rb

@@ -0,0 +1,182 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Builder::Hash, ".new" do
+  it "should be accessible" do
+    Builder::Hash.should respond_to(:new)
+  end
+end
+
+describe Builder::Hash do
+
+  it "should remove the root tag" do
+    builder = Builder::Hash.new
+    # XML :: <root><tag>value</tag></root>
+    builder.root do
+      builder.tag "value"
+    end
+    builder.target!.should == {:tag => "value"}
+  end
+
+  it "should not remove the root tag when include_root is true" do
+    builder = Builder::Hash.new(:include_root => true)
+    # XML :: <root><tag>value</tag></root>
+    builder.root do
+      builder.tag "value"
+    end
+    builder.target!.should == {:root => {:tag => "value"}}
+  end
+
+  it "should use the default_content_key when both content and attributes exist" do
+    builder = Builder::Hash.new
+    # XML :: <root><tag id="1">value</tag></root>
+    builder.root do
+      builder.tag("value", :id => 1)
+    end
+    builder.target!.should == {:tag => {:id => 1, :content => "value"}}
+  end
+
+  it "should use the default_content_key when both cdata! and attributes exist" do
+    builder = Builder::Hash.new
+    # XML :: <root><tag id="1"><![CDATA[value]]></tag></root>
+    builder.root do
+      builder.tag(:id => 1) do
+        builder.cdata! "value"
+      end
+    end
+    builder.target!.should == {:tag => {:id => 1, :content => "value"}}
+  end
+
+end
+
+describe Builder::Hash, "#target!" do
+
+  it "should return a String when there is only a root value" do
+    builder = Builder::Hash.new
+    builder.root("value")
+    builder.target!.should be_a(String)
+  end
+
+  it "should return Hash when root has deeper structure" do
+    builder = Builder::Hash.new
+    builder.root do
+      builder.item("value")
+    end
+    builder.target!.should be_a(Hash)
+  end
+
+end
+
+describe Builder::Hash, "#array_mode" do
+
+  it "should support <<" do
+    builder = Builder::Hash.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::Hash.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::Hash.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::Hash.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::Hash.new
+    builder.root do
+      builder.items do
+        builder.array_mode do
+        end
+      end
+    end
+    builder.target!.should == {:items => []}
+  end
+
+  it "should only support the << operator for insertion"do
+    builder = Builder::Hash.new
+    # XML ::
+    # <root>
+    #   <items>
+    #     <item>
+    #       <text>hello world 0</text>
+    #     </item>
+    #     <item>
+    #       <text>hello world 1</text>
+    #     </item>
+    #   </items>
+    # </root>
+    succeeded = true
+    builder.root do
+      builder.items do
+        begin
+          builder.array_mode do
+            2.times do
+              builder.item do
+                builder.text "hello world"
+              end
+            end
+          end
+        rescue
+          succeeded = false
+        end
+      end
+    end
+    succeeded.should_not be_true
+  end
+
+end

data/spec/builder/json_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Builder::Json, ".new" do
+  it "should be accessible" do
+    Builder::Hash.should respond_to(:new)
+  end
+end
+
+describe Builder::Json, "#target!" do
+
+  it "should return a String when there is only a root value" do
+    builder = Builder::Hash.new
+    builder.root("value")
+    builder.target!.should be_a(String)
+  end
+
+  it "should return a JSON string when root has deeper structure" do
+    builder = Builder::Json.new
+    builder.root do
+      builder.item("value")
+    end
+    builder.target!.should be_a(String)
+    builder.target!.should =="{\"item\":\"value\"}"
+  end
+
+end

data/spec/builder/xml_markup_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Builder::XmlMarkup, "#array_mode" do
+
+  it "should do nothing" do
+    builder = Builder::XmlMarkup.new
+    builder.root do
+      builder.array_mode do
+        builder.item("value")
+      end
+    end
+    builder2 = Builder::XmlMarkup.new
+    builder2.root do
+      builder2.item("value")
+    end
+    builder.target!.should == builder2.target!
+  end
+
+end

data/spec/spec_helper.rb

@@ -6,7 +6,8 @@ rescue LoadError
   require 'spec'
 end
 $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
-require File.join(File.dirname(__FILE__), '..', 'lib', 'jsonbuilder')
+require 'builder'
+require 'jsonbuilder'
 
 def be_a(klass)
   be_is_a(klass)
@@ -15,4 +16,4 @@ end
 def rand_string(length = 100)
   chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
   Array.new(length){ chars[rand(chars.size)] }.join
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jsonbuilder
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - nov
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-06 00:00:00 +09:00
+date: 2009-06-08 00:00:00 +09:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: Builder::XmlMarkup like JsonBuilder (Builder::JsonMarkup)
 email: nov@matake.jp
 executables: []
@@ -27,11 +36,16 @@ files:
 - ChangeLog
 - Rakefile
 - spec/builder
-- spec/builder/jsonmarkup_spec.rb
+- spec/builder/hash_spec.rb
+- spec/builder/json_spec.rb
+- spec/builder/xml_markup_spec.rb
 - spec/jsonbuilder_spec.rb
 - spec/spec_helper.rb
 - lib/builder
-- lib/builder/jsonmarkup.rb
+- lib/builder/abstract.rb
+- lib/builder/hash.rb
+- lib/builder/json.rb
+- lib/builder/xml_markup.rb
 - lib/jsonbuilder.rb
 has_rdoc: true
 homepage: http://jsonbuilder.rubyforge.org

data/spec/builder/jsonmarkup_spec.rb

@@ -1,164 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe Builder::JsonMarkup, ".new" do
-  it "should be accessible" do
-    Builder::JsonMarkup.should respond_to(:new)
-  end
-end
-
-describe Builder::JsonMarkup do
-
-  it "should remove root tag" do
-    markup = Builder::JsonMarkup.new
-    # XML :: <root><tag>value</tag></root>
-    markup.root do
-      markup.tag "value"
-    end
-    markup.target!.should == {:tag => "value"}
-  end
-
-  it "should not remove root tag when include_root is true" do
-    markup = Builder::JsonMarkup.new(:include_root => true)
-    # XML :: <root><tag>value</tag></root>
-    markup.root do
-      markup.tag "value"
-    end
-    markup.target!.should == {:root => {:tag => "value"}}
-  end
-
-  it "should use default_content_key when both content and attributes are exist" do
-    markup = Builder::JsonMarkup.new
-    # XML :: <root><tag id="1">value</tag></root>
-    markup.root do
-      markup.tag("value", :id => 1)
-    end
-    markup.target!.should == {:tag => {:id => 1, :content => "value"}}
-  end
-
-  it "should use default_content_key when both cdata! and attributes are exist" do
-    markup = Builder::JsonMarkup.new
-    # XML :: <root><tag id="1"><![CDATA[value]]></tag></root>
-    markup.root do
-      markup.tag(:id => 1) do
-        markup.cdata! "value"
-      end
-    end
-    markup.target!.should == {:tag => {:id => 1, :content => "value"}}
-  end
-
-end
-
-describe Builder::JsonMarkup, "#array_mode" do
-
-  it "should support <<" do
-    markup = Builder::JsonMarkup.new
-    # XML ::
-    # <root>
-    #   <items>
-    #     <item>
-    #       <text>hello world 0</text>
-    #     </item>
-    #     <item>
-    #       <text>hello world 1</text>
-    #     </item>
-    #   </items>
-    # </root>
-    markup.root do
-      markup.items do
-        markup.array_mode do
-          2.times do |i|
-            _markup = Builder::JsonMarkup.new
-            markup << _markup.item do
-              _markup.text "hello world #{i}"
-            end
-          end
-        end
-      end
-    end
-    markup.target!.should == {
-      :items => [{:text => "hello world 0"}, {:text => "hello world 1"}]
-    }
-  end
-
-  it "should generate new key if needed" do
-    markup = Builder::JsonMarkup.new
-    # XML ::
-    # <root>
-    #   <items site="smart.fm">
-    #     <item>
-    #       <text>hello world 0</text>
-    #     </item>
-    #     <item>
-    #       <text>hello world 1</text>
-    #     </item>
-    #   </items>
-    # </root>
-    markup.root do
-      markup.items(:site => "smart.fm") do
-        markup.array_mode do
-          2.times do |i|
-            _markup = Builder::JsonMarkup.new
-            markup << _markup.item do
-              _markup.text "hello world #{i}"
-            end
-          end
-        end
-      end
-    end
-    markup.target!.should == {
-      :items => {
-        :entries => [{:text => "hello world 0"}, {:text=>"hello world 1"}],
-        :site=>"smart.fm"
-      }
-    }
-  end
-
-  it "should treat blank block as blank Array" do
-    # XML ::
-    # <root>
-    #   <items>
-    #   </items>
-    # </root>
-    markup = Builder::JsonMarkup.new
-    markup.root do
-      markup.items do
-        markup.array_mode do
-        end
-      end
-    end
-    markup.target!.should == {:items => []}
-  end
-
-  it "should not support all methods except <<"do
-    markup = Builder::JsonMarkup.new
-    # XML ::
-    # <root>
-    #   <items>
-    #     <item>
-    #       <text>hello world 0</text>
-    #     </item>
-    #     <item>
-    #       <text>hello world 1</text>
-    #     </item>
-    #   </items>
-    # </root>
-    succeeded = true
-    markup.root do
-      markup.items do
-        begin
-          markup.array_mode do
-            2.times do
-              markup.item do
-                markup.text "hello world"
-              end
-            end
-          end
-        rescue
-          succeeded = false
-        end
-      end
-    end
-    succeeded.should_not be_true
-  end
-
-end