htmlentities 4.2.4 → 4.3.0

data/History.txt

@@ -1,3 +1,16 @@
+== 4.3.0 (2011-03-29)
+* Use Ruby 1.9's encoding support where available.
+* Deprecated HTMLEntities.encode_entities/decode_entities interface is now
+  removed.
+
+== 4.2.4 (2011-01-30)
+* Fix issue where double-escaped entities were not correctly escaped. Bug
+  reported by Christian Kruse.
+
+== 4.2.3 (2011-01-07)
+* Additional entities from Junya Ishihara.
+* Performance improvements.
+
 == 4.2.1 (2010-04-05)
 * Fixed error on Ruby 1.8.x when $KCODE was not set to "UTF8". Thanks to
   Benoit Larroque for the bug report.

data/lib/htmlentities.rb

@@ -1,5 +1,4 @@
 # encoding: UTF-8
-require 'htmlentities/legacy'
 require 'htmlentities/flavors'
 require 'htmlentities/encoder'
 require 'htmlentities/decoder'
@@ -61,9 +60,9 @@ class HTMLEntities
   # If no instructions are specified, :basic will be used.
   #
   # Examples:
-  #   encode_entities(str) - XML-safe
-  #   encode_entities(str, :basic, :decimal) - XML-safe and 7-bit clean
-  #   encode_entities(str, :basic, :named, :decimal) - 7-bit clean, with all
+  #   encode(str) - XML-safe
+  #   encode(str, :basic, :decimal) - XML-safe and 7-bit clean
+  #   encode(str, :basic, :named, :decimal) - 7-bit clean, with all
   #   non-ASCII characters replaced with their named entity where possible, and
   #   decimal equivalents otherwise.
   #

data/lib/htmlentities/decoder.rb

@@ -7,7 +7,7 @@ class HTMLEntities
     end
 
     def decode(source)
