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

Inherits:

Base

• Object
• Base
• YARD::Handlers::Ruby::Base

show all

Extended by:

Parser::Ruby

Includes:

Parser::Ruby

Defined in:

lib/yard/handlers/ruby/base.rb

Overview

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 (collapse)

• - (Object) extra_state inherited from Base readonly

  Returns the value of attribute extra_state.

• - (Object) globals inherited from Base readonly

  Returns the value of attribute globals.

• - (Object) namespace inherited from Base

  Returns the value of attribute namespace.

• - (Object) owner inherited from Base

  Returns the value of attribute owner.

• - (Processor) parser inherited from Base readonly

  The processor object that manages all global state during handling.

• - (Object) scope inherited from Base

  Returns the value of attribute scope.

• - (Object) statement inherited from Base readonly

  The statement object currently being processed.

• - (Object) visibility inherited from Base

  Returns the value of attribute visibility.

Statement Matcher Extensions (collapse)

• + (void) meta_type(type)

  Matcher for handling a node with a specific meta-type.

• + (void) method_call(name = nil)

  Matcher for handling any type of method call.

Testing for a Handler (collapse)

• + (Boolean) handles?(node)

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

Parsing an Inner Block (collapse)

• - (Object) parse_block(inner_node, opts = {})

Macro Handling (collapse)

• - (Object) call_params
• - (Object) caller_method

Methods included from Parser::Ruby

s

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

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

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

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

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

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