Results for: "pstore"

Returns a Kernel#caller style string representing this frame.

Compile a ClassVariableOperatorWriteNode node

Compile a ConstantPathOrWriteNode node

Compile a GlobalVariableOperatorWriteNode node

Compile a InstanceVariableOrWriteNode node

Compile a LocalVariableOperatorWriteNode node

@@foo += bar

becomes

@@foo = @@foo + bar

$foo += bar

becomes

$foo = $foo + bar

@foo ||= bar

becomes

@foo || @foo = bar

foo += bar

becomes

foo = foo + bar

Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue walking the tree.

Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue walking the tree.

Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue walking the tree.

Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue walking the tree.

Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue walking the tree.

Copy a ClassVariableOperatorWriteNode node

Copy a ConstantPathOrWriteNode node

Copy a GlobalVariableOperatorWriteNode node

Copy a InstanceVariableOrWriteNode node

Copy a LocalVariableOperatorWriteNode node

The logical inverse of ‘capture_last_end_same_indent`

When there is an invalid block with an ‘end` missing a keyword right after another `end`, it is unclear where which end is missing the keyword.

Take this example:

class Dog       # 1
    puts "woof" # 2
  end           # 3
end             # 4

the problem line will be identified as:

> end            # 4

This happens because lines 1, 2, and 3 are technically valid code and are expanded first, deemed valid, and hidden. We need to un-hide the matching keyword on line 1. Also work backwards and if there’s a mis-matched end, show it too

Similar to Object#to_enum, except it returns a lazy enumerator. This makes it easy to define Enumerable methods that will naturally remain lazy if called from a lazy enumerator.

For example, continuing from the example in Object#to_enum:

# See Object#to_enum for the definition of repeat
r = 1..Float::INFINITY
r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
r.repeat(2).class # => Enumerator
r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
# works naturally on lazy enumerator:
r.lazy.repeat(2).class # => Enumerator::Lazy
r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]