# File rubypants.rb, line 207
def initialize(string, options=[2])
  super string
  @options = [*options]
end

# File rubypants.rb, line 213
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 = "&#8217;"
            else
              t = "&#8216;"
            end
          elsif t == '"'
            # Special case: single-character " token
            if prev_token_last_char =~ /\S/
              t = "&#8221;"
            else
              t = "&#8220;"
            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

# File rubypants.rb, line 384
def educate_backticks(str)
  str.gsub("``", '“').gsub("''", '”')
end

# File rubypants.rb, line 347
def educate_dashes(str)
  str.gsub(/--/, '—')
end

# File rubypants.rb, line 369
def educate_dashes_inverted(str)
  str.gsub(/---/, '–').gsub(/--/, '—')
end

# File rubypants.rb, line 355
def educate_dashes_oldschool(str)
  str.gsub(/---/, '—').gsub(/--/, '–')
end

# File rubypants.rb, line 377
def educate_ellipses(str)
  str.gsub('...', '…').gsub('. . .', '…')
end

# File rubypants.rb, line 397
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)/, '&#8217;')
  str.gsub!(/^"(?=#{punct_class}\B)/, '&#8221;')

  # Special case for double sets of quotes, e.g.:
  #   <p>He said, "'Quoted' words in a larger quote."</p>
  str.gsub!(/"'(?=\w)/, '&#8220;&#8216;')
  str.gsub!(/'"(?=\w)/, '&#8216;&#8220;')

  # Special case for decade abbreviations (the '80s):
  str.gsub!(/'(?=\d\ds)/, '&#8217;')

  close_class = %Q[^\ \t\r\n\\[\{\(\-]!
  dec_dashes = '&#8211;|&#8212;'
  
  # Get most opening single quotes:
  str.gsub!(/(\s|&nbsp;|--|&[mn]dash;|#{dec_dashes}|&#x201[34];)'(?=\w)/,
           '\1&#8216;')
  # Single closing quotes:
  str.gsub!(/(#{close_class})'/, '\1&#8217;')
  str.gsub!(/'(\s|s\b|$)/, '&#8217;\1')
  # Any remaining single quotes should be opening ones:
  str.gsub!(/'/, '&#8216;')

  # Get most opening double quotes:
  str.gsub!(/(\s|&nbsp;|--|&[mn]dash;|#{dec_dashes}|&#x201[34];)"(?=\w)/,
           '\1&#8220;')
  # Double closing quotes:
  str.gsub!(/(#{close_class})"/, '\1&#8221;')
  str.gsub!(/"(\s|s\b|$)/, '&#8221;\1')
  # Any remaining quotes should be opening ones:
  str.gsub!(/"/, '&#8220;')

  str
end

# File rubypants.rb, line 391
def educate_single_backticks(str)
  str.gsub("`", '‘').gsub("'", '’')
end

# File rubypants.rb, line 335
def process_escapes(str)
  str.gsub('\\', '\').
    gsub('\"', '"').
    gsub("\\\'", ''').
    gsub('\.', '.').
    gsub('\-', '-').
    gsub('\`', '`')
end

# File rubypants.rb, line 445
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

# File rubypants.rb, line 471
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