voloko-sdoc 0.1.7 → 0.1.9

data/rdoc/lib/rdoc/include.rb

@@ -1,39 +0,0 @@
-require 'rdoc/code_object'
-
-##
-# A Module include in a class with \#include
-
-class RDoc::Include < RDoc::CodeObject
-
-  ##
-  # Name of included module
-
-  attr_accessor :name
-
-  ##
-  # Creates a new Include for +name+ with +comment+
-
-  def initialize(name, comment)
-    super()
-    @name = name
-    self.comment = comment
-  end
-
-  def inspect # :nodoc:
-    "#<%s:0x%x %s.include %s>" % [
-      self.class,
-      object_id,
-      parent_name, @name,
-    ]
-  end
-
-  ##
-  # Attempts to locate the included module object.  Returns the name if not
-  # known.
-
-  def module
-    RDoc::TopLevel.find_module_named(@name) || @name
-  end
-
-end
-

data/rdoc/lib/rdoc/known_classes.rb

@@ -1,68 +0,0 @@
-module RDoc
-
-  ##
-  # Ruby's built-in classes, modules and exceptions
-
-  KNOWN_CLASSES = {
-    "rb_cArray"            => "Array",
-    "rb_cBignum"           => "Bignum",
-    "rb_cClass"            => "Class",
-    "rb_cData"             => "Data",
-    "rb_cDir"              => "Dir",
-    "rb_cFalseClass"       => "FalseClass",
-    "rb_cFile"             => "File",
-    "rb_cFixnum"           => "Fixnum",
-    "rb_cFloat"            => "Float",
-    "rb_cHash"             => "Hash",
-    "rb_cIO"               => "IO",
-    "rb_cInteger"          => "Integer",
-    "rb_cModule"           => "Module",
-    "rb_cNilClass"         => "NilClass",
-    "rb_cNumeric"          => "Numeric",
-    "rb_cObject"           => "Object",
-    "rb_cProc"             => "Proc",
-    "rb_cRange"            => "Range",
-    "rb_cRegexp"           => "Regexp",
-    "rb_cRubyVM"           => "RubyVM",
-    "rb_cString"           => "String",
-    "rb_cStruct"           => "Struct",
-    "rb_cSymbol"           => "Symbol",
-    "rb_cThread"           => "Thread",
-    "rb_cTime"             => "Time",
-    "rb_cTrueClass"        => "TrueClass",
-
-    "rb_eArgError"         => "ArgError",
-    "rb_eEOFError"         => "EOFError",
-    "rb_eException"        => "Exception",
-    "rb_eFatal"            => "Fatal",
-    "rb_eFloatDomainError" => "FloatDomainError",
-    "rb_eIOError"          => "IOError",
-    "rb_eIndexError"       => "IndexError",
-    "rb_eInterrupt"        => "Interrupt",
-    "rb_eLoadError"        => "LoadError",
-    "rb_eNameError"        => "NameError",
-    "rb_eNoMemError"       => "NoMemError",
-    "rb_eNotImpError"      => "NotImpError",
-    "rb_eRangeError"       => "RangeError",
-    "rb_eRuntimeError"     => "RuntimeError",
-    "rb_eScriptError"      => "ScriptError",
-    "rb_eSecurityError"    => "SecurityError",
-    "rb_eSignal"           => "Signal",
-    "rb_eStandardError"    => "StandardError",
-    "rb_eSyntaxError"      => "SyntaxError",
-    "rb_eSystemCallError"  => "SystemCallError",
-    "rb_eSystemExit"       => "SystemExit",
-    "rb_eTypeError"        => "TypeError",
-    "rb_eZeroDivError"     => "ZeroDivError",
-
-    "rb_mComparable"       => "Comparable",
-    "rb_mEnumerable"       => "Enumerable",
-    "rb_mErrno"            => "Errno",
-    "rb_mFileTest"         => "FileTest",
-    "rb_mGC"               => "GC",
-    "rb_mKernel"           => "Kernel",
-    "rb_mMath"             => "Math",
-    "rb_mProcess"          => "Process"
-  }
-
-end

data/rdoc/lib/rdoc/markup/attribute_manager.rb

