Class: YARD::Handlers::Ruby::Base Abstract
Overview
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.
Direct Known Subclasses
AliasHandler, AttributeHandler, ClassConditionHandler, ClassHandler, ClassVariableHandler, CommentHandler, ConstantHandler, DSLHandler, ExceptionHandler, MethodConditionHandler, MethodHandler, MixinHandler, ModuleFunctionHandler, ModuleHandler, PrivateClassMethodHandler, PrivateConstantHandler, PublicClassMethodHandler, VisibilityHandler, YieldHandler
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
-
.meta_type(type) ⇒ void
Matcher for handling a node with a specific meta-type.
-
.method_call(name = nil) ⇒ void
Matcher for handling any type of method call.
Testing for a Handler collapse
-
.handles?(node) ⇒ Boolean
Whether or not an Parser::Ruby::AstNode object should be handled by this handler.
Parsing an Inner Block collapse
Macro Handling collapse
Methods included from Parser::Ruby
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.
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”.
105 106 107 |
# File 'lib/yard/handlers/ruby/base.rb', line 105 def (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.
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_params ⇒ Object
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_method ⇒ Object
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 |