123456789_123456789_123456789_123456789_123456789_

Class: Prism::RegularExpressionNode

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Node
Instance Chain:
self, RegularExpressionOptions, Node
Inherits: Prism::Node
Defined in: lib/prism/node.rb,
lib/prism/node_ext.rb,
prism/api_node.c

Overview

Represents a regular expression literal with no interpolation.

/foo/i
^^^^^^

Class Method Summary

Node - Inherited

.fields

Returns a list of the fields that exist for this node class.
.type

Similar to #type, this method returns a symbol that you can use for splitting on the type of the node without having to do a long === chain.

Instance Attribute Summary

Node - Inherited

#newline?

Returns true if the node has the newline flag set.
#node_id

A unique identifier for this node.
#static_literal?

Returns true if the node has the static literal flag set.
#flags

An bitset of flags for this node.
#source

A pointer to the source that this node was created from.
#newline_flag?

Instance Method Summary

RegularExpressionOptions - Included

#options

Returns a numeric value that represents the flags that were used to create the regular expression.

Node - Inherited

#accept

Accepts a visitor and calls back into the specialized visit function.
#breadth_first_search

Returns the first node that matches the given block when visited in a depth-first search.
#cached_end_code_units_column

Delegates to the cached_end_code_units_column of the associated location object.
#cached_end_code_units_offset

Delegates to the cached_end_code_units_offset of the associated location object.
#cached_start_code_units_column

Delegates to the cached_start_code_units_column of the associated location object.
#cached_start_code_units_offset

Delegates to the cached_start_code_units_offset of the associated location object.
#child_nodes

Returns an array of child nodes, including nils in the place of optional nodes that were not present.
#comment_targets

Returns an array of child nodes and locations that could potentially have comments attached to them.
#comments

Delegates to the comments of the associated location object.
#compact_child_nodes

Returns an array of child nodes, excluding any nils in the place of optional nodes that were not present.
#deconstruct

Alias for Node#child_nodes.
#each_child_node

With a block given, yields each child node.
#end_character_column

Delegates to the end_character_column of the associated location object.
#end_character_offset

Delegates to the end_character_offset of the associated location object.
#end_column

Delegates to the end_column of the associated location object.
#end_line

Delegates to the end_line of the associated location object.
#end_offset

The end offset of the node in the source.
#inspect

Returns a string representation of the node.
#leading_comments

Delegates to the leading_comments of the associated location object.
#location

A Location instance that represents the location of this node in the source.
#pretty_print

Similar to inspect, but respects the current level of indentation given by the pretty print object.
#save

Save this node using a saved source so that it can be retrieved later.
#save_location

Save the location using a saved source so that it can be retrieved later.
#script_lines

Alias for Node#source_lines.
#slice

Slice the location of the node from the source.
#slice_lines

Slice the location of the node from the source, starting at the beginning of the line that the location starts on, ending at the end of the line that the location ends on.
#source_lines

Returns all of the lines of the source code associated with this node.
#start_character_column

Delegates to the start_character_column of the associated location object.
#start_character_offset

Delegates to the start_character_offset of the associated location object.
#start_column

Delegates to the start_column of the associated location object.
#start_line

Delegates to the start_line of the associated location object.
#start_offset

The start offset of the node in the source.
#to_dot

Convert this node into a graphviz dot graph string.
#trailing_comments

Delegates to the trailing_comments of the associated location object.
#tunnel

Returns a list of nodes that are descendants of this node that contain the given line and column.
#type

Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform.
#deprecated, #newline_flag!

Constructor Details

.new(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped) ⇒ RegularExpressionNode

Initialize a new RegularExpressionNode node.

[ GitHub ] 

  


# File 'lib/prism/node.rb', line 16364



def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped)
  @source = source
  @node_id = node_id
  @location = location
  @flags = flags
  @opening_loc = opening_loc
  @content_loc = content_loc
  @closing_loc = closing_loc
  @unescaped = unescaped
end


  







Class Method Details



  

    .type  
  



  

    

Return a symbol representation of this node type. See Node::type.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16537



def self.type
  :regular_expression_node
end


  







Instance Attribute Details



  

    #ascii_8bit?  ⇒ Boolean  (readonly)
  



  

    

def ascii_8bit?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16440



def ascii_8bit?
  flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
end


  








  

    #euc_jp?  ⇒ Boolean  (readonly)
  



  

    

def euc_jp?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16435



def euc_jp?
  flags.anybits?(RegularExpressionFlags::EUC_JP)
end


  








  

    #extended?  ⇒ Boolean  (readonly)
  



  

    

def extended?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16420



def extended?
  flags.anybits?(RegularExpressionFlags::EXTENDED)
end


  








  

    #forced_binary_encoding?  ⇒ Boolean  (readonly)
  



  

    

def forced_binary_encoding?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16460



def forced_binary_encoding?
  flags.anybits?(RegularExpressionFlags::FORCED_BINARY_ENCODING)
end


  








  

    #forced_us_ascii_encoding?  ⇒ Boolean  (readonly)
  



  

    

def forced_us_ascii_encoding?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16465



def forced_us_ascii_encoding?
  flags.anybits?(RegularExpressionFlags::FORCED_US_ASCII_ENCODING)
