RubyGems - htree - Versions diffs - 0.7.0 - Mend

htree 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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