representable 0.0.1.alpha1 → 0.0.1

data/spec/xml/encoding_spec.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-require_relative './../spec_helper'
-
-describe ROXML, "encoding" do
-  class TestResult
-    include ROXML
-    xml_accessor :message
-  end
-  
-  context "when provided non-latin characters" do
-    it "should output those characters as input via methods" do
-      res = TestResult.new
-      res.message = "sadfk одловыа jjklsd " #random russian  and english charecters
-      doc = ROXML::XML::Document.new
-      doc.root = res.to_xml
-      if defined?(Nokogiri)
-        doc.at('message').inner_text
-      else
-        doc.find_first('message').inner_xml
-      end.should == "sadfk одловыа jjklsd "
-    end
-  
-    it "should output those characters as input via xml" do
-      res = TestResult.from_xml("<test_result><message>sadfk одловыа jjklsd </message></test_result>")
-      doc = ROXML::XML::Document.new
-      doc.root = res.to_xml
-      if defined?(Nokogiri)
-        doc.at('message').inner_text
-      else
-        doc.find_first('message').inner_xml
-      end.should == "sadfk одловыа jjklsd "
-    end
-  
-    it "should allow override via the document" do
-      res = TestResult.from_xml("<test_result><message>sadfk одловыа jjklsd </message></test_result>")
-      if defined?(Nokogiri)
-        xml = res.to_xml
-        doc = xml.document
-        doc.root = xml
-        doc.encoding = 'ISO-8859-1'
-        doc.to_s.should include('ISO-8859-1')
-        doc.at('message').inner_text
-      else
-        doc = LibXML::XML::Document.new
-        doc.encoding = LibXML::XML::Encoding::ASCII
-        doc.root = res.to_xml
-        pending "Libxml bug"
-        doc.to_s.should include('ISO-8859-1')
-        doc.find_first('message').inner_xml
-      end.should == "sadfk одловыа jjklsd "
-    end
-  end
-end

data/spec/xml/namespace_spec.rb

