mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/fileshell.rb

@@ -0,0 +1,202 @@
+warn 'please use folio (gem install folio) for future versions'
+
+# = File Shell
+#
+# Comprehensive file system access tool. FileShell acts as a "virtual"
+# shell prompt.
+#
+#   c = VirtualShell.new
+#   c.ls  #=> ['ipso.txt']
+#
+# == NOTES
+#
+# * This is still expiremental library and is still undergoing rivision.
+#
+# Authors:: Trans
+# Copying:: (c) 2007 Thomas Sawyer
+# License:: Ruby License
+
+require 'fileutils'
+
+# = File Shell
+#
+# Comprehensive file system access tool. FileShell acts as a "virtual"
+# shell prompt.
+#
+#   c = VirtualShell.new
+#   c.ls  #=> ['ipso.txt']
+#
+class FileShell
+
+  attr_reader :root
+
+  def initialize(*root_and_options)
+    @options = Hash === root_and_options ? root_and_options.pop : {}
+    @root    = root_and_options.first || "/"
+
+    @dryrun = options[:dryrun]
+    @quiet  = options[:quiet]
+    #@force  = options[:force]
+  end
+
+  def dryrun? ; @dryrun ; end
+  def quiet?  ; @quiet  ; end
+  def verbose?  ; !@quiet  ; end
+  #def force?  ; @force  ; end
+
+  # Direct access to a directory or a file.
+  def [](name)
+    if File.directory?(name)
+      Dir.new(name)
+    elsif File.file?(name)
+      File.new(name)
+    else
+      nil
+    end
+  end
+
+  # Is a directory root?
+  def root?(dir=nil)
+    pth = File.expand_path(dir||work)
+    return true if pth == '/'
+    return true if pth =~ /^(\w:)?\/$/
+    false
+  end
+
+  # Present working directory.
+  def pwd; super; end
+
+  # Directory listing
+  def ls(dir, options=nil)
+    Dir.entries.collect do |f|
+      File.directory?(f) ? Dir.new(f) : File.new(f)
+    end
+  end
+
+  # Change directory.
+  #
+  # cd(dir, options)
+  # cd(dir, options) {|dir| .... }
+  def cd(dir, options=nil, &yld)
+    fu(options).cd(dir, &yld)
+  end
+  alias chdir cd
+
+  # mkdir(dir, options)
+  # mkdir(list, options)
+  def mkdir(dir, options=nil)
+    fu(options).mkdir(dir)
+  end
+
+  # mkdir_p(dir, options)
+  # mkdir_p(list, options)
+  def mkdir_p(dir, options=nil)
+    fu(options).mkdir_p(dir)
+  end
+
+  # rmdir(dir, options)
+  # rmdir(list, options)
+  def rmdir(dir, options=nil)
+    fu(options).rmdir(dir)
+  end
+
+  # ln(old, new, options)
+  # ln(list, destdir, options)
+  def ln(old, new, options=nil)
+    fu(options).ln(old, new)
+  end
+
+  # ln_s(old, new, options)
+  # ln_s(list, destdir, options)
+  def ln_s(old, new, options=nil)
+    fu(options).ln_s(old, new)
+  end
+
+  # ln_sf(src, dest, options)
+  def ln_sf(src, dest, options=nil)
+    fu(options).ln_sf(src, dest)
+  end
+
+  # cp(src, dest, options)
+  # cp(list, dir, options)
+  def cp(src, dest, options=nil)
+    fu(options).cp(src, dest)
+  end
+
+  # cp_r(src, dest, options)
+  # cp_r(list, dir, options)
+  def cp_r(src, dest, options=nil)
+    fu(options).cp_r(src, dest)
+  end
+
+  # mv(src, dest, options)
+  # mv(list, dir, options)
+  def mv(src, dest, options=nil)
+    fu(options).mv(src, dest)
+  end
+  alias move mv
+
+  # rm(list, options)
+  def rm(list, options=nil)
+    fu(options).rm(list)
+  end
+
+  # rm_r(list, options)
+  def rm_r(list, options=nil)
+    fu(options).rm_r(list)
+  end
+
+  # rm_rf(list, options)
+  def rm_rf(list, options=nil)
+    fu(options).rm_rf(list)
+  end
+
+  # install(src, dest, mode = <src's>, options)
+  def install(src, dest, mode=src, options=nil)
+    fu(options).install(src, dest, mode)
+  end
+
+  # chmod(mode, list, options)
+  def chmod(mode, list, options=nil)
+    fu(options).chmod(mode, list)
+  end
+
+  # chmod_R(mode, list, options)
+  def chmod_R(mode, list, options=nil)
+    fu(options).chmod_R(mode, list)
+  end
+
+  # chown(user, group, list, options)
+  def chown(user, group, list, options=nil)
+    fu(options).chown(user, group, list)
+  end
+
+  # chown_R(user, group, list, options)
+  def chown_R(user, group, list, options=nil)
+    fu(options).chown_R(user, group, list)
+  end
+
+  # touch(list, options)
+  def touch(list, options=nil)
+    fu(options).touch(list)
+  end
+
+ private
+
+  #
+  def fu(opts)
+    nowrite = opts[:nowrite] || opts[:dryrun] || opts[:noop]   || dryrun?
+    verbose = opts[:verbose] || opts[:dryrun] || !opts[:quiet] || verbose?
+
+    if nowrite and verbose
+      FileUtils::Dryrun
+    elsif nowrite
+      FileUtils::NoWrite
+    elsif verbose
+      FileUtils::Verbose
+    else
+      FileUtils
+    end
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/more/facets/hash/stringify_keys.rb

