xml-spec 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2460e0d0cf76e2ff9285e68c1fcc99f93d26f707
+  data.tar.gz: 67969a91a3db438dd5488055415417ef2e67aa9f
+SHA512:
+  metadata.gz: 752d5fb2dfe2a4a41403633c8a4984aaf277b844f9fe189b4db8da24bb41168c8ee1686654510a54843b6c45c6c6f7817574bf50fa57d05c4ae90d7cc49662e7
+  data.tar.gz: 1c13122c0858a66da06cc50ea371332438600335f73b27f5545e54ff57e763389355720ec268839e8b9eff8a9f5db104e7752dcc94f137a2475517e8346518ec

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+Guardfile
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+gemdev

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.0

data/Gemfile

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

data/Guardfile.example

@@ -0,0 +1,36 @@
+#guard 'rspec', cmd: 'zeus rspec',
+               #all_on_start: false,
+               #all_after_pass: false,
+               #failed_mode: :keep,
+               #spec_paths: ['spec'] do
+##guard 'rspec', :all_on_start => true, :all_after_pass => false, :cli => '--color --format doc' do
+  #watch( %r{^spec/.+_spec\.rb$} )
+  #watch( %r{^lib/(.+)\.rb$} )     { |m| "spec/#{m[1]}_spec.rb" }
+  #watch( 'spec/spec_helper.rb' )  { "spec" }
+#end
+
+guard :rspec, #cmd: 'zeus rspec',
+              all_on_start: false,
+              all_after_pass: false,
+              failed_mode: :keep,
+              spec_paths: ['spec'] do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 C. Jason Harrelson
+
+MIT License
+
+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,33 @@
+# XmlSpec
+
+XML matchers for RSpec and Cucumber.
+
+#### This is alpha software and is not yet ready for primte-time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'xml_spec'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xml_spec
+
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/xml_spec/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/xml-spec.rb

@@ -0,0 +1 @@
+require 'xml-spec'

data/lib/xml_spec.rb

@@ -0,0 +1,56 @@
+#require "json"
+#require 'active_support/all'
+require 'active_support/core_ext/hash/conversions'
+#require 'active_support/core_ext'
+require 'equivalent-xml'
+require 'nokogiri'
+require 'nori'
+require "rspec"
+require "xml_spec/errors"
+require "xml_spec/exclusion"
+require "xml_spec/helpers"
+require "xml_spec/messages"
+require "xml_spec/matchers"
+
+module XmlSpec
+
+  autoload :Configuration, 'xml_spec/configuration'
+  autoload :VERSION,       'xml_spec/version'
+
+  extend Configuration
+
+end
+
+class Hash
+  def diff(other)
+    (self.keys + other.keys).uniq.inject({}) do |memo, key|
+      unless self[key] == other[key]
+        if self[key].kind_of?(Hash) &&  other[key].kind_of?(Hash)
+          memo[key] = self[key].diff(other[key])
+        else
+          memo[key] = [self[key], other[key]]
+        end
+      end
+      memo
+    end
+  end
+
+  def interpret_diff( memos=[], path=[] )
+    self.inject(memos) do |memo, key_value|
+      k, v = key_value.first, key_value.last
+      path << k
+      #puts '', "memo: #{memo.inspect}", "key: #{k}", "value: #{v}"
+      #puts "path: #{path.inspect}"
+      if v.kind_of?( Hash )
+        #debugger
+        v.interpret_diff( memos, path )
+      elsif v.kind_of?(Array)
+        #debugger
+        memo << "#{path.join( '/' )}: #{v.map { |val| val.nil? ? 'nil' : (val.respond_to?( :empty? ) && val.empty? ? "''" : "'#{val}'") }.join( ' is not ' )}"
+      end
+    end
+
+    memos
+  end
+
+end

data/lib/xml_spec/configuration.rb

@@ -0,0 +1,37 @@
+require "set"
+
+module XmlSpec
+  module Configuration
+
+    DEFAULT_EXCLUDED_KEYS = %w(id created_at updated_at)
+
+    def configure(&block)
+      instance_eval(&block)
+    end
+
+    def excluded_keys
+      @excluded_keys ||= DEFAULT_EXCLUDED_KEYS
+    end
+
+    def excluded_keys=(keys)
+      @excluded_keys = keys.map(&:to_s).uniq
+    end
+
+    def exclude_keys(*keys)
+      self.excluded_keys = keys
+    end
+
+    def directory
+      @directory
+    end
+
+    def directory=(directory)
+      @directory = directory
+    end
+
+    def reset
+      instance_variables.each{|ivar| remove_instance_variable(ivar) }
+    end
+
+  end
+end

