yob-roxml 3.1.6

data/test/fixtures/muffins.xml

@@ -0,0 +1,3 @@
+<muffins>
+  <bakers_dozens>3</bakers_dozens>
+</muffins>

data/test/fixtures/nameless_ageless_youth.xml

@@ -0,0 +1,2 @@
+<person>
+</person>

data/test/fixtures/node_with_attr_name_conflicts.xml

@@ -0,0 +1 @@
+<node content="Just junk... really" name="Cartwheel" />

data/test/fixtures/node_with_name_conflicts.xml

@@ -0,0 +1,4 @@
+<node>
+  <content>Just junk... really</content>
+  <name>Cartwheel</name>
+</node>

data/test/fixtures/numerology.xml

@@ -0,0 +1,4 @@
+<numerology>
+  <prediction number="13" meaning="A bad number" />
+  <prediction number="7"  meaning="A good number" />
+</numerology>

data/test/fixtures/person.xml

@@ -0,0 +1 @@
+<person>Ben Franklin</person>

data/test/fixtures/person_with_guarded_mothers.xml

@@ -0,0 +1,13 @@
+<person>
+  <name>Ben &quot;Benji&quot; Franklin</name>
+  <mother>
+    <person>
+      <name>Abiah &apos;Abby&apos; Folger</name>
+      <mother>
+        <person>
+          <name>Madeup Mother &lt; the third &gt;</name>
+        </person>
+      </mother>
+    </person>
+  </mother>
+</person>

data/test/fixtures/person_with_mothers.xml

@@ -0,0 +1,10 @@
+<person>
+  <name>Ben Franklin</name>
+  <mother>
+    <name>Abiah Folger</name>
+    <mother>
+      <name>Madeup Mother</name>
+    </mother>
+  </mother>
+</person>
+

data/test/load_test.rb

@@ -0,0 +1,6 @@
+require 'fileutils'
+FileUtils.cd(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'roxml'
+puts ROXML::VERSION

data/test/mocks/dictionaries.rb

@@ -0,0 +1,57 @@
+require 'lib/roxml'
+
+class DictionaryOfAttrs
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => '@dt',
+                                   :value => '@dd'}, :in => :definitions
+end
+
+class DictionaryOfTexts
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => :word,
+                            :value => :meaning}
+end
+
+class DictionaryOfMixeds
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => '@word',
+                            :value => :content}
+end
+
+class DictionaryOfNames
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => :name,
+                            :value => :content}
+end
+
+class DictionaryOfGuardedNames
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => :name,
+                            :value => :content}, :in => :definitions
+end
+
+class DictionaryOfNameClashes
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => 'name',
+                            :value => 'content'}, :from => :definition
+end
+
+class DictionaryOfAttrNameClashes
+  include ROXML
+
+  xml_name :dictionary
+  xml_reader :definitions, :as => {:key => '@name',
+                            :value => 'content'}, :from => :definition
+end

data/test/mocks/mocks.rb

