jerska-htmlentities 4.3.3

data/lib/htmlentities/version.rb

@@ -0,0 +1,9 @@
+class HTMLEntities
+  module VERSION #:nodoc:
+    MAJOR = 4
+    MINOR = 3
+    TINY  = 3
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/perf/benchmark.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+require File.expand_path("../performance", __FILE__)
+require "benchmark"
+
+job = HTMLEntitiesJob.new
+job.all(100) # Warm up to give JRuby a fair shake.
+
+Benchmark.benchmark do |b|
+  b.report("Encoding"){ job.encode(100) }
+  b.report("Decoding"){ job.decode(100) }
+end

data/perf/performance.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "htmlentities"
+
+class HTMLEntitiesJob
+  def initialize
+    @coder = HTMLEntities.new
+    @decoded = File.read(File.join(File.dirname(__FILE__), "sample"))
+    @encoded = @coder.encode(@decoded, :basic, :named, :hexadecimal)
+  end
+
+  def encode(cycles)
+    cycles.times do
+      @coder.encode(@decoded, :basic, :named, :hexadecimal)
+      @coder.encode(@decoded, :basic, :named, :decimal)
+    end
+  end
+
+  def decode(cycles)
+    cycles.times do
+      @coder.decode(@encoded)
+    end
+  end
+
+  def all(cycles)
+    encode(cycles)
+    decode(cycles)
+  end
+end

data/perf/profile.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+
+require File.expand_path("../performance", __FILE__)
+require "profiler"
+
+job = HTMLEntitiesJob.new
+
+puts "Encoding"
+Profiler__::start_profile
+job.encode(1)
+Profiler__::print_profile($stdout)
+
+puts "Decoding"
+Profiler__::start_profile
+job.decode(1)
+Profiler__::print_profile($stdout)

data/test/decoding_test.rb

