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

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please see Improve the docs, or visit Documenting-ruby.org.

Home Classes Methods

In Files

Parent

Methods

Included Modules

Class/Module Index

RDoc::AnyMethod

Attributes

Public Class Methods

Public Instance Methods