@@ -0,0 +1,279 @@
+require "lib/roxml"
+
+class Muffins
+  include ROXML
+
+  xml_reader(:count, :from => 'bakers_dozens') {|val| val.to_i * 13 }
+end
+
+class MuffinsWithStackedBlocks
+  include ROXML
+
+  xml_reader(:count, :from => 'bakers_dozens', :as => Integer) {|val| val * 13 }
+end
+
+class Numerology
+  include ROXML
+
+  xml_reader :predictions, :as => {:key => '@number', :value => '@meaning'} do |k, v|
+    [Integer(k), v]
+  end
+end
+
+class Contributor
+  include ROXML
+
+  xml_reader :role, :from => :attr
+  xml_reader :name
+end
+
+class WriteableContributor
+  include ROXML
+
+  xml_accessor :role, :from => :attr
+  xml_accessor :name
+end
+
+class Book
+  include ROXML
+
+  xml_accessor :isbn, :from => '@ISBN'
+  xml_reader :title
+  xml_reader :description, :cdata => true
+  xml_reader :author
+  xml_accessor :pages, :from => 'pagecount', :as => Integer
+end
+
+class BookWithRequired
+  include ROXML
+
+  xml_accessor :isbn, :from => '@ISBN', :required => true
+  xml_reader :title, :required => true
+  xml_reader :contributors, :as => [Contributor], :in => 'contributor_array', :required => true
+  xml_reader :contributor_hash, :as => {:key => '@role', :value => '@name'},
+                                :from => 'contributor', :in => 'contributor_hash', :required => true
+end
+
+class BookWithAttrFrom
+  include ROXML
+
+  xml_accessor :isbn, :from => '@ISBN'
+end
+
+class BookWithWrappedAttr
+  include ROXML
+
+  xml_name :book
+  xml_accessor :isbn, :from => '@ISBN', :in => 'ids'
+end
+
+class Measurement
+  include ROXML
+
+  xml_reader :units, :from => :attr
+  xml_reader :value, :from => :content, :as => Float
+
+  def initialize(value = 0, units = 'pixels')
+    @value = Float(value)
+    @units = units.to_s
+    normalize_hundredths
+  end
+
+  def to_s
+    "#{value} #{units}"
+  end
+
+  def ==(other)
+    other.units == @units && other.value == @value
+  end
+
+private
+  def after_parse
+    normalize_hundredths
+  end
+
+  def normalize_hundredths
+    if @units.starts_with? 'hundredths-'
+      @value /= 100
+      @units = @units.split('hundredths-')[1]
+    end
+  end
+end
+
+class BookWithDepth
+  include ROXML
+
+  xml_reader :isbn, :from => '@ISBN'
+  xml_reader :title
+  xml_reader :description, :cdata => true
+  xml_reader :author
+  xml_reader :depth, :as => Measurement
+end
+
+class Author
+  include ROXML
+
+  xml_reader :role, :from => :attr
+  xml_reader :text, :from => :content
+end
+
+class BookWithAuthors
+  include ROXML
+
+  xml_name :book
+  xml_reader :isbn, :from => '@ISBN'
+  xml_reader :title
+  xml_reader :description, :cdata => true
+  xml_reader :authors, :as => []
+end
+
+class BookWithAuthorTextAttribute
+  include ROXML
+
+  xml_name :book
+  xml_reader :isbn, :from => '@ISBN'
+  xml_reader :title
+  xml_reader :description, :cdata => true
+  xml_reader :author, :as => Author
+end
+
+class BookWithContributions
+  include ROXML
+
+  xml_name :book
+  xml_reader :isbn, :from => :attr
+  xml_reader :title
+  xml_reader :description
+  xml_reader :contributions, :as => [Contributor], :from => 'contributor', :in => "contributions"
+end
+
+class BookWithContributors
+  include ROXML
+
+  xml_name :book
+  xml_reader :isbn, :from => :attr
+  xml_reader :title
+  xml_reader :description
+  xml_reader :contributors, :as => [Contributor]
+end
+
+class WriteableBookWithContributors
+  include ROXML
+
+  xml_name :book
+  xml_accessor :isbn, :from => :attr
+  xml_accessor :title
+  xml_accessor :description
+  xml_accessor :contributors, :as => [Contributor]
+end
+
+class NamelessBook
+  include ROXML
+
+  xml_reader :isbn, :from => :attr
+  xml_reader :title
+  xml_reader :description
+  xml_reader :contributors, :as => [Contributor]
+end
+
+class Publisher
+  include ROXML
+
+  xml_reader :name
+end
+
+class BookWithPublisher
+  include ROXML
+
+  xml_reader :book
+  xml_reader :isbn, :from => :attr
+  xml_reader :title
+  xml_reader :description
+  xml_reader :publisher, :as => Publisher
+end
+
+class BookPair
+  include ROXML
+
+  xml_reader :isbn, :from => :attr
+  xml_reader :title
+  xml_reader :description
+  xml_reader :author
+  xml_reader :book, :as => Book
+end
+
+class Library
+  include ROXML
+
+  xml_reader :name
+  xml_reader :books, :as => [BookWithContributions]
+end
+
+class UppercaseLibrary
+  include ROXML
+
+  xml_name :library
+  xml_reader :name, :from => 'NAME'
+  xml_reader :books, :as => [BookWithContributions], :from => 'BOOK'
+end
+
+class LibraryWithBooksOfUnderivableName
+  include ROXML
+
+  xml_accessor :name
+  xml_reader :novels, :as => [NamelessBook]
+end
+
+class NodeWithNameConflicts
+  include ROXML
+
+  xml_name :node
+  xml_reader :content
+  xml_reader :name
+end
+
+class NodeWithAttrNameConflicts
+  include ROXML
+
+  xml_name :node
+  xml_reader :content, :from => '@content'
+  xml_reader :name, :from => '@name'
+end
+
+class Person
+  include ROXML
+
+  xml_accessor :age, :from => :attr, :else => 21
+  xml_accessor :name, :from => :content, :else => 'Unknown'
+
+  def self.blank
+    new.tap do |instance|
+      instance.age = 21
+      instance.name = 'Unknown'
+    end
+  end
+end
+
+class PersonWithMother
+  include ROXML
+
+  xml_name :person
+  xml_reader :name
+  xml_reader :mother, :as => PersonWithMother, :from => 'mother'
+end
+
+class PersonWithGuardedMother
+  include ROXML
+
+  xml_name :person
+  xml_reader :name
+  xml_reader :mother, :as => PersonWithGuardedMother, :from => :person, :in => :mother
+end
+
+class PersonWithMotherOrMissing
+  include ROXML
+
+  xml_reader :age, :from => :attr, :else => 21
+  xml_reader :name, :else => 'Anonymous'
+  xml_reader :mother,:as => PersonWithMotherOrMissing, :else => Person.blank
+end

