Spec-Zone.ru › Ruby 3.4

модуль 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/inspect_visitor.rb.erb, если вы хотите изменить шаблон

Этот файл сгенерирован скриптом templates/template.rb и не должен изменяться вручную. Обратитесь к templates/lib/prism/mutation_compiler.rb.erb, если вы хотите изменить шаблон

Этот файл сгенерирован скриптом templates/template.rb и не должен изменяться вручную. Обратитесь к templates/lib/prism/node.rb.erb, если вы хотите изменить шаблон

Здесь мы повторно открываем модуль prism, чтобы предоставить методы для узлов, которые не являются шаблонными и предназначены в качестве удобных методов.

typed: ignore

Этот файл сгенерирован скриптом templates/template.rb и не должен изменяться вручную. Обратитесь к templates/lib/prism/reflection.rb.erb, если вы хотите изменить шаблон

Этот файл сгенерирован скриптом templates/template.rb и не должен изменяться вручную. Обратитесь к templates/lib/prism/visitor.rb.erb, если вы хотите изменить шаблон

Константы

BACKEND

Расширение C является по умолчанию бэкендом в CRuby.

VERSION

Константа версии устанавливается путем считывания результата вызова pm_version.

Методы публичного класса

dump (source, **options)
Исходный код
# File lib/prism/ffi.rb, line 229
def dump(source, **options)
  LibRubyParser::PrismString.with_string(source) { |string| dump_common(string, options) }
end

Отражает API Prism.dump с использованием API сериализации.

