crack 0.3.2 → 0.4.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem
+/.bundle

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec
+
+gem "rake"
+gem "jnunemaker-matchy"
+gem "minitest"

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    crack (0.3.2)
+      safe_yaml (~> 0.9.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    jnunemaker-matchy (0.4.0)
+    minitest (5.0.3)
+    rake (10.0.3)
+    safe_yaml (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  crack!
+  jnunemaker-matchy
+  minitest
+  rake

data/README.md

@@ -0,0 +1,44 @@
+# crack
+
+Really simple JSON and XML parsing, ripped from Merb and Rails. The XML parser is ripped from Merb and the JSON parser is ripped from Rails. I take no credit, just packaged them for all to enjoy and easily use.
+
+## compatibility
+
+* ruby 1.8.7
+* ruby 1.9+ (3 failures related to time parsing, would love it if someone could figure them out)
+
+## note on patches/pull requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* `script/test` - this will bootstrap and run the tests
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## usage
+  
+```ruby
+gem 'crack' # in Gemfile
+require 'crack' # for xml and json
+require 'crack/json' # for just json
+require 'crack/xml' # for just xml
+```
+
+## examples
+  
+```ruby
+Crack::XML.parse("<tag>This is the contents</tag>")
+# => {'tag' => 'This is the contents'}
+
+Crack::JSON.parse('{"tag":"This is the contents"}')
+# => {'tag' => 'This is the contents'}
+```
+
+## Copyright
+
+Copyright (c) 2009 John Nunemaker. See LICENSE for details.
+
+## Docs
+
+http://rdoc.info/projects/jnunemaker/crack

data/crack.gemspec

@@ -1,53 +1,20 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+require File.expand_path('../lib/crack/version', __FILE__)
 
-Gem::Specification.new do |s|
-  s.name = "crack"
-  s.version = "0.3.2"
+Gem::Specification.new do |gem|
+  gem.authors       = ["John Nunemaker"]
+  gem.email         = ["nunemaker@gmail.com"]
+  gem.description   = %q{Really simple JSON and XML parsing, ripped from Merb and Rails.}
+  gem.summary       = %q{Really simple JSON and XML parsing, ripped from Merb and Rails.}
+  gem.homepage      = "http://github.com/jnunemaker/crack"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["John Nunemaker", "Wynn Netherland"]
-  s.date = "2013-01-09"
-  s.email = "nunemaker@gmail.com"
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.rdoc"
-  ]
-  s.files = [
-    "History",
-    "LICENSE",
-    "README.rdoc",
-    "Rakefile",
-    "crack.gemspec",
-    "lib/crack.rb",
-    "lib/crack/json.rb",
-    "lib/crack/util.rb",
-    "lib/crack/xml.rb",
-    "test/crack_test.rb",
-    "test/data/twittersearch-firefox.json",
-    "test/data/twittersearch-ie.json",
-    "test/hash_test.rb",
-    "test/json_test.rb",
-    "test/parser_test.rb",
-    "test/string_test.rb",
-    "test/test_helper.rb",
-    "test/xml_test.rb"
-  ]
-  s.homepage = "http://github.com/jnunemaker/crack"
-  s.require_paths = ["lib"]
-  s.rubyforge_project = "crack"
-  s.rubygems_version = "1.8.10"
-  s.summary = "Really simple JSON and XML parsing, ripped from Merb and Rails."
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "crack"
+  gem.require_paths = ["lib"]
+  gem.version       = Crack::VERSION
+  gem.license       = "MIT"
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  gem.add_dependency "safe_yaml", "~> 0.9.0"
 end
-

data/lib/crack.rb

@@ -1,5 +1,4 @@
 module Crack
-  VERSION = "0.3.2"
   class ParseError < StandardError; end
 end
 

data/lib/crack/json.rb

@@ -8,9 +8,23 @@ require 'strscan'
 
 module Crack
   class JSON
+    def self.parser_exceptions
+      @parser_exceptions ||= begin
+        exceptions = [ArgumentError]
+
+        if const_defined?(:Psych)
+          if Psych.const_defined?(:SyntaxError)
+            exceptions << Psych::SyntaxError
+          end
+        end
+
+        exceptions
+      end
+    end
+
     def self.parse(json)
       YAML.load(unescape(convert_json_to_yaml(json)))
-    rescue ArgumentError => e
+    rescue *parser_exceptions
       raise ParseError, "Invalid JSON string"
     end
 

data/lib/crack/version.rb

@@ -0,0 +1,3 @@
+module Crack
+  VERSION = "0.4.0"
+end

data/lib/crack/xml.rb

@@ -2,11 +2,19 @@ require 'rexml/parsers/streamparser'
 require 'rexml/parsers/baseparser'
 require 'rexml/light/node'
 require 'rexml/text'
+require "rexml/document"
 require 'date'
 require 'time'
 require 'yaml'
 require 'bigdecimal'
 
+# The Reason behind redefining the String Class for this specific plugin is to
+# avoid the dynamic insertion of stuff on it (see version previous to this commit).
+# Doing that disables the possibility of efectuating a dump on the structure. This way it goes.
+class REXMLUtiliyNodeString < String
+  attr_accessor :attributes
+end
+
 # This is a slighly modified version of the XMLUtilityNode from
 # http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
 # It's mainly just adding vowels, as I ht cd wth n vwls :)
@@ -68,7 +76,8 @@ class REXMLUtilityNode #:nodoc:
   end
 
   def to_hash
-    if @type == "file"
+    # ACG: Added a check here to prevent an exception a type == "file" tag has nodes within it
+    if @type == "file" and (@children.first.nil? or @children.first.is_a?(String))
       f = StringIO.new((@children.first || '').unpack('m').first)
       class << f
         attr_accessor :original_filename, :content_type
@@ -81,9 +90,7 @@ class REXMLUtilityNode #:nodoc:
     if @text
       t = typecast_value( unnormalize_xml_entities( inner_html ) )
       if t.is_a?(String)
-        class << t
-          attr_accessor :attributes
-        end
+        t = REXMLUtiliyNodeString.new(t)
         t.attributes = attributes
       end
       return { name => t }
@@ -187,7 +194,7 @@ class REXMLUtilityNode #:nodoc:
 end
 
 module Crack
-	class REXMLParser
+  class REXMLParser
     def self.parse(xml)
       stack = []
       parser = REXML::Parsers::BaseParser.new(xml)
@@ -210,6 +217,7 @@ module Crack
           stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
         end
       end
+
       stack.length > 0 ? stack.pop.to_hash : {}
     end
   end

data/script/bootstrap

@@ -0,0 +1,21 @@
+#!/bin/sh
+#/ Usage: bootstrap [bundle options]
+#/
+#/ Bundle install the dependencies.
+#/
+#/ Examples:
+#/
+#/   bootstrap
+#/   bootstrap --local
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
+rm -rf .bundle/{binstubs,config}
+bundle install --binstubs .bundle/binstubs --path .bundle --quiet "$@"

data/script/release

@@ -0,0 +1,42 @@
+#!/bin/sh
+#/ Usage: release
+#/
+#/ Tag the version in the repo and push the gem.
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
+gem_name=crack
+
+# Build a new gem archive.
+rm -rf $gem_name-*.gem
+gem build -q $gem_name.gemspec
+
+# Make sure we're on the master branch.
+(git branch | grep -q '* master') || {
+  echo "Only release from the master branch."
+  exit 1
+}
+
+# Figure out what version we're releasing.
+tag=v`ls $gem_name-*.gem | sed "s/^$gem_name-\(.*\)\.gem$/\1/"`
+
+echo "Releasing $tag"
+
+# Make sure we haven't released this version before.
+git fetch -t origin
+
+(git tag -l | grep -q "$tag") && {
+  echo "Whoops, there's already a '${tag}' tag."
+  exit 1
+}
+
+# Tag it and bag it.
+gem push $gem_name-*.gem && git tag "$tag" &&
+  git push origin master && git push origin "$tag"

data/script/test

@@ -0,0 +1,25 @@
+#!/bin/sh
+#/ Usage: test [individual test file]
+#/
+#/ Bootstrap and run all tests or an individual test.
+#/
+#/ Examples:
+#/
+#/   # run all tests
+#/   test
+#/
+#/   # run individual test
+#/   test test/controller_instrumentation_test.rb
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
+script/bootstrap && ruby -I lib -I test -r rubygems \
+  -e 'require "bundler/setup"' \
+  -e '(ARGV.empty? ? Dir["test/**/*_test.rb"] : ARGV).each { |f| load f }' -- "$@"

data/test/hash_test.rb

@@ -1,28 +1,26 @@
 require 'test_helper'
 
-class CrackTest < Test::Unit::TestCase
-  context "to_xml_attributes" do
-    setup do
-      @hash = { :one => "ONE", "two" => "TWO", :three => "it \"should\" work" }
-    end
+describe "Crack::Util.to_xml_attributes" do
+  before do
+    @hash = { :one => "ONE", "two" => "TWO", :three => "it \"should\" work" }
+  end
 
-    should "turn the hash into xml attributes" do
-      attrs = Crack::Util.to_xml_attributes(@hash)
-      attrs.should =~ /one="ONE"/m
-      attrs.should =~ /two="TWO"/m
-      attrs.should =~ /three="it &quot;should&quot; work"/m
-    end
+  it "turn the hash into xml attributes" do
+    attrs = Crack::Util.to_xml_attributes(@hash)
+    attrs.must_match /one="ONE"/m
+    attrs.must_match /two="TWO"/m
+    attrs.must_match /three="it &quot;should&quot; work"/m
+  end
 
-    should 'preserve _ in hash keys' do
-      attrs = Crack::Util.to_xml_attributes({
-        :some_long_attribute => "with short value",
-        :crash               => :burn,
-        :merb                => "uses extlib"
-      })
+  it "preserve _ in hash keys" do
+    attrs = Crack::Util.to_xml_attributes({
+      :some_long_attribute => "with short value",
+      :crash               => :burn,
+      :merb                => "uses extlib"
+    })
 
-      attrs.should =~ /some_long_attribute="with short value"/
-      attrs.should =~ /merb="uses extlib"/
-      attrs.should =~ /crash="burn"/
-    end
+    attrs.must_match /some_long_attribute="with short value"/
+    attrs.must_match /merb="uses extlib"/
+    attrs.must_match /crash="burn"/
   end
 end

data/test/json_test.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 require 'test_helper'
 
-class JsonTest < Test::Unit::TestCase  
+describe "JSON Parsing" do
   TESTS = {
     %q({"data": "G\u00fcnter"})                   => {"data" => "Günter"},
 		%q({"html": "\u003Cdiv\\u003E"})              => {"html" => "<div>"},
@@ -11,14 +11,14 @@ class JsonTest < Test::Unit::TestCase
     %q({"returnTo":{"\/categories":1}})           => {"returnTo" => {"/categories" => 1}},
     %({"returnTo":[1,"a"]})                       => {"returnTo" => [1, "a"]},
     %({"returnTo":[1,"\\"a\\",", "b"]})           => {"returnTo" => [1, "\"a\",", "b"]},
-    %({a: "'", "b": "5,000"})                     => {"a" => "'", "b" => "5,000"},
-    %({a: "a's, b's and c's", "b": "5,000"})      => {"a" => "a's, b's and c's", "b" => "5,000"},
-    %({a: "2007-01-01"})                          => {'a' => Date.new(2007, 1, 1)}, 
-    %({a: "2007-01-01 01:12:34 Z"})               => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)}, 
+    %({"a": "'", "b": "5,000"})                   => {"a" => "'", "b" => "5,000"},
+    %({"a": "a's, b's and c's", "b": "5,000"})    => {"a" => "a's, b's and c's", "b" => "5,000"},
+    %({"a": "2007-01-01"})                        => {'a' => Date.new(2007, 1, 1)},
+    %({"a": "2007-01-01 01:12:34 Z"})             => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)},
     # Handle ISO 8601 date/time format http://en.wikipedia.org/wiki/ISO_8601
