representable 0.0.1.alpha1

data/test/roxml_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class RoxmlTest < MiniTest::Spec
+  class Band
+    include Representable
+    xml_accessor :name
+  end
+    
+  describe "#representable_attrs" do
+    
+    class PunkBand < Band
+      xml_accessor :street_cred
+    end
+    
+    it "responds to #representable_attrs" do
+      assert_equal 1, Band.representable_attrs.size
+      assert_equal "name", Band.representable_attrs.first.name
+    end
+    
+    it "inherits correctly" do
+      assert_equal 2, PunkBand.representable_attrs.size
+      assert_equal "name", PunkBand.representable_attrs.first.name
+      assert_equal "street_cred", PunkBand.representable_attrs.last.name
+    end
+  end
+  
+  describe "#representation_name" do
+    class SoundSystem
+      include Representable
+    end
+    
+    class HardcoreBand
+      include Representable
+    end
+  
+    class SoftcoreBand < HardcoreBand
+    end
+    
+    it "provides the root 'tag' name" do
+      assert_equal "sound_system", SoundSystem.representation_name
+    end
+    
+    it "inherits correctly" do
+      HardcoreBand.representation_name = "breach"
+      assert_equal "breach", HardcoreBand.representation_name
+      assert_equal "breach", SoftcoreBand.representation_name
+    end
+  end
+  
+  
+  describe "#definition_class" do
+    it "returns Definition class" do
+      assert_equal Representable::Definition, Band.definition_class
+    end
+    
+  end
+  
+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,6 @@
+require 'bundler'
+Bundler.setup
+
+require 'representable'
+require 'test/unit'
+require 'minitest/spec'

data/test/unit/definition_test.rb

@@ -0,0 +1,235 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,39 @@
+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