# module Prism

The `Prism` Ruby parser.

“Parsing Ruby is suddenly manageable!”

    - You, hopefully

This file is generated by the templates/template.rb script and should not be modified manually. See templates/lib/prism/compiler.rb.erb if you are looking to modify the template

This file is generated by the templates/template.rb script and should not be modified manually. See templates/lib/prism/dispatcher.rb.erb if you are looking to modify the template

This file is generated by the templates/template.rb script and should not be modified manually. See templates/lib/prism/dsl.rb.erb if you are looking to modify the template

This file is generated by the templates/template.rb script and should not be modified manually. See templates/lib/prism/mutation_compiler.rb.erb if you are looking to modify the template

This file is generated by the templates/template.rb script and should not be modified manually. See templates/lib/prism/node.rb.erb if you are looking to modify the template

Here we are reopening the prism module to provide methods on nodes that aren’t templated and are meant as convenience methods.

This file is generated by the templates/template.rb script and should not be modified manually. See templates/lib/prism/visitor.rb.erb if you are looking to modify the template

### Constants

BACKEND
VERSION

  The version constant is set by reading the result of calling pm_version.

### Public Class Methods

dump(code, **options) click to toggle source

Mirror the `Prism.dump` API by using the serialization 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) click to toggle source

Mirror the `Prism.dump_file` API by using the serialization 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) click to toggle source

Mirror the `Prism.lex` API by using the serialization 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 click to toggle source

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`.

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

lex_file(filepath, **options) click to toggle source

Mirror the `Prism.lex_file` API by using the serialization 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 click to toggle source

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.

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

Prism::load(source, serialized) → ParseResult click to toggle source

Load the serialized AST using the source as a reference into a tree.

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

parse(code, **options) click to toggle source

Mirror the `Prism.parse` API by using the serialization API.

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

parse_comments(code, **options) click to toggle source

Mirror the `Prism.parse_comments` API by using the serialization 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 click to toggle source

Returns true if the source parses with errors.

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

parse_file(filepath, **options) click to toggle source

Mirror the `Prism.parse_file` API by using the serialization API. This uses native strings instead of Ruby strings because it allows us to use mmap when it is available.

    # 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) click to toggle source

Mirror the `Prism.parse_file_comments` API by using the serialization API. This uses native strings instead of Ruby strings because it allows us to use mmap when it is available.

    # 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 click to toggle source

Returns true if the file at filepath parses with errors.

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

parse_file_success?(filepath, **options) click to toggle source

Mirror the `Prism.parse_file_success?` API by using the serialization 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) click to toggle source

Mirror the `Prism.parse_lex` API by using the serialization 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) click to toggle source

Mirror the `Prism.parse_lex_file` API by using the serialization 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) click to toggle source

Mirror the `Prism.parse_success?` API by using the serialization 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

### Private Class Methods

dump_options(options) click to toggle source

Convert the given options into a serialized options string.

    # 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