modul Prism
Der Ruby-Parser Prism.
„Das Parsen von Ruby ist plötzlich überschaubar!“ - Hoffentlich Sie
Constants
- BACKEND
-
Die C-Erweiterung ist das Standard-Backend auf CRuby.
- VERSION
-
Die Versionskonstante wird durch Lesen des Ergebnisses des Aufrufs von pm_version gesetzt.
Öffentliche Klassenmethoden
Source
# File lib/prism/ffi.rb, line 238 def dump(source, **options) LibRubyParser::PrismString.with_string(source) { |string| dump_common(string, options) } end
Die Prism.dump API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 243 def dump_file(filepath, **options) options[:filepath] = filepath LibRubyParser::PrismString.with_file(filepath) { |string| dump_common(string, options) } end
Die Prism.dump_file API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 249 def lex(code, **options) LibRubyParser::PrismString.with_string(code) { |string| lex_common(string, code, options) } end
Die Prism.lex API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism.rb, line 68 def self.lex_compat(source, **options) LexCompat.new(source, **options).result # steep:ignore end
Gibt ein Parse-Ergebnis zurück, dessen Wert ein Array von Token ist, das dem Rückgabewert von Ripper::lex sehr ähnlich ist. Der Hauptunterschied besteht darin, dass das Token :on_sp nicht ausgegeben wird.
Unterstützte Optionen finden Sie unter Prism::parse.
Source
# File lib/prism/ffi.rb, line 254 def lex_file(filepath, **options) options[:filepath] = filepath LibRubyParser::PrismString.with_file(filepath) { |string| lex_common(string, string.read, options) } end
Die Prism.lex_file API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism.rb, line 78 def self.lex_ripper(source) LexRipper.new(source).result # steep:ignore end
Dies wird mit dem Lexer von Ripper geparst. Leert alle Leerzeichenereignisse, gibt aber ansonsten dieselben Token zurück. Löst SyntaxError aus, wenn die Syntax in der Quelle ungültig ist.
Source
# File lib/prism.rb, line 86 def self.load(source, serialized, freeze = false) Serialize.load_parse(source, serialized, freeze) end
Lädt die serialisierte AST unter Verwendung der Quelle als Referenz in einen Baum.
Source
# File lib/prism/ffi.rb, line 260 def parse(code, **options) LibRubyParser::PrismString.with_string(code) { |string| parse_common(string, code, options) } end
Die Prism.parse API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 298 def parse_comments(code, **options) LibRubyParser::PrismString.with_string(code) { |string| parse_comments_common(string, code, options) } end
Die Prism.parse_comments API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 327 def parse_failure?(code, **options) !parse_success?(code, **options) end
Die Prism.parse_failure? API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 267 def parse_file(filepath, **options) options[:filepath] = filepath LibRubyParser::PrismString.with_file(filepath) { |string| parse_common(string, string.read, options) } end
Die Prism.parse_file API wird mithilfe der Serialisierungs-API gespiegelt. Dies verwendet native Strings anstelle von Ruby-Strings, da dies die Verwendung von mmap ermöglicht, sofern verfügbar.
Source
# File lib/prism/ffi.rb, line 305 def parse_file_comments(filepath, **options) options[:filepath] = filepath LibRubyParser::PrismString.with_file(filepath) { |string| parse_comments_common(string, string.read, options) } end
Die Prism.parse_file_comments API wird mithilfe der Serialisierungs-API gespiegelt. Dies verwendet native Strings anstelle von Ruby-Strings, da dies die Verwendung von mmap ermöglicht, sofern verfügbar.
Source
# File lib/prism/ffi.rb, line 338 def parse_file_failure?(filepath, **options) !parse_file_success?(filepath, **options) end
Die Prism.parse_file_failure? API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 332 def parse_file_success?(filepath, **options) options[:filepath] = filepath LibRubyParser::PrismString.with_file(filepath) { |string| parse_file_success_common(string, options) } end
Die Prism.parse_file_success? API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 311 def parse_lex(code, **options) LibRubyParser::PrismString.with_string(code) { |string| parse_lex_common(string, code, options) } end
Die Prism.parse_lex API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 316 def parse_lex_file(filepath, **options) options[:filepath] = filepath LibRubyParser::PrismString.with_file(filepath) { |string| parse_lex_common(string, string.read, options) } end
Die Prism.parse_lex_file API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 273 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 } eof_callback = -> (_) { stream.eof? } # 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, eof_callback, dump_options(options)) Prism.load(source, buffer.read, options.fetch(:freeze, false)) end end
Die Prism.parse_stream API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 322 def parse_success?(code, **options) LibRubyParser::PrismString.with_string(code) { |string| parse_file_success_common(string, options) } end
Die Prism.parse_success? API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 343 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
Die Prism.profile API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/ffi.rb, line 353 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
Die Prism.profile_file API wird mithilfe der Serialisierungs-API gespiegelt.
Source
# File lib/prism/parse_result.rb, line 895 def self.scope(locals: [], forwarding: []) Scope.new(locals, forwarding) end
Erstellt einen neuen Scope mit den angegebenen Locals und Forwarding-Optionen, der für die Übergabe an eine der Prism.*-Methoden, die die Option scopes akzeptieren, geeignet ist.
Private Klassenmethoden
Source
# File lib/prism/ffi.rb, line 449 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 << "C" values << (options.fetch(:freeze, false) ? 1 : 0) template << "L" if (scopes = options[:scopes]) values << scopes.length scopes.each do |scope| locals = nil forwarding = 0 case scope when Array locals = scope when Scope locals = scope.locals scope.forwarding.each do |forward| case forward when :* then forwarding |= 0x1 when :** then forwarding |= 0x2 when :& then forwarding |= 0x4 when :"..." then forwarding |= 0x8 else raise ArgumentError, "invalid forwarding value: #{forward}" end end else raise TypeError, "wrong argument type #{scope.class.inspect} (expected Array or Prism::Scope)" end template << "L" values << locals.length template << "C" values << forwarding locals.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
Konvertiert die angegebenen Optionen in eine serialisierte Optionszeichenkette.
Source
# File lib/prism/ffi.rb, line 407 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
Gibt den Wert zurück, der für die Option command_line gedumpt werden soll.
Source
# File lib/prism/ffi.rb, line 425 def dump_options_version(version) current = version == "current" case current ? RUBY_VERSION : version when nil, "latest" 0 # Handled in pm_parser_init when /\A3\.3(\.\d+)?\z/ 1 when /\A3\.4(\.\d+)?\z/ 2 when /\A3\.5(\.\d+)?\z/, /\A4\.0(\.\d+)?\z/ 3 when /\A4\.1(\.\d+)?\z/ 4 else if current raise CurrentVersionError, RUBY_VERSION else raise ArgumentError, "invalid version: #{version}" end end end
Gibt den Wert zurück, der für die Option version gedumpt werden soll.