data/test/support/fixtures.rb

@@ -0,0 +1,11 @@
+def fixture(name)
+  File.read(fixture_path(name))
+end
+
+def xml_fixture(name)
+  ROXML::XML.parse_file(fixture_path(name)).root
+end
+
+def fixture_path(name)
+  "test/fixtures/#{name}.xml"
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'active_support/test_case'
+require 'test/mocks/mocks'
+require 'test/mocks/dictionaries'
+require 'test/support/fixtures'
+
+def to_xml_test(*names)
+  names = names.first if names.size == 1 && names.first.is_a?(Hash)
+  names.each do |name, xml_name|
+    xml_name ||= name
+
+    define_method "test_#{name}" do
+      klass = name.is_a?(Symbol) ? name.to_s.camelize.constantize : name
+      xml = xml_name.is_a?(Symbol) ? xml_fixture(xml_name) : xml_name
+
+      dict = klass.from_xml(xml)
+      xml = remove_children(xml)
+      assert_equal xml.to_s, dict.to_xml.to_s
+    end
+  end
+end
+
+def remove_children(xml)
+  xml = ROXML::XML.parse_string(xml).root if xml.is_a?(String)
+  return unless xml.respond_to? :children
+  xml.children.each do |child|
+    if child.to_s.blank?
+      defined?(Nokogiri) ? child.remove : child.remove!
+    else
+      remove_children(child)
+    end
+  end
+  xml
+end

data/test/unit/definition_test.rb