data/lib/xml_spec/errors.rb

@@ -0,0 +1,47 @@
+module XmlSpec
+
+  class Error < StandardError
+  end
+
+  class XmlSyntaxError < Error
+    def initialize( e=nil )
+      super e
+      set_backtrace e.backtrace if e
+    end
+
+    def to_s
+      "Invalid XML"
+    end
+  end
+
+  class MissingPath < Error
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      %(Missing JSON path "#{path}")
+    end
+  end
+
+  class MissingDirectory < Error
+    def to_s
+      "No XmlSpec.directory set"
+    end
+  end
+
+  class MissingFile < Error
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      "No XML file at #{path}"
+    end
+  end
+
+end

data/lib/xml_spec/exclusion.rb

@@ -0,0 +1,26 @@
+module XmlSpec
+  module Exclusion
+    extend self
+
+    def exclude_keys(ruby)
+      case ruby
+      when Hash
+        ruby.sort.inject({}) do |hash, (key, value)|
+          hash[key] = exclude_keys(value) unless exclude_key?(key)
+          hash
+        end
+      when Array
+        ruby.map{|v| exclude_keys(v) }
+      else ruby
+      end
+    end
+
+    def exclude_key?(key)
+      excluded_keys.include?(key)
+    end
+
+    def excluded_keys
+      @excluded_keys ||= Set.new(XmlSpec.excluded_keys)
+    end
+  end
+end

data/lib/xml_spec/helpers.rb

@@ -0,0 +1,74 @@
+#require "multi_json"
+
+module XmlSpec
+  module Helpers
+
+    extend self
+
+    def parse_xml( xml, path=nil )
+      Nokogiri::XML( xml ) { |config| config.options = Nokogiri::XML::ParseOptions::STRICT }
+      parser = Nori.new
+      ruby = parser.parse( xml )
+      value_at_json_path( ruby, path )
+    rescue Nokogiri::XML::SyntaxError=> e
+      raise XmlSpec::XmlSyntaxError.new( e )
+    end
+
+    def normalize_xml( xml, path=nil )
+      Nokogiri.XML( xml ) do |config|
+        config.default_xml.noblanks
+      end.to_xml( indent: 2 ).chomp
+    end
+
+    # TODO consider removing ths method as we do not need 2 levels with XML
+    def generate_normalized_xml( xml_or_hash )
+      xml = nil
+      if xml_or_hash.is_a?( Hash )
+         hash = xml_or_hash
+         raise 'error' if hash.keys.size != 1
+         root = hash.keys.first
+         xml = hash[root].to_xml( root: root )
+      end
+
+      normalize_xml( xml )
+    end
+
+    def load_xml(relative_path)
+      missing_json_directory! if XmlSpec.directory.nil?
+      path = File.join(XmlSpec.directory, relative_path)
+      missing_xml_file!(path) unless File.exist?(path)
+      File.read(path)
+    end
+
+  private
+
+    def value_at_json_path(ruby, path)
+      return ruby unless path
+
+      path.split("/").inject(ruby) do |value, key|
+        case value
+        when Hash
+          value.fetch(key){ missing_json_path!(path) }
+        when Array
+          missing_json_path!(path) unless key =~ /^\d+$/
+          value.fetch(key.to_i){ missing_json_path!(path) }
+        else
+          missing_json_path!(path)
+        end
+      end
+    end
+
+    def missing_json_path!(path)
+      raise XmlSpec::MissingPath.new(path)
+    end
+
+    def missing_xml_directory!
+      raise XmlSpec::MissingDirectory
+    end
+
+    def missing_xml_file!(path)
+      raise XmlSpec::MissingFile.new(path)
+    end
+  end
+
+end

data/lib/xml_spec/matchers.rb

