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
@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
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
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
@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
# 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
@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