canonix 0.1.3 → 0.1.4

data/.rvmrc

@@ -1,2 +1,2 @@
 rvm_gemset_create_on_use_flag=1
-rvm gemset use canonix
+rvm gemset use canonix

data/README.rdoc

@@ -1,6 +1,6 @@
 = Canonix
 
-XML Canonicalizer for Ruby >= 1.92
+XML Canonicalizer for Ruby >= 1.9.2
 
 This is taken from XMLCanonicalizer/WSS4R and http://github.com/borisnadion/xml-canonicalizer and https://github.com/andrewferk/xmlcanonicalizer.
 
@@ -20,4 +20,4 @@ I personally have little understanding of the inner workings of this code, and w
   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 I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "canonix"
-    gem.summary = %Q{XML Canonicalizer for Ruby >= 1.92}
+    gem.summary = %Q{XML Canonicalizer for Ruby >= 1.9.2}
     gem.description = %Q{This is based on andrewferk's rewrite for Ruby 1.9 compatibility, but applies 
       relevance's fix to ensure proper canonicalisation. It is intended that this be the new official 
       Ruby XML Canonicaliser as the other project seems to be abandoned.}

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/canonix.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{canonix}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendon Muir"]
-  s.date = %q{2011-07-03}
+  s.date = %q{2011-07-12}
   s.description = %q{This is based on andrewferk's rewrite for Ruby 1.9 compatibility, but applies 
       relevance's fix to ensure proper canonicalisation. It is intended that this be the new official 
       Ruby XML Canonicaliser as the other project seems to be abandoned.}