@@ -0,0 +1,35 @@
+require "xml_spec/matchers/be_xml_eql"
+#require "xml_spec/matchers/include_xml"
+#require "xml_spec/matchers/have_xml_path"
+#require "xml_spec/matchers/have_xml_type"
+#require "xml_spec/matchers/have_xml_size"
+
+module XmlSpec
+  module Matchers
+
+    def be_xml_eql( xml=nil )
+      XmlSpec::Matchers::BeXmlEql.new( xml )
+    end
+
+    #def include_xml(xml = nil)
+      #XmlSpec::Matchers::IncludeJson.new(xml)
+    #end
+
+    #def have_xml_path(path)
+      #XmlSpec::Matchers::HaveJsonPath.new(path)
+    #end
+
+    #def have_xml_type(type)
+      #XmlSpec::Matchers::HaveJsonType.new(type)
+    #end
+
+    #def have_xml_size(size)
+      #XmlSpec::Matchers::HaveJsonSize.new(size)
+    #end
+
+  end
+end
+
+RSpec.configure do |config|
+  config.include XmlSpec::Matchers
+end

data/lib/xml_spec/matchers/be_xml_eql.rb

@@ -0,0 +1,74 @@
+module XmlSpec
+  module Matchers
+    class BeXmlEql
+
+      include XmlSpec::Helpers
+      include XmlSpec::Exclusion
+      include XmlSpec::Messages
+
+      attr_reader :expected, :actual
+
+      def diffable?
+        true
+      end
+
+      def initialize( expected_xml=nil )
+        @expected_xml = expected_xml
+      end
+
+      def matches?( actual_xml )
+        raise "Expected equivalent XML not provided" if @expected_xml.nil?
+
+        @actual_xml = actual_xml
+        @actual = parse_xml( actual_xml, @path )
+        @expected = parse_xml( @expected_xml, @path )
+        #@actual, @expected = scrub(actual_xml, @path), scrub(@expected_xml)
+        #@actual == @expected
+        EquivalentXml.equivalent?( @expected_xml, @actual_xml )
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def to_file(path)
+        @expected_xml = load_xml(path)
+        self
+      end
+
+      def excluding(*keys)
+        excluded_keys.merge(keys.map(&:to_s))
+        self
+      end
+
+      def including(*keys)
+        excluded_keys.subtract(keys.map(&:to_s))
+        self
+      end
+
+      def failure_message_for_should
+        message_with_path( "Expected equivalent XML" ) #+ "\nReadable Diff:\n#{diff}"
+      end
+
+      def failure_message_for_should_not
+        message_with_path( "Expected inequivalent XML" )
+      end
+
+      def description
+        message_with_path("equal XML")
+      end
+
+    private
+
+      def diff
+        '  ' + expected.diff( actual ).interpret_diff.join( "\n  " )
+      end
+
+      def scrub(xml, path = nil)
+        generate_normalized_xml(exclude_keys(parse_xml(xml, path))).chomp + "\n"
+      end
+
+    end
+  end
+end

data/lib/xml_spec/messages.rb

@@ -0,0 +1,8 @@
+module XmlSpec
+  module Messages
+    def message_with_path(message)
+      message << %( at path "#{@path}") if @path
+      message
+    end
+  end
+end

data/lib/xml_spec/version.rb