@@ -0,0 +1 @@
+require 'facets/hash/symbolize_keys'

data/lib/gems/facets-2.4.5/lib/more/facets/hash/symbolize_keys.rb

@@ -0,0 +1,94 @@
+require 'facets/hash/rekey'
+
+class Hash
+
+  # Converts all keys in the Hash to Symbols, returning a new Hash.
+  # With a +filter+, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.symbolize_keys    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #   foo.inspect           #=>  { "name" =>"Gavin", "wife"=>:Lisa }
+  #
+  # This method is considered archaic. Use #rekey instead.
+
+  def symbolize_keys(&filter)
+    if filter
+      rekey{ |k| filter[k] ? k.to_sym : nil }
+    else
+      rekey{ |k| k.to_sym }
+    end
+  end
+
+  #alias_method( :keys_to_sym, :symbolize_keys )
+
+  #--
+  # # Rails has these aliases too, but they are not very good for
+  # # gerenal use, IMHO. But perhaps someone can convince me otherwise.
+  # alias_method( :to_options,  :symbolize_keys )
+  #++
+
+  # Synonym for Hash#symbolize_keys, but modifies the receiver in place and returns it.
+  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { 'name'=>'Gavin', 'wife'=>:Lisa }
+  #   foo.symbolize_keys!    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #   foo.inspect            #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #
+  # This method is considered archaic. Use #rekey instead.
+
+  def symbolize_keys!(&filter)
+    if filter
+      rekey!{ |k| filter[k] ? k.to_sym : nil }
+    else
+      rekey!{ |k| k.to_sym }
+    end
+
+  end
+
+  #alias_method( :keys_to_sym!, :symbolize_keys! )
+
+  # Converts all keys in the Hash to Strings, returning a new Hash.
+  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.stringify_keys    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect           #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #
+  # This method is considered archaic. Use #rekey instead.
+
+  def stringify_keys(&filter)
+    if filter
+      rekey{ |k| filter[k] ? k.to_s : nil }
+    else
+      rekey{ |k| k.to_s }
+    end
+  end
+
+  #alias_method(:keys_to_s, :stringify_keys)
+
+  # Synonym for Hash#stringify_keys, but modifies the receiver in place and returns it.
+  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.stringify_keys!    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect            #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  # This method is considered archaic. Use #rekey instead.
+
+  def stringify_keys!(&filter)
+    if filter
+      rekey!{ |k| filter[k] ? k.to_s : nil }
+    else
+      rekey!{ |k| k.to_s }
+    end
+  end
+
+  #alias_method( :keys_to_s!, :stringify_keys!)
+
+  #--
+  # # Rails has these aliases too.
+  # alias_method( :to_options!, :symbolize_keys! )
+  #++
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/heap.rb

