yob-roxml 3.1.6

data/test/unit/xml_hash_test.rb

@@ -0,0 +1,115 @@
+require 'test/test_helper'
+
+class BookWithContributorHash
+  include ROXML
+
+  xml_reader :contributors, :as => {:key => '@role',
+                             :value => 'name'}
+end
+
+class TestXMLHash < ActiveSupport::TestCase
+  def setup
+    @contents = {'quaquaversally' => 'adjective: (of a geological formation) sloping downward from the center in all directions.',
+                 'tergiversate' => 'To use evasions or ambiguities; equivocate.'}
+  end
+
+  def test_hash_preserves_data
+    b = BookWithContributorHash.from_xml(%{
+      <book isbn="0974514055">
+        <contributor role="author"><name>David Thomas</name></contributor>
+        <contributor role="supporting author"><name>Andrew Hunt</name></contributor>
+        <contributor role="supporting author"><name>Chad Fowler</name></contributor>
+      </book>
+    })
+    assert_equal({'author' => 'David Thomas', 'supporting author' => ['Andrew Hunt', 'Chad Fowler']},
+      b.contributors)
+  end
+
+  def test_hash_with_object_key_fails
+    assert_raise ArgumentError do
+      Class.new do
+        include ROXML
+
+        xml_reader :object_key_to_text, :as => {:key => BookWithContributorHash,
+                                         :value => 'text_node'}
+      end
+    end
+  end
+
+  def test_hash_with_object_value_fails
+    assert_raise ArgumentError do
+      Class.new do
+        include ROXML
+
+        xml_reader :key_to_object_value, :as => {:key => '@text_node',
+                                          :value => BookWithContributorHash}
+      end
+    end
+  end
+
+  def test_attrs_hash
+    dict = DictionaryOfAttrs.from_xml(fixture(:dictionary_of_attrs))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_text_hash
+    dict = DictionaryOfTexts.from_xml(fixture(:dictionary_of_texts))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_mixed_content_hash
+    dict = DictionaryOfMixeds.from_xml(fixture(:dictionary_of_mixeds))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_name_hash
+    dict = DictionaryOfNames.from_xml(fixture(:dictionary_of_names))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_guarded_name_hash
+    dict = DictionaryOfGuardedNames.from_xml(fixture(:dictionary_of_guarded_names))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_text_name_clashes
+    dict = DictionaryOfNameClashes.from_xml(fixture(:dictionary_of_name_clashes))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_attr_name_clashes
+    dict = DictionaryOfAttrNameClashes.from_xml(fixture(:dictionary_of_attr_name_clashes))
+    assert_equal Hash, dict.definitions.class
+    assert_equal @contents, dict.definitions
+  end
+
+  def test_it_should_gracefully_handle_empty_hash
+    dict = Class.new do
+      include ROXML
+
+      xml_reader :missing_hash, :as => {:key => :name, :value => :content}, :in => 'EmptyDictionary'
+    end
+
+    assert_equal({}, dict.from_xml(%{
+      <dict>
+        <EmptyDictionary>
+        </EmptyDictionary>
+      </dict>
+    }).missing_hash)
+  end
+
+  def test_as_hash_of_as_type_not_deprecated
+    assert_not_deprecated do
+      opts = ROXML::Definition.new(:name, :as => {:key => :name, :value => {:from => 'value', :as => OctalInteger}})
+      assert opts.hash?
+      assert_equal OctalInteger, opts.hash.value.sought_type
+      assert_equal 'value', opts.hash.value.name
+    end
+  end
+end

data/test/unit/xml_initialize_test.rb

@@ -0,0 +1,49 @@
+require 'test/test_helper'
+
+class InheritedBookWithDepth < Book
+  xml_reader :depth, :as => Measurement
+end
+
+class BookWithXmlInitialize < BookWithDepth
+  attr_reader :created_at, :creator
+
+  def initialize(created_at, creator = "Unknown")
+    @created_at = created_at
+    @creator = creator
+  end
+end
+
+class TestXMLInitialize < ActiveSupport::TestCase
+  def test_initialize_is_run
+    m = Measurement.from_xml('<measurement units="hundredths-meters">1130</measurement>')
+    assert_equal 11.3, m.value
+    assert_equal 'meters', m.units
+  end
+
+  def test_initialize_is_run_for_nested_type
+    b = BookWithDepth.from_xml(fixture(:book_with_depth))
+    assert_equal Measurement.new(11.3, 'meters'), b.depth
+  end
+
+  def test_initialize_is_run_for_nested_type_with_inheritance
+    b = InheritedBookWithDepth.from_xml(fixture(:book_with_depth))
+    assert_equal Measurement.new(11.3, 'meters'), b.depth
+  end
+
+  def test_initialize_fails_on_missing_required_arg
+    assert_raise ArgumentError do
+      BookWithXmlInitialize.from_xml(fixture(:book_with_depth))
+    end
+  end
+
+  def test_initialize_with_extra_args
+    now = Time.now
+    b = BookWithXmlInitialize.from_xml(fixture(:book_with_depth), now)
+    assert_equal now, b.created_at
+    assert_equal "Unknown", b.creator
+
+    b = BookWithXmlInitialize.from_xml(fixture(:book_with_depth), Time.now, "Joe Librarian")
+    assert now < b.created_at
+    assert_equal "Joe Librarian", b.creator
+  end
+end

