class YARD::Handlers::Ruby::Base

This is the base handler class for the new-style (1.9) Ruby parser. All handlers that subclass this base class will be used when the new-style parser is used. For implementing legacy handlers, see {Legacy::Base}.

@abstract See {Handlers::Base} for subclassing information. @see Handlers::Base @see Legacy::Base

Public Class Methods

handles?(node) click to toggle source

@return [Boolean] whether or not an {AstNode} object should be

handled by this handler
# File lib/yard/handlers/ruby/base.rb, line 110
def handles?(node)
  handlers.any? do |a_handler|
    case a_handler
    when Symbol
      a_handler == node.type
    when String
      node.source == a_handler
    when Regexp
      node.source =~ a_handler
    when Parser::Ruby::AstNode
      a_handler == node
    when HandlesExtension
      a_handler.matches?(node)
    end
  end
end
meta_type(type) click to toggle source

Matcher for handling a node with a specific meta-type. An {AstNode} has a {AstNode#type} to define its type but can also be associated with a set of types. For instance, :if and :unless are both of the meta-type :condition.

A meta-type is any method on the {AstNode} class ending in “?”, though you should not include the “?” suffix in your declaration. Some examples are: “condition”, “call”, “literal”, “kw”, “token”, “ref”.

@example Handling any conditional statement (if, unless)

handles meta_type(:condition)

@param [Symbol] type the meta-type to match. A meta-type can be

any method name + "?" that {AstNode} responds to.

@return [void]

# File lib/yard/handlers/ruby/base.rb, line 102
def meta_type(type)
  TestNodeWrapper.new(type.to_s + "?")
end
method_call(name = nil) click to toggle source

Matcher for handling any type of method call. Method calls can be expressed by many {AstNode} types depending on the syntax with which it is called, so YARD allows you to use this matcher to simplify matching a method call.

@example Match the “describe” method call

handles method_call(:describe)

# The following will be matched:
# describe(...)
# object.describe(...)
# describe "argument" do ... end

@param [#to_s] name matches the method call of this name @return [void]

# File lib/yard/handlers/ruby/base.rb, line 83
def method_call(name = nil)
  MethodCallWrapper.new(name ? name.to_s : nil)
end

Public Instance Methods

call_params() click to toggle source

@group Macro Handling

# File lib/yard/handlers/ruby/base.rb, line 141
def call_params
  return [] unless statement.respond_to?(:parameters)
  statement.parameters(false).compact.map do |param|
    if param.type == :list
      param.map {|n| n.jump(:ident, :kw, :tstring_content).source }
    else
      param.jump(:ident, :kw, :tstring_content).source
    end
  end.flatten
end
caller_method() click to toggle source
# File lib/yard/handlers/ruby/base.rb, line 152
def caller_method
  if statement.call? || statement.def?
    statement.method_name(true).to_s
  elsif statement.type == :var_ref || statement.type == :vcall
    statement[0].jump(:ident, :kw).source
  else
    nil
  end
end
parse_block(inner_node, opts = {}) click to toggle source

@group Parsing an Inner Block

# File lib/yard/handlers/ruby/base.rb, line 132
def parse_block(inner_node, opts = {})
  push_state(opts) do
    nodes = inner_node.type == :list ? inner_node.children : [inner_node]
    parser.process(nodes)
  end
end