Class: Prism::SymbolNode
- Inherits:
-
PrismNode
- Object
- PrismNode
- Prism::SymbolNode
- Defined in:
- lib/prism/node.rb,
ext/prism/api_node.c
Overview
Represents a symbol literal or a symbol contained within a ‘%i` list.
:foo
^^^^
%i[foo]
^^^
Instance Attribute Summary collapse
-
#closing_loc ⇒ Object
readonly
attr_reader closing_loc: Location?.
-
#flags ⇒ Object
readonly
Returns the value of attribute flags.
-
#opening_loc ⇒ Object
readonly
attr_reader opening_loc: Location?.
-
#unescaped ⇒ Object
readonly
attr_reader unescaped: String.
-
#value_loc ⇒ Object
readonly
attr_reader value_loc: Location?.
Class Method Summary collapse
-
.type ⇒ Object
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 Method Summary collapse
-
#accept(visitor) ⇒ Object
def accept: (visitor: Visitor) -> void.
-
#child_nodes ⇒ Object
(also: #deconstruct)
def child_nodes: () -> Array[nil | Node].
-
#closing ⇒ Object
def closing: () -> String?.
-
#comment_targets ⇒ Object
def comment_targets: () -> Array[Node | Location].
-
#compact_child_nodes ⇒ Object
def compact_child_nodes: () -> Array.
-
#copy(**params) ⇒ Object
def copy: (**params) -> SymbolNode.
- #deconstruct_keys(keys) ⇒ Object
-
#forced_binary_encoding? ⇒ Boolean
def forced_binary_encoding?: () -> bool.
-
#forced_us_ascii_encoding? ⇒ Boolean
def forced_us_ascii_encoding?: () -> bool.
-
#forced_utf8_encoding? ⇒ Boolean
def forced_utf8_encoding?: () -> bool.
-
#initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location) ⇒ SymbolNode
constructor
def initialize: (flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void.
-
#inspect(inspector = NodeInspector.new) ⇒ Object
def inspect(inspector: NodeInspector) -> String.
-
#opening ⇒ Object
def opening: () -> String?.
-
#type ⇒ Object
Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform.
-
#value ⇒ Object
def value: () -> String?.
Constructor Details
#initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location) ⇒ SymbolNode
def initialize: (flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
16167 16168 16169 16170 16171 16172 16173 16174 |
# File 'lib/prism/node.rb', line 16167 def initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location) @flags = flags @opening_loc = opening_loc @value_loc = value_loc @closing_loc = closing_loc @unescaped = unescaped @location = location end |
Instance Attribute Details
#closing_loc ⇒ Object (readonly)
attr_reader closing_loc: Location?
16161 16162 16163 |
# File 'lib/prism/node.rb', line 16161 def closing_loc @closing_loc end |
#flags ⇒ Object (readonly)
Returns the value of attribute flags.
16152 16153 16154 |
# File 'lib/prism/node.rb', line 16152 def flags @flags end |
#opening_loc ⇒ Object (readonly)
attr_reader opening_loc: Location?
16155 16156 16157 |
# File 'lib/prism/node.rb', line 16155 def opening_loc @opening_loc end |
#unescaped ⇒ Object (readonly)
attr_reader unescaped: String
16164 16165 16166 |
# File 'lib/prism/node.rb', line 16164 def unescaped @unescaped end |
#value_loc ⇒ Object (readonly)
attr_reader value_loc: Location?
16158 16159 16160 |
# File 'lib/prism/node.rb', line 16158 def value_loc @value_loc end |
Class Method Details
.type ⇒ Object
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. Note that like #type, it will still be slower than using == for a single class, but should be faster in a case statement or an array comparison.
def self.type: () -> Symbol
16282 16283 16284 |
# File 'lib/prism/node.rb', line 16282 def self.type :symbol_node end |
Instance Method Details
#accept(visitor) ⇒ Object
def accept: (visitor: Visitor) -> void
16177 16178 16179 |
# File 'lib/prism/node.rb', line 16177 def accept(visitor) visitor.visit_symbol_node(self) end |
#child_nodes ⇒ Object Also known as: deconstruct
def child_nodes: () -> Array[nil | Node]
16182 16183 16184 |
# File 'lib/prism/node.rb', line 16182 def child_nodes [] end |
#closing ⇒ Object
def closing: () -> String?
16242 16243 16244 |
# File 'lib/prism/node.rb', line 16242 def closing closing_loc&.slice end |
#comment_targets ⇒ Object
def comment_targets: () -> Array[Node | Location]
16192 16193 16194 |
# File 'lib/prism/node.rb', line 16192 def comment_targets [*opening_loc, *value_loc, *closing_loc] end |
#compact_child_nodes ⇒ Object
def compact_child_nodes: () -> Array
16187 16188 16189 |
# File 'lib/prism/node.rb', line 16187 def compact_child_nodes [] end |
#copy(**params) ⇒ Object
def copy: (**params) -> SymbolNode
16197 16198 16199 16200 16201 16202 16203 16204 16205 16206 |
# File 'lib/prism/node.rb', line 16197 def copy(**params) SymbolNode.new( params.fetch(:flags) { flags }, params.fetch(:opening_loc) { opening_loc }, params.fetch(:value_loc) { value_loc }, params.fetch(:closing_loc) { closing_loc }, params.fetch(:unescaped) { unescaped }, params.fetch(:location) { location }, ) end |
#deconstruct_keys(keys) ⇒ Object
16212 16213 16214 |
# File 'lib/prism/node.rb', line 16212 def deconstruct_keys(keys) { flags: flags, opening_loc: opening_loc, value_loc: value_loc, closing_loc: closing_loc, unescaped: unescaped, location: location } end |
#forced_binary_encoding? ⇒ Boolean
def forced_binary_encoding?: () -> bool
16222 16223 16224 |
# File 'lib/prism/node.rb', line 16222 def forced_binary_encoding? flags.anybits?(SymbolFlags::FORCED_BINARY_ENCODING) end |
#forced_us_ascii_encoding? ⇒ Boolean
def forced_us_ascii_encoding?: () -> bool
16227 16228 16229 |
# File 'lib/prism/node.rb', line 16227 def forced_us_ascii_encoding? flags.anybits?(SymbolFlags::FORCED_US_ASCII_ENCODING) end |
#forced_utf8_encoding? ⇒ Boolean
def forced_utf8_encoding?: () -> bool
16217 16218 16219 |
# File 'lib/prism/node.rb', line 16217 def forced_utf8_encoding? flags.anybits?(SymbolFlags::FORCED_UTF8_ENCODING) end |
#inspect(inspector = NodeInspector.new) ⇒ Object
def inspect(inspector: NodeInspector) -> String
16247 16248 16249 16250 16251 16252 16253 16254 16255 16256 |
# File 'lib/prism/node.rb', line 16247 def inspect(inspector = NodeInspector.new) inspector << inspector.header(self) flags = [("forced_utf8_encoding" if forced_utf8_encoding?), ("forced_binary_encoding" if forced_binary_encoding?), ("forced_us_ascii_encoding" if forced_us_ascii_encoding?)].compact inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n" inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n" inspector << "├── value_loc: #{inspector.location(value_loc)}\n" inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n" inspector << "└── unescaped: #{unescaped.inspect}\n" inspector.to_str end |
#opening ⇒ Object
def opening: () -> String?
16232 16233 16234 |
# File 'lib/prism/node.rb', line 16232 def opening opening_loc&.slice end |
#type ⇒ Object
Sometimes you want to check an instance of a node against a list of classes to see what kind of behavior to perform. Usually this is done by calling ‘[cls1, cls2].include?(node.class)` or putting the node into a case statement and doing `case node; when cls1; when cls2; end`. Both of these approaches are relatively slow because of the constant lookups, method calls, and/or array allocations.
Instead, you can call #type, which will return to you a symbol that you can use for comparison. This is faster than the other approaches because it uses a single integer comparison, but also because if you’re on CRuby you can take advantage of the fact that case statements with all symbol keys will use a jump table.
def type: () -> Symbol
16272 16273 16274 |
# File 'lib/prism/node.rb', line 16272 def type :symbol_node end |
#value ⇒ Object
def value: () -> String?
16237 16238 16239 |
# File 'lib/prism/node.rb', line 16237 def value value_loc&.slice end |