Implement circular-buffer in ruby

ruby/circular-buffer/HELP.md

@@ -0,0 +1,54 @@
+# Help
+
+## Running the tests
+
+For running the tests provided, you will need the Minitest gem. Open a
+terminal window and run the following command to install minitest:
+
+```
+gem install minitest
+```
+
+
+Run the tests from the exercise directory using the following command:
+
+```
+ruby <snake-case-exercise>_test.rb
+```
+
+Please replace `<snake-case-exercise>` with your exercise name in snake_case.
+
+## Color output
+
+You can `require 'minitest/pride'` or run the following command to get colored output:
+
+```
+ruby -r minitest/pride <snake-case-exercise>_test.rb
+```
+
+## Submitting your solution
+
+You can submit your solution using the `exercism submit circular_buffer.rb` command.
+This command will upload your solution to the Exercism website and print the solution page's URL.
+
+It's possible to submit an incomplete solution which allows you to:
+
+- See how others have completed the exercise
+- Request help from a mentor
+
+## Need to get help?
+
+If you'd like help solving the exercise, check the following pages:
+
+- The [Ruby track's documentation](https://exercism.org/docs/tracks/ruby)
+- The [Ruby track's programming category on the forum](https://forum.exercism.org/c/programming/ruby)
+- [Exercism's programming category on the forum](https://forum.exercism.org/c/programming/5)
+- The [Frequently Asked Questions](https://exercism.org/docs/using/faqs)
+
+Should those resources not suffice, you could submit your (incomplete) solution to request mentoring.
+
+To get help if you're having trouble, you can use one of the following resources:
+
+- [Ruby Documentation](http://ruby-doc.org/)
+- [StackOverflow](http://stackoverflow.com/questions/tagged/ruby)
+- [/r/ruby](https://www.reddit.com/r/ruby) is the Ruby subreddit.

ruby/circular-buffer/README.md

@@ -0,0 +1,71 @@
+# Circular Buffer
+
+Welcome to Circular Buffer on Exercism's Ruby Track.
+If you need help running the tests or submitting your code, check out `HELP.md`.
+
+## Instructions
+
+A circular buffer, cyclic buffer or ring buffer is a data structure that uses a single, fixed-size buffer as if it were connected end-to-end.
+
+A circular buffer first starts empty and of some predefined length.
+For example, this is a 7-element buffer:
+<!-- prettier-ignore -->
+    [ ][ ][ ][ ][ ][ ][ ]
+
+Assume that a 1 is written into the middle of the buffer (exact starting location does not matter in a circular buffer):
+<!-- prettier-ignore -->
+    [ ][ ][ ][1][ ][ ][ ]
+
+Then assume that two more elements are added — 2 & 3 — which get appended after the 1:
+<!-- prettier-ignore -->
+    [ ][ ][ ][1][2][3][ ]
+
+If two elements are then removed from the buffer, the oldest values inside the buffer are removed.
+The two elements removed, in this case, are 1 & 2, leaving the buffer with just a 3:
+<!-- prettier-ignore -->
+    [ ][ ][ ][ ][ ][3][ ]
+
+If the buffer has 7 elements then it is completely full:
+<!-- prettier-ignore -->
+    [5][6][7][8][9][3][4]
+
+When the buffer is full an error will be raised, alerting the client that further writes are blocked until a slot becomes free.
+
+When the buffer is full, the client can opt to overwrite the oldest data with a forced write.
+In this case, two more elements — A & B — are added and they overwrite the 3 & 4:
+<!-- prettier-ignore -->
+    [5][6][7][8][9][A][B]
+
+3 & 4 have been replaced by A & B making 5 now the oldest data in the buffer.
+Finally, if two elements are removed then what would be returned is 5 & 6 yielding the buffer:
+<!-- prettier-ignore -->
+    [ ][ ][7][8][9][A][B]
+
+Because there is space available, if the client again uses overwrite to store C & D then the space where 5 & 6 were stored previously will be used not the location of 7 & 8.
+7 is still the oldest element and the buffer is once again full.
+<!-- prettier-ignore -->
+    [C][D][7][8][9][A][B]
+
+## Source
+
+### Created by
+
+- @anthonygreen
+
+### Contributed to by
+
+- @budmc29
+- @dalexj
+- @dkinzer
+- @hilary
+- @iHiD
+- @Insti
+- @julianandrews
+- @kotp
+- @kytrinyx
+- @pendletons
+- @tryantwit
+
+### Based on
+
+Wikipedia - https://en.wikipedia.org/wiki/Circular_buffer

ruby/circular-buffer/circular_buffer.rb

@@ -0,0 +1,31 @@
+class CircularBuffer
+  def initialize(size)
+    @size = size
+    @buffer = []
+  end
+
+  def read()
+    raise BufferEmptyException if @buffer.empty?
+    @buffer.shift
+  end
+
+  def write(data)
+    raise BufferFullException if @buffer.length == @size
+    @buffer.push(data)
+  end
+
+  def write!(data)
+    read() if @buffer.length == @size
+    write(data)
+  end
+
+  def clear()
+    @buffer = []
+  end
+
+  class BufferEmptyException < StandardError
+  end
+
+  class BufferFullException < StandardError
+  end
+end

ruby/circular-buffer/circular_buffer_test.rb

@@ -0,0 +1,99 @@
+require 'minitest/autorun'
+require_relative 'circular_buffer'
+
+class CircularBufferTest < Minitest::Test
+  def test_read_empty_buffer_throws_buffer_empty_exception
+    buffer = CircularBuffer.new(1)
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+  end
+
+  def test_write_and_read_back_one_item
+    buffer = CircularBuffer.new(1)
+    buffer.write '1'
+    assert_equal '1', buffer.read
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+  end
+
+  def test_write_and_read_back_multiple_items
+    buffer = CircularBuffer.new(2)
+    buffer.write '1'
+    buffer.write '2'
+    assert_equal '1', buffer.read
+    assert_equal '2', buffer.read
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+  end
+
+  def test_clearing_buffer
+    buffer = CircularBuffer.new(3)
+    ('1'..'3').each { |i| buffer.write i }
+    buffer.clear
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+    buffer.write '1'
+    buffer.write '2'
+    assert_equal '1', buffer.read
+    buffer.write '3'
+    assert_equal '2', buffer.read
+  end
+
+  def test_alternate_write_and_read
+    buffer = CircularBuffer.new(2)
+    buffer.write '1'
+    assert_equal '1', buffer.read
+    buffer.write '2'
+    assert_equal '2', buffer.read
+  end
+
+  def test_reads_back_oldest_item
+    buffer = CircularBuffer.new(3)
+    buffer.write '1'
+    buffer.write '2'
+    buffer.read
+    buffer.write '3'
+    assert_equal '2', buffer.read
+    assert_equal '3', buffer.read
+  end
+
+  def test_writing_to_a_full_buffer_throws_an_exception
+    buffer = CircularBuffer.new(2)
+    buffer.write '1'
+    buffer.write '2'
+    assert_raises(CircularBuffer::BufferFullException) { buffer.write 'A' }
+  end
+
+  def test_overwriting_oldest_item_in_a_full_buffer
+    buffer = CircularBuffer.new(2)
+    buffer.write '1'
+    buffer.write '2'
+    buffer.write! 'A'
+    assert_equal '2', buffer.read
+    assert_equal 'A', buffer.read
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+  end
+
+  def test_forced_writes_to_non_full_buffer_should_behave_like_writes
+    buffer = CircularBuffer.new(2)
+    buffer.write '1'
+    buffer.write! '2'
+    assert_equal '1', buffer.read
+    assert_equal '2', buffer.read
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+  end
+
+  def test_alternate_read_and_write_into_buffer_overflow
+    buffer = CircularBuffer.new(5)
+    ('1'..'3').each { |i| buffer.write i }
+    buffer.read
+    buffer.read
+    buffer.write '4'
+    buffer.read
+    ('5'..'8').each { |i| buffer.write i }
+    buffer.write! 'A'
+    buffer.write! 'B'
+    ('6'..'8').each do |i|
+      assert_equal i, buffer.read
+    end
+    assert_equal 'A', buffer.read
+    assert_equal 'B', buffer.read
+    assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
+  end
+end