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

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

Instance Attribute Summary collapse

Statement Matcher Extensions collapse

Testing for a Handler collapse

Parsing an Inner Block collapse

Macro Handling collapse

Methods included from Parser::Ruby

s

Constructor Details

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

Instance Attribute Details

#extra_stateObject (readonly) Originally defined in class Base

Returns the value of attribute extra_state

#globalsObject (readonly) Originally defined in class Base

Returns the value of attribute globals

#namespaceObject Originally defined in class Base

Returns the value of attribute namespace

#ownerObject Originally defined in class Base

Returns the value of attribute owner

#parserProcessor (readonly) Originally defined in class Base

Returns the processor object that manages all global state during handling.

Returns:

  • (Processor)

    the processor object that manages all global state during handling.

#scopeObject Originally defined in class Base

Returns the value of attribute scope

#statementObject (readonly) Originally defined in class Base

Returns the statement object currently being processed. Usually refers to one semantic language statement, though the strict definition depends on the parser used.

Returns:

  • (Object)

    the statement object currently being processed. Usually refers to one semantic language statement, though the strict definition depends on the parser used.

#visibilityObject Originally defined in class Base

Returns the value of attribute visibility

Class Method Details

.handles?(node) ⇒ Boolean

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

Returns:



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
# 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) ⇒ 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.



102
103
104
# File 'lib/yard/handlers/ruby/base.rb', line 102

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



83
84
85
# File 'lib/yard/handlers/ruby/base.rb', line 83

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

Instance Method Details

#call_paramsObject



141
142
143
144
145
146
147
148
149
150
# 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_methodObject



152
153
154
155
156
157
158
159
160
# 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 = {}) ⇒ Object



132
133
134
135
136
137
# 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