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

Inherits:
  Handlers::Base
  - Object
  - Handlers::Base
  - YARD::Handlers::Ruby::Base
  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:

- Base
- Legacy::Base

## Direct Known Subclasses

AliasHandler, AttributeHandler, ClassConditionHandler, ClassHandler, ClassVariableHandler, CommentHandler, ConstantHandler, DSLHandler, ExceptionHandler, MethodConditionHandler, MethodHandler, MixinHandler, ModuleFunctionHandler, ModuleHandler, PrivateClassMethodHandler, PrivateConstantHandler, PublicClassMethodHandler, VisibilityHandler, YieldHandler

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

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

## Macro Handling collapse

- #call_params ⇒ Object
- #caller_method ⇒ Object

### Methods included from Parser::Ruby

s

## Class Method Details

### .handles?(node) ⇒ `Boolean`

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

Returns:

- (`Boolean`) —

  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”.

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