# Class: YARD::Handlers::Base Abstract

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

Includes:
  CodeObjects, Parser

Defined in:
  lib/yard/handlers/base.rb

## Overview

This class is abstract.

Subclass this class to provide a handler for YARD to use during the processing phase.

Handlers are pluggable semantic parsers for YARD’s code generation phase. They allow developers to control what information gets generated by YARD, giving them the ability to, for instance, document any Ruby DSLs that a customized framework may use. A good example of this would be the ability to document and generate meta data for the ‘describe’ declaration of the RSpec testing framework by simply adding a handler for such a keyword. Similarly, any Ruby API that takes advantage of class level declarations could add these to the documentation in a very explicit format by treating them as first- class objects in any outputted documentation.

## Overview of a Typical Handler Scenario

Generally, a handler class will declare a set of statements which it will handle using the Base.handles class declaration. It will then implement the #process method to do the work. The processing would usually involve the manipulation of the #namespace, #owner code objects or the creation of new ones, in which case they should be registered by #register, a method that sets some basic attributes for the new objects.

Handlers are usually simple and take up to a page of code to process and register a new object or add new attributes to the current `namespace`.

## Setting up a Handler for Use

A Handler is automatically registered when it is subclassed from the base class. The only other thing that needs to be done is to specify which statement the handler will process. This is done with the `handles` declaration, taking either a Parser::Ruby::Legacy::RubyToken, String or ‘Regexp`. Here is a simple example which processes module statements.

    class MyModuleHandler < YARD::Handlers::Base
      handles TkMODULE

      def process
        # do something
      end
    end

## Processing Handler Data

The goal of a specific handler is really up to the developer, and as such there is no real guideline on how to process the data. However, it is important to know where the data is coming from to be able to use it.

### `statement` Attribute

The `statement` attribute pertains to the Parser::Ruby::Legacy::Statement object containing a set of tokens parsed in by the parser. This is the main set of data to be analyzed and processed. The comments attached to the statement can be accessed by the Parser::Ruby::Legacy::Statement#comments method, but generally the data to be processed will live in the `tokens` attribute. This list can be converted to a `String` using `#to_s` to parse the data with regular expressions (or other text processing mechanisms), if needed.

### `namespace` Attribute

The `namespace` attribute is a namespace object which represents the current namespace that the parser is in. For instance:

    module SomeModule
      class MyClass
        def mymethod; end
      end
    end

If a handler was to parse the ‘class MyClass’ statement, it would be necessary to know that it belonged inside the SomeModule module. This is the value that `namespace` would return when processing such a statement. If the class was then entered and another handler was called on the method, the `namespace` would be set to the ‘MyClass’ code object.

### `owner` Attribute

The `owner` attribute is similar to the `namespace` attribute in that it also follows the scope of the code during parsing. However, a namespace object is loosely defined as a module or class and YARD has the ability to parse beyond module and class blocks (inside methods, for instance), so the `owner` attribute would not be limited to modules and classes.

To put this into context, the example from above will be used. If a method handler was added to the mix and decided to parse inside the method body, the `owner` would be set to the method object but the namespace would remain set to the class. This would allow the developer to process any method definitions set inside a method (def x; def y; 2 end end) by adding them to the correct namespace (the class, not the method).

In summary, the distinction between `namespace` and `owner` can be thought of as the difference between first-class Ruby objects (namespaces) and second-class Ruby objects (methods).

### `visibility` and `scope` Attributes

Mainly needed for parsing methods, the `visibility` and `scope` attributes refer to the public/protected/private and class/instance values (respectively) of the current parsing position.

## Parsing Blocks in Statements

In addition to parsing a statement and creating new objects, some handlers may wish to continue parsing the code inside the statement’s block (if there is one). In this context, a block means the inside of any statement, be it class definition, module definition, if statement or classic ‘Ruby block’.

For example, a class statement would be “class MyClass” and the block would be a list of statements including the method definitions inside the class. For a class handler, the programmer would execute the #parse_block method to continue parsing code inside the block, with the `namespace` now pointing to the class object the handler created.

YARD has the ability to continue into any block: class, module, method, even if statements. For this reason, the block parsing method must be invoked explicitly out of efficiency sake.

See Also:

- CodeObjects::Base
- CodeObjects::NamespaceObject
- Base.handles
- #namespace
- #owner
- #register
- #parse_block

## Direct Known Subclasses

C::Base, Ruby::Base, Ruby::Legacy::Base

