rsxml 0.1.4 → 0.2.0

data/spec/rsxml/sexp_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rsxml
+
+
+  describe "traverse" do
+    
+  end
+
+  describe "decompose_sexp" do
+  end
+
+  describe "compare" do
+  end
+end

data/spec/rsxml/util_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rsxml
+  describe Util do
+    describe "check_opts" do
+      it "should permit a nil opts Hash" do
+        Util.check_opts({}, nil).should == {}
+      end
+
+      it "should return an equals opts Hash" do
+        Util.check_opts({:foo=>nil}, {:foo=>10}).should == {:foo=>10}
+      end
+
+      it "should raise an exception if an opt is given with no matching constraint" do
+        lambda {
+          Util.check_opts({:foo=>nil}, {:bar=>10})
+        }.should raise_error(/not permitted: :bar/)
+      end
+
+      it "should raise an exception if the value of an opt with an Array constraint is not in the Array" do
+        lambda {
+          Util.check_opts({:foo=>[1,2,3]}, {:foo=>10})
+        }.should raise_error(/unknown value/)
+      end
+
+      it "should permit an opt with an Array constraint to have a nil value" do
+        Util.check_opts({:foo=>[1,2,3]}, {}).should == {}
+      end
+
+      it "should check_opts for opts with Hash constraints" do
+        lambda {
+          Util.check_opts({:foo=>{:bar=>[1,2,3]}}, {:foo=>{:bar=>10}})
+        }.should raise_error(/unknown value/)
+      end
+
+      it "should permit sub-hashes to be skipped with a nil value" do
+        Util.check_opts({:foo=>{:bar=>10}}, {}).should == {}
+      end
+    end
+  end
+end

data/spec/rsxml/visitor_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rsxml
+  describe Visitor::WriteXmlVisitor do
+    it "should write single element xml" do
+      Sexp::traverse(["item"], Visitor::WriteXmlVisitor.new).to_s.should == "<item></item>"
+    end
+
+    it "should write single element xml with attributes" do
+      Sexp::traverse([:item, {:foo=>"100"}], Visitor::WriteXmlVisitor.new).to_s.should == '<item foo="100"></item>'
+    end
+
+    it "should write nested elements with attributes and text content" do
+      Sexp::traverse([:item, {:foo=>"100"}, [:bar], "foofoo", [:baz]], Visitor::WriteXmlVisitor.new).to_s.should == '<item foo="100"><bar></bar>foofoo<baz></baz></item>'
+    end
+
+    it "should permit lazy declaration of namespces" do
+      root = Nokogiri::XML(Sexp::traverse([[:bar, "foo", "http://foo.com/foo"], {"foo:foofoo"=>"fff"}], Visitor::WriteXmlVisitor.new).to_s).children.first
+      root.namespaces.should == {"xmlns:foo"=>"http://foo.com/foo"}
+
+      root.name.should == 'bar'
+      root.namespace.prefix.should == 'foo'
+      root.namespace.href.should == 'http://foo.com/foo'
+
+      root.attributes["foofoo"].value.should == "fff"
+      root.attributes["foofoo"].namespace.prefix.should == 'foo'
+      root.attributes["foofoo"].namespace.href.should == 'http://foo.com/foo'
+    end
+  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 ==
+          "bar:foo"
+        Visitor::BuildRsxmlVisitor.new.compact_qname("foo").should ==
+          "foo"
+      end
+    end
+
+    describe "compact_attr_names" do
+      it "should compact exploded attribute names" do
+        Visitor::BuildRsxmlVisitor.new.compact_attr_names({["foo", "bar", "http://bar.com/bar"]=>"foofoo", "baz"=>"bazbaz", ["foofoo", "bar"]=>"fff"}).should ==
+          {"bar:foo"=>"foofoo", "baz"=>"bazbaz", "bar:foofoo"=>"fff"}
+      end
+    end
+
+    describe "tag" do
+      it "should append the rsxml tag to the cursor element and yield" do
+      end
+    end
+
+    describe "text" do
+      it "should append the text to the cursor element" do
+      end
+    end
+
+    it "should read a single element document" do
+      root = Nokogiri::XML('<foo></foo>').children.first
+      rsxml = Rsxml::Xml.traverse(root, Visitor::BuildRsxmlVisitor.new).sexp
+      rsxml.should == ["foo"]
+    end
+
+    it "should read a single element document with attributes" do
+      root = Nokogiri::XML('<foo bar="10" baz="20"></foo>').children.first
+      rsxml = Rsxml::Xml.traverse(root, Visitor::BuildRsxmlVisitor.new).sexp
+      rsxml.should == ["foo", {"bar"=>"10", "baz"=>"20"}]
+    end
+  end
+
+end

