模組 Prism

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 lex 進行詞法分析。它會捨棄任何空白事件，但會傳回相同的代幣。如果 source 中的語法無效，則會引發 SyntaxError。

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

Prism::load(source, serialized) → ParseResult 按一下以切換原始碼

使用 source 作為參考，將序列化 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 按一下以切換原始碼

如果 source 含有錯誤，則傳回 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