@@ -1,311 +0,0 @@
-require 'rdoc/markup/inline'
-
-##
-# Manages changes of attributes in a block of text
-
-class RDoc::Markup::AttributeManager
-
-  ##
-  # The NUL character
-
-  NULL = "\000".freeze
-
-  ##
-  # We work by substituting non-printing characters in to the text. For now
-  # I'm assuming that I can substitute a character in the range 0..8 for a 7
-  # bit character without damaging the encoded string, but this might be
-  # optimistic
-
-  A_PROTECT  = 004
-  PROTECT_ATTR  = A_PROTECT.chr
-
-  ##
-  # This maps delimiters that occur around words (such as *bold* or +tt+)
-  # where the start and end delimiters and the same. This lets us optimize
-  # the regexp
-
-  MATCHING_WORD_PAIRS = {}
-
-  ##
-  # And this is used when the delimiters aren't the same. In this case the
-  # hash maps a pattern to the attribute character
-
-  WORD_PAIR_MAP = {}
-
-  ##
-  # This maps HTML tags to the corresponding attribute char
-
-  HTML_TAGS = {}
-
-  ##
-  # And this maps _special_ sequences to a name. A special sequence is
-  # something like a WikiWord
-
-  SPECIAL = {}
-
-  ##
-  # Return an attribute object with the given turn_on and turn_off bits set
-
-  def attribute(turn_on, turn_off)
-    RDoc::Markup::AttrChanger.new turn_on, turn_off
-  end
-
-  def change_attribute(current, new)
-    diff = current ^ new
-    attribute(new & diff, current & diff)
-  end
-
-  def changed_attribute_by_name(current_set, new_set)
-    current = new = 0
-    current_set.each do |name|
-      current |= RDoc::Markup::Attribute.bitmap_for(name)
-    end
-
-    new_set.each do |name|
-      new |= RDoc::Markup::Attribute.bitmap_for(name)
-    end
-
-    change_attribute(current, new)
-  end
-
-  def copy_string(start_pos, end_pos)
-    res = @str[start_pos...end_pos]
-    res.gsub!(/\000/, '')
-    res
-  end
-
-  ##
-  # Map attributes like <b>text</b>to the sequence
-  # \001\002<char>\001\003<char>, where <char> is a per-attribute specific
-  # character
-
-  def convert_attrs(str, attrs)
-    # first do matching ones
-    tags = MATCHING_WORD_PAIRS.keys.join("")
-
-    re = /(^|\W)([#{tags}])([#:\\]?[\w.\/-]+?\S?)\2(\W|$)/
-
-    1 while str.gsub!(re) do
-      attr = MATCHING_WORD_PAIRS[$2]
-      attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
-      $1 + NULL * $2.length + $3 + NULL * $2.length + $4
-    end
-
-    # then non-matching
-    unless WORD_PAIR_MAP.empty? then
-      WORD_PAIR_MAP.each do |regexp, attr|
-        str.gsub!(regexp) {
-          attrs.set_attrs($`.length + $1.length, $2.length, attr)
-          NULL * $1.length + $2 + NULL * $3.length
-        }
-      end
-    end
-  end
-
-  ##
-  # Converts HTML tags to RDoc attributes
-
-  def convert_html(str, attrs)
-    tags = HTML_TAGS.keys.join '|'
-
-    1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
-      attr = HTML_TAGS[$1.downcase]
-      html_length = $1.length + 2
-      seq = NULL * html_length
-      attrs.set_attrs($`.length + html_length, $2.length, attr)
-      seq + $2 + seq + NULL
-    }
-  end
-
-  ##
-  # Converts special sequences to RDoc attributes
-
-  def convert_specials(str, attrs)
-    unless SPECIAL.empty?
-      SPECIAL.each do |regexp, attr|
-        str.scan(regexp) do
-          attrs.set_attrs($`.length, $&.length,
-                          attr | RDoc::Markup::Attribute::SPECIAL)
-        end
-      end
-    end
-  end
-
-  ##
-  # A \ in front of a character that would normally be processed turns off
-  # processing. We do this by turning \< into <#{PROTECT}
-
-  PROTECTABLE = %w[<\\]
-
-  ##
-  # Escapes special sequences of text to prevent conversion to RDoc
-
-  def mask_protected_sequences
-    protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
-    @str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
-  end
-
-  ##
-  # Unescapes special sequences of text
-
-  def unmask_protected_sequences
-    @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
-  end
-
-  ##
-  # Creates a new attribute manager that understands bold, emphasized and
-  # teletype text.
-
-  def initialize
-    add_word_pair("*", "*", :BOLD)
-    add_word_pair("_", "_", :EM)
-    add_word_pair("+", "+", :TT)
-
-    add_html("em", :EM)
-    add_html("i",  :EM)
-    add_html("b",  :BOLD)
-    add_html("tt",   :TT)
-    add_html("code", :TT)
-  end
-
-  ##
-  # Adds a markup class with +name+ for words wrapped in the +start+ and
-  # +stop+ character.  To make words wrapped with "*" bold:
-  #
-  #   am.add_word_pair '*', '*', :BOLD
-
-  def add_word_pair(start, stop, name)
-    raise ArgumentError, "Word flags may not start with '<'" if
-      start[0,1] == '<'
-
-    bitmap = RDoc::Markup::Attribute.bitmap_for name
-
-    if start == stop then
-      MATCHING_WORD_PAIRS[start] = bitmap
-    else
-      pattern = /(#{Regexp.escape start})(\S+)(#{Regexp.escape stop})/
-      WORD_PAIR_MAP[pattern] = bitmap
-    end
-
-    PROTECTABLE << start[0,1]
-    PROTECTABLE.uniq!
-  end
-
-  ##
-  # Adds a markup class with +name+ for words surrounded by HTML tag +tag+.
-  # To process emphasis tags:
-  #
-  #   am.add_html 'em', :EM
-
-  def add_html(tag, name)
-    HTML_TAGS[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
-  end
-
-  ##
-  # Adds a special handler for +pattern+ with +name+.  A simple URL handler
-  # would be:
-  #
-  #   @am.add_special(/((https?:)\S+\w)/, :HYPERLINK)
-
-  def add_special(pattern, name)
-    SPECIAL[pattern] = RDoc::Markup::Attribute.bitmap_for name
-  end
-
-  ##
-  # Processes +str+ converting attributes, HTML and specials
-
-  def flow(str)
-    @str = str
-
-    mask_protected_sequences
-
-    @attrs = RDoc::Markup::AttrSpan.new @str.length
-
-    convert_attrs(@str, @attrs)
-    convert_html(@str, @attrs)
-    convert_specials(str, @attrs)
-
-    unmask_protected_sequences
-
-    split_into_flow
-  end
-
-  ##
-  # Debug method that prints a string along with its attributes
-
-  def display_attributes
-    puts
-    puts @str.tr(NULL, "!")
-    bit = 1
-    16.times do |bno|
-      line = ""
-      @str.length.times do |i|
-        if (@attrs[i] & bit) == 0
-          line << " "
-        else
-          if bno.zero?
-            line << "S"
-          else
-            line << ("%d" % (bno+1))
-          end
-        end
-      end
-      puts(line) unless line =~ /^ *$/
-      bit <<= 1
-    end
-  end
-
-  def split_into_flow
-    res = []
-    current_attr = 0
-    str = ""
-
-    str_len = @str.length
-
-    # skip leading invisible text
-    i = 0
-    i += 1 while i < str_len and @str[i].chr == "\0"
-    start_pos = i
-
-    # then scan the string, chunking it on attribute changes
-    while i < str_len
-      new_attr = @attrs[i]
-      if new_attr != current_attr
-        if i > start_pos
-          res << copy_string(start_pos, i)
-          start_pos = i
-        end
-
-        res << change_attribute(current_attr, new_attr)
-        current_attr = new_attr
-
-        if (current_attr & RDoc::Markup::Attribute::SPECIAL) != 0 then
-          i += 1 while
-            i < str_len and (@attrs[i] & RDoc::Markup::Attribute::SPECIAL) != 0
-
-          res << RDoc::Markup::Special.new(current_attr,
-                                           copy_string(start_pos, i))
-          start_pos = i
-          next
-        end
-      end
-
-      # move on, skipping any invisible characters
-      begin
-        i += 1
-      end while i < str_len and @str[i].chr == "\0"
-    end
-
-    # tidy up trailing text
-    if start_pos < str_len
-      res << copy_string(start_pos, str_len)
-    end
-
-    # and reset to all attributes off
-    res << change_attribute(current_attr, 0) if current_attr != 0
-
-    res
-  end
-
-end
-

data/rdoc/lib/rdoc/markup/formatter.rb

@@ -1,25 +0,0 @@
-require 'rdoc/markup'
-
-##
-# Base class for RDoc markup formatters
-#
-# Formatters use a visitor pattern to convert content into output.
-
-class RDoc::Markup::Formatter
-
-  ##
-  # Creates a new Formatter
-
-  def initialize
-    @markup = RDoc::Markup.new
-  end
-
-  ##
-  # Marks up +content+
-
-  def convert(content)
-    @markup.convert content, self
-  end
-
-end
-