Module: Prism

Defined in:
lib/prism.rb,
lib/prism/ffi.rb,
lib/prism/pack.rb,
lib/prism/debug.rb,
lib/prism/pattern.rb,
lib/prism/node_ext.rb,
lib/prism/lex_compat.rb,
lib/prism/translation.rb,
lib/prism/parse_result.rb,
lib/prism/ripper_compat.rb,
lib/prism/node_inspector.rb,
lib/prism/desugar_compiler.rb,
lib/prism/translation/parser.rb,
lib/prism/parse_result/comments.rb,
lib/prism/parse_result/newlines.rb,
lib/prism/translation/parser/lexer.rb,
lib/prism/translation/parser/rubocop.rb,
lib/prism/translation/parser/compiler.rb

Overview

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

Defined Under Namespace

Modules: Pack, Translation Classes: Comment, ConstantPathNode, ConstantPathTargetNode, ConstantReadNode, DesugarCompiler, EmbDocComment, FloatNode, ImaginaryNode, InlineComment, IntegerNode, InterpolatedMatchLastLineNode, InterpolatedRegularExpressionNode, InterpolatedStringNode, InterpolatedXStringNode, Location, MagicComment, MatchLastLineNode, NodeInspector, ParametersNode, ParseError, ParseResult, ParseWarning, Pattern, RationalNode, RegularExpressionNode, RipperCompat, Source, StringNode, Token, XStringNode

Constant Summary collapse

BACKEND = 
:FFI
VERSION =

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

LibRubyParser.pm_version.read_string

Class Method Summary collapse

Class Method Details

.dump(code, **options) ⇒ Object

Mirror the Prism.dump API by using the serialization API.



182
183
184
185
186
187
 
# 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) ⇒ Object

Mirror the Prism.dump_file API by using the serialization API.



190
191
192
193
194
 
# 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) ⇒ Object

Mirror the Prism.lex API by using the serialization API.



197
198
199
200
201
202
 
# 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

.lex_compat(source, **options) ⇒ Object

:call-seq:

Prism::lex_compat(source, **options) -> ParseResult

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.



47
48
49
 
# File 'lib/prism.rb', line 47

def self.lex_compat(source, **options)
  LexCompat.new(source, **options).result
end

.lex_file(filepath, **options) ⇒ Object

Mirror the Prism.lex_file API by using the serialization API.



205
206
207
208
209
 
# 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

.lex_ripper(source) ⇒ Object

:call-seq:

Prism::lex_ripper(source) -> Array

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.



57
58
59
 
# File 'lib/prism.rb', line 57

def self.lex_ripper(source)
  LexRipper.new(source).result
end

.load(source, serialized) ⇒ Object

:call-seq:

Prism::load(source, serialized) -> ParseResult

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



65
66
67
 
# File 'lib/prism.rb', line 65

def self.load(source, serialized)
  Serialize.load(source, serialized)
end

.parse(code, **options) ⇒ Object

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



212
213
214
 
# File 'lib/prism/ffi.rb', line 212

def parse(code, **options)
  Prism.load(code, dump(code, **options))
end

.parse_comments(code, **options) ⇒ Object

Mirror the Prism.parse_comments API by using the serialization API.



226
227
228
229
230
231
232
233
234
235
236
237
238
 
# 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

.parse_failure?(source, **options) ⇒ Boolean

:call-seq:

Prism::parse_failure?(source, **options) -> bool

Returns true if the source parses with errors.

Returns:

  • (Boolean) 


73
74
75
 
# File 'lib/prism.rb', line 73

def self.parse_failure?(source, **options)
  !parse_success?(source, **options)
end

.parse_file(filepath, **options) ⇒ Object

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.



219
220
221
222
223
 
# 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) ⇒ Object

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.



243
244
245
246
247
 
# 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

.parse_file_failure?(filepath, **options) ⇒ Boolean

:call-seq:

Prism::parse_file_failure?(filepath, **options) -> bool

Returns true if the file at filepath parses with errors.

Returns:

  • (Boolean) 


81
82
83
 
# File 'lib/prism.rb', line 81

def self.parse_file_failure?(filepath, **options)
  !parse_file_success?(filepath, **options)
end

.parse_file_success?(filepath, **options) ⇒ Boolean

Mirror the Prism.parse_file_success? API by using the serialization API.

Returns:

  • (Boolean) 


278
279
280
281
282
 
# 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) ⇒ Object

Mirror the Prism.parse_lex API by using the serialization API.



250
251
252
253
254
255
256
257
258
259
260
261
262
263
 
# 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) ⇒ Object

Mirror the Prism.parse_lex_file API by using the serialization API.



266
267
268
269
270
 
# 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) ⇒ Boolean

Mirror the Prism.parse_success? API by using the serialization API.

Returns:

  • (Boolean) 


273
274
275
 
# File 'lib/prism/ffi.rb', line 273

def parse_success?(code, **options)
  LibRubyParser.pm_parse_success_p(code, code.bytesize, dump_options(options))
end