jsonify 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jsonify.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Bill Siggelkow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Jsonify
+
+[Jsonify](https://github.com/bsiggelkow/jsonify) Jsonify is to JSON as [Builder](https://github.com/jimweirich/builder) is to XML.
+
+## Goal
+
+Jsonify provides a ___builder___ style engine for creating correct JSON representations of Ruby objects.
+
+Jsonify hooks into Rails ActionView to allow you to create JSON view templates in much the same way that you can use Builder for XML templates.
+
+## Motivation
+
+JSON and XML are without a doubt the most common representations used by RESTful applications. Jsonify was built around the notion that these representations belong in the ___view___ layer of the application.
+For XML representations, Rails makes this easy through its support of Builder templates, but, when it comes to JSON, there is no clear approach.
+
+___more coming soon___
+
+## Installation
+
+gem install jsonify
+
+## Usage
+
+### Standalone
+
+    # Create some objects that represent a person and associated hyperlinks
+    person = Struct.new(:first_name,:last_name).new('George','Burdell')
+    links = [
+      ['self',   'http://example.com/people/123'],
+      ['school', 'http://gatech.edu'],
+    ]
+
+    # Build this information as JSON
+    require 'jsonify'
+    json = Jsonify::Builder.new(:pretty => true)
+  
+    json.result do
+      json.alumnus do
+        json.fname person.first_name
+        json.lname person.last_name
+      end
+      json.links do
+        json.map!(links) do |link|
+          {:rel => link.first, :href => link.last}
+        end
+      end
+    end
+
+    # Evaluate the result to a string
+    json.compile!
+
+Results in ...
+
+    {
+      "result": {
+        "alumnus": {
+          "fname": "George",
+          "lname": "Burdell"
+        },
+        "links": [
+          {
+            "rel": "self",
+            "href": "http://example.com/people/123"
+          },
+          {
+            "rel": "school",
+            "href": "http://gatech.edu"
+          }
+        ]
+      }
+    }
+
+
+### View Templates
+
+___coming soon___
+
+## License
+
+This project is released under the MIT license.
+
+## Authors
+
+* [Bill Siggelkow](https://github.com/bsiggelkow)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/jsonify.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jsonify/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jsonify"
+  s.version     = Jsonify::VERSION
+  s.authors     = ["Bill Siggelkow"]
+  s.email       = ["bsiggelkow@me.com"]
+  s.homepage    = "http://github.com/bsiggelkow/jsonify"
+  s.summary     = %q{Turn Ruby objects into JSON}
+  s.description = %q{Turn Ruby objects into JSON -- correctly!}
+
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'json'
+  s.add_dependency "actionpack", "~> 3.0.0"
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'autotest'
+end

data/lib/blank_slate.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+######################################################################
+# BlankSlate provides an abstract base class with no predefined
+# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+# BlankSlate is useful as a base class when writing classes that
+# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+#
+class BlankSlate
+  class << self
+
+    # Hide the method named +name+ in the BlankSlate class.  Don't
+    # hide +instance_eval+ or any method beginning with "__".
+    def hide(name)
+      if instance_methods.include?(name.to_s) and
+        name !~ /^(__|instance_eval)/
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+
+    def find_hidden_method(name)
+      @hidden_methods ||= {}
+      @hidden_methods[name] || superclass.find_hidden_method(name)
+    end
+
+    # Redefine a previously hidden method so that it may be called on a blank
+    # slate object.
+    def reveal(name)
+      hidden_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless hidden_method
+      define_method(name, hidden_method)
+    end
+  end
+
+  instance_methods.each { |m| hide(m) }
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+#
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Kernel
+      BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+#
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Object
+      BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+#
+class Module
+  alias blankslate_original_append_features append_features
+  def append_features(mod)
+    result = blankslate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      BlankSlate.hide(name)
+    end
+    result
+  end
+end

data/lib/jsonify.rb

@@ -0,0 +1,7 @@
+require 'json'
+require 'blank_slate'
+require 'jsonify/version'
+require 'jsonify/json_value'
+require 'jsonify/generate'
+require 'jsonify/builder'
+require 'jsonify/rails'

data/lib/jsonify/builder.rb

@@ -0,0 +1,82 @@
+module Jsonify
+  class Builder < BlankSlate
+
+    def initialize(options={})
+      @verify = options[:verify].nil? ? false : options[:verify] 
+      @pretty = options[:pretty].nil? ? false : options[:pretty] 
+      reset!
+    end
+    
+    def reset!
+      @level = 0
+      @stack = []
+    end
+
+    # Builder-style methods
+    def tag!(sym, *args, &block)
+      method_missing(sym, *args, &block)
+    end
+    
+    def compile!
+      result = (@stack[0] ? @stack[0].evaluate : {}.to_json)
+      JSON.parse(result) if @verify
+      @pretty ? JSON.pretty_generate(JSON.parse(result)) : result
+    end
+    
+    def add!(value)
+      __current.add Generate.value(value)
+    end
+    
+    def method_missing(sym, *args, &block)
+      if block        
+        pair = Generate.pair_value(sym)
+        __current.add(pair)
+        @level += 1
+          block.call(self)
+          pair.value = __current
+        @level -= 1
+      else
+        if sym && args && args.length > 0
+          __current.add Generate.pair_value(sym, args.length > 1 ? args : args.first)
+        end
+        __current
+      end
+    end
+    
+    def object!
+      __set_current JsonObject.new
+      yield __current
+    end
+    
+    def array!
+      __set_current JsonArray.new
+      @level += 1
+        yield @stack[@level-1]
+      @level -= 1
+      __current
+    end
+
+    def map!(array)
+      __set_current JsonArray.new
+      array.each do |item|
+        __current << (yield item)
+      end
+      __current
+    end
+    
+    alias_method :collect!, :map!
+    
+    private
+    
+    # Inheriting from BlankSlate requires these funky (aka non-idiomatic) method names
+
+    def __current
+      @stack[@level] ||= JsonObject.new
+    end
+
+    def __set_current(val)
+      @stack[@level] = val
+    end
+    
+  end
+end

data/lib/jsonify/generate.rb

@@ -0,0 +1,58 @@
+module Jsonify
+  module Generate
+
+    class << self
+      
+      def value(val)
+        case val
+          when JsonValue; val
+          when String; string_value val
+          when Numeric; number_value val
+          when TrueClass; true_value
+          when FalseClass; false_value
+          when NilClass; null_value
+          when Array; array_value val
+          when Hash; object_value val
+          else string_value val
+        end
+      end
+    
+      def pair_value(key,val=nil)
+        JsonPair.new(key,value(val))
+      end
+    
+      def string_value(val)
+        JsonString.new(val)
+      end
+
+      def object_value(hash)
+        json_object = JsonObject.new
+        hash.each { |key,val| json_object.add( pair_value(key, val) ) }
+        json_object
+      end
+    
+      def array_value(vals)
+        JsonArray.new(Array(vals).map{ |v| value v })
+      end
+    
+      def number_value(val)
+        JsonNumber.new(val)
+      end
+
+      def true_value
+        @json_true ||= JsonTrue.new # memoize
+      end
+
+      def false_value
+        @json_false ||= JsonFalse.new # memoize
+      end
+
+      def null_value
+        @json_null ||= JsonNull.new # memoize
+      end
+
+    end
+
+  end
+
+end

data/lib/jsonify/json_value.rb

@@ -0,0 +1,110 @@
+module Jsonify
+  class JsonValue
+    attr_accessor :values
+
+    def initialize(values=nil)
+      @values = values || []
+    end
+    
+    def evaluate
+      wrap values.map {|v| v.evaluate}.join(',')
+    end
+    
+    def add(jsonValue)
+      values << Generate.value(jsonValue)
+    end
+
+  end
+  
+  class JsonObject < JsonValue
+    def initialize(values=nil)
+      @values = values || {}
+    end
+
+    def wrap(joined_values)
+      "{#{joined_values}}"
+    end
+
+    def values
+      @values.values
+    end
+
+    def add(val)
+      raise ArgumentError.new("Cannot add #{val} to JsonOject") unless (Array === val || JsonPair === val)       
+      val = JsonPair.new(val.shift, val.length <= 1 ? val.first : val) if Array === val
+      @values.store(val.key, val)
+    end
+
+    alias_method :<<, :add
+
+  end
+
+  class JsonArray < JsonValue
+    
+    def wrap(joined_values)
+      "[#{joined_values}]"
+    end
+    
+    def add(value)
+      if JsonPair === value # wrap JsonPair in a JsonObject
+        object = JsonObject.new
+        object.add value
+        value = object
+      end
+      super(value)
+    end
+
+    alias_method :<<, :add
+    
+  end
+  
+  class JsonPair < JsonValue
+    attr_accessor :key, :value
+    def initialize(key, value=nil)
+      @key = key.to_s
+      @value = Generate.value(value)
+    end
+    def evaluate
+      %Q{#{key.to_json}:#{value.evaluate}}
+    end
+  end
+  
+  class JsonString < JsonValue
+    attr_accessor :value
+    def initialize(value)
+      @value = value.to_s
+    end
+    def evaluate
+      value.to_json
+    end
+  end
+  
+  class JsonNumber < JsonValue
+    attr_accessor :value
+    def initialize(value)
+      @value = value
+    end
+    def evaluate
+      value
+    end
+  end
+
+  class JsonTrue < JsonValue
+    def evaluate
+      'true'
+    end
+  end
+  
+  class JsonFalse < JsonValue
+    def evaluate
+      'false'
+    end
+  end
+  
+  class JsonNull < JsonValue
+    def evaluate
+      'null'
+    end
+  end
+  
+end

data/lib/jsonify/rails.rb

@@ -0,0 +1,19 @@
+require 'action_view'
+
+module ActionView
+  module Template::Handlers
+    class JsonifyBuilder < Template::Handler
+      include Compilable
+
+      self.default_format = Mime::JSON
+
+      def compile(template)
+        "json = ::Jsonify::Builder.new();" +
+          template.source +
+        ";json.compile!;"
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler :jsonify, ActionView::Template::Handlers::JsonifyBuilder

data/lib/jsonify/version.rb

@@ -0,0 +1,3 @@
+module Jsonify
+  VERSION = "0.0.1"
+end

data/spec/builder_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe Jsonify::Builder do
+
+  let(:json) { Jsonify::Builder.new }
+
+  describe 'base behavior' do
+    describe 'should render empty object on literal' do
+      it 'after initialization' do
+        json.compile!.should == "{}"
+      end
+      it 'after reset' do
+        json.foo 'bar'
+        json.reset!
+        json.compile!.should == "{}"
+      end
+    end
+    describe 'with verify set' do
+      it 'should report a parse error if the result is not parseable' do
+        json = Jsonify::Builder.new(:verify => true)
+        # Hackery to come up with a failing case
+        class FooBar
+          def evaluate
+            "foobar"
+          end
+        end
+        json.instance_variable_set(:@stack, [FooBar.new])
+        lambda{ json.compile! }.should raise_error(JSON::ParserError)
+      end
+    end
+    describe 'unicode characters' do
+      it 'should properly encode' do
+        json = Jsonify::Builder.new(:verify => true)
+        json.foo 'bar'.concat(16)
+        lambda { json.compile! }.should_not raise_error
+      end
+    end
+    describe "pretty printing" do
+      it "should not be pretty by default" do
+        json.foo do
+          json.bar 'baz'
+        end
+        non_pretty_results = '{"foo":{"bar":"baz"}}'
+        json.compile!.should == non_pretty_results
+      end
+      it "should be pretty when asked for" do
+        json = Jsonify::Builder.new(:pretty => true)
+        json.foo do
+          json.bar 'baz'
+        end
+        pretty_results = <<PRETTY_JSON
+{
+  "foo": {
+    "bar": "baz"
+  }
+}
+PRETTY_JSON
+        json.compile!.should == pretty_results.chomp
+      end
+    end
+  end
+  
+  describe 'arrays' do
+    it 'simple array should work' do
+      json.array! do |ary|
+        ary << 1
+        ary << 2
+      end
+      json.compile!.should == "[1,2]"
+    end
+    it 'array of arrays should work' do
+      json.array! do |ary|
+        ary << json.array! {|a| a << 1}
+        ary << json.array! {|b| b << 2}
+        ary << 3
+      end
+      json.compile!.should == "[[1],[2],3]"
+    end
+    it 'array of hashes should work' do
+      json.array! do |ary|
+        ary << {foo: :bar}
+        ary << {go:  :far}
+      end
+      json.compile!.should == "[{\"foo\":\"bar\"},{\"go\":\"far\"}]"
+    end
+  end
+  
+  describe 'objects' do
+    it 'simple object should work' do
+      json.object! do |obj|
+        obj << [:foo,:bar]
+        obj << [:go, :far]
+      end
+      json.compile!.should ==  "{\"foo\":\"bar\",\"go\":\"far\"}"
+    end
+    it 'should treat the first element of an array as a key' do
+      json.object! do |obj|
+        obj << [1, 2, 3]
+        obj << [4, 5]
+      end
+      json.compile!.should ==  '{"1":[2,3],"4":5}'
+    end
+  end
+  
+  describe 'using blocks' do
+    
+    it 'complex hash' do
+      json.foo do
+        json.bar do
+          json.baz 'goo'
+        end
+      end
+      json.compile!.should == "{\"foo\":{\"bar\":{\"baz\":\"goo\"}}}"
+    end
+    it 'simple hash' do
+      json.foo do
+        json.baz :goo
+      end
+      json.compile!.should == "{\"foo\":{\"baz\":\"goo\"}}"
+    end
+    it 'hash with array' do
+      json.foo do
+        json.array! do |ary|
+          ary << 1
+          ary << 2
+        end
+      end
+      json.compile!.should == "{\"foo\":[1,2]}"
+    end
+    
+    it 'simple array with object' do
+      json.array! do |ary|
+        ary << 1
+        ary << (json.foo 'bar')
+      end
+      json.compile!.should == "[1,{\"foo\":\"bar\"}]"
+    end
+
+    it 'complex hash with array' do
+      json.foo do
+        json.bar do
+          json.baz 'goo'
+          json.years do
+            json.array! do |ary|
+              ary << 2011
+              ary << 2012
+            end
+          end
+        end
+      end
+      json.compile!.should == "{\"foo\":{\"bar\":{\"baz\":\"goo\",\"years\":[2011,2012]}}}"
+    end
+  end
+  
+  describe 'without blocks' do
+    describe 'complex array' do
+      it 'should work' do
+        json.bar [1,2,{:foo => 'goo'}]
+        json.compile!.should == "{\"bar\":[1,2,{\"foo\":\"goo\"}]}"
+      end
+    end
+  end
+  
+  describe 'super complex example' do
+    let(:links) { 
+      link_class = Struct.new(:url,:type)
+      [ 
+        link_class.new('example.com', 'self'),
+        link_class.new('foo.com',     'parent')
+      ]
+    }
+    it 'should work using array!' do
+      json.result do
+        json.person do
+          json.fname 'George'
+          json.lname 'Burdell'
+        end
+        json.links do
+          json.array! do |ary|
+            links.each do |link|
+              ary << { href: link.url, rel: link.type}
+            end
+          end
+        end
+      end
+      expected = "{\"result\":{\"person\":{\"fname\":\"George\",\"lname\":\"Burdell\"},\"links\":[{\"href\":\"example.com\",\"rel\":\"self\"},{\"href\":\"foo.com\",\"rel\":\"parent\"}]}}"
+      json.compile!.should == expected
+    end
+
+    [:map!, :collect!].each do |method|
+      it "should work using #{method} with argument" do
+        json.result do
+          json.person do
+            json.fname 'George'
+            json.lname 'Burdell'
+          end
+          json.links do
+            json.send(method,links) do |link|
+              { href: link.url, rel: link.type}
+            end
+          end
+        end
+        expected = "{\"result\":{\"person\":{\"fname\":\"George\",\"lname\":\"Burdell\"},\"links\":[{\"href\":\"example.com\",\"rel\":\"self\"},{\"href\":\"foo.com\",\"rel\":\"parent\"}]}}"
+        json.compile!.should == expected
+      end
+    end
+  end
+  
+  
+end

data/spec/generate_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Jsonify::Generate do
+  let(:links) do
+    { :links => 
+       [
+         {:rel => 'foo', :href => 'goo'},
+         {:rel => 'bar', :href => 'baz'}
+       ]
+    }
+  end
+  it 'should build json' do
+    json = Jsonify::Generate
+    result = json.value links
+    result.evaluate.should == '{"links":[{"rel":"foo","href":"goo"},{"rel":"bar","href":"baz"}]}'
+  end
+
+  describe 'complex example' do
+    let(:jsonifier) { Jsonify::Generate }
+    
+    it 'should work' do
+      json = jsonifier.object_value( 
+        {"links" =>
+          jsonifier.array_value([
+            jsonifier.object_value( {"rel" => "foo", "href" => "goo"} ),
+            jsonifier.object_value( {"rel" => "bar", "href" => "baz"} )
+          ])
+        }
+      )
+      json.evaluate.should == "{\"links\":[{\"rel\":\"foo\",\"href\":\"goo\"},{\"rel\":\"bar\",\"href\":\"baz\"}]}"
+    end
+  end
+end

data/spec/json_value_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Jsonify::JsonValue do
+  describe Jsonify::JsonPair do
+    let(:pair) { Jsonify::JsonPair.new('key',Jsonify::JsonString.new('value')) }
+    it 'should be constructed of a key and value' do
+      pair.key.should == 'key'
+      # pair.value.should == 
+    end
+    it 'should evaluate to key:value' do
+      pair.evaluate.should == "\"key\":\"value\""
+    end
+  end
+  
+end

data/spec/jsonify_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+describe Jsonify do
+  it('should be true') {true.should be_true}
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler'
+require 'bundler/setup'
+require 'jsonify'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: jsonify
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Bill Siggelkow
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: Turn Ruby objects into JSON -- correctly!
+email: 
+- bsiggelkow@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- jsonify.gemspec
+- lib/blank_slate.rb
+- lib/jsonify.rb
+- lib/jsonify/builder.rb
+- lib/jsonify/generate.rb
+- lib/jsonify/json_value.rb
+- lib/jsonify/rails.rb
+- lib/jsonify/version.rb
+- spec/builder_spec.rb
+- spec/generate_spec.rb
+- spec/json_value_spec.rb
+- spec/jsonify_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/bsiggelkow/jsonify
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3514387947205950198
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3514387947205950198
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: jsonify
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Turn Ruby objects into JSON
+test_files: 
+- spec/builder_spec.rb
+- spec/generate_spec.rb
+- spec/json_value_spec.rb
+- spec/jsonify_spec.rb
+- spec/spec_helper.rb