-    %({a: "2007-01-01T01:12:34Z"})                => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)},
+    %({"a": "2007-01-01T01:12:34Z"})              => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)},
     # no time zone
-    %({a: "2007-01-01 01:12:34"})                 => {'a' => "2007-01-01 01:12:34"},
+    %({"a": "2007-01-01 01:12:34"})               => {'a' => "2007-01-01 01:12:34"},
     %({"bio": "1985-01-29: birthdate"})           => {'bio' => '1985-01-29: birthdate'},
     %({"regex": /foo.*/})                         => {'regex' => /foo.*/},
     %({"regex": /foo.*/i})                        => {'regex' => /foo.*/i},
@@ -42,41 +42,34 @@ class JsonTest < Test::Unit::TestCase
     %q({"foo":"bar\x00"}) => {"foo" => "bar\x00"},
     %q({"foo":"bar\x00baz"}) => {"foo" => "bar\x00baz"}
   }
-  
+
   TESTS.each do |json, expected|
-    should "decode json (#{json})" do
-      lambda {
-        Crack::JSON.parse(json).should == expected
-      }.should_not raise_error
+    it "decode json (#{json})" do
+      Crack::JSON.parse(json).must_equal expected
     end
   end
 
-  should "raise error for failed decoding" do
-    lambda {
+  it "raise error for failed decoding" do
+    assert_raises(Crack::ParseError) {
       Crack::JSON.parse(%({: 1}))
-    }.should raise_error(Crack::ParseError)
+    }
   end