## 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 Attribute Summary collapse

- #extra_state ⇒ Object readonly

  Returns the value of attribute extra_state.

- #globals ⇒ Object readonly

  Returns the value of attribute globals.

- #namespace ⇒ Object

  Returns the value of attribute namespace.

- #owner ⇒ Object

  Returns the value of attribute owner.

- #parser ⇒ Processor readonly

  The processor object that manages all global state during handling.

- #scope ⇒ Object

  Returns the value of attribute scope.

- #statement ⇒ Object readonly

  The statement object currently being processed.

- #visibility ⇒ Object

  Returns the value of attribute visibility.

## Macro Support collapse

- #call_params ⇒ Array<String> abstract

  A list of argument names.

- #caller_method ⇒ String? abstract

## Class Method Summary collapse

- .clear_subclasses ⇒ void

  Clear all registered subclasses.

- .handlers ⇒ Array

  A list of matchers for the handler object.

- .handles(*matches) ⇒ Object

  Declares the statement type which will be processed by this handler.

- .handles?(statement) ⇒ Boolean

  This class is implemented by Ruby::Base and Ruby::Legacy::Base.

- .in_file(filename) ⇒ void

  Declares that a handler should only be called when inside a filename by its basename or a regex match for the full path.

- .matches_file?(filename) ⇒ Boolean

  Whether the filename matches the declared file match for a handler.

- .namespace_only ⇒ void

  Declares that the handler should only be called when inside a CodeObjects::NamespaceObject, not a method body.

- .namespace_only? ⇒ Boolean

  Whether the handler should only be processed inside a namespace.

- .process(&block) ⇒ void

  Generates a `process` method, equivalent to +def process; …

- .subclasses ⇒ Array<Base>

  Returns all registered handler subclasses.

## Instance Method Summary collapse

- #abort! ⇒ Object

  Aborts a handler by raising HandlerAborted.

- #ensure_loaded!(object, max_retries = 1) ⇒ Object

  Ensures that a specific `object` has been parsed and loaded into the registry.

- #initialize(source_parser, stmt) ⇒ Base constructor

  A new instance of Base.

- #parse_block ⇒ Object abstract

  Parses the semantic “block” contained in the statement node.

- #process ⇒ Array<CodeObjects::Base>, ...

  The main handler method called by the parser on a statement that matches the Base.handles declaration.

- #push_state(opts = {}) { ... } ⇒ Object

  Executes a given block with specific state values for #owner, #namespace and #scope.

- #register(*objects) ⇒ CodeObjects::Base+

  Do some post processing on a list of code objects.

- #register_docstring(object, docstring = statement.comments, stmt = statement) ⇒ void

  Registers any docstring found for the object and expands macros.

- #register_dynamic(object) ⇒ void

  Registers the object as dynamic if the object is defined inside a method or block (owner != namespace).

- #register_ensure_loaded(object) ⇒ void

  Ensures that the object’s namespace is loaded before attaching it to the namespace.

- #register_file_info(object, file = parser.file, line = statement.line, comments = statement.comments) ⇒ void

  Registers the file/line of the declaration with the object.

- #register_group(object, group = extra_state.group) ⇒ void

  Registers the object as being inside a specific group.

- #register_module_function(object) ⇒ Object

  Registers the same method information on the module function, if the object was defined as a module function.

- #register_source(object, source = statement, type = parser.parser_type) ⇒ void
- #register_transitive_tags(object) ⇒ void

  Registers any transitive tags from the namespace on the object.

- #register_visibility(object, visibility = self.visibility) ⇒ Object

  Registers visibility on a method object.

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

### #initialize(source_parser, stmt) ⇒ `Base`

Returns a new instance of Base.

    276
    277
    278
    279

    # File 'lib/yard/handlers/base.rb', line 276

    def initialize(source_parser, stmt)
      @parser = source_parser
      @statement = stmt
    end

## Instance Attribute Details

### #extra_state ⇒ `Object` (readonly)

Returns the value of attribute extra_state.

    333
    334
    335

    # File 'lib/yard/handlers/base.rb', line 333

    def extra_state
      @extra_state
    end

### #globals ⇒ `Object` (readonly)

Returns the value of attribute globals.

    330
    331
    332

    # File 'lib/yard/handlers/base.rb', line 330

    def globals
      @globals
    end

### #namespace ⇒ `Object`

