Class: YARD::Parser::SourceParser

Relationships & Source Files
Inherits:	Object
Defined in:	lib/yard/parser/source_parser.rb

Overview

Responsible for parsing a source file into the namespace. Parsing also invokes handlers to process the parsed statements and generate any code objects that may be recognized.

=== Custom Parsers SourceParser allows custom parsers to be registered and called when a certain filetype is recognized. To register a parser and hook it up to a set of file extensions, call .register_parser_type

See Also:

Constant Summary

DEFAULT_PATH_GLOB =

The default glob of files to be parsed.
Since:
- 0.9.0
# File 'lib/yard/parser/source_parser.rb', line 70
```
["{lib,app}/**/*.rb", "ext/**/*.{c,cc,cxx,cpp,rb}"]
```

ENCODING_BYTE_ORDER_MARKS =

Byte order marks for various encodings

Since:

0.7.0

# File 'lib/yard/parser/source_parser.rb', line 74

{
  'utf-8' => String.new("\xEF\xBB\xBF"),
  # Not yet supported
  # 'utf-16be' => "\xFE\xFF",
  # 'utf-16le' => "\xFF\xFE",
  # 'utf-32be' => "\x00\x00\xFF\xFE",
  # 'utf-32le' => "\xFF\xFE",
}

ENCODING_LINE =
# File 'lib/yard/parser/source_parser.rb', line 65