-  
-  should "be able to parse a JSON response from a Twitter search about 'firefox'" do
+
+  it "be able to parse a JSON response from a Twitter search about 'firefox'" do
     data = ''
     File.open(File.dirname(__FILE__) + "/data/twittersearch-firefox.json", "r") { |f|
         data = f.read
     }
-    
-    lambda {
-      Crack::JSON.parse(data)
-    }.should_not raise_error(Crack::ParseError)
+
+    Crack::JSON.parse(data)
   end
 
-  should "be able to parse a JSON response from a Twitter search about 'internet explorer'" do
+  it "be able to parse a JSON response from a Twitter search about 'internet explorer'" do
     data = ''
     File.open(File.dirname(__FILE__) + "/data/twittersearch-ie.json", "r") { |f|
         data = f.read
     }
-    
-    lambda {
-      Crack::JSON.parse(data)
-    }.should_not raise_error(Crack::ParseError)
-  end
 
+    Crack::JSON.parse(data)
+  end
 end

data/test/parser_test.rb

@@ -1,26 +1,26 @@
 require 'test_helper'
 
-class ParserTest < Test::Unit::TestCase
-  should "default to REXMLParser" do
-    Crack::XML.parser.should == Crack::REXMLParser
+describe Crack::XML do
+  it "default to REXMLParser" do
+    Crack::XML.parser.must_equal Crack::REXMLParser
   end
 
-  context "with a custom Parser" do
-	  class CustomParser
-			def self.parse(xml)
-				xml
-			end
-		end
+  describe "with a custom Parser" do
+    class CustomParser
+      def self.parse(xml)
+        xml
+      end
+    end
 
-    setup do
+    before do
       Crack::XML.parser = CustomParser
     end
 
