模块 Prism

The Prism Ruby 解析器。

“解析 Ruby 变得易如反掌！”

- You, hopefully

此文件由 templates/template.rb 脚本生成，请勿手动修改。如果您想修改模板，请查看 templates/lib/prism/compiler.rb.erb

此文件由 templates/template.rb 脚本生成，请勿手动修改。如果您想修改模板，请查看 templates/lib/prism/dispatcher.rb.erb

此文件由 templates/template.rb 脚本生成，请勿手动修改。如果您想修改模板，请查看 templates/lib/prism/dsl.rb.erb

此文件由 templates/template.rb 脚本生成，请勿手动修改。如果您想修改模板，请查看 templates/lib/prism/mutation_compiler.rb.erb

此文件由 templates/template.rb 脚本生成，请勿手动修改。如果您想修改模板，请查看 templates/lib/prism/node.rb.erb

在这里，我们重新打开 prism 模块，为节点提供一些非模板化方法，这些方法作为便捷方法。

此文件由 templates/template.rb 脚本生成，请勿手动修改。如果您想修改模板，请查看 templates/lib/prism/visitor.rb.erb

常量

BACKEND
VERSION: 版本常量通过读取调用 pm_version 的结果来设置。

公共类方法

dump(code, **options) 点击切换源代码

通过使用序列化 API 来镜像 Prism.dump API。

# File lib/prism/ffi.rb, line 182
def dump(code, **options)
  LibRubyParser::PrismBuffer.with do |buffer|
    LibRubyParser.pm_serialize_parse(buffer.pointer, code, code.bytesize, dump_options(options))
    buffer.read
  end
end

dump_file(filepath, **options) 点击切换源代码

使用序列化 API 镜像 Prism.dump_file API。

# File lib/prism/ffi.rb, line 190
def dump_file(filepath, **options)
  LibRubyParser::PrismString.with(filepath) do |string|
    dump(string.read, **options, filepath: filepath)
  end
end

lex(code, **options) 点击切换源代码

使用序列化 API 镜像 Prism.lex API。

# File lib/prism/ffi.rb, line 197
def lex(code, **options)
  LibRubyParser::PrismBuffer.with do |buffer|
    LibRubyParser.pm_serialize_lex(buffer.pointer, code, code.bytesize, dump_options(options))
    Serialize.load_tokens(Source.new(code), buffer.read)
  end
end

Prism::lex_compat(source, **options) → ParseResult 点击切换源代码