@@ -38,8 +38,8 @@ Gem::Specification.new do |s|
   ]
   s.homepage = %q{http://github.com/brendon/canonix}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
-  s.summary = %q{XML Canonicalizer for Ruby >= 1.92}
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{XML Canonicalizer for Ruby >= 1.9.2}
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/lib/xml/util/xmlcanonicalizer.rb

@@ -1,84 +1,20 @@
-#require "rexml/document"
-#require "base64"
-#require "log4r"
+# require "rexml/document"
+# require "base64"
+# require "log4r"
 
-#include REXML
-#include Log4r
+# include REXML
+# include Log4r
 
 require "rexml/document"
 require "base64"
 
 module XML
   include REXML
-
+  
   module Util
       
-      class REXML::Instruction
-        def write(writer, indent=-1, transitive=false, ie_hack=false)
-          indent(writer, indent)
-          writer << START.sub(/\\/u, '')
-          writer << @target
-          writer << ' '
-          writer << @content if @content != nil
-          writer << STOP.sub(/\\/u, '')
-        end
-      end
-      
-      class REXML::Attribute
-        def <=>(a2)
-          if (self === a2)
-            return 0
-          elsif (self == nil)
-            return -1
-          elsif (a2 == nil)
-            return 1
-          elsif (self.prefix() == a2.prefix())
-            return self.name()<=>a2.name()
-          end
-          if (self.prefix() == nil)
-            return -1
-          elsif (a2.prefix() == nil)
-            return 1
-          end
-          ret = self.namespace()<=>a2.namespace()
-          if (ret == 0)
-            ret = self.prefix()<=>a2.prefix()
-          end
-          return ret
-        end
-      end
-      
-      class REXML::Element
-        def search_namespace(prefix)
-          if (self.namespace(prefix) == nil)
-            return (self.parent().search_namespace(prefix)) if (self.parent() != nil)
-          else
-            return self.namespace(prefix)
-          end
-        end
-      def rendered=(rendered)
-			@rendered = rendered
-		end
-		def rendered?()
-			return @rendered
-		end
-        def node_namespaces()
-          ns = Array.new()
-          ns.push(self.prefix())
-          self.attributes().each_attribute{|a|
-            if (a.prefix() != nil)
-              ns.push(a.prefix())
-            end
-            if (a.prefix() == "" && a.local_name() == "xmlns")
-              ns.push("xmlns")
-            end
-          }
-          ns
-        end
-      end
-      
       class NamespaceNode
-        attr_reader :prefix, :uri	
+        attr_reader :prefix, :uri
         def initialize(prefix, uri)
           @prefix = prefix
           @uri = uri
@@ -102,7 +38,6 @@ module XML
         def initialize(with_comments, excl_c14n)
           @with_comments = with_comments
           @exclusive = excl_c14n
-          @res = ""
           @state = BEFORE_DOC_ELEMENT
           @xnl = Array.new()
           @prevVisibleNamespacesStart = 0
@@ -126,7 +61,6 @@ module XML
         
         def canonicalize(document)
           write_document_node(document)
-          @res
         end
         
         def canonicalize_element(element, logging = true)
@@ -141,10 +75,10 @@ module XML
           ns = element.namespace(element.prefix())
           document.root().add_namespace(element.prefix(), ns)
           write_document_node(document)
-          @res
         end
         
         def write_document_node(document)
+          @res = ""
           @state = BEFORE_DOC_ELEMENT
           if (document.class().to_s() == "REXML::Element")
             write_node(document)
@@ -161,19 +95,18 @@ module XML
           if ((node.node_type() == :text) && white_text?(node.value()))
             res = node.value()
             res.gsub("\r\n","\n")
-            #res = res.delete(" ").delete("\t")
+            # res = res.delete(" ").delete("\t")
             res.delete("\r")
             @res = @res + res
-            #write_text_node(node,visible) if (@state == INSIDE_DOC_ELEMENT)
+            # write_text_node(node,visible) if (@state == INSIDE_DOC_ELEMENT)
             return
           end
           if (node.node_type() == :text)
             write_text_node(node, visible)
             return
-          end		
+          end
           if (node.node_type() == :element)
-            write_element_node(node, visible) if (!node.rendered?())
-				    node.rendered=(true)
+            write_element_node(node, visible)
           end
           if (node.node_type() == :processing_instruction)
           end
@@ -192,13 +125,13 @@ module XML
           write_attribute_axis(node)
           @res = @res + ">" if (visible)
           node.each_child{|child|
-    			 	write_node(child)
-    			}
+            write_node(child)
+          }
           @res = @res + "</" +node.expanded_name() + ">" if (visible)
           @state = AFTER_DOC_ELEMENT if (visible && state == BEFORE_DOC_ELEMENT)
           @prevVisibleNamespacesStart = savedPrevVisibleNamespacesStart
           @prevVisibleNamespacesEnd = savedPrevVisibleNamespacesEnd
-          @visibleNamespaces.slice!(savedVisibleNamespacesSize, @visibleNamespaces.size() - savedVisibleNamespacesSize) 		if (@visibleNamespaces.size() > savedVisibleNamespacesSize)
+          @visibleNamespaces.slice!(savedVisibleNamespacesSize, @visibleNamespaces.size() - savedVisibleNamespacesSize) if (@visibleNamespaces.size() > savedVisibleNamespacesSize)
         end
         
         def write_namespace_axis(node, visible)
@@ -206,10 +139,9 @@ module XML
           has_empty_namespace = false
           list = Array.new()
           cur = node