-    should "use the custom Parser" do
-			Crack::XML.parse("<xml/>").should == "<xml/>"
+    it "use the custom Parser" do
+      Crack::XML.parse("<xml/>").must_equal "<xml/>"
     end
 
-    teardown do
+    after do
       Crack::XML.parser = nil
     end
   end

data/test/string_test.rb

@@ -1,31 +1,31 @@
 require 'test_helper'
 
-class CrackTest < Test::Unit::TestCase
-  context "snake_case" do
-    should "lowercases one word CamelCase" do
-      Crack::Util.snake_case("Merb").should == "merb"
+describe Crack::Util do
+  describe "snake_case" do
+    it "lowercases one word CamelCase" do
+      Crack::Util.snake_case("Merb").must_equal "merb"
     end
 
-    should "makes one underscore snake_case two word CamelCase" do
-      Crack::Util.snake_case("MerbCore").should == "merb_core"
+    it "makes one underscore snake_case two word CamelCase" do
+      Crack::Util.snake_case("MerbCore").must_equal "merb_core"
     end
 
-    should "handles CamelCase with more than 2 words" do
-      Crack::Util.snake_case("SoYouWantContributeToMerbCore").should == "so_you_want_contribute_to_merb_core"
+    it "handles CamelCase with more than 2 words" do
+      Crack::Util.snake_case("SoYouWantContributeToMerbCore").must_equal "so_you_want_contribute_to_merb_core"
     end
 
-    should "handles CamelCase with more than 2 capital letter in a row" do
-      Crack::Util.snake_case("CNN").should == "cnn"
-      Crack::Util.snake_case("CNNNews").should == "cnn_news"
-      Crack::Util.snake_case("HeadlineCNNNews").should == "headline_cnn_news"
+    it "handles CamelCase with more than 2 capital letter in a row" do
+      Crack::Util.snake_case("CNN").must_equal "cnn"
+      Crack::Util.snake_case("CNNNews").must_equal "cnn_news"
+      Crack::Util.snake_case("HeadlineCNNNews").must_equal "headline_cnn_news"
     end
 
-    should "does NOT change one word lowercase" do
-      Crack::Util.snake_case("merb").should == "merb"
+    it "does NOT change one word lowercase" do
+      Crack::Util.snake_case("merb").must_equal "merb"
     end
 
-    should "leaves snake_case as is" do
-      Crack::Util.snake_case("merb_core").should == "merb_core"
+    it "leaves snake_case as is" do
+      Crack::Util.snake_case("merb_core").must_equal "merb_core"
     end
   end
-end
+end

data/test/test_helper.rb

@@ -1,12 +1,3 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-gem 'jnunemaker-matchy', '>= 0.4.0'
-require 'matchy'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'pp'
+require 'minitest/autorun'
 require 'crack'
-
-class Test::Unit::TestCase
-end

data/test/xml_test.rb

@@ -1,12 +1,12 @@
 require 'test_helper'
 
-class XmlTest < Test::Unit::TestCase
-  should "should transform a simple tag with content" do
+describe Crack::XML do
+  it "should transform a simple tag with content" do
     xml = "<tag>This is the contents</tag>"
-    Crack::XML.parse(xml).should == { 'tag' => 'This is the contents' }
+    Crack::XML.parse(xml).must_equal({ 'tag' => 'This is the contents' })
   end
 
-  should "should work with cdata tags" do
+  it "should work with cdata tags" do
     xml = <<-END
       <tag>
       <![CDATA[
@@ -14,16 +14,16 @@ class XmlTest < Test::Unit::TestCase
       ]]>
       </tag>
     END
-    Crack::XML.parse(xml)["tag"].strip.should == "text inside cdata"
+    Crack::XML.parse(xml)["tag"].strip.must_equal "text inside cdata"
   end
 
-  should "should transform a simple tag with attributes" do
+  it "should transform a simple tag with attributes" do
     xml = "<tag attr1='1' attr2='2'></tag>"
     hash = { 'tag' => { 'attr1' => '1', 'attr2' => '2' } }
-    Crack::XML.parse(xml).should == hash
+    Crack::XML.parse(xml).must_equal hash
   end
 
-  should "should transform repeating siblings into an array" do
+  it "should transform repeating siblings into an array" do
     xml =<<-XML
       <opt>
         <user login="grep" fullname="Gary R Epstein" />
@@ -31,7 +31,7 @@ class XmlTest < Test::Unit::TestCase
       </opt>
     XML
 
-    Crack::XML.parse(xml)['opt']['user'].class.should == Array
+    Crack::XML.parse(xml)['opt']['user'].class.must_equal Array
 
     hash = {
       'opt' => {
@@ -45,17 +45,17 @@ class XmlTest < Test::Unit::TestCase
       }
     }
 
-    Crack::XML.parse(xml).should == hash
+    Crack::XML.parse(xml).must_equal hash
   end
 
-  should "should not transform non-repeating siblings into an array" do
+  it "should not transform non-repeating siblings into an array" do
     xml =<<-XML
       <opt>
         <user login="grep" fullname="Gary R Epstein" />
       </opt>
     XML
 
