In Files

  • rdoc/any_method.rb
  • rdoc/generator/markup.rb

Class/Module Index [+]

Quicksearch

RDoc::AnyMethod

AnyMethod is the base class for objects representing methods

Attributes

add_line_numbers[RW]

Allows controlling whether #markup_code adds line numbers to the source code.

c_function[RW]

The C function that implements this method (if it was defined in a C file)

call_seq[RW]

Different ways to call this method

dont_rename_initialize[RW]

Don't rename #initialize to ::new

params[RW]

Parameters for this method

Public Class Methods

new(text, name) click to toggle source

Creates a new AnyMethod with a token stream text and name

 
               # File rdoc/any_method.rb, line 36
def initialize text, name
  super

  @c_function = nil
  @dont_rename_initialize = false
  @token_stream = nil
end
            

Public Instance Methods

add_alias(an_alias, context = nil) click to toggle source

Adds an_alias as an alias for this method in context.

 
               # File rdoc/any_method.rb, line 47
def add_alias an_alias, context = nil
  method = self.class.new an_alias.text, an_alias.new_name

  method.record_location an_alias.file
  method.singleton = self.singleton
  method.params = self.params
  method.visibility = self.visibility
  method.comment = an_alias.comment
  method.is_alias_for = self
  @aliases << method
  context.add_method method if context
  method
end
            
add_line_numbers(src) click to toggle source

Prepend src with line numbers. Relies on the first line of a source code listing having:

# File xxxxx, line dddd

If it has, line numbers are added an ', line dddd' is removed.

 
               # File rdoc/generator/markup.rb, line 87
def add_line_numbers(src)
  return unless src.sub!(/\A(.*)(, line (\d+))/, '\1')
  first = $3.to_i - 1
  last  = first + src.count("\n")
  size = last.to_s.length

  line = first
  src.gsub!(/^/) do
    res = if line == first then
            " " * (size + 1)
          else
            "<span class=\"line-num\">%2$*1$d</span> " % [size, line]
          end

    line += 1
    res
  end
end
            
aref_prefix() click to toggle source

Prefix for aref is 'method'.

 
               # File rdoc/any_method.rb, line 64
def aref_prefix
  'method'
end
            
arglists() click to toggle source

The #call_seq or the #param_seq with method name, if there is no call_seq.

Use this for displaying a method's argument lists.

 
               # File rdoc/any_method.rb, line 73
def arglists
  if @call_seq then
    @call_seq
  elsif @params then
    "#{name}#{param_seq}"
  end
end
            
markup_code() click to toggle source

Turns the method's token stream into HTML.

Prepends line numbers if add_line_numbers is true.

 
               # File rdoc/generator/markup.rb, line 111
def markup_code
  return '' unless @token_stream

  src = ""

  @token_stream.each 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
      src << "<span class=\"#{style}\">#{text}</span>"
    else
      src << text
    end
  end

  # dedent the source
  indent = src.length
  lines = src.lines.to_a
  lines.shift if src =~ /\A.*#\ *File/ # remove '# File' comment
  lines.each do |line|
    if line =~ /^ *(?=\S)/
      n = $&.length
      indent = n if n < indent
      break if n == 0
    end
  end
  src.gsub!(/^#{' ' * indent}/, '') if indent > 0

  add_line_numbers(src) if self.class.add_line_numbers

  src
end
            
marshal_dump() click to toggle source

Dumps this AnyMethod for use by ri. See also marshal_load

 
               # File rdoc/any_method.rb, line 84
def marshal_dump
  aliases = @aliases.map do |a|
    [a.name, parse(a.comment)]
  end

  [ MARSHAL_VERSION,
    @name,
    full_name,
    @singleton,
    @visibility,
    parse(@comment),
    @call_seq,
    @block_params,
    aliases,
    @params,
    @file.absolute_name,
  ]
end
            
marshal_load(array) click to toggle source

Loads this AnyMethod from array. For a loaded AnyMethod the following methods will return cached values:

 
               # File rdoc/any_method.rb, line 110
def marshal_load(array)
  @dont_rename_initialize = nil
  @is_alias_for           = nil
  @token_stream           = nil
  @aliases                = []

  version       = array[0]
  @name         = array[1]
  @full_name    = array[2]
  @singleton    = array[3]
  @visibility   = array[4]
  @comment      = array[5]
  @call_seq     = array[6]
  @block_params = array[7]

  array[8].each do |new_name, comment|
    add_alias RDoc::Alias.new(nil, @name, new_name, comment, @singleton)
  end

  @params       = array[9]

  @parent_name = if @full_name =~ /#/ then
                   $`
                 else
                   name = @full_name.split('::')
                   name.pop
                   name.join '::'
                 end

  @file = RDoc::TopLevel.new array[10] if version > 0
end
            
name() click to toggle source

Method name

If the method has no assigned name, it extracts it from call_seq.

 
               # File rdoc/any_method.rb, line 147
def name
  return @name if @name

  @name = @call_seq[/^.*?\.(\w+)/, 1] || @call_seq if @call_seq
end
            
param_list() click to toggle source

A list of this method's method and yield parameters. call-seq params are preferred over parsed method and block params.

 
               # File rdoc/any_method.rb, line 157
def param_list
  if @call_seq then
    params = @call_seq.split("\n").last
    params = params.sub(/.*?\((.*)\)/, '\1')
    params = params.sub(/(\{|do)\s*\|([^|]*)\|.*/, ',\2')
  elsif @params then
    params = @params.sub(/\((.*)\)/, '\1')

    params << ",#{@block_params}" if @block_params
  elsif @block_params then
    params = @block_params
  else
    return []
  end

  params.gsub(/\s+/, '').split ','
end
            
param_seq() click to toggle source

Pretty parameter list for this method. If the method's parameters were given by call-seq it is preferred over the parsed values.

 
               # File rdoc/any_method.rb, line 179
def param_seq
  if @call_seq then
    params = @call_seq.split("\n").last
    params = params.sub(/[^( ]+/, '')
    params = params.sub(/(\|[^|]+\|)\s*\.\.\.\s*(end|\})/, '\1 \2')
  else
    params = @params.gsub(/\s*\#.*/, '')
    params = params.tr("\n", " ").squeeze(" ")
    params = "(#{params})" unless params[0] == (
  end

  if @block_params then
    # If this method has explicit block parameters, remove any explicit
    # &block
    params.sub!(/,?\s*&\w+/, '')

    block = @block_params.gsub(/\s*\#.*/, '')
    block = block.tr("\n", " ").squeeze(" ")
    if block[0] == (
      block.sub!(/^\(/, '').sub!(/\)/, '')
    end
    params << " { |#{block}| ... }"
  end

  params
end