返回一个解析结果，其值为一个与 Ripper::lex 返回值非常相似的令牌数组。主要区别在于没有发出 ‘:on_sp` 令牌。

有关支持的选项，请参见 Prism::parse。

# File lib/prism.rb, line 46
def self.lex_compat(source, **options)
  LexCompat.new(source, **options).result
end

lex_file(filepath, **options) 点击切换源代码

使用序列化 API 镜像 Prism.lex_file API。

# File lib/prism/ffi.rb, line 205
def lex_file(filepath, **options)
  LibRubyParser::PrismString.with(filepath) do |string|
    lex(string.read, **options, filepath: filepath)
  end
end

Prism::lex_ripper(source) → Array 点击切换源代码

使用 Ripper 词法分析器进行词法分析。它会丢弃任何空格事件，但否则会返回相同的令牌。如果源代码中的语法无效，则会引发 SyntaxError。

# File lib/prism.rb, line 56
def self.lex_ripper(source)
  LexRipper.new(source).result
end

Prism::load(source, serialized) → ParseResult 点击切换源代码

使用源代码作为参考将序列化 AST 加载到树中。

# File lib/prism.rb, line 64
def self.load(source, serialized)
  Serialize.load(source, serialized)
end

parse(code, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse API。

# File lib/prism/ffi.rb, line 212
def parse(code, **options)
  Prism.load(code, dump(code, **options))
end

parse_comments(code, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_comments API。

# File lib/prism/ffi.rb, line 226
def parse_comments(code, **options)
  LibRubyParser::PrismBuffer.with do |buffer|
    LibRubyParser.pm_serialize_parse_comments(buffer.pointer, code, code.bytesize, dump_options(options))

    source = Source.new(code)
    loader = Serialize::Loader.new(source, buffer.read)

    loader.load_header
    loader.load_encoding
    loader.load_start_line
    loader.load_comments
  end
end

Prism::parse_failure?(source, **options) → bool 点击切换源代码

如果源代码解析时出现错误，则返回 true。

# File lib/prism.rb, line 72
def self.parse_failure?(source, **options)
  !parse_success?(source, **options)
end

parse_file(filepath, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_file API。这使用的是原生字符串而不是 Ruby 字符串，因为它允许我们在可用时使用 mmap。

# File lib/prism/ffi.rb, line 219
def parse_file(filepath, **options)
  LibRubyParser::PrismString.with(filepath) do |string|
    parse(string.read, **options, filepath: filepath)
  end
end

parse_file_comments(filepath, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_file_comments API。这使用的是原生字符串而不是 Ruby 字符串，因为它允许我们在可用时使用 mmap。

# File lib/prism/ffi.rb, line 243
def parse_file_comments(filepath, **options)
  LibRubyParser::PrismString.with(filepath) do |string|
    parse_comments(string.read, **options, filepath: filepath)
  end
end

Prism::parse_file_failure?(filepath, **options) → bool 点击切换源代码

如果 filepath 处的文件解析时出现错误，则返回 true。

# File lib/prism.rb, line 80
def self.parse_file_failure?(filepath, **options)
  !parse_file_success?(filepath, **options)
end

parse_file_success?(filepath, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_file_success? API。

# File lib/prism/ffi.rb, line 278
def parse_file_success?(filepath, **options)
  LibRubyParser::PrismString.with(filepath) do |string|
    parse_success?(string.read, **options, filepath: filepath)
  end
end

parse_lex(code, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_lex API。

# File lib/prism/ffi.rb, line 250
def parse_lex(code, **options)
  LibRubyParser::PrismBuffer.with do |buffer|
    LibRubyParser.pm_serialize_parse_lex(buffer.pointer, code, code.bytesize, dump_options(options))

    source = Source.new(code)
    loader = Serialize::Loader.new(source, buffer.read)

    tokens = loader.load_tokens
    node, comments, magic_comments, data_loc, errors, warnings = loader.load_nodes
    tokens.each { |token,| token.value.force_encoding(loader.encoding) }

    ParseResult.new([node, tokens], comments, magic_comments, data_loc, errors, warnings, source)
  end
end

parse_lex_file(filepath, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_lex_file API。

# File lib/prism/ffi.rb, line 266
def parse_lex_file(filepath, **options)
  LibRubyParser::PrismString.with(filepath) do |string|
    parse_lex(string.read, **options, filepath: filepath)
  end
end

parse_success?(code, **options) 点击切换源代码

使用序列化 API 镜像 Prism.parse_success? API。

# File lib/prism/ffi.rb, line 273
def parse_success?(code, **options)
  LibRubyParser.pm_parse_success_p(code, code.bytesize, dump_options(options))
end

私有类方法

dump_options(options) 点击切换源代码

将给定的选项转换为序列化选项字符串。

# File lib/prism/ffi.rb, line 287
def dump_options(options)
  template = +""
  values = []

  template << "L"
  if (filepath = options[:filepath])
    values.push(filepath.bytesize, filepath.b)
    template << "A*"
  else
    values << 0
  end

  template << "L"
  values << options.fetch(:line, 1)

  template << "L"
  if (encoding = options[:encoding])
    name = encoding.name
    values.push(name.bytesize, name.b)
    template << "A*"
  else
    values << 0
  end

  template << "C"
  values << (options.fetch(:frozen_string_literal, false) ? 1 : 0)

  template << "C"
  values << (options.fetch(:verbose, true) ? 0 : 1)

  template << "L"
  if (scopes = options[:scopes])
    values << scopes.length

    scopes.each do |scope|
      template << "L"
      values << scope.length

      scope.each do |local|
        name = local.name
        template << "L"
        values << name.bytesize

        template << "A*"
        values << name.b
      end
    end
  else
    values << 0
  end

  values.pack(template)
end