Class: Yard::Lint::Executor::InProcessRegistry

Inherits:
Object
  • Object
show all
Defined in:
lib/yard/lint/executor/in_process_registry.rb

Overview

Manages shared YARD::Registry for in-process execution. Ensures files are parsed once and shared across all validators.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ InProcessRegistry

Returns a new instance of InProcessRegistry.



15
16
17
18
19
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 15

def initialize
  @parsed = false
  @warnings = []
  @mutex = Mutex.new
end

Instance Attribute Details

#warnings ⇒ Array<String> (readonly)

Returns warnings captured during parsing.

Returns:

  • (Array<String>) —

    warnings captured during parsing



13
14
15
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 13

def warnings
  @warnings
end

Instance Method Details

#all_objects ⇒ Array<YARD::CodeObjects::Base>

Get all objects from the registry

Returns:

  • (Array<YARD::CodeObjects::Base>) 


82
83
84
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 82

def all_objects
  YARD::Registry.all
end

#clear! ⇒ void

This method returns an undefined value.

Clear the registry and reset state



125
126
127
128
129
130
131
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 125

def clear!
  @mutex.synchronize do
    YARD::Registry.clear
    @parsed = false
    @warnings = []
  end
end

#objects_for_validator(visibility:, file_excludes: [], file_selection: nil) ⇒ Array<YARD::CodeObjects::Base>

Get objects filtered for a specific validator

Parameters:

  • visibility (Symbol) —

    visibility filter, either :all or :public

  • file_excludes (Array<String>) (defaults to: []) —

    glob patterns for files to exclude

  • file_selection (Array<String>, nil) (defaults to: nil) —

    specific files to include (nil = all files)

Returns:

  • (Array<YARD::CodeObjects::Base>) 


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 91

def objects_for_validator(visibility:, file_excludes: [], file_selection: nil)
  objects = all_objects

  # Filter by visibility
  unless visibility == :all
    objects = objects.select do |obj|
      !obj.respond_to?(:visibility) || obj.visibility == :public
    end
  end

  # Filter by file selection (if provided)
  if file_selection && !file_selection.empty?
    expanded_selection = file_selection.to_set { |f| File.expand_path(f) }
    objects = objects.select do |obj|
      obj.file && expanded_selection.include?(File.expand_path(obj.file))
    end
  end

  # Filter by file excludes
  unless file_excludes.empty?
    objects = objects.reject do |obj|
      next false unless obj.file

      file_excludes.any? do |pattern|
        File.fnmatch(pattern, obj.file, File::FNM_PATHNAME | File::FNM_EXTGLOB)
      end
    end
  end

  objects
end

#parse(files, source: nil) ⇒ void

This method returns an undefined value.

Parse Ruby source files and populate the YARD registry. Captures any warnings emitted by YARD during parsing for later dispatch.

Parameters:

  • files (Array<String>) —

    absolute or relative paths to Ruby source files

  • source (String, nil) (defaults to: nil) —

    in-memory source; when given, ‘files.first` is used as the virtual filename for registry/location reporting only



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
66
67
68
69
70
71
72
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 27

def parse(files, source: nil)
  @mutex.synchronize do
    return if @parsed

    YARD::Registry.clear

    # Register custom tags declared in .yardopts so the parser does not
    # warn about them (matching how the real `yard` command behaves).
    register_yardopts_tags

    # Suppress YARD's default output by setting log level high
    # YARD uses its own logging levels, 4 is ERROR/FATAL level
    original_level = YARD::Logger.instance.level
    YARD::Logger.instance.level = 4 # Only show fatal errors

    begin
      if source
        virtual_path = files.first
        # First pass: register directive/macro definitions from the in-memory source.
        # We set parser.file manually so registered objects carry the virtual path.
        parse_source_string(source, virtual_path)
        # Clear checksums so the second pass is not skipped
        YARD::Registry.checksums.clear
        # Second pass: full parse with all directives available
        @warnings = capture_warnings { parse_source_string(source, virtual_path) }
      else
        # First pass: parse all files to process directive definitions
        YARD.parse(files)

        # Clear checksums to force reparsing without clearing the registry.
        # This allows macro definitions from the first pass to be available
        # during the second pass, enabling proper directive expansion regardless of parse order.
        YARD::Registry.checksums.clear

        # Second pass: reparse files now that all directive definitions are available
        @warnings = capture_warnings { YARD.parse(files) }
      end

      @parsed = true
    ensure
      # Restore the log level even if parsing raises, so a single bad
      # file does not leave YARD's global logger silenced for the run.
      YARD::Logger.instance.level = original_level
    end
  end
end

#parsed? ⇒ Boolean

Check if registry has been parsed

Returns:

  • (Boolean) 


76
77
78
 
# File 'lib/yard/lint/executor/in_process_registry.rb', line 76

def parsed?
  @parsed
end