-      source.to_s.gsub(@entity_regexp) {
+      prepare(source).gsub(@entity_regexp) {
         if $1 && codepoint = @map[$1]
           [codepoint].pack('U')
         elsif $2
@@ -21,6 +21,16 @@ class HTMLEntities
     end
 
   private
+    if "1.9".respond_to?(:encoding)
+      def prepare(string) #:nodoc:
+        string.to_s.encode(Encoding::UTF_8)
+      end
+    else
+      def prepare(string) #:nodoc:
+        string.to_s
+      end
+    end
+
     def entity_regexp
       key_lengths = @map.keys.map{ |k| k.length }
       entity_name_pattern =

data/lib/htmlentities/encoder.rb

@@ -13,13 +13,23 @@ class HTMLEntities
     end
 
     def encode(source)
-      string = source.to_s.dup
-      string.gsub!(basic_entity_regexp){ encode_basic($&) }
-      string.gsub!(extended_entity_regexp){ encode_extended($&) }
-      string
+      prepare(source).
+        gsub(basic_entity_regexp){ encode_basic($&) }.
+        gsub(extended_entity_regexp){ encode_extended($&) }
     end
 
   private
+
+    if "1.9".respond_to?(:encoding)
+      def prepare(string) #:nodoc:
+        string.to_s.encode(Encoding::UTF_8)
+      end
+    else
+      def prepare(string) #:nodoc:
+        string.to_s
+      end
+    end
+
     def basic_entity_regexp
       @basic_entity_regexp ||= (
         case @flavor
@@ -33,15 +43,15 @@ class HTMLEntities
 
     def extended_entity_regexp
       @extended_entity_regexp ||= (
-        regexp_options = [nil]
+        options = [nil]
         if encoding_aware?
-          regexp = '[^\u{20}-\u{7E}]'
+          pattern = '[^\u{20}-\u{7E}]'
         else
-          regexp = '[^\x20-\x7E]'
-          regexp_options << "U"
+          pattern = '[^\x20-\x7E]'
+          options << "U"
         end
-        regexp += "|'" if @flavor == 'html4'
-        Regexp.new(regexp, *regexp_options)
+        pattern << "|'" if @flavor == 'html4'
+        Regexp.new(pattern, *options)
       )
     end
 

data/lib/htmlentities/version.rb

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

data/test/common.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'htmlentities'
+
+ENCODING_AWARE_RUBY = "1.9".respond_to?(:encoding)
+$KCODE = 'u' unless ENCODING_AWARE_RUBY

data/test/decoding_test.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+require File.expand_path("../common", __FILE__)
+
+class HTMLEntities::DecodingTest < Test::Unit::TestCase
+
+  def setup
+    @entities = [:xhtml1, :html4, :expanded].map{ |a| HTMLEntities.new(a) }
+  end
+
+  def assert_decode(expected, input)
+    @entities.each do |coder|
+      assert_equal expected, coder.decode(input)
+    end
+  end
+
+  def test_should_decode_basic_entities
+    assert_decode '&', '&amp;'
+    assert_decode '<', '&lt;'
+    assert_decode '"', '&quot;'
+  end
+
+  def test_should_decode_extended_named_entities
+    assert_decode '±', '&plusmn;'
+    assert_decode 'ð', '&eth;'
+    assert_decode 'Œ', '&OElig;'
+    assert_decode 'œ', '&oelig;'
+  end
+
+  def test_should_decode_decimal_entities
+    assert_decode '“', '&#8220;'
+    assert_decode '…', '&#8230;'
+    assert_decode ' ', '&#32;'
+  end
+
+  def test_should_decode_hexadecimal_entities
+    assert_decode '−', '&#x2212;'
+    assert_decode '—', '&#x2014;'
+    assert_decode '`', '&#x0060;'
+    assert_decode '`', '&#x60;'
+  end
+
+  def test_should_not_mutate_string_being_decoded
+    original = "&lt;&#163;"
+    input = original.dup
+    HTMLEntities.new.decode(input)
+
+    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_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
+
+  # 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
+
+  # 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 File.expand_path("../common", __FILE__)
+
+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

@@ -1,30 +1,10 @@
 # encoding: UTF-8
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'htmlentities'
-
-$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+require File.expand_path("../common", __FILE__)
 
 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
+    assert_raises HTMLEntities::UnknownFlavor do
       HTMLEntities.new('foo')
     end
   end
@@ -41,186 +21,4 @@ class HTMLEntities::EntitiesTest < Test::Unit::TestCase
     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
-
-  # 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
-    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

@@ -1,9 +1,5 @@
 # encoding: UTF-8
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'htmlentities'
-
-$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+require File.expand_path("../common", __FILE__)
 
 class HTMLEntities::ExpandedTest < Test::Unit::TestCase
 
@@ -109,4 +105,5 @@ class HTMLEntities::ExpandedTest < Test::Unit::TestCase
       assert_not_equal xhtml_encoder.encode(decoded, :named), html_entities.encode(decoded, :named)
     end
   end
+
 end

data/test/html4_test.rb

@@ -1,9 +1,5 @@
 # encoding: UTF-8
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'htmlentities'
-
-$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+require File.expand_path("../common", __FILE__)
 
 class HTML4Test < Test::Unit::TestCase
 

data/test/roundtrip_test.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'htmlentities'
+require File.expand_path("../common", __FILE__)
 
 class HTMLEntities::RoundtripTest < Test::Unit::TestCase
 
@@ -13,74 +11,50 @@ class HTMLEntities::RoundtripTest < Test::Unit::TestCase
   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))
-      )
+    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))
-      )
+    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))
-      )
+    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))
-      )
+    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))
-      )
+    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))
-      )
+    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))
-      )
+    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))
-      )
+    each_mapping 'html4' do |name, string|
+      assert_equal string, html4_entities.decode(html4_entities.encode(string, :hexadecimal))
     end
   end
 