data/test/unit/xml_name_test.rb

@@ -0,0 +1,141 @@
+require 'test/test_helper'
+
+#      Parent        |    Child
+#  :from  | no :from |
+# -------------------|--------------
+#  :from  | xml_name | xml_name-d
+#  value  |  value   |
+# -------------------|--------------
+#  :from  | parent's |
+#  value  | accessor | un-xml_name-d
+#         |  name    |
+
+class Child
+  include ROXML
+end
+
+class NamedChild
+  include ROXML
+
+  xml_name :xml_name_of_child
+end
+
+class ParentOfNamedChild
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, :as => NamedChild
+end
+
+class ParentOfNamedChildWithFrom
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, :as => NamedChild, :from => 'child_from_name'
+end
+
+class ParentOfUnnamedChild
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, :as => Child
+end
+
+class ParentOfUnnamedChildWithFrom
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name,:as => Child, :from => 'child_from_name'
+end
+
+class TestXMLName < ActiveSupport::TestCase
+  def test_from_always_dominates_attribute_name_xml_name_or_not
+    parent = ParentOfNamedChildWithFrom.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_from_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+
+    parent = ParentOfUnnamedChildWithFrom.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_from_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_attribute_name_comes_from_the_xml_name_value_if_present
+    parent = ParentOfNamedChild.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><xml_name_of_child/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_attribute_name_comes_from_parent_accessor_by_default
+    parent = ParentOfUnnamedChild.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_accessor_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_it_should_be_inherited
+    class_with_inherited_name = Class.new(ParentOfNamedChild)
+    assert_equal :parent, class_with_inherited_name.tag_name
+  end
+
+  def test_it_should_be_inherited_over_multiple_levels
+    class_with_inherited_name = Class.new(Class.new(ParentOfNamedChild))
+    assert_equal :parent, class_with_inherited_name.tag_name
+  end
+
+  def test_named_books_picked_up
+    named = Library.from_xml(fixture(:library))
+    assert named.books
+    assert_equal :book, named.books.first.class.tag_name
+  end
+
+  def test_nameless_books_missing
+    nameless = LibraryWithBooksOfUnderivableName.from_xml(fixture(:library))
+    assert nameless.novels.empty?
+  end
+
+  def test_tag_name
+    assert_equal :dictionary, DictionaryOfTexts.tag_name
+
+    dict = DictionaryOfTexts.from_xml(fixture(:dictionary_of_texts))
+
+    assert_equal :dictionary, dict.class.tag_name
+  end
+
+  def test_roxml_attrs
+    assert_equal 'definition', DictionaryOfTexts.roxml_attrs.first.name
+    assert_equal 'word', DictionaryOfTexts.roxml_attrs.first.hash.key.name
+    assert_equal 'meaning', DictionaryOfTexts.roxml_attrs.first.hash.value.name
+  end
+
+  def test_xml_name_should_not_be_conventionalized_if_explicitly_set
+    reference = ROXML::XMLTextRef.new(ROXML::Definition.new(:name, :from => 'georss:name'), WrapModule::InstanceStandin.new)
+    assert_equal "georss:name", reference.name
+  end
+
+  def test_xml_name_not_screwed_up_by_xml_convention
+    reference = ROXML::XMLTextRef.new(ROXML::Definition.new(:name, :in => './'), WrapModule::InstanceStandin.new)
+    assert_equal "name value", reference.value_in(ROXML::XML.parse_string(%(
+      <Wrapper>
+         <MoreStuff>
+            <DeepWrapper>
+               <Name>name value</Name>
+            </DeepWrapper>
+         </MoreStuff>
+      </Wrapper>
+    )).root)
+  end
+end
+
+module WrapModule
+  class BaseClass
+    include ROXML
+    xml_convention :camelcase
+  end
+
+  class InstanceStandin < BaseClass
+    xml_reader :name, :in => './'
+  end
+end

