rdoc-3.12 Documentation

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)

Creates a new AnyMethod with a token stream text and name

# File lib/rdoc/any_method.rb, line 33
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)

Adds an_alias as an alias for this method in context.

# File lib/rdoc/any_method.rb, line 44
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)

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 lib/rdoc/generator/markup.rb, line 88
def add_line_numbers(src)
  return unless src.sub!(%r\A(.*)(, line (\d+))/, '\1')
  first = $3.to_i - 1
  last  = first + src.count("\n")
  size = last.to_s.length

  line = first
  src.gsub!(%r^/) 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()

Prefix for aref is ‘method’.

# File lib/rdoc/any_method.rb, line 61
def aref_prefix
  'method'
end

arglists()

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 lib/rdoc/any_method.rb, line 70
def arglists
  if @call_seq then
    @call_seq
  elsif @params then
    "#{name}#{param_seq}"
  end
end

markup_code()

Turns the method’s token stream into HTML.

Prepends line numbers if add_line_numbers is true.

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

  src = RDoc::TokenStream.to_html @token_stream

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

  add_line_numbers(src) if self.class.add_line_numbers

  src
end

marshal_dump()

Dumps this AnyMethod for use by ri. See also marshal_load

# File lib/rdoc/any_method.rb, line 81
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)

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

# File lib/rdoc/any_method.rb, line 107
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 =~ %r#/ then
                   $`
                 else
                   name = @full_name.split('::')
                   name.pop
                   name.join '::'
                 end

  @file = RDoc::TopLevel.new array[10] if version > 0
end

name()

Method name

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

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

  @name = @call_seq[%r^.*?\.(\w+)/, 1] || @call_seq if @call_seq
end

param_list()

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

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

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

  params = params.gsub(%r\s+/, '').split ','

  params.map { |param| param.sub(%r=.*/, '') }
end

param_seq()

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

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

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

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

  params
end

/	Search
?	Show this help

Keyboard Shortcuts