@@ -1,270 +0,0 @@
-require_relative './../spec_helper.rb'
-
-describe ROXML, "with namespaces" do
-  describe "for writing" do
-    before do
-      @xml = <<EOS
-<?xml version="1.0" encoding="UTF-8"?>
-<gronk:VApp name="My new vApp" status="1" href="https://vcloud.example.com/vapp/833" type="application/vnd.vmware.vcloud.vapp+xml" xmlns:vmw="http://foo.example.com" xmlns:gronk="http://gronk.example.com">
-  <gronk:NetworkConfig name="Network 1">
-    <vmw:FenceMode>allowInOut</vmw:FenceMode>
-    <vmw:Dhcp>true</vmw:Dhcp>
-    <gronk:errors>
-      <gronk:error>OhNo!</gronk:error>
-      <gronk:error>Another!</gronk:error>
-    </gronk:errors>
-  </gronk:NetworkConfig>
-  <foo />
-  <bar>
-    gronk
-  </bar>
-</gronk:VApp>
-EOS
-    end
-
-    class NetworkConfig
-      include ROXML
-      xml_namespace :gronk
-
-      xml_name 'NetworkConfig'
-      xml_reader    :name, :from => '@name'
-      xml_reader    :errors, :as => []
-      xml_accessor  :fence_mode, :from => 'vmw:FenceMode'
-      xml_accessor  :dhcp?, :from => 'vmw:Dhcp'
-    end
-
-    class VApp
-      include ROXML
-      xml_namespace :gronk
-
-      xml_name "VApp"
-      xml_reader    :name,    :from => '@name'
-      xml_reader    :status,  :from => '@status'
-      xml_reader    :href,    :from => '@href'
-      xml_reader    :type,    :from => '@type'
-      xml_accessor  :foo,     :from => 'foo', :namespace => false
-      xml_accessor  :bar,     :from => 'bar', :namespace => false
-      xml_accessor  :network_configs, :as => [NetworkConfig], :namespace => :gronk
-    end
-
-    describe "#to_xml" do
-      it "should reproduce the input xml" do
-        output = ROXML::XML::Document.new
-        output.root = VApp.from_xml(@xml).to_xml
-        pending "Full namespace write support"
-        output.should == ROXML::XML.parse_string(@xml)
-      end
-    end
-  end
-
-  shared_examples_for "roxml namespacey declaration" do
-    context "with a namespacey :from" do
-      context "and an explicit :namespace" do
-        it "should raise" do
-          proc do
-            Class.new do
-              include ROXML
-              xml_reader :default_namespace_with_namespacey_from_and_explicit_namespace, :from => 'namespacey:with_namespacey_from', :namespace => 'explicit'
-            end
-          end.should raise_error(ROXML::ContradictoryNamespaces)
-        end
-      end
-
-      context "and :namespace => false" do
-        it "should raise" do
-          proc do
-            Class.new do
-              include ROXML
-              xml_reader :default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespacey_from', :namespace => false
-            end
-          end.should raise_error(ROXML::ContradictoryNamespaces)
-        end
-      end
-    end
-  end
-
-  shared_examples_for "roxml namespacey declaration with default" do
-    it_should_behave_like "roxml namespacey declaration"
-    
-    it "should use the default namespace" do
-      @instance.default_namespace.should == 'default namespace node'
-    end
-    
-    context "and :namespace => false" do
-      it "should find the namespace-less node" do
-        @instance.default_namespace_with_namespace_false.should == 'namespaceless node'
-      end
-    end
-
-    context "with an explicit :namespace" do
-      it "should use the explicit namespace" do
-        @instance.default_and_explicit_namespace == 'explicit namespace node'
-      end
-    end
-
-    context "with a namespace-less :from" do
-      it "should use the default namespace" do
-        @instance.default_namespace_with_namespaceless_from.should == 'default namespace node'
-      end
-      
-      context "and :namespace => false" do
-        it "should find the namespace-less node" do
-          @instance.default_namespace_with_namespaceless_from_and_namespace_false.should == 'namespaceless node'
-        end
-      end
-
-      context "and an explicit :namespace" do
-        it "should use the explicit namespace" do
-          @instance.default_namespace_with_namespaceless_from_and_explicit_namespace.should == 'explicit namespace node'
-        end
-      end
-    end
-
-    context "with a namespacey :from" do
-      it "should use the :from namespace" do
-        @instance.default_namespace_with_namespacey_from.should == 'namespacey node'
-      end
-    end
-  end
-
-  context "with a default namespace declared" do
-    class DefaultNamespaceyObject
-      include ROXML
-      xml_namespace :default_declared
-
-      xml_reader :default_namespace
-      xml_reader :default_namespace_with_namespace_false, :namespace => false
-      xml_reader :default_and_explicit_namespace, :namespace => 'explicit'
-      xml_reader :default_namespace_with_namespaceless_from, :from => 'with_namespaceless_from'
-      xml_reader :default_namespace_with_namespaceless_from_and_explicit_namespace, :from => 'with_namespaceless_from', :namespace => 'explicit'
-      xml_reader :default_namespace_with_namespaceless_from_and_namespace_false, :from => 'with_namespaceless_from', :namespace => false
-      xml_reader :default_namespace_with_namespacey_from, :from => 'namespacey:with_namespacey_from'
-
-      # These are handled in the "roxml namespacey declaration" shared spec
-      # xml_reader :default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespaceless_from', :namespace => false
-      # xml_reader :default_namespace_with_namespacey_from_and_explicit_namespace, :from => 'namespacey:with_namespaceless_from', :namespace => 'explicit'
-    end
-
-    before do
-      @instance = DefaultNamespaceyObject.from_xml(%{
-        <book xmlns:namespacey="http://www.aws.com/aws" xmlns:default_declared="http://www.aws.com/default" xmlns:explicit="http://www.aws.com/different">
-          <default_declared:default_namespace>default namespace node</default_declared:default_namespace>
-          <namespacey:with_namespacey_from>namespacey node</namespacey:with_namespacey_from>
-          <explicit:with_namespaceless_from>explicit namespace node</explicit:with_namespaceless_from>
-          <with_namespaceless_from>namespaceless node</with_namespaceless_from>
-          <default_declared:with_namespaceless_from>default namespace node</default_declared:with_namespaceless_from>
-          <explicit:default_and_explicit_namespace>explicit namespace node</explicit:default_and_explicit_namespace>
-          <default_namespace_with_namespace_false>namespaceless node</default_namespace_with_namespace_false>
-        </book>
-      })
-    end
-    
-    it_should_behave_like "roxml namespacey declaration with default"
-  end
-
-  context "with a default namespace on the root node" do
-    class XmlDefaultNamespaceyObject
-      include ROXML
-      xml_reader :default_namespace
-      xml_reader :default_namespace_with_namespace_false, :namespace => false
-      xml_reader :default_and_explicit_namespace, :namespace => 'explicit'
-      xml_reader :default_namespace_with_namespaceless_from, :from => 'with_namespaceless_from'
-      xml_reader :default_namespace_with_namespaceless_from_and_explicit_namespace, :from => 'with_namespaceless_from', :namespace => 'explicit'
-      xml_reader :default_namespace_with_namespaceless_from_and_namespace_false, :from => 'with_namespaceless_from', :namespace => false
-      xml_reader :default_namespace_with_namespacey_from, :from => 'namespacey:with_namespacey_from'
-
-      # These are handled in the "roxml namespacey declaration" shared spec
-      # xml_reader :default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespaceless_from', :namespace => false
-      # xml_reader :default_namespace_with_namespacey_from_and_explicit_namespace, :from => 'namespacey:with_namespaceless_from', :namespace => 'explicit'
-    end
-
-    before do
-      @instance = XmlDefaultNamespaceyObject.from_xml(%{
-        <book xmlns="http://www.aws.com/xml_default" xmlns:namespacey="http://www.aws.com/aws" xmlns:default_declared="http://www.aws.com/default" xmlns:explicit="http://www.aws.com/different">
-          <default_namespace>default namespace node</default_namespace>
-          <namespacey:with_namespacey_from>namespacey node</namespacey:with_namespacey_from>
-          <explicit:with_namespaceless_from>explicit namespace node</explicit:with_namespaceless_from>
-          <with_namespaceless_from xmlns="">namespaceless node</with_namespaceless_from>
-          <with_namespaceless_from>default namespace node</with_namespaceless_from>
-          <explicit:default_and_explicit_namespace>explicit namespace node</explicit:default_and_explicit_namespace>
-          <default_namespace_with_namespace_false xmlns="">namespaceless node</default_namespace_with_namespace_false>
-        </book>
-      })
-    end
-
-    it_should_behave_like "roxml namespacey declaration with default"
-  end
-
-  context "without a default namespace" do
-    class NamespaceyObject
-      include ROXML
-
-      xml_reader :no_default_namespace
-      xml_reader :no_default_namespace_with_namespace_false, :namespace => false
-      xml_reader :no_default_but_an_explicit_namespace, :namespace => 'explicit'
-      xml_reader :no_default_namespace_with_namespaceless_from, :from => 'with_namespaceless_from'
-      xml_reader :no_default_namespace_with_namespaceless_from_and_explicit_namespace, :from => 'with_namespaceless_from', :namespace => 'explicit'
-      xml_reader :no_default_namespace_with_namespaceless_from_and_namespace_false, :from => 'with_namespaceless_from', :namespace => false
-      xml_reader :no_default_namespace_with_namespacey_from, :from => 'namespacey:with_namespacey_from'
-
-      # These are handled in the "roxml namespacey declaration" shared spec
-      # xml_reader :no_default_namespace_with_namespacey_from_and_explicit_namespace, :from => 'namespacey:with_namespacey_from', :namespace => 'explicit'
-      # xml_reader :no_default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespacey_from', :namespace => false
-    end
-
-    before do
-      @instance = NamespaceyObject.from_xml(%{
-        <book xmlns:namespacey="http://www.aws.com/aws" xmlns:explicit="http://www.aws.com/different">
-          <namespacey:with_namespacey_from>namespacey node</namespacey:with_namespacey_from>
-          <explicit:with_namespaceless_from>explicit namespace node</explicit:with_namespaceless_from>
-          <with_namespaceless_from>namespaceless node</with_namespaceless_from>
-          <explicit:no_default_but_an_explicit_namespace>explicit namespace node</explicit:no_default_but_an_explicit_namespace>
-          <no_default_namespace_with_namespace_false>namespaceless node</no_default_namespace_with_namespace_false>
-          <no_default_namespace>namespaceless node</no_default_namespace>
-        </book>
-      })
-    end
-    
-    it_should_behave_like "roxml namespacey declaration"
-
-    it "should find the namespace-less node" do
-      @instance.no_default_namespace.should == 'namespaceless node'
-    end
-
-    context "with :namespace => false" do
-      it "should find the namespace-less node" do
-        @instance.no_default_namespace_with_namespace_false.should == 'namespaceless node'
-      end
-    end
-
-    context "with an explicit :namespace" do
-      it "should use the explicit namespace" do
-        @instance.no_default_but_an_explicit_namespace.should == 'explicit namespace node'
-      end
-    end
-
-    context "with a namespace-less :from" do
-      it "should find the namespace-less node" do
-        @instance.no_default_namespace_with_namespaceless_from.should == 'namespaceless node'
-      end
-    
-      context "and an explicit :namespace" do
-        it "should use the explicit namespace" do
-          @instance.no_default_namespace_with_namespaceless_from_and_explicit_namespace.should == 'explicit namespace node'
-        end
-      end
-
-      context "with :namespace => false" do
-        it "should find the namespace-less node" do
-          @instance.no_default_namespace_with_namespaceless_from_and_namespace_false.should == 'namespaceless node'
-        end
-      end
-    end
-
-    context "with a namespacey :from" do
-      it "should use the :from namespace" do
-        @instance.no_default_namespace_with_namespacey_from.should == 'namespacey node'
-      end
-    end
-  end
-end

