htmlentitties 4.2.1

data/test/entities_test.rb

@@ -0,0 +1,219 @@
+# encoding: UTF-8
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'htmlentities'
+
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+class HTMLEntities::EntitiesTest < Test::Unit::TestCase
+
+  attr_reader :xhtml1_entities, :html4_entities
+
+  def setup
+    @xhtml1_entities = HTMLEntities.new('xhtml1')
+    @html4_entities = HTMLEntities.new('html4')
+  end
+
+  class PseudoString
+    def initialize(string)
+      @string = string
+    end
+    def to_s
+      @string
+    end
+  end
+
+  def test_should_raise_exception_when_unknown_flavor_specified
+    assert_raises(HTMLEntities::UnknownFlavor) do
+      HTMLEntities.new('foo')
+    end
+  end
+
+  def test_should_allow_symbol_for_flavor
+    assert_nothing_raised do
+      HTMLEntities.new(:xhtml1)
+    end
+  end
+
+  def test_should_allow_upper_case_flavor
+    assert_nothing_raised do
+      HTMLEntities.new('XHTML1')
+    end
+  end
+
+  def test_should_decode_basic_entities
+    assert_decode('&', '&amp;')
+    assert_decode('<', '&lt;')
+    assert_decode('"', '&quot;')
+  end
+
+  def test_should_encode_basic_entities
+    assert_encode('&amp;', '&', :basic)
+    assert_encode('&quot;', '"')
+    assert_encode('&lt;', '<', :basic)
+    assert_encode('&lt;', '<')
+  end
+
+  def test_should_encode_basic_entities_to_decimal
+    assert_encode('&#38;', '&', :decimal)
+    assert_encode('&#34;', '"', :decimal)
+    assert_encode('&#60;', '<', :decimal)
+    assert_encode('&#62;', '>', :decimal)
+    assert_encode('&#39;', "'", :decimal)
+  end
+
+  def test_should_encode_basic_entities_to_hexadecimal
+    assert_encode('&#x26;', '&', :hexadecimal)
+    assert_encode('&#x22;', '"', :hexadecimal)
+    assert_encode('&#x3c;', '<', :hexadecimal)
+    assert_encode('&#x3e;', '>', :hexadecimal)
+    assert_encode('&#x27;', "'", :hexadecimal)
+  end
+
+  def test_should_decode_extended_named_entities
+    assert_decode('±', '&plusmn;')
+    assert_decode('ð', '&eth;')
+    assert_decode('Œ', '&OElig;')
+    assert_decode('œ', '&oelig;')
+  end
+
+  def test_should_encode_extended_named_entities
+    assert_encode('&plusmn;', '±', :named)
+    assert_encode('&eth;', 'ð', :named)
+    assert_encode('&OElig;', 'Œ', :named)
+    assert_encode('&oelig;', 'œ', :named)
+  end
+
+  def test_should_decode_decimal_entities
+    assert_decode('“', '&#8220;')
+    assert_decode('…', '&#8230;')
+    assert_decode(' ', '&#32;')
+  end
+
+  def test_should_encode_decimal_entities
+    assert_encode('&#8220;', '“', :decimal)
+    assert_encode('&#8230;', '…', :decimal)
+  end
+
+  def test_should_decode_hexadecimal_entities
+    assert_decode('−', '&#x2212;')
+    assert_decode('—', '&#x2014;')
+    assert_decode('`', '&#x0060;')
+    assert_decode('`', '&#x60;')
+  end
+
+  def test_should_encode_hexadecimal_entities
+    assert_encode('&#x2212;', '−', :hexadecimal)
+    assert_encode('&#x2014;', '—', :hexadecimal)
+  end
+
+  def test_should_decode_text_with_mix_of_entities
+    # Just a random headline - I needed something with accented letters.
+    assert_decode(
+      'Le tabac pourrait bientôt être banni dans tous les lieux publics en France',
+      'Le tabac pourrait bient&ocirc;t &#234;tre banni dans tous les lieux publics en France'
+    )
+    assert_decode(
+      '"bientôt" & 文字',
+      '&quot;bient&ocirc;t&quot; &amp; &#25991;&#x5b57;'
+    )
+  end
+
+  def test_should_encode_text_using_mix_of_entities
+    assert_encode(
+      '&quot;bient&ocirc;t&quot; &amp; &#x6587;&#x5b57;',
+      '"bientôt" & 文字', :basic, :named, :hexadecimal
+    )
+    assert_encode(
+      '&quot;bient&ocirc;t&quot; &amp; &#25991;&#23383;',
+      '"bientôt" & 文字', :basic, :named, :decimal
+    )
+  end
+
+  def test_should_sort_commands_when_encoding_using_mix_of_entities
+    assert_encode(
+      '&quot;bient&ocirc;t&quot; &amp; &#x6587;&#x5b57;',
+      '"bientôt" & 文字', :named, :hexadecimal, :basic
+    )
+    assert_encode(
+      '&quot;bient&ocirc;t&quot; &amp; &#25991;&#23383;',
+      '"bientôt" & 文字', :decimal, :named, :basic
+    )
+  end
+
+  def test_should_detect_illegal_encoding_command
+    assert_raise(HTMLEntities::InstructionError) {
+      HTMLEntities.encode_entities('foo', :bar, :baz)
+    }
+  end
+
+  def test_should_decode_empty_string
+    assert_decode('', '')
+  end
+
+  def test_should_skip_unknown_entity
+    assert_decode('&bogus;', '&bogus;')
+  end
+
+  def test_should_decode_double_encoded_entity_once
+    assert_decode('&amp;', '&amp;amp;')
+  end
+
+  def test_should_not_encode_normal_ASCII
+    assert_encode('`', '`')
+    assert_encode(' ', ' ')
+  end
+
+  def test_should_double_encode_existing_entity
+    assert_encode('&amp;amp;', '&amp;')
+  end
+
+  # Faults found and patched by Moonwolf
+  def test_should_decode_full_hexadecimal_range
+    (0..127).each do |codepoint|
+      assert_decode([codepoint].pack('U'), "&\#x#{codepoint.to_s(16)};")
+    end
+  end
+
+  # Reported by Dallas DeVries and Johan Duflost
+  def test_should_decode_named_entities_reported_as_missing_in_3_0_1
+    assert_decode([178].pack('U'), '&sup2;')
+    assert_decode([8226].pack('U'), '&bull;')
+    assert_decode([948].pack('U'), '&delta;')
+  end
+
+  if RUBY_VERSION =~ /^1\.8\./
+    # Reported by Benoit Larroque
+    def test_should_encode_without_error_when_KCODE_is_not_UTF_8
+      kcode = $KCODE
+      $KCODE = "n"
+      coder = HTMLEntities.new;
+      text = [8212].pack('U')
+      assert_equal "&#8212;", coder.encode(text, :decimal)
+      $KCODE = kcode
+    end
+  end
+
+  def test_should_ducktype_parameter_to_string_before_encoding
+    pseudo_string = PseudoString.new('foo')
+    assert_decode('foo', pseudo_string)
+  end
+
+  def test_should_ducktype_parameter_to_string_before_decoding
+    pseudo_string = PseudoString.new('foo')
+    assert_encode('foo', pseudo_string)
+  end
+
+  def assert_decode(expected, input)
+    [xhtml1_entities, html4_entities].each do |coder|
+      assert_equal(expected, coder.decode(input))
+    end
+  end
+
+  def assert_encode(expected, input, *args)
+    [xhtml1_entities, html4_entities].each do |coder|
+      assert_equal(expected, coder.encode(input, *args))
+    end
+  end
+
+end