-    Crack::XML.parse(xml)['opt']['user'].class.should == Hash
+    Crack::XML.parse(xml)['opt']['user'].class.must_equal Hash
 
     hash = {
       'opt' => {
@@ -66,11 +66,11 @@ class XmlTest < Test::Unit::TestCase
       }
     }
 
-    Crack::XML.parse(xml).should == hash
+    Crack::XML.parse(xml).must_equal hash
   end
 
-  context "Parsing xml with text and attributes" do
-    setup do
+  describe "Parsing xml with text and attributes" do
+    before do
       xml =<<-XML
         <opt>
           <user login="grep">Gary R Epstein</user>
@@ -80,60 +80,60 @@ class XmlTest < Test::Unit::TestCase
       @data = Crack::XML.parse(xml)
     end
 
-    should "correctly parse text nodes" do
-      @data.should == {
+    it "correctly parse text nodes" do
+      @data.must_equal({
         'opt' => {
           'user' => [
             'Gary R Epstein',
             'Simon T Tyson'
           ]
         }
-      }
+      })
     end
 
-    should "be parse attributes for text node if present" do
-      @data['opt']['user'][0].attributes.should == {'login' => 'grep'}
+    it "be parse attributes for text node if present" do
+      @data['opt']['user'][0].attributes.must_equal({'login' => 'grep'})
     end
 
-    should "default attributes to empty hash if not present" do
-      @data['opt']['user'][1].attributes.should == {}
+    it "default attributes to empty hash if not present" do
+      @data['opt']['user'][1].attributes.must_equal({})
     end
 
-    should "add 'attributes' accessor methods to parsed instances of String" do
-      @data['opt']['user'][0].respond_to?(:attributes).should be(true)
-      @data['opt']['user'][0].respond_to?(:attributes=).should be(true)
+    it "add 'attributes' accessor methods to parsed instances of String" do
+      @data['opt']['user'][0].respond_to?(:attributes).must_equal(true)
+      @data['opt']['user'][0].respond_to?(:attributes=).must_equal(true)
     end
 
-    should "not add 'attributes' accessor methods to all instances of String" do
-      "some-string".respond_to?(:attributes).should be(false)
-      "some-string".respond_to?(:attributes=).should be(false)
+    it "not add 'attributes' accessor methods to all instances of String" do
+      "some-string".respond_to?(:attributes).must_equal(false)
+      "some-string".respond_to?(:attributes=).must_equal(false)
     end
   end
 
-  should "should typecast an integer" do
+  it "should typecast an integer" do
     xml = "<tag type='integer'>10</tag>"
-    Crack::XML.parse(xml)['tag'].should == 10
+    Crack::XML.parse(xml)['tag'].must_equal 10
   end
 
-  should "should typecast a true boolean" do
+  it "should typecast a true boolean" do
     xml = "<tag type='boolean'>true</tag>"
-    Crack::XML.parse(xml)['tag'].should be(true)
+    Crack::XML.parse(xml)['tag'].must_equal(true)
   end
 
-  should "should typecast a false boolean" do
+  it "should typecast a false boolean" do
     ["false"].each do |w|
-      Crack::XML.parse("<tag type='boolean'>#{w}</tag>")['tag'].should be(false)
+      Crack::XML.parse("<tag type='boolean'>#{w}</tag>")['tag'].must_equal(false)
     end
   end
 
-  should "should typecast a datetime" do
+  it "should typecast a datetime" do
     xml = "<tag type='datetime'>2007-12-31 10:32</tag>"
-    Crack::XML.parse(xml)['tag'].should == Time.parse( '2007-12-31 10:32' ).utc
+    Crack::XML.parse(xml)['tag'].must_equal Time.parse( '2007-12-31 10:32' ).utc
   end
 
-  should "should typecast a date" do
+  it "should typecast a date" do
     xml = "<tag type='date'>2007-12-31</tag>"
-    Crack::XML.parse(xml)['tag'].should == Date.parse('2007-12-31')
+    Crack::XML.parse(xml)['tag'].must_equal Date.parse('2007-12-31')
   end
 
   xml_entities = {
@@ -143,57 +143,57 @@ class XmlTest < Test::Unit::TestCase
     "'" => "&apos;",
     "&" => "&amp;"
   }
-  should "should unescape html entities" do
+  it "should unescape html entities" do
     xml_entities.each do |k,v|
       xml = "<tag>Some content #{v}</tag>"
-      Crack::XML.parse(xml)['tag'].should =~ Regexp.new(k)
+      Crack::XML.parse(xml)['tag'].must_match Regexp.new(k)
     end
   end
 
-  should "should unescape XML entities in attributes" do
+  it "should unescape XML entities in attributes" do
     xml_entities.each do |k,v|
       xml = "<tag attr='Some content #{v}'></tag>"
-      Crack::XML.parse(xml)['tag']['attr'].should =~ Regexp.new(k)
+      Crack::XML.parse(xml)['tag']['attr'].must_match Regexp.new(k)
     end
   end
 
-  should "should undasherize keys as tags" do
+  it "should undasherize keys as tags" do
     xml = "<tag-1>Stuff</tag-1>"
-    Crack::XML.parse(xml).keys.should include( 'tag_1' )
+    Crack::XML.parse(xml).keys.must_include( 'tag_1' )
   end
 
