representable 0.0.1.alpha1 → 0.0.1

data/test/unit/xml_bool_test.rb

@@ -1,122 +0,0 @@
-require_relative './../test_helper'
-
-PROC_TRUE = proc {|val| val ? 'TRUE' : 'FALSE'}
-PROC_True = proc {|val| val ? 'True' : 'False'}
-PROC_true = proc {|val| val.to_s}
-PROC_1    = proc {|val| val ? 1 : 0}
-
-class XmlBool
-  include ROXML
-
-  xml_name 'xml_bool'
-  xml_reader :true_from_TRUE?, :to_xml => PROC_TRUE
-  xml_reader :false_from_FALSE?, :from => 'text_for_FALSE', :to_xml => PROC_TRUE
-  xml_reader :true_from_one?, :from => '@attr_for_one', :to_xml => PROC_1
-  xml_reader :false_from_zero?, :from => 'text_for_zero', :in => 'container', :to_xml => PROC_1
-  xml_reader :true_from_True?, :from => '@attr_for_True', :in => 'container', :to_xml => PROC_True
-  xml_reader :false_from_False?, :from => 'false_from_cdata_False', :cdata => true, :to_xml => PROC_True
-  xml_reader :true_from_true?, :to_xml => PROC_true
-  xml_reader :false_from_false?, :to_xml => PROC_true
-  xml_reader :missing?
-end
-
-class XmlBoolRequired
-  include ROXML
-
-  xml_reader :required?, :required => true
-end
-
-class XmlBoolUnexpected
-  include ROXML
-
-  xml_reader :unexpected?
-end
-
-class XmlBoolUnexpectedWithBlock
-  include ROXML
-
-  xml_reader :unexpected? do |val|
-    val
-  end
-end
-
-BOOL_XML = %{
-  <xml_bool attr_for_one="1">
-    <true_from_TRUE>TRUE</true_from_TRUE>
-    <text_for_FALSE>FALSE</text_for_FALSE>
-    <container attr_for_True="True">
-      <text_for_zero>0</text_for_zero>
-    </container>
-    <false_from_cdata_False><![CDATA[False]]></false_from_cdata_False>
-    <true_from_true>true</true_from_true>
-    <false_from_false>false</false_from_false>
-  </xml_bool>
-}
-PRESENT = %{
-  <xml_bool_required>
-    <required>true</required>
-  </xml_bool_required>
-}
-ABSENT = %{
-  <xml_bool_required>
-  </xml_bool_required>
-}
-UNEXPECTED_VALUE_XML = %{
-  <xml_bool_unexpected>
-    <unexpected>Unexpected Value</unexpected>
-  </xml_bool_unexpected>
-}
-
-
-class TestXMLBool < ActiveSupport::TestCase
-  def test_bool_results_for_various_inputs
-    x = XmlBool.from_xml(BOOL_XML)
-    assert_equal true, x.true_from_TRUE?
-    assert_equal false, x.false_from_FALSE?
-    assert_equal true, x.true_from_one?
-    assert_equal false, x.false_from_zero?
-    assert_equal true, x.true_from_True?
-    assert_equal false, x.false_from_False?
-    assert_equal true, x.true_from_true?
-    assert_equal false, x.false_from_false?
-  end
-
-  def test_missing_results_in_nil
-    x = XmlBool.from_xml(BOOL_XML)
-    assert_equal nil, x.missing?
-  end
-
-  def test_unexpected_value_results_in_nil
-    x = XmlBoolUnexpected.from_xml(UNEXPECTED_VALUE_XML)
-    assert_equal nil, x.unexpected?
-  end
-
-  def test_block_recieves_unexpected_value_rather_than_nil
-    x = XmlBoolUnexpectedWithBlock.from_xml(UNEXPECTED_VALUE_XML)
-    assert_equal "Unexpected Value", x.unexpected?
-  end
-
-  def test_required_raises_on_missing
-    assert_nothing_raised do
-      XmlBoolRequired.from_xml(PRESENT)
-    end
-
-    assert_raise ROXML::RequiredElementMissing do
-      XmlBoolRequired.from_xml(ABSENT)
-    end
-  end
-
-  def test_writable_references_properly_handle_punctuation
-    klass = Class.new do
-      include ROXML
-      xml_accessor :punctuation?
-    end
-
-    instance = klass.from_xml("<xml><punctuation>True</punctuation></xml>")
-    assert_equal true, instance.punctuation?
-    instance.punctuation = false
-    assert_equal false, instance.punctuation?
-  end
-
-  to_xml_test XmlBool => BOOL_XML
-end

data/test/unit/xml_convention_test.rb

