class Prism::Translation::RubyParser::Compiler
A prism visitor that builds Sexp objects.
Attributes
This is the name of the file that we are compiling. We set it on every Sexp object that is generated, and also use it to compile __FILE__ nodes.
Class variables will change their type based on if they are inside of a method definition or not, so we need to track that state.
Some nodes will change their representation if they are inside of a pattern, so we need to track that state.
Public Class Methods
Source
# File lib/prism/translation/ruby_parser.rb, line 31 def initialize(file, in_def: false, in_pattern: false) @file = file @in_def = in_def @in_pattern = in_pattern end
Initialize a new compiler with the given file name.
Public Instance Methods
Source
# File lib/prism/translation/ruby_parser.rb, line 45 def visit_alias_global_variable_node(node) s(node, :valias, node.new_name.name, node.old_name.name) end
alias $foo $bar ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 39 def visit_alias_method_node(node) s(node, :alias, visit(node.new_name), visit(node.old_name)) end
alias foo bar ^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 51 def visit_alternation_pattern_node(node) s(node, :or, visit(node.left), visit(node.right)) end
foo => bar | baz
^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 57
def visit_and_node(node)
left = visit(node.left)
if left[0] == :and
# ruby_parser has the and keyword as right-associative as opposed to
# prism which has it as left-associative. We reverse that
# associativity here.
nest = left
nest = nest[2] while nest[2][0] == :and
nest[2] = s(node, :and, nest[2], visit(node.right))
left
else
s(node, :and, left, visit(node.right))
end
end a and b ^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 108 def visit_arguments_node(node) raise "Cannot visit arguments directly" end
foo(bar)
^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 75
def visit_array_node(node)
if in_pattern
s(node, :array_pat, nil).concat(visit_all(node.elements))
else
s(node, :array).concat(visit_all(node.elements))
end
end -
^^
Source
# File lib/prism/translation/ruby_parser.rb, line 85
def visit_array_pattern_node(node)
if node.constant.nil? && node.requireds.empty? && node.rest.nil? && node.posts.empty?
s(node, :array_pat)
else
result = s(node, :array_pat, visit_pattern_constant(node.constant)).concat(visit_all(node.requireds))
case node.rest
when SplatNode
result << :"*#{node.rest.expression&.name}"
when ImplicitRestNode
result << :*
# This doesn't make any sense at all, but since we're trying to
# replicate the behavior directly, we'll copy it.
result.line(666)
end
result.concat(visit_all(node.posts))
end
end foo => [bar]
^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 114 def visit_assoc_node(node) [visit(node.key), visit(node.value)] end
{ a: 1 }
^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 123
def visit_assoc_splat_node(node)
if node.value.nil?
[s(node, :kwsplat)]
else
[s(node, :kwsplat, visit(node.value))]
end
end def foo(**); bar(**); end
^^
{ **foo }
^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 133
def visit_back_reference_read_node(node)
s(node, :back_ref, node.name.name.delete_prefix("$").to_sym)
end $+ ^^
Source
# File lib/prism/translation/ruby_parser.rb, line 139
def visit_begin_node(node)
result = node.statements.nil? ? s(node, :nil) : visit(node.statements)
if !node.rescue_clause.nil?
if !node.statements.nil?
result = s(node.statements, :rescue, result, visit(node.rescue_clause))
else
result = s(node.rescue_clause, :rescue, visit(node.rescue_clause))
end
current = node.rescue_clause
until (current = current.subsequent).nil?
result << visit(current)
end
end
if !node.else_clause&.statements.nil?
result << visit(node.else_clause)
end
if !node.ensure_clause.nil?
if !node.statements.nil? || !node.rescue_clause.nil? || !node.else_clause.nil?
result = s(node.statements || node.rescue_clause || node.else_clause || node.ensure_clause, :ensure, result, visit(node.ensure_clause))
else
result = s(node.ensure_clause, :ensure, visit(node.ensure_clause))
end
end
result
end begin end ^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 172
def visit_block_argument_node(node)
s(node, :block_pass).tap do |result|
result << visit(node.expression) unless node.expression.nil?
end
end foo(&bar)
^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 180 def visit_block_local_variable_node(node) node.name end
foo { |; bar| }
^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 185 def visit_block_node(node) s(node, :block_pass, visit(node.expression)) end
A block on a keyword or method call.
Source
# File lib/prism/translation/ruby_parser.rb, line 191
def visit_block_parameter_node(node)
:"&#{node.name}"
end def foo(&bar); end
^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 196
def visit_block_parameters_node(node)
# If this block parameters has no parameters and is using pipes, then
# it inherits its location from its shadow locals, even if they're not
# on the same lines as the pipes.
shadow_loc = true
result =
if node.parameters.nil?
s(node, :args)
else
shadow_loc = false
visit(node.parameters)
end
if node.opening == "("
result.line = node.opening_loc.start_line
result.line_max = node.closing_loc.end_line
shadow_loc = false
end
if node.locals.any?
shadow = s(node, :shadow).concat(visit_all(node.locals))
shadow.line = node.locals.first.location.start_line
shadow.line_max = node.locals.last.location.end_line
result << shadow
if shadow_loc
result.line = shadow.line
result.line_max = shadow.line_max
end
end
result
end A block’s parameters.
Source
# File lib/prism/translation/ruby_parser.rb, line 236
def visit_break_node(node)
if node.arguments.nil?
s(node, :break)
elsif node.arguments.arguments.length == 1
s(node, :break, visit(node.arguments.arguments.first))
else
s(node, :break, s(node.arguments, :array).concat(visit_all(node.arguments.arguments)))
end
end break ^^^^^
break foo ^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 304
def visit_call_and_write_node(node)
if op_asgn?(node)
s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"&&")
else
s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"&&", visit_write_value(node.value))
end
end foo.bar &&= baz ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 254
def visit_call_node(node)
case node.name
when :!~
return s(node, :not, visit(node.copy(name: :"=~")))
when :=~
if node.arguments&.arguments&.length == 1 && node.block.nil?
case node.receiver
when StringNode
return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
when RegularExpressionNode, InterpolatedRegularExpressionNode
return s(node, :match2, visit(node.receiver), visit(node.arguments.arguments.first))
end
case node.arguments.arguments.first
when RegularExpressionNode, InterpolatedRegularExpressionNode
return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
end
end
end
type = node.attribute_write? ? :attrasgn : :call
type = :"safe_#{type}" if node.safe_navigation?
arguments = node.arguments&.arguments || []
write_value = arguments.pop if type == :attrasgn
block = node.block
if block.is_a?(BlockArgumentNode)
arguments << block
block = nil
end
result = s(node, type, visit(node.receiver), node.name).concat(visit_all(arguments))
result << visit_write_value(write_value) unless write_value.nil?
visit_block(node, result, block)
end foo ^^^
foo.bar ^^^^^^^
foo.bar() {} ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 294
def visit_call_operator_write_node(node)
if op_asgn?(node)
s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, node.binary_operator)
else
s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.binary_operator, visit_write_value(node.value))
end
end foo.bar += baz ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 314
def visit_call_or_write_node(node)
if op_asgn?(node)
s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"||")
else
s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"||", visit_write_value(node.value))
end
end foo.bar ||= baz ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 337 def visit_call_target_node(node) s(node, :attrasgn, visit(node.receiver), node.name) end
foo.bar, = 1 ^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 343 def visit_capture_pattern_node(node) visit(node.target) << visit(node.value) end
foo => bar => baz
^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 355 def visit_case_match_node(node) s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause) end
case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 349 def visit_case_node(node) s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause) end
case foo; when bar; end ^^^^^^^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 361
def visit_class_node(node)
name =
if node.constant_path.is_a?(ConstantReadNode)
node.name
else
visit(node.constant_path)
end
if node.body.nil?
s(node, :class, name, visit(node.superclass))
elsif node.body.is_a?(StatementsNode)
compiler = copy_compiler(in_def: false)
s(node, :class, name, visit(node.superclass)).concat(node.body.body.map { |child| child.accept(compiler) })
else
s(node, :class, name, visit(node.superclass), node.body.accept(copy_compiler(in_def: false)))
end
end class Foo; end ^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 402 def visit_class_variable_and_write_node(node) s(node, :op_asgn_and, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value))) end
@@foo &&= bar ^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 396 def visit_class_variable_operator_write_node(node) s(node, class_variable_write_type, node.name, s(node, :call, s(node, :cvar, node.name), node.binary_operator, visit_write_value(node.value))) end
@@foo += bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 408 def visit_class_variable_or_write_node(node) s(node, :op_asgn_or, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value))) end
@@foo ||= bar ^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 381 def visit_class_variable_read_node(node) s(node, :cvar, node.name) end
@@foo ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 414 def visit_class_variable_target_node(node) s(node, class_variable_write_type, node.name) end
@@foo, = bar ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 390 def visit_class_variable_write_node(node) s(node, class_variable_write_type, node.name, visit_write_value(node.value)) end
@@foo = 1 ^^^^^^^^^
@@foo, @@bar = 1 ^^^^^ ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 447 def visit_constant_and_write_node(node) s(node, :op_asgn_and, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value))) end
Foo &&= bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 441 def visit_constant_operator_write_node(node) s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.binary_operator, visit_write_value(node.value))) end
Foo += bar ^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 453 def visit_constant_or_write_node(node) s(node, :op_asgn_or, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value))) end
Foo ||= bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 490 def visit_constant_path_and_write_node(node) s(node, :op_asgn_and, visit(node.target), visit_write_value(node.value)) end
Foo::Bar &&= baz ^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 465
def visit_constant_path_node(node)
if node.parent.nil?
s(node, :colon3, node.name)
else
s(node, :colon2, visit(node.parent), node.name)
end
end Foo::Bar ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 484 def visit_constant_path_operator_write_node(node) s(node, :op_asgn, visit(node.target), node.binary_operator, visit_write_value(node.value)) end
Foo::Bar += baz ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 496 def visit_constant_path_or_write_node(node) s(node, :op_asgn_or, visit(node.target), visit_write_value(node.value)) end
Foo::Bar ||= baz ^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 502
def visit_constant_path_target_node(node)
inner =
if node.parent.nil?
s(node, :colon3, node.name)
else
s(node, :colon2, visit(node.parent), node.name)
end
s(node, :const, inner)
end Foo::Bar, = baz ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 478 def visit_constant_path_write_node(node) s(node, :cdecl, visit(node.target), visit_write_value(node.value)) end
Foo::Bar = 1 ^^^^^^^^^^^^
Foo::Foo, Bar::Bar = 1 ^^^^^^^^ ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 426 def visit_constant_read_node(node) s(node, :const, node.name) end
Foo ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 459 def visit_constant_target_node(node) s(node, :cdecl, node.name) end
Foo, = bar ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 435 def visit_constant_write_node(node) s(node, :cdecl, node.name, visit_write_value(node.value)) end
Foo = 1 ^^^^^^^
Foo, Bar = 1 ^^^ ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 518
def visit_def_node(node)
name = node.name_loc.slice.to_sym
result =
if node.receiver.nil?
s(node, :defn, name)
else
s(node, :defs, visit(node.receiver), name)
end
result.line(node.name_loc.start_line)
if node.parameters.nil?
result << s(node, :args).line(node.name_loc.start_line)
else
result << visit(node.parameters)
end
if node.body.nil?
result << s(node, :nil)
elsif node.body.is_a?(StatementsNode)
compiler = copy_compiler(in_def: true)
result.concat(node.body.body.map { |child| child.accept(compiler) })
else
result << node.body.accept(copy_compiler(in_def: true))
end
end def foo; end ^^^^^^^^^^^^
def self.foo; end ^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 549 def visit_defined_node(node) s(node, :defined, visit(node.value)) end
defined? a ^^^^^^^^^^
defined?(a) ^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 555 def visit_else_node(node) visit(node.statements) end
if foo then bar else baz end
^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 561 def visit_embedded_statements_node(node) result = s(node, :evstr) result << visit(node.statements) unless node.statements.nil? result end
“foo #{bar}”
^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 569 def visit_embedded_variable_node(node) s(node, :evstr, visit(node.variable)) end
“foo #@bar”
^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 575 def visit_ensure_node(node) node.statements.nil? ? s(node, :nil) : visit(node.statements) end
begin; foo; ensure; bar; end
^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 581 def visit_false_node(node) s(node, :false) end
false ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 587
def visit_find_pattern_node(node)
s(node, :find_pat, visit_pattern_constant(node.constant), :"*#{node.left.expression&.name}", *visit_all(node.requireds), :"*#{node.right.expression&.name}")
end foo => [*, bar, *]
^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 593
def visit_flip_flop_node(node)
if node.left.is_a?(IntegerNode) && node.right.is_a?(IntegerNode)
s(node, :lit, Range.new(node.left.value, node.right.value, node.exclude_end?))
else
s(node, node.exclude_end? ? :flip3 : :flip2, visit(node.left), visit(node.right))
end
end if foo .. bar; end
^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 603 def visit_float_node(node) s(node, :lit, node.value) end
1.0 ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 609 def visit_for_node(node) s(node, :for, visit(node.collection), visit(node.index), visit(node.statements)) end
for foo in bar do end ^^^^^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 615 def visit_forwarding_arguments_node(node) s(node, :forward_args) end
def foo(…); bar(…); end
^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 621 def visit_forwarding_parameter_node(node) s(node, :forward_args) end
def foo(…); end
^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 630 def visit_forwarding_super_node(node) visit_block(node, s(node, :zsuper), node.block) end
super ^^^^^
super {} ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 657 def visit_global_variable_and_write_node(node) s(node, :op_asgn_and, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value))) end
$foo &&= bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 651 def visit_global_variable_operator_write_node(node) s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.binary_operator, visit(node.value))) end
$foo += bar ^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 663 def visit_global_variable_or_write_node(node) s(node, :op_asgn_or, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value))) end
$foo ||= bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 636 def visit_global_variable_read_node(node) s(node, :gvar, node.name) end
$foo ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 669 def visit_global_variable_target_node(node) s(node, :gasgn, node.name) end
$foo, = bar ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 645 def visit_global_variable_write_node(node) s(node, :gasgn, node.name, visit_write_value(node.value)) end
$foo = 1 ^^^^^^^^
$foo, $bar = 1 ^^^^ ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 675
def visit_hash_node(node)
s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
end {} ^^
Source
# File lib/prism/translation/ruby_parser.rb, line 681
def visit_hash_pattern_node(node)
result = s(node, :hash_pat, visit_pattern_constant(node.constant)).concat(node.elements.flat_map { |element| visit(element) })
case node.rest
when AssocSplatNode
result << s(node.rest, :kwrest, :"**#{node.rest.value&.name}")
when NoKeywordsParameterNode
result << visit(node.rest)
end
result
end foo => {}
^^
Source
# File lib/prism/translation/ruby_parser.rb, line 702 def visit_if_node(node) s(node, :if, visit(node.predicate), visit(node.statements), visit(node.subsequent)) end
if foo then bar end ^^^^^^^^^^^^^^^^^^^
bar if foo ^^^^^^^^^^
foo ? bar : baz ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 707 def visit_imaginary_node(node) s(node, :lit, node.value) end
1i
Source
# File lib/prism/translation/ruby_parser.rb, line 713 def visit_implicit_node(node) end
{ foo: }
^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 718 def visit_implicit_rest_node(node) end
foo { |bar,| }
^
Source
# File lib/prism/translation/ruby_parser.rb, line 723
def visit_in_node(node)
pattern =
if node.pattern.is_a?(ConstantPathNode)
s(node.pattern, :const, visit(node.pattern))
else
node.pattern.accept(copy_compiler(in_pattern: true))
end
s(node, :in, pattern).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
end case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 749
def visit_index_and_write_node(node)
arglist = nil
if !node.arguments.nil? || !node.block.nil?
arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
arglist << visit(node.block) if !node.block.nil?
end
s(node, :op_asgn1, visit(node.receiver), arglist, :"&&", visit_write_value(node.value))
end foo &&= baz ^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 736
def visit_index_operator_write_node(node)
arglist = nil
if !node.arguments.nil? || !node.block.nil?
arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
arglist << visit(node.block) if !node.block.nil?
end
s(node, :op_asgn1, visit(node.receiver), arglist, node.binary_operator, visit_write_value(node.value))
end foo += baz ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 762
def visit_index_or_write_node(node)
arglist = nil
if !node.arguments.nil? || !node.block.nil?
arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
arglist << visit(node.block) if !node.block.nil?
end
s(node, :op_asgn1, visit(node.receiver), arglist, :"||", visit_write_value(node.value))
end foo ||= baz ^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 775 def visit_index_target_node(node) arguments = visit_all(node.arguments&.arguments || []) arguments << visit(node.block) unless node.block.nil? s(node, :attrasgn, visit(node.receiver), :[]=).concat(arguments) end
foo, = 1 ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 805 def visit_instance_variable_and_write_node(node) s(node, :op_asgn_and, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value))) end
@foo &&= bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 799 def visit_instance_variable_operator_write_node(node) s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.binary_operator, visit_write_value(node.value))) end
@foo += bar ^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 811 def visit_instance_variable_or_write_node(node) s(node, :op_asgn_or, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value))) end
@foo ||= bar ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 784 def visit_instance_variable_read_node(node) s(node, :ivar, node.name) end
@foo ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 817 def visit_instance_variable_target_node(node) s(node, :iasgn, node.name) end
@foo, = bar ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 793 def visit_instance_variable_write_node(node) s(node, :iasgn, node.name, visit_write_value(node.value)) end
@foo = 1 ^^^^^^^^
@foo, @bar = 1 ^^^^ ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 823 def visit_integer_node(node) s(node, :lit, node.value) end
1 ^
Source
# File lib/prism/translation/ruby_parser.rb, line 829
def visit_interpolated_match_last_line_node(node)
parts = visit_interpolated_parts(node.parts)
regexp =
if parts.length == 1
s(node, :lit, Regexp.new(parts.first, node.options))
else
s(node, :dregx).concat(parts).tap do |result|
options = node.options
result << options if options != 0
end
end
s(node, :match, regexp)
end if /foo #{bar}/ then end
^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 846
def visit_interpolated_regular_expression_node(node)
parts = visit_interpolated_parts(node.parts)
if parts.length == 1
s(node, :lit, Regexp.new(parts.first, node.options))
else
s(node, :dregx).concat(parts).tap do |result|
options = node.options
result << options if options != 0
end
end
end /foo #{bar}/ ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 861 def visit_interpolated_string_node(node) parts = visit_interpolated_parts(node.parts) parts.length == 1 ? s(node, :str, parts.first) : s(node, :dstr).concat(parts) end
“foo #{bar}” ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 868 def visit_interpolated_symbol_node(node) parts = visit_interpolated_parts(node.parts) parts.length == 1 ? s(node, :lit, parts.first.to_sym) : s(node, :dsym).concat(parts) end
:“foo #{bar}” ^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 875 def visit_interpolated_x_string_node(node) source = node.heredoc? ? node.parts.first : node parts = visit_interpolated_parts(node.parts) parts.length == 1 ? s(source, :xstr, parts.first) : s(source, :dxstr).concat(parts) end
‘foo #{bar}` ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 956 def visit_it_local_variable_read_node(node) s(node, :call, nil, :it) end
-> { it }
^^
Source
# File lib/prism/translation/ruby_parser.rb, line 962
def visit_keyword_hash_node(node)
s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
end foo(bar: baz)
^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 971
def visit_keyword_rest_parameter_node(node)
:"**#{node.name}"
end def foo(**bar); end
^^^^^
def foo(**); end
^^
Source
# File lib/prism/translation/ruby_parser.rb, line 976
def visit_lambda_node(node)
parameters =
case node.parameters
when nil, NumberedParametersNode
s(node, :args)
else
visit(node.parameters)
end
if node.body.nil?
s(node, :iter, s(node, :lambda), parameters)
else
s(node, :iter, s(node, :lambda), parameters, visit(node.body))
end
end -> {}
Source
# File lib/prism/translation/ruby_parser.rb, line 1019 def visit_local_variable_and_write_node(node) s(node, :op_asgn_and, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value))) end
foo &&= bar ^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1013 def visit_local_variable_operator_write_node(node) s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.binary_operator, visit_write_value(node.value))) end
foo += bar ^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1025 def visit_local_variable_or_write_node(node) s(node, :op_asgn_or, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value))) end
foo ||= bar ^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 994
def visit_local_variable_read_node(node)
if node.name.match?(/^_\d$/)
s(node, :call, nil, node.name)
else
s(node, :lvar, node.name)
end
end foo ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1031 def visit_local_variable_target_node(node) s(node, :lasgn, node.name) end
foo, = bar ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1007 def visit_local_variable_write_node(node) s(node, :lasgn, node.name, visit_write_value(node.value)) end
foo = 1 ^^^^^^^
foo, bar = 1 ^^^ ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1037 def visit_match_last_line_node(node) s(node, :match, s(node, :lit, Regexp.new(node.unescaped, node.options))) end
if /foo/ then end
^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1043 def visit_match_predicate_node(node) s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil) end
foo in bar ^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1049 def visit_match_required_node(node) s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil) end
foo => bar ^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1055 def visit_match_write_node(node) s(node, :match2, visit(node.call.receiver), visit(node.call.arguments.arguments.first)) end
/(?<foo>foo)/ =~ bar ^^^^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1062 def visit_missing_node(node) raise "Cannot visit missing node directly" end
A node that is missing from the syntax tree. This is only used in the case of a syntax error. The parser gem doesn’t have such a concept, so we invent our own here.
Source
# File lib/prism/translation/ruby_parser.rb, line 1068
def visit_module_node(node)
name =
if node.constant_path.is_a?(ConstantReadNode)
node.name
else
visit(node.constant_path)
end
if node.body.nil?
s(node, :module, name)
elsif node.body.is_a?(StatementsNode)
compiler = copy_compiler(in_def: false)
s(node, :module, name).concat(node.body.body.map { |child| child.accept(compiler) })
else
s(node, :module, name, node.body.accept(copy_compiler(in_def: false)))
end
end module Foo; end ^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1088 def visit_multi_target_node(node) targets = [*node.lefts] targets << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode) targets.concat(node.rights) s(node, :masgn, s(node, :array).concat(visit_all(targets))) end
foo, bar = baz ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1098
def visit_multi_write_node(node)
targets = [*node.lefts]
targets << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
targets.concat(node.rights)
value =
if node.value.is_a?(ArrayNode) && node.value.opening_loc.nil?
if node.value.elements.length == 1 && node.value.elements.first.is_a?(SplatNode)
visit(node.value.elements.first)
else
visit(node.value)
end
else
s(node.value, :to_ary, visit(node.value))
end
s(node, :masgn, s(node, :array).concat(visit_all(targets)), value)
end foo, bar = baz ^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1122
def visit_next_node(node)
if node.arguments.nil?
s(node, :next)
elsif node.arguments.arguments.length == 1
argument = node.arguments.arguments.first
s(node, :next, argument.is_a?(SplatNode) ? s(node, :svalue, visit(argument)) : visit(argument))
else
s(node, :next, s(node, :array).concat(visit_all(node.arguments.arguments)))
end
end next ^^^^
next foo ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1135 def visit_nil_node(node) s(node, :nil) end
nil ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1141 def visit_no_keywords_parameter_node(node) in_pattern ? s(node, :kwrest, :"**nil") : :"**nil" end
def foo(**nil); end
^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1147 def visit_numbered_parameters_node(node) raise "Cannot visit numbered parameters directly" end
-> { _1 + _2 } ^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1153 def visit_numbered_reference_read_node(node) s(node, :nth_ref, node.number) end
$1 ^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1159 def visit_optional_keyword_parameter_node(node) s(node, :kwarg, node.name, visit(node.value)) end
def foo(bar: baz); end
^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1165 def visit_optional_parameter_node(node) s(node, :lasgn, node.name, visit(node.value)) end
def foo(bar = 1); end
^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1171
def visit_or_node(node)
left = visit(node.left)
if left[0] == :or
# ruby_parser has the or keyword as right-associative as opposed to
# prism which has it as left-associative. We reverse that
# associativity here.
nest = left
nest = nest[2] while nest[2][0] == :or
nest[2] = s(node, :or, nest[2], visit(node.right))
left
else
s(node, :or, left, visit(node.right))
end
end a or b ^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1189
def visit_parameters_node(node)
children =
node.compact_child_nodes.map do |element|
if element.is_a?(MultiTargetNode)
visit_destructured_parameter(element)
else
visit(element)
end
end
s(node, :args).concat(children)
end def foo(bar, *baz); end
^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1227
def visit_parentheses_node(node)
if node.body.nil?
s(node, :nil)
else
visit(node.body)
end
end () ^^
(1) ^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1237 def visit_pinned_expression_node(node) node.expression.accept(copy_compiler(in_pattern: false)) end
foo => ^(bar)
^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1243
def visit_pinned_variable_node(node)
if node.variable.is_a?(LocalVariableReadNode) && node.variable.name.match?(/^_\d$/)
s(node, :lvar, node.variable.name)
else
visit(node.variable)
end
end foo = 1 and bar => ^foo
^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1252 def visit_post_execution_node(node) s(node, :iter, s(node, :postexe), 0, visit(node.statements)) end
END {}
Source
# File lib/prism/translation/ruby_parser.rb, line 1257 def visit_pre_execution_node(node) s(node, :iter, s(node, :preexe), 0, visit(node.statements)) end
BEGIN {}
Source
# File lib/prism/translation/ruby_parser.rb, line 1262 def visit_program_node(node) visit(node.statements) end
The top-level program node.
Source
# File lib/prism/translation/ruby_parser.rb, line 1268
def visit_range_node(node)
if !in_pattern && !node.left.nil? && !node.right.nil? && ([node.left.type, node.right.type] - %i[nil_node integer_node]).empty?
left = node.left.value if node.left.is_a?(IntegerNode)
right = node.right.value if node.right.is_a?(IntegerNode)
s(node, :lit, Range.new(left, right, node.exclude_end?))
else
s(node, node.exclude_end? ? :dot3 : :dot2, visit_range_bounds_node(node.left), visit_range_bounds_node(node.right))
end
end 0..5 ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1290 def visit_rational_node(node) s(node, :lit, node.value) end
1r ^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1296 def visit_redo_node(node) s(node, :redo) end
redo ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1302 def visit_regular_expression_node(node) s(node, :lit, Regexp.new(node.unescaped, node.options)) end
/foo/ ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1308 def visit_required_keyword_parameter_node(node) s(node, :kwarg, node.name) end
def foo(bar:); end
^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1314 def visit_required_parameter_node(node) node.name end
def foo(bar); end
^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1320 def visit_rescue_modifier_node(node) s(node, :rescue, visit(node.expression), s(node.rescue_expression, :resbody, s(node.rescue_expression, :array), visit(node.rescue_expression))) end
foo rescue bar ^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1326
def visit_rescue_node(node)
exceptions =
if node.exceptions.length == 1 && node.exceptions.first.is_a?(SplatNode)
visit(node.exceptions.first)
else
s(node, :array).concat(visit_all(node.exceptions))
end
if !node.reference.nil?
exceptions << (visit(node.reference) << s(node.reference, :gvar, :"$!"))
end
s(node, :resbody, exceptions).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
end begin; rescue; end
^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1346
def visit_rest_parameter_node(node)
:"*#{node.name}"
end def foo(*bar); end
^^^^
def foo(*); end
^
Source
# File lib/prism/translation/ruby_parser.rb, line 1352 def visit_retry_node(node) s(node, :retry) end
retry ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1361
def visit_return_node(node)
if node.arguments.nil?
s(node, :return)
elsif node.arguments.arguments.length == 1
argument = node.arguments.arguments.first
s(node, :return, argument.is_a?(SplatNode) ? s(node, :svalue, visit(argument)) : visit(argument))
else
s(node, :return, s(node, :array).concat(visit_all(node.arguments.arguments)))
end
end return ^^^^^^
return 1 ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1374 def visit_self_node(node) s(node, :self) end
self ^^^^
Source
A shareable constant.
Source
# File lib/prism/translation/ruby_parser.rb, line 1385
def visit_singleton_class_node(node)
s(node, :sclass, visit(node.expression)).tap do |sexp|
sexp << node.body.accept(copy_compiler(in_def: false)) unless node.body.nil?
end
end class << self; end ^^^^^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1393 def visit_source_encoding_node(node) # TODO s(node, :colon2, s(node, :const, :Encoding), :UTF_8) end
__ENCODING__ ^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1400 def visit_source_file_node(node) s(node, :str, node.filepath) end
__FILE__ ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1406 def visit_source_line_node(node) s(node, :lit, node.location.start_line) end
__LINE__ ^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1418
def visit_splat_node(node)
if node.expression.nil?
s(node, :splat)
else
s(node, :splat, visit(node.expression))
end
end foo(*bar)
^^^^
def foo((bar, *baz)); end
^^^^
def foo(*); bar(*); end
^
Source
# File lib/prism/translation/ruby_parser.rb, line 1427
def visit_statements_node(node)
first, *rest = node.body
if rest.empty?
visit(first)
else
s(node, :block).concat(visit_all(node.body))
end
end A list of statements.
Source
# File lib/prism/translation/ruby_parser.rb, line 1439
def visit_string_node(node)
unescaped = node.unescaped
if node.forced_binary_encoding?
unescaped.force_encoding(Encoding::BINARY)
end
s(node, :str, unescaped)
end “foo” ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1451
def visit_super_node(node)
arguments = node.arguments&.arguments || []
block = node.block
if block.is_a?(BlockArgumentNode)
arguments << block
block = nil
end
visit_block(node, s(node, :super).concat(visit_all(arguments)), block)
end super(foo) ^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1465 def visit_symbol_node(node) node.value == "!@" ? s(node, :lit, :"!@") : s(node, :lit, node.unescaped.to_sym) end
:foo ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1471 def visit_true_node(node) s(node, :true) end
true ^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1477
def visit_undef_node(node)
names = node.names.map { |name| s(node, :undef, visit(name)) }
names.length == 1 ? names.first : s(node, :block).concat(names)
end undef foo ^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1487 def visit_unless_node(node) s(node, :if, visit(node.predicate), visit(node.else_clause), visit(node.statements)) end
unless foo; bar end ^^^^^^^^^^^^^^^^^^^
bar unless foo ^^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1496 def visit_until_node(node) s(node, :until, visit(node.predicate), visit(node.statements), !node.begin_modifier?) end
until foo; bar end ^^^^^^^^^^^^^^^^^
bar until foo ^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1502 def visit_when_node(node) s(node, :when, s(node, :array).concat(visit_all(node.conditions))).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body)) end
case foo; when bar; end
^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1511 def visit_while_node(node) s(node, :while, visit(node.predicate), visit(node.statements), !node.begin_modifier?) end
while foo; bar end ^^^^^^^^^^^^^^^^^^
bar while foo ^^^^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1517
def visit_x_string_node(node)
result = s(node, :xstr, node.unescaped)
if node.heredoc?
result.line = node.content_loc.start_line
result.line_max = node.content_loc.end_line
end
result
end ‘foo` ^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 1533 def visit_yield_node(node) s(node, :yield).concat(visit_all(node.arguments&.arguments || [])) end
yield ^^^^^
yield 1 ^^^^^^^
Private Instance Methods
Source
# File lib/prism/translation/ruby_parser.rb, line 420
def class_variable_write_type
in_def ? :cvasgn : :cvdecl
end If a class variable is written within a method definition, it has a different type than everywhere else.
Source
# File lib/prism/translation/ruby_parser.rb, line 1540 def copy_compiler(in_def: self.in_def, in_pattern: self.in_pattern) Compiler.new(file, in_def: in_def, in_pattern: in_pattern) end
Create a new compiler with the given options.
Source
# File lib/prism/translation/ruby_parser.rb, line 325
def op_asgn?(node)
node.call_operator == "::" || (node.value.is_a?(CallNode) && node.value.opening_loc.nil? && !node.value.arguments.nil?)
end Call nodes with operators following them will either be op_asgn or op_asgn2 nodes. That is determined by their call operator and their right-hand side.
Source
# File lib/prism/translation/ruby_parser.rb, line 331
def op_asgn_type(node, type)
node.safe_navigation? ? :"safe_#{type}" : type
end Call nodes with operators following them can use &. as an operator, which changes their type by prefixing “safe_”.
Source
# File lib/prism/translation/ruby_parser.rb, line 1545 def s(node, *arguments) result = Sexp.new(*arguments) result.file = file result.line = node.location.start_line result.line_max = node.location.end_line result end
Create a new Sexp object from the given prism node and arguments.
Source
# File lib/prism/translation/ruby_parser.rb, line 1555
def visit_block(node, sexp, block)
if block.nil?
sexp
else
parameters =
case block.parameters
when nil, NumberedParametersNode
0
else
visit(block.parameters)
end
if block.body.nil?
s(node, :iter, sexp, parameters)
else
s(node, :iter, sexp, parameters, visit(block.body))
end
end
end Visit a block node, which will modify the AST by wrapping the given visited node in an iter node.
Source
# File lib/prism/translation/ruby_parser.rb, line 1204
def visit_destructured_parameter(node)
children =
[*node.lefts, *node.rest, *node.rights].map do |child|
case child
when RequiredParameterNode
visit(child)
when MultiTargetNode
visit_destructured_parameter(child)
when SplatNode
:"*#{child.expression&.name}"
else
raise
end
end
s(node, :masgn).concat(children)
end def foo((bar, baz)); end
^^^^^^^^^^
Source
# File lib/prism/translation/ruby_parser.rb, line 882
def visit_interpolated_parts(parts)
visited = []
parts.each do |part|
result = visit(part)
if result[0] == :evstr && result[1]
if result[1][0] == :str
visited << result[1]
elsif result[1][0] == :dstr
visited.concat(result[1][1..-1])
else
visited << result
end
visited << :space
elsif result[0] == :dstr
if !visited.empty? && part.parts[0].is_a?(StringNode)
# If we are in the middle of an implicitly concatenated string,
# we should not have a bare string as the first part. In this
# case we need to visit just that first part and then we can
# push the rest of the parts onto the visited array.
result[1] = visit(part.parts[0])
end
visited.concat(result[1..-1])
else
visited << result
end
end
state = :beginning #: :beginning | :string_content | :interpolated_content
results = []
visited.each_with_index do |result, index|
case state
when :beginning
if result.is_a?(String)
results << result
state = :string_content
elsif result.is_a?(Array) && result[0] == :str
results << result[1]
state = :string_content
else
results << ""
results << result
state = :interpolated_content
end
when :string_content
if result == :space
# continue
elsif result.is_a?(String)
results[0] << result
elsif result.is_a?(Array) && result[0] == :str
results[0] << result[1]
else
results << result
state = :interpolated_content
end
when :interpolated_content
if result == :space
# continue
elsif visited[index - 1] != :space && result.is_a?(Array) && result[0] == :str && results[-1][0] == :str && (results[-1].line_max == result.line)
results[-1][1] << result[1]
results[-1].line_max = result.line_max
else
results << result
end
end
end
results
end Visit the interpolated content of the string-like node.
Source
# File lib/prism/translation/ruby_parser.rb, line 1576
def visit_pattern_constant(node)
case node
when nil
# nothing
when ConstantReadNode
visit(node)
else
s(node, :const, visit(node))
end
end Pattern constants get wrapped in another layer of :const.
Source
# File lib/prism/translation/ruby_parser.rb, line 1280
def visit_range_bounds_node(node)
if node.is_a?(ParenthesesNode) && node.body.nil?
s(node, :begin)
else
visit(node)
end
end If the bounds of a range node are empty parentheses, then they do not get replaced by their usual s(:nil), but instead are s(:begin).
Source
# File lib/prism/translation/ruby_parser.rb, line 1590
def visit_write_value(node)
if node.is_a?(ArrayNode) && node.opening_loc.nil?
if node.elements.length == 1 && node.elements.first.is_a?(SplatNode)
s(node, :svalue, visit(node.elements.first))
else
s(node, :svalue, visit(node))
end
else
visit(node)
end
end Visit the value of a write, which will be on the right-hand side of a write operator. Because implicit arrays can have splats, those could potentially be wrapped in an svalue node.
Ruby Core © 1993–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.