class YARP::InterpolatedRegularExpressionNode

Represents a regular expression literal that contains interpolation.

/foo #{bar} baz/
^^^^^^^^^^^^^^^^

Attributes

closing_loc[R]

attr_reader closing_loc: Location

opening_loc[R]

attr_reader opening_loc: Location

parts[R]

attr_reader parts: Array

Public Class Methods

new(opening_loc, parts, closing_loc, flags, location) click to toggle source

def initialize: (opening_loc: Location, parts: Array, closing_loc: Location, flags: Integer, location: Location) -> void

# File yarp/node.rb, line 6034
def initialize(opening_loc, parts, closing_loc, flags, location)
  @opening_loc = opening_loc
  @parts = parts
  @closing_loc = closing_loc
  @flags = flags
  @location = location
end

Public Instance Methods

accept(visitor) click to toggle source

def accept: (visitor: Visitor) -> void

# File yarp/node.rb, line 6043
def accept(visitor)
  visitor.visit_interpolated_regular_expression_node(self)
end

ascii_8bit?() click to toggle source

def ascii_8bit?: () -> bool

# File yarp/node.rb, line 6112
def ascii_8bit?
  flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
end

child_nodes() click to toggle source

def child_nodes: () -> Array[nil | Node]

# File yarp/node.rb, line 6053
def child_nodes
  [*parts]
end

Also aliased as: deconstruct

closing() click to toggle source

def closing: () -> String

# File yarp/node.rb, line 6087
def closing
  closing_loc.slice
end

comment_targets() click to toggle source

def comment_targets: () -> Array[Node | Location]

# File yarp/node.rb, line 6058
def comment_targets
  [opening_loc, *parts, closing_loc]
end

copy(**params) click to toggle source

def copy: (**params) -> InterpolatedRegularExpressionNode

# File yarp/node.rb, line 6063
def copy(**params)
  InterpolatedRegularExpressionNode.new(
    params.fetch(:opening_loc) { opening_loc },
    params.fetch(:parts) { parts },
    params.fetch(:closing_loc) { closing_loc },
    params.fetch(:flags) { flags },
    params.fetch(:location) { location },
  )
end

deconstruct()

def deconstruct: () -> Array[nil | Node]

Alias for: child_nodes

deconstruct_keys(keys) click to toggle source

# File yarp/node.rb, line 6077
def deconstruct_keys(keys)
  { opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, flags: flags, location: location }
end

euc_jp?() click to toggle source

def euc_jp?: () -> bool

# File yarp/node.rb, line 6107
def euc_jp?
  flags.anybits?(RegularExpressionFlags::EUC_JP)
end

extended?() click to toggle source

def extended?: () -> bool

# File yarp/node.rb, line 6097
def extended?
  flags.anybits?(RegularExpressionFlags::EXTENDED)
end

ignore_case?() click to toggle source

def ignore_case?: () -> bool

# File yarp/node.rb, line 6092
def ignore_case?
  flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
end

inspect(inspector = NodeInspector.new) click to toggle source

# File yarp/node.rb, line 6131
def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
  inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
  inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
  flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
  inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
  inspector.to_str
end

multi_line?() click to toggle source

def multi_line?: () -> bool

# File yarp/node.rb, line 6102
def multi_line?
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
end

once?() click to toggle source

def once?: () -> bool

# File yarp/node.rb, line 6127
def once?
  flags.anybits?(RegularExpressionFlags::ONCE)
end

opening() click to toggle source

def opening: () -> String

# File yarp/node.rb, line 6082
def opening
  opening_loc.slice
end

options() click to toggle source

Returns a numeric value that represents the flags that were used to create the regular expression. This mirrors the Regexp#options method in Ruby. Note that this is effectively masking only the three common flags that are used in Ruby, and does not include the full set of flags like encoding.

# File yarp.rb, line 597
def options
  flags & 0b111
end

set_newline_flag(newline_marked) click to toggle source

# File yarp/node.rb, line 6047
def set_newline_flag(newline_marked)
  first = parts.first
  first.set_newline_flag(newline_marked) if first
end

utf_8?() click to toggle source

def utf_8?: () -> bool

# File yarp/node.rb, line 6122
def utf_8?
  flags.anybits?(RegularExpressionFlags::UTF_8)
end

windows_31j?() click to toggle source

def windows_31j?: () -> bool

# File yarp/node.rb, line 6117
def windows_31j?
  flags.anybits?(RegularExpressionFlags::WINDOWS_31J)
end