-  should "should undasherize keys as attributes" do
+  it "should undasherize keys as attributes" do
     xml = "<tag1 attr-1='1'></tag1>"
-    Crack::XML.parse(xml)['tag1'].keys.should include( 'attr_1')
+    Crack::XML.parse(xml)['tag1'].keys.must_include( 'attr_1')
   end
 
-  should "should undasherize keys as tags and attributes" do
+  it "should undasherize keys as tags and attributes" do
     xml = "<tag-1 attr-1='1'></tag-1>"
-    Crack::XML.parse(xml).keys.should include( 'tag_1' )
-    Crack::XML.parse(xml)['tag_1'].keys.should include( 'attr_1')
+    Crack::XML.parse(xml).keys.must_include( 'tag_1' )
+    Crack::XML.parse(xml)['tag_1'].keys.must_include( 'attr_1')
   end
 
-  should "should render nested content correctly" do
+  it "should render nested content correctly" do
     xml = "<root><tag1>Tag1 Content <em><strong>This is strong</strong></em></tag1></root>"
-    Crack::XML.parse(xml)['root']['tag1'].should == "Tag1 Content <em><strong>This is strong</strong></em>"
+    Crack::XML.parse(xml)['root']['tag1'].must_equal "Tag1 Content <em><strong>This is strong</strong></em>"
   end
 
-  should "should render nested content with splshould text nodes correctly" do
+  it "should render nested content with splshould text nodes correctly" do
     xml = "<root>Tag1 Content<em>Stuff</em> Hi There</root>"
-    Crack::XML.parse(xml)['root'].should == "Tag1 Content<em>Stuff</em> Hi There"
+    Crack::XML.parse(xml)['root'].must_equal "Tag1 Content<em>Stuff</em> Hi There"
   end
 
-  should "should ignore attributes when a child is a text node" do
+  it "should ignore attributes when a child is a text node" do
     xml = "<root attr1='1'>Stuff</root>"
-    Crack::XML.parse(xml).should == { "root" => "Stuff" }
+    Crack::XML.parse(xml).must_equal({ "root" => "Stuff" })
   end
 
-  should "should ignore attributes when any child is a text node" do
+  it "should ignore attributes when any child is a text node" do
     xml = "<root attr1='1'>Stuff <em>in italics</em></root>"
-    Crack::XML.parse(xml).should == { "root" => "Stuff <em>in italics</em>" }
+    Crack::XML.parse(xml).must_equal({ "root" => "Stuff <em>in italics</em>" })
   end
 
-  should "should correctly transform multiple children" do
+  it "should correctly transform multiple children" do
     xml = <<-XML
     <user gender='m'>
       <age type='integer'>35</age>
@@ -215,10 +215,10 @@ class XmlTest < Test::Unit::TestCase
       }
     }
 
-    Crack::XML.parse(xml).should == hash
+    Crack::XML.parse(xml).must_equal hash
   end
 
-  should "should properly handle nil values (ActiveSupport Compatible)" do
+  it "should properly handle nil values (ActiveSupport Compatible)" do
     topic_xml = <<-EOT
       <topic>
         <title></title>
@@ -238,10 +238,10 @@ class XmlTest < Test::Unit::TestCase
       'viewed_at'  => nil,
       'parent_id'  => nil
     }
-    Crack::XML.parse(topic_xml)["topic"].should == expected_topic_hash
+    Crack::XML.parse(topic_xml)["topic"].must_equal expected_topic_hash
   end
 
-  should "should handle a single record from xml (ActiveSupport Compatible)" do
+  it "should handle a single record from xml (ActiveSupport Compatible)" do
     topic_xml = <<-EOT
       <topic>
         <title>The First Topic</title>
@@ -277,11 +277,11 @@ class XmlTest < Test::Unit::TestCase
     }
 
     Crack::XML.parse(topic_xml)["topic"].each do |k,v|
-      v.should == expected_topic_hash[k]
+      v.must_equal expected_topic_hash[k]
     end
   end
 
-  should "should handle multiple records (ActiveSupport Compatible)" do
+  it "should handle multiple records (ActiveSupport Compatible)" do
     topics_xml = <<-EOT
       <topics type="array">
         <topic>
@@ -328,11 +328,11 @@ class XmlTest < Test::Unit::TestCase
     }
     # puts Crack::XML.parse(topics_xml)['topics'].first.inspect
     Crack::XML.parse(topics_xml)["topics"].first.each do |k,v|
-      v.should == expected_topic_hash[k]
+      v.must_equal expected_topic_hash[k]
     end
   end
 
-  should "should handle a single record from_xml with attributes other than type (ActiveSupport Compatible)" do
+  it "should handle a single record from_xml with attributes other than type (ActiveSupport Compatible)" do
     topic_xml = <<-EOT
     <rsp stat="ok">
       <photos page="1" pages="1" perpage="100" total="16">
@@ -352,21 +352,21 @@ class XmlTest < Test::Unit::TestCase
       'isfamily' => "0",
     }
     Crack::XML.parse(topic_xml)["rsp"]["photos"]["photo"].each do |k,v|
-      v.should == expected_topic_hash[k]
+      v.must_equal expected_topic_hash[k]
     end
   end
 
