Class: SyntaxTree::RegexpLiteral

Inherits:
Node
  • Object
show all
Defined in:
lib/syntax_tree/node.rb

Overview

RegexpLiteral represents a regular expression literal.

/.+/

Instance Attribute Summary collapse

Attributes inherited from Node

#location

Instance Method Summary collapse

Methods inherited from Node

#construct_keys, #pretty_print, #to_json

Constructor Details

#initialize(beginning:, ending:, parts:, location:) ⇒ RegexpLiteral

Returns a new instance of RegexpLiteral.



9101
9102
9103
9104
9105
9106
9107
 
# File 'lib/syntax_tree/node.rb', line 9101

def initialize(beginning:, ending:, parts:, location:)
  @beginning = beginning
  @ending = ending
  @parts = parts
  @location = location
  @comments = []
end

Instance Attribute Details

#beginning ⇒ Object (readonly)

String

the beginning of the regular expression literal



9089
9090
9091
 
# File 'lib/syntax_tree/node.rb', line 9089

def beginning
  @beginning
end

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



9099
9100
9101
 
# File 'lib/syntax_tree/node.rb', line 9099

def comments
  @comments
end

#ending ⇒ Object (readonly)

String

the ending of the regular expression literal



9092
9093
9094
 
# File 'lib/syntax_tree/node.rb', line 9092

def ending
  @ending
end

#parts ⇒ Object (readonly)

Array[ StringEmbExpr | StringDVar | TStringContent ]

the parts of the

regular expression literal



9096
9097
9098
 
# File 'lib/syntax_tree/node.rb', line 9096

def parts
  @parts
end

Instance Method Details

#===(other) ⇒ Object 



9183
9184
9185
9186
9187
 
# File 'lib/syntax_tree/node.rb', line 9183

def ===(other)
  other.is_a?(RegexpLiteral) && beginning === other.beginning &&
    ending === other.ending && options === other.options &&
    ArrayMatch.call(parts, other.parts)
end

#accept(visitor) ⇒ Object 



9109
9110
9111
 
# File 'lib/syntax_tree/node.rb', line 9109

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

#child_nodes ⇒ Object Also known as: deconstruct 



9113
9114
9115
 
# File 'lib/syntax_tree/node.rb', line 9113

def child_nodes
  parts
end

#copy(beginning: nil, ending: nil, parts: nil, location: nil) ⇒ Object 



9117
9118
9119
9120
9121
9122
9123
9124
9125
9126
9127
9128
 
# File 'lib/syntax_tree/node.rb', line 9117

def copy(beginning: nil, ending: nil, parts: nil, location: nil)
  node =
    RegexpLiteral.new(
      beginning: beginning || self.beginning,
      ending: ending || self.ending,
      parts: parts || self.parts,
      location: location || self.location
    )

  node.comments.concat(comments.map(&:copy))
  node
end

#deconstruct_keys(_keys) ⇒ Object 



9132
9133
9134
9135
9136
9137
9138
9139
9140
9141
 
# File 'lib/syntax_tree/node.rb', line 9132

def deconstruct_keys(_keys)
  {
    beginning: beginning,
    ending: ending,
    options: options,
    parts: parts,
    location: location,
    comments: comments
  }
end

#format(q) ⇒ Object 



9143
9144
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
9159
9160
9161
9162
9163
9164
9165
9166
9167
9168
9169
9170
9171
9172
9173
9174
9175
9176
9177
9178
9179
9180
9181
 
# File 'lib/syntax_tree/node.rb', line 9143

def format(q)
  braces = ambiguous?(q) || include?(%r{/})

  if braces && include?(/[{}]/)
    q.group do
      q.text(beginning)
      q.format_each(parts)
      q.text(ending)
    end
  elsif braces
    q.group do
      q.text("%r{")

      if beginning == "/"
        # If we're changing from a forward slash to a %r{, then we can
        # replace any escaped forward slashes with regular forward slashes.
        parts.each do |part|
          if part.is_a?(TStringContent)
            q.text(part.value.gsub("\\/", "/"))
          else
            q.format(part)
          end
        end
      else
        q.format_each(parts)
      end

      q.text("}")
      q.text(options)
    end
  else
    q.group do
      q.text("/")
      q.format_each(parts)
      q.text("/")
      q.text(options)
    end
  end
end

#options ⇒ Object 



9189
9190
9191
 
# File 'lib/syntax_tree/node.rb', line 9189

def options
  ending[1..]
end