end


  








  

    #forced_utf8_encoding?  ⇒ Boolean  (readonly)
  



  

    

def forced_utf8_encoding?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16455



def forced_utf8_encoding?
  flags.anybits?(RegularExpressionFlags::FORCED_UTF8_ENCODING)
end


  








  

    #ignore_case?  ⇒ Boolean  (readonly)
  



  

    

def ignore_case?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16415



def ignore_case?
  flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
end


  








  

    #multi_line?  ⇒ Boolean  (readonly)
  



  

    

def multi_line?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16425



def multi_line?
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
end


  








  

    #once?  ⇒ Boolean  (readonly)
  



  

    

def once?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16430



def once?
  flags.anybits?(RegularExpressionFlags::ONCE)
end


  








  

    #unescaped   (readonly)
  



  

    

attr_reader unescaped: String


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16509



attr_reader :unescaped


  








  

    #utf_8?  ⇒ Boolean  (readonly)
  



  

    

def utf_8?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16450



def utf_8?
  flags.anybits?(RegularExpressionFlags::UTF_8)
end


  








  

    #windows_31j?  ⇒ Boolean  (readonly)
  



  

    

def windows_31j?: () -> bool


  





  


  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16445



def windows_31j?
  flags.anybits?(RegularExpressionFlags::WINDOWS_31J)
end


  







Instance Method Details



  

    #===(other)  
  



  

    

Implements case-equality for the node. This is effectively == but without comparing the value of locations. Locations are checked only for presence.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16543



def ===(other)
  other.is_a?(RegularExpressionNode) &&
    (flags === other.flags) &&
    (opening_loc.nil? == other.opening_loc.nil?) &&
    (content_loc.nil? == other.content_loc.nil?) &&
    (closing_loc.nil? == other.closing_loc.nil?) &&
    (unescaped === other.unescaped)
end


  








  

    #accept(visitor)  
  



  

    

def accept: (Visitor visitor) -> void


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16376



def accept(visitor)
  visitor.visit_regular_expression_node(self)
end


  








  

    #child_nodes  
    Also known as: #deconstruct
  



  

    

def child_nodes: () -> Array


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16381



def child_nodes
  []
end


  








  

    #closing  
  



  

    

def closing: () -> String


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16522



def closing
  closing_loc.slice
end


  








  

    #closing_loc  
  



  

    

attr_reader closing_loc: Location


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16496



def closing_loc
  location = @closing_loc
  return location if location.is_a?(Location)
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end


  








  

    #comment_targets  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16397



def comment_targets
  [opening_loc, content_loc, closing_loc] #: Array[Prism::node | Location]
end


  








  

    #compact_child_nodes  
  



  

    

def compact_child_nodes: () -> Array


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16392



def compact_child_nodes
  []
end


  








  

    #content  
  



  

    

def content: () -> String


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16517



def content
  content_loc.slice
end


  








  

    #content_loc  
  



  

    

attr_reader content_loc: Location


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16483



def content_loc
  location = @content_loc
  return location if location.is_a?(Location)
  @content_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end


  








  

    #copy(node_id: self.node_id, location: self.location, flags: self.flags, opening_loc: self.opening_loc, content_loc: self.content_loc, closing_loc: self.closing_loc, unescaped: self.unescaped)  
  



  

    

def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> RegularExpressionNode


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16402



def copy(node_id: self.node_id, location: self.location, flags: self.flags, opening_loc: self.opening_loc, content_loc: self.content_loc, closing_loc: self.closing_loc, unescaped: self.unescaped)
  RegularExpressionNode.new(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped)
end


  








  

    #deconstruct  
  



  

    

Alias for #child_nodes.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16407



alias deconstruct child_nodes


  








  

    #deconstruct_keys(keys)  
  



  

    

def deconstruct_keys: (Array keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16410



def deconstruct_keys(keys)
  { node_id: node_id, location: location, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped }
end


  








  

    #each_child_node  
  



  

    

def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16386



def each_child_node
  return to_enum(:each_child_node) unless block_given?

end


  








  

    #inspect  
  



  

    

def inspect -> String


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16527



def inspect
  InspectVisitor.compose(self)
end


  








  

    #opening  
  



  

    

def opening: () -> String


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16512



def opening
  opening_loc.slice
end


  








  

    #opening_loc  
  



  

    

attr_reader opening_loc: Location


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16470



def opening_loc
  location = @opening_loc
  return location if location.is_a?(Location)
  @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
end


  








  

    #save_closing_loc(repository)  
  



  

    

Save the closing_loc location using the given saved source so that it can be retrieved later.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16504



def save_closing_loc(repository)
  repository.enter(node_id, :closing_loc)
end


  








  

    #save_content_loc(repository)  
  



  

    

Save the content_loc location using the given saved source so that it can be retrieved later.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16491



def save_content_loc(repository)
  repository.enter(node_id, :content_loc)
end


  








  

    #save_opening_loc(repository)  
  



  

    

Save the opening_loc location using the given saved source so that it can be retrieved later.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16478



def save_opening_loc(repository)
  repository.enter(node_id, :opening_loc)
end


  








  

    #type  
  



  

    

Return a symbol representation of this node type. See Node#type.


  



  [ GitHub ]


  

  


# File 'lib/prism/node.rb', line 16532



def type
  :regular_expression_node
end