@@ -0,0 +1,235 @@
+require 'test/test_helper'
+
+class TestDefinition < ActiveSupport::TestCase
+  def assert_hash(opts, kvp)
+    assert opts.hash?
+    assert !opts.array?
+    assert_equal kvp, {opts.hash.key.sought_type => opts.hash.key.name,
+                       opts.hash.value.sought_type => opts.hash.value.name}
+  end
+
+  def test_empty_array_means_as_array_for_text
+    opts = ROXML::Definition.new(:authors, :as => [])
+    assert opts.array?
+    assert_equal :text, opts.sought_type
+  end
+
+  def test_attr_in_array_means_as_array_for_attr
+    opts = ROXML::Definition.new(:authors, :as => [], :from => :attr)
+    assert opts.array?
+    assert_equal :attr, opts.sought_type
+  end
+
+  def test_block_shorthand_in_array_means_array
+    opts = ROXML::Definition.new(:intarray, :as => [Integer])
+    assert opts.array?
+    assert_equal :text, opts.sought_type
+    assert 1, opts.blocks.size
+  end
+
+  def test_required
+    assert !ROXML::Definition.new(:author).required?
+    assert ROXML::Definition.new(:author, :required => true).required?
+    assert !ROXML::Definition.new(:author, :required => false).required?
+  end
+
+  def test_required_conflicts_with_else
+    assert_raise ArgumentError do
+      ROXML::Definition.new(:author, :required => true, :else => 'Johnny')
+    end
+    assert_nothing_raised do
+      ROXML::Definition.new(:author, :required => false, :else => 'Johnny')
+    end
+  end
+
+  def test_hash_of_attrs
+    opts = ROXML::Definition.new(:attributes, :as => {:key => '@name', :value => '@value'})
+    assert_hash(opts, :attr => 'name', :attr => 'value')
+  end
+
+  def test_hash_with_attr_key_and_text_val
+    opts = ROXML::Definition.new(:attributes, :as => {:key => '@name',
+                                         :value => :value})
+    assert_hash(opts, :attr => 'name', :text => 'value')
+  end
+
+  def test_hash_with_string_class_for_type
+    opts = ROXML::Definition.new(:attributes, :as => {:key => 'name',
+                                         :value => 'value'})
+    assert_hash(opts, :text => 'name', :text => 'value')
+  end
+
+  def test_hash_with_attr_key_and_content_val
+    opts = ROXML::Definition.new(:attributes, :as => {:key => '@name',
+                                         :value => :content})
+    assert_hash(opts, :attr => 'name', :text => '.')
+  end
+
+  def test_hash_with_options
+    opts = ROXML::Definition.new(:definitions, :as => {:key => '@dt', :value => '@dd'},
+                           :in => :definitions, :from => 'definition')
+    assert_hash(opts, :attr => 'dt', :attr => 'dd')
+    assert_equal 'definition', opts.hash.wrapper
+  end
+
+  def test_no_block_shorthand_means_no_block
+    assert ROXML::Definition.new(:count).blocks.empty?
+  end
+
+  def test_block_integer_shorthand
+    assert_equal 3, ROXML::Definition.new(:count, :as => Integer).blocks.first['3']
+  end
+
+  def test_block_float_shorthand
+    assert_equal 3.1, ROXML::Definition.new(:count, :as => Float).blocks.first['3.1']
+  end
+
+  def test_from_attr_is_supported
+    opts = ROXML::Definition.new(:count, :from => :attr)
+    assert_equal "count", opts.name
+    assert_equal :attr, opts.sought_type
+  end
+
+  def test_from_at_name_is_supported
+    opts = ROXML::Definition.new(:count, :from => "@COUNT")
+    assert_equal "COUNT", opts.name
+    assert_equal :attr, opts.sought_type
+  end
+
+  def test_multiple_shorthands_raises
+    assert_raise ArgumentError do
+      assert_deprecated do
+        ROXML::Definition.new(:count, :as => [Float, Integer])
+      end
+    end
+  end
+
+  def test_stacked_blocks
+    assert_equal 2, ROXML::Definition.new(:count, :as => Integer) {|val| val.to_i }.blocks.size
+    assert_equal 2, ROXML::Definition.new(:count, :as => Float) {|val| val.object_id }.blocks.size
+  end
+
+  def test_block_shorthand_supports_bool
+    assert_equal true, ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("1")
+    assert_equal [true, false, nil], ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call(["TrUe", "0", "328"])
+  end
+
+  def test_block_shorthand_supports_integer
+    assert_equal nil, ROXML::Definition.new(:floatvalue, :as => Integer).blocks.first.call(" ")
+    assert_equal 792, ROXML::Definition.new(:floatvalue, :as => Integer).blocks.first.call("792")
+    assert_raise ArgumentError do
+      ROXML::Definition.new(:floatvalue, :as => Integer).blocks.first.call("792.13")
+    end
+    assert_equal [792, 12, 328], ROXML::Definition.new(:floatvalue, :as => Integer).blocks.first.call(["792", "12", "328"])
+  end
+
+  def test_block_shorthand_supports_float
+    assert_equal nil, ROXML::Definition.new(:floatvalue, :as => Float).blocks.first.call("  ")
+    assert_equal 792.13, ROXML::Definition.new(:floatvalue, :as => Float).blocks.first.call("792.13")
+    assert_equal 240.0, ROXML::Definition.new(:floatvalue, :as => Float).blocks.first.call("240")
+    assert_equal [792.13, 240.0, 3.14], ROXML::Definition.new(:floatvalue, :as => Float).blocks.first.call(["792.13", "240", "3.14"])
+  end
+
+  def test_block_shorthand_supports_time
+    assert_equal nil, ROXML::Definition.new(:floatvalue, :as => Time).blocks.first.call("  ")
+    assert_equal 31, ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call("12:31am").min
+    assert_equal [31, 0, 59], ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call(["12:31am", "3:00pm", "11:59pm"]).map(&:min)
+  end
+
+  def test_block_shorthand_supports_date
+    assert_equal nil, ROXML::Definition.new(:floatvalue, :as => Date).blocks.first.call("  ")
+    assert_equal "1970-09-03", ROXML::Definition.new(:datevalue, :as => Date).blocks.first.call("September 3rd, 1970").to_s
+    assert_equal ["1970-09-03", "1776-07-04"], ROXML::Definition.new(:datevalue, :as => Date).blocks.first.call(["September 3rd, 1970", "1776-07-04"]).map(&:to_s)
+  end
+
+  def test_block_shorthand_supports_datetime
+    assert_equal nil, ROXML::Definition.new(:floatvalue, :as => DateTime).blocks.first.call("  ")
+    assert_equal "1970-09-03T12:05:00+00:00", ROXML::Definition.new(:datevalue, :as => DateTime).blocks.first.call("12:05pm, September 3rd, 1970").to_s
+    assert_equal ["1970-09-03T12:05:00+00:00", "1700-05-22T15:00:00+00:00"], ROXML::Definition.new(:datevalue, :as => DateTime).blocks.first.call(["12:05pm, September 3rd, 1970", "3:00pm, May 22, 1700"]).map(&:to_s)
+  end
+
+  def test_name_explicit_indicates_whether_from_option_is_present
+    assert_equal true, ROXML::Definition.new(:element, :from => 'somewhere').name_explicit?
+    assert_equal false, ROXML::Definition.new(:element).name_explicit?
+  end
+
+  def test_xpath_in_is_formed_properly
+    opts = ROXML::Definition.new(:manufacturer, :in => './')
+    assert_equal "manufacturer", opts.name
+    assert_equal "./", opts.wrapper
+  end
+
+  def test_cdata_is_specifiable
+    assert ROXML::Definition.new(:manufacturer, :cdata => true).cdata?
+  end
+
+  def test_as_supports_generic_roxml_types
+    assert_equal RoxmlObject, ROXML::Definition.new(:type, :as => RoxmlObject).sought_type
+  end
+
+  def test_as_supports_generic_roxml_types_in_arrays
+    assert_equal RoxmlObject, ROXML::Definition.new(:types, :as => [RoxmlObject]).sought_type
+  end
+
+  def test_default_works
+    opts = ROXML::Definition.new(:missing, :else => true)
+    assert_equal true, opts.to_ref(RoxmlObject.new).value_in(ROXML::XML.parse_string('<xml></xml>'))
+  end
+
+  def test_default_works_for_arrays
+    opts = ROXML::Definition.new(:missing, :as => [])
+    assert_equal [], opts.to_ref(RoxmlObject.new).value_in(ROXML::XML.parse_string('<xml></xml>'))
+  end
+
+  def test_default_works_for_recursive_objects
+    opts = ROXML::Definition.new(:missing, :as => RecursiveObject, :else => false)
+    assert_equal false, opts.to_ref(RoxmlObject.new).value_in(ROXML::XML.parse_string('<xml></xml>'))
+  end
+
+  def test_content_is_accepted_as_from
+    assert ROXML::Definition.new(:author, :from => :content).content?
+    assert ROXML::Definition.new(:author, :from => '.').content?
+  end
+
+  def test_content_is_a_recognized_type
+    opts = ROXML::Definition.new(:author, :from => :content)
+    assert opts.content?
+    assert_equal '.', opts.name
+    assert_equal :text, opts.sought_type
+  end
+
+  def test_content_symbol_as_target_is_translated_to_string
+    opts = ROXML::Definition.new(:content, :from => :attr)
+    assert_equal 'content', opts.name
+    assert_equal :attr, opts.sought_type
+  end
+
+  def test_attr_is_accepted_as_from
+    assert_equal :attr, ROXML::Definition.new(:author, :from => :attr).sought_type
+    assert_equal :attr, ROXML::Definition.new(:author, :from => '@author').sought_type
+  end
+
+  def test_attr_is_a_recognized_type
+    opts = ROXML::Definition.new(:author, :from => :attr)
+    assert_equal 'author', opts.name
+    assert_equal :attr, opts.sought_type
+  end
+end
+
+class RecursiveObject
+  include ROXML
+
+  xml_reader :next, :as => RecursiveObject, :else => true
+end
+
+class RoxmlObject
+  include ROXML
+end
+
+class HashDefinitionTest < ActiveSupport::TestCase
+  def test_content_detected_as_from
+    opts = ROXML::Definition.new(:hash, :as => {:key => :content, :value => :name})
+    assert_equal '.', opts.hash.key.name
+    assert_equal :text, opts.hash.key.sought_type
+  end
+end