module Prism
The Prism Ruby parser.
“Parsing Ruby is suddenly manageable!” - You, hopefully
Constants
- BACKEND
-
The C extension is the default backend on CRuby.
- VERSION
-
The version of the prism library.
Public Class Methods
Source
static VALUE
dump(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
#ifdef PRISM_BUILD_DEBUG
size_t length = pm_string_length(&input);
char* dup = xmalloc(length);
memcpy(dup, pm_string_source(&input), length);
pm_string_constant_init(&input, dup, length);
#endif
VALUE value = dump_input(&input, &options);
if (options.freeze) rb_obj_freeze(value);
#ifdef PRISM_BUILD_DEBUG
xfree(dup);
#endif
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Dump the AST corresponding to the given string to a string. For supported options, see Prism::parse.
Source
static VALUE
dump_file(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
VALUE value = dump_input(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Dump the AST corresponding to the given file to a string. For supported options, see Prism::parse.
Source
static VALUE
lex(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
VALUE result = parse_lex_input(&input, &options, false);
pm_string_free(&input);
pm_options_free(&options);
return result;
}
Return a LexResult instance that contains an array of Token instances corresponding to the given string. For supported options, see Prism::parse.
Source
# File lib/prism.rb, line 68 def self.lex_compat(source, **options) LexCompat.new(source, **options).result # steep:ignore end
Returns a parse result whose value is an array of tokens that closely resembles the return value of Ripper::lex. The main difference is that the :on_sp token is not emitted.
For supported options, see Prism::parse.
Source
static VALUE
lex_file(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
VALUE value = parse_lex_input(&input, &options, false);
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Return a LexResult instance that contains an array of Token instances corresponding to the given file. For supported options, see Prism::parse.
Source
# File lib/prism.rb, line 78 def self.lex_ripper(source) LexRipper.new(source).result # steep:ignore end
This lexes with the Ripper lex. It drops any space events but otherwise returns the same tokens. Raises SyntaxError if the syntax in source is invalid.
Source
# File lib/prism.rb, line 86 def self.load(source, serialized, freeze = false) Serialize.load_parse(source, serialized, freeze) end
Load the serialized AST using the source as a reference into a tree.
Source
static VALUE
parse(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
#ifdef PRISM_BUILD_DEBUG
size_t length = pm_string_length(&input);
char* dup = xmalloc(length);
memcpy(dup, pm_string_source(&input), length);
pm_string_constant_init(&input, dup, length);
#endif
VALUE value = parse_input(&input, &options);
#ifdef PRISM_BUILD_DEBUG
xfree(dup);
#endif
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Parse the given string and return a ParseResult instance. The options that are supported are:
-
command_line- either nil or a string of the various options that were set on the command line. Valid values are combinations of “a”, “l”, “n”, “p”, and “x”. -
encoding- the encoding of the source being parsed. This should be an encoding or nil. -
filepath- the filepath of the source being parsed. This should be a string or nil. -
freeze- whether or not to deeply freeze the AST. This should be a boolean or nil. -
frozen_string_literal- whether or not the frozen string literal pragma has been set. This should be a boolean or nil. -
line- the line number that the parse starts on. This should be an integer or nil. Note that this is 1-indexed. -
main_script- a boolean indicating whether or not the source being parsed is the main script being run by the interpreter. This controls whether or not shebangs are parsed for additional flags and whether or not the parser will attempt to find a matching shebang if the first one does not contain the word “ruby”. -
partial_script- when the file being parsed is considered a “partial” script, jumps will not be marked as errors if they are not contained within loops/blocks. This is used in the case that you’re parsing a script that you know will be embedded inside another script later, but you do not have that context yet. For example, when parsing an ERB template that will be evaluated inside another script. -
scopes- the locals that are in scope surrounding the code that is being parsed. This should be an array of arrays of symbols or nil. Scopes are ordered from the outermost scope to the innermost one. -
version- the version of Ruby syntax that prism should used to parse Ruby code. By default prism assumes you want to parse with the latest version of Ruby syntax (which you can trigger withnilor"latest"). You may also restrict the syntax to a specific version of Ruby, e.g., with"3.3.0". To parse with the same syntax version that the current Ruby is running useversion: "current". Raises ArgumentError if the version is not currently supported byPrism.
Source
static VALUE
parse_comments(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
VALUE result = parse_input_comments(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return result;
}
Parse the given string and return an array of Comment objects. For supported options, see Prism::parse.
Source
static VALUE
parse_failure_p(int argc, VALUE *argv, VALUE self) {
return RTEST(parse_success_p(argc, argv, self)) ? Qfalse : Qtrue;
}
Parse the given string and return true if it parses with errors. For supported options, see Prism::parse.
Source
static VALUE
parse_file(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
VALUE value = parse_input(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Parse the given file and return a ParseResult instance. For supported options, see Prism::parse.
Source
static VALUE
parse_file_comments(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
VALUE value = parse_input_comments(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Parse the given file and return an array of Comment objects. For supported options, see Prism::parse.
Source
static VALUE
parse_file_failure_p(int argc, VALUE *argv, VALUE self) {
return RTEST(parse_file_success_p(argc, argv, self)) ? Qfalse : Qtrue;
}
Parse the given file and return true if it parses with errors. For supported options, see Prism::parse.
Source
static VALUE
parse_file_success_p(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
VALUE result = parse_input_success_p(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return result;
}
Parse the given file and return true if it parses without errors. For supported options, see Prism::parse.
Source
static VALUE
parse_lex(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
VALUE value = parse_lex_input(&input, &options, true);
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Parse the given string and return a ParseLexResult instance that contains a 2-element array, where the first element is the AST and the second element is an array of Token instances.
This API is only meant to be used in the case where you need both the AST and the tokens. If you only need one or the other, use either Prism::parse or Prism::lex.
For supported options, see Prism::parse.
Source
static VALUE
parse_lex_file(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
VALUE value = parse_lex_input(&input, &options, true);
pm_string_free(&input);
pm_options_free(&options);
return value;
}
Parse the given file and return a ParseLexResult instance that contains a 2-element array, where the first element is the AST and the second element is an array of Token instances.
This API is only meant to be used in the case where you need both the AST and the tokens. If you only need one or the other, use either Prism::parse_file or Prism::lex_file.
For supported options, see Prism::parse.
Source
static VALUE
parse_stream(int argc, VALUE *argv, VALUE self) {
VALUE stream;
VALUE keywords;
rb_scan_args(argc, argv, "1:", &stream, &keywords);
pm_options_t options = { 0 };
extract_options(&options, Qnil, keywords);
pm_parser_t parser;
pm_buffer_t buffer;
pm_node_t *node = pm_parse_stream(&parser, &buffer, (void *) stream, parse_stream_fgets, parse_stream_eof, &options);
rb_encoding *encoding = rb_enc_find(parser.encoding->name);
VALUE source = pm_source_new(&parser, encoding, options.freeze);
VALUE value = pm_ast_new(&parser, node, encoding, source, options.freeze);
VALUE result = parse_result_create(rb_cPrismParseResult, &parser, value, encoding, source, options.freeze);
pm_node_destroy(&parser, node);
pm_buffer_free(&buffer);
pm_parser_free(&parser);
return result;
}
Parse the given object that responds to gets and return a ParseResult instance. The options that are supported are the same as Prism::parse.
Source
static VALUE
parse_success_p(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
VALUE result = parse_input_success_p(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return result;
}
Parse the given string and return true if it parses without errors. For supported options, see Prism::parse.
Source
static VALUE
profile(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
string_options(argc, argv, &input, &options);
profile_input(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return Qnil;
}
Parse the given string and return nothing. This method is meant to allow profilers to avoid the overhead of reifying the AST to Ruby. For supported options, see Prism::parse.
Source
static VALUE
profile_file(int argc, VALUE *argv, VALUE self) {
pm_string_t input;
pm_options_t options = { 0 };
VALUE encoded_filepath;
file_options(argc, argv, &input, &options, &encoded_filepath);
profile_input(&input, &options);
pm_string_free(&input);
pm_options_free(&options);
return Qnil;
}
Parse the given file and return nothing. This method is meant to allow profilers to avoid the overhead of reifying the AST to Ruby. For supported options, see Prism::parse.
Source
# File lib/prism/parse_result.rb, line 908 def self.scope(locals: [], forwarding: []) Scope.new(locals, forwarding) end
Create a new scope with the given locals and forwarding options that is suitable for passing into one of the Prism.* methods that accepts the scopes option.
Private Class Methods
Source
# File lib/prism/ffi.rb, line 447 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
Convert the given options into a serialized options string.
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
Return the value that should be dumped for the command_line option.
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/ 3 else if current raise CurrentVersionError, RUBY_VERSION else raise ArgumentError, "invalid version: #{version}" end end end
Return the value that should be dumped for the version option.