Class: YARD::Handlers::Processor

Inherits:

Object

• Object
• YARD::Handlers::Processor

show all

Defined in:

lib/yard/handlers/processor.rb

Overview

Instance Attribute Summary (collapse)

• - (String) file

  The filename.

• - (Boolean) load_order_errors

  Whether or not Parser::LoadOrderError is raised.

• - (CodeObjects::NamespaceObject) namespace

  The current namespace.

• - (CodeObjects::Base^?) owner

  Unlike the namespace, the owner is a non-namespace object that should be stored between statements.

• - (Symbol) parser_type

  The parser type (:ruby, :ruby18, :c).

• - (Symbol) scope

  The current scope (class, instance).

• - (Symbol) visibility

  The current visibility (public, private, protected).

Class Method Summary (collapse)

• + (Object) register_handler_namespace(type, ns)

  Registeres a new namespace for handlers of the given type.

Instance Method Summary (collapse)

• - (Array<Base>) find_handlers(statement)

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

• - (Processor) initialize(file = nil, load_order_errors = false, parser_type = Parser::SourceParser.parser_type) constructor

  Creates a new Processor for a file.

• - (void) process(statements)

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

69
70
71
72
73
74
75
76
77
78
79

# File 'lib/yard/handlers/processor.rb', line 69

def initialize(file = nil, load_order_errors = false, parser_type = Parser::SourceParser.parser_type)
  @file = file || "(stdin)"
  @namespace = YARD::Registry.root
  @visibility = :public
  @scope = :instance
  @owner = @namespace
  @load_order_errors = load_order_errors
  @parser_type = parser_type
  @handlers_loaded = {}
  load_handlers
end

35
36
37

# File 'lib/yard/handlers/processor.rb', line 35

def file
  @file
end

53
54
55

# File 'lib/yard/handlers/processor.rb', line 53

def load_order_errors
  @load_order_errors
end

38
39
40

# File 'lib/yard/handlers/processor.rb', line 38

def namespace
  @namespace
end

50
51
52

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

def owner
  @owner
end

56
57
58

# File 'lib/yard/handlers/processor.rb', line 56

def parser_type
  @parser_type
end

44
45
46

# File 'lib/yard/handlers/processor.rb', line 44

def scope
  @scope
end

41
42
43

# File 'lib/yard/handlers/processor.rb', line 41

def visibility
  @visibility
end

19
20
21

# File 'lib/yard/handlers/processor.rb', line 19

def register_handler_namespace(type, ns)
  namespace_for_handler[type] = ns
end

114
115
116
117
118
119
120

# File 'lib/yard/handlers/processor.rb', line 114

def find_handlers(statement)
  Base.subclasses.find_all do |handler|
    handler_base_class > handler &&
    (handler.namespace_only? ? owner.is_a?(CodeObjects::NamespaceObject) : true) &&
    handler.handles?(statement)
  end
end

86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

# File 'lib/yard/handlers/processor.rb', line 86

def process(statements)
  statements.each_with_index do |stmt, index|
    find_handlers(stmt).each do |handler| 
      begin
        handler.new(self, stmt).process
      rescue Parser::LoadOrderError => loaderr
        raise # Pass this up
      rescue NamespaceMissingError => missingerr
        log.warn "The #{missingerr.object.type} #{missingerr.object.path} has not yet been recognized." 
        log.warn "If this class/method is part of your source tree, this will affect your documentation results." 
        log.warn "You can correct this issue by loading the source file for this object before `#{file}'"
        log.warn 
      rescue Parser::UndocumentableError => undocerr
        log.warn "in #{handler.to_s}: Undocumentable #{undocerr.message}"
        log.warn "\tin file '#{file}':#{stmt.line}:\n\n" + stmt.show + "\n"
      rescue => e
        log.error "Unhandled exception in #{handler.to_s}:"
        log.error "  in `#{file}`:#{stmt.line}:\n\n#{stmt.show}\n"
        log.backtrace(e)
      end
    end
  end
end