-  should "should handle an emtpy array (ActiveSupport Compatible)" do
+  it "should handle an emtpy array (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
         <posts type="array"></posts>
       </blog>
     XML
     expected_blog_hash = {"blog" => {"posts" => []}}
-    Crack::XML.parse(blog_xml).should == expected_blog_hash
+    Crack::XML.parse(blog_xml).must_equal expected_blog_hash
   end
 
-  should "should handle empty array with whitespace from xml (ActiveSupport Compatible)" do
+  it "should handle empty array with whitespace from xml (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
         <posts type="array">
@@ -374,10 +374,10 @@ class XmlTest < Test::Unit::TestCase
       </blog>
     XML
     expected_blog_hash = {"blog" => {"posts" => []}}
-    Crack::XML.parse(blog_xml).should == expected_blog_hash
+    Crack::XML.parse(blog_xml).must_equal expected_blog_hash
   end
 
-  should "should handle array with one entry from_xml (ActiveSupport Compatible)" do
+  it "should handle array with one entry from_xml (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
         <posts type="array">
@@ -386,10 +386,10 @@ class XmlTest < Test::Unit::TestCase
       </blog>
     XML
     expected_blog_hash = {"blog" => {"posts" => ["a post"]}}
-    Crack::XML.parse(blog_xml).should == expected_blog_hash
+    Crack::XML.parse(blog_xml).must_equal expected_blog_hash
   end
 
-  should "should handle array with multiple entries from xml (ActiveSupport Compatible)" do
+  it "should handle array with multiple entries from xml (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
         <posts type="array">
@@ -399,10 +399,10 @@ class XmlTest < Test::Unit::TestCase
       </blog>
     XML
     expected_blog_hash = {"blog" => {"posts" => ["a post", "another post"]}}
-    Crack::XML.parse(blog_xml).should == expected_blog_hash
+    Crack::XML.parse(blog_xml).must_equal expected_blog_hash
   end
 
-  should "should handle file types (ActiveSupport Compatible)" do
+  it "should handle file types (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
         <logo type="file" name="logo.png" content_type="image/png">
@@ -410,15 +410,15 @@ class XmlTest < Test::Unit::TestCase
       </blog>
     XML
     hash = Crack::XML.parse(blog_xml)
-    hash.keys.should include('blog')
-    hash['blog'].keys.should include('logo')
+    hash.keys.must_include('blog')
+    hash['blog'].keys.must_include('logo')
 
     file = hash['blog']['logo']
-    file.original_filename.should == 'logo.png'
-    file.content_type.should == 'image/png'
+    file.original_filename.must_equal 'logo.png'
+    file.content_type.must_equal 'image/png'
   end
 
-  should "should handle file from xml with defaults (ActiveSupport Compatible)" do
+  it "should handle file from xml with defaults (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
         <logo type="file">
@@ -426,11 +426,11 @@ class XmlTest < Test::Unit::TestCase
       </blog>
     XML
     file = Crack::XML.parse(blog_xml)['blog']['logo']
-    file.original_filename.should == 'untitled'
-    file.content_type.should == 'application/octet-stream'
+    file.original_filename.must_equal 'untitled'
+    file.content_type.must_equal 'application/octet-stream'
   end
 
-  should "should handle xsd like types from xml (ActiveSupport Compatible)" do
+  it "should handle xsd like types from xml (ActiveSupport Compatible)" do
     bacon_xml = <<-EOT
     <bacon>
       <weight type="double">0.5</weight>
@@ -451,10 +451,10 @@ class XmlTest < Test::Unit::TestCase
       'illustration' => "babe.png"
     }
 
-    Crack::XML.parse(bacon_xml)["bacon"].should == expected_bacon_hash
+    Crack::XML.parse(bacon_xml)["bacon"].must_equal expected_bacon_hash
   end
 
-  should "should let type trickle through when unknown (ActiveSupport Compatible)" do
+  it "should let type trickle through when unknown (ActiveSupport Compatible)" do
     product_xml = <<-EOT
     <product>
       <weight type="double">0.5</weight>
@@ -468,25 +468,47 @@ class XmlTest < Test::Unit::TestCase
       'image' => {'type' => 'ProductImage', 'filename' => 'image.gif' },
     }
 
-    Crack::XML.parse(product_xml)["product"].should == expected_product_hash
+    Crack::XML.parse(product_xml)["product"].must_equal expected_product_hash
   end
 
-  should "should handle unescaping from xml (ActiveResource Compatible)" do
+  it "should handle unescaping from xml (ActiveResource Compatible)" do
     xml_string = '<person><bare-string>First &amp; Last Name</bare-string><pre-escaped-string>First &amp;amp; Last Name</pre-escaped-string></person>'
     expected_hash = {
       'bare_string'        => 'First & Last Name',
       'pre_escaped_string' => 'First &amp; Last Name'
     }
 
-    Crack::XML.parse(xml_string)['person'].should == expected_hash
+    Crack::XML.parse(xml_string)['person'].must_equal expected_hash
   end
 
-  should "handle an empty xml string" do
-    Crack::XML.parse('').should == {}
+  it "handle an empty xml string" do
+    Crack::XML.parse('').must_equal({})
   end
 
   # As returned in the response body by the unfuddle XML API when creating objects