data/test/unit/xml_namespace_test.rb

@@ -0,0 +1,31 @@
+require 'test/test_helper'
+
+class TestDefaultXMLNamespaces < ActiveSupport::TestCase
+  def setup
+    @book = BookWithContributions.from_xml(fixture(:book_with_default_namespace))
+  end
+
+  def test_default_namespace_doesnt_interfere_with_normal_operation
+    assert_equal("Programming Ruby - 2nd Edition", @book.title)
+  end
+
+  def test_default_namespace_is_applied_to_in_element
+    expected_authors = ["David Thomas","Andrew Hunt","Chad Fowler"]
+    assert !@book.contributions.empty?
+    @book.contributions.each do |contributor|
+      assert expected_authors.include?(contributor.name)
+    end
+  end
+
+  def test_default_namespace_on_root_node_should_be_found
+    require 'libxml'
+    xml = LibXML::XML::Parser.string(
+      '<container xmlns="http://defaultnamespace.org"><node>Yeah, content</node><node><subnode>Another</subnode></node></container>').parse
+
+    assert_equal nil, xml.find_first('node')
+    assert_equal "Yeah, content", xml.find_first('ns:node', 'ns:http://defaultnamespace.org').content
+    assert_equal nil, xml.find_first('ns:node/subnode', 'ns:http://defaultnamespace.org')
+    assert_equal "Another", xml.find_first('ns:node/ns:subnode', 'ns:http://defaultnamespace.org').content
+  rescue LoadError
+  end
+end

data/test/unit/xml_object_test.rb