Returns the value of attribute namespace.

    321
    322
    323

    # File 'lib/yard/handlers/base.rb', line 321

    def namespace
      @namespace
    end

### #owner ⇒ `Object`

Returns the value of attribute owner.

    318
    319
    320

    # File 'lib/yard/handlers/base.rb', line 318

    def owner
      @owner
    end

### #parser ⇒ `Processor` (readonly)

Returns the processor object that manages all global state during handling.

Returns:

- (`Processor`) —

  the processor object that manages all global state during handling.

    310
    311
    312

    # File 'lib/yard/handlers/base.rb', line 310

    def parser
      @parser
    end

### #scope ⇒ `Object`

Returns the value of attribute scope.

    327
    328
    329

    # File 'lib/yard/handlers/base.rb', line 327

    def scope
      @scope
    end

### #statement ⇒ `Object` (readonly)

Returns the statement object currently being processed. Usually refers to one semantic language statement, though the strict definition depends on the parser used.

Returns:

- (`Object`) —

  the statement object currently being processed. Usually refers to one semantic language statement, though the strict definition depends on the parser used.

    315
    316
    317

    # File 'lib/yard/handlers/base.rb', line 315

    def statement
      @statement
    end

### #visibility ⇒ `Object`

Returns the value of attribute visibility.

    324
    325
    326

    # File 'lib/yard/handlers/base.rb', line 324

    def visibility
      @visibility
    end

## Class Method Details

### .clear_subclasses ⇒ `void`

This method returns an undefined value.

Clear all registered subclasses. Testing purposes only

    159
    160
    161

    # File 'lib/yard/handlers/base.rb', line 159

    def clear_subclasses
      @@subclasses = []
    end

### .handlers ⇒ `Array`

Returns a list of matchers for the handler object.

Returns:

- (`Array`) —

  a list of matchers for the handler object.

See Also:

- handles?

    211
    212
    213

    # File 'lib/yard/handlers/base.rb', line 211

    def handlers
      @handlers ||= []
    end

### .handles(*matches) ⇒ `Object`

Declares the statement type which will be processed by this handler.

A match need not be unique to a handler. Multiple handlers can process the same statement. However, in this case, care should be taken to make sure that #parse_block would only be executed by one of the handlers, otherwise the same code will be parsed multiple times and slow YARD down.

Parameters:

- matches (`Parser::Ruby::Legacy::RubyToken`, `Symbol`, `String`, `Regexp`) —

  statements that match the declaration will be processed by this handler. A String match is equivalent to a `/Astring/` regular expression (match from the beginning of the line), and all token matches match only the first token of the statement.

    192
    193
    194

    # File 'lib/yard/handlers/base.rb', line 192

    def handles(*matches)
      (@handlers ||= []).concat(matches)
    end

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

This class is implemented by Ruby::Base and Ruby::Legacy::Base. To implement a base handler class for another language, implement this method to return true if the handler should process the given statement object. Use handlers to enumerate the matchers declared for the handler class.

Parameters:

- statement —

  a statement object or node (depends on language type)

Returns:

- (`Boolean`) —

  whether or not this handler object should process the given statement

Raises:

- (`NotImplementedError`)

    205
    206
    207

    # File 'lib/yard/handlers/base.rb', line 205

    def handles?(statement) # rubocop:disable Lint/UnusedMethodArgument
      raise NotImplementedError, "override #handles? in a subclass"
    end

### .in_file(filename) ⇒ `void`

This method returns an undefined value.

Declares that a handler should only be called when inside a filename by its basename or a regex match for the full path.

Parameters:

- filename (`String`, `Regexp`) —

  a matching filename or regex

Since:

- 0.6.2

    235
    236
    237

    # File 'lib/yard/handlers/base.rb', line 235

    def in_file(filename)
      (@in_files ||= []) << filename
    end

### .matches_file?(filename) ⇒ `Boolean`

Returns whether the filename matches the declared file match for a handler. If no file match is specified, returns true.

Returns:

- (`Boolean`) —

  whether the filename matches the declared file match for a handler. If no file match is specified, returns true.

Since:

- 0.6.2

    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255

    # File 'lib/yard/handlers/base.rb', line 242

    def matches_file?(filename)
      @in_files ||= nil # avoid ruby warnings
      return true unless @in_files
      @in_files.any? do |in_file|
        case in_file
        when String
          File.basename(filename) == in_file
        when Regexp
          filename =~ in_file
        else
          true
        end
      end
    end

### .namespace_only ⇒ `void`

