# Class: YARD::Handlers::Ruby::AttributeHandler

Inherits:
  Base
  - Object
  - Base
  - Base
  - YARD::Handlers::Ruby::AttributeHandler
  show all

Defined in:
  lib/yard/handlers/ruby/attribute_handler.rb

## Overview

Handles `attr_*` statements in modules/classes

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

## Instance Method Summary collapse

- #process ⇒ void

  Main processing callback.

- #validated_attribute_names(params) ⇒ Array<String> protected

  Strips out any non-essential arguments from the attr statement.

### Methods included from Parser::Ruby

#s

### Methods included from CodeObjects::NamespaceMapper

#clear_separators, #default_separator, on_invalidate, #register_separator, #separators, #separators_for_type, #separators_match, #types_for_separator, #unregister_separator_by_type

## Constructor Details

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

## Instance Method Details

### #process ⇒ `void`

This method returns an undefined value.

Main processing callback

    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
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65

    # File 'lib/yard/handlers/ruby/attribute_handler.rb', line 10

    process do
      return if statement.type == :var_ref || statement.type == :vcall
      read = true
      write = false
      params = statement.parameters(false).dup

      # Change read/write based on attr_reader/writer/accessor
      case statement.method_name(true)
      when :attr
        # In the case of 'attr', the second parameter (if given) isn't a symbol.
        if params.size == 2
          write = true if params.pop == s(:var_ref, s(:kw, "true"))
        end
      when :attr_accessor
        write = true
      when :attr_reader
        # change nothing
      when :attr_writer
        read = false
        write = true
      end

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

        # Show their methods as well
        {:read => name, :write => "#{name}="}.each do |type, meth|
          if type == :read ? read : write
            o = MethodObject.new(namespace, meth, scope)
            if type == :write
              o.parameters = [['value', nil]]
              src = "def #{meth}(value)"
              full_src = "#{src}\n  @#{name} = value\nend"
              doc = "Sets the attribute #{name}\n@param value the value to set the attribute #{name} to."
            else
              src = "def #{meth}"
              full_src = "#{src}\n  @#{name}\nend"
              doc = "Returns the value of attribute #{name}."
            end
            o.source ||= full_src
            o.signature ||= src
            register(o)
            o.docstring = doc if o.docstring.blank?(false)

            # Register the object explicitly
            namespace.attributes[scope][name][type] = o
          else
            obj = namespace.children.find {|other| other.name == meth.to_sym && other.scope == scope }

            # register an existing method as attribute
            namespace.attributes[scope][name][type] = obj if obj
          end
        end
      end
    end

### #validated_attribute_names(params) ⇒ `Array<String>` (protected)

Strips out any non-essential arguments from the attr statement.

Parameters:

- params (`Array<Parser::Ruby::AstNode>`) —

  a list of the parameters in the attr call.

Returns:

- (`Array<String>`) —

  the validated attribute names

Raises:

- (`Parser::UndocumentableError`) —

  if the arguments are not valid.

    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86

    # File 'lib/yard/handlers/ruby/attribute_handler.rb', line 75

    def validated_attribute_names(params)
      params.map do |obj|
        case obj.type
        when :symbol_literal
          obj.jump(:ident, :op, :kw, :const).source
        when :string_literal
          obj.jump(:string_content).source
        else
          raise YARD::Parser::UndocumentableError, obj.source
        end
      end
    end