data/spec/xml/namespaces_spec.rb

@@ -1,67 +0,0 @@
-require_relative './../spec_helper.rb'
-
-describe ROXML, "#xml_namespaces" do
-  describe "for reading" do
-    class Tires
-       include ROXML
-
-       xml_namespaces \
-         :bobsbike => 'http://bobsbikes.example.com',
-         :alicesauto => 'http://alicesautosupply.example.com/'
-
-       xml_reader :bike_tires, :as => [], :from => '@name', :in => 'bobsbike:tire'
-       xml_reader :car_tires, :as => [], :from => '@name', :in => 'alicesauto:tire'
-       xml_reader :tires, :as => [], :from => '@name', :in => 'tire', :namespace => '*'
-     end
-
-    before do
-       @xml = %{<?xml version="1.0"?>
-         <inventory xmlns="http://alicesautosupply.example.com/" xmlns:bike="http://bobsbikes.example.com">
-          <tire name="super slick racing tire" />
-          <tire name="all weather tire" />
-          <bike:tire name="skinny street" />
-         </inventory>
-       }
-    end
-
-    it "should remap default namespaces" do
-      Tires.from_xml(@xml).car_tires.should =~ ['super slick racing tire', 'all weather tire']
-    end
-
-    it "should remap prefix namespaces" do
-      Tires.from_xml(@xml).bike_tires.should == ['skinny street']
-    end
-
-    context "with namespace-indifferent option" do
-      it "should return all tires" do
-        Tires.from_xml(@xml).tires.should =~ ['super slick racing tire', 'all weather tire', 'skinny street']
-      end
-    end
-  end
-
-  context "when an included namespace is not defined in the xml" do
-    context "where the missing namespace is the default" do
-      it "should raise"
-
-      context "but the namespace is declared in the body" do
-        it "should succeed"
-      end
-    end
-    
-    context "where the missing namespace is included in a namespacey from" do
-      it "should raise"
-
-      context "but the namespace is declared in the body" do
-        it "should succeed"
-      end
-    end
-    
-    context "where the missing namespace is included in an explicit :namespace" do
-      it "should raise"
-
-      context "but the namespace is declared in the body" do
-        it "should succeed"
-      end
-    end
-  end
-end

