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

     # File rubypants.rb, line 213
213:   def to_html
214:     do_quotes = do_backticks = do_dashes = do_ellipses = do_stupify = nil
215:     convert_quotes = false
216: 
217:     if @options.include? 0
218:       # Do nothing.
219:       return self
220:     elsif @options.include? 1
221:       # Do everything, turn all options on.
222:       do_quotes = do_backticks = do_ellipses = true
223:       do_dashes = :normal
224:     elsif @options.include? 2
225:       # Do everything, turn all options on, use old school dash shorthand.
226:       do_quotes = do_backticks = do_ellipses = true
227:       do_dashes = :oldschool
228:     elsif @options.include? 3
229:       # Do everything, turn all options on, use inverted old school
230:       # dash shorthand.
231:       do_quotes = do_backticks = do_ellipses = true
232:       do_dashes = :inverted
233:     elsif @options.include?(-1)
234:       do_stupefy = true
235:     else
236:       do_quotes =                @options.include? :quotes
237:       do_backticks =             @options.include? :backticks
238:       do_backticks = :both    if @options.include? :allbackticks
239:       do_dashes = :normal     if @options.include? :dashes
240:       do_dashes = :oldschool  if @options.include? :oldschool
241:       do_dashes = :inverted   if @options.include? :inverted
242:       do_ellipses =              @options.include? :ellipses
243:       convert_quotes =           @options.include? :convertquotes
244:       do_stupefy =               @options.include? :stupefy
245:     end
246: 
247:     # Parse the HTML
248:     tokens = tokenize
249:     
250:     # Keep track of when we're inside <pre> or <code> tags.
251:     in_pre = false
252: 
253:     # Here is the result stored in.
254:     result = ""
255: 
256:     # This is a cheat, used to get some context for one-character
257:     # tokens that consist of just a quote char. What we do is remember
258:     # the last character of the previous text token, to use as context
259:     # to curl single- character quote tokens correctly.
260:     prev_token_last_char = nil
261: 
262:     tokens.each { |token|
263:       if token.first == :tag
264:         result << token[1]
265:         if token[1] =~ %!<(/?)(?:pre|code|kbd|script|math)[\s>]!
266:           in_pre = ($1 != "/")  # Opening or closing tag?
267:         end
268:       else
269:         t = token[1]
270: 
271:         # Remember last char of this token before processing.
272:         last_char = t[-1].chr
273: 
274:         unless in_pre
275:           t = process_escapes t
276:           
277:           t.gsub!(/&quot;/, '"')  if convert_quotes
278: 
279:           if do_dashes
280:             t = educate_dashes t            if do_dashes == :normal
281:             t = educate_dashes_oldschool t  if do_dashes == :oldschool
282:             t = educate_dashes_inverted t   if do_dashes == :inverted
283:           end
284: 
285:           t = educate_ellipses t  if do_ellipses
286: 
287:           # Note: backticks need to be processed before quotes.
288:           if do_backticks
289:             t = educate_backticks t
290:             t = educate_single_backticks t  if do_backticks == :both
291:           end
292: 
293:           if do_quotes
294:             if t == "'"
295:               # Special case: single-character ' token
296:               if prev_token_last_char =~ /\S/
297:                 t = "&#8217;"
298:               else
299:                 t = "&#8216;"
300:               end
301:             elsif t == '"'
302:               # Special case: single-character " token
303:               if prev_token_last_char =~ /\S/
304:                 t = "&#8221;"
305:               else
306:                 t = "&#8220;"
307:               end
308:             else
309:               # Normal case:                  
310:               t = educate_quotes t
311:             end
312:           end
313: 
314:           t = stupefy_entities t  if do_stupefy
315:         end
316: 
317:         prev_token_last_char = last_char
318:         result << t
319:       end
320:     }
321: 
322:     # Done
323:     result
324:   end

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

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

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

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

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

     # File rubypants.rb, line 397
397:   def educate_quotes(str)
398:     punct_class = '[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^^_`{|}~]'
399: 
400:     str = str.dup
401:       
402:     # Special case if the very first character is a quote followed by
403:     # punctuation at a non-word-break. Close the quotes by brute
404:     # force:
405:     str.gsub!(/^'(?=#{punct_class}\B)/, '&#8217;')
406:     str.gsub!(/^"(?=#{punct_class}\B)/, '&#8221;')
407: 
408:     # Special case for double sets of quotes, e.g.:
409:     #   <p>He said, "'Quoted' words in a larger quote."</p>
410:     str.gsub!(/"'(?=\w)/, '&#8220;&#8216;')
411:     str.gsub!(/'"(?=\w)/, '&#8216;&#8220;')
412: 
413:     # Special case for decade abbreviations (the '80s):
414:     str.gsub!(/'(?=\d\ds)/, '&#8217;')
415: 
416:     close_class = %![^\ \t\r\n\\[\{\(\-]!
417:     dec_dashes = '&#8211;|&#8212;'
418:     
419:     # Get most opening single quotes:
420:     str.gsub!(/(\s|&nbsp;|--|&[mn]dash;|#{dec_dashes}|&#x201[34];)'(?=\w)/,
421:              '\1&#8216;')
422:     # Single closing quotes:
423:     str.gsub!(/(#{close_class})'/, '\1&#8217;')
424:     str.gsub!(/'(\s|s\b|$)/, '&#8217;\1')
425:     # Any remaining single quotes should be opening ones:
426:     str.gsub!(/'/, '&#8216;')
427: 
428:     # Get most opening double quotes:
429:     str.gsub!(/(\s|&nbsp;|--|&[mn]dash;|#{dec_dashes}|&#x201[34];)"(?=\w)/,
430:              '\1&#8220;')
431:     # Double closing quotes:
432:     str.gsub!(/(#{close_class})"/, '\1&#8221;')
433:     str.gsub!(/"(\s|s\b|$)/, '&#8221;\1')
434:     # Any remaining quotes should be opening ones:
435:     str.gsub!(/"/, '&#8220;')
436: 
437:     str
438:   end

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

     # File rubypants.rb, line 335
335:   def process_escapes(str)
336:     str.gsub('\\\\', '\').
337:       gsub('\"', '"').
338:       gsub("\\\'", ''').
339:       gsub('\.', '.').
340:       gsub('\-', '-').
341:       gsub('\`', '`')
342:   end

     # File rubypants.rb, line 445
445:   def stupefy_entities(str)
446:     str.
447:       gsub(/–/, '-').      # en-dash
448:       gsub(/—/, '--').     # em-dash
449:       
450:       gsub(/‘/, "'").      # open single quote
451:       gsub(/’/, "'").      # close single quote
452:       
453:       gsub(/“/, '"').      # open double quote
454:       gsub(/”/, '"').      # close double quote
455:       
456:       gsub(/…/, '...')     # ellipsis
457:   end

     # File rubypants.rb, line 471
471:   def tokenize
472:     tag_soup = /([^<]*)(<[^>]*>)/
473: 
474:     tokens = []
475: 
476:     prev_end = 0
477:     scan(tag_soup) {
478:       tokens << [:text, $1]  if $1 != ""
479:       tokens << [:tag, $2]
480:       
481:       prev_end = $~.end(0)
482:     }
483: 
484:     if prev_end < size
485:       tokens << [:text, self[prev_end..-1]]
486:     end
487: 
488:     tokens
489:   end