-          #while ((cur != nil) && (cur != doc) && (cur.node_type() != :document)) 
-          namespaces = cur.node_namespaces()
-          namespaces.each{|prefix|
-            next if ((prefix == "xmlns") && (node.namespace(prefix) == "")) 
+          # while ((cur != nil) && (cur != doc) && (cur.node_type() != :document))
+          node_namespaces(cur).each{|prefix|
+            next if ((prefix == "xmlns") && (node.namespace(prefix) == ""))
             namespace = cur.namespace(prefix)
             next if (is_namespace_node(namespace))
             next if (node.namespace(prefix) != cur.namespace(prefix))
@@ -222,14 +154,14 @@ module XML
             end
             has_empty_namespace = true if (prefix == nil)
           }
-          if (visible && !has_empty_namespace && !is_namespace_rendered(nil, nil)) 
+          if (visible && !has_empty_namespace && !is_namespace_rendered(nil, nil))
             @res = @res + ' xmlns=""'
           end
           
           #: ns of inclusive_list
           if self.inclusive_namespaces && !self.inclusive_namespaces.empty?
             self.inclusive_namespaces.each{|prefix|
-              list.push(prefix) if (!list.include?(prefix) && (node.attributes.prefixes.include?(prefix))) 
+              list.push(prefix) if (!list.include?(prefix) && (node.attributes.prefixes.include?(prefix)))
             }
           end
           
@@ -243,10 +175,24 @@ module XML
           }
           if (visible)
             @prevVisibleNamespacesStart = @prevVisibleNamespacesEnd
-            @prevVisibleNamespacesEnd = @visibleNamespaces.size()	
+            @prevVisibleNamespacesEnd = @visibleNamespaces.size()
           end
         end
         
+        def node_namespaces(node)
+          ns = Array.new()
+          ns.push(node.prefix())
+          node.attributes().each_attribute{|a|
+            if (a.prefix() != nil)
+              ns.push(a.prefix())
+            end
+            if (a.prefix() == "" && a.local_name() == "xmlns")
+              ns.push("xmlns")
+            end
+          }
+          ns
+        end
+        
         def write_attribute_axis(node)
           list = Array.new()
           node.attributes.keys.sort.each{|key|
@@ -256,7 +202,7 @@ module XML
           if (!@exclusive && node.parent() != nil && node.parent().parent() != nil)
             cur = node.parent()
             while (cur != nil)
-              #next if (cur.attributes() == nil)
+              # next if (cur.attributes() == nil)
               cur.each_attribute{|attribute|
                 next if (attribute.prefix() != "xml")
                 next if (attribute.prefix().index("xmlns") == 0)
@@ -277,10 +223,9 @@ module XML
             if (attribute != nil)
               if (attribute.name() != "xmlns")
                 @res = @res + " " + normalize_string(attribute.to_string(), NODE_TYPE_ATTRIBUTE).gsub("'",'"')
+              # else
+              #   @res = @res + " " + normalize_string(attribute.name()+'="'+attribute.to_s()+'"', NODE_TYPE_ATTRIBUTE).gsub("'",'"')
               end
-              #	else
-              #	@res = @res + " " + normalize_string(attribute.name()+'="'+attribute.to_s()+'"', NODE_TYPE_ATTRIBUTE).gsub("'",'"')
-              #end
             end
           }
         end
@@ -302,13 +247,13 @@ module XML
             end
           }
           return is_empty_ns
-          #(@visibleNamespaces.size()-1).downto(start) {|i|
+          # (@visibleNamespaces.size()-1).downto(start) {|i|
           #   ns = @visibleNamespaces[i]
-          #	return true if (ns.prefix() == "xmlns:"+prefix.to_s() && ns.uri() == uri)
-          #	#p = ns.prefix() if (ns.prefix().index("xmlns") == 0) 
-          #	#return ns.uri() == uri if (p == prefix) 
-          #}
-          #return is_empty_ns
+          #   return true if (ns.prefix() == "xmlns:"+prefix.to_s() && ns.uri() == uri)
+          #   # p = ns.prefix() if (ns.prefix().index("xmlns") == 0)
+          #   # return ns.uri() == uri if (p == prefix)
+          # }
+          # return is_empty_ns
         end
         
         def is_node_visible(node)
@@ -322,30 +267,29 @@ module XML
         def normalize_string(input, type)
           sb = ""
           return input
