rubypants-unicode 0.2.0

data/README.md

@@ -0,0 +1,119 @@
+# RubyPants Unicode — SmartyPants ported to Ruby
+
+Switched to unicode output (UTF-8) instead of HTML entities by Chris Chapman
+  Copyright © 2012 Chris Chapman
+
+Ported by Christian Neukirchen <mailto:chneukirchen@gmail.com>
+  Copyright © 2004 Christian Neukirchen
+
+Incooporates ideas, comments and documentation by Chad Miller
+  Copyright © 2004 Chad Miller
+
+Original SmartyPants by John Gruber
+  Copyright © 2003 John Gruber
+
+
+## RubyPants
+
+RubyPants is a Ruby port of the smart-quotes library SmartyPants.
+
+The original “SmartyPants” is a free web publishing plug-in for
+Movable Type, Blosxom, and BBEdit that easily translates plain ASCII
+punctuation characters into “smart” typographic punctuation HTML
+entities.
+
+See rubypants.rb for more information.
+
+
+## Incompatibilities
+
+RubyPants uses a different API than SmartyPants; it is compatible to
+Red- and BlueCloth.  Usually, you call RubyPants like this:
+
+```ruby
+  nicehtml = RubyPants.new(uglyhtml, options).to_html
+```
+
+where +options+ is an Array of Integers and/or Symbols (if you don’t
+pass any options, RubyPants will use <tt>[2]</tt> as default.)
+
+*Note*:: This is incompatible to SmartyPants, which uses <tt>[1]</tt>
+         for default.
+
+The exact meaning of numbers and symbols is documented at RubyPants#new.
+
+
+## SmartyPants license:
+
+Copyright © 2003 John Gruber
+(http://daringfireball.net)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+* Neither the name “SmartyPants” nor the names of its contributors
+  may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+This software is provided by the copyright holders and contributors
+“as is” and any express or implied warranties, including, but not
+limited to, the implied warranties of merchantability and fitness
+for a particular purpose are disclaimed. In no event shall the
+copyright owner or contributors be liable for any direct, indirect,
+incidental, special, exemplary, or consequential damages (including,
+but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however
+caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence or otherwise) arising in
+any way out of the use of this software, even if advised of the
+possibility of such damage.
+
+
+## RubyPants license
+
+Copyright © 2004 Christian Neukirchen
+
+RubyPants is a derivative work of SmartyPants and smartypants.py.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+This software is provided by the copyright holders and contributors
+“as is” and any express or implied warranties, including, but not
+limited to, the implied warranties of merchantability and fitness
+for a particular purpose are disclaimed. In no event shall the
+copyright owner or contributors be liable for any direct, indirect,
+incidental, special, exemplary, or consequential damages (including,
+but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however
+caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence or otherwise) arising in
+any way out of the use of this software, even if advised of the
+possibility of such damage.
+
+
+## Links
+
+- John Gruber:: http://daringfireball.net
+- SmartyPants:: http://daringfireball.net/projects/smartypants
+- Chad Miller:: http://web.chad.org
+- Christian Neukirchen:: http://kronavita.de/chris

data/Rakefile

@@ -0,0 +1,56 @@
+# Rakefile for rubypants  -*-ruby-*-
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+
+desc "Run all the tests"
+task :default => [:test]
+
+desc "Do predistribution stuff"
+task :predist => [:doc]
+
+
+desc "Run all the tests"
+task :test do
+  ruby 'test_rubypants.rb'
+end
+
+desc "Make an archive as .tar.gz"
+task :dist => :test do
+  system "darcs dist -d rubypants#{get_darcs_tree_version}"
+end
+
+
+desc "Generate RDoc documentation"
+Rake::RDocTask.new(:doc) do |rdoc|
+  rdoc.options << '--line-numbers --inline-source --all'
+  rdoc.rdoc_files.include 'README'
+  rdoc.rdoc_files.include 'rubypants.rb'
+end
+
+
+# Helper to retrieve the "revision number" of the darcs tree.
+def get_darcs_tree_version
+  return ""  unless File.directory? "_darcs"
+
+  changes = `darcs changes`
+  count = 0
+  tag = "0.0"
+  
+  changes.each("\n\n") { |change|
+    head, title, desc = change.split("\n", 3)
+    
+    if title =~ /^  \*/
+      # Normal change.
+      count += 1
+    elsif title =~ /tagged (.*)/
+      # Tag.  We look for these.
+      tag = $1
+      break
+    else
+      warn "Unparsable change: #{change}"
+    end
+  }
+
+  "-" + tag + "." + count.to_s
+end

data/install.rb

@@ -0,0 +1,9 @@
+# Install RubyPants.
+
+require "rbconfig"
+require "fileutils"
+
+source = "rubypants.rb"
+dest = File.join(Config::CONFIG["sitelibdir"], source)
+
+FileUtils.install(source, dest, :mode => 0644, :verbose => true)

data/rubypants.rb

@@ -0,0 +1,491 @@
+# encoding: utf-8
+#
+# = RubyPants -- SmartyPants ported to Ruby
+#
+# Ported by Christian Neukirchen <mailto:chneukirchen@gmail.com>
+#   Copyright (C) 2004 Christian Neukirchen
+#
+# Incooporates ideas, comments and documentation by Chad Miller
+#   Copyright (C) 2004 Chad Miller
+#
+# Original SmartyPants by John Gruber
+#   Copyright (C) 2003 John Gruber
+#
+
+#
+# = RubyPants -- SmartyPants ported to Ruby
+#
+# == Synopsis
+#
+# RubyPants is a Ruby port of the smart-quotes library SmartyPants.
+#
+# The original "SmartyPants" is a free web publishing plug-in for
+# Movable Type, Blosxom, and BBEdit that easily translates plain ASCII
+# punctuation characters into "smart" typographic punctuation HTML
+# entities.
+#
+#
+# == Description
+# 
+# RubyPants can perform the following transformations:
+# 
+# * Straight quotes (<tt>"</tt> and <tt>'</tt>) into "curly" quote
+#   HTML entities
+# * Backticks-style quotes (<tt>``like this''</tt>) into "curly" quote
+#   HTML entities
+# * Dashes (<tt>--</tt> and <tt>---</tt>) into en- and em-dash
+#   entities
+# * Three consecutive dots (<tt>...</tt> or <tt>. . .</tt>) into an
+#   ellipsis entity
+# 
+# This means you can write, edit, and save your posts using plain old
+# ASCII straight quotes, plain dashes, and plain dots, but your
+# published posts (and final HTML output) will appear with smart
+# quotes, em-dashes, and proper ellipses.
+# 
+# RubyPants does not modify characters within <tt><pre></tt>,
+# <tt><code></tt>, <tt><kbd></tt>, <tt><math></tt> or
+# <tt><script></tt> tag blocks. Typically, these tags are used to
+# display text where smart quotes and other "smart punctuation" would
+# not be appropriate, such as source code or example markup.
+#
+#
+# == Backslash Escapes
+# 
+# If you need to use literal straight quotes (or plain hyphens and
+# periods), RubyPants accepts the following backslash escape sequences
+# to force non-smart punctuation. It does so by transforming the
+# escape sequence into a decimal-encoded HTML entity:
+# 
+#   \\    \"    \'    \.    \-    \`
+#
+# This is useful, for example, when you want to use straight quotes as
+# foot and inch marks: 6'2" tall; a 17" iMac.  (Use <tt>6\'2\"</tt>
+# resp. <tt>17\"</tt>.)
+#
+# 
+# == Algorithmic Shortcomings
+# 
+# One situation in which quotes will get curled the wrong way is when
+# apostrophes are used at the start of leading contractions. For
+# example:
+# 
+#   'Twas the night before Christmas.
+# 
+# In the case above, RubyPants will turn the apostrophe into an
+# opening single-quote, when in fact it should be a closing one. I
+# don't think this problem can be solved in the general case--every
+# word processor I've tried gets this wrong as well. In such cases,
+# it's best to use the proper HTML entity for closing single-quotes
+# ("<tt>’</tt>") by hand.
+# 
+# 
+# == Bugs
+#
+# To file bug reports or feature requests (except see above) please
+# send email to: mailto:chneukirchen@gmail.com
+#
+# If the bug involves quotes being curled the wrong way, please send
+# example text to illustrate.
+#
+#
+# == Authors
+# 
+# John Gruber did all of the hard work of writing this software in
+# Perl for Movable Type and almost all of this useful documentation.
+# Chad Miller ported it to Python to use with Pyblosxom.
+#
+# Christian Neukirchen provided the Ruby port, as a general-purpose
+# library that follows the *Cloth API.
+# 
+#
+# == Copyright and License
+# 
+# === SmartyPants license:
+# 
+# Copyright (c) 2003 John Gruber
+# (http://daringfireball.net)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# 
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+# 
+# * Neither the name "SmartyPants" nor the names of its contributors
+#   may be used to endorse or promote products derived from this
+#   software without specific prior written permission.
+# 
+# This software is provided by the copyright holders and contributors
+# "as is" and any express or implied warranties, including, but not
+# limited to, the implied warranties of merchantability and fitness
+# for a particular purpose are disclaimed. In no event shall the
+# copyright owner or contributors be liable for any direct, indirect,
+# incidental, special, exemplary, or consequential damages (including,
+# but not limited to, procurement of substitute goods or services;
+# loss of use, data, or profits; or business interruption) however
+# caused and on any theory of liability, whether in contract, strict
+# liability, or tort (including negligence or otherwise) arising in
+# any way out of the use of this software, even if advised of the
+# possibility of such damage.
+# 
+# === RubyPants license
+# 
+# RubyPants is a derivative work of SmartyPants and smartypants.py.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+# 
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+# 
+# This software is provided by the copyright holders and contributors
+# "as is" and any express or implied warranties, including, but not
+# limited to, the implied warranties of merchantability and fitness
+# for a particular purpose are disclaimed. In no event shall the
+# copyright owner or contributors be liable for any direct, indirect,
+# incidental, special, exemplary, or consequential damages (including,
+# but not limited to, procurement of substitute goods or services;
+# loss of use, data, or profits; or business interruption) however
+# caused and on any theory of liability, whether in contract, strict
+# liability, or tort (including negligence or otherwise) arising in
+# any way out of the use of this software, even if advised of the
+# possibility of such damage.
+# 
+#
+# == Links
+#
+# John Gruber:: http://daringfireball.net
+# SmartyPants:: http://daringfireball.net/projects/smartypants
+#
+# Chad Miller:: http://web.chad.org
+#
+# Christian Neukirchen:: http://kronavita.de/chris
+#
+
+
+class RubyPants < String
+  VERSION = "0.2"
+
+  # Create a new RubyPants instance with the text in +string+.
+  #
+  # Allowed elements in the options array:
+  # 
+  # 0  :: do nothing
+  # 1  :: enable all, using only em-dash shortcuts
+  # 2  :: enable all, using old school en- and em-dash shortcuts (*default*)
+  # 3  :: enable all, using inverted old school en and em-dash shortcuts
+  # -1 :: stupefy (translate HTML entities to their ASCII-counterparts)
+  #
+  # If you don't like any of these defaults, you can pass symbols to change
+  # RubyPants' behavior:
+  #
+  # <tt>:quotes</tt>        :: quotes
+  # <tt>:backticks</tt>     :: backtick quotes (``double'' only)
+  # <tt>:allbackticks</tt>  :: backtick quotes (``double'' and `single')
+  # <tt>:dashes</tt>        :: dashes
+  # <tt>:oldschool</tt>     :: old school dashes
+  # <tt>:inverted</tt>      :: inverted old school dashes
+  # <tt>:ellipses</tt>      :: ellipses
+  # <tt>:convertquotes</tt> :: convert <tt>&quot;</tt> entities to
+  #                            <tt>"</tt> for Dreamweaver users
+  # <tt>:stupefy</tt>       :: translate RubyPants HTML entities
+  #                            to their ASCII counterparts.
+  #
+  def initialize(string, options=[2])
+    super string
+    @options = [*options]
+  end
+
+  # Apply SmartyPants transformations.
+  def to_html
+    do_quotes = do_backticks = do_dashes = do_ellipses = do_stupify = nil
+    convert_quotes = false
+
+    if @options.include? 0
+      # Do nothing.
+      return self
+    elsif @options.include? 1
+      # Do everything, turn all options on.
+      do_quotes = do_backticks = do_ellipses = true
+      do_dashes = :normal
+    elsif @options.include? 2
+      # Do everything, turn all options on, use old school dash shorthand.
+      do_quotes = do_backticks = do_ellipses = true
+      do_dashes = :oldschool
+    elsif @options.include? 3
+      # Do everything, turn all options on, use inverted old school
+      # dash shorthand.
+      do_quotes = do_backticks = do_ellipses = true
+      do_dashes = :inverted
+    elsif @options.include?(-1)
+      do_stupefy = true
+    else
+      do_quotes =                @options.include? :quotes
+      do_backticks =             @options.include? :backticks
+      do_backticks = :both    if @options.include? :allbackticks
+      do_dashes = :normal     if @options.include? :dashes
+      do_dashes = :oldschool  if @options.include? :oldschool
+      do_dashes = :inverted   if @options.include? :inverted
+      do_ellipses =              @options.include? :ellipses
+      convert_quotes =           @options.include? :convertquotes
+      do_stupefy =               @options.include? :stupefy
+    end
+
+    # Parse the HTML
+    tokens = tokenize
+    
+    # Keep track of when we're inside <pre> or <code> tags.
+    in_pre = false
+
+    # Here is the result stored in.
+    result = ""
+
+    # This is a cheat, used to get some context for one-character
+    # tokens that consist of just a quote char. What we do is remember
+    # the last character of the previous text token, to use as context
+    # to curl single- character quote tokens correctly.
+    prev_token_last_char = nil
+
+    tokens.each { |token|
+      if token.first == :tag
+        result << token[1]
+        if token[1] =~ %r!<(/?)(?:pre|code|kbd|script|math)[\s>]!
+          in_pre = ($1 != "/")  # Opening or closing tag?
+        end
+      else
+        t = token[1]
+
+        # Remember last char of this token before processing.
+        last_char = t[-1].chr
+
+        unless in_pre
+          t = process_escapes t
+          
+          t.gsub!(/&quot;/, '"')  if convert_quotes
+
+          if do_dashes
+            t = educate_dashes t            if do_dashes == :normal
+            t = educate_dashes_oldschool t  if do_dashes == :oldschool
+            t = educate_dashes_inverted t   if do_dashes == :inverted
+          end
+
+          t = educate_ellipses t  if do_ellipses
+
+          # Note: backticks need to be processed before quotes.
+          if do_backticks
+            t = educate_backticks t
+            t = educate_single_backticks t  if do_backticks == :both
+          end
+
+          if do_quotes
+            if t == "'"
+              # Special case: single-character ' token
+              if prev_token_last_char =~ /\S/
+                t = "’"
+              else
+                t = "‘"
+              end
+            elsif t == '"'
+              # Special case: single-character " token
+              if prev_token_last_char =~ /\S/
+                t = "”"
+              else
+                t = "“"
+              end
+            else
+              # Normal case:                  
+              t = educate_quotes t
+            end
+          end
+
+          t = stupefy_entities t  if do_stupefy
+        end
+
+        prev_token_last_char = last_char
+        result << t
+      end
+    }
+
+    # Done
+    result
+  end
+
+  protected
+
+  # Return the string, with after processing the following backslash
+  # escape sequences. This is useful if you want to force a "dumb" quote
+  # or other character to appear.
+  #
+  # Escaped are:
+  #      \\    \"    \'    \.    \-    \`
+  #
+  def process_escapes(str)
+    str.gsub('\\\\', '&#92;').
+      gsub('\"', '&#34;').
+      gsub("\\\'", '&#39;').
+      gsub('\.', '&#46;').
+      gsub('\-', '&#45;').
+      gsub('\`', '&#96;')
+  end
+
+  # The string, with each instance of "<tt>--</tt>" translated to an
+  # em-dash HTML entity.
+  #
+  def educate_dashes(str)
+    str.gsub(/--/, '—')
+  end
+
+  # The string, with each instance of "<tt>--</tt>" translated to an
+  # en-dash HTML entity, and each "<tt>---</tt>" translated to an
+  # em-dash HTML entity.
+  #
+  def educate_dashes_oldschool(str)
+    str.gsub(/---/, '—').gsub(/--/, '–')
+  end
+
+  # Return the string, with each instance of "<tt>--</tt>" translated
+  # to an em-dash HTML entity, and each "<tt>---</tt>" translated to
+  # an en-dash HTML entity. Two reasons why: First, unlike the en- and
+  # em-dash syntax supported by +educate_dashes_oldschool+, it's
+  # compatible with existing entries written before SmartyPants 1.1,
+  # back when "<tt>--</tt>" was only used for em-dashes.  Second,
+  # em-dashes are more common than en-dashes, and so it sort of makes
+  # sense that the shortcut should be shorter to type. (Thanks to
+  # Aaron Swartz for the idea.)
+  #
+  def educate_dashes_inverted(str)
+    str.gsub(/---/, '–').gsub(/--/, '—')
+  end
+
+  # Return the string, with each instance of "<tt>...</tt>" translated
+  # to an ellipsis HTML entity. Also converts the case where there are
+  # spaces between the dots.
+  #
+  def educate_ellipses(str)
+    str.gsub('...', '…').gsub('. . .', '…')
+  end
+
+  # Return the string, with "<tt>``backticks''</tt>"-style single quotes
+  # translated into HTML curly quote entities.
+  #
+  def educate_backticks(str)
+    str.gsub("``", '“').gsub("''", '”')
+  end
+
+  # Return the string, with "<tt>`backticks'</tt>"-style single quotes
+  # translated into HTML curly quote entities.
+  #
+  def educate_single_backticks(str)
+    str.gsub("`", '‘').gsub("'", '’')
+  end
+
+  # Return the string, with "educated" curly quote HTML entities.
+  #
+  def educate_quotes(str)
+    punct_class = '[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^_`{|}~]'
+
+    str = str.dup
+      
+    # Special case if the very first character is a quote followed by
+    # punctuation at a non-word-break. Close the quotes by brute
+    # force:
+    str.gsub!(/^'(?=#{punct_class}\B)/, '’')
+    str.gsub!(/^"(?=#{punct_class}\B)/, '”')
+
+    # Special case for double sets of quotes, e.g.:
+    #   <p>He said, "'Quoted' words in a larger quote."</p>
+    str.gsub!(/"'(?=\w)/, '“‘')
+    str.gsub!(/'"(?=\w)/, '‘“')
+
+    # Special case for decade abbreviations (the '80s):
+    str.gsub!(/'(?=\d\ds)/, '’')
+
+    close_class = %![^\ \t\r\n\\[\{\(\-]!
+    dec_dashes = '–|—'
+    
+    # Get most opening single quotes:
+    str.gsub!(/(\s|&nbsp;|--|&[mn]dash;|#{dec_dashes}|&#x201[34];)'(?=\w)/,
+             '\1‘')
+    # Single closing quotes:
+    str.gsub!(/(#{close_class})'/, '\1’')
+    str.gsub!(/'(\s|s\b|$)/, '’\1')
+    # Any remaining single quotes should be opening ones:
+    str.gsub!(/'/, '‘')
+
+    # Get most opening double quotes:
+    str.gsub!(/(\s|&nbsp;|--|&[mn]dash;|#{dec_dashes}|&#x201[34];)"(?=\w)/,
+             '\1“')
+    # Double closing quotes:
+    str.gsub!(/(#{close_class})"/, '\1”')
+    str.gsub!(/"(\s|s\b|$)/, '”\1')
+    # Any remaining quotes should be opening ones:
+    str.gsub!(/"/, '“')
+
+    str
+  end
+
+  # Return the string, with each RubyPants HTML entity translated to
+  # its ASCII counterpart.
+  #
+  # Note: This is not reversible (but exactly the same as in SmartyPants)
+  #
+  def stupefy_entities(str)
+    str.
+      gsub(/–/, '-').      # en-dash
+      gsub(/—/, '--').     # em-dash
+      
+      gsub(/‘/, "'").      # open single quote
+      gsub(/’/, "'").      # close single quote
+      
+      gsub(/“/, '"').      # open double quote
+      gsub(/”/, '"').      # close double quote
+      
+      gsub(/…/, '...')     # ellipsis
+  end
+
+  # Return an array of the tokens comprising the string. Each token is
+  # either a tag (possibly with nested, tags contained therein, such
+  # as <tt><a href="<MTFoo>"></tt>, or a run of text between
+  # tags. Each element of the array is a two-element array; the first
+  # is either :tag or :text; the second is the actual value.
+  #
+  # Based on the <tt>_tokenize()</tt> subroutine from Brad Choate's
+  # MTRegex plugin.  <http://www.bradchoate.com/past/mtregex.php>
+  #
+  # This is actually the easier variant using tag_soup, as used by
+  # Chad Miller in the Python port of SmartyPants.
+  #
+  def tokenize
+    tag_soup = /([^<]*)(<[^>]*>)/
+
+    tokens = []
+
+    prev_end = 0
+    scan(tag_soup) {
+      tokens << [:text, $1]  if $1 != ""
+      tokens << [:tag, $2]
+      
+      prev_end = $~.end(0)
+    }
+
+    if prev_end < size
+      tokens << [:text, self[prev_end..-1]]
+    end
+
+    tokens
+  end
+end

data/test_rubypants.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+
+require 'test/unit'
+require './rubypants'
+
+# Test EVERYTHING against SmartyPants.pl output!
+
+
+class TestRubyPants < Test::Unit::TestCase
+  def assert_rp_equal(str, orig, options=[2])
+    assert_equal orig, RubyPants.new(str, options).to_html
+  end
+
+  def assert_verbatim(str)
+    assert_rp_equal str, str
+  end
+
+  def test_verbatim
+    assert_verbatim "foo!"
+    assert_verbatim "<div>This is HTML</div>"
+    assert_verbatim "<div>This is HTML with <crap </div> tags>"
+    assert_verbatim <<EOF
+multiline
+
+<b>html</b>
+
+code
+
+EOF
+  end
+
+  def test_quotes
+    assert_rp_equal '"A first example"', '“A first example”'
+    assert_rp_equal '"A first "nested" example"',
+                    '“A first “nested” example”'
+
+    assert_rp_equal '".', '”.'
+    assert_rp_equal '"a', '“a'
+
+    assert_rp_equal "'.", '’.'
+    assert_rp_equal "'a", '‘a'
+
+    assert_rp_equal %{<p>He said, "'Quoted' words in a larger quote."</p>},
+    "<p>He said, “‘Quoted’ words in a larger quote.”</p>"
+
+    assert_rp_equal %{"I like the 70's"}, '“I like the 70’s”'
+    assert_rp_equal %{"I like the '70s"}, '“I like the ’70s”'
+    assert_rp_equal %{"I like the '70!"}, '“I like the ‘70!”'
+
+    assert_rp_equal 'pre"post', 'pre”post'
+    assert_rp_equal 'pre "post', 'pre “post'
+    assert_rp_equal 'pre&nbsp;"post', 'pre&nbsp;“post'
+    assert_rp_equal 'pre--"post', 'pre–“post'
+    assert_rp_equal 'pre--"!', 'pre–”!'
+
+    assert_rp_equal "pre'post", 'pre’post'
+    assert_rp_equal "pre 'post", 'pre ‘post'
+    assert_rp_equal "pre&nbsp;'post", 'pre&nbsp;‘post'
+    assert_rp_equal "pre--'post", 'pre–‘post'
+    assert_rp_equal "pre--'!", 'pre–’!'
+
+    assert_rp_equal "<b>'</b>", "<b>‘</b>"
+    assert_rp_equal "foo<b>'</b>", "foo<b>’</b>"
+
+    assert_rp_equal '<b>"</b>', "<b>“</b>"
+    assert_rp_equal 'foo<b>"</b>', "foo<b>”</b>"
+  end
+
+  def test_dashes
+    assert_rp_equal "foo--bar", 'foo—bar', 1
+    assert_rp_equal "foo---bar", 'foo—-bar', 1
+    assert_rp_equal "foo----bar", 'foo——bar', 1
+    assert_rp_equal "foo-----bar", 'foo——-bar', 1
+    assert_rp_equal "--foo--bar--quux--",
+                    '—foo—bar—quux—', 1
+
+    assert_rp_equal "foo--bar", 'foo–bar', 2
+    assert_rp_equal "foo---bar", 'foo—bar', 2
+    assert_rp_equal "foo----bar", 'foo—-bar', 2
+    assert_rp_equal "foo-----bar", 'foo—–bar', 2
+    assert_rp_equal "--foo--bar--quux--",
+                    '–foo–bar–quux–', 2
+
+    assert_rp_equal "foo--bar", 'foo—bar', 3
+    assert_rp_equal "foo---bar", 'foo–bar', 3
+    assert_rp_equal "foo----bar", 'foo–-bar', 3
+    assert_rp_equal "foo-----bar", 'foo–—bar', 3
+    assert_rp_equal "--foo--bar--quux--",
+                    '—foo—bar—quux—', 3
+  end
+
+  def test_ellipses
+    assert_rp_equal "foo..bar", 'foo..bar'
+    assert_rp_equal "foo...bar", 'foo…bar'
+    assert_rp_equal "foo....bar", 'foo….bar'
+
+    # Nasty ones
+    assert_rp_equal "foo. . ..bar", 'foo….bar'
+    assert_rp_equal "foo. . ...bar", 'foo. . …bar'
+    assert_rp_equal "foo. . ....bar", 'foo. . ….bar'
+  end
+
+  def test_backticks
+    assert_rp_equal "pre``post", 'pre“post'
+    assert_rp_equal "pre ``post", 'pre “post'
+    assert_rp_equal "pre&nbsp;``post", 'pre&nbsp;“post'
+    assert_rp_equal "pre--``post", 'pre–“post'
+    assert_rp_equal "pre--``!", 'pre–“!'
+
+    assert_rp_equal "pre''post", 'pre”post'
+    assert_rp_equal "pre ''post", 'pre ”post'
+    assert_rp_equal "pre&nbsp;''post", 'pre&nbsp;”post'
+    assert_rp_equal "pre--''post", 'pre–”post'
+    assert_rp_equal "pre--''!", 'pre–”!'
+  end
+
+  def test_single_backticks
+    o = [:oldschool, :allbackticks]
+
+    assert_rp_equal "`foo'", "‘foo’", o
+
+    assert_rp_equal "pre`post", 'pre‘post', o
+    assert_rp_equal "pre `post", 'pre ‘post', o
+    assert_rp_equal "pre&nbsp;`post", 'pre&nbsp;‘post', o
+    assert_rp_equal "pre--`post", 'pre–‘post', o
+    assert_rp_equal "pre--`!", 'pre–‘!', o
+
+    assert_rp_equal "pre'post", 'pre’post', o
+    assert_rp_equal "pre 'post", 'pre ’post', o
+    assert_rp_equal "pre&nbsp;'post", 'pre&nbsp;’post', o
+    assert_rp_equal "pre--'post", 'pre–’post', o
+    assert_rp_equal "pre--'!", 'pre–’!', o
+  end
+
+  def test_stupefy
+    o = [:stupefy]
+
+    assert_rp_equal "<p>He said, “‘Quoted’ words " +
+                    "in a larger quote.”</p>",
+                    %{<p>He said, "'Quoted' words in a larger quote."</p>}, o
+
+    assert_rp_equal "– — ‘’ “” …",
+                    %{- -- '' "" ...}, o
+
+    assert_rp_equal %{- -- '' "" ...}, %{- -- '' "" ...}, o
+  end
+
+  def test_process_escapes
+    assert_rp_equal %q{foo\bar}, "foo\\bar"
+    assert_rp_equal %q{foo\\\bar}, "foo&#92;bar"
+    assert_rp_equal %q{foo\\\\\bar}, "foo&#92;\\bar"
+    assert_rp_equal %q{foo\...bar}, "foo&#46;..bar"
+    assert_rp_equal %q{foo\.\.\.bar}, "foo&#46;&#46;&#46;bar"
+
+    assert_rp_equal %q{foo\'bar}, "foo&#39;bar"
+    assert_rp_equal %q{foo\"bar}, "foo&#34;bar"
+    assert_rp_equal %q{foo\-bar}, "foo&#45;bar"
+    assert_rp_equal %q{foo\`bar}, "foo&#96;bar"
+
+    assert_rp_equal %q{foo\#bar}, "foo\\#bar"
+    assert_rp_equal %q{foo\*bar}, "foo\\*bar"
+    assert_rp_equal %q{foo\&bar}, "foo\\&bar"
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: rubypants-unicode
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Chapman
+- Christian Neukirchen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-30 00:00:00.000000000 Z
+dependencies: []
+description: ! 'RubyPants-Unicode is a Ruby port of the smart-quotes library SmartyPants
+  that outputs
+
+  unicode characters (UTF-8) instead of HTML entities.
+
+
+  The original "SmartyPants" is a free web publishing plug-in for
+
+  Movable Type, Blosxom, and BBEdit that easily translates plain ASCII
+
+  punctuation characters into "smart" typographic punctuation HTML
+
+  entities.
+
+'
+email: chris.chapman@aggiemail.usu.edu
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- install.rb
+- rubypants.rb
+- test_rubypants.rb
+- README.md
+- Rakefile
+homepage: https://github.com/cdchapman/rubypants-unicode
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+- --line-numbers
+- --inline-source
+- --all
+- --exclude
+- test_rubypants.rb
+require_paths:
+- .
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: RubyPants-Unicode is a Ruby port of the smart-quotes library SmartyPants.
+test_files:
+- test_rubypants.rb