RubyGems - htree - Versions diffs - 0.7.0 - Mend

htree 0.7.0

Files changed (62) hide show

data/test-all.rb ADDED

@@ -0,0 +1,5 @@
+$VERBOSE = true
+Dir.glob('test/test-*.rb') {|filename|
+  load filename
+}

data/test/assign.html ADDED

	@@ -0,0 +1 @@
1	+ <span _text="htree_test_toplevel_local_variable = :modified" />

data/test/template.html ADDED

@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<html>
+  <title _text="self">dummy_title</title>
+</html>

data/test/test-attr.rb ADDED

@@ -0,0 +1,67 @@
+require 'test/unit'
+require 'htree/tag'
+require 'htree/elem'
+require 'htree/traverse'
+class TestAttr < Test::Unit::TestCase
+  def test_each_attribute
+    t = HTree::STag.new('ename', [['p:n', 'a&b']], HTree::DefaultContext.subst_namespaces({'p'=>'u'}))
+    t = HTree::Elem.new!(t)
+    t.each_attribute {|n, v|
+      assert_instance_of(HTree::Name, n)
+      assert_instance_of(HTree::Text, v)
+      assert_equal('{u}n', n.universal_name)
+      assert_equal('a&amp;b', v.rcdata)
+    }
+  end
+  def test_each_attr
+    t = HTree::STag.new('ename', [['p:n', 'a&b']], HTree::DefaultContext.subst_namespaces({'p'=>'u'}))
+    t = HTree::Elem.new!(t)
+    t.each_attr {|n, v|
+      assert_instance_of(String, n)
+      assert_instance_of(String, v)
+      assert_equal('{u}n', n)
+      assert_equal('a&b', v)
+    }
+  end
+  def test_fetch_attribute
+    t = HTree::STag.new('ename', [['p:n', 'a&b']], HTree::DefaultContext.subst_namespaces({'p'=>'u'}))
+    t = HTree::Elem.new!(t)
+    v = t.fetch_attribute('{u}n')
+    assert_instance_of(HTree::Text, v)
+    assert_equal('a&amp;b', v.rcdata)
+    assert_equal('y', t.fetch_attribute('x', 'y'))
+    assert_raises(IndexError) { t.fetch_attribute('x') }
+  end
+  def test_get_attribute
+    t = HTree::STag.new('ename', [['p:n', 'a&b']], HTree::DefaultContext.subst_namespaces({'p'=>'u'}))
+    t = HTree::Elem.new!(t)
+    v = t.get_attribute('{u}n')
+    assert_instance_of(HTree::Text, v)
+    assert_equal('a&amp;b', v.rcdata)
+    assert_equal(nil, t.get_attribute('x'))
+  end
+  def test_get_attr
+    t = HTree::STag.new('ename', [['p:n', 'a&b']], HTree::DefaultContext.subst_namespaces({'p'=>'u'}))
+    t = HTree::Elem.new!(t)
+    v = t.get_attr('{u}n')
+    assert_instance_of(String, v)
+    assert_equal('a&b', v)
+    assert_equal(nil, t.get_attr('x'))
+  end
+  def test_loc_get_attr
+    t = HTree::Elem.new('e', {'k'=>'v'})
+    v = t.make_loc.get_attr('k')
+    assert_instance_of(String, v)
+    assert_equal('v', v)
+    v = t.make_loc.fetch_attr('k')
+    assert_instance_of(String, v)
+    assert_equal('v', v)
+  end
+end

data/test/test-charset.rb ADDED

