class YARP::RegularExpressionNode

Represents a regular expression literal with no interpolation.

/foo/i
^^^^^^

Attributes

closing_loc[R]

attr_reader closing_loc: Location

content_loc[R]

attr_reader content_loc: Location

opening_loc[R]

attr_reader opening_loc: Location

unescaped[R]

attr_reader unescaped: String

Public Class Methods

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

def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void

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

Public Instance Methods

accept(visitor) click to toggle source

def accept: (visitor: Visitor) -> void

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

ascii_8bit?() click to toggle source

def ascii_8bit?: () -> bool

# File yarp/node.rb, line 8965
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 8900
def child_nodes
  []
end

Also aliased as: deconstruct

closing() click to toggle source

def closing: () -> String

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

comment_targets() click to toggle source

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

# File yarp/node.rb, line 8905
def comment_targets
  [opening_loc, content_loc, closing_loc]
end

content() click to toggle source

def content: () -> String

# File yarp/node.rb, line 8935
def content
  content_loc.slice
end

copy(**params) click to toggle source

def copy: (**params) -> RegularExpressionNode

# File yarp/node.rb, line 8910
def copy(**params)
  RegularExpressionNode.new(
    params.fetch(:opening_loc) { opening_loc },
    params.fetch(:content_loc) { content_loc },
    params.fetch(:closing_loc) { closing_loc },
    params.fetch(:unescaped) { unescaped },
    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 8925
def deconstruct_keys(keys)
  { opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, flags: flags, location: location }
end

euc_jp?() click to toggle source

def euc_jp?: () -> bool

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

extended?() click to toggle source

def extended?: () -> bool

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

ignore_case?() click to toggle source

def ignore_case?: () -> bool

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

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

# File yarp/node.rb, line 8984
def inspect(inspector = NodeInspector.new)
  inspector << inspector.header(self)
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
  inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
  inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
  inspector << "├── unescaped: #{unescaped.inspect}\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 8955
def multi_line?
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
end

once?() click to toggle source

def once?: () -> bool

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

opening() click to toggle source

def opening: () -> String

# File yarp/node.rb, line 8930
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 614
def options
  flags & 0b111
end

utf_8?() click to toggle source

def utf_8?: () -> bool

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

windows_31j?() click to toggle source

def windows_31j?: () -> bool

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