Class | YARD::Handlers::Processor
In: | lib/yard/handlers/processor.rb
Parent: | Object

Iterates over all statements in a file and delegates them to the {Handlers::Base} objects that are registered to handle the statement.

This class is passed to each handler and keeps overall processing state. For example, if the {visibility} is set in a handler, all following statements will have access to this state. This allows "public", "protected" and "private" statements to be handled in classes and modules. In addition, the {namespace} can be set during parsing to control where objects are being created from. You can also access extra stateful properties that any handler can set during the duration of the post processing of a file from {extra_state}. If you need to access state across different files, look at {globals}.

@see Handlers::Base

### Methods

find_handlers namespace_for_handler new process register_handler_namespace

### Attributes

extra_state

[RW]

Share state across different handlers inside of a file. This attribute is similar to {visibility}, {scope}, {namespace} and {owner}, in that they all maintain state across all handlers for the entire source file. Use this attribute to store any data your handler might need to save during the parsing of a file. If you need to save state across files, see {globals}.

@return [OpenStruct] an open structure that can store arbitrary data @see globals

file | [RW] | @return [String] the filename

globals

[RW]

Handlers can share state for the entire post processing stage through this attribute. Note that post processing stage spans multiple files. To share state only within a single file, use {extra_state}

@example Sharing state among two handlers

      class Handler1 < YARD::Handlers::Ruby::Base
        handles :class
        process { globals.foo = :bar }
      end

      class Handler2 < YARD::Handlers::Ruby::Base
        handles :method
        process { puts globals.foo }
      end

@return [OpenStruct] global shared state for post-processing stage @see extra_state

load_order_errors | [RW] | @return [Boolean] whether or not {Parser::LoadOrderError} is raised
namespace | [RW] | @return [CodeObjects::NamespaceObject] the current namespace
namespace_for_handler | [R] | @return [Hash] a list of registered parser type extensions @private @since 0.6.0

owner

[RW]

@return [CodeObjects::Base, nil] unlike the namespace, the owner

      is a non-namespace object that should be stored between statements.
      For instance, when parsing a method body, the {CodeObjects::MethodObject}
      is set as the owner, in case any extra method information is processed.

parser_type | [RW] | @return [Symbol] the parser type (:ruby, :ruby18, :c)
scope | [RW] | @return [Symbol] the current scope (class, instance)
visibility | [RW] | @return [Symbol] the current visibility (public, private, protected)

### Public Class methods

namespace_for_handler()
new(file = nil, load_order_errors = false, parser_type = Parser::SourceParser.parser_type, globals = nil)

Creates a new Processor for a `file`.

@param [String] file the name of the file that is being processed.

      uses '(stdin)' if file is nil.

@param [Boolean] load_order_error whether or not to raise {Parser::LoadOrderError}

      when a file has unresolved references that need to be parsed first.
      If these errors are raised, the processor will attempt to load all
      other files before continuing to parse the file.

@param [Symbol] parser_type the parser type (:ruby, :ruby18, :c) from

      the parser. Used to select the handler (since handlers are specific
      to a parser type).

@param [OpenStruct] globals the object holding all state during the

      post processing stage

register_handler_namespace(type, ns)

Registers a new namespace for handlers of the given type. @since 0.6.0

### Public Instance methods

find_handlers(statement)

Searches for all handlers in {Base.subclasses} that match the `statement`

@param statement the statement object to match. @return [Array<Base>] a list of handlers to process the statement with.

process(statements)

Processes a list of statements by finding handlers to process each one.

@param [Array] statements a list of statements @return [void]

[Validate]