rsxml 0.2.1 → 0.3.0

data/README.rdoc

@@ -6,7 +6,7 @@ Why would you want to do this ? Well, s-expressions can be == compared natively
 and editors indent them nicely when embedded in code. These features make them very suitable for writing readable
 XML generation code and readable tests for XML generating code
 
-Rsxml uses Nokogiri[http://nokogiri.org/] for parsing XML, and Builder[http://builder.rubyforge.org/] to generate it. Rsxml is not intended to be a feature complete XML representation : It does not attempt to represent PIs, CDATA etc, but it does make it very easy to use and generate straightforward XML documents from Ruby
+Rsxml uses Nokogiri[http://nokogiri.org/] for parsing XML, and Builder[http://builder.rubyforge.org/] to generate it. Rsxml is not intended to be a feature complete XML processor : It does not attempt to process PIs, CDATA etc, but it does make it very easy to use and generate straightforward XML documents from Ruby
 
 Rsxml represents XML documents as s-expressions thus :
 
@@ -25,9 +25,9 @@ It is easy to convert XML docuemnts to Rsxml representation and back again :
 
 === Namespaces
 
-XML namespaces are dealt with straightforwardly. When an XML document is converted to Rsxml, namespaces are preserved, and you can specify namespaces in an Rsxml structure in two ways
+XML namespaces are dealt with straightforwardly. When an XML document is converted to Rsxml, namespaces are preserved, and you can specify namespaces in an Rsxml structure in two ways, which can be freely mixed
 * using QName prefixes and declarative attributes, exactly as with XML
-* using exploded QNames consisting of <tt>[local_name, prefix, uri]</tt> triples and <tt>[local_name, prefix]</tt> pairs
+* using exploded QNames consisting of <tt>[local_part, prefix, uri]</tt> triples and <tt>[local_part, prefix]</tt> pairs
 
 === Converting to Rsxml
 
@@ -44,7 +44,7 @@ prefixed QNames, just as in XML
 ==== <tt>:exploded</tt> style
 
 In <tt>:exploded</tt> style namespaces are not declared using attributes, and QNames are specified
-using <tt>[local_name, prefix, uri]</tt> triples
+using <tt>[local_part, prefix, uri]</tt> triples
 
  Rsxml.to_rsxml('<foo:foofoo xmlns:foo="http://foo.com/foo" foo:bar="barbar"/>', :style=>:exploded)
    => [["foofoo", "foo", "http://foo.com/foo"], {["bar", "foo", "http://foo.com/foo"]=>"barbar"}]
@@ -69,6 +69,18 @@ Fragments can be generated similarly :
  Rsxml.to_xml(["foo:foofoo", {"foo:bar"=>"barbar"}], :ns=>{"foo"=>"http://foo.com/foo"})
    => '<foo:foofoo foo:bar="barbar"></foo:foofoo>'
 
+== Visitors
+
+<tt>Rsxml.to_rsxml</tt> and <tt>Rsxml.to_xml</tt> are implemented with a simple Visitor pattern over the XML document structure. <tt>Rsxml::Sexp.traverse()</tt> traverses a Rsxml s-expression representation of an XML document and <tt>Rsxml::Xml.traverse()</tt> traverses a Nokogiri Node tree. The Visitor receives a
+
+ text(context, text)
+
+invocation for each text node, and an
+
+ element(context, name, attrs, ns_decls)
+
+method invocation for each element. If namespaces are used, element and attribute names in the <tt>element</tt> method invocations are exploded <tt>[local_part, prefix, uri]</tt> triples. The attributes are presented as a <tt>{name=>value}</tt> +Hash+ which contains no namespace-related attributes. Any namespace declarations for the element are provided as the <tt>{prefix=>uri}</tt> +ns_decls+ +Hash+. Namespace prefixes, URIs and declaration attributes are cleanly separated in this API, so it is easy for Visitor implementations to correctly process XML documents with namespaces
+
 == Install
 
  gem install rsxml

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/rsxml/namespace.rb

@@ -13,9 +13,9 @@ module Rsxml
     def explode_attr_qnames(ns_stack, attrs)
       Hash[attrs.map do |name, value|
              uq_name = explode_qname(ns_stack, name, true)
-             local_name, prefix, uri = uq_name
+             local_part, prefix, uri = uq_name
              if !prefix || prefix==""
-               [local_name, value]
+               [local_part, value]
              else
                [uq_name, value]
              end
@@ -39,15 +39,22 @@ module Rsxml
       end
     end
 
-    # split a QName into [LocalPart, prefix, URI] triple
+    # split a QName into [LocalPart, prefix, URI] triple. fill out
+    # missing uris if necessary, and check QName is well specified
     def explode_qname(ns_stack, qname, attr=false)
       if qname.is_a?(Array)
-        if qname.length>1 && !qname[1].nil?
-          return qname
-        elsif qname.length>1 && qname[1].nil? && !qname[2].nil?
-          raise "invalid name: #{qname.inspect}"
+        local_part, prefix, uri = qname
+        if uri
+          raise "invalid name: #{qname.inspect}" if !prefix
+          bound_uri = find_namespace_uri(ns_stack, prefix)
+          raise "namespace conflict: prefix '#{prefix}' refers to '#{uri}' and '#{bound_uri}'" if bound_uri && uri != bound_uri
+          return [local_part, prefix, uri]
+        elsif prefix
+          uri = find_namespace_uri(ns_stack, prefix)
+          raise "namespace prefix not bound: '#{prefix}'" if !uri
+          return [local_part, prefix, uri]
         else
-          return qname[0]
+          return local_part
         end
       end
 
@@ -93,24 +100,28 @@ module Rsxml
       uri
     end
 
-
-    # extract a Hash of {prefix=>uri} mappings declared in attributes
-    def extract_declared_namespace_bindings(attrs)
-      Hash[attrs.map do |name,value|
-             local_part, prefix, uri = split_qname(name)
-             if (prefix && prefix == "xmlns")
-               [local_part, value]
-             elsif (!prefix && local_part == "xmlns")
-               ["", value]
-             end
-           end.compact]
+    # split attributes into non-namespace related attrs and {prefix=>uri} namespace bindings
+    def partition_namespace_decls(attrs)
+      nonns_attrs = []
+      ns_bindings = []
+      attrs.each do |name, value| 
+        local_part, prefix = split_qname(name)
+        if prefix && prefix=="xmlns"
+          ns_bindings << [local_part, value]
+        elsif !prefix && local_part=="xmlns"
+          ns_bindings << ["", value]
+        else
+          nonns_attrs << [name, value]
+        end
+      end
+      [Hash[nonns_attrs], Hash[ns_bindings]]
     end
 
-    # extract a Hash of {prefix=>uri} mappings from exploded QName tag and attrs
-    def extract_explicit_namespace_bindings(tag, attrs)
-      tag_local_part, tag_prefix, tag_uri = tag
+    # extract a Hash of {prefix=>uri} mappings from exploded QName element and attrs
+    def extract_explicit_namespace_bindings(element_name, attrs)
+      element_name_local_part, element_name_prefix, element_name_uri = element_name
       ns = {}
-      ns[tag_prefix] = tag_uri if tag_prefix && tag_uri
+      ns[element_name_prefix] = element_name_uri if element_name_prefix && element_name_uri
 
       attrs.each do |name, value|
         attr_local_part, attr_prefix, attr_uri = name
@@ -125,7 +136,7 @@ module Rsxml
     # figure out which explicit namespaces need declaring
     #
     # +ns_stack+ is the stack of namespace bindings
-    # +ns_explicit+ is the explicit refs for a tag
+    # +ns_explicit+ is the explicit refs for a element
     def undeclared_namespace_bindings(ns_stack, ns_explicit)
       Hash[ns_explicit.map do |prefix,uri|
              [prefix, uri] if !find_namespace_uri(ns_stack, prefix, uri)
@@ -145,6 +156,18 @@ module Rsxml
            end]
     end
 
+    # produces a Hash of compact namespace attributes from a
+    # Hash of namespace bindings
+    def namespace_attributes(ns)
+      Hash[ns.map do |prefix, uri|
+             if prefix==""
+               ["xmlns", uri]
+             else
+               [["xmlns", prefix].join(":"), uri]
+             end
+           end]
+    end
+
     # merges two sets of namespace bindings, raising error on clash
     def merge_namespace_bindings(ns1, ns2)
       m = ns1.clone
@@ -155,20 +178,18 @@ module Rsxml
       m
     end
 
-    # given the existing +ns_stack+ of ns bindings, a +tag+ and it's +attributes+,
-    # return a pair <tt>[ns_bindings, ns_additional_decls]</tt> containing
-    # ns bindings for the stack, and additional required (exploded) namespace 
-    # declarations to be added to the attributes
-    def namespace_bindings_declarations(ns_stack, tag, attrs)
-      ns_declared = extract_declared_namespace_bindings(attrs)
-      ns_explicit = extract_explicit_namespace_bindings(tag, attrs)
+    # given the existing +ns_stack+ of ns bindings, a +element_name+ and it's +attributes+,
+    # return a pair <tt>[non_ns_attrs, ns_bindings]</tt> containing
+    # non-ns related attributes, and namespace bindings for the current element,
+    # both those declared in attributes and declared implicitly through exploded element names
+    def non_ns_attrs_ns_bindings(ns_stack, element_name, attrs)
+      non_ns_attrs, ns_declared = partition_namespace_decls(attrs)
+
+      ns_explicit = extract_explicit_namespace_bindings(element_name, attrs)
       ns_undeclared = undeclared_namespace_bindings(ns_stack + [ns_declared], ns_explicit)
       ns_bindings = merge_namespace_bindings(ns_declared, ns_undeclared)
 
-      # and declarations for undeclared namespaces
-      ns_additional_decls = exploded_namespace_declarations(ns_undeclared)
-      
-      [ns_bindings, ns_additional_decls]
+      [non_ns_attrs, ns_bindings]
     end
 
   end

data/lib/rsxml/sexp.rb

@@ -6,34 +6,25 @@ module Rsxml
     # pre-order traversal of the sexp, calling methods on
     # the visitor with each node
     def traverse(sexp, visitor, context=Visitor::Context.new)
-      tag, attrs, children = decompose_sexp(sexp)
+      element_name, attrs, children = decompose_sexp(sexp)
       
-      ns_bindings, ns_additional_decls = Namespace::namespace_bindings_declarations(context.ns_stack, tag, attrs)
+      non_ns_attrs, ns_bindings = Namespace::non_ns_attrs_ns_bindings(context.ns_stack, element_name, attrs)
 
       context.ns_stack.push(ns_bindings)
 
-      etag = Namespace::explode_qname(context.ns_stack, tag)
-      eattrs = Namespace::explode_attr_qnames(context.ns_stack, attrs)
-
-      eattrs = eattrs.merge(ns_additional_decls)
+      eelement_name = Namespace::explode_qname(context.ns_stack, element_name)
+      eattrs = Namespace::explode_attr_qnames(context.ns_stack, non_ns_attrs)
 
       begin
-        visitor.tag(context, etag, eattrs) do
-          context.push_node([etag, eattrs])
-          begin
-            children.each_with_index do |child, i|
-              if child.is_a?(Array)
-                traverse(child, visitor, context)
-              else
-                visitor.text(context, child)
-                context.processed_node(child)
-              end
+        visitor.element(context, eelement_name, eattrs, ns_bindings) do
+          children.each_with_index do |child, i|
+            if child.is_a?(Array)
+              traverse(child, visitor, context)
+            else
+              visitor.text(context, child)
             end
-          ensure
-            context.pop_node
           end
         end
-
       ensure
         context.ns_stack.pop
       end
@@ -41,13 +32,13 @@ module Rsxml
       visitor
     end
 
-    # decompose a sexp to a [tag, attrs, children] list
+    # decompose a sexp to a [element_name, attrs, children] list
     def decompose_sexp(sexp)
       raise "invalid rsxml: #{rsxml.inspect}" if sexp.length<1
       if sexp[0].is_a?(Array)
-        tag = sexp[0]
+        element_name = sexp[0]
       else
-        tag = sexp[0].to_s
+        element_name = sexp[0].to_s
       end
       if sexp[1].is_a?(Hash)
         attrs = sexp[1]
@@ -56,7 +47,7 @@ module Rsxml
         attrs = {}
         children = sexp[1..-1]
       end
-      [tag, attrs, children]
+      [element_name, attrs, children]
     end
 
     class ComparisonError < RuntimeError
@@ -68,14 +59,14 @@ module Rsxml
     end
 
     def compare(sexpa, sexpb, path=nil)
-      taga, attrsa, childrena = decompose_sexp(sexpa)
-      tagb, attrsb, childrenb = decompose_sexp(sexpb)
+      element_name_a, attrsa, childrena = decompose_sexp(sexpa)
+      element_name_b, attrsb, childrenb = decompose_sexp(sexpb)
 
-      raise ComparisonError.new("element names differ: '#{taga}', '#{tagb}'", path) if taga != tagb
+      raise ComparisonError.new("element names differ: '#{element_name_a}', '#{element_name_b}'", path) if element_name_a != element_name_b
       raise ComparisonError.new("attributes differ", path) if attrsa != attrsb
       raise ComparisonError.new("child count differs", path) if childrena.length != childrenb.length
 
-      path = [path, taga].compact.join("/")
+      path = [path, element_name_a].compact.join("/")
       (0...childrena.length).each do |i|
         if childrena[i].is_a?(Array) && childrenb[i].is_a?(Array)
           compare(childrena[i], childrenb[i], path)

data/lib/rsxml/visitor.rb

@@ -6,30 +6,9 @@ module Rsxml
 
     class Context
       attr_reader :ns_stack
-      attr_reader :node_stack
-      attr_reader :prev_siblings
       def initialize(initial_ns_bindings = nil)
         @ns_stack=[]
         @ns_stack << initial_ns_bindings if initial_ns_bindings
-        @node_stack=[]
-        @prev_siblings=[]
-        @sibling_stack=[]
-      end
-
-      def push_node(node)
-        node_stack.push(node)
-        @sibling_stack.push(@prev_siblings)
-        @prev_siblings=[]
-      end
-
-      def pop_node
-        n = node_stack.pop
-        @prev_siblings = @sibling_stack.pop
-        @prev_siblings << n
-      end
-
-      def processed_node(node)
-        @prev_siblings << node
       end
     end
 
@@ -40,11 +19,13 @@ module Rsxml
         @xml = xml_builder || Builder::XmlMarkup.new
       end
 
-      def tag(context, name, attrs)
+      def element(context, name, attrs, ns_decls)
         qname = Namespace::compact_qname(context.ns_stack, name)
         qattrs = Namespace::compact_attr_qnames(context.ns_stack, attrs)
+        ns_attrs = Namespace::namespace_attributes(ns_decls)
+        attrs = qattrs.merge(ns_attrs)
 
-        xml.__send__(qname, qattrs) do
+        xml.__send__(qname, attrs) do
           yield
         end
       end
@@ -62,50 +43,42 @@ module Rsxml
       attr_reader :sexp
       attr_reader :cursor_stack 
       attr_reader :opts
+      attr_reader :element_transformer
 
       # The <tt>:style</tt> option specifies how the Rsxml is to be produced
-      #  :xml style is with compact <tt>"prefix:local_name"</tt> Strings for QNames, and namespace declaration attributes
-      #  :exploded style is with <tt>[local_name, prefix, uri]</tt> triples for QNames, and no namespace declaration attributes
+      #  :xml style is with compact <tt>"prefix:local_part"</tt> Strings for QNames, and namespace declaration attributes
+      #  :exploded style is with <tt>[local_part, prefix, uri]</tt> triples for QNames, and no namespace declaration attributes
       OPTS = {:style=>[:xml, :exploded]}
 
-      def initialize(opts=nil)
-        @opts = opts || {}
-        opts = Util.check_opts(OPTS, opts)
+      def initialize(opts=nil, &element_transformer)
+        @opts = Util.check_opts(OPTS, opts) 
         @cursor_stack = []
-        @sexp
+        @element_transformer = element_transformer
       end
 
       def compact_qname(qname)
-        local_name, prefix, uri = qname
+        local_part, prefix, uri = qname
 
-        [prefix, local_name].map{|s| (!s || s.empty?) ? nil : s}.compact.join(":")
+        [prefix, local_part].map{|s| (!s || s.empty?) ? nil : s}.compact.join(":")
       end
 
       def compact_attr_names(attrs)
         Hash[attrs.map{|qname,value| [compact_qname(qname), value]}]
       end
 
-      # strip namespace decls from exploded attributes
-      def strip_namespace_decls(attrs)
-        Hash[attrs.map do |qname,value| 
-               local_name, prefix, uri = qname
-               if !(prefix=="xmlns" || (prefix==nil && local_name=="xmlns"))
-                 [qname,value]
-               end
-             end.compact]
-      end
+      def element(context, element_name, attrs, ns_decls)
 
-      def tag(context, tag, attrs)
+        element_name, attrs = element_transformer.call(context, element_name, attrs) if element_transformer
 
         opts[:style] ||= :exploded
         if opts[:style] == :xml
-          tag = compact_qname(tag)
+          element_name = compact_qname(element_name)
           attrs = compact_attr_names(attrs)
-        elsif opts[:style] == :exploded
-          attrs = strip_namespace_decls(attrs)
+          ns_attrs = Namespace.namespace_attributes(ns_decls)
+          attrs = attrs.merge(ns_attrs)
         end
         
-        el = [tag, (attrs if attrs.size>0)].compact
+        el = [element_name, (attrs if attrs.size>0)].compact
 
         if !cursor_stack.last
           @sexp = el

data/lib/rsxml/xml.rb

@@ -36,18 +36,8 @@ module Rsxml
       node = node_uri ? [node_name, node_prefix, node_uri] : node_name
     end
 
-    def explode_ns_definitions(element)
-      Hash[element.namespace_definitions.map do |ns|
-             if ns.prefix
-               [[ns.prefix, "xmlns"], ns.href]
-             else
-               ["xmlns", ns.href]
-             end
-           end]
-    end
-
     # given a <tt>Nokogiri::XML::Element</tt> in +element+ , produce
-    # a <tt>[[local_name, prefix, namespace], {[local_name, prefix, namespace]=>value}</tt>
+    # a <tt>[[local_part, prefix, namespace], {[local_part, prefix, namespace]=>value}</tt>
     # pair of exploded element name and attributes with exploded names
     def explode_element(element)
       eelement = explode_node(element)
@@ -56,36 +46,36 @@ module Rsxml
                       [explode_node(attr), attr.value]
                     end]
 
-      ns_decl_attrs = explode_ns_definitions(element)
-      eattrs = eattrs.merge(ns_decl_attrs)
-
       [eelement, eattrs]
     end
 
+    # give a list of <tt>Nokogiri::XML::Namespace</tt> definitions, produce
+    # a Hash <tt>{prefix=>uri}</tt> of namespace bindings
+    def namespace_bindings_from_defs(ns_defs)
+      (ns_defs||[]).reduce({}) do |h,ns_def|
+        h[ns_def.prefix||""] = ns_def.href
+        h
+      end
+    end
+
     # pre-order traversal of the Nokogiri Nodes, calling methods on
     # the visitor with each Node
     def traverse(element, visitor, context = Visitor::Context.new)
-      eelement, eattrs = explode_element(element)
-
-      ns_bindings = Rsxml::Namespace.extract_declared_namespace_bindings(element.namespaces)
+      ns_bindings = namespace_bindings_from_defs(element.namespace_definitions)
       context.ns_stack.push(ns_bindings)
 
+      eelement, eattrs = explode_element(element)
+
       begin
-        visitor.tag(context, eelement, eattrs) do
-          context.push_node([eelement, eattrs])
-          begin
-            element.children.each do |child|
-              if child.element?
-                traverse(child, visitor, context)
-              elsif child.text?
-                visitor.text(context, child.content)
-                context.processed_node(child.content)
-              else
-                Rsxml.log{|logger| logger.warn("unknown Nokogiri Node type: #{child.inspect}")}
-              end
+        visitor.element(context, eelement, eattrs, ns_bindings) do
+          element.children.each do |child|
+            if child.element?
+              traverse(child, visitor, context)
+            elsif child.text?
+              visitor.text(context, child.content)
+            else
+              Rsxml.log{|logger| logger.warn("unknown Nokogiri Node type: #{child.inspect}")}
             end
-          ensure
-            context.pop_node
           end
         end
       ensure

data/spec/rsxml/mock_visitor.rb

@@ -0,0 +1,43 @@
+module Rsxml
+  module Visitor
+    # a mock visitor which can be used to check expectations
+    class MockVisitor
+      attr_reader :expectations
+      
+      def initialize(expectations)
+        @expectations = expectations.clone
+      end
+
+      def __format_invocation__(method, args)
+        "#{method}(#{(args||[]).map(&:inspect).join(', ')})"
+      end
+
+      def __check_arg_expectation__(arg_xp, arg)
+        return true if arg_xp == :_
+        return arg_xp.call(arg) if arg_xp.is_a?(Proc)
+        return arg_xp == arg
+      end
+
+      def __check_expectation__(method, args)
+        xp_method, *xp_args = expectations.shift
+        msg = "unexpected invocation: #{__format_invocation__(method, args)}. expected: #{__format_invocation__(xp_method, xp_args)}"
+        raise msg if method!=xp_method || args.length != xp_args.length
+        (0...xp_args.length).each do |i|
+          raise msg if !__check_arg_expectation__(xp_args[i], args[i])
+        end
+      end
+
+      def __finalize__
+        raise "missing invocations: #{expectations.map{|xp_method, *xp_args| __format_invocation__(xp_method, xp_args)}.join('\n')}" if expectations && expectations.length>0
+      end
+
+      # check that there is an expectation for the invoked method, and if 
+      # a block is given yield to that block
+      def method_missing(method, *args, &block)
+        __check_expectation__(method, args)
+        block.call if block
+      end
+
+    end
+  end
+end

data/spec/rsxml/namespace_spec.rb

@@ -22,11 +22,26 @@ module Rsxml
   end
 
   describe "explode_qname" do
-    it "should do nothing to an array with more than one element" do
+    it "should do nothing to an array with an exploded name" do
       Namespace.explode_qname([], ["bar", "foo", "http://foo.com/foo"]).should ==
         ["bar", "foo", "http://foo.com/foo"]
-      Namespace.explode_qname([], ["bar", "foo"]).should ==
-        ["bar", "foo"]
+    end
+
+    it "should fill in the uri if a bound prefix with no uri is given" do
+      Namespace.explode_qname([{"foo"=>"http://foo.com/foo"}], ["bar", "foo"]).should ==
+        ["bar", "foo", "http://foo.com/foo"]
+    end
+
+    it "should raise an exception if an unbound prefix and no uri is given" do
+      lambda{
+        Namespace.explode_qname([], ["bar", "foo"])
+      }.should raise_error(/not bound/)
+    end
+
+    it "should raise an execption if a prefix and uri are given which conflict with ns bindings" do
+      lambda{
+        Namespace.explode_qname([{"foo"=>"http://foo.com/foo"}], ["bar", "foo", "http://bar.com/bar"])
+      }.should raise_error
     end
 
     it "should return the first element of an array with only the first non-nil element" do
@@ -159,15 +174,15 @@ module Rsxml
 
   end
 
-  describe "extract_declared_namespace_bindings" do
-    it "should extract a hash of declared namespace bindings from a Hash of attributes" do
-      Namespace.extract_declared_namespace_bindings({"xmlns"=>"http://default.com/default", "xmlns:foo"=>"http://foo.com/foo", "foo"=>"bar"}).should ==
-        {""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}
+  describe "partition_namespace_decls" do
+    it "should partition attributes into non-namespace attributes and a hash of namespace bindings" do
+      Namespace.partition_namespace_decls({"xmlns"=>"http://default.com/default", "xmlns:foo"=>"http://foo.com/foo", "foo"=>"bar"}).should ==
+        [{"foo"=>"bar"},{""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}]
     end
   end
 
   describe "extract_explicit_namespace_bindings" do
-    it "should extract a hash of explicit namespace bindings from expanded tags" do
+    it "should extract a hash of explicit namespace bindings from expanded QNames" do
       Namespace.extract_explicit_namespace_bindings(["bar", "foo", "http://foo.com/foo"],
                                                     {["baz", "bar", "http://bar.com/bar"]=>"baz",
                                                       ["boo", "", "http://default.com/default"]=>"boo"}).should ==
@@ -225,26 +240,38 @@ module Rsxml
     end
   end
 
-  describe "namespace_bindings_declarations" do
-    it "should extract declared and explicit bindings and additional declarations" do
-      Namespace.namespace_bindings_declarations([{"foo"=>"http://foo.com/foo"}], 
-                                                [:bar, "foo", "http://foo.com/foo"], 
-                                                { [:b, "bar", "http://bar.com/bar"]=>"barbar",
-                                                  [:c, "baz", "http://baz.com/baz"]=>"bazbaz",
-                                                  [:d, "foo"]=>"booboo"}).should ==
-        [{ "baz"=>"http://baz.com/baz", 
-           "bar"=>"http://bar.com/bar"}, 
-         { ["baz", "xmlns"]=>"http://baz.com/baz", 
-           ["bar", "xmlns"]=>"http://bar.com/bar"}]
+  describe "namespace_attributes" do
+    it "should produce a Hash of namespace declaration attributes" do
+      Namespace.namespace_attributes({""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}).should == 
+        {"xmlns"=>"http://default.com/default", "xmlns:foo"=>"http://foo.com/foo"}
+    end
+  end
+
+  describe "non_ns_attrs_ns_bindings" do
+    it "should extract non-ns attributes and explicit namespace bindings" do
+      Namespace.non_ns_attrs_ns_bindings([{"foo"=>"http://foo.com/foo"}], 
+                                         [:bar, "foo", "http://foo.com/foo"], 
+                                         { "xmlns:boo"=>"http://boo.com/boo",
+                                           [:b, "bar", "http://bar.com/bar"]=>"barbar",
+                                           [:c, "baz", "http://baz.com/baz"]=>"bazbaz",
+                                           [:d, "foo"]=>"booboo"}).should ==
+        [{[:b, "bar", "http://bar.com/bar"]=>"barbar",
+           [:c, "baz", "http://baz.com/baz"]=>"bazbaz",
+           [:d, "foo"]=>"booboo"},
+         { "baz"=>"http://baz.com/baz", 
+           "bar"=>"http://bar.com/bar",
+           "boo"=>"http://boo.com/boo"}]
     end
 
     it "should extract explicit default namespace bindings" do
-      Namespace.namespace_bindings_declarations([{"foo"=>"http://foo.com/foo"}], 
-                                                [:bar, "", "http://default.com/default"], 
-                                                { [:d, "foo"]=>"booboo"}).should ==
-        [{ ""=>"http://default.com/default"}, 
-         { "xmlns"=>"http://default.com/default"}]
+      Namespace.non_ns_attrs_ns_bindings([{"foo"=>"http://foo.com/foo"}], 
+                                         [:bar, "", "http://default.com/default"], 
+                                         { [:d, "foo"]=>"booboo"}).should ==
+        [{ [:d, "foo"]=>"booboo"},
+         { ""=>"http://default.com/default"}]
     end
+
+    
   end
 
 end

data/spec/rsxml/sexp_spec.rb

@@ -1,13 +1,22 @@
 require File.expand_path("../../spec_helper", __FILE__)
 
 module Rsxml
-
-
   describe "traverse" do
-    
+    # tests moved to visitor_spec... done in parallel with Xml traverse tests
   end
 
   describe "decompose_sexp" do
+    it "should decompose a [element_name] sexp" do
+      Sexp.decompose_sexp(["foo"]).should == ["foo", {}, []]
+    end
+
+    it "should decompose a [element_name, attrs] sexp" do
+      Sexp.decompose_sexp(["foo", {"foofoo"=>"a"}]).should == ["foo", {"foofoo"=>"a"}, []]
+    end
+
+    it "should decompose a [element_name, attrs, children] sexp" do
+      Sexp.decompose_sexp(["foo", {"foofoo"=>"a"}, ["bar"], ["baz"]]).should == ["foo", {"foofoo"=>"a"}, [["bar"], ["baz"]]]
+    end
   end
 
   describe "compare" do

data/spec/rsxml/visitor_spec.rb

@@ -1,6 +1,103 @@
 require File.expand_path("../../spec_helper", __FILE__)
 
 module Rsxml
+  # tests traverse methods on both Xml and Sexp together : they should produce identical visitation
+  # patterns
+  describe "traverse" do
+    def check_traverse(expectations, xml, sexp)
+      xml_visitor = Visitor::MockVisitor.new(expectations)
+      xml_root = Nokogiri::XML(xml).children.first
+      Xml.traverse(xml_root, xml_visitor)
+      xml_visitor.__finalize__
+      
+      sexp_visitor = Visitor::MockVisitor.new(expectations)
+      Sexp.traverse(sexp, sexp_visitor)
+      sexp_visitor.__finalize__
+    end
+
+    it "should call the element function on the visitor" do
+      check_traverse([[:element, :_, "foo", {"bar"=>"barbar"}, {}]],
+                     '<foo bar="barbar"/>',
+                     [:foo, {"bar"=>"barbar"}])
+    end
+
+    it "should call the element function on the visitor with exploded element and attributes qnames" do
+      check_traverse([[:element, :_, 
+                       ["foofoo", "foo", "http://foo.com/foo"], 
+                       {["bar", "foo", "http://foo.com/foo"]=>"barbar"}, 
+                       {"foo"=>"http://foo.com/foo"}]],
+                     '<foo:foofoo foo:bar="barbar" xmlns:foo="http://foo.com/foo"/>',
+                     [["foofoo", "foo"], {["bar", "foo", "http://foo.com/foo"]=>"barbar"}])
+    end
+
+    it "should call the test function on the visitor with textual content" do
+      check_traverse([[:element, :_, 
+                       ["foofoo", "foo", "http://foo.com/foo"], 
+                       {["bar", "foo", "http://foo.com/foo"]=>"barbar"}, 
+                       {"foo"=>"http://foo.com/foo"}],
+                      [:text, :_, "boohoo"]],
+                     '<foo:foofoo foo:bar="barbar" xmlns:foo="http://foo.com/foo">boohoo</foo:foofoo>',
+                     [["foofoo", "foo"], {["bar", "foo", "http://foo.com/foo"]=>"barbar"}, "boohoo"])
+    end
+
+    it "should call the element function in document order for each element in a hierarchic doc" do
+      check_traverse([[:element, :_, 
+                       ["foofoo", "foo", "http://foo.com/foo"], 
+                       {["bar", "foo", "http://foo.com/foo"]=>"barbar"}, 
+                       {"foo"=>"http://foo.com/foo"}],
+                      [:element, :_,
+                       ["barbar", "foo", "http://foo.com/foo"],
+                       {["baz", "foo", "http://foo.com/foo"]=>"bazbaz"},
+                       {}]],
+                     '<foo:foofoo foo:bar="barbar" xmlns:foo="http://foo.com/foo"><foo:barbar foo:baz="bazbaz"/></foo:foofoo>',
+                     [["foofoo", "foo"], {["bar", "foo", "http://foo.com/foo"]=>"barbar"},
+                      [["barbar", "foo"], {["baz", "foo"]=>"bazbaz"}]])
+    end
+
+    it "should call the element/text functions in a mixed document in document order" do
+      check_traverse([[:element, :_, 
+                       ["foofoo", "foo", "http://foo.com/foo"], 
+                       {["bar", "foo", "http://foo.com/foo"]=>"barbar"}, 
+                       {"foo"=>"http://foo.com/foo"}],
+                      [:element, :_,
+                       ["barbar", "foo", "http://foo.com/foo"],
+                       {["baz", "foo", "http://foo.com/foo"]=>"bazbaz"},
+                       {}],
+                      [:text, :_, "sometext"],
+                      [:element, :_, "boo", {"hoo"=>"hoohoo"}, {"zoo"=>"http://zoo.com/zoo"}],
+                      [:element, :_, ["bozo", "zoo", "http://zoo.com/zoo"], {}, {}]
+                     ],
+                     '<foo:foofoo foo:bar="barbar" xmlns:foo="http://foo.com/foo"><foo:barbar foo:baz="bazbaz"/>sometext<boo hoo="hoohoo" xmlns:zoo="http://zoo.com/zoo"><zoo:bozo/></boo></foo:foofoo>',
+                     [["foofoo", "foo"], {["bar", "foo", "http://foo.com/foo"]=>"barbar"},
+                      [["barbar", "foo"], {["baz", "foo"]=>"bazbaz"}],
+                      "sometext",
+                      ["boo", {"hoo"=>"hoohoo", "xmlns:zoo"=>"http://zoo.com/zoo"},
+                       ["zoo:bozo"]]])
+    end
+
+    it "should work the same with compact sexp representations" do
+      check_traverse([[:element, :_, 
+                       ["foofoo", "foo", "http://foo.com/foo"], 
+                       {["bar", "foo", "http://foo.com/foo"]=>"barbar"}, 
+                       {"foo"=>"http://foo.com/foo"}],
+                      [:element, :_,
+                       ["barbar", "foo", "http://foo.com/foo"],
+                       {["baz", "foo", "http://foo.com/foo"]=>"bazbaz"},
+                       {}],
+                      [:text, :_, "sometext"],
+                      [:element, :_, "boo", {"hoo"=>"hoohoo"}, {"zoo"=>"http://zoo.com/zoo"}],
+                      [:element, :_, ["bozo", "zoo", "http://zoo.com/zoo"], {}, {}]
+                     ],
+                     '<foo:foofoo foo:bar="barbar" xmlns:foo="http://foo.com/foo"><foo:barbar foo:baz="bazbaz"/>sometext<boo hoo="hoohoo" xmlns:zoo="http://zoo.com/zoo"><zoo:bozo/></boo></foo:foofoo>',
+                     ["foo:foofoo", {"foo:bar"=>"barbar", "xmlns:foo"=>"http://foo.com/foo"},
+                      ["foo:barbar", {"foo:baz"=>"bazbaz"}],
+                      "sometext",
+                      ["boo", {"hoo"=>"hoohoo", "xmlns:zoo"=>"http://zoo.com/zoo"},
+                       ["zoo:bozo"]]])
+    end
+
+  end
+
   describe Visitor::WriteXmlVisitor do
     it "should write single element xml" do
       Sexp::traverse(["item"], Visitor::WriteXmlVisitor.new).to_s.should == "<item></item>"
@@ -29,17 +126,6 @@ module Rsxml
   end
 
   describe Visitor::BuildRsxmlVisitor do
-    describe "strip_namespace_decls" do
-      it "should remove default and prefixed namespace decls from exploded attributes" do
-        Visitor::BuildRsxmlVisitor.new.strip_namespace_decls({"xmlns"=>"http://default.com/default",
-                                                                   ["foo", "xmlns"]=>"http://foo.com/foo",
-                                                                   ["bar", "foo", "http://foo.com/foo"]=>"barbar",
-                                                                   "baz"=>"bazbaz"}).should ==
-          {["bar", "foo", "http://foo.com/foo"]=>"barbar",
-          "baz"=>"bazbaz"}
-      end
-    end
-
     describe "compact_qname" do
       it "should compact exploded qnames" do
         Visitor::BuildRsxmlVisitor.new.compact_qname(["foo", "bar", "http://bar.com/bar"]).should ==
@@ -56,8 +142,8 @@ module Rsxml
       end
     end
 
-    describe "tag" do
-      it "should append the rsxml tag to the cursor element and yield" do
+    describe "element" do
+      it "should append the rsxml element to the cursor element and yield" do
       end
     end
 
@@ -77,6 +163,40 @@ module Rsxml
       rsxml = Rsxml::Xml.traverse(root, Visitor::BuildRsxmlVisitor.new).sexp
       rsxml.should == ["foo", {"bar"=>"10", "baz"=>"20"}]
     end
+
+    describe "element_transformer" do
+      def capitalize_local_part(qname)
+        local_part, prefix, uri = qname
+        if uri
+          [local_part.capitalize, prefix, uri]
+        else
+          local_part.capitalize
+        end
+      end
+
+      it "should call a element_transformer block to transform element_names and attrs" do
+        root = Nokogiri::XML('<foo bar="10" baz="20"></foo>').children.first
+        rsxml = Rsxml::Xml.traverse(root, Visitor::BuildRsxmlVisitor.new do |context,element_name,attrs|
+                                      celement_name = capitalize_local_part(element_name)
+                                      cattrs = Hash[attrs.map{|n,v| [capitalize_local_part(n), v]}]
+                                      [celement_name, cattrs]
+                                    end ).sexp
+                                        
+        rsxml.should ==
+          ["Foo", {"Bar"=>"10", "Baz"=>"20"}]
+
+        root = Nokogiri::XML('<a:foo bar="10" baz="20" xmlns:a="http://a.com/a"></a:foo>').children.first
+        rsxml = Rsxml::Xml.traverse(root, Visitor::BuildRsxmlVisitor.new(:style=>:exploded) do |context,element_name,attrs|
+                                      celement_name = capitalize_local_part(element_name)
+                                      cattrs = Hash[attrs.map{|n,v| [capitalize_local_part(n), v]}]
+                                      [celement_name, cattrs]
+                                    end ).sexp
+                                        
+        rsxml.should ==
+          [["Foo", "a", "http://a.com/a"], {"Bar"=>"10", "Baz"=>"20"}]
+
+      end
+    end
   end
 
 end

data/spec/rsxml/xml_spec.rb

@@ -7,6 +7,7 @@ module Rsxml
 
     it "should wrap a fragment in a document with namespace declarations if there are ns prefixes" do
     end
+
   end
 
   describe "unwrap_fragment" do
@@ -18,6 +19,14 @@ module Rsxml
 
     it "should throw an exception if it unwraps and there is more than one child" do
     end
+
+    it "should return a node with no namespace definitions" do
+      root = Xml.unwrap_fragment(Nokogiri::XML(Xml.wrap_fragment("<foo:bar/>", {"foo"=>"http://foo.com/foo"})).children.first)
+      root.namespace_definitions.should == []
+      root.name.should == "bar"
+      root.namespace.prefix.should == "foo"
+      root.namespace.href.should == "http://foo.com/foo"
+    end
   end
 
   describe "explode_node" do
@@ -28,7 +37,7 @@ module Rsxml
       Xml.explode_node(node).should == "foo"
     end
 
-    it "should return the [local_name, prefix, uri] triple if there is a namespace" do
+    it "should return the [local_part, prefix, uri] triple if there is a namespace" do
       node = Object.new
       stub(node).name{"foo"}
       namespace = Object.new
@@ -38,7 +47,7 @@ module Rsxml
       Xml.explode_node(node).should == ["foo", "bar", "http://bar.com/bar"]
     end
 
-    it "should return a [local_name, "", uri] triple if there is a default namespace" do
+    it "should return a [local_part, "", uri] triple if there is a default namespace" do
       node = Object.new
       stub(node).name{"foo"}
       namespace = Object.new
@@ -56,13 +65,27 @@ module Rsxml
       eelement, eattrs = Rsxml::Xml.explode_element(root)
       eelement.should == ["bar", "foo", "http://foo.com/foo"]
       eattrs.should == {"a"=>"aa", 
-        ["b", "foo", "http://foo.com/foo"]=>"bb",
-        ["foo", "xmlns"]=>"http://foo.com/foo",
-        "xmlns"=>"http://default.com/default"}
+        ["b", "foo", "http://foo.com/foo"]=>"bb"}
+    end
+  end
+
+  describe "namespace_bindings_from_defs" do
+    it "should produce a hash of {prefix=>uri} bindings from a list of Nokogiri::XML::Namespace" do
+      default_def = Object.new
+      mock(default_def).prefix{nil}
+      mock(default_def).href{"http://default.com/default"}
+
+      foo_def = Object.new
+      mock(foo_def).prefix{"foo"}
+      mock(foo_def).href{"http://foo.com/foo"}
+
+      Xml.namespace_bindings_from_defs([default_def, foo_def]).should ==
+        {"foo"=>"http://foo.com/foo", ""=>"http://default.com/default"}
     end
   end
 
   describe "traverse" do
+    # tests moved to visitor_spec... done in parallel with Sexp traverse tests
   end
 
 end

data/spec/rsxml_spec.rb

@@ -183,7 +183,7 @@ describe Rsxml do
       rsxml.should == org_no_ns
     end
 
-    it "should return exploded namespaces if :compact is false when parsing a fragment" do
+    it "should return exploded namespaces if :style=>:exploded when parsing a fragment" do
       xml = '<foofoo foo:bar="1" foo:baz="baz"></foofoo>'
       rsxml = Rsxml.to_rsxml(xml, :ns=>{:foo=>"http://foo.com/foo", ""=>"http://baz.com/baz"}, :style=>:exploded)
 

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'spec/autorun'
 require 'rr'
 require 'nokogiri'
 require 'rsxml'
+require 'rsxml/mock_visitor'
 
 Spec::Runner.configure do |config|
   config.mock_with RR::Adapters::Rspec

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rsxml
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Trampoline Systems Ltd
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-11 00:00:00 +01:00
+date: 2011-05-27 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -118,6 +118,7 @@ files:
 - lib/rsxml/util.rb
 - lib/rsxml/visitor.rb
 - lib/rsxml/xml.rb
+- spec/rsxml/mock_visitor.rb
 - spec/rsxml/namespace_spec.rb
 - spec/rsxml/sexp_spec.rb
 - spec/rsxml/util_spec.rb
@@ -160,6 +161,7 @@ signing_key:
 specification_version: 3
 summary: an s-expression representation of XML documents in Ruby
 test_files: 
+- spec/rsxml/mock_visitor.rb
 - spec/rsxml/namespace_spec.rb
 - spec/rsxml/sexp_spec.rb
 - spec/rsxml/util_spec.rb