@@ -0,0 +1,164 @@
+# encoding: UTF-8
+require_relative "./test_helper"
+
+class HTMLEntities::DecodingTest < Test::Unit::TestCase
+
+  def setup
+    @entities = [:xhtml1, :html4, :expanded].map{ |a| HTMLEntities.new(a) }
+  end
+
+  def assert_decode(expected, input, options = {})
+    @entities.each do |coder|
+      assert_equal expected, coder.decode(input, options)
+    end
+  end
+
+  def test_should_decode_basic_entities
+    assert_decode '&', '&amp;'
+    assert_decode '<', '&lt;'
+    assert_decode '"', '&quot;'
+  end
+
+  def test_should_not_decode_excluded_basic_entities
+    assert_decode '&amp;', '&amp;', exclude: ['&']
+    assert_decode '&lt;', '&lt;', exclude: ['<']
+    assert_decode '&quot;', '&quot;', exclude: ['"']
+  end
+
+  def test_should_decode_extended_named_entities
+    assert_decode '±', '&plusmn;'
+    assert_decode 'ð', '&eth;'
+    assert_decode 'Œ', '&OElig;'
+    assert_decode 'œ', '&oelig;'
+  end
+
+  def test_should_not_decode_excluded_extended_named_entities
+    assert_decode '&plusmn;', '&plusmn;', exclude: ['±']
+    assert_decode '&eth;', '&eth;', exclude: ['ð']
+    assert_decode '&OElig;', '&OElig;', exclude: ['Œ']
+    assert_decode '&oelig;', '&oelig;', exclude: ['œ']
+  end
+
+  def test_should_decode_decimal_entities
+    assert_decode '“', '&#8220;'
+    assert_decode '…', '&#8230;'
+    assert_decode ' ', '&#32;'
+  end
+
+  def test_should_not_decode_excluded_decimal_entities
+    assert_decode '&#8220;', '&#8220;', exclude: ['“']
+    assert_decode '&#8230;', '&#8230;', exclude: ['…']
+    assert_decode '&#32;', '&#32;', exclude: [' ']
+  end
+
+  def test_should_decode_hexadecimal_entities
+    assert_decode '−', '&#x2212;'
+    assert_decode '—', '&#x2014;'
+    assert_decode '`', '&#x0060;'
+    assert_decode '`', '&#x60;'
+  end
+
+  def test_should_not_decode_excluded_hexadecimal_entities
+    assert_decode '&#x2212;', '&#x2212;', exclude: ['−']
+    assert_decode '&#x2014;', '&#x2014;', exclude: ['—']
+    assert_decode '&#x0060;', '&#x0060;', exclude: ['`']
+    assert_decode '&#x60;', '&#x60;', exclude: ['`']
+  end
+
+  def test_should_not_mutate_string_being_decoded
+    original = "&lt;&#163;"
+    input = original.dup
+
+    HTMLEntities.new.decode(input)
+    assert_equal original, input
+
+    HTMLEntities.new.decode(input, excluded: ['a'])
+    assert_equal original, input
+  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_decode_text_with_mix_of_entities_only_not_excluded
+    # Just a random headline - I needed something with accented letters.
+    assert_decode(
+      'Le tabac pourrait bient&ocirc;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',
+      exclude: ['ô']
+    )
+    assert_decode(
+      '"bientôt" & &#25991;字',
+      '&quot;bient&ocirc;t&quot; &amp; &#25991;&#x5b57;',
+      exclude: ['文']
+    )
+    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',
+      exclude: ['文']
+    )
+  end
+
+  def test_should_decode_empty_string
+    assert_decode '', ''
+    assert_decode '', '', exclude: ['a']
+  end
+
+  def test_should_skip_unknown_entity
+    assert_decode '&bogus;', '&bogus;'
+    assert_decode '&bogus;', '&bogus;', exclude: ['a']
+  end
+
+  def test_should_decode_double_encoded_entity_once
+    assert_decode '&amp;', '&amp;amp;'
+    assert_decode '&amp;', '&amp;amp;', exclude: ['a']
+  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
+
+  def test_should_not_decode_full_hexadecimal_range_if_excluded
+    (0..127).each do |codepoint|
+      assert_decode "&\#x#{codepoint.to_s(16)};", "&\#x#{codepoint.to_s(16)};", exclude: [[codepoint].pack('U')]
+    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
+
+  def test_should_not_decode_named_entities_reported_as_missing_in_3_0_1_if_excluded
+    assert_decode '&sup2;', '&sup2;', exclude: [[178].pack('U')]
+    assert_decode '&bull;', '&bull;', exclude: [[8226].pack('U')]
+    assert_decode '&delta;', '&delta;', exclude: [[948].pack('U')]
+  end
+
+  # Reported by ckruse
+  def test_should_decode_only_first_element_in_masked_entities
+    input = '&amp;#3346;'
+    expected = '&#3346;'
+    assert_decode expected, input
+  end
+
+  def test_should_ducktype_parameter_to_string_before_encoding
+    obj = Object.new
+    def obj.to_s; "foo"; end
+    assert_decode "foo", obj
+  end
+
+end

data/test/encoding_test.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+require_relative "./test_helper"
+
+class HTMLEntities::EncodingTest < Test::Unit::TestCase
+
+  def setup
+    @entities = [:xhtml1, :html4, :expanded].map{ |a| HTMLEntities.new(a) }
+  end
+
+  def assert_encode(expected, input, *args)
+    @entities.each do |coder|
+      assert_equal expected, coder.encode(input, *args)
+    end
+  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_encode_extended_named_entities
+    assert_encode '&plusmn;', '±', :named
+    assert_encode '&eth;',    'ð', :named
+    assert_encode '&OElig;',  'Œ', :named
+    assert_encode '&oelig;',  'œ', :named
+  end
+
+  def test_should_encode_decimal_entities
+    assert_encode '&#8220;', '“', :decimal
+    assert_encode '&#8230;', '…', :decimal
+  end
+
+  def test_should_encode_hexadecimal_entities
+    assert_encode '&#x2212;', '−', :hexadecimal
+    assert_encode '&#x2014;', '—', :hexadecimal
+  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 do
+      HTMLEntities.new.encode('foo', :bar, :baz)
+    end
+  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
+
+  def test_should_not_mutate_string_being_encoded
+    original = "<£"
+    input = original.dup
+    HTMLEntities.new.encode(input, :basic, :decimal)
+
+    assert_equal original, input
+  end
+
+  def test_should_ducktype_parameter_to_string_before_encoding
+    obj = Object.new
+    def obj.to_s; "foo"; end
+    assert_encode "foo", obj
+  end
+end

data/test/entities_test.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+require_relative "./test_helper"
+
+class HTMLEntities::EntitiesTest < Test::Unit::TestCase
+
+  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
+
+end

data/test/expanded_test.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+require_relative "./test_helper"
+
+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