# Class: YARD::Handlers::Ruby::MixinHandler

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

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

## Overview

Handles the ‘include’ statement to mixin a module in the instance scope

## Direct Known Subclasses

ExtendHandler

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

- #process_mixin(mixin) ⇒ Object protected
- #recipient(mixin) ⇒ Object protected

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

    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

    # File 'lib/yard/handlers/ruby/mixin_handler.rb', line 8

    process do
      errors = []
      statement.parameters(false).reverse.each do |mixin|
        begin
          process_mixin(mixin)
        rescue YARD::Parser::UndocumentableError => err
          errors << err.message
        end
      end
      unless errors.empty?
        msg = errors.size == 1 ? ": #{errors[0]}" : "s: #{errors.join(", ")}"
        raise YARD::Parser::UndocumentableError, "mixin#{msg} for class #{namespace.path}"
      end
    end

### #process_mixin(mixin) ⇒ `Object` (protected)

Raises:

- (`YARD::Parser::UndocumentableError`)

    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48

    # File 'lib/yard/handlers/ruby/mixin_handler.rb', line 25

    def process_mixin(mixin)
      raise YARD::Parser::UndocumentableError unless mixin.ref?
      raise YARD::Parser::UndocumentableError if mixin.first.type == :ident

      if mixin.type == :var_ref && mixin[0] == s(:kw, "self")
        obj = namespace
      else
        case obj = Proxy.new(namespace, mixin.source)
        when ConstantObject # If a constant is included, use its value as the real object
          obj = Proxy.new(namespace, obj.value, :module)
        else
          obj = Proxy.new(namespace, mixin.source, :module)
        end
      end

      rec = recipient(mixin)
      return if rec.nil?

      ensure_loaded!(rec)
      return if rec.mixins(scope).include?(obj)

      shift = statement.method_name(true) == :include ? :unshift : :push
      rec.mixins(scope).send(shift, obj)
    end

### #recipient(mixin) ⇒ `Object` (protected)

    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60

    # File 'lib/yard/handlers/ruby/mixin_handler.rb', line 50

    def recipient(mixin)
      if statement[0].type == :const_path_ref || statement[0].type == :top_const_ref
        Proxy.new(namespace, statement[0].source)
      elsif statement[0].type == :var_ref && statement[0][0] != s(:kw, "self")
        statement[0][0].type == :const ?
          Proxy.new(namespace, statement.namespace.source) :
          nil
      else
        namespace
      end
    end