data/test/expanded_test.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'htmlentities'
+
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+class HTMLEntities::ExpandedTest < Test::Unit::TestCase
+
+  attr_reader :html_entities
+
+  def setup
+    @html_entities = HTMLEntities.new(:expanded)
+  end
+
+  TEST_ENTITIES_SET = [
+    ['sub',      0x2282,   "xhtml", nil,      "⊂", ],
+    ['sup',      0x2283,   "xhtml", nil,      "⊃", ],
+    ['nsub',     0x2284,   "xhtml", nil,      "⊄", ],
+    ['subE',     0x2286,   nil,     "skip",   "⊆", ],
+    ['sube',     0x2286,   "xhtml", nil,      "⊆", ],
+    ['supE',     0x2287,   nil,     "skip",   "⊇", ],
+    ['supe',     0x2287,   "xhtml", nil,      "⊇", ],
+    ['bottom',   0x22a5,   nil,     "skip",   "⊥", ],
+    ['perp',     0x22a5,   "xhtml", nil,      "⊥", ],
+    ['models',   0x22a7,   nil,     nil,      "⊧", ],
+    ['vDash',    0x22a8,   nil,     nil,      "⊨", ],
+    ['Vdash',    0x22a9,   nil,     nil,      "⊩", ],
+    ['Vvdash',   0x22aa,   nil,     nil,      "⊪", ],
+    ['nvdash',   0x22ac,   nil,     nil,      "⊬", ],
+    ['nvDash',   0x22ad,   nil,     nil,      "⊭", ],
+    ['nVdash',   0x22ae,   nil,     nil,      "⊮", ],
+    ['nsubE',    0x2288,   nil,     nil,      "⊈", ],
+    ['nsube',    0x2288,   nil,     "skip",   "⊈", ],
+    ['nsupE',    0x2289,   nil,     nil,      "⊉", ],
+    ['nsupe',    0x2289,   nil,     "skip",   "⊉", ],
+    ['subnE',    0x228a,   nil,     nil,      "⊊", ],
+    ['subne',    0x228a,   nil,     "skip",   "⊊", ],
+    ['vsubnE',   0x228a,   nil,     "skip",   "⊊", ],
+    ['vsubne',   0x228a,   nil,     "skip",   "⊊", ],
+    ['nsc',      0x2281,   nil,     nil,      "⊁", ],
+    ['nsup',     0x2285,   nil,     nil,      "⊅", ],
+    ['b.alpha',  0x03b1,   nil,     "skip",   "α", ],
+    ['b.beta',   0x03b2,   nil,     "skip",   "β", ],
+    ['b.chi',    0x03c7,   nil,     "skip",   "χ", ],
+    ['b.Delta',  0x0394,   nil,     "skip",   "Δ", ],
+  ]
+
+  def test_should_encode_apos_entity
+    assert_equal "&apos;", html_entities.encode("'", :named) # note: the normal ' 0x0027, not ʼ 0x02BC
+  end
+
+  def test_should_decode_apos_entity
+    assert_equal "é'", html_entities.decode("&eacute;&apos;")
+  end
+
+  def test_should_decode_dotted_entity
+    assert_equal "Θ", html_entities.decode("&b.Theta;")
+  end
+
+  def test_should_encode_from_test_set
+    TEST_ENTITIES_SET.each do |ent, _, _, skip, decoded|
+      next if skip
+      assert_equal "&#{ent};", html_entities.encode(decoded, :named)
+    end
+  end
+
+  def test_should_decode_from_test_set
+    TEST_ENTITIES_SET.each do |ent, _, _, _, decoded|
+      assert_equal decoded, html_entities.decode("&#{ent};")
+    end
+  end
+
+  def test_should_round_trip_preferred_entities
+    TEST_ENTITIES_SET.each do |ent, _, _, skip, decoded|
+      next if skip
+      assert_equal "&#{ent};", html_entities.encode(html_entities.decode("&#{ent};"), :named)
+      assert_equal decoded,    html_entities.decode(html_entities.encode(decoded, :named))
+    end
+  end
+
+  def test_should_not_round_trip_decoding_skipped_entities
+    TEST_ENTITIES_SET.each do |ent, _, _, skip, decoded|
+      next unless skip
+      assert_not_equal "&#{ent};", html_entities.encode(html_entities.decode("&#{ent};"), :named)
+    end
+  end
+
+  def test_should_round_trip_encoding_skipped_entities
+    TEST_ENTITIES_SET.each do |ent, _, _, skip, decoded|
+      next unless skip
+      assert_equal decoded,        html_entities.decode(html_entities.encode(decoded, :named))
+    end
+  end
+
+  def test_should_treat_all_xhtml1_named_entities_as_xhtml_does
+    xhtml_encoder = HTMLEntities.new(:xhtml1)
+    HTMLEntities::MAPPINGS['xhtml1'].each do |ent, decoded|
+      assert_equal xhtml_encoder.decode("&#{ent};"),      html_entities.decode("&#{ent};")
+      assert_equal xhtml_encoder.encode(decoded, :named), html_entities.encode(decoded, :named)
+    end
+  end
+
+  def test_should_not_agree_with_xhtml1_when_not_in_xhtml
+    xhtml_encoder = HTMLEntities.new(:xhtml1)
+    TEST_ENTITIES_SET.each do |ent, _, xhtml1, skip, decoded|
+      next if xhtml1 || skip
+      assert_not_equal xhtml_encoder.decode("&#{ent};"),         html_entities.decode("&#{ent};")
+      assert_not_equal xhtml_encoder.encode(decoded, :named), html_entities.encode(decoded, :named)
+    end
+  end
+end