@@ -0,0 +1,79 @@
+require 'test/unit'
+require 'htree/parse'
+class TestCharset < Test::Unit::TestCase
+  def setup
+    unless "".respond_to? :force_encoding
+      @old_kcode = $KCODE
+    end
+  end
+  def teardown
+    unless "".respond_to? :force_encoding
+      $KCODE = @old_kcode
+    end
+  end
+  def self.mark_string(str, charset)
+    def str.read() self end
+    class << str; self end.__send__(:define_method, :charset) { charset }
+    if str.respond_to? :force_encoding
+      str.force_encoding charset
+    end
+    str
+  end
+  # HIRAGANA LETTER A in various charset
+  UTF8 = mark_string("\343\201\202", 'UTF-8')
+  EUCKR = mark_string("\252\242", 'EUC-KR')
+  EUCJP = mark_string("\244\242", 'EUC-JP')
+  SJIS = mark_string("\202\240", 'Shift_JIS')
+  ISO2022JP = mark_string("\e$B$\"\e(B", 'ISO-2022-JP')
+  def with_kcode(kcode)
+    if "".respond_to? :force_encoding
+      if HTree::Encoder.internal_charset.start_with?(kcode.upcase)
+        yield
+      end
+    else
+      old = $KCODE
+      begin
+        $KCODE = kcode
+        yield
+      ensure
+        $KCODE = old
+      end
+    end
+  end
+  def test_u
+    with_kcode('u') {
+      assert_equal(UTF8, HTree.parse(UTF8).children[0].to_s)
+      assert_equal(UTF8, HTree.parse(EUCKR).children[0].to_s)
+      assert_equal(UTF8, HTree.parse(EUCJP).children[0].to_s)
+      assert_equal(UTF8, HTree.parse(SJIS).children[0].to_s)
+      assert_equal(UTF8, HTree.parse(ISO2022JP).children[0].to_s)
+    }
+  end
+  def test_e
+    with_kcode('e') {
+      assert_equal(EUCJP, HTree.parse(UTF8).children[0].to_s)
+      assert_equal(EUCJP, HTree.parse(EUCKR).children[0].to_s)
+      assert_equal(EUCJP, HTree.parse(EUCJP).children[0].to_s)
+      assert_equal(EUCJP, HTree.parse(SJIS).children[0].to_s)
+      assert_equal(EUCJP, HTree.parse(ISO2022JP).children[0].to_s)
+    }
+  end
+  def test_s
+    with_kcode('s') {
+      assert_equal(SJIS, HTree.parse(UTF8).children[0].to_s)
+      assert_equal(SJIS, HTree.parse(EUCKR).children[0].to_s)
+      assert_equal(SJIS, HTree.parse(EUCJP).children[0].to_s)
+      assert_equal(SJIS, HTree.parse(SJIS).children[0].to_s)
+      assert_equal(SJIS, HTree.parse(ISO2022JP).children[0].to_s)
+    }
+  end
+end

data/test/test-context.rb ADDED

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'htree/context'
+class TestContext < Test::Unit::TestCase
+  def test_namespaces_validation
+    assert_raise(ArgumentError) { HTree::Context.new({1=>'u'}) }
+    assert_raise(ArgumentError) { HTree::Context.new({''=>'u'}) }
+    assert_raise(ArgumentError) { HTree::Context.new({'p'=>nil}) }
+    assert_nothing_raised { HTree::Context.new({nil=>'u'}) }
+  end
+  def test_namespace_uri
+    assert_equal('http://www.w3.org/XML/1998/namespace',
+      HTree::Context.new.namespace_uri('xml'))
+    assert_equal('u', HTree::Context.new({nil=>'u'}).namespace_uri(nil))
+    assert_equal('u', HTree::Context.new({'p'=>'u'}).namespace_uri('p'))
+    assert_equal(nil, HTree::Context.new({'p'=>'u'}).namespace_uri('q'))
+  end
+  def test_subst_namespaces
+    c1 = HTree::Context.new({'p'=>'u'})
+    c2 = c1.subst_namespaces({'q'=>'v'})
+    assert_equal('u', c1.namespace_uri('p'))
+    assert_equal(nil, c1.namespace_uri('q'))
+    assert_equal('u', c2.namespace_uri('p'))
+    assert_equal('v', c2.namespace_uri('q'))
+  end
+end

data/test/test-display_xml.rb ADDED

@@ -0,0 +1,45 @@
+require 'test/unit'
+require 'htree/elem'
+require 'htree/display'
+class TestXMLNS < Test::Unit::TestCase
+  def assert_xml(expected, node)
+    assert_equal(expected, node.display_xml('', 'US-ASCII'))
+  end
+  def test_update_xmlns_empty
+    assert_xml("<n\n/>", HTree::Elem.new('n'))
+  end
+  def test_reduce_xmlns
+    assert_xml(
+      "<p:n xmlns:p=\"u\"\n/>",
+      HTree::Elem.new('p:n', {'xmlns:p'=>'u'}))
+    assert_xml(
+      "<n xmlns:p=\"u\"\n><p:n\n/></n\n>",
+      HTree::Elem.new('n', {'xmlns:p'=>'u'}, HTree::Elem.new('p:n', {'xmlns:p'=>'u'})))
+    assert_xml(
+      "<n xmlns:p=\"u\"\n><p:n xmlns:p=\"v\"\n/></n\n>",
+      HTree::Elem.new('n', {'xmlns:p'=>'u'}, HTree::Elem.new('p:n', {'xmlns:p'=>'v'})))
+  end
+  def test_extra_xmlns
+    assert_xml(
+      "<p:n xmlns:p=\"u\"\n/>",
+      HTree::Elem.new(HTree::Name.new('p', 'u', 'n')))
+    assert_xml(
+      "<nn\n><p:n xmlns:p=\"u\"\n/></nn\n>",
+      HTree::Elem.new('nn', HTree::Elem.new(HTree::Name.new('p', 'u', 'n'))))
+    assert_xml(
+      "<nn xmlns:p=\"u\"\n><p:n\n/></nn\n>",
+      HTree::Elem.new('nn', {'xmlns:p'=>'u'}, HTree::Elem.new(HTree::Name.new('p', 'u', 'n'))))
+    assert_xml(
+      "<nn xmlns:p=\"v\"\n><p:n xmlns:p=\"u\"\n/></nn\n>",
+      HTree::Elem.new('nn', {'xmlns:p'=>'v'}, HTree::Elem.new(HTree::Name.new('p', 'u', 'n'))))
+  end
+end