This method returns an undefined value.

Declares that the handler should only be called when inside a CodeObjects::NamespaceObject, not a method body.

    219
    220
    221

    # File 'lib/yard/handlers/base.rb', line 219

    def namespace_only
      @namespace_only = true
    end

### .namespace_only? ⇒ `Boolean`

Returns whether the handler should only be processed inside a namespace.

Returns:

- (`Boolean`) —

  whether the handler should only be processed inside a namespace.

    225
    226
    227

    # File 'lib/yard/handlers/base.rb', line 225

    def namespace_only?
      @namespace_only ||= false
    end

### .process(&block) ⇒ `void`

This method returns an undefined value.

Generates a `process` method, equivalent to `def process; … end`. Blocks defined with this syntax will be wrapped inside an anonymous module so that the handler class can be extended with mixins that override the `process` method without alias chaining.

See Also:

- #process

Since:

- 0.5.4

    269
    270
    271
    272
    273

    # File 'lib/yard/handlers/base.rb', line 269

    def process(&block)
      mod = Module.new
      mod.send(:define_method, :process, &block)
      include mod
    end

### .subclasses ⇒ `Array<Base>`

Returns all registered handler subclasses.

Returns:

- (`Array<Base>`) —

  a list of handlers

    165
    166
    167

    # File 'lib/yard/handlers/base.rb', line 165

    def subclasses
      @@subclasses ||= []
    end

## Instance Method Details

### #abort! ⇒ `Object`

Aborts a handler by raising HandlerAborted. An exception will only be logged in debugging mode for this kind of handler exit.

Raises:

- (`Handlers::HandlerAborted`)

Since:

- 0.8.4

    355
    356
    357

    # File 'lib/yard/handlers/base.rb', line 355

    def abort!
      raise Handlers::HandlerAborted
    end

### #call_params ⇒ `Array<String>`

This method is abstract.

Implement this method to return the parameters in a method call statement. It should return an empty list if the statement is not a method call.

Returns a list of argument names.

Returns:

- (`Array<String>`) —

  a list of argument names

Raises:

- (`NotImplementedError`)

    603
    604
    605

    # File 'lib/yard/handlers/base.rb', line 603

    def call_params
      raise NotImplementedError
    end

### #caller_method ⇒ `String`?

This method is abstract.

Implement this method to return the method being called in a method call. It should return nil if the statement is not a method call.

Returns:

- (`String`) —

  the method name being called

- (`nil`) —

  if the statement is not a method call

Raises:

- (`NotImplementedError`)

    612
    613
    614

    # File 'lib/yard/handlers/base.rb', line 612

    def caller_method
      raise NotImplementedError
    end

### #ensure_loaded!(object, max_retries = 1) ⇒ `Object`

Ensures that a specific `object` has been parsed and loaded into the registry. This is necessary when adding data to a namespace, for instance, since the namespace may not have been processed yet (it can be located in a file that has not been handled).

Calling this method defers the handler until all other files have been processed. If the object gets resolved, the rest of the handler continues, otherwise an exception is raised.

#### Examples:

#####

Adding a mixin to the String class programmatically

    ensure_loaded! P('String')
    # "String" is now guaranteed to be loaded
    P('String').mixins << P('MyMixin')

Parameters:

- object (`Proxy`, `CodeObjects::Base`) —

  the object to resolve.

- max_retries (`Integer`) (defaults to: `1`) —

  the number of times to defer the handler before raising a `NamespaceMissingError`.

Raises:

- (`NamespaceMissingError`) —

  if the object is not resolved within `max_retries` attempts, this exception is raised and the handler finishes processing.

    583
    584
    585
    586
    587
    588
    589
    590
    591
    592
    593
    594
    595

    # File 'lib/yard/handlers/base.rb', line 583

    def ensure_loaded!(object, max_retries = 1)
      return if object.root?
      return object unless object.is_a?(Proxy)

      retries = 0
      while object.is_a?(Proxy)
        raise NamespaceMissingError, object if retries > max_retries
        log.debug "Missing object #{object} in file `#{parser.file}', moving it to the back of the line."
        parser.parse_remaining_files
        retries += 1
      end
      object
    end

### #parse_block ⇒ `Object`

This method is abstract.

Subclasses should call parser.process

Parses the semantic “block” contained in the statement node.

Raises:

- (`NotImplementedError`)

    304
    305
    306

    # File 'lib/yard/handlers/base.rb', line 304

    def parse_block(*)
      raise NotImplementedError, "#{self} did not implement a #parse_block method for handling"
    end