data/test/html4_test.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'htmlentities'
+
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+class HTML4Test < Test::Unit::TestCase
+
+  attr_reader :html_entities
+
+  def setup
+    @html_entities = HTMLEntities.new('html4')
+  end
+
+  # Found by Marcos Kuhns
+  def test_should_not_encode_apos_entity
+    assert_equal "'", html_entities.encode("'", :basic)
+  end
+
+  def test_should_not_decode_apos_entity
+    assert_equal "é&apos;", html_entities.decode("&eacute;&apos;")
+  end
+
+  def test_should_not_decode_dotted_entity
+    assert_equal "&b.Theta;", html_entities.decode("&b.Theta;")
+  end
+
+end

data/test/legacy_test.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'htmlentities'
+
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+#
+# Test that version 3.x functionality still works
+#
+class HTMLEntities::LegacyTest < Test::Unit::TestCase
+
+  def test_should_decode_via_legacy_interface
+    assert_decode('&', '&amp;')
+    assert_decode('±', '&plusmn;')
+    assert_decode('“', '&#8220;')
+    assert_decode('—', '&#x2014;')
+  end
+
+  def test_should_encode_via_legacy_interface
+    assert_encode('&amp;', '&', :basic)
+    assert_encode('&eth;', 'ð', :named)
+    assert_encode('&#8230;', '…', :decimal)
+    assert_encode('&#x2212;', '−', :hexadecimal)
+  end
+
+  def assert_encode(expected, *encode_args)
+    assert_equal expected, HTMLEntities.encode_entities(*encode_args)
+  end
+
+  def assert_decode(expected, *decode_args)
+    assert_equal expected, HTMLEntities.decode_entities(*decode_args)
+  end
+
+end