data/spec/rsxml/xml_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rsxml
+  describe "wrap_fragment" do
+    it "should do nothing if there are no ns_prefixes" do
+    end
+
+    it "should wrap a fragment in a document with namespace declarations if there are ns prefixes" do
+    end
+  end
+
+  describe "unwrap_fragment" do
+    it "should do nothing if there is no wrapping element" do
+    end
+
+    it "should remove the outermost element if it is a wrapping element" do
+    end
+
+    it "should throw an exception if it unwraps and there is more than one child" do
+    end
+  end
+
+  describe "explode_node" do
+    it "should return the element name String if there is no namespace" do
+      node = Object.new
+      stub(node).name{"foo"}
+      stub(node).namespace{nil}
+      Xml.explode_node(node).should == "foo"
+    end
+
+    it "should return the [local_name, prefix, uri] triple if there is a namespace" do
+      node = Object.new
+      stub(node).name{"foo"}
+      namespace = Object.new
+      stub(node).namespace{namespace}
+      stub(namespace).prefix{"bar"}
+      stub(namespace).href{"http://bar.com/bar"}
+      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
+      node = Object.new
+      stub(node).name{"foo"}
+      namespace = Object.new
+      stub(node).namespace{namespace}
+      stub(namespace).prefix{nil}
+      stub(namespace).href{"http://bar.com/bar"}
+      Xml.explode_node(node).should == ["foo", "", "http://bar.com/bar"]
+    end
+  end
+
+  describe "explode_element" do
+    it "should explode an element and it's attributes" do
+      root = Nokogiri::XML('<foo:bar a="aa" foo:b="bb" xmlns:foo="http://foo.com/foo" xmlns="http://default.com/default"></foo:bar>').children.first
+
+      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"}
+    end
+  end
+
+  describe "traverse" do
+  end
+
+end

data/spec/rsxml_spec.rb

@@ -6,6 +6,16 @@ describe Rsxml do
       Rsxml.to_xml([:foo]).should == "<foo></foo>"
     end
 
+    it "should produce a single-element doc with namespaces" do
+      Rsxml.to_xml([[:bar, :foo, "http://foo.com/foo"]]).should == 
+        '<foo:bar xmlns:foo="http://foo.com/foo"></foo:bar>'
+    end
+
+    it "should produce a fragment without namespace declarations if ns bindings are provided" do
+      Rsxml.to_xml(["foo:bar", {["baz", "foo"]=>"bazbaz"}], :ns=>{"foo"=>"http://foo.com/foo"}).should ==
+        '<foo:bar foo:baz="bazbaz"></foo:bar>'
+    end
+
     it "should produce a single-element doc with attrs" do
       xml = Rsxml.to_xml([:foo, {:bar=>1, :baz=>"baz"}])
       r = Nokogiri::XML(xml).children.first
@@ -14,6 +24,60 @@ describe Rsxml do
       r["baz"].should == "baz"
     end
 
+    it "should produce a single-element doc with  element namespace attrs" do
+      xml = Rsxml.to_xml([[:bar, :foo, "http://foo.com/foo"], {:bar=>1, :baz=>"baz"}])
+      r = Nokogiri::XML(xml).children.first
+      r.name.should == "bar"
+      r.namespace.href.should == "http://foo.com/foo"
+      r.namespace.prefix.should == "foo"
+      
+      r.attributes["bar"].namespace.should == nil
+      r["bar"].should == "1"
+
+      r.attributes["baz"].namespace.should == nil
+      r["baz"].should == "baz"
+    end
+
+    it "should produce a single-element doc with namespace and attr namespaces" do
+      xml = Rsxml.to_xml([[:bar, :foo, "http://foo.com/foo"], 
+                          {[:barbar, :bar, "http://bar.com/bar"]=>1, 
+                            :baz=>"baz"}])
+      r = Nokogiri::XML(xml).children.first
+      
+      r.name.should == "bar"
+      r.namespace.prefix.should == "foo"
+      r.namespace.href.should == "http://foo.com/foo"
+
+      barbar = r.attributes["barbar"]
+      barbar.namespace.prefix.should == "bar"
+      barbar.namespace.href.should == "http://bar.com/bar"
+      barbar.value.should == "1"
+
+      baz = r.attributes["baz"]
+      baz.namespace.should == nil
+      baz.value.should == "baz"
+    end
+
+    it "should produce a single-element doc with default namespace and attr namespaces" do
+      xml = Rsxml.to_xml([[:bar, "", "http://foo.com/foo"], 
+                          {[:barbar, :bar, "http://bar.com/bar"]=>1, 
+                            :baz=>"baz"}])
+      r = Nokogiri::XML(xml).children.first
+      
+      r.name.should == "bar"
+      r.namespace.prefix.should == nil
+      r.namespace.href.should == "http://foo.com/foo"
+
+      barbar = r.attributes["barbar"]
+      barbar.namespace.prefix.should == "bar"
+      barbar.namespace.href.should == "http://bar.com/bar"
+      barbar.value.should == "1"
+
+      baz = r.attributes["baz"]
+      baz.namespace.should == nil
+      baz.value.should == "baz"
+    end
+
     it "should produce a doc with text content" do
       xml = Rsxml.to_xml([:foo, "foofoo"])
       r = Nokogiri::XML(xml).children.first