@@ -0,0 +1,22 @@
+# = Heap
+#
+# Another name for PQueue.
+#
+# == Copying
+#
+# Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'facets/pqueue'
+
+# Heap is PQueue.
+Heap = PQueue
+

data/lib/gems/facets-2.4.5/lib/more/facets/htmlfilter.rb

@@ -0,0 +1,595 @@
+# = HTML Filter
+#
+# HTML Filter library can be used to sanitize and sterilize
+# HTML. A good idea if you let users submit HTML in comments,
+# for instance.
+#
+# HtmlFilter is a port of lib_filter.php, v1.15 by Cal Henderson <cal@iamcal.com>
+#
+# This code is licensed under a Creative Commons Attribution-ShareAlike 2.5 License
+# http://creativecommons.org/licenses/by-sa/2.5/
+#
+# Thanks to Jang Kim for adding support for single quoted attributes.
+#
+# == Reference
+#
+# * http://iamcal.com/publish/articles/php/processing_html/
+# * http://iamcal.com/publish/articles/php/processing_html_part_2/
+#
+# == Author(s)
+#
+# * TransNoumena
+# * George Moschovitis
+# * James Britt
+# * Cal Henderson
+# * Jang Kim
+#
+# == Authors
+#
+# * Trans
+#
+# == Copying
+#
+# Copyright (c) 2007 7rans
+
+require 'facets/multiton'
+
+# = HtmlFilter
+#
+# HTML Filter library can be used to sanitize and sterilize
+# HTML. A good idea if you let users submit HTML in comments,
+# for instance.
+#
+# lib_filter.php, v1.15 by Cal Henderson <cal@iamcal.com>
+#
+# This code is licensed under a Creative Commons Attribution-ShareAlike 2.5 License
+# http://creativecommons.org/licenses/by-sa/2.5/
+#
+# Thanks to Jang Kim for adding support for single quoted attributes.
+#
+# == Reference
+#
+# * http://iamcal.com/publish/articles/php/processing_html/
+# * http://iamcal.com/publish/articles/php/processing_html_part_2/
+
+class HtmlFilter
+
+  include Multiton
+
+  # tags and attributes that are allowed
+  #
+  # Eg.
+  #
+  #   {
+  #     'a' => ['href', 'target'],
+  #     'b' => [],
+  #     'img' => ['src', 'width', 'height', 'alt']
+  #   }
+  attr_accessor :allowed
+
+  # tags which should always be self-closing (e.g. "<img />")
+  attr_accessor :no_close
+
+  # tags which must always have seperate opening and closing
+  # tags (e.g. "<b></b>")
+  attr_accessor :always_close
+
+  # attributes which should be checked for valid protocols
+  # (src,href)
+  attr_accessor :protocol_attributes
+
+  # protocols which are allowed (http, ftp, mailto)
+  attr_accessor :allowed_protocols
+
+  # tags which should be removed if they contain no content
+  # (e.g. "<b></b>" or "<b />")
+  attr_accessor :remove_blanks
+
+  # should we remove comments? (true, false)
+  attr_accessor :strip_comments
+
+  # should we try and make a b tag out of "b>" (true, false)
+  attr_accessor :always_make_tags
+
+  # entity control option (true, false)
+  attr_accessor :allow_numbered_entities
+
+  # entity control option (amp, gt, lt, quot, etc.)
+  attr_accessor :allowed_entities
+
+  # default settings
+
+  DEFAULT = {
+    'allowed' => {
+      'a'   => ['href', 'target'],
+      'b'   => [],
+      'i'   => [],
+      'img' => ['src', 'width', 'height', 'alt']
+    },
+    'no_close' => ['img', 'br', 'hr'],
+    'always_close' => ['a', 'b'],
+    'protocol_attributes' => ['src', 'href'],
+    'allowed_protocols' => ['http', 'ftp', 'mailto'],
+    'remove_blanks' => ['a', 'b'],
+    'strip_comments' => true,
+    'always_make_tags' => true,
+    'allow_numbered_entities' => true,
+    'allowed_entities' => ['amp', 'gt', 'lt', 'quot']
+  }
+
+  # New html filter.
+
+  def initialize( options=nil )
+    if options
+      h = DEFAULT.dup
+      options.each do |k,v|
+        h[k.to_s] = v
+      end
+      options = h
+    else
+      options = DEFAULT.dup
+    end
+
+    options.each{ |k,v| send("#{k}=",v) }
+  end
+
+  # Filter html string.
+
+  def filter(data)
+    @tag_counts = {}
+
+    data = escape_comments(data)
+    data = balance_html(data)
+    data = check_tags(data)
+    data = process_remove_blanks(data)
+    data = validate_entities(data)
+
+    return data
+  end
+
+  private
+
+  #
+  # internal tag counter
+  #
+
+  attr_reader :tag_counts
+
+  #
+  #
+  #
+
+  def escape_comments(data)
+    data = data.gsub(/<!--(.*?)-->/s) do
+      '<!--' + escape_special_chars(strip_single($1)) + '-->'
+    end
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def balance_html(data)
+    data = data.dup
+
+    if always_make_tags
+      # try and form html
+      data.gsub!(/>>+/, '>')
+      data.gsub!(/<<+/, '<')
+      data.gsub!(/^>/, '')
+      data.gsub!(/<([^>]*?)(?=<|$)/, '<\1>')
+      data.gsub!(/(^|>)([^<]*?)(?=>)/, '\1<\2')
+    else
+      # escape stray brackets
+      data.gsub!(/<([^>]*?)(?=<|$)/, '&lt;\1')
+      data.gsub!(/(^|>)([^<]*?)(?=>)/, '\1\2&gt;<')
+      # the last regexp causes '<>' entities to appear
+      # (we need to do a lookahead assertion so that the last bracket
+      # can be used in the next pass of the regexp)
+      data.gsub!('<>', '')
+    end
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def check_tags(data)
+    data = data.dup
+
+    data.gsub!(/<(.*?)>/s){
+      process_tag(strip_single($1))
+    }
+
+    tag_counts.each do |tag, cnt|
+        cnt.times{ data << "</#{tag}>" }
+    end
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def process_tag(data)
+
+    # ending tags
+
+    re = /^\/([a-z0-9]+)/si
+
+    if matches = re.match(data)
+        name = matches[1].downcase
+        if allowed.key?(name)
+            unless no_close.include?(name)
+                if tag_counts[name]
+                    tag_counts[name] -= 1
+                    return "</#{name}>"
+                end
+            end
+        else
+            return ''
+        end
+    end
+
+    # starting tags
+
+    re = /^([a-z0-9]+)(.*?)(\/?)$/si
+
+    if matches = re.match(data)
+        name   = matches[1].downcase
+        body   = matches[2]
+        ending = matches[3]
+
+        if allowed.key?(name)
+            params = ""
+
+            matches_2 = body.scan(/([a-z0-9]+)=(["'])(.*?)\2/si)         # <foo a="b" />
+            matches_1 = body.scan(/([a-z0-9]+)(=)([^"\s']+)/si)          # <foo a=b />
+            matches_3 = body.scan(/([a-z0-9]+)=(["'])([^"']*?)\s*$/si)   # <foo a="b />
+
+            matches = matches_1 + matches_2 + matches_3
+
+            matches.each do |match|
+                pname = match[0].downcase
+                if allowed[name].include?(pname)
+                    value = match[2]
+                    if protocol_attributes.include?(pname)
+                        value = process_param_protocol(value)
+                    end
+                    params += %{ #{pname}="#{value}"}
+                end
+            end
+            if no_close.include?(name)
+                ending = ' /'
+            end
+            if always_close.include?(name)
+                ending = ''
+            end
+            if ending.empty?
+                if tag_counts.key?(name)
+                    tag_counts[name] += 1
+                else
+                    tag_counts[name] = 1
+                end
+            end
+            unless ending.empty?
+                ending = ' /'
+            end
+            return '<' + name + params + ending + '>'
+        else
+            return ''
+        end
+    end
+
+    # comments
+    if /^!--(.*)--$/si =~ data
+        if strip_comments
+            return ''
+        else
+            return '<' + data + '>'
+        end
+    end
+
+    # garbage, ignore it
+    return ''
+  end
+
+  #
+  #
+  #
+
+  def process_param_protocol(data)
+    data = decode_entities(data)
+
+    re = /^([^:]+)\:/si
+
+    if matches = re.match(data)
+        unless allowed_protocols.include?(matches[1])
+            #data = '#'.substr(data, strlen(matches[1])+1)
+            data = '#' + data[0..matches[1].size+1]
+        end
+    end
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def process_remove_blanks(data)
+    data = data.dup
+
+    remove_blanks.each do |tag|
+        data.gsub!(/<#{tag}(\s[^>]*)?><\/#{tag}>/, '')
+        data.gsub!(/<#{tag}(\s[^>]*)?\/>/, '')
+    end
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def fix_case(data)
+    data_notags = strip_tags(data)
+    data_notags = data_notags.gsub(/[^a-zA-Z]/, '')
+
+    if data_notags.size < 5
+        return data
+    end
+
+    if /[a-z]/ =~ data_notags
+        return data
+    end
+
+    data = data.gsub(/(>|^)([^<]+?)(<|$)/s){
+        strip_single($1) +
+        fix_case_inner(strip_single($2)) +
+        strip_single($3)
+    }
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def fix_case_inner(data)
+    data = data.dup
+
+    data.downcase!
+
+    data.gsub!(/(^|[^\w\s\';,\\-])(\s*)([a-z])/){
+        strip_single("#{$1}#{$2}") + strip_single($3).upcase
+    }
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def validate_entities(data)
+    data = data.dup
+
+    # validate entities throughout the string
+    data.gsub!(%r!&([^&;]*)(?=(;|&|$))!){
+        check_entity(strip_single($1), strip_single($2))
+    }
+
+    # validate quotes outside of tags
+    data.gsub!(/(>|^)([^<]+?)(<|$)/s){
+        m1, m2, m3 = $1, $2, $3
+        strip_single(m1) +
+        strip_single(m2).gsub('\"', '&quot;') +
+        strip_single(m3)
+    }
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def check_entity(preamble, term)
+    if term != ';'
+        return '&amp;' + preamble
+    end
+
+    if is_valid_entity(preamble)
+        return '&' + preamble
+    end
+
+    return '&amp;' + preamble
+  end
+
+  #
+  #
+  #
+
+  def is_valid_entity(entity)
+    re = /^#([0-9]+)$/i
+
+    if md = re.match(entity)
+        if (md[1].to_i > 127)
+            return true
+        end
+        return allow_numbered_entities
+    end
+
+    if allowed_entities.include?(entity)
+        return true
+    end
+
+    return nil
+  end
+
+  # within attributes, we want to convert all hex/dec/url
+  # escape sequences into their raw characters so that we can
+  # check we don't get stray quotes/brackets inside strings.
+
+  def decode_entities(data)
+    data = data.dup
+
+    data.gsub!(/(&)#(\d+);?/){ decode_dec_entity($1, $2) }
+    data.gsub!(/(&)#x([0-9a-f]+);?/i){ decode_hex_entity($1, $2) }
+    data.gsub!(/(%)([0-9a-f]{2});?/i){ decode_hex_entity($1, $2) }
+
+    data = validate_entities(data)
+
+    return data
+  end
+
+  #
+  #
+  #
+
+  def decode_hex_entity(*m)
+    return decode_num_entity(m[1], m[2].to_i.to_s(16))
+  end
+
+  #
+  #
+  #
+
+  def decode_dec_entity(*m)
+    return decode_num_entity(m[1], m[2])
+  end
+
+  #
+  #
+  #
+
+  def decode_num_entity(orig_type, d)
+    d = d.to_i
+    d = 32 if d < 0   # space
+
+    # don't mess with high chars
+    if d > 127
+        return '%' + d.to_s(16) if orig_type == '%'
+        return "&#{d};" if orig_type == '&'
+    end
+
+    return escape_special_chars(d.chr)
+  end
+
+  #
+  #
+  #
+
+  def strip_single(data)
+    return data.gsub('\"', '"').gsub('\0', 0.chr)
+  end
+
+  # Certain characters have special significance in HTML, and
+  # should be represented by HTML entities if they are to
+  # preserve their meanings. This function returns a string
+  # with some of these conversions made; the translations made
+  # are those most useful for everyday web programming.
+
+  def escape_special_chars(data)
+    data = data.dup
+    data.gsub! /&/n  , '&amp;'
+    data.gsub! /\"/n , '&quot;'
+    data.gsub! />/n  , '&gt;'
+    data.gsub! /</n  , '&lt;'
+    data.gsub! /'/   , '&#039;'
+    return data
+  end
+
+end
+
+# Overload the standard String class for extra convienience.
+
+class String
+  def html_filter(*opts)
+    HtmlFilter.new(*opts).filter(self)
+  end
+end
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  class TestHtmlFilter < Test::Unit::TestCase
+
+    # core tests
+
+    def test_multiton_without_options
+      h1 = HtmlFilter.new
+      h2 = HtmlFilter.new
+      h3 = HtmlFilter.new( :strip_comments => false )
+      assert_equal( h1.object_id, h2.object_id )
+      assert_not_equal( h1.object_id, h3.object_id )
+    end
+
+    def test_multiton_with_options
+      h1 = HtmlFilter.new( :strip_comments => false )
+      h2 = HtmlFilter.new( :strip_comments => false )
+      h3 = HtmlFilter.new
+      assert_equal( h1.object_id, h2.object_id )
+      assert_not_equal( h1.object_id, h3.object_id )
+    end
+
+    def test_strip_single
+      hf = HtmlFilter.new
+      assert_equal( '"', hf.send(:strip_single,'\"') )
+      assert_equal( "\000", hf.send(:strip_single,'\0') )
+    end
+
+    # functional tests
+
+    def assert_filter(filtered, original)
+      assert_equal(filtered, original.html_filter)
+    end
+
+    def test_fix_quotes
+      assert_filter '<img src="foo.jpg" />', "<img src=\"foo.jpg />"
+    end
+
+    def test_basics
+      assert_filter '', ''
+      assert_filter 'hello', 'hello'
+    end
+
+    def test_balancing_tags
+      assert_filter "<b>hello</b>", "<<b>hello</b>"
+      assert_filter "<b>hello</b>", "<b>>hello</b>"
+      assert_filter "<b>hello</b>", "<b>hello<</b>"
+      assert_filter "<b>hello</b>", "<b>hello</b>>"
+      assert_filter "", "<>"
+    end
+
+    def test_tag_completion
+      assert_filter "hello", "hello<b>"
+      assert_filter "<b>hello</b>", "<b>hello"
+      assert_filter "hello<b>world</b>", "hello<b>world"
+      assert_filter "hello", "hello</b>"
+      assert_filter "hello", "hello<b/>"
+      assert_filter "hello<b>world</b>", "hello<b/>world"
+      assert_filter "<b><b><b>hello</b></b></b>", "<b><b><b>hello"
+      assert_filter "", "</b><b>"
+    end
+
+    def test_end_slashes
+      assert_filter '<img />', '<img>'
+      assert_filter '<img />', '<img/>'
+      assert_filter '', '<b/></b>'
+    end
+
+  end
+
+=end
+