data/test/ruby_1_8_test.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+require File.expand_path("../common", __FILE__)
+
+unless ENCODING_AWARE_RUBY
+  class HTMLEntities::Ruby18Test < Test::Unit::TestCase
+
+    # 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
+end

data/test/ruby_1_9_test.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+require File.expand_path("../common", __FILE__)
+
+if ENCODING_AWARE_RUBY
+  class HTMLEntities::Ruby19Test < Test::Unit::TestCase
+
+    def test_should_encode_ascii_to_ascii
+      s = "<elan>".encode(Encoding::US_ASCII)
+      assert_equal Encoding::US_ASCII, s.encoding
+
+      t = HTMLEntities.new.encode(s)
+      assert_equal "&lt;elan&gt;", t
+      assert_equal Encoding::US_ASCII, t.encoding
+    end
+
+    def test_should_encode_utf8_to_utf8_if_needed
+      s = "<élan>"
+      assert_equal Encoding::UTF_8, s.encoding
+
+      t = HTMLEntities.new.encode(s)
+      assert_equal "&lt;élan&gt;", t
+      assert_equal Encoding::UTF_8, t.encoding
+    end
+
+    def test_should_encode_utf8_to_ascii_if_possible
+      s = "<elan>"
+      assert_equal Encoding::UTF_8, s.encoding
+
+      t = HTMLEntities.new.encode(s)
+      assert_equal "&lt;elan&gt;", t
+      assert_equal Encoding::US_ASCII, t.encoding
+    end
+
+    def test_should_encode_other_encoding_to_utf8
+      s = "<élan>".encode(Encoding::ISO_8859_1)
+      assert_equal Encoding::ISO_8859_1, s.encoding
+
+      t = HTMLEntities.new.encode(s)
+      assert_equal "&lt;élan&gt;", t
+      assert_equal Encoding::UTF_8, t.encoding
+    end
+
+    def test_should_decode_ascii_to_utf8
+      s = "&lt;&eacute;lan&gt;".encode(Encoding::US_ASCII)
+      assert_equal Encoding::US_ASCII, s.encoding
+
+      t = HTMLEntities.new.decode(s)
+      assert_equal "<élan>", t
+      assert_equal Encoding::UTF_8, t.encoding
+    end
+
+    def test_should_decode_utf8_to_utf8
+      s = "&lt;&eacute;lan&gt;".encode(Encoding::UTF_8)
+      assert_equal Encoding::UTF_8, s.encoding
+
+      t = HTMLEntities.new.decode(s)
+      assert_equal "<élan>", t
+      assert_equal Encoding::UTF_8, t.encoding
+    end
+
+    def test_should_decode_other_encoding_to_utf8
+      s = "&lt;&eacute;lan&gt;".encode(Encoding::ISO_8859_1)
+      assert_equal Encoding::ISO_8859_1, s.encoding
+
+      t = HTMLEntities.new.decode(s)
+      assert_equal "<élan>", t
+      assert_equal Encoding::UTF_8, t.encoding
+    end
+  end
+end

data/test/xhtml1_test.rb

@@ -1,9 +1,5 @@
 # encoding: UTF-8
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'htmlentities'
-
-$KCODE = 'u' unless "1.9".respond_to?(:encoding)
+require File.expand_path("../common", __FILE__)
 
 class HTMLEntities::XHTML1Test < Test::Unit::TestCase
 
@@ -25,5 +21,4 @@ class HTMLEntities::XHTML1Test < Test::Unit::TestCase
     assert_equal "&b.Theta;", html_entities.decode("&b.Theta;")
   end
 
-
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: htmlentities
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 51
   prerelease: false
   segments: 
   - 4
-  - 2
-  - 4
-  version: 4.2.4
+  - 3
+  - 0
+  version: 4.3.0
 platform: ruby
 authors: 
 - Paul Battley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-30 00:00:00 +00:00