@@ -0,0 +1,205 @@
+require 'test/test_helper'
+
+class EmptyCart
+  include ROXML
+
+  xml_reader :id
+
+  def empty?
+    true
+  end
+end
+
+class CartHolder
+  include ROXML
+
+  xml_reader :cart, :as => EmptyCart, :required => true
+end
+
+class TestXMLObject < ActiveSupport::TestCase
+  # Test book with text and attribute
+  def test_book_author_text_attribute
+    book = BookWithAuthorTextAttribute.from_xml(fixture(:book_text_with_attribute))
+    assert_equal("primary",book.author.role)
+    assert_equal("David Thomas",book.author.text)
+  end
+
+  # Test XML object containing list of other XML objects (one-to-many)
+  # In this case, book with contibutions
+  def test_one_to_many_with_container
+    expected_authors = ["David Thomas","Andrew Hunt","Chad Fowler"]
+    book = BookWithContributions.from_xml(fixture(:book_with_contributions))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    book.contributions.each do |contributor|
+      assert expected_authors.include?(contributor.name)
+    end
+  end
+
+  # Test XML object containing 1-n other XML objects without container (one-to-many)
+  # In this case, book with contibutions
+  def test_one_to_many_without_container
+    expected_contributors = ["David Thomas","Andrew Hunt","Chad Fowler"]
+    book = BookWithContributors.from_xml(fixture(:book_with_contributors))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    book.contributors.each do |contributor|
+      assert(expected_contributors.include?(contributor.name))
+    end
+  end
+
+  # when building objects that contain arrays, the second object seems to
+  # inherit data from the first
+  #
+  def test_one_to_many_without_container_sequence
+    contrib = WriteableContributor.new
+    contrib.name = "David Thomas"
+
+    book_one = WriteableBookWithContributors.new
+    book_one.isbn = "9781843549161"
+    book_one.title = "Anathem"
+    book_one.description = "A new title from Neal Stephenson"
+    book_one.contributors = [contrib]
+
+    # this book should be completely empty
+    book_two = WriteableBookWithContributors.new
+
+    assert_equal(nil, book_two.isbn)
+    assert_equal(nil, book_two.title)
+    assert_equal(nil, book_two.description)
+    assert_equal(nil, book_two.contributors)
+  end
+
+  # Test XML object containing one other XML object (one-to-one)
+  # In this case, book with publisher
+  def test_one_to_one
+    book = BookWithPublisher.from_xml(fixture(:book_with_publisher))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    assert_equal("Pragmatic Bookshelf", book.publisher.name)
+  end
+
+  # Test XML object containing type of self (self-reference)
+  def test_self_reference
+    book = BookPair.from_xml(fixture(:book_pair))
+    assert_equal("Programming Ruby - 2nd Edition", book.title)
+    assert_equal("Agile Web Development with Rails", book.book.title)
+  end
+
+  # Test three-level composition (one-to-many-to-many)
+  def test_one_to_many_to_many
+    expected_contributors = ["David Thomas","Andrew Hunt","Chad Fowler", "David Heinemeier Hansson"]
+    expected_books = ["Programming Ruby - 2nd Edition", "Agile Web Development with Rails"]
+    library = Library.from_xml(fixture(:library))
+    assert_equal("Ruby library", library.name)
+    assert !library.books.empty?
+    library.books.each do |book|
+      assert expected_books.include?(book.title)
+      book.contributions.each do |contributor|
+        assert(expected_contributors.include?(contributor.name))
+      end
+    end
+  end
+
+  def test_without_needed_from
+    assert_equal [], UppercaseLibrary.from_xml(fixture(:library)).books
+    assert_equal [], Library.from_xml(fixture(:library_uppercase)).books
+  end
+
+  def test_with_needed_from
+    assert Library.from_xml(fixture(:library)).books
+    assert UppercaseLibrary.from_xml(fixture(:library_uppercase)).books
+  end
+
+  def test_with_recursion
+    p = PersonWithMother.from_xml(fixture(:person_with_mothers))
+    assert_equal 'Ben Franklin', p.name
+    assert_equal 'Abiah Folger', p.mother.name
+    assert_equal 'Madeup Mother', p.mother.mother.name
+    assert_equal nil, p.mother.mother.mother
+  end
+
+  class Node
+    include ROXML
+
+    xml_reader :name, :from => 'node_name'
+    xml_reader :nodes, :as => [Node]
+  end
+
+  class Taxonomy
+    include ROXML
+
+    xml_reader :name, :from => 'taxonomy_name'
+    xml_reader :nodes, :as => [Node]
+  end
+
+  class Taxonomies
+    include ROXML
+    xml_reader :taxonomies, :as => [Taxonomy]
+  end
+
+  def test_more_recursion
+    taxonomies = Taxonomies.from_xml(<<HERE)
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE taxonomies SYSTEM "taxonomy.dtd">
+<taxonomies>
+	<taxonomy>
+		<taxonomy_name>World</taxonomy_name>
+		<node node_id="2" content_object_id="82534" object_type_id="2">
+			<node_name lang_iso="eng">Africa</node_name>
+			<node node_id="331" content_object_id="11" object_type_id="4">
+				<node_name lang_iso="eng">Algeria</node_name>
+				<node node_id="7271" content_object_id="117629" object_type_id="8">
+					<node_name lang_iso="eng">Algiers</node_name>
+				</node>
+				<node node_id="7272" content_object_id="117630" object_type_id="8">
+					<node_name lang_iso="eng">Gharda&#239;a</node_name>
+				</node>
+				<node node_id="7871" content_object_id="1000713999" object_type_id="8">
+					<node_name lang_iso="eng">El Oued</node_name>
+				</node>
+				<node node_id="7872" content_object_id="1000714008" object_type_id="8">
+					<node_name lang_iso="eng">Timimoun</node_name>
+				</node>
+				<node node_id="8903" content_object_id="1000565565" object_type_id="8">
+					<node_name lang_iso="eng">Annaba</node_name>
+				</node>
+			</node>
+		</node>
+	</taxonomy>
+</taxonomies>
+HERE
+    assert_equal 1, taxonomies.taxonomies.size
+    assert_equal 'World', taxonomies.taxonomies.first.name
+    node = taxonomies.taxonomies.first.nodes.first
+    assert_equal 'Africa', node.name
+    assert_equal 'Algeria', node.nodes.first.name
+    assert_equal ['Algiers', "Gharda\303\257a", 'El Oued', 'Timimoun', 'Annaba'],
+      node.nodes.first.nodes.map(&:name)
+  end
+
+  def test_with_guarded_recursion
+    p = PersonWithGuardedMother.from_xml(fixture(:person_with_guarded_mothers))
+    assert_equal 'Ben "Benji" Franklin', p.name
+    assert_equal 'Abiah \'Abby\' Folger', p.mother.name
+    assert_equal 'Madeup Mother < the third >', p.mother.mother.name
+    assert_equal nil, p.mother.mother.mother
+  end
+
+  def test_recursive_with_default_initialization
+    p = PersonWithMotherOrMissing.from_xml(fixture(:person_with_mothers))
+    assert_equal 'Unknown', p.mother.mother.mother.name
+    assert_equal Person, p.mother.mother.mother.class
+  end
+
+  def test_defining_empty_on_object_doesnt_cause_it_to_be_seen_as_absent
+    # absent means defaulting, failing required
+
+    holder = CartHolder.from_xml(%{
+      <cartholder>
+        <cart>
+          <id>111111</id>
+        </cart>
+      </cartholder>
+    })
+
+    assert_equal "111111", holder.cart.id
+  end
+end