class Pry::Ring

A ring is a thread-safe fixed-capacity array to which you can only add elements. Older entries are overwritten as you add new elements, so that the ring can never contain more than `max_size` elemens.

@example

ring = Pry::Ring.new(3)
ring << 1 << 2 << 3
ring.to_a #=> [1, 2, 3]
ring << 4
ring.to_a #=> [2, 3, 4]

ring[0] #=> 2
ring[-1] #=> 4
ring.clear
ring[0] #=> nil

@api public @since v0.12.0

Attributes

count[R]

@return [Integer] how many objects were added during the lifetime of the

ring
max_size[R]

@return [Integer] maximum buffer size

size[R]

@return [Integer] how many objects were added during the lifetime of the

ring

Public Class Methods

new(max_size) click to toggle source

@param [Integer] max_size Maximum buffer size. The buffer will start

overwriting elements once its reaches its maximum capacity
# File lib/pry/ring.rb, line 33
def initialize(max_size)
  @max_size = max_size
  @mutex = Mutex.new
  clear
end

Public Instance Methods

<<(value) click to toggle source

Push `value` to the current index.

@param [Object] value @return [self]

# File lib/pry/ring.rb, line 43
def <<(value)
  @mutex.synchronize do
    @buffer[count % max_size] = value
    @count += 1
    self
  end
end
[](index) click to toggle source

Read the value stored at `index`.

@param [Integer, Range] index The element (if Integer) or elements

(if Range) associated with `index`

@return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none

exist
# File lib/pry/ring.rb, line 57
def [](index)
  @mutex.synchronize do
    return @buffer[(count + index) % max_size] if index.is_a?(Integer)
    return @buffer[index] if count <= max_size

    transpose_buffer_tail[index]
  end
end
clear() click to toggle source

Clear the buffer and reset count. @return [void]

# File lib/pry/ring.rb, line 75
def clear
  @mutex.synchronize do
    @buffer = []
    @count = 0
  end
end
to_a() click to toggle source

@return [Array<Object>] the buffer as unwinded array

# File lib/pry/ring.rb, line 67
def to_a
  return @buffer.dup if count <= max_size

  transpose_buffer_tail
end

Private Instance Methods

transpose_buffer_tail() click to toggle source
# File lib/pry/ring.rb, line 84
def transpose_buffer_tail
  tail = @buffer.slice(count % max_size, @buffer.size)
  tail.concat @buffer.slice(0, count % max_size)
end