data/test/roundtrip_test.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'htmlentities'
+
+class HTMLEntities::RoundtripTest < Test::Unit::TestCase
+
+  attr_reader :xhtml1_entities, :html4_entities
+
+  def setup
+    @xhtml1_entities = HTMLEntities.new('xhtml1')
+    @html4_entities = HTMLEntities.new('html4')
+  end
+
+  def test_should_roundtrip_xhtml1_entities_via_named_encoding
+    each_mapping('xhtml1') do |name, string|
+      assert_equal(
+        string,
+        xhtml1_entities.decode(xhtml1_entities.encode(string, :named))
+      )
+    end
+  end
+
+  def test_should_roundtrip_xhtml1_entities_via_basic_and_named_encoding
+    each_mapping('xhtml1') do |name, string|
+      assert_equal(
+        string,
+        xhtml1_entities.decode(xhtml1_entities.encode(string, :basic, :named))
+      )
+    end
+  end
+
+  def test_should_roundtrip_xhtml1_entities_via_basic_named_and_decimal_encoding
+    each_mapping('xhtml1') do |name, string|
+      assert_equal(
+        string,
+        xhtml1_entities.decode(xhtml1_entities.encode(string, :basic, :named, :decimal))
+      )
+    end
+  end
+
+  def test_should_roundtrip_xhtml1_entities_via_hexadecimal_encoding
+    each_mapping('xhtml1') do |name, string|
+      assert_equal(
+        string,
+        xhtml1_entities.decode(xhtml1_entities.encode(string, :hexadecimal))
+      )
+    end
+  end
+
+  def test_should_roundtrip_html4_entities_via_named_encoding
+    each_mapping('html4') do |name, string|
+      assert_equal(
+        string,
+        html4_entities.decode(html4_entities.encode(string, :named))
+      )
+    end
+  end
+
+  def test_should_roundtrip_html4_entities_via_basic_and_named_encoding
+    each_mapping('html4') do |name, string|
+      assert_equal(
+        string,
+        html4_entities.decode(html4_entities.encode(string, :basic, :named))
+      )
+    end
+  end
+
+  def test_should_roundtrip_html4_entities_via_basic_named_and_decimal_encoding
+    each_mapping('html4') do |name, string|
+      assert_equal(
+        string,
+        html4_entities.decode(html4_entities.encode(string, :basic, :named, :decimal))
+      )
+    end
+  end
+
+  def test_should_roundtrip_html4_entities_via_hexadecimal_encoding
+    each_mapping('html4') do |name, string|
+      assert_equal(
+        string,
+        html4_entities.decode(html4_entities.encode(string, :hexadecimal))
+      )
+    end
+  end
+
+  def each_mapping(flavor)
+    HTMLEntities::MAPPINGS[flavor].each do |name, codepoint|
+      yield name, [codepoint].pack('U')
+    end
+  end
+
+end