data/test/test-elem-new.rb ADDED

@@ -0,0 +1,101 @@
+require 'test/unit'
+require 'htree/doc'
+require 'htree/elem'
+require 'htree/equality'
+require 'htree/traverse'
+class TestElemNew < Test::Unit::TestCase
+  def test_empty
+    e = HTree::Elem.new('a')
+    assert_equal('a', e.qualified_name)
+    assert_equal({}, e.attributes)
+    assert_equal(HTree::DefaultContext, e.instance_variable_get(:@stag).inherited_context)
+    assert_equal([], e.children)
+    assert_equal(true, e.empty_element?)
+    assert_nil(e.instance_variable_get(:@etag))
+  end
+  def test_empty_array
+    e = HTree::Elem.new('a', [])
+    assert_equal('a', e.qualified_name)
+    assert_equal({}, e.attributes)
+    assert_equal(HTree::DefaultContext, e.instance_variable_get(:@stag).inherited_context)
+    assert_equal([], e.children)
+    assert_equal(false, e.empty_element?)
+    assert_equal(nil, e.instance_variable_get(:@etag))
+  end
+  def test_empty_attr
+    e = HTree::Elem.new('a', {'href'=>'xxx'})
+    assert_equal('a', e.qualified_name)
+    assert_equal({HTree::Name.parse_attribute_name('href', HTree::DefaultContext)=>HTree::Text.new('xxx')}, e.attributes)
+    assert_equal(HTree::DefaultContext, e.instance_variable_get(:@stag).inherited_context)
+    assert_equal([], e.children)
+    assert_equal(true, e.empty_element?)
+    assert_equal(nil, e.instance_variable_get(:@etag))
+  end
+  def test_node
+    t = HTree::Text.new('t')
+    e = HTree::Elem.new('a', t)
+    assert_equal({}, e.attributes)
+    assert_equal([t], e.children)
+  end
+  def test_hash
+    t = HTree::Text.new('t')
+    e = HTree::Elem.new('a', {'b' => t})
+    assert_equal([['b', t]], e.attributes.map {|n,v| [n.universal_name, v] })
+    assert_equal([], e.children)
+  end
+  def test_string
+    t = HTree::Text.new('s')
+    e = HTree::Elem.new('a', "s")
+    assert_equal({}, e.attributes)
+    assert_equal([t], e.children)
+  end
+  def test_interleave
+    t = HTree::Text.new('t')
+    e = HTree::Elem.new('a', t, {'b' => t}, t, {'c' => 'd'}, t)
+    assert_equal([['b', t], ['c', HTree::Text.new('d')]],
+      e.attributes.map {|n,v| [n.universal_name, v] }.sort)
+    assert_equal([t, t, t], e.children)
+  end
+  def test_nest
+    t = HTree::Text.new('t')
+    b = HTree::BogusETag.new('a')
+    x = HTree::Elem.new('e', HTree::XMLDecl.new('1.0'))
+    d = HTree::Elem.new('e', HTree::DocType.new('html'))
+    e = HTree::Elem.new('a', [t, t, t, b, x, d])
+    assert_equal({}, e.attributes)
+    assert_equal([t, t, t, b, x, d], e.children)
+  end
+  def test_err
+    assert_raises(TypeError) { HTree::Elem.new('e', HTree::STag.new('a')) }
+    assert_raises(TypeError) { HTree::Elem.new('e', HTree::ETag.new('a')) }
+  end
+  def test_context
+    context = HTree::DefaultContext.subst_namespaces({'p'=>'u'})
+    elem = HTree::Elem.new('p:n', {'p:a'=>'t'}, context)
+    assert_equal('{u}n', elem.name)
+    assert_equal('t', elem.get_attr('{u}a'))
+    assert_same(context, elem.instance_variable_get(:@stag).inherited_context)
+    assert_raises(ArgumentError) { HTree::Elem.new('e', context, context) }
+  end
+  def test_hash_in_array
+    attrs = [{'a'=>'1'}, {'a'=>'2'}]
+    assert_raises(TypeError) { HTree::Elem.new('e', attrs) }
+    attrs.pop
+    assert_raises(TypeError) { HTree::Elem.new('e', attrs) }
+    attrs.pop
+    assert_equal([], attrs)
+    assert_equal(false, HTree::Elem.new('e', attrs).empty_element?)
+  end
+end