-  should "handle an xml string containing a single space" do
-    Crack::XML.parse(' ').should == {}
+  it "handle an xml string containing a single space" do
+    Crack::XML.parse(' ').must_equal({})
+  end
+
+  it "can dump parsed xml" do
+    xml = <<-XML
+      <blog>
+        <posts language="english">I like big butts and I cannot Lie</posts>
+      </blog>
+    XML
+
+    Marshal.dump(Crack::XML.parse(xml))
+  end
+
+  it "properly handles a node with type == file that has children" do
+    # Example is an excerpt from a problematic kvm domain config file
+    example_xml = <<-EOT
+    <disk type='file' device='cdrom'>
+      <driver name='qemu' type='raw' cache='none' io='native'/>
+      <source file='/tmp/cdrom.iso'/>
+    </disk>
+    EOT
+
+    Crack::XML.parse(example_xml).must_equal({"disk"=>{"driver"=>{"name"=>"qemu", "type"=>"raw", "cache"=>"none", "io"=>"native"}, "source"=>{"file"=>"/tmp/cdrom.iso"}, "type"=>"file", "device"=>"cdrom"}})
   end
 end

metadata

@@ -1,44 +1,54 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: crack
-version: !ruby/object:Gem::Version 
-  hash: 23
+version: !ruby/object:Gem::Version
+  version: 0.4.0
   prerelease: 
-  segments: 
-  - 0
-  - 3
-  - 2
-  version: 0.3.2
 platform: ruby
-authors: 
+authors:
 - John Nunemaker
-- Wynn Netherland
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-01-09 00:00:00 Z
-dependencies: []
-
-description: 
-email: nunemaker@gmail.com
+date: 2013-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: safe_yaml
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+description: Really simple JSON and XML parsing, ripped from Merb and Rails.
+email:
+- nunemaker@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
-files: 
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
 - History
 - LICENSE
-- README.rdoc
-- Rakefile
+- README.md
 - crack.gemspec
 - lib/crack.rb
 - lib/crack/json.rb
 - lib/crack/util.rb
+- lib/crack/version.rb
 - lib/crack/xml.rb
-- test/crack_test.rb
+- script/bootstrap
+- script/release
+- script/test
 - test/data/twittersearch-firefox.json
 - test/data/twittersearch-ie.json
 - test/hash_test.rb
@@ -48,37 +58,36 @@ files:
 - test/test_helper.rb
 - test/xml_test.rb
 homepage: http://github.com/jnunemaker/crack
-licenses: []
-
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: crack
-rubygems_version: 1.8.10
+rubyforge_project: 
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Really simple JSON and XML parsing, ripped from Merb and Rails.
-test_files: []
-
+test_files:
+- test/data/twittersearch-firefox.json
+- test/data/twittersearch-ie.json
+- test/hash_test.rb
+- test/json_test.rb
+- test/parser_test.rb
+- test/string_test.rb
+- test/test_helper.rb
+- test/xml_test.rb

data/README.rdoc

@@ -1,42 +0,0 @@
-= crack
-
-Really simple JSON and XML parsing, ripped from Merb and Rails. The XML parser is ripped from Merb and the JSON parser is ripped from Rails. I take no credit, just packaged them for all to enjoy and easily use.
-
-== note on releases
-
-Releases are tagged on github and also released as gems on github and rubyforge. Master is pushed to whenever I add a patch or a new feature. To build from master, you can clone the code, generate the updated gemspec, build the gem and install.
-
-* rake gemspec
-* gem build crack.gemspec
-* gem install the gem that was built
-
-== note on patches/pull requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a future version unintentionally.
-* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== usage
-  
-  gem 'crack'
-  require 'crack' # for xml and json
-  require 'crack/json' # for just json
-  require 'crack/xml' # for just xml
-
-== examples
-  
-  Crack::XML.parse("<tag>This is the contents</tag>")
-    # => {'tag' => 'This is the contents'}
-  
-  Crack::JSON.parse('{"tag":"This is the contents"}')
-    # => {'tag' => 'This is the contents'}
-
-== Copyright
-
-Copyright (c) 2009 John Nunemaker. See LICENSE for details.
-
-== Docs
-
-http://rdoc.info/projects/jnunemaker/crack

data/Rakefile

@@ -1,32 +0,0 @@
-$:.unshift("lib")
-require 'rubygems'
-require 'rake'
-
-$:.unshift(File.expand_path('lib', File.dirname(__FILE__)))
-require 'crack'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "crack"
-    gem.summary = %Q{Really simple JSON and XML parsing, ripped from Merb and Rails.}
-    gem.email = "nunemaker@gmail.com"
-    gem.homepage = "http://github.com/jnunemaker/crack"
-    gem.authors = ["John Nunemaker", "Wynn Netherland"]
-    gem.rubyforge_project = 'crack'
-    gem.version = Crack::VERSION
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler"
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = false
-end
-
-task :default => :test

data/test/crack_test.rb

@@ -1,4 +0,0 @@
-require 'test_helper'
-
-# class CrackTest < Test::Unit::TestCase
-# end