rb2exe 0.1.11 → 0.1.12

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rdoc/text.rb

@@ -0,0 +1,324 @@
+# coding: utf-8
+
+##
+# For RDoc::Text#to_html
+
+require 'strscan'
+
+##
+# For RDoc::Text#snippet
+
+begin
+  gem 'json'
+rescue Gem::LoadError
+end
+
+require 'json'
+
+##
+# Methods for manipulating comment text
+
+module RDoc::Text
+
+  ##
+  # Maps markup formats to classes that can parse them.  If the format is
+  # unknown, "rdoc" format is used.
+
+  MARKUP_FORMAT = {
+    'markdown' => RDoc::Markdown,
+    'rdoc'     => RDoc::Markup,
+    'rd'       => RDoc::RD,
+    'tomdoc'   => RDoc::TomDoc,
+  }
+
+  MARKUP_FORMAT.default = RDoc::Markup
+
+  ##
+  # Maps an encoding to a Hash of characters properly transcoded for that
+  # encoding.
+  #
+  # See also encode_fallback.
+
+  TO_HTML_CHARACTERS = Hash.new do |h, encoding|
+    h[encoding] = {
+      :close_dquote => encode_fallback('”', encoding, '"'),
+      :close_squote => encode_fallback('’', encoding, '\''),
+      :copyright    => encode_fallback('©', encoding, '(c)'),
+      :ellipsis     => encode_fallback('…', encoding, '...'),
+      :em_dash      => encode_fallback('—', encoding, '---'),
+      :en_dash      => encode_fallback('–', encoding, '--'),
+      :open_dquote  => encode_fallback('“', encoding, '"'),
+      :open_squote  => encode_fallback('‘', encoding, '\''),
+      :trademark    => encode_fallback('®', encoding, '(r)'),
+    }
+  end if Object.const_defined? :Encoding
+
+  ##
+  # Transcodes +character+ to +encoding+ with a +fallback+ character.
+
+  def self.encode_fallback character, encoding, fallback
+    character.encode(encoding, :fallback => { character => fallback },
+                     :undef => :replace, :replace => fallback)
+  end
+
+  ##
+  # Expands tab characters in +text+ to eight spaces
+
+  def expand_tabs text
+    expanded = []
+
+    text.each_line do |line|
+      nil while line.gsub!(/(?:\G|\r)((?:.{8})*?)([^\t\r\n]{0,7})\t/) do
+        r = "#{$1}#{$2}#{' ' * (8 - $2.size)}"
+        r.force_encoding text.encoding if Object.const_defined? :Encoding
+        r
+      end
+
+      expanded << line
+    end
+
+    expanded.join
+  end
+
+  ##
+  # Flush +text+ left based on the shortest line
+
+  def flush_left text
+    indent = 9999
+
+    text.each_line do |line|
+      line_indent = line =~ /\S/ || 9999
+      indent = line_indent if indent > line_indent
+    end
+
+    empty = ''
+    empty.force_encoding text.encoding if Object.const_defined? :Encoding
+
+    text.gsub(/^ {0,#{indent}}/, empty)
+  end
+
+  ##
+  # Convert a string in markup format into HTML.
+  #
+  # Requires the including class to implement #formatter
+
+  def markup text
+    if @store.rdoc.options
+      locale = @store.rdoc.options.locale
+    else
+      locale = nil
+    end
+    if locale
+      i18n_text = RDoc::I18n::Text.new(text)
+      text = i18n_text.translate(locale)
+    end
+    parse(text).accept formatter
+  end
+
+  ##
+  # Strips hashes, expands tabs then flushes +text+ to the left
+
+  def normalize_comment text
+    return text if text.empty?
+
+    text = strip_stars    text
+    text = strip_hashes   text
+    text = expand_tabs    text
+    text = flush_left     text
+    text = strip_newlines text
+    text
+  end
+
+  ##
+  # Normalizes +text+ then builds a RDoc::Markup::Document from it
+
+  def parse text, format = 'rdoc'
+    return text if RDoc::Markup::Document === text
+    return text.parse if RDoc::Comment === text
+
+    text = normalize_comment text # TODO remove, should not be necessary
+
+    return RDoc::Markup::Document.new if text =~ /\A\n*\z/
+
+    MARKUP_FORMAT[format].parse text
+  end
+
+  ##
+  # The first +limit+ characters of +text+ as HTML
+
+  def snippet text, limit = 100
+    document = parse text
+
+    RDoc::Markup::ToHtmlSnippet.new(options, limit).convert document
+  end
+
+  ##
+  # Strips leading # characters from +text+
+
+  def strip_hashes text
+    return text if text =~ /^(?>\s*)[^\#]/
+
+    empty = ''
+    empty.force_encoding text.encoding if Object.const_defined? :Encoding
+
+    text.gsub(/^\s*(#+)/) { $1.tr '#', ' ' }.gsub(/^\s+$/, empty)
+  end
+
+  ##
+  # Strips leading and trailing \n characters from +text+
+
+  def strip_newlines text
+    text.gsub(/\A\n*(.*?)\n*\z/m) do $1 end # block preserves String encoding
+  end
+
+  ##
+  # Strips /* */ style comments
+
+  def strip_stars text
+    return text unless text =~ %r%/\*.*\*/%m
+
+    encoding = text.encoding if Object.const_defined? :Encoding
+
+    text = text.gsub %r%Document-method:\s+[\w:.#=!?]+%, ''
+
+    space = ' '
+    space.force_encoding encoding if encoding
+
+    text.sub!  %r%/\*+%       do space * $&.length end
+    text.sub!  %r%\*+/%       do space * $&.length end
+    text.gsub! %r%^[ \t]*\*%m do space * $&.length end
+
+    empty = ''
+    empty.force_encoding encoding if encoding
+    text.gsub(/^\s+$/, empty)
+  end
+
+  ##
+  # Converts ampersand, dashes, ellipsis, quotes, copyright and registered
+  # trademark symbols in +text+ to properly encoded characters.
+
+  def to_html text
+    if Object.const_defined? :Encoding then
+      html = ''.encode text.encoding
+
+      encoded = RDoc::Text::TO_HTML_CHARACTERS[text.encoding]
+    else
+      html = ''
+      encoded = {
+        :close_dquote => '”',
+        :close_squote => '’',
+        :copyright    => '©',
+        :ellipsis     => '…',
+        :em_dash      => '—',
+        :en_dash      => '–',
+        :open_dquote  => '“',
+        :open_squote  => '‘',
+        :trademark    => '®',
+      }
+    end
+
+    s = StringScanner.new text
+    insquotes = false
+    indquotes = false
+    after_word = nil
+
+    until s.eos? do
+      case
+      when s.scan(/<(tt|code)>.*?<\/\1>/) then # skip contents of tt
+        html << s.matched.gsub('\\\\', '\\')
+      when s.scan(/<(tt|code)>.*?/) then
+        warn "mismatched <#{s[1]}> tag" # TODO signal file/line
+        html << s.matched
+      when s.scan(/<[^>]+\/?s*>/) then # skip HTML tags
+        html << s.matched
+      when s.scan(/\\(\S)/) then # unhandled suppressed crossref
+        html << s[1]
+        after_word = nil
+      when s.scan(/\.\.\.(\.?)/) then
+        html << s[1] << encoded[:ellipsis]
+        after_word = nil
+      when s.scan(/\(c\)/) then
+        html << encoded[:copyright]
+        after_word = nil
+      when s.scan(/\(r\)/) then
+        html << encoded[:trademark]
+        after_word = nil
+      when s.scan(/---/) then
+        html << encoded[:em_dash]
+        after_word = nil
+      when s.scan(/--/) then
+        html << encoded[:en_dash]
+        after_word = nil
+      when s.scan(/&quot;|"/) then
+        html << encoded[indquotes ? :close_dquote : :open_dquote]
+        indquotes = !indquotes
+        after_word = nil
+      when s.scan(/``/) then # backtick double quote
+        html << encoded[:open_dquote]
+        after_word = nil
+      when s.scan(/''/) then # tick double quote
+        html << encoded[:close_dquote]
+        after_word = nil
+      when s.scan(/'/) then # single quote
+        if insquotes
+          html << encoded[:close_squote]
+          insquotes = false
+        elsif after_word
+          # Mary's dog, my parents' house: do not start paired quotes
+          html << encoded[:close_squote]
+        else
+          html << encoded[:open_squote]
+          insquotes = true
+        end
+
+        after_word = nil
+      else # advance to the next potentially significant character
+        match = s.scan(/.+?(?=[<\\.("'`&-])/) #"
+
+        if match then
+          html << match
+          after_word = match =~ /\w$/
+        else
+          html << s.rest
+          break
+        end
+      end
+    end
+
+    html
+  end
+
+  ##
+  # Wraps +txt+ to +line_len+
+
+  def wrap(txt, line_len = 76)
+    res = []
+    sp = 0
+    ep = txt.length
+
+    while sp < ep
+      # scan back for a space
+      p = sp + line_len - 1
+      if p >= ep
+        p = ep
+      else
+        while p > sp and txt[p] != ?\s
+          p -= 1
+        end
+        if p <= sp
+          p = sp + line_len
+          while p < ep and txt[p] != ?\s
+            p += 1
+          end
+        end
+      end
+      res << txt[sp...p] << "\n"
+      sp = p
+      sp += 1 while sp < ep and txt[sp] == ?\s
+    end
+
+    res.join.strip
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rdoc/token_stream.rb

@@ -0,0 +1,95 @@
+##
+# A TokenStream is a list of tokens, gathered during the parse of some entity
+# (say a method). Entities populate these streams by being registered with the
+# lexer. Any class can collect tokens by including TokenStream. From the
+# outside, you use such an object by calling the start_collecting_tokens
+# method, followed by calls to add_token and pop_token.
+
+module RDoc::TokenStream
+
+  ##
+  # Converts +token_stream+ to HTML wrapping various tokens with
+  # <tt><span></tt> elements.  The following tokens types are wrapped in spans
+  # with the given class names:
+  #
+  # TkCONSTANT :: 'ruby-constant'
+  # TkKW       :: 'ruby-keyword'
+  # TkIVAR     :: 'ruby-ivar'
+  # TkOp       :: 'ruby-operator'
+  # TkId       :: 'ruby-identifier'
+  # TkNode     :: 'ruby-node'
+  # TkCOMMENT  :: 'ruby-comment'
+  # TkREGEXP   :: 'ruby-regexp'
+  # TkSTRING   :: 'ruby-string'
+  # TkVal      :: 'ruby-value'
+  #
+  # Other token types are not wrapped in spans.
+
+  def self.to_html token_stream
+    token_stream.map do |t|
+      next unless t
+
+      style = case t
+              when RDoc::RubyToken::TkCONSTANT then 'ruby-constant'
+              when RDoc::RubyToken::TkKW       then 'ruby-keyword'
+              when RDoc::RubyToken::TkIVAR     then 'ruby-ivar'
+              when RDoc::RubyToken::TkOp       then 'ruby-operator'
+              when RDoc::RubyToken::TkId       then 'ruby-identifier'
+              when RDoc::RubyToken::TkNode     then 'ruby-node'
+              when RDoc::RubyToken::TkCOMMENT  then 'ruby-comment'
+              when RDoc::RubyToken::TkREGEXP   then 'ruby-regexp'
+              when RDoc::RubyToken::TkSTRING   then 'ruby-string'
+              when RDoc::RubyToken::TkVal      then 'ruby-value'
+              end
+
+      text = CGI.escapeHTML t.text
+
+      if style then
+        "<span class=\"#{style}\">#{text}</span>"
+      else
+        text
+      end
+    end.join
+  end
+
+  ##
+  # Adds +tokens+ to the collected tokens
+
+  def add_tokens(*tokens)
+    tokens.flatten.each { |token| @token_stream << token }
+  end
+
+  alias add_token add_tokens
+
+  ##
+  # Starts collecting tokens
+
+  def collect_tokens
+    @token_stream = []
+  end
+
+  alias start_collecting_tokens collect_tokens
+
+  ##
+  # Remove the last token from the collected tokens
+
+  def pop_token
+    @token_stream.pop
+  end
+
+  ##
+  # Current token stream
+
+  def token_stream
+    @token_stream
+  end
+
+  ##
+  # Returns a string representation of the token stream
+
+  def tokens_to_s
+    token_stream.compact.map { |token| token.text }.join ''
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rdoc/tom_doc.rb

@@ -0,0 +1,257 @@
+# :markup: tomdoc
+
+# A parser for TomDoc based on TomDoc 1.0.0-rc1 (02adef9b5a)
+#
+# The TomDoc specification can be found at:
+#
+# http://tomdoc.org
+#
+# The latest version of the TomDoc specification can be found at:
+#
+# https://github.com/mojombo/tomdoc/blob/master/tomdoc.md
+#
+# To choose TomDoc as your only default format see RDoc::Options@Saved+Options
+# for instructions on setting up a <code>.rdoc_options</code> file to store
+# your project default.
+#
+# There are a few differences between this parser and the specification.  A
+# best-effort was made to follow the specification as closely as possible but
+# some choices to deviate were made.
+#
+# A future version of RDoc will warn when a MUST or MUST NOT is violated and
+# may warn when a SHOULD or SHOULD NOT is violated.  RDoc will always try
+# to emit documentation even if given invalid TomDoc.
+#
+# Here are some implementation choices this parser currently makes:
+#
+# This parser allows rdoc-style inline markup but you should not depended on
+# it.
+#
+# This parser allows a space between the comment and the method body.
+#
+# This parser does not require the default value to be described for an
+# optional argument.
+#
+# This parser does not examine the order of sections.  An Examples section may
+# precede the Arguments section.
+#
+# This class is documented in TomDoc format.  Since this is a subclass of the
+# RDoc markup parser there isn't much to see here, unfortunately.
+
+class RDoc::TomDoc < RDoc::Markup::Parser
+
+  # Internal: Token accessor
+
+  attr_reader :tokens
+
+  # Internal: Adds a post-processor which sets the RDoc section based on the
+  # comment's status.
+  #
+  # Returns nothing.
+
+  def self.add_post_processor # :nodoc:
+    RDoc::Markup::PreProcess.post_process do |comment, code_object|
+      next unless code_object and
+                  RDoc::Comment === comment and comment.format == 'tomdoc'
+
+      comment.text.gsub!(/(\A\s*# )(Public|Internal|Deprecated):\s+/) do
+        section = code_object.add_section $2
+        code_object.temporary_section = section
+
+        $1
+      end
+    end
+  end
+
+  add_post_processor
+
+  # Public: Parses TomDoc from text
+  #
+  # text - A String containing TomDoc-format text.
+  #
+  # Examples
+  #
+  #   RDoc::TomDoc.parse <<-TOMDOC
+  #   This method does some things
+  #
+  #   Returns nothing.
+  #   TOMDOC
+  #   # => #<RDoc::Markup::Document:0xXXX @parts=[...], @file=nil>
+  #
+  # Returns an RDoc::Markup::Document representing the TomDoc format.
+
+  def self.parse text
+    parser = new
+
+    parser.tokenize text
+    doc = RDoc::Markup::Document.new
+    parser.parse doc
+    doc
+  end
+
+  # Internal: Extracts the Signature section's method signature
+  #
+  # comment - An RDoc::Comment that will be parsed and have the signature
+  #           extracted
+  #
+  # Returns a String containing the signature and nil if not
+
+  def self.signature comment
+    return unless comment.tomdoc?
+
+    document = comment.parse
+
+    signature = nil
+    found_heading = false
+    found_signature = false
+
+    document.parts.delete_if do |part|
+      next false if found_signature
+
+      found_heading ||=
+        RDoc::Markup::Heading === part && part.text == 'Signature'
+
+      next false unless found_heading
+
+      next true if RDoc::Markup::BlankLine === part
+
+      if RDoc::Markup::Verbatim === part then
+        signature = part
+        found_signature = true
+      end
+    end
+
+    signature and signature.text
+  end
+
+  # Public: Creates a new TomDoc parser.  See also RDoc::Markup::parse
+
+  def initialize
+    super
+
+    @section      = nil
+    @seen_returns = false
+  end
+
+  # Internal: Builds a heading from the token stream
+  #
+  # level - The level of heading to create
+  #
+  # Returns an RDoc::Markup::Heading
+
+  def build_heading level
+    heading = super
+
+    @section = heading.text
+
+    heading
+  end
+
+  # Internal: Builds a verbatim from the token stream.  A verbatim in the
+  # Examples section will be marked as in Ruby format.
+  #
+  # margin - The indentation from the margin for lines that belong to this
+  #          verbatim section.
+  #
+  # Returns an RDoc::Markup::Verbatim
+
+  def build_verbatim margin
+    verbatim = super
+
+    verbatim.format = :ruby if @section == 'Examples'
+
+    verbatim
+  end
+
+  # Internal: Builds a paragraph from the token stream
+  #
+  # margin - Unused
+  #
+  # Returns an RDoc::Markup::Paragraph.
+
+  def build_paragraph margin
+    p :paragraph_start => margin if @debug
+
+    paragraph = RDoc::Markup::Paragraph.new
+
+    until @tokens.empty? do
+      type, data, = get
+
+      case type
+      when :TEXT then
+        @section = 'Returns' if data =~ /\AReturns/
+
+        paragraph << data
+      when :NEWLINE then
+        if :TEXT == peek_token[0] then
+          paragraph << ' '
+        else
+          break
+        end
+      else
+        unget
+        break
+      end
+    end
+
+    p :paragraph_end => margin if @debug
+
+    paragraph
+  end
+
+  ##
+  # Detects a section change to "Returns" and adds a heading
+
+  def parse_text parent, indent # :nodoc:
+    paragraph = build_paragraph indent
+
+    if false == @seen_returns and 'Returns' == @section then
+      @seen_returns = true
+      parent << RDoc::Markup::Heading.new(3, 'Returns')
+      parent << RDoc::Markup::BlankLine.new
+    end
+
+    parent << paragraph
+  end
+
+  # Internal: Turns text into an Array of tokens
+  #
+  # text - A String containing TomDoc-format text.
+  #
+  # Returns self.
+
+  def tokenize text
+    text.sub!(/\A(Public|Internal|Deprecated):\s+/, '')
+
+    setup_scanner text
+
+    until @s.eos? do
+      pos = @s.pos
+
+      # leading spaces will be reflected by the column of the next token
+      # the only thing we loose are trailing spaces at the end of the file
+      next if @s.scan(/ +/)
+
+      @tokens << case
+                 when @s.scan(/\r?\n/) then
+                   token = [:NEWLINE, @s.matched, *token_pos(pos)]
+                   @line_pos = char_pos @s.pos
+                   @line += 1
+                   token
+                 when @s.scan(/(Examples|Signature)$/) then
+                   @tokens << [:HEADER, 3, *token_pos(pos)]
+
+                   [:TEXT, @s[1], *token_pos(pos)]
+                 when @s.scan(/([:\w][\w\[\]]*)[ ]+- /) then
+                   [:NOTE, @s[1], *token_pos(pos)]
+                 else
+                   @s.scan(/.*/)
+                   [:TEXT, @s.matched.sub(/\r$/, ''), *token_pos(pos)]
+                 end
+    end
+
+    self
+  end
+
+end
+