### #process ⇒ `Array<CodeObjects::Base>`, ...

The main handler method called by the parser on a statement that matches the handles declaration.

Subclasses should override this method to provide the handling functionality for the class.

Returns:

- (`Array<CodeObjects::Base>`, `CodeObjects::Base`, `Object`) —

  If this method returns a code object (or a list of them), they are passed to the `#register` method which adds basic attributes. It is not necessary to return any objects and in some cases you may want to explicitly avoid the returning of any objects for post-processing by the register method.

Raises:

- (`NotImplementedError`)

See Also:

- handles
- #register

    297
    298
    299

    # File 'lib/yard/handlers/base.rb', line 297

    def process
      raise NotImplementedError, "#{self} did not implement a #process method for handling."
    end

### #push_state(opts = {}) { ... } ⇒ `Object`

Executes a given block with specific state values for #owner, #namespace and #scope.

Parameters:

- opts (`Hash`) (defaults to: `{}`) —

  a customizable set of options

Options Hash (`opts`):

- :namespace (`CodeObjects::NamespaceObject`) — default: `value of #namespace` —

  the namespace object that #namespace will be equal to for the duration of the block.

- :scope (`Symbol`) — default: `:instance` —

  the scope for the duration of the block.

- :owner (`CodeObjects::Base`) — default: `value of #owner` —

  the owner object (method) for the duration of the block

Yields:

- a block to execute with the given state values.

    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393

    # File 'lib/yard/handlers/base.rb', line 370

    def push_state(opts = {})
      opts = {
        :namespace => namespace,
        :scope => :instance,
        :owner => owner || namespace,
        :visibility => nil
      }.update(opts)

      ns = namespace
      vis = visibility
      sc = scope
      oo = owner
      self.namespace = opts[:namespace]
      self.visibility = opts[:visibility] || :public
      self.scope = opts[:scope]
      self.owner = opts[:owner]

      yield

      self.namespace = ns
      self.visibility = vis
      self.scope = sc
      self.owner = oo
    end

### #register(*objects) ⇒ `CodeObjects::Base`+

Do some post processing on a list of code objects. Adds basic attributes to the list of objects like the filename, line number, CodeObjects::Base#dynamic, source code and CodeObjects::Base#docstring, but only if they don’t exist.

Parameters:

- objects (`Array<CodeObjects::Base>`) —

  the list of objects to post-process.

Returns:

- (`CodeObjects::Base`, `Array<CodeObjects::Base>`) —

  returns whatever is passed in, for chainability.

    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421

    # File 'lib/yard/handlers/base.rb', line 407

    def register(*objects)
      objects.flatten.each do |object|
        next unless object.is_a?(CodeObjects::Base)
        register_ensure_loaded(object)
        yield(object) if block_given?
        register_file_info(object)
        register_source(object)
        register_visibility(object)
        register_docstring(object)
        register_group(object)
        register_dynamic(object)
        register_module_function(object)
      end
      objects.size == 1 ? objects.first : objects
    end

### #register_docstring(object, docstring = statement.comments, stmt = statement) ⇒ `void`

This method returns an undefined value.

Registers any docstring found for the object and expands macros

Parameters:

- object (`CodeObjects::Base`) —

  the object to register

Since:

- 0.8.0

    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478

    # File 'lib/yard/handlers/base.rb', line 450

    def register_docstring(object, docstring = statement.comments, stmt = statement)
      docstring = docstring.join("\n") if Array === docstring
      parser = Docstring.parser
      parser.parse(docstring || "", object, self)

      if object && docstring
        object.docstring = parser.to_docstring

        # Add hash_flag/line_range
        if stmt
          object.docstring.hash_flag = stmt.comments_hash_flag
          object.docstring.line_range = stmt.comments_range
        end
      end

      if docstring.is_a?(String)
        if (m = docstring.match(/^\s*@!?visibility\s+(public|private|protected)\b/m))
          vis_sym = m[1].to_sym

          if object.nil?
            globals.visibility_origin = :directive
          elsif object.is_a?(CodeObjects::MethodObject)
            object.visibility = vis_sym
          end
        end
      end

      register_transitive_tags(object)
    end

### #register_dynamic(object) ⇒ `void`

This method returns an undefined value.

Registers the object as dynamic if the object is defined inside a method or block (owner != namespace)

Parameters:

- object (`CodeObjects::Base`) —

  the object to register

Since:

- 0.8.0

    559
    560
    561

    # File 'lib/yard/handlers/base.rb', line 559

    def register_dynamic(object)
      object.dynamic = true if owner != namespace
    end

### #register_ensure_loaded(object) ⇒ `void`

This method returns an undefined value.

Ensures that the object’s namespace is loaded before attaching it to the namespace.

Parameters:

- object (`CodeObjects::Base`) —

  the object to register

Since:

- 0.8.0

    429
    430
    431
    432
    433
    434

    # File 'lib/yard/handlers/base.rb', line 429

    def register_ensure_loaded(object)
      ensure_loaded!(object.namespace)
      object.namespace.children << object
    rescue NamespaceMissingError
      nil # noop
    end

### #register_file_info(object, file = parser.file, line = statement.line, comments = statement.comments) ⇒ `void`

This method returns an undefined value.

Registers the file/line of the declaration with the object

Parameters:

- object (`CodeObjects::Base`) —

  the object to register

Since:

- 0.8.0

    441
    442
    443

    # File 'lib/yard/handlers/base.rb', line 441

    def register_file_info(object, file = parser.file, line = statement.line, comments = statement.comments)
      object.add_file(file, line, comments)
    end

### #register_group(object, group = extra_state.group) ⇒ `void`

This method returns an undefined value.

Registers the object as being inside a specific group

Parameters:

- object (`CodeObjects::Base`) —

  the object to register

Since:

- 0.8.0

    485
    486
    487
    488
    489
    490
    491
    492

    # File 'lib/yard/handlers/base.rb', line 485

    def register_group(object, group = extra_state.group)
      if group
        unless object.namespace.is_a?(Proxy)
          object.namespace.groups |= [group]
        end
        object.group = group
      end
    end

### #register_module_function(object) ⇒ `Object`

Registers the same method information on the module function, if the object was defined as a module function.

Parameters:

- object (`CodeObjects::Base`) —

  the possible module function object to copy data for

Since:

- 0.8.0

    545
    546
    547
    548
    549
    550
    551

    # File 'lib/yard/handlers/base.rb', line 545

    def register_module_function(object)
      return unless object.is_a?(MethodObject)
      return unless object.module_function?
      modobj = MethodObject.new(object.namespace, object.name)
      object.copy_to(modobj)
      modobj.visibility = :private # rubocop:disable Lint/UselessSetterCall
    end

### #register_source(object, source = statement, type = parser.parser_type) ⇒ `void`

This method returns an undefined value.

Parameters:

- object (`CodeObjects::Base`) —

  the object to register

Since:

- 0.8.0

    511
    512
    513
    514
    515

    # File 'lib/yard/handlers/base.rb', line 511

    def register_source(object, source = statement, type = parser.parser_type)
      return unless object.is_a?(MethodObject)
      object.source ||= source
      object.source_type = type
    end

### #register_transitive_tags(object) ⇒ `void`

This method returns an undefined value.

Registers any transitive tags from the namespace on the object

Parameters:

- object (`CodeObjects::Base`, `nil`) —

  the object to register

Since:

- 0.8.0

    499
    500
    501
    502
    503
    504
    505
    506

    # File 'lib/yard/handlers/base.rb', line 499

    def register_transitive_tags(object)
      return unless object && !object.namespace.is_a?(Proxy)
      Tags::Library.transitive_tags.each do |tag|
        next unless object.namespace.has_tag?(tag)
        next if object.has_tag?(tag)
        object.add_tag(*object.namespace.tags(tag))
      end
    end

### #register_visibility(object, visibility = self.visibility) ⇒ `Object`

Registers visibility on a method object. If the object does not respond to setting visibility, nothing is done.

Parameters:

- object (`#visibility=`) —

  the object to register

- visibility (`Symbol`) (defaults to: `self.visibility`) —

  the visibility to set on the object

Since:

- 0.8.0

    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
    534
    535
    536
    537

    # File 'lib/yard/handlers/base.rb', line 523

    def register_visibility(object, visibility = self.visibility)
      return unless object.respond_to?(:visibility=)
      return if object.is_a?(NamespaceObject)

      if object.is_a?(CodeObjects::MethodObject)
        origin = globals.visibility_origin
        if origin == :keyword
          object.visibility = visibility if object.scope == scope
        else
          object.visibility = visibility
        end
      else
        object.visibility = visibility
      end
    end