# class 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 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) click to toggle source

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) 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 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() click to toggle source

Prefix for `aref` is ‘method’.

    # File lib/rdoc/any_method.rb, line 61
    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 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() click to toggle source

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() click to toggle source

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) click to toggle source

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

- full_name

- parent_name

    # 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() click to toggle source

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() 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 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() 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 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