equivalent-xml 0.1.1

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "nokogiri"
+  gem "bundler", "~> 1.0.0"
+  gem "rcov", ">= 0"
+  gem "rspec"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Michael B. Klein
+
+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.rdoc

@@ -0,0 +1,73 @@
+= equivalent-xml
+
+== Description
+
+=== Problem
+Testing XML output is difficult:
+* Comparing text output is brittle due to the vagaries of serialization.
+* Attribute order doesn't matter.
+* Element order matters sometimes, but not always. 
+* Text sometimes needs to be normalized, but CDATA doesn't.
+* Nodes in the same namespace don't always use the same prefix
+* Etc.
+
+=== Solution
+EquivalentXml for Nokogiri
+
+=== Use
+  EquivalentXml.equivalent?(node_1, node_2, opts = { :element_order => false, :normalize_whitespace => true })
+
+node_1 and node_2 can be any Nokogiri::XML::Node descendants. The most common
+use is to compare two Nokogiri::XML::Document instances.
+
+node_1 is equivalent to node_2 if and only if:
+* node_1 and node_2 are of the same class
+* node_1 and node_2 are in the same namespace
+* node_1 and node_2 have the same number of child nodes
+  (excluding ProcessingInstructions, Comments and empty Text nodes)
+* For each child of node_1, there is exactly one equal child of node_2
+* If called with :element_order => true, equivalent child elements must be
+  in the same relative position in order to be considered equal
+
++Element+ nodes are equivalent if they have the same name, and their 
+child nodesets are equal (as defined above)
+
++Attribute+ nodes are equivalent if their names and values match exactly
+
++CDATA+ nodes are equivalent if their text strings match exactly,
+including leading, trailing, and internal whitespace
+
+Non-CDATA +CharacterData+ nodes are equivalent if their text strings 
+match after stripping leading and trailing whitespace and collapsing 
+internal whitespace to a single space
+
++Document+ nodes are equivalent if their root nodes are equal
+
++ProcessingInstruction+ and +Comment+ nodes are ignored
+
+==== Options
+  :element_order => true
+
+Require elements to be in the same relative position in order to be
+considered equivalent.
+
+  :normalize_whitespace => false
+
+Don't normalize whitespace within text nodes; require text nodes to 
+match exactly.
+
+== Contributing to equivalent-xml
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Michael B. Klein. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+require 'rake/tasklib'
+require 'rake/rdoctask'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = FileList['./spec/**/*_spec.rb']
+end
+  
+task :default => :spec
+
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "equivalent-xml #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/equivalent-xml.rb

@@ -0,0 +1,129 @@
+module EquivalentXml
+  
+  class << self
+
+    ELEMENT_NODE                = 1
+    ATTRIBUTE_NODE              = 2
+    TEXT_NODE                   = 3
+    CDATA_SECTION_NODE          = 4
+    ENTITY_REFERENCE_NODE       = 5
+    ENTITY_NODE                 = 6
+    PROCESSING_INSTRUCTION_NODE = 7
+    COMMENT_NODE                = 8
+    DOCUMENT_NODE               = 9
+    DOCUMENT_TYPE_NODE          = 10
+    DOCUMENT_FRAGMENT_NODE      = 11
+    NOTATION_NODE               = 12
+    
+    DEFAULT_OPTS                = { :element_order => false, :normalize_whitespace => true }
+
+    def equivalent?(node_1, node_2, opts = {})
+      opts = DEFAULT_OPTS.merge(opts)
+      self.compare_nodes(node_1, node_2, opts)
+    end
+  
+    def compare_nodes(node_1, node_2, opts)
+      if (node_1.class != node_2.class) or self.same_namespace?(node_1,node_2) == false
+        false
+      else
+        case node_1.node_type
+        when DOCUMENT_NODE
+          self.compare_documents(node_1,node_2,opts)
+        when ELEMENT_NODE
+          self.compare_elements(node_1,node_2,opts)
+        when ATTRIBUTE_NODE
+          self.compare_attributes(node_1,node_2,opts)
+        when CDATA_SECTION_NODE
+          self.compare_cdata(node_1,node_2,opts)
+        when TEXT_NODE
+          self.compare_text(node_1,node_2,opts)
+        else
+          self.compare_children(node_1,node_2,opts)
+        end
+      end
+    end
+
+    def compare_documents(node_1, node_2, opts)
+      self.equivalent?(node_1.root,node_2.root,opts)
+    end
+    
+    def compare_elements(node_1, node_2, opts)
+      (node_1.name == node_2.name) && self.compare_children(node_1,node_2,opts)
+    end
+    
+    def compare_attributes(node_1, node_2, opts)
+      (node_1.name == node_2.name) && (node_1.value == node_2.value)
+    end
+    
+    def compare_text(node_1, node_2, opts)
+      if opts[:normalize_whitespace]
+        node_1.text.strip.gsub(/\s+/,' ') == node_2.text.strip.gsub(/\s+/,' ')
+      else
+        node_1.text == node_2.text
+      end
+    end
+    
+    def compare_cdata(node_1, node_2, opts)
+      node_1.text == node_2.text
+    end
+    
+    def compare_children(node_1, node_2, opts)
+      ignore_proc = lambda do |child|
+        child.is_a?(Nokogiri::XML::Comment) ||
+        child.is_a?(Nokogiri::XML::ProcessingInstruction) ||
+        (child.class == Nokogiri::XML::Text && child.text.strip.empty?)
+      end
+    
+      nodeset_1 = node_1.children.reject { |child| ignore_proc.call(child) }
+      nodeset_2 = node_2.children.reject { |child| ignore_proc.call(child) }
+      result = self.compare_nodesets(nodeset_1,nodeset_2,opts)
+      
+      if node_1.respond_to?(:attribute_nodes)
+        attributes_1 = node_1.attribute_nodes
+        attributes_2 = node_2.attribute_nodes
+        result = result && self.compare_nodesets(attributes_1,attributes_2,opts)
+      end
+      result
+    end
+    
+    def compare_nodesets(nodeset_1, nodeset_2, opts)
+      local_set_1 = nodeset_1.dup
+      local_set_2 = nodeset_2.dup
+      
+      if local_set_1.length != local_set_2.length
+        return false
+      end
+    
+      local_set_1.each do |search_node|
+        found_node = local_set_2.find { |test_node| self.equivalent?(search_node,test_node,opts) }
+        if found_node.nil?
+          return false
+        else
+          if search_node.is_a?(Nokogiri::XML::Element) and opts[:element_order]
+            if search_node.parent.elements.index(search_node) != found_node.parent.elements.index(found_node)
+              return false
+            end
+          end
+          local_set_2.delete(found_node)
+        end
+      end
+      return local_set_2.length == 0
+    end
+
+    def same_namespace?(node_1, node_2)
+      unless node_1.respond_to?(:namespace) and node_2.respond_to?(:namespace)
+        return true
+      end
+      
+      if node_1.namespace.nil? and node_2.namespace.nil?
+        return true
+      end
+    
+      href1 = node_1.namespace.nil? ? '' : node_1.namespace.href
+      href2 = node_2.namespace.nil? ? '' : node_2.namespace.href
+      return href1 == href2
+    end
+  
+  end
+
+end

