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::CSEP, CodeObjects::CSEPQ, CodeObjects::ISEP, CodeObjects::ISEPQ, CodeObjects::METHODMATCH, CodeObjects::METHODNAMEMATCH, CodeObjects::NAMESPACEMATCH, CodeObjects::NSEP, CodeObjects::NSEPQ

Instance Attribute Summary

Attributes inherited from Base

#extra_state, #globals, #namespace, #owner, #parser, #scope, #statement, #visibility

Statement Matcher Extensions collapse

Testing for a Handler collapse

Parsing an Inner Block collapse

Macro Handling collapse

Methods included from Parser::Ruby

s

Methods inherited from Base

clear_subclasses, #ensure_loaded!, #expand_macro, #find_or_create_macro, handlers, handles, in_file, #initialize, matches_file?, namespace_only, namespace_only?, #process, process, #push_state, #register, subclasses

Constructor Details

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

Class Method Details

.handles?(node) ⇒ Boolean



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)


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


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
# File 'lib/yard/handlers/ruby/base.rb', line 141

def call_params
  return [] unless statement.respond_to?(:parameters)
  statement.parameters(false).map do |param|
    param.jump(:ident, :tstring_content).source
  end
end

#caller_methodObject



148
149
150
151
152
153
154
155
156
# File 'lib/yard/handlers/ruby/base.rb', line 148

def caller_method
  if statement.call?
    statement.method_name(true).to_s
  elsif statement.type == :var_ref || statement.type == :vcall
    statement[0].jump(:ident).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