+date: 2011-03-29 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -26,30 +26,30 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.rdoc
 - History.txt
 - COPYING.txt
 files: 
-- lib/htmlentities/version.rb
+- lib/htmlentities.rb
 - lib/htmlentities/flavors.rb
+- lib/htmlentities/version.rb
 - lib/htmlentities/encoder.rb
-- lib/htmlentities/legacy.rb
-- lib/htmlentities/mappings/html4.rb
 - lib/htmlentities/mappings/expanded.rb
 - lib/htmlentities/mappings/xhtml1.rb
+- lib/htmlentities/mappings/html4.rb
 - lib/htmlentities/decoder.rb
-- lib/htmlentities.rb
-- test/entities_test.rb
+- test/decoding_test.rb
+- test/ruby_1_8_test.rb
 - test/xhtml1_test.rb
-- test/roundtrip_test.rb
-- test/legacy_test.rb
-- test/expanded_test.rb
-- test/test_all.rb
 - test/html4_test.rb
+- test/encoding_test.rb
+- test/expanded_test.rb
+- test/ruby_1_9_test.rb
+- test/common.rb
+- test/roundtrip_test.rb
+- test/entities_test.rb
+- perf/performance.rb
 - perf/profile.rb
 - perf/benchmark.rb
-- perf/performance.rb
-- README.rdoc
 - History.txt
 - COPYING.txt
 has_rdoc: true
@@ -87,4 +87,12 @@ signing_key:
 specification_version: 3
 summary: A module for encoding and decoding (X)HTML entities.
 test_files: 
-- test/test_all.rb
+- test/decoding_test.rb
+- test/ruby_1_8_test.rb
+- test/xhtml1_test.rb
+- test/html4_test.rb
+- test/encoding_test.rb
+- test/expanded_test.rb
+- test/ruby_1_9_test.rb
+- test/roundtrip_test.rb
+- test/entities_test.rb

data/README.rdoc

@@ -1,44 +0,0 @@
-== HTMLEntities
-
-HTML entity encoding and decoding for Ruby
-
-The HTMLEntities module facilitates encoding and decoding of
-(X)HTML entities from/to their corresponding UTF-8 codepoints.
-
-To install (requires root/admin privileges):
-
- ruby setup.rb
-
-Alternatively, you can just use the gem.
-
-== Licence
-
-This code is free to use under the terms of the MIT licence:
-
-  Copyright (c) 2005-2009 Paul Battley
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to
-  deal in the Software without restriction, including without limitation the
-  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-  sell copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-  IN THE SOFTWARE.
-
-If you'd like to negotiate a different licence for a specific use, just
-contact me -- I'll almost certainly permit it.
-
-== Contact
-
-Comments are welcome. Send an email to pbattley@gmail.com.
-

data/lib/htmlentities/legacy.rb

@@ -1,31 +0,0 @@
-class HTMLEntities
-  class << self
-
-    #
-    # Legacy compatibility class method allowing direct encoding of XHTML1 entities.
-    # See HTMLEntities#encode for description of parameters.
-    #
-    # Deprecated.
-    #
-    def encode_entities(*args)
-      xhtml1_entities.encode(*args)
-    end
-
-    #
-    # Legacy compatibility class method allowing direct decoding of XHTML1 entities.
-    # See HTMLEntities#decode for description of parameters.
-    #
-    # Deprecated.
-    #
-    def decode_entities(*args)
-      xhtml1_entities.decode(*args)
-    end
-
-  private
-
-    def xhtml1_entities
-      @xhtml1_entities ||= new('xhtml1')
-    end
-
-  end
-end

data/test/legacy_test.rb

@@ -1,35 +0,0 @@
-# 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/test_all.rb

@@ -1,4 +0,0 @@
-# encoding: UTF-8
-Dir[File.dirname(__FILE__)+'/*_test.rb'].each do |test|
-  require "./#{test}"
-end