ROXML 3.0.0

data/test/support/fixtures.rb

@@ -0,0 +1,11 @@
+def fixture(name)
+  File.read(fixture_path(name))
+end
+
+def xml_fixture(name)
+  ROXML::XML::Parser.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::Parser.parse(xml).root if xml.is_a?(String)
+  return unless xml.respond_to? :children
+  xml.children.each do |child|
+    if child.to_s.blank?
+      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.type => opts.hash.key.name,
+                       opts.hash.value.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.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.type
+  end
+
+  def test_block_shorthand_in_array_means_array
+    opts = ROXML::Definition.new(:intarray, :as => [Integer])
+    assert opts.array?
+    assert_equal :text, opts.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.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.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).type
+  end
+
+  def test_as_supports_generic_roxml_types_in_arrays
+    assert_equal RoxmlObject, ROXML::Definition.new(:types, :as => [RoxmlObject]).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::Parser.parse('<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::Parser.parse('<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::Parser.parse('<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.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.type
+  end
+
+  def test_attr_is_accepted_as_from
+    assert_equal :attr, ROXML::Definition.new(:author, :from => :attr).type
+    assert_equal :attr, ROXML::Definition.new(:author, :from => '@author').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.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.type
+  end
+end

data/test/unit/deprecations_test.rb

@@ -0,0 +1,24 @@
+require 'test/test_helper'
+
+class TestDeprecation < ActiveSupport::TestCase
+  def test_as_array_not_deprecated
+    assert_not_deprecated do
+      opts = ROXML::Definition.new(:name, :as => [])
+      assert_equal :text, opts.type
+      assert opts.array?
+    end
+  end
+
+  def test_as_hash_not_deprecated
+    assert_not_deprecated do
+      opts = ROXML::Definition.new(:name, :as => {:key => '@dt', :value => '@dd'})
+      assert opts.hash?
+    end
+  end
+
+  def test_as_object_with_from_xml_not_deprecated
+    assert_not_deprecated do
+      ROXML::Definition.new(:name, :as => OctalInteger)
+    end
+  end
+end

data/test/unit/to_xml_test.rb

@@ -0,0 +1,81 @@
+require 'test/test_helper'
+
+class TestHashToXml < ActiveSupport::TestCase
+  to_xml_test :dictionary_of_attrs,
+              :dictionary_of_mixeds,
+              :dictionary_of_texts,
+              :dictionary_of_names,
+              :dictionary_of_guarded_names,
+              :dictionary_of_name_clashes,
+              :dictionary_of_attr_name_clashes
+end
+
+class TestOtherToXml < ActiveSupport::TestCase
+  to_xml_test :book => :book_valid,
+              :book_with_author_text_attribute => :book_text_with_attribute,
+              :uppercase_library => :library_uppercase
+
+  to_xml_test :book_with_authors,
+              :book_with_contributors,
+              :book_with_contributions,
+              :library,
+              :node_with_name_conflicts,
+              :node_with_attr_name_conflicts
+
+  to_xml_test :person_with_mother => :person_with_mothers,
+              :person_with_guarded_mother => :person_with_guarded_mothers
+
+  to_xml_test :book_with_wrapped_attr
+end
+
+class TestToXmlWithDefaults < ActiveSupport::TestCase
+  def test_content_and_attr_defaults_are_represented_in_output
+    dict = Person.from_xml(fixture(:nameless_ageless_youth))
+
+    xml = '<person age="21">Unknown</person>'
+    assert_equal ROXML::XML::Parser.parse(xml).root.to_s, dict.to_xml.to_s
+  end
+end
+
+class TestToXmlWithBlocks < ActiveSupport::TestCase
+  def test_pagecount_serialized_properly_after_modification
+    b = Book.from_xml(fixture(:book_valid))
+    xml = xml_fixture(:book_valid)
+    assert_equal '357', xml.search('pagecount').first.content
+    assert_equal 357, b.pages
+
+    b.pages = 500
+    doc = ROXML::XML::Document.new()
+    doc.root = b.to_xml
+    assert_equal '500', doc.search('pagecount').first.content
+  end
+end
+
+class OctalInteger
+  def self.from_xml(val)
+    new(Integer(val.content))
+  end
+
+  def initialize(value)
+    @val = value
+  end
+
+  def ==(other)
+    @val == other
+  end
+
+  def to_xml
+    sprintf("%#o", @val)
+  end
+end
+
+class BookWithOctalPages
+  include ROXML
+
+  xml_accessor :pages_with_to_xml_proc, :as => Integer, :to_xml => proc {|val| sprintf("%#o", val) }, :required => true
+  xml_accessor :pages_with_type, :as => OctalInteger, :required => true
+end
+
+class TestToXmlWithOverriddenOutput < ActiveSupport::TestCase
+  to_xml_test :book_with_octal_pages
+end

data/test/unit/xml_attribute_test.rb

@@ -0,0 +1,39 @@
+require 'test/test_helper'
+
+class TestXMLAttribute < ActiveSupport::TestCase
+  def test_attr_from
+    # :attr => *
+    book = Book.from_xml(fixture(:book_text_with_attribute))
+    assert_equal '0201710897', book.isbn
+
+    # :attr, :from => *
+    book = BookWithAttrFrom.from_xml(fixture(:book_text_with_attribute))
+    assert_equal '0201710897', book.isbn
+  end
+
+  def test_mutable_attr
+    book = Book.from_xml(fixture(:book_text_with_attribute))
+    assert book.respond_to?(:'isbn=')
+  end
+
+  def test_default_initialization
+    person = PersonWithMotherOrMissing.from_xml(fixture(:nameless_ageless_youth))
+    assert_equal 21, person.age
+  end
+
+  def test_recursive_with_default_initialization
+    p = PersonWithMotherOrMissing.from_xml(fixture(:person_with_mothers))
+    assert_equal 21, p.mother.mother.mother.age
+  end
+
+  def test_no_name_clashes
+    n = NodeWithAttrNameConflicts.from_xml(fixture(:node_with_attr_name_conflicts))
+    assert_equal "Just junk... really", n.content
+    assert_equal "Cartwheel", n.name
+  end
+
+  def test_wrapped_attr_accessible
+    b = BookWithWrappedAttr.from_xml(fixture(:book_with_wrapped_attr))
+    assert_equal "0974514055", b.isbn
+  end
+end

data/test/unit/xml_block_test.rb

@@ -0,0 +1,81 @@
+require 'test/test_helper'
+
+class ArrayWithBlockShorthand
+  include ROXML
+
+  xml_reader :array, :as => [Integer], :from => 'number'
+end
+
+class ArrayWithBlock
+  include ROXML
+
+  xml_reader :array, :as => [], :from => 'number' do |arr|
+    arr.map(&:to_i).reverse
+  end
+end
+
+class TestXMLBlocks < ActiveSupport::TestCase
+  def test_block_is_applied
+    muffins = Muffins.from_xml(fixture(:muffins))
+
+    assert muffins.count > 0
+    assert_equal 0, muffins.count % 13
+  end
+
+  def test_block_is_applied_to_hash
+    numerology = Numerology.from_xml(fixture(:numerology))
+
+    assert !numerology.predictions.keys.empty?
+    assert numerology.predictions.keys.all? {|k| k.is_a? Integer }
+    assert numerology.predictions.values.all? {|k| k.is_a? String }
+  end
+
+  def test_stacked_blocks_are_applied
+    muffins = MuffinsWithStackedBlocks.from_xml(fixture(:muffins))
+
+    assert muffins.count > 0
+    assert_equal 0, muffins.count % 13
+  end
+
+  def test_block_shorthand_applied_properly_to_array
+    obj = ArrayWithBlockShorthand.from_xml(%{
+      <array_with_block_shorthand>
+        <number>1</number>
+        <number>2</number>
+        <number>3</number>
+      </array_with_block_shorthand>
+    })
+
+    assert_equal [1, 2, 3], obj.array
+  end
+
+  def test_block_applied_properly_to_array
+    obj = ArrayWithBlock.from_xml(%{
+      <array_with_block>
+        <number>1</number>
+        <number>2</number>
+        <number>3</number>
+      </array_with_block>
+    })
+
+    assert_equal [3, 2, 1], obj.array
+  end
+
+  def test_block_shorthand_applied_properly_to_empty_array
+    obj = ArrayWithBlockShorthand.from_xml(%{
+      <array_with_block_shorthand>
+      </array_with_block_shorthand>
+    })
+
+    assert_equal [], obj.array
+  end
+
+  def test_block_applied_properly_to_empty_array
+    obj = ArrayWithBlock.from_xml(%{
+      <array_with_block>
+      </array_with_block>
+    })
+
+    assert_equal [], obj.array
+  end
+end