123456789_123456789_123456789_123456789_123456789_

Module: Prism

Overview

The Prism Ruby parser.

“Parsing Ruby is suddenly manageable!”

- You, hopefully

Constant Summary

Class Method Summary

Class Method Details

.dump(code, **options)

Mirror the dump API by using the serialization API.

[ GitHub ] 

  


# 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)  
  



  

    

Mirror the dump_file API by using the serialization API.


  



  [ GitHub ]


  

  


# 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


  








  

    .dump_options(options)   (private)
  



  

    

Convert the given options into a serialized options string.


  



  [ GitHub ]


  

  


# 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


  








  

    .lex(code, **options)  
  



  

    

Mirror the lex API by using the serialization API.


  



  [ GitHub ]


  

  


# 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)  ⇒ 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 .parse.


  



  [ GitHub ]


  

  


# File 'lib/prism.rb', line 46



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


  








  

    .lex_file(filepath, **options)  
  



  

    

Mirror the lex_file API by using the serialization API.


  



  [ GitHub ]


  

  


# 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)  ⇒ 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.


  



  [ GitHub ]


  

  


# File 'lib/prism.rb', line 56



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


  








  

    .load(source, serialized)  ⇒ ParseResult   



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/prism.rb', line 64



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


  








  

    .parse(code, **options)  
  



  

    

Mirror the parse API by using the serialization API.


  



  [ GitHub ]


  

  


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



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


  








  

    .parse_comments(code, **options)  
  



  

    

Mirror the parse_comments API by using the serialization API.


  



  [ GitHub ]


  

  


# 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   



  

    

Returns true if the source parses with errors.


  



  [ GitHub ]


  

  


# File 'lib/prism.rb', line 72



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


  








  

    .parse_file(filepath, **options)  
  



  

    

Mirror the 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.


  



  [ GitHub ]


  

  


# 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)  
  



  

    

Mirror the 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.


  



  [ GitHub ]


  

  


# 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   



  

    

Returns true if the file at filepath parses with errors.


  



  [ GitHub ]


  

  


# File 'lib/prism.rb', line 80



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


  








  

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



  

    

Mirror the parse_file_success? API by using the serialization API.


  





  


  [ GitHub ]


  

  


# 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)  
  



  

    

Mirror the parse_lex API by using the serialization API.


  



  [ GitHub ]


  

  


# 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)  
  



  

    

Mirror the parse_lex_file API by using the serialization API.


  



  [ GitHub ]


  

  


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


  





  


  [ GitHub ]


  

  


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



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