data/spec/xml/object_spec.rb

@@ -1,82 +0,0 @@
-require_relative './../spec_helper'
-
-describe ROXML::XMLObjectRef do
-  class SubObject
-    include ROXML
-
-    xml_reader :value, :from => :attr
-
-    def initialize(value = nil)
-      @value = value
-    end
-  end
-
-  before do
-    @xml = ROXML::XML.parse_string %(
-<myxml>
-  <node>
-    <name value="first" />
-    <name value="second" />
-    <name value="third" />
-  </node>
-</myxml>)
-  end
-
-  context "plain vanilla" do
-    before do
-      @ref = ROXML::XMLObjectRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => false, :sought_type => SubObject), RoxmlObject.new)
-    end
-
-    it "should return one instance" do
-      @ref.value_in(@xml).value.should == "first"
-    end
-    it "should output one instance"
-  end
-  
-  context "with :as => []" do
-    before do
-      @ref = ROXML::XMLObjectRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true, :sought_type => SubObject), RoxmlObject.new)
-    end
-
-    it "should collect all instances" do
-      @ref.value_in(@xml).map(&:value).should == ["first", "second", "third"]
-    end
-
-    it "should output all instances" do
-      xml = ROXML::XML.new_node('myxml')
-      @ref.update_xml(xml, ["first", "second", "third"].map {|value| SubObject.new(value) })
-      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
-    end
-  end
-  
-  context "when the namespaces are different" do
-    before do
-      @xml = ROXML::XML.parse_string %(
-      <myxml xmlns="http://example.com/three" xmlns:one="http://example.com/one" xmlns:two="http://example.com/two">
-        <node>
-          <one:name>first</one:name>
-          <two:name>second</two:name>
-          <name>third</name>
-        </node>
-      </myxml>)
-    end
-
-    context "with :namespace => '*'" do
-      before do
-        @ref = ROXML::XMLObjectRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true, :namespace => '*', :sought_type => SubObject), RoxmlObject.new)
-      end
-
-      it "should collect all instances" do
-        pending "Test bug?"
-        @ref.value_in(@xml).map(&:value).should == ["first", "second", "third"]
-      end
-
-      it "should output all instances with namespaces" do
-        pending "Full namespace write support"
-        xml = ROXML::XML.new_node('myxml')
-        @ref.update_xml(xml, ["first", "second", "third"].map {|value| SubObject.new(value) })
-        xml.should == @xml.root
-      end
-    end
-  end
-end