representable 0.0.1.alpha1 → 0.0.1

data/test/support/fixtures.rb

@@ -1,11 +0,0 @@
-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/unit/definition_test.rb

@@ -1,235 +0,0 @@
-require_relative './../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_equal 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

data/test/unit/deprecations_test.rb

@@ -1,24 +0,0 @@
-require_relative './../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.sought_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

@@ -1,81 +0,0 @@
-require_relative './../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.parse_string(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.roxml_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.roxml_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

@@ -1,39 +0,0 @@
-require_relative './../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

@@ -1,81 +0,0 @@
-require_relative './../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