@@ -0,0 +1,3 @@
+module XmlSpec
+  VERSION = "0.2.0"
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe XmlSpec::Configuration do
+
+  it "excludes id and timestamps by default" do
+    XmlSpec.excluded_keys.should == ["id", "created_at", "updated_at"]
+  end
+
+  it "excludes custom keys" do
+    XmlSpec.exclude_keys("token")
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via setter" do
+    XmlSpec.excluded_keys = ["token"]
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via block" do
+    XmlSpec.configure{ |c| c.exclude_keys("token") }
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via block setter" do
+    XmlSpec.configure{ |c| c.excluded_keys = ["token"] }
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via instance-evaluated block" do
+    XmlSpec.configure{ exclude_keys("token") }
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "ensures its excluded keys are strings" do
+    XmlSpec.exclude_keys(:token)
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "ensures its excluded keys are unique" do
+    XmlSpec.exclude_keys("token", :token)
+    XmlSpec.excluded_keys.should == ["token"]
+  end
+
+  it "resets its excluded keys" do
+    original = XmlSpec.excluded_keys
+
+    XmlSpec.exclude_keys("token")
+    XmlSpec.excluded_keys.should_not == original
+
+    XmlSpec.reset
+    XmlSpec.excluded_keys.should == original
+  end
+
+  it "resets its directory" do
+    XmlSpec.directory.should be_nil
+
+    XmlSpec.directory = "/"
+    XmlSpec.directory.should_not be_nil
+
+    XmlSpec.reset
+    XmlSpec.directory.should be_nil
+  end
+
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe XmlSpec::Helpers do
+
+  include described_class
+
+  let :xml do
+    %(<xml><specs type="array"><spec type="integer">1</spec><spec type="integer">2</spec></specs></xml>)
+  end
+
+  let :normalized do
+    <<-XML
+<?xml version="1.0"?>
+<xml>
+  <specs type="array">
+    <spec type="integer">1</spec>
+    <spec type="integer">2</spec>
+  </specs>
+</xml>
+    XML
+  end
+
+  let :hash do
+    {"xml" => {"specs" =>  [1, 2]}}
+  end
+
+  context "parse_xml" do
+
+    it "parses XML documents" do
+      parse_xml( xml ).should == hash
+    end
+
+    it "raises a parser error for invalid XML" do
+      expect{ parse_xml("xml_spec") }.to raise_error( XmlSpec::XmlSyntaxError )
+    end
+
+    it "parses at a path if given" do
+      parse_xml( xml, "xml/specs" ).should == [1, 2]
+      parse_xml( xml, "xml/specs/0" ).should == 1
+    end
+
+    it "raises an error for a missing path" do
+      %w(spec spec/1).each do |path|
+        expect{ parse_xml( xml, path ) }.to raise_error( XmlSpec::MissingPath )
+      end
+    end
+
+  end
+
+  context "normalize_xml" do
+
+    it "normalizes a XML document" do
+      normalize_xml( xml ).should == normalized.chomp
+    end
+
+    #it "normalizes at a path" do
+      #normalize_xml(%({"xml":["spec"]}), "xml/0").should == %("spec")
+    #end
+
+    #it "accepts a XML value" do
+      #normalize_xml(%("xml_spec")).should == %("xml_spec")
+    #end
+
+    #it "normalizes XML values" do
+      #normalize_xml(%(1e+1)).should == %(10.0)
+    #end
+
+  end
+
+  context "generate_normalized_xml" do
+
+    it "generates a normalized XML document" do
+      generate_normalized_xml( hash ).should == normalized.chomp
+    end
+
+    it "generates a normalized XML value" do
+      generate_normalized_xml( nil ).should == %(<?xml version=\"1.0\"?>)
+    end
+
+  end
+
+  #context "load_xml_file" do
+    #it "raises an error when no directory is set" do
+      #expect{ load_xml("one.xml") }.to raise_error(XmlSpec::MissingDirectory)
+    #end
+
+    #it "returns JSON when the file exists" do
+      #XmlSpec.directory = files_path
+      #load_xml("one.xml").should == %({"value":"from_file"})
+    #end
+
+    #it "ignores extra slashes" do
+      #XmlSpec.directory = "/#{files_path}/"
+      #load_xml("one.xml").should == %({"value":"from_file"})
+    #end
+
+    #it "raises an error when the file doesn't exist" do
+      #XmlSpec.directory = files_path
+      #expect{ load_xml("bogus.xml") }.to raise_error(XmlSpec::MissingFile)
+    #end
+
+    #it "raises an error when the directory doesn't exist" do
+      #XmlSpec.directory = "#{files_path}_bogus"
+      #expect{ load_xml("one.xml") }.to raise_error(XmlSpec::MissingFile)
+    #end
+
+    #it "finds nested files" do
+      #XmlSpec.directory = files_path
+      #load_xml("project/one.xml").should == %({"nested":"inside_folder"})
+      #load_xml("project/version/one.xml").should == %({"nested":"deeply"})
+    #end
+  #end
+
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+describe XmlSpec::Matchers do
+
+  let(:environment) do
+    klass = Class.new
+    klass.send(:include, XmlSpec::Matchers)
+    klass.new
+  end
+
+  let(:json){ %({"json":"spec"}) }
+
+  #context "be_json_eql" do
+    #it "instantiates its matcher" do
+      #XmlSpec::Matchers::BeJsonEql.should_receive(:new).with(json)
+      #environment.be_json_eql(json)
+    #end
+
+    #it "returns its matcher" do
+      #matcher = environment.be_json_eql(json)
+      #matcher.should be_a(XmlSpec::Matchers::BeJsonEql)
+    #end
+  #end
+
+  #context "include_json" do
+    #it "instantiates its matcher" do
+      #XmlSpec::Matchers::IncludeJson.should_receive(:new).with(json)
+      #environment.include_json(json)
+    #end
+
+    #it "returns its matcher" do
+      #matcher = environment.include_json(json)
+      #matcher.should be_a(XmlSpec::Matchers::IncludeJson)
+    #end
+  #end
+
+  #context "have_json_path" do
+    #let(:path){ "json" }
+
+    #it "instantiates its matcher" do
+      #XmlSpec::Matchers::HaveJsonPath.should_receive(:new).with(path)
+      #environment.have_json_path(path)
+    #end
+
+    #it "returns its matcher" do
+      #matcher = environment.have_json_path(path)
+      #matcher.should be_a(XmlSpec::Matchers::HaveJsonPath)
+    #end
+  #end
+
+  #context "have_json_type" do
+    #let(:type){ Hash }
+
+    #it "instantiates its matcher" do
+      #XmlSpec::Matchers::HaveJsonType.should_receive(:new).with(type)
+      #environment.have_json_type(type)
+    #end
+
+    #it "returns its matcher" do
+      #matcher = environment.have_json_type(type)
+      #matcher.should be_a(XmlSpec::Matchers::HaveJsonType)
+    #end
+  #end
+
+  #context "have_json_size" do
+    #let(:size){ 1 }
+
+    #it "instantiates its matcher" do
+      #XmlSpec::Matchers::HaveJsonSize.should_receive(:new).with(size)
+      #environment.have_json_size(size)
+    #end
+
+    #it "returns its matcher" do
+      #matcher = environment.have_json_size(size)
+      #matcher.should be_a(XmlSpec::Matchers::HaveJsonSize)
+    #end
+  #end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require "xml_spec"
+
+RSpec.configure do |config|
+
+  config.before do
+    XmlSpec.reset
+  end
+
+end
+
+def files_path
+  File.expand_path("../support/files", __FILE__)
+end

data/xml-spec.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xml_spec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "xml-spec"
+  spec.version       = XmlSpec::VERSION
+  spec.authors       = ["C. Jason Harrelson"]
+  spec.email         = ["jason@lookforwardenterprises.com"]
+  spec.summary       = %q{XML matchers for specs.}
+  spec.description   = %q{XML matchers for specs.  See README for more info.}
+  spec.homepage      = "https://github.com/midas/xml_spec"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  #spec.add_dependency "multi_json", "~> 1.0"
+  spec.add_dependency "activesupport", ">= 3"
+  spec.add_dependency "builder", ">= 3"
+  spec.add_dependency "equivalent-xml"
+  spec.add_dependency "nokogiri", "~> 1"
+  spec.add_dependency "nori", "~> 2"
+  spec.add_dependency "rspec", "~> 2"
+
+  spec.add_development_dependency "bundler", "~> 1"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: xml-spec
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- C. Jason Harrelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: nori
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: XML matchers for specs.  See README for more info.
+email:
+- jason@lookforwardenterprises.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Guardfile.example
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/xml-spec.rb
+- lib/xml_spec.rb
+- lib/xml_spec/configuration.rb
+- lib/xml_spec/errors.rb
+- lib/xml_spec/exclusion.rb
+- lib/xml_spec/helpers.rb
+- lib/xml_spec/matchers.rb
+- lib/xml_spec/matchers/be_xml_eql.rb
+- lib/xml_spec/messages.rb
+- lib/xml_spec/version.rb
+- spec/configuration_spec.rb
+- spec/helpers_spec.rb
+- spec/matchers_spec.rb
+- spec/spec_helper.rb
+- xml-spec.gemspec
+homepage: https://github.com/midas/xml_spec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: XML matchers for specs.
+test_files:
+- spec/configuration_spec.rb
+- spec/helpers_spec.rb
+- spec/matchers_spec.rb
+- spec/spec_helper.rb