In Files

  • rdoc/any_method.rb

Class/Module Index [+]

Quicksearch

RDoc::AnyMethod

AnyMethod is the base class for objects representing methods

Attributes

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

calls_super[RW]

If true this method uses super to call a superclass version

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 45
def initialize text, name
  super

  @c_function = nil
  @dont_rename_initialize = false
  @token_stream = nil
  @calls_super = false
  @superclass_method = 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 58
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
            
aref_prefix() click to toggle source

Prefix for aref is ‘method’.

 
               # File rdoc/any_method.rb, line 75
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 84
def arglists
  if @call_seq then
    @call_seq
  elsif @params then
    "#{name}#{param_seq}"
  end
end
            
marshal_dump() click to toggle source

Dumps this AnyMethod for use by ri. See also marshal_load

 
               # File rdoc/any_method.rb, line 95
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.relative_name,
    @calls_super,
    @parent.name,
    @parent.class,
    @section.title,
  ]
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 125
def marshal_load array
  initialize_visibility

  @dont_rename_initialize = nil
  @is_alias_for           = nil
  @token_stream           = nil
  @aliases                = []
  @parent                 = nil
  @parent_name            = nil
  @parent_class           = nil
  @section                = nil
  @file                   = nil

  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]
  #                      8 handled below
  @params        = array[9]
  #                      10 handled below
  @calls_super   = array[11]
  @parent_name   = array[12]
  @parent_title  = array[13]
  @section_title = array[14]

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

  @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 174
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 184
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 = params.gsub(/\s+/, '').split ','

  params.map { |param| param.sub(/=.*/, '') }
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 208
def param_seq
  if @call_seq then
    params = @call_seq.split("\n").last
    params = params.sub(/[^( ]+/, '')
    params = params.sub(/(\|[^|]+\|)\s*\.\.\.\s*(end|\})/, '\1 \2')
  elsif @params then
    params = @params.gsub(/\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!(/,?\s*&\w+/, '')

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

  params
end
            
store=(store) click to toggle source

Sets the store for this method and its referenced code objects.

 
               # File rdoc/any_method.rb, line 240
def store= store
  super

  @file = @store.add_file @file.full_name if @file
end
            
superclass_method() click to toggle source

For methods that super, find the superclass method that would be called.

 
               # File rdoc/any_method.rb, line 249
def superclass_method
  return unless @calls_super
  return @superclass_method if @superclass_method

  parent.each_ancestor do |ancestor|
    if method = ancestor.method_list.find { |m| m.name == @name } then
      @superclass_method = method
      break
    end
  end

  @superclass_method
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 visit Documenting-ruby.org.

blog comments powered by Disqus