data/spec/equvalent-xml_spec.rb

@@ -0,0 +1,101 @@
+$:.push(File.join(File.dirname(__FILE__),'..','lib'))
+require 'nokogiri'
+require 'equivalent-xml'
+
+describe EquivalentXml do
+
+  it "should consider a document equivalent to itself" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc1).should == true
+  end
+  
+  it "should ensure that attributes match" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first order='1'>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><first order='2'>foo  bar baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == false
+
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first order='1'>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><first order='1'>foo  bar baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == true
+  end
+  
+  it "shouldn't care about attribute order" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first order='1' value='quux'>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><first value='quux' order='1'>foo  bar baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == true
+  end
+  
+  it "shouldn't care about element order by default" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><second>things</second><first>foo  bar baz</first></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == true
+  end
+  
+  it "should care about element order if :element_order => true is specified" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><second>things</second><first>foo  bar baz</first></doc>")
+    EquivalentXml.equivalent?(doc1,doc2,:element_order => true).should == false
+  end
+  
+  it "should ensure nodesets have the same number of elements" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><second>things</second><first>foo  bar baz</first><third/></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == false
+  end
+
+  it "should ensure namespaces match" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:baz'><first>foo  bar baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == false
+  end
+
+  it "should normalize simple whitespace by default" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo bar  baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc2).should == true
+  end
+
+  it "shouldn't normalize simple whitespace if :normalize_whitespace => false is specified" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo bar  baz</first><second>things</second></doc>")
+    EquivalentXml.equivalent?(doc1,doc2, :normalize_whitespace => false).should == false
+  end
+
+  it "should normalize complex whitespace by default" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML(%{<doc xmlns='foo:bar'>
+      <second>things</second>
+      <first>
+        foo
+        bar baz
+      </first>
+    </doc>})
+    EquivalentXml.equivalent?(doc1,doc2).should == true
+  end
+  
+  it "shouldn't normalize complex whitespace if :normalize_whitespace => false is specified" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML(%{<doc xmlns='foo:bar'>
+      <second>things</second>
+      <first>
+        foo
+        bar baz
+      </first>
+    </doc>})
+    EquivalentXml.equivalent?(doc1,doc2, :normalize_whitespace => false).should == false
+  end
+
+  it "should ignore comment nodes" do
+    doc1 = Nokogiri::XML("<doc xmlns='foo:bar'><first>foo  bar baz</first><second>things</second></doc>")
+    doc2 = Nokogiri::XML(%{<doc xmlns='foo:bar'>
+      <second>things</second>
+      <!-- Comment Node -->
+      <first>
+        foo
+        bar baz
+      </first>
+    </doc>})
+    EquivalentXml.equivalent?(doc1,doc2).should == true
+  end
+  
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: equivalent-xml
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Michael B. Klein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-17 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: |-
+  Compares two XML Nodes (Documents, etc.) for certain semantic equivalencies. 
+      Currently written for Nokogiri, but with an eye toward supporting multiple XML libraries
+email: mbklein@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/equivalent-xml.rb
+- spec/equvalent-xml_spec.rb
+has_rdoc: true
+homepage: http://github.com/mbklein/equivalent-xml
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easy equivalency tests for Ruby XML
+test_files: 
+- spec/equvalent-xml_spec.rb