dump_file (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 234
def dump_file(filepath, **options)
  options[:filepath] = filepath
  LibRubyParser::PrismString.with_file(filepath) { |string| dump_common(string, options) }
end

Отражает API Prism.dump_file с использованием API сериализации.

lex (code, **options)
Исходный код
# File lib/prism/ffi.rb, line 240
def lex(code, **options)
  LibRubyParser::PrismString.with_string(code) { |string| lex_common(string, code, options) }
end

Отражает API Prism.lex с использованием API сериализации.

Prism::lex_compat(source, **options) → LexCompat::Result
Исходный код
# File lib/prism.rb, line 47
def self.lex_compat(source, **options)
  LexCompat.new(source, **options).result # steep:ignore
end

Возвращает результат разбора, значение которого представляет собой массив токенов, который очень похож на возвращаемое значение Ripper::lex. Основное отличие заключается в том, что токен «:on_sp» не выводится.

Для поддерживаемых опций см. Prism::parse.

lex_file (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 245
def lex_file(filepath, **options)
  options[:filepath] = filepath
  LibRubyParser::PrismString.with_file(filepath) { |string| lex_common(string, string.read, options) }
end

Отражает API Prism.lex_file с использованием API сериализации.

Prism::lex_ripper(source) → Массив
Исходный код
# File lib/prism.rb, line 57
def self.lex_ripper(source)
  LexRipper.new(source).result # steep:ignore
end

Производит лексический анализ с помощью лексического анализатора Ripper. Он опускает все события пробелов, но в остальном возвращает те же токены. Вызывает SyntaxError, если синтаксис в источнике неверен.

Prism::load(source, serialized) → ParseResult
Исходный код
# File lib/prism.rb, line 65
def self.load(source, serialized)
  Serialize.load(source, serialized)
end

Загрузить сериализованное AST, используя источник в качестве ссылки в дерево.

parse (code, **options)
Исходный код
# File lib/prism/ffi.rb, line 251
def parse(code, **options)
  LibRubyParser::PrismString.with_string(code) { |string| parse_common(string, code, options) }
end

Отражает API Prism.parse с использованием API сериализации.

parse_comments (code, **options)
Исходный код
# File lib/prism/ffi.rb, line 287
def parse_comments(code, **options)
  LibRubyParser::PrismString.with_string(code) { |string| parse_comments_common(string, code, options) }
end

Отражает API Prism.parse_comments с использованием API сериализации.

parse_failure? (code, **options)
Исходный код
# File lib/prism/ffi.rb, line 316
def parse_failure?(code, **options)
  !parse_success?(code, **options)
end

Отражает API Prism.parse_failure? с использованием API сериализации.

parse_file (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 258
def parse_file(filepath, **options)
  options[:filepath] = filepath
  LibRubyParser::PrismString.with_file(filepath) { |string| parse_common(string, string.read, options) }
end

Отражает API Prism.parse_file с использованием API сериализации. Использует собственные строки вместо строк Ruby, что позволяет использовать mmap, когда это доступно.

parse_file_comments (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 294
def parse_file_comments(filepath, **options)
  options[:filepath] = filepath
  LibRubyParser::PrismString.with_file(filepath) { |string| parse_comments_common(string, string.read, options) }
end

Отражает API Prism.parse_file_comments с использованием API сериализации. Использует собственные строки вместо строк Ruby, что позволяет использовать mmap, когда это доступно.

parse_file_failure? (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 327
def parse_file_failure?(filepath, **options)
  !parse_file_success?(filepath, **options)
end

Отражает API Prism.parse_file_failure? с использованием API сериализации.

parse_file_success? (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 321
def parse_file_success?(filepath, **options)
  options[:filepath] = filepath
  LibRubyParser::PrismString.with_file(filepath) { |string| parse_file_success_common(string, options) }
end

Отражает API Prism.parse_file_success? с использованием API сериализации.

parse_lex (code, **options)
Исходный код
# File lib/prism/ffi.rb, line 300
def parse_lex(code, **options)
  LibRubyParser::PrismString.with_string(code) { |string| parse_lex_common(string, code, options) }
end

Отражает API Prism.parse_lex с использованием API сериализации.

parse_lex_file (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 305
def parse_lex_file(filepath, **options)
  options[:filepath] = filepath
  LibRubyParser::PrismString.with_file(filepath) { |string| parse_lex_common(string, string.read, options) }
end

Отражает API Prism.parse_lex_file с использованием API сериализации.

parse_stream (stream, **options)
Исходный код
# File lib/prism/ffi.rb, line 264
def parse_stream(stream, **options)
  LibRubyParser::PrismBuffer.with do |buffer|
    source = +""
    callback = -> (string, size, _) {
      raise "Expected size to be >= 0, got: #{size}" if size <= 0

      if !(line = stream.gets(size - 1)).nil?
        source << line
        string.write_string("#{line}\x00", line.bytesize + 1)
      end
    }

    # In the pm_serialize_parse_stream function it accepts a pointer to the
    # IO object as a void* and then passes it through to the callback as the
    # third argument, but it never touches it itself. As such, since we have
    # access to the IO object already through the closure of the lambda, we
    # can pass a null pointer here and not worry.
    LibRubyParser.pm_serialize_parse_stream(buffer.pointer, nil, callback, dump_options(options))
    Prism.load(source, buffer.read)
  end
end

Отражает API Prism.parse_stream с помощью API сериализации.

parse_success? (code, **options)
Исходный код
# File lib/prism/ffi.rb, line 311
def parse_success?(code, **options)
  LibRubyParser::PrismString.with_string(code) { |string| parse_file_success_common(string, options) }
end

Отражает API Prism.parse_success? с помощью API сериализации.

profile (source, **options)
Исходный код
# File lib/prism/ffi.rb, line 332
def profile(source, **options)
  LibRubyParser::PrismString.with_string(source) do |string|
    LibRubyParser::PrismBuffer.with do |buffer|
      LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options))
      nil
    end
  end
end

Отражает API Prism.profile с помощью API сериализации.

profile_file (filepath, **options)
Исходный код
# File lib/prism/ffi.rb, line 342
def profile_file(filepath, **options)
  LibRubyParser::PrismString.with_file(filepath) do |string|
    LibRubyParser::PrismBuffer.with do |buffer|
      options[:filepath] = filepath
      LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options))
      nil
    end
  end
end

Отражает API Prism.profile_file с помощью API сериализации.

Методы частного класса

dump_options (options)
Исходный код
# File lib/prism/ffi.rb, line 441
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.is_a?(Encoding) ? encoding.name : encoding
    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 << dump_options_command_line(options)

  template << "C"
  values << dump_options_version(options[:version])

  template << "C"
  values << (options[:encoding] == false ? 1 : 0)

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

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

  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

Преобразует заданные опции в сериализованную строку опций.

dump_options_command_line (options)
Исходный код
# File lib/prism/ffi.rb, line 409
def dump_options_command_line(options)
  command_line = options.fetch(:command_line, "")
  raise ArgumentError, "command_line must be a string" unless command_line.is_a?(String)

  command_line.each_char.inject(0) do |value, char|
    case char
    when "a" then value | 0b000001
    when "e" then value | 0b000010
    when "l" then value | 0b000100
    when "n" then value | 0b001000
    when "p" then value | 0b010000
    when "x" then value | 0b100000
    else raise ArgumentError, "invalid command_line option: #{char}"
    end
  end
end

Возвращает значение, которое должно быть выведено для опции command_line.

dump_options_version (version)
Исходный код
# File lib/prism/ffi.rb, line 427
def dump_options_version(version)
  case version
  when nil, "latest"
    0
  when /\A3\.3(\.\d+)?\z/
    1
  when /\A3\.4(\.\d+)?\z/
    0
  else
    raise ArgumentError, "invalid version: #{version}"
  end
end

Возвращает значение, которое должно быть выведено для опции version.

Ruby Core © 1993–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API