Class: YARD::Handlers::Ruby::Base Abstract

Inherits:
Base
  • Object
show all
Extended by:
Parser::Ruby
Includes:
Parser::Ruby
Defined in:
lib/yard/handlers/ruby/base.rb

Overview

This class is abstract.

See Base for subclassing information.

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.

See Also:

Constant Summary

Constants included from CodeObjects

CodeObjects::BUILTIN_ALL, CodeObjects::BUILTIN_CLASSES, CodeObjects::BUILTIN_EXCEPTIONS, CodeObjects::BUILTIN_EXCEPTIONS_HASH, CodeObjects::BUILTIN_MODULES, CodeObjects::CONSTANTMATCH, CodeObjects::CONSTANTSTART, CodeObjects::CSEP, CodeObjects::CSEPQ, CodeObjects::ISEP, CodeObjects::ISEPQ, CodeObjects::METHODMATCH, CodeObjects::METHODNAMEMATCH, CodeObjects::NAMESPACEMATCH, CodeObjects::NSEP, CodeObjects::NSEPQ

Statement Matcher Extensions collapse

Testing for a Handler collapse

Parsing an Inner Block collapse

Macro Handling collapse

Methods included from Parser::Ruby

s

Methods included from CodeObjects::NamespaceMapper

#clear_separators, #default_separator, #register_separator, #separators, #separators_for_type, #separators_match, #types_for_separator

Constructor Details

This class inherits a constructor from YARD::Handlers::Base

Class Method Details

.handles?(node) ⇒ Boolean

Returns whether or not an Parser::Ruby::AstNode object should be handled by this handler

Returns:



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
# File 'lib/yard/handlers/ruby/base.rb', line 113

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) ⇒ void

This method returns an undefined value.

Matcher for handling a node with a specific meta-type. An Parser::Ruby::AstNode has a Parser::Ruby::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 Parser::Ruby::AstNode class ending in “?”, though you should not include the “?” suffix in your declaration. Some examples are: “condition”, “call”, “literal”, “kw”, “token”, “ref”.

Examples:

Handling any conditional statement (if, unless)

handles meta_type(:condition)

Parameters:

  • type (Symbol)

    the meta-type to match. A meta-type can be any method name + “?” that Parser::Ruby::AstNode responds to.



105
106
107
# File 'lib/yard/handlers/ruby/base.rb', line 105

def meta_type(type)
  TestNodeWrapper.new(type.to_s + "?")
end

.method_call(name = nil) ⇒ void

This method returns an undefined value.

Matcher for handling any type of method call. Method calls can be expressed by many Parser::Ruby::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.

Examples:

Match the “describe” method call

handles method_call(:describe)

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

Parameters:

  • name (#to_s) (defaults to: nil)

    matches the method call of this name



86
87
88
# File 'lib/yard/handlers/ruby/base.rb', line 86

def method_call(name = nil)
  MethodCallWrapper.new(name ? name.to_s : nil)
end

Instance Method Details

#call_paramsObject



144
145
146
147
148
149
150
151
152
153
# File 'lib/yard/handlers/ruby/base.rb', line 144

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_methodObject



155
156
157
158
159
160
161
# File 'lib/yard/handlers/ruby/base.rb', line 155

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
  end
end

#parse_block(inner_node, opts = {}) ⇒ Object



135
136
137
138
139
140
# File 'lib/yard/handlers/ruby/base.rb', line 135

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