%r{\A(?:\s*#*!.*\r?\n)?\s*(?:#+|/\*+|//+).*coding\s*[:=]{1,2}\s*([a-z\d_\-]+)}i

FROZEN_STRING_LINE =
# File 'lib/yard/parser/source_parser.rb', line 66
```
/frozen(-|_)string(-|_)literal:\s+(true|false)/i
```
SHEBANG_LINE =
# File 'lib/yard/parser/source_parser.rb', line 64
```
/\A\s*#!\S+/
```

Parser Callbacks

.after_parse_file {|parser| ... } ⇒ Proc

Registers a callback to be called after an individual file is parsed.
.after_parse_file_callbacks ⇒ Array<Proc>
.after_parse_list {|files, globals| ... } ⇒ Proc

Registers a callback to be called after a list of files is parsed via .parse.
.after_parse_list_callbacks ⇒ Array<Proc>
.before_parse_file {|parser| ... } ⇒ Proc

Registers a callback to be called before an individual file is parsed.
.before_parse_file_callbacks ⇒ Array<Proc>
.before_parse_list {|files, globals| ... } ⇒ Proc

Registers a callback to be called before a list of files is parsed via .parse.
.before_parse_list_callbacks ⇒ Array<Proc>
#contents ⇒ String readonly
#convert_encoding(content) private

Searches for encoding line and forces encoding.
#file ⇒ String rw
#globals ⇒ OpenStruct readonly
.new(parser_type = SourceParser.parser_type, globals = nil) ⇒ SourceParser constructor
#parse(content = __FILE__) ⇒ Object^?

The main parser method.
.parse_in_order(*files) ⇒ void private

Parses a list of files in a queue.
#parser_class private
#parser_type ⇒ Symbol rw
#parser_type=(value) rw private
#parser_type_for_filename(filename) ⇒ Symbol private

Guesses the parser type to use depending on the file extension.
#post_process ⇒ void private

Runs a ::YARD::Handlers::Processor object to post process the parsed statements.
#tokenize(content) ⇒ Array

Tokenizes but does not parse the block of code using the current #parser_type

Class Attribute Summary

.parser_type ⇒ Symbol rw
.parser_type=(value) rw
.parser_type_extensions ⇒ Hash rw Internal use only Internal use only
.parser_type_extensions=(value) rw
.parser_types ⇒ Hash{Symbol=>Object} rw Internal use only Internal use only
.parser_types=(value) rw

Class Method Summary

.parse(paths = DEFAULT_PATH_GLOB, excluded = [], level = log.level) ⇒ void

Parses a path or set of paths.
.parse_string(content, ptype = parser_type) ⇒ Object

Parses a string content
.parser_type_for_extension(extension) ⇒ Symbol

Finds a parser type that is registered for the extension.
.register_parser_type(type, parser_klass, extensions = nil) ⇒ void

Registers a new parser type.
.tokenize(content, ptype = parser_type) ⇒ Array

Tokenizes but does not parse the block of code.
.validated_parser_type(type) ⇒ Symbol Internal use only Internal use only

Returns the validated parser type.

Constructor Details

.new(parser_type = SourceParser.parser_type, globals = nil) ⇒ `SourceParser`

Creates a new parser object for code parsing with a specific parser type.

Parameters:

parser_type (Symbol) (defaults to: SourceParser.parser_type) —
the parser type to use
globals (OpenStruct) (defaults to: nil) —
global state to be re-used across separate source files

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 406


def initialize(parser_type = SourceParser.parser_type, globals1 = nil, globals2 = nil)
  globals = [true, false].include?(globals1) ? globals2 : globals1
  @file = '(stdin)'
  @globals = globals || OpenStruct.new
  self.parser_type = parser_type
end

Class Attribute Details

.parser_type ⇒ `Symbol` (rw)

Returns:

(Symbol) —
the default parser type (defaults to :ruby)

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 85


attr_reader :parser_type

.parser_type=(value) (rw)

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 87


def parser_type=(value)
  @parser_type = validated_parser_type(value)
end

.parser_type_extensions ⇒ Hash (rw)

This method is for internal use only.

Returns:

(Hash) —
a list of registered parser type extensions

Since:

0.5.6

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 163


def parser_type_extensions; @@parser_type_extensions ||= {} end

.parser_type_extensions=(value) (rw)

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 164


def parser_type_extensions=(value) @@parser_type_extensions = value end

.parser_types ⇒ Hash{`Symbol`=>`Object`} (rw)

This method is for internal use only.

Returns:

(Hash{Symbol=>Object}) —
a list of registered parser types

Since:

0.5.6

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 157


def parser_types; @@parser_types ||= {} end

.parser_types=(value) (rw)

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 158


def parser_types=(value) @@parser_types = value end

Class Method Details

.after_parse_file {|parser| ... } ⇒ `Proc`

Registers a callback to be called after an individual file is parsed. The block passed to this method will be called on subsequent parse calls.

To register a callback that is called after the entire list of files is processed, see .after_parse_list.

Examples:

Printing the length of each file after it is parsed

SourceParser.after_parse_file do |parser|
  puts "#{parser.file} is #{parser.contents.size} characters"
end
YARD.parse('lib/**/*.rb')
# prints:
"lib/foo.rb is 1240 characters"
"lib/foo_bar.rb is 248 characters"

Yields:

(parser) —
the yielded block is called once after each file that is parsed. This might happen many times for a single codebase.

Yield Parameters:

parser (SourceParser) —
the parser object that parsed the file.

Yield Returns:

(void) —
the return value for the block is ignored.

Returns:

(Proc) —
the yielded block

See Also:

.before_parse_file
.after_parse_list

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 324


def after_parse_file(&block)
  after_parse_file_callbacks << block
end

.after_parse_file_callbacks ⇒ Array<`Proc`>

Returns:

(Array<Proc>) —
the list of callbacks to be called after parsing a file. Should only be used for testing.

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 352


def after_parse_file_callbacks
  @after_parse_file_callbacks ||= []
end

.after_parse_list {|files, globals| ... } ⇒ `Proc`

Registers a callback to be called after a list of files is parsed via .parse. The block passed to this method will be called on subsequent parse calls.

Examples:

Printing results after parsing occurs

SourceParser.after_parse_list do
  puts "Finished parsing!"
end
YARD.parse
# Prints "Finished parsing!" after parsing files

Yields:

(files, globals) —
the yielded block is called once before parsing all files

Yield Parameters:

files (Array<String>) —
the list of files that will be parsed.
globals (OpenStruct) —
a global structure to store arbitrary state for post processing (see Handlers::Processor#globals)

Yield Returns:

(void) —
the return value for the block is ignored.

Returns:

(Proc) —
the yielded block

See Also:

.before_parse_list
.before_parse_file

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 258


def after_parse_list(&block)
  after_parse_list_callbacks << block
end

.after_parse_list_callbacks ⇒ Array<`Proc`>

Returns:

(Array<Proc>) —
the list of callbacks to be called after parsing a list of files. Should only be used for testing.

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 338


def after_parse_list_callbacks
  @after_parse_list_callbacks ||= []
end

.before_parse_file {|parser| ... } ⇒ `Proc`

Registers a callback to be called before an individual file is parsed. The block passed to this method will be called on subsequent parse calls.

To register a callback that is called before the entire list of files is processed, see .before_parse_list.

Examples:

Installing a simple callback

SourceParser.before_parse_file do |parser|
  puts "I'm parsing #{parser.file}"
end
YARD.parse('lib/**/*.rb')
# prints:
"I'm parsing lib/foo.rb"
"I'm parsing lib/foo_bar.rb"
"I'm parsing lib/last_file.rb"

Cancel parsing of any test_*.rb files

SourceParser.before_parse_file do |parser|
  return false if parser.file =~ /^test_.+\.rb$/
end

Yields:

(parser) —
the yielded block is called once before each file that is parsed. This might happen many times for a single codebase.

Yield Parameters:

parser (SourceParser) —
the parser object that will #parse the file.

Yield Returns:

(Boolean) —
if the block returns false, parsing for the file is cancelled.

Returns:

(Proc) —
the yielded block

See Also:

.after_parse_file
.before_parse_list

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 295


def before_parse_file(&block)
  before_parse_file_callbacks << block
end

.before_parse_file_callbacks ⇒ Array<`Proc`>

Returns:

(Array<Proc>) —
the list of callbacks to be called before parsing a file. Should only be used for testing.

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 345


def before_parse_file_callbacks
  @before_parse_file_callbacks ||= []
end

.before_parse_list {|files, globals| ... } ⇒ `Proc`

Registers a callback to be called before a list of files is parsed via .parse. The block passed to this method will be called on subsequent parse calls.

Examples:

Installing a simple callback

SourceParser.before_parse_list do |files, globals|
  puts "Starting to parse..."
end
YARD.parse('lib/**/*.rb')
# prints "Starting to parse..."

Setting global state

SourceParser.before_parse_list do |files, globals|
  globals.method_count = 0
end
SourceParser.after_parse_list do |files, globals|
  puts "Found #{globals.method_count} methods"
end
class MyCountHandler < Handlers::Ruby::Base
  handles :def, :defs
  process { globals.method_count += 1 }
end
YARD.parse
# Prints: "Found 37 methods"

Using a global callback to cancel parsing

SourceParser.before_parse_list do |files, globals|
  return false if files.include?('foo.rb')
end

YARD.parse(['foo.rb', 'bar.rb']) # callback cancels this method
YARD.parse('bar.rb') # parses normally

Yields:

(files, globals) —
the yielded block is called once before parsing all files

Yield Parameters:

files (Array<String>) —
the list of files that will be parsed.
globals (OpenStruct) —
a global structure to store arbitrary state for post processing (see Handlers::Processor#globals)

Yield Returns:

(Boolean) —
if the block returns false, parsing is cancelled.

Returns:

(Proc) —
the yielded block

See Also:

.after_parse_list
.before_parse_file

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 234


def before_parse_list(&block)
  before_parse_list_callbacks << block
end

.before_parse_list_callbacks ⇒ Array<`Proc`>

Returns:

(Array<Proc>) —
the list of callbacks to be called before parsing a list of files. Should only be used for testing.

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 331


def before_parse_list_callbacks
  @before_parse_list_callbacks ||= []
end

.parse(paths = DEFAULT_PATH_GLOB, excluded = [], level = log.level) ⇒ `void`

This method returns an undefined value.

Parses a path or set of paths

Parameters:

paths (String, Array<String>) (defaults to: DEFAULT_PATH_GLOB) —
a path, glob, or list of paths to parse
excluded (Array<String, Regexp>) (defaults to: []) —
a list of excluded path matchers
level (Fixnum) (defaults to: log.level) —
the logger level to use during parsing. See ::YARD::Logger

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 99


def parse(paths = DEFAULT_PATH_GLOB, excluded = [], level = log.level)
  log.debug("Parsing #{paths.inspect} with `#{parser_type}` parser")
  excluded = excluded.map do |path|
    case path
    when Regexp; path
    else Regexp.new(path.to_s, Regexp::IGNORECASE)
    end
  end
  files = [paths].flatten.
    map {|p| File.directory?(p) ? "#{p}/**/*.{rb,c,cc,cxx,cpp}" : p }.
    map {|p| p.include?("*") ? Dir[p].sort_by {|d| [d.length, d] } : p }.flatten.
    reject {|p| !File.file?(p) || excluded.any? {|re| p =~ re } }.
    map {|p| p.encoding == Encoding.default_external ? p : p.dup.force_encoding(Encoding.default_external) }

  log.enter_level(level) do
    parse_in_order(*files.uniq)
  end
end

.parse_in_order(*files) ⇒ `void` (private)

This method returns an undefined value.

Parses a list of files in a queue.

Parameters:

files (Array<String>) —
a list of files to queue for parsing

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 364


def parse_in_order(*files)
  global_state = OpenStruct.new

  return if before_parse_list_callbacks.any? do |cb|
    cb.call(files, global_state) == false
  end

  OrderedParser.new(global_state, files).parse

  after_parse_list_callbacks.each do |cb|
    cb.call(files, global_state)
  end
end

.parse_string(content, ptype = parser_type) ⇒ `Object`

Parses a string content

Parameters:

content (String) —
the block of code to parse
ptype (Symbol) (defaults to: parser_type) —
the parser type to use. See .parser_type.

Returns:

the parser object that was used to parse content

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 123


def parse_string(content, ptype = parser_type)
  new(ptype).parse(StringIO.new(content))
end

.parser_type_for_extension(extension) ⇒ `Symbol`

Finds a parser type that is registered for the extension. If no type is found, the default Ruby type is returned.

Returns:

(Symbol) —
the parser type to be used for the extension

Since:

0.5.6

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 171


def parser_type_for_extension(extension)
  type = parser_type_extensions.find do |_t, exts|
    [exts].flatten.any? {|ext| ext === extension }
  end
  validated_parser_type(type ? type.first : :ruby)
end

.register_parser_type(type, parser_klass, extensions = nil) ⇒ `void`

This method returns an undefined value.

Registers a new parser type.

Examples:

Registering a parser for "java" files

SourceParser.register_parser_type :java, JavaParser, 'java'

Parameters:

type (Symbol) —
a symbolic name for the parser type
parser_klass (Base) —
a class that implements parsing and tokenization
extensions (Array<String>, String, Regexp) (defaults to: nil) —
a list of extensions or a regex to match against the file extension

See Also:

Base

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 146


def register_parser_type(type, parser_klass, extensions = nil)
  unless Base > parser_klass
    raise ArgumentError, "expecting parser_klass to be a subclass of YARD::Parser::Base"
  end
  parser_type_extensions[type.to_sym] = extensions if extensions
  parser_types[type.to_sym] = parser_klass
end

.tokenize(content, ptype = parser_type) ⇒ Array

Tokenizes but does not parse the block of code

Parameters:

content (String) —
the block of code to tokenize
ptype (Symbol) (defaults to: parser_type) —
the parser type to use. See .parser_type.

Returns:

(Array) —
a list of tokens

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 132


def tokenize(content, ptype = parser_type)
  new(ptype).tokenize(content)
end

.validated_parser_type(type) ⇒ `Symbol`

This method is for internal use only.

Returns the validated parser type. Basically, enforces that :ruby type is never set if the Ripper library is not available

Parameters:

type (Symbol) —
the parser type to set

Returns:

(Symbol) —
the validated parser type

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 184


def validated_parser_type(type)
  !defined?(::Ripper) && type == :ruby ? :ruby18 : type
end

Instance Attribute Details

#contents ⇒ String (readonly)

Returns:

(String) —
the contents of the file to be parsed

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 399


attr_reader :contents

#file ⇒ String (rw)

Returns:

(String) —
the filename being parsed by the parser.

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 386


attr_accessor :file

#globals ⇒ OpenStruct (readonly)

Returns:

(OpenStruct) —
an open struct containing arbitrary global state shared between files and handlers.

Since:

0.7.0

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 395


attr_reader :globals

#parser_type ⇒ `Symbol` (rw)

Returns:

(Symbol) —
the parser type associated with the parser instance. This should be set by the constructor.

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 390


attr_reader :parser_type

#parser_type=(value) (rw, private)

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 500


def parser_type=(value)
  @parser_type = self.class.validated_parser_type(value)
end

Instance Method Details

#convert_encoding(content) (private)

Searches for encoding line and forces encoding

Since:

0.5.3

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 471


def convert_encoding(content)
  return content unless content.respond_to?(:force_encoding)
  if content =~ ENCODING_LINE
    content.force_encoding($1)
  else
    content.force_encoding('binary')
    ENCODING_BYTE_ORDER_MARKS.each do |encoding, bom|
      bom.force_encoding('binary')
      if content.start_with?(bom)
        return content.sub(bom, '').force_encoding(encoding)
      end
    end
    content.force_encoding('utf-8') # UTF-8 is default encoding
    content
  end
end

#parse(content = FILE) ⇒ `Object`^?

The main parser method. This should not be called directly. Instead, use the class methods parse and .parse_string.

Parameters:

content (String, #read, Object) (defaults to: __FILE__) —
the source file to parse

Returns:

(Object, nil) —
the parser object used to parse the source

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 418


def parse(content = __FILE__)
  case content
  when String
    @file = File.cleanpath(content)
    content = convert_encoding(String.new(File.read_binary(file)))
    checksum = Registry.checksum_for(content)
    return if Registry.checksums[file] == checksum

    if Registry.checksums.key?(file)
      log.info "File '#{file}' was modified, re-processing..."
    end
    Registry.checksums[@file] = checksum
    self.parser_type = parser_type_for_filename(file)
  else
    content = content.read if content.respond_to? :read
  end

  @contents = content
  @parser = parser_class.new(content, file)

  self.class.before_parse_file_callbacks.each do |cb|
    return @parser if cb.call(self) == false
  end

  @parser.parse
  post_process

  self.class.after_parse_file_callbacks.each do |cb|
    cb.call(self)
  end

  @parser
rescue ArgumentError, NotImplementedError => e
  log.warn("Cannot parse `#{file}': #{e.message}")
  log.backtrace(e, :warn)
rescue ParserSyntaxError => e
  log.warn(e.message.capitalize)
  log.backtrace(e, :warn)
end

#parser_class (private)

Since:

0.5.6

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 515


def parser_class
  klass = self.class.parser_types[parser_type]
  unless klass
    raise ArgumentError, "invalid parser type '#{parser_type}' or unrecognized file", caller[1..-1]
  end

  klass
end

#parser_type_for_filename(filename) ⇒ `Symbol` (private)

Guesses the parser type to use depending on the file extension.

Parameters:

filename (String) —
the filename to use to guess the parser type

Returns:

(Symbol) —
a parser type that matches the filename

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 508


def parser_type_for_filename(filename)
  ext = (File.extname(filename)[1..-1] || "").downcase
  type = self.class.parser_type_for_extension(ext)
  parser_type == :ruby18 && type == :ruby ? :ruby18 : type
end

#post_process ⇒ `void` (private)

This method returns an undefined value.

Runs a ::YARD::Handlers::Processor object to post process the parsed statements.

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 490


def post_process
  return unless @parser.respond_to?(:enumerator)

  enumerator = @parser.enumerator
  if enumerator
    post = Handlers::Processor.new(self)
    post.process(enumerator)
  end
end

#tokenize(content) ⇒ Array

Tokenizes but does not parse the block of code using the current #parser_type

Parameters:

content (String) —
the block of code to tokenize

Returns:

(Array) —
a list of tokens

[ GitHub ]

# File 'lib/yard/parser/source_parser.rb', line 462


def tokenize(content)
  @parser = parser_class.new(content, file)
  @parser.tokenize
end

Class: YARD::Parser::SourceParser

Overview

Constant Summary

Parser Callbacks

Class Attribute Summary

Class Method Summary

Constructor Details

.new(parser_type = SourceParser.parser_type, globals = nil) ⇒ SourceParser

Class Attribute Details

.parser_type ⇒ Symbol (rw)

.parser_type=(value) (rw)

.parser_type_extensions ⇒ Hash (rw)

.parser_type_extensions=(value) (rw)

.parser_types ⇒ Hash{Symbol=>Object} (rw)

.parser_types=(value) (rw)

Class Method Details

.after_parse_file {|parser| ... } ⇒ Proc

.after_parse_file_callbacks ⇒ Array<Proc>

.after_parse_list {|files, globals| ... } ⇒ Proc

.after_parse_list_callbacks ⇒ Array<Proc>

.before_parse_file {|parser| ... } ⇒ Proc

.before_parse_file_callbacks ⇒ Array<Proc>

.before_parse_list {|files, globals| ... } ⇒ Proc

.before_parse_list_callbacks ⇒ Array<Proc>

.parse(paths = DEFAULT_PATH_GLOB, excluded = [], level = log.level) ⇒ void

.parse_in_order(*files) ⇒ void (private)

.parse_string(content, ptype = parser_type) ⇒ Object

.parser_type_for_extension(extension) ⇒ Symbol

.register_parser_type(type, parser_klass, extensions = nil) ⇒ void

.tokenize(content, ptype = parser_type) ⇒ Array

.validated_parser_type(type) ⇒ Symbol

Instance Attribute Details

#contents ⇒ String (readonly)

#file ⇒ String (rw)

#globals ⇒ OpenStruct (readonly)

#parser_type ⇒ Symbol (rw)

#parser_type=(value) (rw, private)

Instance Method Details

#convert_encoding(content) (private)

#parse(content = __FILE__) ⇒ Object?

#parser_class (private)

#parser_type_for_filename(filename) ⇒ Symbol (private)

#post_process ⇒ void (private)

#tokenize(content) ⇒ Array

.new(parser_type = SourceParser.parser_type, globals = nil) ⇒ `SourceParser`

.parser_type ⇒ `Symbol` (rw)

.parser_types ⇒ Hash{`Symbol`=>`Object`} (rw)

.after_parse_file {|parser| ... } ⇒ `Proc`

.after_parse_file_callbacks ⇒ Array<`Proc`>

.after_parse_list {|files, globals| ... } ⇒ `Proc`

.after_parse_list_callbacks ⇒ Array<`Proc`>

.before_parse_file {|parser| ... } ⇒ `Proc`

.before_parse_file_callbacks ⇒ Array<`Proc`>

.before_parse_list {|files, globals| ... } ⇒ `Proc`

.before_parse_list_callbacks ⇒ Array<`Proc`>

.parse(paths = DEFAULT_PATH_GLOB, excluded = [], level = log.level) ⇒ `void`

.parse_in_order(*files) ⇒ `void` (private)

.parse_string(content, ptype = parser_type) ⇒ `Object`

.parser_type_for_extension(extension) ⇒ `Symbol`

.register_parser_type(type, parser_klass, extensions = nil) ⇒ `void`

.validated_parser_type(type) ⇒ `Symbol`

#parser_type ⇒ `Symbol` (rw)

#parse(content = FILE) ⇒ `Object`^?

#parser_type_for_filename(filename) ⇒ `Symbol` (private)

#post_process ⇒ `void` (private)