+          # input.each_byte{|b|
+          #   if (b == 60 && (type == NODE_TYPE_ATTRIBUTE || is_text_node(type)))
+          #     sb = sb + "&lt;"
+          #   elsif (b == 62 && is_text_node(type))
+          #     sb = sb + "&gt;"
+          #   elsif (b == 38 && (is_text_node(type) || is_text_node(type))) #Ampersand
+          #     sb = sb + "&amp;"
+          #   elsif (b == 34 && is_text_node(type)) #Quote
+          #     sb = sb + "&quot;"
+          #   elsif (b == 9 && is_text_node(type)) #Tabulator
+          #     sb = sb + "&#x9;"
+          #   elsif (b == 11 && is_text_node(type)) #CR
+          #     sb = sb + "&#xA;"
+          #   elsif (b == 13 && (type == NODE_TYPE_ATTRIBUTE || (is_text_node(type) && type != NODE_TYPE_WHITESPACE) || type == NODE_TYPE_COMMENT || type == NODE_TYPE_PI))
+          #     sb = sb + "&#xD;"
+          #   elsif (b == 13)
+          #     next
+          #   else
+          #     sb = sb.concat(b)
+          #   end
+          # }
+          # sb
         end
-        #input.each_byte{|b|
-        #	if (b ==60 && (type == NODE_TYPE_ATTRIBUTE || is_text_node(type)))
-        #		sb = sb + "&lt;"
-        #	elsif (b == 62 && is_text_node(type))
-        #		sb = sb + "&gt;"
-        #	elsif (b == 38 && (is_text_node(type) || is_text_node(type))) #Ampersand
-        #		sb = sb + "&amp;"
-        #	elsif (b == 34 && is_text_node(type)) #Quote
-        #		sb = sb + "&quot;"
-        #	elsif (b == 9 && is_text_node(type)) #Tabulator
-        #		sb = sb + "&#x9;"
-        #	elsif (b == 11 && is_text_node(type)) #CR
-        #		sb = sb + "&#xA;"
-        #	elsif (b == 13 && (type == NODE_TYPE_ATTRIBUTE || (is_text_node(type) && type != NODE_TYPE_WHITESPACE) || type == NODE_TYPE_COMMENT || type == NODE_TYPE_PI))
-        #		sb = sb + "&#xD;"
-        #	elsif (b == 13)
-        #		next
-        #	else
-        #		sb = sb.concat(b)
-        #	end
-        #}
-        #sb
-        #end
         
         def write_text_node(node, visible)
           if (visible)
@@ -359,7 +303,7 @@ module XML
         end
         
         def is_namespace_decl(attribute)
-          #return true if (attribute.name() == "xmlns")
+          # return true if (attribute.name() == "xmlns")
           return true if (attribute.prefix().index("xmlns") == 0)
           return false
         end