@@ -1,150 +0,0 @@
-require_relative './../test_helper'
-
-XML_CAMELLOWER = %{
-  <bookCase name="Jonas' Books">
-    <bookCount>12</bookCount>
-    <bigBooks>
-      <bigBook>GED</bigBook>
-      <bigBook>House of Leaves</bigBook>
-    </bigBooks>
-  </bookCase>
-}
-
-XML_CAMELCASE = %{
-  <BookCase Name="Jonas' Books">
-    <BookCount>12</BookCount>
-    <BigBooks>
-      <BigBook>GED</BigBook>
-      <BigBook>House of Leaves</BigBook>
-    </BigBooks>
-  </BookCase>
-}
-
-XML_UNDERSCORE = %{
-  <book_case name="Jonas' Books">
-    <book_count>12</book_count>
-    <big_books>
-      <big_book>GED</big_book>
-      <big_book>House of Leaves</big_book>
-    </big_books>
-  </book_case>
-}
-
-XML_DASHES = %{
-  <book-case name="Jonas' Books">
-    <book-count>12</book-count>
-    <big-books>
-      <big-book>GED</big-book>
-      <big-book>House of Leaves</big-book>
-    </big-books>
-  </book-case>
-}
-
-XML_UPCASE = %{
-  <BOOKCASE NAME="Jonas' Books">
-    <BOOKCOUNT>12</BOOKCOUNT>
-    <BIGBOOKS>
-      <BIGBOOK>GED</BIGBOOK>
-      <BIGBOOK>House of Leaves</BIGBOOK>
-    </BIGBOOKS>
-  </BOOKCASE>
-}
-
-class BookCase
-  include ROXML
-
-  xml_reader :book_count, :as => Integer, :required => true
-  xml_reader :big_books, :as => [], :required => true
-end
-
-class BookCaseCamelCase < BookCase
-  xml_convention :camelcase
-end
-
-class BookCaseUnderScore < BookCase
-  xml_convention :underscore
-end
-
-class BookCaseDashes < BookCase
-  xml_convention &:dasherize
-end
-
-class BookCaseCamelLower < BookCase
-  xml_convention {|val| val.camelcase(:lower) }
-end
-
-class BookCaseUpCase < BookCase
-  xml_convention {|val| val.gsub('_', '').upcase }
-end
-
-class InheritedBookCaseCamelCase < BookCaseCamelCase
-end
-
-class InheritedBookCaseUpCase < BookCaseUpCase
-end
-
-# Same as BookCase.  Needed to keep BookCase clean for other tests
-class ParentBookCaseDefault
-  include ROXML
-
-  xml_reader :book_count, :as => Integer, :required => true
-  xml_reader :big_books, :as => [], :required => true
-end
-
-class InheritedBookCaseDefault < ParentBookCaseDefault
-end
-
-class TestXMLConvention < ActiveSupport::TestCase
-  # TODO: Test convention applies to xml_name as well...
-
-  def test_default_convention_is_underscore
-    bc = BookCase.from_xml(XML_UNDERSCORE)
-    assert_has_book_case_info(bc)
-  end
-
-  [BookCaseUpCase, BookCaseCamelLower, BookCaseDashes, BookCaseUnderScore, BookCaseCamelCase].each do |klass|
-    define_method(:"test_xml_convention_#{klass.to_s.underscore}") do
-      data = :"XML_#{klass.to_s.sub('BookCase', '').upcase}"
-      assert_equal Proc, klass.roxml_naming_convention.class
-
-      bc = klass.from_xml(Object.const_get(data))
-      assert_has_book_case_info(bc)
-    end
-  end
-
-  def test_child_should_inherit_convention_if_it_doesnt_declare_one
-    [InheritedBookCaseUpCase, InheritedBookCaseCamelCase].each do |klass|
-      data = :"XML_#{klass.to_s.sub('InheritedBookCase', '').upcase}"
-      assert_equal Proc, klass.roxml_naming_convention.class
-
-      bc = klass.from_xml(Object.const_get(data))
-      assert_has_book_case_info(bc)
-    end
-  end
-
-  def test_child_should_inherit_convention_even_if_it_is_added_after_child_declaration
-    bc = InheritedBookCaseDefault.from_xml(XML_UNDERSCORE)
-    assert_has_book_case_info(bc)
-
-    ParentBookCaseDefault.class_eval do
-      xml_convention :dasherize
-    end
-
-    bc = InheritedBookCaseDefault.from_xml(XML_DASHES)
-    assert_has_book_case_info(bc)
-    assert_raise ROXML::RequiredElementMissing do
-      InheritedBookCaseDefault.from_xml(XML_UNDERSCORE)
-    end
-  end
-
-  def test_tag_name_should_get_convention_treatment_as_well
-    assert_equal "book-case-dashes", BookCaseDashes.tag_name
-    assert_equal "INHERITEDBOOKCASEUPCASE", InheritedBookCaseUpCase.tag_name
-    assert_equal "InheritedBookCaseCamelCase", InheritedBookCaseCamelCase.tag_name
-  end
-
-  def assert_has_book_case_info(bc)
-    assert_equal 12, bc.book_count
-    assert_equal ['GED', 'House of Leaves'], bc.big_books
-  end
-end

data/test/unit/xml_hash_test.rb

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

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

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