@@ -67,38 +131,13 @@ describe Rsxml do
       r.attributes["baz"].namespace.href.should == "http://foo.com/foo"
       r.attributes["baz"].namespace.prefix.should == "foo"
     end
-
-    it "should transform a single tag if a transformer is supplied" do
-      xml = Rsxml.to_xml([:foo]) do |tag,attrs,path| 
-        path.should == ""
-        [tag.upcase, attrs]
-      end.should ==
-        "<FOO></FOO>"
-    end
-
-    it "should transform nested tags if a transformer is supplied" do
-      txs = {"/foo"=>"Blub", "/foo[0]/bar"=>"Wub"}
-      xml = Rsxml.to_xml([:foo, [:bar]]) do |tag,attrs,path| 
-        $stderr << [tag, attrs, path].inspect
-        [txs[[path, tag].join("/")], attrs]
-      end.should ==
-        "<Blub><Wub></Wub></Blub>"
-    end
-
-    it "should transform a tag with attributes if a transformer is supplied" do
-      xml = Rsxml.to_xml([:foo, {:bar=>"bar"}]) do |tag,attrs,path| 
-        path.should == ""
-        [tag.upcase, Hash[*attrs.map{|k,v| [k.to_s.upcase,v]}.flatten]]
-      end.should ==
-        '<FOO BAR="bar"></FOO>'
-      
-    end
   end
 
   describe "to_rsxml" do
+
     def test_roundtrip(org) 
       xml = Rsxml.to_xml(org)
-      rsxml = Rsxml.to_rsxml(xml)
+      rsxml = Rsxml.to_rsxml(xml, :style=>:xml)
       rsxml.should == org
     end
     
@@ -126,14 +165,31 @@ describe Rsxml do
       test_roundtrip(["foo:foofoo", {"xmlns:foo"=>"http://foo.com/foo", "foo:bar"=>"1", "foo:baz"=>"baz"}])
     end
 
+    it "should parse a doc with namespaces and return exploded names if :style is :exploded" do
+      xml = Rsxml.to_xml(["foo:foofoo", {"xmlns:foo"=>"http://foo.com/foo", "foo:bar"=>"1", "foo:baz"=>"baz"}])
+      rsxml = Rsxml.to_rsxml(xml, :style=>:exploded)
+      rsxml.should == [["foofoo", "foo", "http://foo.com/foo"],
+                       { ["bar", "foo", "http://foo.com/foo"]=>"1",
+                         ["baz", "foo", "http://foo.com/foo"]=>"baz"}]
+
+    end
+
     it "should allow namespace prefixes to be specified when parsing a fragment" do
-      org = ["foo:foofoo", {"foo:bar"=>"1", "foo:baz"=>"baz"}]
-      xml = Rsxml.to_xml(["foo:foofoo", {"foo:bar"=>"1", "foo:baz"=>"baz"}])
+      org_no_ns = ["foofoo", {"foo:bar"=>"1", "foo:baz"=>"baz"}]
+      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=>:xml)
+
+      rsxml.should == org_no_ns
+    end
 
-      org_with_ns = ["foo:foofoo", {"foo:bar"=>"1", "foo:baz"=>"baz", "xmlns"=>"http://baz.com/baz", "xmlns:foo"=>"http://foo.com/foo"}]
-      rsxml = Rsxml.to_rsxml(xml, :ns=>{:foo=>"http://foo.com/foo", ""=>"http://baz.com/baz"})
+    it "should return exploded namespaces if :compact is false 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)
 
-      rsxml.should == org_with_ns
+      rsxml.should == [["foofoo", "", "http://baz.com/baz"],
+                       { ["bar", "foo", "http://foo.com/foo"]=>"1",
+                         ["baz", "foo", "http://foo.com/foo"]=>"baz"}]
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rsxml
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 4
-  version: 0.1.4
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Trampoline Systems Ltd
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-05 00:00:00 +01:00
+date: 2011-05-11 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -113,6 +113,16 @@ files:
 - Rakefile
 - VERSION
 - lib/rsxml.rb
+- lib/rsxml/namespace.rb
+- lib/rsxml/sexp.rb
+- lib/rsxml/util.rb
+- lib/rsxml/visitor.rb
+- lib/rsxml/xml.rb
+- spec/rsxml/namespace_spec.rb
+- spec/rsxml/sexp_spec.rb
+- spec/rsxml/util_spec.rb
+- spec/rsxml/visitor_spec.rb
+- spec/rsxml/xml_spec.rb
 - spec/rsxml_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -150,5 +160,10 @@ signing_key:
 specification_version: 3
 summary: an s-expression representation of XML documents in Ruby
 test_files: 
+- spec/rsxml/namespace_spec.rb
+- spec/rsxml/sexp_spec.rb
+- spec/rsxml/util_spec.rb
+- spec/rsxml/visitor_spec.rb
+- spec/rsxml/xml_spec.rb
 - spec/rsxml_spec.rb
 - spec/spec_helper.rb