@@ -373,8 +317,8 @@ module XML
           new_string = ""
           in_white = false
           string.each_byte{|b|
-            #if (in_white && b == 32)
-            #else
+            # if (in_white && b == 32)
+            # else
             if !(in_white && b == 32)
               new_string = new_string + b.chr()
             end
@@ -388,7 +332,7 @@ module XML
           new_string
         end
       end
-    end #Util
+  end #Util
 end #XML
 
 
@@ -397,7 +341,7 @@ if __FILE__ == $0
   body = nil
   c = WSS4R::Security::Util::XmlCanonicalizer.new(false, true)
   
-  if (ARGV.size() == 3) 
+  if (ARGV.size() == 3)
     body = ARGV[2]
     if (body == "true")
       element = XPath.match(document, "/soap:Envelope/soap:Body")[0]
@@ -406,15 +350,15 @@ if __FILE__ == $0
       puts("-----")
       puts(result)
       puts("-----")
-      puts(result.size())            
+      puts(result.size())
       puts("-----")
       puts(CryptHash.new().digest_b64(result))
     end
-  else 
+  else
     result = c.canonicalize(document)
   end
     
   file = File.new(ARGV[1], "wb")
   file.write(result)
   file.close()
-end
+end

data/lib/xmlcanonicalizer.rb

@@ -1 +1 @@
-require 'xml/util/xmlcanonicalizer'
+require 'xml/util/xmlcanonicalizer'

data/test/helper.rb

@@ -8,3 +8,15 @@ require 'xmlcanonicalizer'
 
 class Test::Unit::TestCase
 end
+
+def fixture_path(name)
+  File.join(File.dirname(__FILE__), name)
+end
+
+def fixture(name)
+  File.read(fixture_path(name))
+end
+
+def rexml_fixture(name)
+  REXML::Document.new(fixture(name))
+end

data/test/test_xmlcanonicalizer.rb

@@ -1,79 +1,105 @@
 require File.dirname(File.expand_path(__FILE__))+'/helper'
 
-class TestXmlcanonicalizer < Test::Unit::TestCase
+class TestXmlCanonicalizer < Test::Unit::TestCase
   
   should "canonicalize a simple xml file" do
     xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
-    xml = "<foo bar='test'/>";
-    rexml = REXML::Document.new(xml);
-    xml_canonicalized = xml_canonicalizer.canonicalize(rexml);
-    xml_expect = "<foo bar=\"test\"></foo>";
+    
+    xml = "<foo bar='test'/>"
+    rexml = REXML::Document.new(xml)
+    xml_canonicalized = xml_canonicalizer.canonicalize(rexml)
+    
+    xml_expect = "<foo bar=\"test\"></foo>"
     assert_equal xml_expect, xml_canonicalized
   end
   
   should "canonicalize a complex xml file" do
-    fp = File.new(File.dirname(File.expand_path(__FILE__))+'/complex.xml','r')
-    xml = ''
-    while (l = fp.gets)
-      xml += l
-    end
-    fp.close
-    
     xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
-    rexml = REXML::Document.new(xml);
-    xml_canonicalized = xml_canonicalizer.canonicalize(rexml);
     
-    fp = File.new(File.dirname(File.expand_path(__FILE__))+'/expected.xml','r')
-    xml_expect = ''
-    while (l = fp.gets)
-      xml_expect += l
-    end
-    fp.close
+    rexml = rexml_fixture("complex.xml")
+    xml_canonicalized = xml_canonicalizer.canonicalize(rexml)
     
+    xml_expect = fixture("expected.xml")
     assert_equal xml_expect, xml_canonicalized
   end
-
-  should "canonicalize a saml xml file correctly" do
-    fp = File.new(File.dirname(File.expand_path(__FILE__))+'/saml_assertion.xml','r')
-    xml = ''
-    while (l = fp.gets)
-      xml += l
-    end
-    fp.close
+  
+  should "canonicalize multiple documents" do
+    xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
+    
+    rexml_1 = rexml_fixture("complex.xml")
+    xml_canonicalizer.canonicalize(rexml_1)
+    
+    rexml_2 = rexml_fixture("complex.xml")
+    xml_canonicalized_2 = xml_canonicalizer.canonicalize(rexml_2)
+    
+    xml_expect = fixture("expected.xml")
+    assert_equal xml_expect, xml_canonicalized_2
+  end
+  
+  should "canonicalize the same document multiple times" do
+    xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
+    
+    rexml = rexml_fixture("complex.xml")
+    xml_canonicalized_1 = xml_canonicalizer.canonicalize(rexml)
+    xml_canonicalized_2 = xml_canonicalizer.canonicalize(rexml)
+    
+    assert_equal xml_canonicalized_1, xml_canonicalized_2
+  end
+  
+  should "canonicalize an xml element correctly" do
+    xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
     
+    rexml = rexml_fixture("complex.xml")
+    element = REXML::XPath.first(rexml, "//AttributeValue[@FriendlyName='type']")
+    element_canonicalized = xml_canonicalizer.canonicalize(element)
+    
+    element_expected = '<AttributeValue FriendlyName="type" type="example:profile:attribute">Person</AttributeValue>'
+    assert_equal element_expected, element_canonicalized
+  end
+  
+  should "canonicalize the same element multiple times" do
+    xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
+    
+    rexml = rexml_fixture("complex.xml")
+    element = REXML::XPath.first(rexml, "//AttributeValue[@FriendlyName='type']")
+    element_canonicalized_1 = xml_canonicalizer.canonicalize(element)
+    element_canonicalized_2 = xml_canonicalizer.canonicalize(element)
+    
+    assert_equal element_canonicalized_1, element_canonicalized_2
+  end
+  
+  should "canonicalize multiple xml elements correctly" do
+    xml_canonicalizer = XML::Util::XmlCanonicalizer.new(true,true)
+    
+    rexml = rexml_fixture("complex.xml")
+    
+    element_1 = REXML::XPath.first(rexml, "//AttributeValue[@FriendlyName='type']")
+    xml_canonicalizer.canonicalize(element_1)
+    
+    element_2 = REXML::XPath.first(rexml, "//AuthnStatement")
+    element_2_canonicalized = xml_canonicalizer.canonicalize(element_2)
+    element_2_expected = '<AuthnStatement AuthnInstant="2010-09-10T00:00:50-05:00"><AuthnContext><AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:PreviousSession</AuthnContextClassRef></AuthnContext></AuthnStatement>'
+    assert_equal element_2_expected, element_2_canonicalized
+  end
+  
+  should "canonicalize a saml xml file correctly" do
     xml_canonicalizer = XML::Util::XmlCanonicalizer.new(false,true)
-    rexml = REXML::Document.new(xml);
-    xml_canonicalized = xml_canonicalizer.canonicalize(rexml);
     
-    fp = File.new(File.dirname(File.expand_path(__FILE__))+'/saml_expected_canonical_form.xml','r')
-    xml_expect = ''
-    while (l = fp.gets)
-      xml_expect += l
-    end
-    fp.close
+    rexml = rexml_fixture("saml_assertion.xml")
+    xml_canonicalized = xml_canonicalizer.canonicalize(rexml)
     
+    xml_expect = fixture("saml_expected_canonical_form.xml")
     assert_equal xml_expect, xml_canonicalized
   end
   
   should "canonicalize a saml file with inclusive namespaces" do
-    fp = File.new(File.dirname(File.expand_path(__FILE__))+'/saml_with_inclusive_ns_assertion.xml','r')
-    xml = ''
-    while (l = fp.gets)
-      xml += l
-    end
-    fp.close
-    
     xml_canonicalizer = XML::Util::XmlCanonicalizer.new(false,true)
-    rexml = REXML::Document.new(xml);
+    
+    rexml = rexml_fixture("saml_with_inclusive_ns_assertion.xml")
     xml_canonicalizer.inclusive_namespaces = %w(ds saml samlp xs)
-    xml_canonicalized = xml_canonicalizer.canonicalize(rexml);
-    
-    fp = File.new(File.dirname(File.expand_path(__FILE__))+'/saml_with_inclusive_ns_expected_canonical_form.xml','r')
-    xml_expect = ''
-    while (l = fp.gets)
-      xml_expect += l
-    end
-    fp.close
+    xml_canonicalized = xml_canonicalizer.canonicalize(rexml)
+    
+    xml_expect = fixture("saml_with_inclusive_ns_expected_canonical_form.xml")
     assert_equal xml_expect, xml_canonicalized #, (xml_canonicalized.to_s + "\n\n" + xml_expect)
   end
 

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: canonix
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: 
-  version: 0.1.3
+  segments: 
+  - 0
+  - 1
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Brendon Muir
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-03 00:00:00 +12:00
+date: 2011-07-12 00:00:00 +12:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +26,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id001
@@ -67,19 +75,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   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.5.0
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
-summary: XML Canonicalizer for Ruby >= 1.92
+summary: XML Canonicalizer for Ruby >= 1.9.2
 test_files: []