data/test/test-encoder.rb ADDED

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'htree/encoder'
+class TestEncoder < Test::Unit::TestCase
+  EUC_JISX0212_CH = "\217\260\241" # cannot encode with Shift_JIS.
+  EUC_JISX0208_CH = "\260\241"
+  if EUC_JISX0212_CH.respond_to? :force_encoding
+    EUC_JISX0212_CH.force_encoding("EUC-JP")
+    EUC_JISX0208_CH.force_encoding("EUC-JP")
+  end
+  def test_minimal_charset
+    out = HTree::Encoder.new('Shift_JIS', 'EUC-JP')
+    assert_equal("US-ASCII", out.minimal_charset)
+    out.output_text("a")
+    assert_equal("US-ASCII", out.minimal_charset)
+    out.output_text(EUC_JISX0212_CH)
+    assert_equal("US-ASCII", out.minimal_charset)
+    out.output_text("b")
+    assert_equal("US-ASCII", out.minimal_charset)
+    assert_equal("a&#19970;b", out.finish)
+  end
+  def test_minimal_charset_2
+    out = HTree::Encoder.new('ISO-2022-JP-2', 'EUC-JP')
+    assert_equal("US-ASCII", out.minimal_charset)
+    out.output_text("a")
+    assert_equal("US-ASCII", out.minimal_charset)
+    out.output_text(EUC_JISX0208_CH)
+    assert_equal("ISO-2022-JP", out.minimal_charset)
+    out.output_text("b")
+    assert_equal("ISO-2022-JP", out.minimal_charset)
+    out.output_text(EUC_JISX0212_CH)
+    assert_equal("ISO-2022-JP-2", out.minimal_charset)
+    assert_equal("a\e$B0!\e(Bb\e$(D0!\e(B", out.finish)
+  end
+  def test_minimal_charset_u
+    out = HTree::Encoder.new('UTF-16BE', 'EUC-JP')
+    assert_equal("UTF-16BE", out.minimal_charset)
+    out.output_text("a")
+    assert_equal("UTF-16BE", out.minimal_charset)
+    assert_equal("\000a", out.finish)
+  end
+  def test_close
+    out = HTree::Encoder.new('ISO-2022-JP', 'EUC-JP')
+    out.output_string(EUC_JISX0208_CH)
+    assert_equal("ISO-2022-JP", out.minimal_charset)
+    assert_equal("\e$B0!\e(B", out.finish)
+  end
+end

data/test/test-equality.rb ADDED

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'htree/equality'
+class TestEQQ < Test::Unit::TestCase
+  def assert_exact_equal(expected, actual, message=nil)
+    full_message = build_message(message, <<EOT, expected, actual)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) { expected.exact_equal? actual }
+  end
+  def test_tag_name_prefix
+    tags = [
+      HTree::STag.new('{u}n'),
+      HTree::STag.new('p1{u}n'),
+      HTree::STag.new('p2{u}n'),
+      HTree::STag.new('p1:n', [], HTree::DefaultContext.subst_namespaces({'p1'=>'u'})),
+      HTree::STag.new('p2:n', [], HTree::DefaultContext.subst_namespaces({'p2'=>'u'})),
+    ]
+    tags.each {|t1|
+      tags.each {|t2|
+        assert_equal(t1, t2)
+      }
+    }
+  end
+  def test_tag_attribute_name_prefix
+    tags = [
+      HTree::STag.new('n', [['p1{u}a', 'v']]),
+      HTree::STag.new('n', [['p2{u}a', 'v']]),
+      HTree::STag.new('n', [['p1:a', 'v']], HTree::DefaultContext.subst_namespaces({'p1'=>'u'})),
+      HTree::STag.new('n', [['p2:a', 'v']], HTree::DefaultContext.subst_namespaces({'p2'=>'u'})),
+    ]
+    tags.each {|t1|
+      tags.each {|t2|
+        assert_equal(t1, t2)
+      }
+    }
+  end
+  def test_element
+    assert_equal(HTree::Elem.new('p1{u}n'), HTree::Elem.new('p2{u}n'))
+    assert_equal(HTree::Elem.new('n', {'p1{u}a'=>'v'}),
+                 HTree::Elem.new('n', {'p2{u}a'=>'v'}))
+    assert(!HTree::Elem.new('n', {'p1{u}a'=>'v'}).exact_equal?(HTree::Elem.new('n', {'p2{u}a'=>'v'})))
+  end
+  def test_tag_namespaces
+    assert_nothing_raised {
+      HTree::STag.new("n", [], HTree::DefaultContext.subst_namespaces({nil=>"u1", "p"=>"u2"})).make_exact_equal_object
+    }
+  end
+end