Class: AttributeHandler

Inherits:
YARD::Handlers::Ruby::AttributeHandler
  • Object
show all
Defined in:
lib/yard/attribute_handler.rb

Instance Method Summary collapse

Instance Method Details

#node_exists?(ast_node, jumps) ⇒ <Type>

Checks whether a node exists at the given jumps

Parameters:

  • ast_node (<AstNode>) —

    A YARD::Parser::Ruby::AstNode

  • jumps ([<Symbol>]) —

    array of AST node types that should match

Returns:

  • (<Type>) —

    <description>



62
63
64
65
 
# File 'lib/yard/attribute_handler.rb', line 62

def node_exists?(ast_node, jumps)
  jumped = walk(ast_node, jumps)
  !!jumped
end

#process ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/yard/attribute_handler.rb', line 5

def process
  params = statement.parameters(false).dup
  options = params.pop if params.last.type == :list

  validated_attribute_names(params).each do |name|
    namespace.attributes[scope][name] ||= SymbolHash[:read => nil, :write => nil]

    object = MethodObject.new(namespace, name, scope)
    object.file = statement.file
    object.source = statement.source
    register(object)

    if options.first.jump(:label).source == "type:"
      return_type = options.first.jump(:const).source
    end

    return_type = "String"
    desc = ""

    options.each do |option|
      if option.jump(:label).source == "desc:"
        desc = option.jump(:string_content).source
      end

      if option.jump(:label).source == "type:"
        if node_exists?(option, [:var_ref, :const])
          return_type = option.source.sub(/^type: /, "")
        elsif node_exists?(option, [:assoc, :symbol_literal])
          return_type = walk(option, [:assoc, :symbol_literal, :ident]).source.capitalize
        end

        if node_exists?(option, [:arg_paren])
          return_type = "[#{return_type.sub(/\AArray\(/,"").sub(/\)\z/, "")}]"
        end
      end
    end

    object.docstring = desc.gsub(/\n/, " ") if desc

    # tags must be added after the docstring
    object.add_tag(
      YARD::Tags::Tag.new(:return, nil, return_type)
    )

    # Register the object explicitly
    namespace.attributes[scope][name][:read] = object
  end
end

#walk(ast_node, jumps) ⇒ <AstNode, nil>

Recusively ‘jump`s the AstNode node to find a node that matches all provided jumps. Returns nil if node is not found.

In constast ‘jump` will return any node that matches any of the provided jumps and return the original node if there are no matches.

Parameters:

  • ast_node (<AstNode>) —

    A YARD::Parser::Ruby::AstNode

  • jumps ([<Symbol>]) —

    through array of AST node types to walk

Returns:

  • (<AstNode, nil>) —

    the requested node or nil



81
82
83
84
85
86
 
# File 'lib/yard/attribute_handler.rb', line 81

def walk(ast_node, jumps)
  jumps = Array(jumps)
  node = jumps.inject(ast_node) { |o, j| o.jump(j) }

  return node if node != ast_node
end