rsxml 0.1.4 → 0.2.0

data/lib/rsxml/util.rb

@@ -0,0 +1,25 @@
+module Rsxml
+  module Util
+    module_function
+    
+    # simple option checking, with value constraints and sub-hash checking
+    def check_opts(constraints, opts)
+      opts ||= {}
+      opts.each{|k,v| raise "opt not permitted: #{k.inspect}" if !constraints.has_key?(k)}
+      Hash[constraints.map do |k,constraint|
+             if opts.has_key?(k)
+               v = opts[k]
+               if constraint.is_a?(Array)
+                 raise "unknown value for opt #{k.inspect}: #{v.inspect}. permitted values are: #{constraint.inspect}" if !constraint.include?(v)
+                 [k,v]
+               elsif constraint.is_a?(Hash)
+                 raise "opt #{k.inspect} must be a Hash" if !v.is_a?(Hash)
+                 [k,check_opts(constraint, v || {})]
+               else
+                 [k,v]
+               end
+             end
+           end]
+    end
+  end
+end

data/lib/rsxml/visitor.rb

@@ -0,0 +1,132 @@
+module Rsxml
+  module Visitor
+    class << self
+      include Util
+    end
+
+    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
+
+    class WriteXmlVisitor
+      attr_reader :xml
+
+      def initialize(xml_builder=nil)
+        @xml = xml_builder || Builder::XmlMarkup.new
+      end
+
+      def tag(context, name, attrs)
+        qname = Namespace::compact_qname(context.ns_stack, name)
+        qattrs = Namespace::compact_attr_qnames(context.ns_stack, attrs)
+
+        xml.__send__(qname, qattrs) do
+          yield
+        end
+      end
+
+      def text(context, text)
+        xml << text
+      end
+
+      def to_s
+        xml.target!
+      end
+    end
+
+    class BuildRsxmlVisitor
+      attr_reader :sexp
+      attr_reader :cursor_stack 
+      attr_reader :opts
+
+      # 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
+      OPTS = {:style=>[:xml, :exploded]}
+
+      def initialize(opts=nil)
+        @opts = opts || {}
+        opts = Util.check_opts(OPTS, opts)
+        @cursor_stack = []
+        @sexp
+      end
+
+      def compact_qname(qname)
+        local_name, prefix, uri = qname
+
+        [prefix, local_name].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 tag(context, tag, attrs)
+
+        opts[:style] ||= :exploded
+        if opts[:style] == :xml
+          tag = compact_qname(tag)
+          attrs = compact_attr_names(attrs)
+        elsif opts[:style] == :exploded
+          attrs = strip_namespace_decls(attrs)
+        end
+        
+        el = [tag, (attrs if attrs.size>0)].compact
+
+        if !cursor_stack.last
+          @sexp = el
+        else
+          cursor_stack.last << el
+        end
+        cursor_stack.push(el)
+
+        begin
+          yield
+        ensure
+          cursor_stack.pop
+        end
+      end
+
+      def text(context, text)
+        cursor_stack.last << text
+      end
+    end
+
+
+
+  end
+end

data/lib/rsxml/xml.rb

@@ -0,0 +1,99 @@
+module Rsxml
+  module Xml
+
+    module_function
+
+    WRAP_ELEMENT = "RsxmlXmlWrapper"
+
+    def wrap_fragment(fragment, ns_prefixes)
+      return fragment if !ns_prefixes
+
+      ns_attrs = Hash[ns_prefixes.map do |prefix,href|
+                        prefix = nil if prefix.to_s.length == 0
+                        [["xmlns", prefix].compact.join(":"), href]
+                      end]
+      xml = Builder::XmlMarkup.new
+      xml.__send__(WRAP_ELEMENT, ns_attrs) do
+        xml << fragment
+      end
+      xml.target!
+    end
+
+    def unwrap_fragment(node)
+      if node.name==WRAP_ELEMENT
+        node.children.first
+      else
+        node
+      end
+    end
+
+    def explode_node(node)
+      node_name = node.name
+      if node.namespace
+        node_prefix = node.namespace.prefix || "" # nokogiri has nil prefix for default namespace
+        node_uri = node.namespace.href
+      end
+      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>
+    # pair of exploded element name and attributes with exploded names
+    def explode_element(element)
+      eelement = explode_node(element)
+
+      eattrs = Hash[element.attributes.map do |name,attr|
+                      [explode_node(attr), attr.value]
+                    end]
+
+      ns_decl_attrs = explode_ns_definitions(element)
+      eattrs = eattrs.merge(ns_decl_attrs)
+
+      [eelement, eattrs]
+    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)
+      context.ns_stack.push(ns_bindings)
+
+      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
+            end
+          ensure
+            context.pop_node
+          end
+        end
+      ensure
+        context.ns_stack.pop
+      end
+
+      visitor
+    end
+
+  end
+end

