aboutsummaryrefslogtreecommitdiffstats
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/prism.rb54
-rw-r--r--lib/prism/debug.rb12
-rw-r--r--lib/prism/desugar_compiler.rb2
-rw-r--r--lib/prism/ffi.rb116
-rw-r--r--lib/prism/lex_compat.rb16
-rw-r--r--lib/prism/node_ext.rb4
-rw-r--r--lib/prism/node_inspector.rb2
-rw-r--r--lib/prism/pack.rb2
-rw-r--r--lib/prism/parse_result.rb10
-rw-r--r--lib/prism/parse_result/comments.rb2
-rw-r--r--lib/prism/parse_result/newlines.rb2
-rw-r--r--lib/prism/pattern.rb26
-rw-r--r--lib/prism/prism.gemspec138
-rw-r--r--lib/prism/ripper_compat.rb10
14 files changed, 198 insertions, 198 deletions
diff --git a/lib/prism.rb b/lib/prism.rb
index 4d111b072f..b45098480a 100644
--- a/lib/prism.rb
+++ b/lib/prism.rb
@@ -1,25 +1,25 @@
# frozen_string_literal: true
-module YARP
- # There are many files in YARP that are templated to handle every node type,
+module Prism
+ # There are many files in prism that are templated to handle every node type,
# which means the files can end up being quite large. We autoload them to make
# our require speed faster since consuming libraries are unlikely to use all
# of these features.
- autoload :BasicVisitor, "yarp/visitor"
- autoload :Compiler, "yarp/compiler"
- autoload :Debug, "yarp/debug"
- autoload :DesugarCompiler, "yarp/desugar_compiler"
- autoload :Dispatcher, "yarp/dispatcher"
- autoload :DSL, "yarp/dsl"
- autoload :LexCompat, "yarp/lex_compat"
- autoload :LexRipper, "yarp/lex_compat"
- autoload :MutationCompiler, "yarp/mutation_compiler"
- autoload :NodeInspector, "yarp/node_inspector"
- autoload :RipperCompat, "yarp/ripper_compat"
- autoload :Pack, "yarp/pack"
- autoload :Pattern, "yarp/pattern"
- autoload :Serialize, "yarp/serialize"
- autoload :Visitor, "yarp/visitor"
+ autoload :BasicVisitor, "prism/visitor"
+ autoload :Compiler, "prism/compiler"
+ autoload :Debug, "prism/debug"
+ autoload :DesugarCompiler, "prism/desugar_compiler"
+ autoload :Dispatcher, "prism/dispatcher"
+ autoload :DSL, "prism/dsl"
+ autoload :LexCompat, "prism/lex_compat"
+ autoload :LexRipper, "prism/lex_compat"
+ autoload :MutationCompiler, "prism/mutation_compiler"
+ autoload :NodeInspector, "prism/node_inspector"
+ autoload :RipperCompat, "prism/ripper_compat"
+ autoload :Pack, "prism/pack"
+ autoload :Pattern, "prism/pattern"
+ autoload :Serialize, "prism/serialize"
+ autoload :Visitor, "prism/visitor"
# Some of these constants are not meant to be exposed, so marking them as
# private here.
@@ -47,18 +47,18 @@ module YARP
end
end
-require_relative "yarp/node"
-require_relative "yarp/node_ext"
-require_relative "yarp/parse_result"
-require_relative "yarp/parse_result/comments"
-require_relative "yarp/parse_result/newlines"
+require_relative "prism/node"
+require_relative "prism/node_ext"
+require_relative "prism/parse_result"
+require_relative "prism/parse_result/comments"
+require_relative "prism/parse_result/newlines"
-# This is a Ruby implementation of the YARP parser. If we're running on CRuby
-# and we haven't explicitly set the YARP_FFI_BACKEND environment variable, then
+# This is a Ruby implementation of the prism parser. If we're running on CRuby
+# and we haven't explicitly set the PRISM_FFI_BACKEND environment variable, then
# it's going to require the built library. Otherwise, it's going to require a
# module that uses FFI to call into the library.
-if RUBY_ENGINE == "ruby" and !ENV["YARP_FFI_BACKEND"]
- require "yarp/yarp"
+if RUBY_ENGINE == "ruby" and !ENV["PRISM_FFI_BACKEND"]
+ require "prism/prism"
else
- require_relative "yarp/ffi"
+ require_relative "prism/ffi"
end
diff --git a/lib/prism/debug.rb b/lib/prism/debug.rb
index 39df1e838c..9c6756ff35 100644
--- a/lib/prism/debug.rb
+++ b/lib/prism/debug.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
# This module is used for testing and debugging and is not meant to be used by
# consumers of this library.
module Debug
@@ -77,11 +77,11 @@ module YARP
end
end
- # For the given source, parses with YARP and returns a list of all of the
+ # For the given source, parses with prism and returns a list of all of the
# sets of local variables that were encountered.
- def self.yarp_locals(source)
+ def self.prism_locals(source)
locals = []
- stack = [YARP.parse(source).value]
+ stack = [Prism.parse(source).value]
while (node = stack.pop)
case node
@@ -91,7 +91,7 @@ module YARP
params = node.parameters
params = params&.parameters unless node.is_a?(DefNode)
- # YARP places parameters in the same order that they appear in the
+ # prism places parameters in the same order that they appear in the
# source. CRuby places them in the order that they need to appear
# according to their own internal calling convention. We mimic that
# order here so that we can compare properly.
@@ -147,7 +147,7 @@ module YARP
end
def self.newlines(source)
- YARP.parse(source).source.offsets
+ Prism.parse(source).source.offsets
end
def self.parse_serialize_file(filepath)
diff --git a/lib/prism/desugar_compiler.rb b/lib/prism/desugar_compiler.rb
index b86e8518c6..232c6ecb37 100644
--- a/lib/prism/desugar_compiler.rb
+++ b/lib/prism/desugar_compiler.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
# DesugarCompiler is a compiler that desugars Ruby code into a more primitive
# form. This is useful for consumers that want to deal with fewer node types.
class DesugarCompiler < MutationCompiler
diff --git a/lib/prism/ffi.rb b/lib/prism/ffi.rb
index 82643be808..3ff1875611 100644
--- a/lib/prism/ffi.rb
+++ b/lib/prism/ffi.rb
@@ -6,7 +6,7 @@
require "rbconfig"
require "ffi"
-module YARP
+module Prism
BACKEND = :FFI
module LibRubyParser
@@ -35,13 +35,13 @@ module YARP
def self.load_exported_functions_from(header, *functions)
File.foreach(File.expand_path("../../include/#{header}", __dir__)) do |line|
# We only want to attempt to load exported functions.
- next unless line.start_with?("YP_EXPORTED_FUNCTION ")
+ next unless line.start_with?("PRISM_EXPORTED_FUNCTION ")
# We only want to load the functions that we are interested in.
next unless functions.any? { |function| line.include?(function) }
# Parse the function declaration.
- unless /^YP_EXPORTED_FUNCTION (?<return_type>.+) (?<name>\w+)\((?<arg_types>.+)\);$/ =~ line
+ unless /^PRISM_EXPORTED_FUNCTION (?<return_type>.+) (?<name>\w+)\((?<arg_types>.+)\);$/ =~ line
raise "Could not parse #{line}"
end
@@ -67,35 +67,35 @@ module YARP
end
load_exported_functions_from(
- "yarp.h",
- "yp_version",
- "yp_parse_serialize",
- "yp_lex_serialize",
- "yp_parse_lex_serialize"
+ "prism.h",
+ "pm_version",
+ "pm_parse_serialize",
+ "pm_lex_serialize",
+ "pm_parse_lex_serialize"
)
load_exported_functions_from(
- "yarp/util/yp_buffer.h",
- "yp_buffer_sizeof",
- "yp_buffer_init",
- "yp_buffer_value",
- "yp_buffer_length",
- "yp_buffer_free"
+ "prism/util/pm_buffer.h",
+ "pm_buffer_sizeof",
+ "pm_buffer_init",
+ "pm_buffer_value",
+ "pm_buffer_length",
+ "pm_buffer_free"
)
load_exported_functions_from(
- "yarp/util/yp_string.h",
- "yp_string_mapped_init",
- "yp_string_free",
- "yp_string_source",
- "yp_string_length",
- "yp_string_sizeof"
+ "prism/util/pm_string.h",
+ "pm_string_mapped_init",
+ "pm_string_free",
+ "pm_string_source",
+ "pm_string_length",
+ "pm_string_sizeof"
)
- # This object represents a yp_buffer_t. We only use it as an opaque pointer,
- # so it doesn't need to know the fields of yp_buffer_t.
- class YPBuffer
- SIZEOF = LibRubyParser.yp_buffer_sizeof
+ # This object represents a pm_buffer_t. We only use it as an opaque pointer,
+ # so it doesn't need to know the fields of pm_buffer_t.
+ class PrismBuffer
+ SIZEOF = LibRubyParser.pm_buffer_sizeof
attr_reader :pointer
@@ -104,11 +104,11 @@ module YARP
end
def value
- LibRubyParser.yp_buffer_value(pointer)
+ LibRubyParser.pm_buffer_value(pointer)
end
def length
- LibRubyParser.yp_buffer_length(pointer)
+ LibRubyParser.pm_buffer_length(pointer)
end
def read
@@ -121,19 +121,19 @@ module YARP
pointer = FFI::MemoryPointer.new(SIZEOF)
begin
- raise unless LibRubyParser.yp_buffer_init(pointer)
+ raise unless LibRubyParser.pm_buffer_init(pointer)
yield new(pointer)
ensure
- LibRubyParser.yp_buffer_free(pointer)
+ LibRubyParser.pm_buffer_free(pointer)
pointer.free
end
end
end
- # This object represents a yp_string_t. We only use it as an opaque pointer,
+ # This object represents a pm_string_t. We only use it as an opaque pointer,
# so it doesn't have to be an FFI::Struct.
- class YPString
- SIZEOF = LibRubyParser.yp_string_sizeof
+ class PrismString
+ SIZEOF = LibRubyParser.pm_string_sizeof
attr_reader :pointer
@@ -142,93 +142,93 @@ module YARP
end
def source
- LibRubyParser.yp_string_source(pointer)
+ LibRubyParser.pm_string_source(pointer)
end
def length
- LibRubyParser.yp_string_length(pointer)
+ LibRubyParser.pm_string_length(pointer)
end
def read
source.read_string(length)
end
- # Yields a yp_string_t pointer to the given block.
+ # Yields a pm_string_t pointer to the given block.
def self.with(filepath, &block)
pointer = FFI::MemoryPointer.new(SIZEOF)
begin
- raise unless LibRubyParser.yp_string_mapped_init(pointer, filepath)
+ raise unless LibRubyParser.pm_string_mapped_init(pointer, filepath)
yield new(pointer)
ensure
- LibRubyParser.yp_string_free(pointer)
+ LibRubyParser.pm_string_free(pointer)
pointer.free
end
end
end
def self.dump_internal(source, source_size, filepath)
- YPBuffer.with do |buffer|
+ PrismBuffer.with do |buffer|
metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
- yp_parse_serialize(source, source_size, buffer.pointer, metadata)
+ pm_parse_serialize(source, source_size, buffer.pointer, metadata)
buffer.read
end
end
end
# Mark the LibRubyParser module as private as it should only be called through
- # the YARP module.
+ # the prism module.
private_constant :LibRubyParser
- # The version constant is set by reading the result of calling yp_version.
- VERSION = LibRubyParser.yp_version.read_string
+ # The version constant is set by reading the result of calling pm_version.
+ VERSION = LibRubyParser.pm_version.read_string
- # Mirror the YARP.dump API by using the serialization API.
+ # Mirror the Prism.dump API by using the serialization API.
def self.dump(code, filepath = nil)
LibRubyParser.dump_internal(code, code.bytesize, filepath)
end
- # Mirror the YARP.dump_file API by using the serialization API.
+ # Mirror the Prism.dump_file API by using the serialization API.
def self.dump_file(filepath)
- LibRubyParser::YPString.with(filepath) do |string|
+ LibRubyParser::PrismString.with(filepath) do |string|
LibRubyParser.dump_internal(string.source, string.length, filepath)
end
end
- # Mirror the YARP.lex API by using the serialization API.
+ # Mirror the Prism.lex API by using the serialization API.
def self.lex(code, filepath = nil)
- LibRubyParser::YPBuffer.with do |buffer|
- LibRubyParser.yp_lex_serialize(code, code.bytesize, filepath, buffer.pointer)
+ LibRubyParser::PrismBuffer.with do |buffer|
+ LibRubyParser.pm_lex_serialize(code, code.bytesize, filepath, buffer.pointer)
Serialize.load_tokens(Source.new(code), buffer.read)
end
end
- # Mirror the YARP.lex_file API by using the serialization API.
+ # Mirror the Prism.lex_file API by using the serialization API.
def self.lex_file(filepath)
- LibRubyParser::YPString.with(filepath) do |string|
+ LibRubyParser::PrismString.with(filepath) do |string|
lex(string.read, filepath)
end
end
- # Mirror the YARP.parse API by using the serialization API.
+ # Mirror the Prism.parse API by using the serialization API.
def self.parse(code, filepath = nil)
- YARP.load(code, dump(code, filepath))
+ Prism.load(code, dump(code, filepath))
end
- # Mirror the YARP.parse_file API by using the serialization API. This uses
+ # 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.
def self.parse_file(filepath)
- LibRubyParser::YPString.with(filepath) do |string|
+ LibRubyParser::PrismString.with(filepath) do |string|
parse(string.read, filepath)
end
end
- # Mirror the YARP.parse_lex API by using the serialization API.
+ # Mirror the Prism.parse_lex API by using the serialization API.
def self.parse_lex(code, filepath = nil)
- LibRubyParser::YPBuffer.with do |buffer|
+ LibRubyParser::PrismBuffer.with do |buffer|
metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
- LibRubyParser.yp_parse_lex_serialize(code, code.bytesize, buffer.pointer, metadata)
+ LibRubyParser.pm_parse_lex_serialize(code, code.bytesize, buffer.pointer, metadata)
source = Source.new(code)
loader = Serialize::Loader.new(source, buffer.read)
@@ -242,9 +242,9 @@ module YARP
end
end
- # Mirror the YARP.parse_lex_file API by using the serialization API.
+ # Mirror the Prism.parse_lex_file API by using the serialization API.
def self.parse_lex_file(filepath)
- LibRubyParser::YPString.with(filepath) do |string|
+ LibRubyParser::PrismString.with(filepath) do |string|
parse_lex(string.read, filepath)
end
end
diff --git a/lib/prism/lex_compat.rb b/lib/prism/lex_compat.rb
index 720ac2b59b..afc0f3b605 100644
--- a/lib/prism/lex_compat.rb
+++ b/lib/prism/lex_compat.rb
@@ -2,14 +2,14 @@
require "delegate"
-module YARP
- # This class is responsible for lexing the source using YARP and then
+module Prism
+ # This class is responsible for lexing the source using prism and then
# converting those tokens to be compatible with Ripper. In the vast majority
# of cases, this is a one-to-one mapping of the token type. Everything else
# generally lines up. However, there are a few cases that require special
# handling.
class LexCompat
- # This is a mapping of YARP token types to Ripper token types. This is a
+ # This is a mapping of prism token types to Ripper token types. This is a
# many-to-one mapping because we split up our token types, whereas Ripper
# tends to group them.
RIPPER = {
@@ -339,8 +339,8 @@ module YARP
# Heredocs that are dedenting heredocs are a little more complicated.
# Ripper outputs on_ignored_sp tokens for the whitespace that is being
- # removed from the output. YARP only modifies the node itself and keeps
- # the token the same. This simplifies YARP, but makes comparing against
+ # removed from the output. prism only modifies the node itself and keeps
+ # the token the same. This simplifies prism, but makes comparing against
# Ripper much harder because there is a length mismatch.
#
# Fortunately, we already have to pull out the heredoc tokens in order to
@@ -563,7 +563,7 @@ module YARP
state = :default
heredoc_stack = [[]]
- result = YARP.lex(source, @filepath)
+ result = Prism.lex(source, @filepath)
result_value = result.value
previous_state = nil
@@ -650,7 +650,7 @@ module YARP
IgnoredNewlineToken.new([[lineno, column], event, value, lex_state])
when :on_regexp_end
# On regex end, Ripper scans and then sets end state, so the ripper
- # lexed output is begin, when it should be end. YARP sets lex state
+ # lexed output is begin, when it should be end. prism sets lex state
# correctly to end state, but we want to be able to compare against
# Ripper's lexed state. So here, if it's a regexp end token, we
# output the state as the previous state, solely for the sake of
@@ -706,7 +706,7 @@ module YARP
# The order in which tokens appear in our lexer is different from the
# order that they appear in Ripper. When we hit the declaration of a
- # heredoc in YARP, we skip forward and lex the rest of the content of
+ # heredoc in prism, we skip forward and lex the rest of the content of
# the heredoc before going back and lexing at the end of the heredoc
# identifier.
#
diff --git a/lib/prism/node_ext.rb b/lib/prism/node_ext.rb
index 760b3d75df..08d9e9f36a 100644
--- a/lib/prism/node_ext.rb
+++ b/lib/prism/node_ext.rb
@@ -1,8 +1,8 @@
# frozen_string_literal: true
-# Here we are reopening the YARP module to provide methods on nodes that aren't
+# Here we are reopening the prism module to provide methods on nodes that aren't
# templated and are meant as convenience methods.
-module YARP
+module Prism
class FloatNode < Node
# Returns the value of the node as a Ruby Float.
def value
diff --git a/lib/prism/node_inspector.rb b/lib/prism/node_inspector.rb
index c09840a471..be5b3532db 100644
--- a/lib/prism/node_inspector.rb
+++ b/lib/prism/node_inspector.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
# This object is responsible for generating the output for the inspect method
# implementations of child nodes.
class NodeInspector
diff --git a/lib/prism/pack.rb b/lib/prism/pack.rb
index 83f5569923..5c5f0a34fe 100644
--- a/lib/prism/pack.rb
+++ b/lib/prism/pack.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
module Pack
%i[
SPACE
diff --git a/lib/prism/parse_result.rb b/lib/prism/parse_result.rb
index 2d9d855b86..fafa1ae15f 100644
--- a/lib/prism/parse_result.rb
+++ b/lib/prism/parse_result.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
# This represents a source of Ruby code that has been parsed. It is used in
# conjunction with locations to allow them to resolve line numbers and source
# ranges.
@@ -71,7 +71,7 @@ module YARP
# Returns a string representation of this location.
def inspect
- "#<YARP::Location @start_offset=#{@start_offset} @length=#{@length} start_line=#{start_line}>"
+ "#<Prism::Location @start_offset=#{@start_offset} @length=#{@length} start_line=#{start_line}>"
end
# The source code that this location represents.
@@ -162,7 +162,7 @@ module YARP
end
def inspect
- "#<YARP::Comment @type=#{@type.inspect} @location=#{@location.inspect}>"
+ "#<Prism::Comment @type=#{@type.inspect} @location=#{@location.inspect}>"
end
end
@@ -180,7 +180,7 @@ module YARP
end
def inspect
- "#<YARP::ParseError @message=#{@message.inspect} @location=#{@location.inspect}>"
+ "#<Prism::ParseError @message=#{@message.inspect} @location=#{@location.inspect}>"
end
end
@@ -198,7 +198,7 @@ module YARP
end
def inspect
- "#<YARP::ParseWarning @message=#{@message.inspect} @location=#{@location.inspect}>"
+ "#<Prism::ParseWarning @message=#{@message.inspect} @location=#{@location.inspect}>"
end
end
diff --git a/lib/prism/parse_result/comments.rb b/lib/prism/parse_result/comments.rb
index 88240609b1..fba0b1a5aa 100644
--- a/lib/prism/parse_result/comments.rb
+++ b/lib/prism/parse_result/comments.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
class ParseResult
# When we've parsed the source, we have both the syntax tree and the list of
# comments that we found in the source. This class is responsible for
diff --git a/lib/prism/parse_result/newlines.rb b/lib/prism/parse_result/newlines.rb
index d16600afd0..334f3f2a69 100644
--- a/lib/prism/parse_result/newlines.rb
+++ b/lib/prism/parse_result/newlines.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module YARP
+module Prism
class ParseResult
# The :line tracepoint event gets fired whenever the Ruby VM encounters an
# expression on a new line. The types of expressions that can trigger this
diff --git a/lib/prism/pattern.rb b/lib/prism/pattern.rb
index f7519137e4..3d7d5bea70 100644
--- a/lib/prism/pattern.rb
+++ b/lib/prism/pattern.rb
@@ -1,24 +1,24 @@
# frozen_string_literal: true
-module YARP
+module Prism
# A pattern is an object that wraps a Ruby pattern matching expression. The
# expression would normally be passed to an `in` clause within a `case`
# expression or a rightward assignment expression. For example, in the
# following snippet:
#
# case node
- # in ConstantPathNode[ConstantReadNode[name: :YARP], ConstantReadNode[name: :Pattern]]
+ # in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
# end
#
# the pattern is the `ConstantPathNode[...]` expression.
#
# The pattern gets compiled into an object that responds to #call by running
- # the #compile method. This method itself will run back through YARP to
+ # the #compile method. This method itself will run back through Prism to
# parse the expression into a tree, then walk the tree to generate the
# necessary callable objects. For example, if you wanted to compile the
# expression above into a callable, you would:
#
- # callable = YARP::Pattern.new("ConstantPathNode[ConstantReadNode[name: :YARP], ConstantReadNode[name: :Pattern]]").compile
+ # callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
# callable.call(node)
#
# The callable object returned by #compile is guaranteed to respond to #call
@@ -32,7 +32,7 @@ module YARP
#
# If the query given to the initializer cannot be compiled into a valid
# matcher (either because of a syntax error or because it is using syntax we
- # do not yet support) then a YARP::Pattern::CompilationError will be
+ # do not yet support) then a Prism::Pattern::CompilationError will be
# raised.
class Pattern
# Raised when the query given to a pattern is either invalid Ruby syntax or
@@ -40,15 +40,15 @@ module YARP
class CompilationError < StandardError
def initialize(repr)
super(<<~ERROR)
- YARP was unable to compile the pattern you provided into a usable
+ prism was unable to compile the pattern you provided into a usable
expression. It failed on to understand the node represented by:
#{repr}
Note that not all syntax supported by Ruby's pattern matching syntax
- is also supported by YARP's patterns. If you're using some syntax
+ is also supported by prism's patterns. If you're using some syntax
that you believe should be supported, please open an issue on
- GitHub at https://github.com/ruby/yarp/issues/new.
+ GitHub at https://github.com/ruby/prism/issues/new.
ERROR
end
end
@@ -61,7 +61,7 @@ module YARP
end
def compile
- result = YARP.parse("case nil\nin #{query}\nend")
+ result = Prism.parse("case nil\nin #{query}\nend")
compile_node(result.value.statements.body.last.conditions.last.pattern)
end
@@ -126,11 +126,11 @@ module YARP
combine_or(compile_node(node.left), compile_node(node.right))
end
- # in YARP::ConstantReadNode
+ # in Prism::ConstantReadNode
def compile_constant_path_node(node)
parent = node.parent
- if parent.is_a?(ConstantReadNode) && parent.slice == "YARP"
+ if parent.is_a?(ConstantReadNode) && parent.slice == "Prism"
compile_node(node.child)
else
compile_error(node)
@@ -142,8 +142,8 @@ module YARP
def compile_constant_read_node(node)
value = node.slice
- if YARP.const_defined?(value, false)
- clazz = YARP.const_get(value)
+ if Prism.const_defined?(value, false)
+ clazz = Prism.const_get(value)
->(other) { clazz === other }
elsif Object.const_defined?(value, false)
diff --git a/lib/prism/prism.gemspec b/lib/prism/prism.gemspec
index d1a7bbbbcf..af2555247f 100644
--- a/lib/prism/prism.gemspec
+++ b/lib/prism/prism.gemspec
@@ -1,13 +1,13 @@
# frozen_string_literal: true
Gem::Specification.new do |spec|
- spec.name = "yarp"
+ spec.name = "prism"
spec.version = "0.12.0"
spec.authors = ["Shopify"]
spec.email = ["ruby@shopify.com"]
- spec.summary = "Yet Another Ruby Parser"
- spec.homepage = "https://github.com/ruby/yarp"
+ spec.summary = "Prism Ruby parser"
+ spec.homepage = "https://github.com/ruby/prism"
spec.license = "MIT"
spec.required_ruby_version = ">= 3.0.0"
@@ -33,59 +33,59 @@ Gem::Specification.new do |spec|
"docs/ruby_api.md",
"docs/serialization.md",
"docs/testing.md",
- "ext/yarp/api_node.c",
- "ext/yarp/api_pack.c",
- "ext/yarp/extension.c",
- "ext/yarp/extension.h",
- "include/yarp.h",
- "include/yarp/ast.h",
- "include/yarp/defines.h",
- "include/yarp/diagnostic.h",
- "include/yarp/enc/yp_encoding.h",
- "include/yarp/node.h",
- "include/yarp/pack.h",
- "include/yarp/parser.h",
- "include/yarp/regexp.h",
- "include/yarp/unescape.h",
- "include/yarp/util/yp_buffer.h",
- "include/yarp/util/yp_char.h",
- "include/yarp/util/yp_constant_pool.h",
- "include/yarp/util/yp_list.h",
- "include/yarp/util/yp_memchr.h",
- "include/yarp/util/yp_newline_list.h",
- "include/yarp/util/yp_state_stack.h",
- "include/yarp/util/yp_string.h",
- "include/yarp/util/yp_string_list.h",
- "include/yarp/util/yp_strpbrk.h",
- "include/yarp/version.h",
- "lib/yarp.rb",
- "lib/yarp/compiler.rb",
- "lib/yarp/debug.rb",
- "lib/yarp/desugar_compiler.rb",
- "lib/yarp/dispatcher.rb",
- "lib/yarp/dsl.rb",
- "lib/yarp/ffi.rb",
- "lib/yarp/lex_compat.rb",
- "lib/yarp/mutation_compiler.rb",
- "lib/yarp/node.rb",
- "lib/yarp/node_ext.rb",
- "lib/yarp/node_inspector.rb",
- "lib/yarp/pack.rb",
- "lib/yarp/parse_result.rb",
- "lib/yarp/pattern.rb",
- "lib/yarp/ripper_compat.rb",
- "lib/yarp/serialize.rb",
- "lib/yarp/parse_result/comments.rb",
- "lib/yarp/parse_result/newlines.rb",
- "lib/yarp/visitor.rb",
+ "ext/prism/api_node.c",
+ "ext/prism/api_pack.c",
+ "ext/prism/extension.c",
+ "ext/prism/extension.h",
+ "include/prism.h",
+ "include/prism/ast.h",
+ "include/prism/defines.h",
+ "include/prism/diagnostic.h",
+ "include/prism/enc/pm_encoding.h",
+ "include/prism/node.h",
+ "include/prism/pack.h",
+ "include/prism/parser.h",
+ "include/prism/regexp.h",
+ "include/prism/unescape.h",
+ "include/prism/util/pm_buffer.h",
+ "include/prism/util/pm_char.h",
+ "include/prism/util/pm_constant_pool.h",
+ "include/prism/util/pm_list.h",
+ "include/prism/util/pm_memchr.h",
+ "include/prism/util/pm_newline_list.h",
+ "include/prism/util/pm_state_stack.h",
+ "include/prism/util/pm_string.h",
+ "include/prism/util/pm_string_list.h",
+ "include/prism/util/pm_strpbrk.h",
+ "include/prism/version.h",
+ "lib/prism.rb",
+ "lib/prism/compiler.rb",
+ "lib/prism/debug.rb",
+ "lib/prism/desugar_compiler.rb",
+ "lib/prism/dispatcher.rb",
+ "lib/prism/dsl.rb",
+ "lib/prism/ffi.rb",
+ "lib/prism/lex_compat.rb",
+ "lib/prism/mutation_compiler.rb",
+ "lib/prism/node.rb",
+ "lib/prism/node_ext.rb",
+ "lib/prism/node_inspector.rb",
+ "lib/prism/pack.rb",
+ "lib/prism/parse_result.rb",
+ "lib/prism/pattern.rb",
+ "lib/prism/ripper_compat.rb",
+ "lib/prism/serialize.rb",
+ "lib/prism/parse_result/comments.rb",
+ "lib/prism/parse_result/newlines.rb",
+ "lib/prism/visitor.rb",
"src/diagnostic.c",
- "src/enc/yp_big5.c",
- "src/enc/yp_euc_jp.c",
- "src/enc/yp_gbk.c",
- "src/enc/yp_shift_jis.c",
- "src/enc/yp_tables.c",
- "src/enc/yp_unicode.c",
- "src/enc/yp_windows_31j.c",
+ "src/enc/pm_big5.c",
+ "src/enc/pm_euc_jp.c",
+ "src/enc/pm_gbk.c",
+ "src/enc/pm_shift_jis.c",
+ "src/enc/pm_tables.c",
+ "src/enc/pm_unicode.c",
+ "src/enc/pm_windows_31j.c",
"src/node.c",
"src/pack.c",
"src/prettyprint.c",
@@ -93,21 +93,21 @@ Gem::Specification.new do |spec|
"src/serialize.c",
"src/token_type.c",
"src/unescape.c",
- "src/util/yp_buffer.c",
- "src/util/yp_char.c",
- "src/util/yp_constant_pool.c",
- "src/util/yp_list.c",
- "src/util/yp_memchr.c",
- "src/util/yp_newline_list.c",
- "src/util/yp_state_stack.c",
- "src/util/yp_string.c",
- "src/util/yp_string_list.c",
- "src/util/yp_strncasecmp.c",
- "src/util/yp_strpbrk.c",
- "src/yarp.c",
- "yarp.gemspec",
+ "src/util/pm_buffer.c",
+ "src/util/pm_char.c",
+ "src/util/pm_constant_pool.c",
+ "src/util/pm_list.c",
+ "src/util/pm_memchr.c",
+ "src/util/pm_newline_list.c",
+ "src/util/pm_state_stack.c",
+ "src/util/pm_string.c",
+ "src/util/pm_string_list.c",
+ "src/util/pm_strncasecmp.c",
+ "src/util/pm_strpbrk.c",
+ "src/prism.c",
+ "prism.gemspec",
]
- spec.extensions = ["ext/yarp/extconf.rb"]
+ spec.extensions = ["ext/prism/extconf.rb"]
spec.metadata["allowed_push_host"] = "https://rubygems.org"
end
diff --git a/lib/prism/ripper_compat.rb b/lib/prism/ripper_compat.rb
index c76f3fd07a..e0064196ea 100644
--- a/lib/prism/ripper_compat.rb
+++ b/lib/prism/ripper_compat.rb
@@ -2,14 +2,14 @@
require "ripper"
-module YARP
- # This class is meant to provide a compatibility layer between YARP and
+module Prism
+ # This class is meant to provide a compatibility layer between prism and
# Ripper. It functions by parsing the entire tree first and then walking it
# and executing each of the Ripper callbacks as it goes.
#
# This class is going to necessarily be slower than the native Ripper API. It
- # is meant as a stopgap until developers migrate to using YARP. It is also
- # meant as a test harness for the YARP parser.
+ # is meant as a stopgap until developers migrate to using prism. It is also
+ # meant as a test harness for the prism parser.
class RipperCompat
# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
# returns the arrays of [type, *children].
@@ -156,7 +156,7 @@ module YARP
end
def result
- @result ||= YARP.parse(source)
+ @result ||= Prism.parse(source)
end
def _dispatch0; end
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-04 04:54:34 +0000