data/spec/rsxml/namespace_spec.rb

@@ -0,0 +1,250 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rsxml
+  describe "find_namespace_uri" do
+    it "should find a namespace uri in a stack of prefix bindings" do
+      Namespace.find_namespace_uri([{"foo"=>"http://foo.com/foo"},
+                                    {"bar"=>"http://bar.com/bar"}],
+                                   "bar").should == "http://bar.com/bar"
+      Namespace.find_namespace_uri([{"foo"=>"http://foo.com/foo"},
+                                    {"bar"=>"http://bar.com/bar"}],
+                                   "foo").should == "http://foo.com/foo"
+    end
+
+    it "should return nil if there is no matching binding" do
+      Namespace.find_namespace_uri([{"foo"=>"http://foo.com/foo"},
+                                    {"bar"=>"http://bar.com/bar"}],
+                                   "blah").should == nil
+      Namespace.find_namespace_uri([],
+                                   "blah").should == nil
+    end
+
+  end
+
+  describe "explode_qname" do
+    it "should do nothing to an array with more than one element" 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 return the first element of an array with only the first non-nil element" do
+      Namespace.explode_qname([], ["bar"]).should ==
+        "bar"
+    end
+
+    it "should raise an error if prefix is nil but uri is not" do
+      lambda {
+        Namespace.explode_qname([], ["bar", nil, "http://foo.com/foo"])
+      }.should raise_error(/invalid name/)
+    end
+
+    it "should unqualify an unprefixed name with no default namespace" do
+      Namespace.explode_qname([], "bar").should == "bar"
+    end
+
+    it "should unqualify an unprefixed name in the default namespace" do
+      Namespace.explode_qname([{""=>"http://foo.com/foo"}], "bar").should == 
+        ["bar", "", "http://foo.com/foo"]
+    end
+
+    it "should unqualify a prefixed name with a bound namespace" do
+      Namespace.explode_qname([{"foo"=>"http://foo.com/foo"}], "foo:bar").should ==
+        ["bar", "foo", "http://foo.com/foo"]
+    end
+
+    it "should raise an error with a prefixed name with no bound namespace" do
+      lambda {
+        Namespace.explode_qname([], "foo:bar")
+      }.should raise_error(/not bound/)
+    end
+  end
+
+  describe "split_qname" do
+    it "should split a name with prefix" do
+      Namespace.split_qname("foo:bar").should == ["bar", "foo"]
+    end
+
+    it "should leave a name without prefix unchanged" do
+      Namespace.split_qname("bar").should == "bar"
+    end
+
+    it "should leave an array unchanged" do
+      Namespace.split_qname(["bar", "foo"]).should == ["bar", "foo"]
+    end
+  end
+
+  describe "compact_attr_qnames" do
+    it "should qualify attribute names when there is a default namespaces" do
+      Namespace.compact_attr_qnames([{""=>"http://default.com/default","foo"=>"http://foo.com/foo"}], {["bar", "foo"] => "barbar", ["boo", ""] => "booboo", "baz" =>"bazbaz"}).should ==
+        {"foo:bar"=>"barbar", "boo"=>"booboo", "baz"=>"bazbaz"}
+    end
+
+    it "should raise an exception if a namespace is referenced but not bound" do
+      lambda {
+        Namespace.compact_attr_qnames([], {["bar", "foo"] => "barbar", "baz" =>"bazbaz"})
+      }.should raise_error(/not bound/)
+    end
+
+    it "should raise an exception if default namespace referenced but not bound" do
+      lambda {
+        Namespace.compact_attr_qnames([{"foo"=>"http://foo.com/foo"}], {["bar", "foo"] => "barbar", ["boo", ""] => "booboo", "baz" =>"bazbaz"})
+      }.should raise_error(/not bound/)
+    end
+  end
+
+  describe "explode_attr_qnames" do
+    it "should unqualify attributes when there is no default namespace" do
+      Namespace.explode_attr_qnames([{"foo"=>"http://foo.com/foo"}], {"foo:bar"=>"barbar", "baz"=>"bazbaz"}).should ==
+        {["bar", "foo", "http://foo.com/foo"]=>"barbar", "baz"=>"bazbaz"}
+    end
+
+    it "should unqualify attributes when there is a default namespace" do
+      Namespace.explode_attr_qnames([{""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}], {"foo:bar"=>"barbar", "baz"=>"bazbaz"}).should ==
+        {["bar", "foo", "http://foo.com/foo"]=>"barbar", "baz"=>"bazbaz"}
+    end
+  end
+
+  describe "compact_qname" do
+    it "should produce a qname from a pair or triple" do
+      Namespace.compact_qname([{"foo"=>"http://foo.com/foo"}], 
+                              ["bar", "foo"]).should ==
+        "foo:bar"
+      Namespace.compact_qname([{"foo"=>"http://foo.com/foo"}], 
+                              ["bar", "foo", "http://foo.com/foo"]).should ==
+        "foo:bar"
+    end
+
+    it "should produce a qname with default namespace" do
+      Namespace.compact_qname([{""=>"http://foo.com/foo"}], 
+                              ["bar", ""]).should ==
+        "bar"
+
+      Namespace.compact_qname([{""=>"http://foo.com/foo"}], 
+                              ["bar", "", "http://foo.com/foo"]).should ==
+        "bar"
+    end
+
+    it "should do nothing to a String" do
+      Namespace.compact_qname([], "foo:bar").should == "foo:bar"
+    end
+
+    it "should raise an error if prefix is nil but uri is not" do
+      lambda {
+        Namespace.compact_qname([], ["bar", nil, "http://foo.com/foo"])
+      }.should raise_error(/invalid name/)
+    end
+
+    it "should raise an error if a prefix is not bound" do
+      lambda {
+        Namespace.compact_qname([], 
+                                ["bar", "foo", "http://foo.com/foo"])
+      }.should raise_error(/not bound/)
+    end
+
+    it "should raise an error if a prefix binding clashes" do
+      lambda {
+        Namespace.compact_qname([{"foo"=>"http://foo.com/foo"}], 
+                                ["bar", "foo", "http://bar.com/bar"])
+      }.should raise_error(/'foo' is bound/)
+    end
+
+    it "should raise an error if default namespace binding clashes" do
+      lambda {
+        Namespace.compact_qname([{""=>"http://foo.com/foo"}], 
+                                ["bar", "", "http://bar.com/bar"])
+      }.should raise_error(/'' is bound/)
+    end
+
+  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"}
+    end
+  end
+
+  describe "extract_explicit_namespace_bindings" do
+    it "should extract a hash of explicit namespace bindings from expanded tags" 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 ==
+        {"foo"=>"http://foo.com/foo", "bar"=>"http://bar.com/bar", ""=>"http://default.com/default"}
+    end
+
+    it "should raise an error if extracted namespaces clash" do
+      lambda{
+        Namespace.extract_explicit_namespace_bindings(["bar", "foo", "http://foo.com/foo"],
+                                                      {["baz", "foo", "http://bar.com/bar"]=>"baz",
+                                                        ["boo", "", "http://default.com/default"]=>"boo"})
+      }.should raise_error(/bindings clash/)
+    end
+  end
+
+  describe "undeclared_namespace_bindings" do
+    it "should determine which explicit namespaces are not declared in context" do
+      Namespace.undeclared_namespace_bindings([{""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}], {""=>"http://default.com/default", "foo"=>"http://foo.com/foo", "bar"=>"http://bar.com/bar"}).should ==
+        {"bar"=>"http://bar.com/bar"}
+    end
+
+    it "should raise an exception if an explicit prefix clashes with a declard prefix" do
+      lambda {
+        Namespace.undeclared_namespace_bindings([{""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}], {""=>"http://foo.com/foo", "foo"=>"http://foo.com/foo", "bar"=>"http://bar.com/bar"})
+      }.should raise_error(/is bound to uri/)
+    end
+  end
+
+  describe "merge_namespace_bindings" do
+    it "should merge two sets of namespace bindings" do
+      Namespace.merge_namespace_bindings({""=>"http://default.com/default",
+                                           "boo"=>"http://boo.com/boo"},
+                                         {"foo"=>"http://foo.com/foo",
+                                           "bar"=>"http://bar.com/bar"}).should ==
+        {""=>"http://default.com/default",
+        "boo"=>"http://boo.com/boo",
+        "foo"=>"http://foo.com/foo",
+        "bar"=>"http://bar.com/bar"}
+    end
+
+    it "should raise an error if there are binding clashes" do
+      lambda {
+        Namespace.merge_namespace_bindings({""=>"http://default.com/default",
+                                             "boo"=>"http://boo.com/boo"},
+                                           {""=>"http://foo.com/foo",
+                                             "bar"=>"http://bar.com/bar"})
+      }.should raise_error(/bindings clash/)
+    end
+  end
+
+  describe "exploded_namespace_declarations" do
+    it "should produce unqalified namespaces declarations" do
+      Namespace.exploded_namespace_declarations({""=>"http://default.com/default", "foo"=>"http://foo.com/foo"}).should == 
+        {"xmlns"=>"http://default.com/default", ["foo", "xmlns"]=>"http://foo.com/foo"}
+    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"}]
+    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"}]
+    end
+  end
+
+end