yap-rawline 0.6.3 → 0.7.0

data/lib/rawline/keycode_parser.rb

@@ -49,7 +49,7 @@ module RawLine
         results = []
         index = 0
         loop do
-          sequence = byte_sequence_for(bytes[index..-1])
+          sequence = byte_sequence_for(bytes[index..index], bytes[index+1..-1])
           results.concat sequence
           index += sequence.first.is_a?(Array) ? sequence.first.length : sequence.length
           break if index >= bytes.length
@@ -63,16 +63,29 @@ module RawLine
     # about a multi-byte sequence like :left_arrow then it will return
     # [[27,91,68]]. If it does not have a matching byte sequence it will
     # return a single element array, e.g. [12].
-    def byte_sequence_for(bytes)
-      if @inverted_keymap[bytes]
-        [bytes]
-      elsif bytes.length == 1
-        bytes
-      elsif bytes.length == 0
-        fail "Bytes cannot be zero length"
+    def byte_sequence_for(bytes, more_bytes)
+      results = []
+      more_bytes ||= []
+      longer_sequence_possible = false
+      if more_bytes && more_bytes.any?
+         longer_sequence_possible = @inverted_keymap.detect do |kbytes, _|
+          kbytes[0..bytes.length] == bytes + more_bytes[0..0]
+        end
+      end
+
+      if longer_sequence_possible
+        found_sequences = byte_sequence_for(bytes + [more_bytes.first], more_bytes[1..-1])
+        if found_sequences.any?
+          results.push *found_sequences
+        else
+          results.push *bytes
+        end
+      elsif @inverted_keymap[bytes]
+        results.push bytes
       else
-        byte_sequence_for(bytes[0..-2])
+        results.push *bytes
       end
+      results
     end
   end
 end

data/lib/rawline/renderer.rb

@@ -3,7 +3,9 @@ module RawLine
     def initialize(dom:, output:, width:, height:)
       @dom = dom
       @output = output
-      @renderer = TerminalLayout::TerminalRenderer.new(output: output)
+      @paused = false
+      @paused_attempts = []
+      @renderer = TerminalLayout::Renderer.new(output: output)
       @render_tree = TerminalLayout::RenderTree.new(
         dom,
         parent: nil,
@@ -12,40 +14,76 @@ module RawLine
       )
     end
 
-    def pause
+    def pause(&blk)
       @paused = true
     end
 
-    def unpause
-      @paused = false
-      if @render_on_unpause_kwargs
-        render(**@render_on_unpause_kwargs)
-        @render_on_unpause = nil
-      end
+    def paused?
+      @paused
     end
 
-    def render(reset: false)
-      Treefell['editor'].puts %|#{self.class}##{__callee__} reset=#{reset}}|
+    def render(reset: false, &blk)
       if @paused
-        Treefell['editor'].puts "    paused"
-        if @render_on_unpause_kwargs && @render_on_unpause_kwargs[:reset]
-          reset = true
-        end
-        @render_on_unpause_kwargs = {reset: reset}
+        @paused_attempts << [:render, { reset: reset }]
       else
-        Treefell['editor'].puts "    unpaused"
+        Treefell['render'].puts %|\nRenderer:#{self.class}##{__callee__} reset=#{reset} caller=#{caller[0..5].join("\n")}}|
         @render_tree.layout
         @renderer.render(@render_tree, reset: reset)
       end
     end
 
     def render_cursor
-      @renderer.render_cursor(@dom.focused_input_box)
+      if @paused
+        @paused_attempts << [:render_cursor, {}]
+      else
+        @renderer.render_cursor(@dom.focused_input_box)
+      end
+    end
+
+    def rollup(&blk)
+      if block_given?
+        begin
+          pause
+          blk.call
+        ensure
+          unpause
+          rollup_render_paused_attempts
+        end
+      end
     end
 
     def update_dimensions(width:, height:)
       @render_tree.width = width
       @render_tree.height = height
     end
+
+    def unpause
+      @paused = false
+      if @render_on_unpause_kwargs
+        render(**@render_on_unpause_kwargs)
+        @render_on_unpause_kwargs = nil
+      end
+    end
+
+    private
+
+    def rollup_render_paused_attempts
+      render_attempts = @paused_attempts.select do |attempt|
+        attempt.first == :render
+      end
+
+      # rendering handles render_cursor so only explicitly rerender the
+      # cursor if there were no render attempts
+      if render_attempts.any?
+        reset = render_attempts.any?{ |attempt| attempt.last[:reset] }
+        render reset: reset
+      else
+        if @paused_attempts.any? { |attempt| attempt.first == :render_cursor }
+          render_cursor
+        end
+      end
+    ensure
+      @paused_attempts.clear
+    end
   end
 end

data/lib/rawline/terminal.rb

@@ -209,10 +209,6 @@ module RawLine
       terminal_size[1]
     end
 
-    def cursor_position
-      cursor_position
-    end
-
     #
     # Update the terminal escape sequences. This method is called automatically
     # by RawLine::Editor#bind().

data/lib/rawline/version.rb

@@ -1,3 +1,3 @@
 module RawLine
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
 end

data/spec/history_buffer_spec.rb

@@ -3,139 +3,360 @@
 require_relative "../lib/rawline/history_buffer.rb"
 
 describe RawLine::HistoryBuffer do
-  before do
-    @history = RawLine::HistoryBuffer.new(5)
-  end
-
-  it "instantiates an empty array when created" do
-    expect(@history.length).to eq(0)
-  end
-
-  it "allows items to be added to the history" do
-    @history.duplicates = false
-    @history << "line #1"
-    @history << "line #2"
-    @history << "line #3"
-    @history << "line #2"
-    expect(@history).to eq(["line #1",  "line #2", "line #3"])
-    @history.duplicates = true
-    @history << "line #3"
-    expect(@history).to eq(["line #1", "line #2", "line #3", "line #3"])
-    @history.exclude = lambda { |i| i.match(/line #[456]/) }
-    @history << "line #4"
-    @history << "line #5"
-    @history << "line #6"
-    expect(@history).to eq(["line #1", "line #2", "line #3", "line #3"])
-  end
-
-  it "does not overflow" do
-    @history << "line #1"
-    @history << "line #2"
-    @history << "line #3"
-    @history << "line #4"
-    @history << "line #5"
-    @history << "line #6"
-    expect(@history.length).to eq(5)
-  end
-
-  it "allows navigation back and forward" do
-    @history.back
-    @history.forward
-    expect(@history.position).to eq(nil)
-    @history << "line #1"
-    @history << "line #2"
-    @history << "line #3"
-    @history << "line #4"
-    @history << "line #5"
-    @history.back
-    @history.back
-    @history.back
-    @history.back
-    @history.back
-    expect(@history.position).to eq(0)
-    @history.back
-    expect(@history.position).to eq(0)
-    @history.forward
-    expect(@history.position).to eq(1)
-    @history.forward
-    @history.forward
-    @history.forward
-    @history.forward
-    expect(@history.position).to eq(4)
-    @history.forward
-    expect(@history.position).to eq(4)
-    @history.cycle = true
-    @history.forward
-    @history.forward
-    expect(@history.position).to eq(1)
-  end
-
-  it "can retrieve the last element or the element at @position via 'get'" do
-    expect(@history.get).to eq(nil)
-    @history << "line #1"
-    @history << "line #2"
-    @history << "line #3"
-    @history << "line #4"
-    @history << "line #5"
-    expect(@history.get).to eq("line #5")
-    @history.back
-    expect(@history.get).to eq("line #4")
-    @history.forward
-    expect(@history.get).to eq("line #5")
-  end
-
-  it "can be cleared and resized" do
-    @history << "line #1"
-    @history << "line #2"
-    @history << "line #3"
-    @history << "line #4"
-    @history << "line #5"
-    @history.back
-    @history.back
-    expect(@history.get).to eq("line #4")
-    @history.resize(6)
-    expect(@history.position).to eq(nil)
-    @history << "line #6"
-    expect(@history.get).to eq("line #6")
-    @history.empty
-    expect(@history).to eq([])
-    expect(@history.size).to eq(6)
-    expect(@history.position).to eq(nil)
+  subject(:history) do
+    RawLine::HistoryBuffer.new(100)
+  end
+  let(:empty_history) { RawLine::HistoryBuffer.new(0) }
+
+  def build_history(*items)
+    described_class.new(items.length).tap do |history|
+      items.each { |item| history << item }
+    end
+  end
+
+  describe '.new_with_infinite_size' do
+    let(:infinity) { 1.0 / 0.0 }
+    it 'returns a new HistoryBuffer of an infinite size' do
+      history = described_class.new_with_infinite_size
+      expect(history).to be_kind_of(described_class)
+      expect(history.size).to eq(infinity)
+    end
+  end
+
+  describe '#[]' do
+    before { history << 'foo' << 'bar' }
+
+    it 'returns the history item at the given index' do
+      expect(history[0]).to eq 'foo'
+      expect(history[1]).to eq 'bar'
+    end
+
+    it 'returns nil when there is no item at the index' do
+      expect(history[2]).to be(nil)
+    end
+  end
+
+  describe '#any?' do
+    it 'returns true when there is at least one item in the history' do
+      history << 'item 1'
+      expect(history.any?).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      expect(history.any?).to be(false)
+    end
+
+    context 'called with a block' do
+      before { history << 'item 1' << 'item 2' }
+
+      it 'returns true the block returns true for any item in the history' do
+        expect(history.any?{ |item| item =~ /1/ }).to be(true)
+      end
+
+      it 'returns false otherwise' do
+        expect(history.any?{ |item| item =~ /z/ }).to be(false)
+      end
+    end
+  end
+
+  describe '#beginning?' do
+    before do
+      history << 'item 1' << 'item 2'
+    end
+
+    it 'returns false when the position is nil' do
+      history.position = nil
+      expect(history.beginning?).to be(false)
+    end
+
+    it 'returns true when the position is at the beginning' do
+      history.position = 0
+      expect(history.beginning?).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      history.position = 1
+      expect(history.beginning?).to be(false)
+    end
+  end
+
+  describe '#clear' do
+    before { history << 'item 1' << 'item 2' }
+
+    it 'forgets all history items' do
+      history.clear
+      expect(history).to eq empty_history
+    end
+
+    it 'clears the position' do
+      history.forward
+      expect do
+        history.clear
+      end.to change { history.position }.to nil
+    end
+  end
+
+  describe '#clear_position' do
+    before do
+      history << 'item 1' << 'item 2'
+      history.position = 1
+    end
+
+    it 'clears the position' do
+      expect do
+        history.clear_position
+      end.to change { history.position }.to nil
+    end
+  end
+
+  describe '#detect' do
+    before { history << 'item 1' << 'item 2' << 'item 22' }
+    it 'returns the first item that matches the given block' do
+      expect(history.detect { |item| item =~ /2/ }).to eq('item 2')
+    end
+
+    it 'returns nil when there is no matching item' do
+      expect(history.detect { |item| item =~ /z/ }).to be(nil)
+    end
+  end
+
+  describe '#duplicates' do
+    it 'allows duplicates by default' do
+      expect(history.duplicates).to be(true)
+    end
+  end
+
+  describe '#each' do
+    before { history << 'foo' << 'bar' << 'baz' }
+
+    it 'iterates over each item in the history, oldest to newest' do
+      results = []
+      history.each do |item|
+        results << item
+      end
+      expect(results).to eq ['foo', 'bar', 'baz']
+    end
+  end
+
+  describe '#empty?' do
+    it 'returns true when there are not history items' do
+      expect(empty_history.empty?).to be(true)
+    end
+
+    it 'returns false when there are history items' do
+      history << 'item 1'
+      expect(history.empty?).to be(false)
+    end
+  end
+
+  describe '#end?' do
+    before do
+      history << 'item 1' << 'item 2'
+    end
+
+    it 'returns false when the position is nil' do
+      history.position = nil
+      expect(history.end?).to be(false)
+    end
+
+    it 'returns true when the position is at the end' do
+      history.position = 1
+      expect(history.end?).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      history.position = 0
+      expect(history.end?).to be(false)
+    end
+  end
+
+  describe '#first' do
+    it 'returns the first history item' do
+      history << 'item 1' << 'item 2'
+      expect(history.first).to eq 'item 1'
+    end
+
+    it 'returns nil when there are no history items' do
+      expect(history.first).to be(nil)
+    end
+  end
+
+  describe '#first!' do
+    before do
+      history << 'item 1' << 'item 2' << 'item 3'
+      history.forward
+      history.forward
+      expect(history.beginning?).to be(false)
+    end
+
+    it 'sets the position to the beginning of the HistoryBuffer' do
+      history.first!
+      expect(history.beginning?).to be(true)
+      expect(history.position).to eq(0)
+    end
+
+    it 'returns the first history item' do
+      expect(history.first!).to eq('item 1')
+    end
+  end
+
+  describe '#get' do
+    before do
+      history << 'item 1'
+      history << 'item 2'
+      history << 'item 3'
+    end
+
+    context 'and there is no position' do
+      before { expect(history.position).to be(nil) }
+
+      it 'returns the last item' do
+        expect(history.get).to eq('item 3')
+      end
+
+      it 'sets the position to that of the last item' do
+        expect do
+          history.get
+        end.to change { history.position }.to history.length - 1
+      end
+    end
+
+    context 'and there is a position' do
+      before { history.back }
+
+      it 'returns the item at the current position' do
+        expect(history.get).to eq('item 3')
+      end
+    end
+  end
+
+  describe '#length' do
+    it 'is empty when newly created' do
+      expect(history.empty?).to be(true)
+      expect(history.length).to eq(0)
+    end
+  end
+
+  describe '#<<' do
+    it 'appends the given item to the history' do
+      history << "line #1"
+      history << "line #2"
+      history << "line #2"
+      history << "line #3"
+      expect(history).to eq(build_history('line #1', 'line #2', 'line #2', 'line #3'))
+    end
+
+    context 'and duplicates are disabled' do
+      before do
+        history.duplicates = false
+      end
+
+      it 'does not append a duplicate item' do
+        history << "line #1"
+        history << "line #1"
+        history << "line #1"
+        expect(history).to eq(build_history('line #1'))
+      end
+
+      it 'allows duplicate item that are not next to each other in the history' do
+        history << "line #1"
+        history << "line #2"
+        history << "line #1"
+        expect(history).to eq(build_history('line #1', 'line #2', 'line #1'))
+      end
+    end
+
+    context 'and there is an exclusion filter' do
+      before do
+        history.exclude = -> (i) { i.match(/line #[13]/) }
+      end
+
+      it 'does not append excluded items' do
+        history << "line #1"
+        history << "line #2"
+        history << "line #3"
+        history << "line #4"
+        expect(history).to eq(build_history('line #2', 'line #4'))
+      end
+    end
+
+    context 'and the history has a set size' do
+      subject(:history) { described_class.new(size) }
+      let(:size) { 2 }
+
+      it 'does not overflow' do
+        3.times { history << 'apples' }
+        expect(history).to eq(build_history('apples', 'apples'))
+      end
+    end
   end
 
   describe 'finding matches in history, forward and backward' do
     before do
-      @history.resize(100)
-      @history << 'echo foo'
-      @history << 'echo bar'
-      @history << 'echo baz'
-      @history << 'echo food'
-      @history << 'echo bark'
-      @history << 'echo bonanza'
+      history.resize(100)
+      history << 'echo foo'
+      history << 'echo bar'
+      history << 'echo baz'
+      history << 'echo food'
+      history << 'echo bark'
+      history << 'echo bonanza'
     end
 
     describe '#find_match_backward' do
       context 'when the position starts as nil' do
         it 'finds the first item back that matches' do
-          @history.clear_position
-          expect(@history.find_match_backward('bonanza')).to eq 'echo bonanza'
+          history.clear_position
+          expect(history.find_match_backward('bonanza')).to eq 'echo bonanza'
 
-          @history.clear_position
-          expect(@history.find_match_backward('foo')).to eq 'echo food'
+          history.clear_position
+          expect(history.find_match_backward('foo')).to eq 'echo food'
         end
 
         it 'can find consecutive matches, skipping unmatched items' do
-          @history.clear_position
-          expect(@history.find_match_backward('foo')).to eq 'echo food'
-          $z = true
-          expect(@history.find_match_backward('foo')).to eq 'echo foo'
+          history.clear_position
+          expect(history.find_match_backward('foo')).to eq 'echo food'
+          expect(history.find_match_backward('foo')).to eq 'echo foo'
         end
       end
 
       context 'when the position starts as non-nil' do
         it 'finds the first item back that matches from the current position' do
-          3.times { @history.back }
-          expect(@history.find_match_backward('bar')).to eq 'echo bar'
+          3.times { history.back }
+          expect(history.find_match_backward('bar')).to eq 'echo bar'
+        end
+      end
+
+      context 'when the HistoryBuffer is not cyclic' do
+        before { history.cycle = false }
+
+        it 'stops searching at the very first item in the HistoryBuffer' do
+          history.find_match_backward('echo foo')
+          expect(history.get).to eq('echo food')
+
+          history.find_match_backward('echo foo')
+          expect(history.get).to eq('echo foo')
+          expect(history.beginning?).to be(true)
+
+          history.find_match_backward('echo foo')
+          expect(history.get).to eq('echo foo')
+          expect(history.beginning?).to be(true)
+        end
+      end
+
+      context 'when the HistoryBuffer is cyclic' do
+        before { history.cycle = true }
+
+        it 'wraps aorund and searches from the end of hte HistoryBuffer' do
+          history.find_match_backward('echo foo')
+          expect(history.get).to eq('echo food')
+
+          history.find_match_backward('echo foo')
+          expect(history.get).to eq('echo foo')
+          expect(history.beginning?).to be(true)
+
+          history.find_match_backward('echo foo')
+          expect(history.get).to eq('echo food')
+          expect(history.beginning?).to be(false)
         end
       end
     end
@@ -143,42 +364,245 @@ describe RawLine::HistoryBuffer do
     describe '#find_match_forward' do
       context 'when the position starts as nil' do
         it 'finds the first item from the beginning that matches' do
-          @history.clear_position
-          expect(@history.find_match_forward('bar')).to eq 'echo bar'
-          expect(@history.position).to eq @history.index('echo bar')
+          history.clear_position
+          expect(history.find_match_forward('bar')).to eq 'echo bar'
+          expect(history.position).to eq history.index('echo bar')
 
-          @history.clear_position
-          expect(@history.find_match_forward('foo')).to eq 'echo foo'
-          expect(@history.position).to eq @history.index('echo foo')
+          history.clear_position
+          expect(history.find_match_forward('foo')).to eq 'echo foo'
+          expect(history.position).to eq history.index('echo foo')
         end
 
         it 'can find consecutive matches, skipping unmatched items' do
-          @history.clear_position
-          expect(@history.find_match_forward('foo')).to eq 'echo foo'
-          expect(@history.position).to eq @history.index('echo foo')
+          history.clear_position
+          expect(history.find_match_forward('foo')).to eq 'echo foo'
+          expect(history.position).to eq history.index('echo foo')
 
-          expect(@history.find_match_forward('foo')).to eq 'echo food'
-          expect(@history.position).to eq @history.index('echo food')
+          expect(history.find_match_forward('foo')).to eq 'echo food'
+          expect(history.position).to eq history.index('echo food')
         end
       end
 
       context 'when the position starts as non-nil' do
         it 'finds the first item back that matches from the current position' do
-          3.times { @history.back }
-          expect(@history.find_match_forward('bar')).to eq 'echo bark'
-          expect(@history.position).to eq @history.index('echo bark')
+          3.times { history.back }
+          expect(history.find_match_forward('bar')).to eq 'echo bark'
+          expect(history.position).to eq history.index('echo bark')
         end
       end
 
       context 'when its gone all the way back, and we want to go forward' do
-        it 'd' do
-          @history.length.times do
-            @history.find_match_backward('bar')
+        it 'finds the first item forward that matches from the current position' do
+          history.length.times do
+            history.find_match_backward('bar')
           end
-          expect(@history.find_match_forward('bar')).to eq 'echo bark'
+          expect(history.find_match_forward('bar')).to eq 'echo bark'
+        end
+      end
+
+      context 'when the HistoryBuffer is not cyclic' do
+        before do
+          history.cycle = false
+          history.position = 0
+        end
+
+        it 'stops searching at the very last item matched in the HistoryBuffer' do
+          history.find_match_forward('echo b')
+          history.find_match_forward('echo b')
+          history.find_match_forward('echo b')
+          expect(history.get).to eq('echo bark')
+
+          history.find_match_forward('echo b')
+          expect(history.get).to eq('echo bonanza')
+          expect(history.end?).to be(true)
+
+          history.find_match_forward('echo b')
+          expect(history.end?).to be(true)
+        end
+      end
+
+      context 'when the HistoryBuffer is cyclic' do
+        before { history.cycle = true }
+
+        it 'wraps aorund and searches from the end of hte HistoryBuffer' do
+          history.find_match_forward('echo b')
+          history.find_match_forward('echo b')
+          history.find_match_forward('echo b')
+          expect(history.get).to eq('echo bark')
+          history.find_match_forward('echo b')
+          expect(history.get).to eq('echo bonanza')
+          expect(history.end?).to be(true)
+
+          history.find_match_forward('echo bar')
+          expect(history.end?).to be(false)
         end
       end
+
     end
+  end
+
+  describe 'navigating the history' do
+    before do
+      history << 'item 1'
+      history << 'item 2'
+      history << 'item 3'
+      history << 'item 4'
+      history << 'item 5'
 
+      expect(history.position).to be(nil)
+    end
+
+    describe '#back' do
+      it 'allows you to move back thru the history' do
+        history.back
+        expect(history.position).to be(4)
+        history.back
+        history.back
+        expect(history.position).to be(2)
+      end
+
+      it 'does not allow you to go past the very first item' do
+        100.times { history.back }
+        expect(history.position).to be(0)
+      end
+
+      context 'and the history is set to cycle' do
+        before { history.cycle = true }
+
+        it 'wraps around to the very last item when you move beyond the first item' do
+          history.position = 0
+          expect do
+            history.back
+          end.to change { history.end? }.to true
+        end
+      end
+    end
+
+    describe '#forward' do
+      context 'and you are starting with no position' do
+        before { expect(history.position).to be(nil) }
+
+        it 'puts you at the position of the last item' do
+          expect do
+            history.back
+          end.to change { history.end? }.to true
+        end
+      end
+
+      context 'and you are starting from a known position' do
+        before do
+          history.length.times { history.back }
+          expect(history.position).to be(0)
+        end
+
+        it 'allows you to move forward thru the history' do
+          history.forward
+          expect(history.position).to be(1)
+          history.forward
+          history.forward
+          expect(history.position).to be(3)
+        end
+      end
+
+      it 'does not allow you to go past the very last item (by default)' do
+        100.times { history.forward }
+        expect do
+          history.forward
+        end.to_not change { history.end? }.from true
+      end
+
+      context 'and the history is set to cycle' do
+        before { history.cycle = true }
+
+        it 'wraps around to the very first item when you move beyond the last item' do
+          history.position = history.length - 2
+          history.forward
+          expect do
+            history.forward
+          end.to change { history.beginning? }.to true
+        end
+      end
+    end
+  end
+
+  describe '#map' do
+    before { history << 'foo' << 'bar' << 'baz' }
+
+    it 'iterates over each item in the history, oldest to newest' do
+      results = history.map do |item|
+        "echo #{item}"
+      end
+      expect(results).to eq ['echo foo', 'echo bar', 'echo baz']
+    end
+  end
+
+  describe '#replace' do
+    before { history << 'item 1' << 'item 2' }
+
+    it 'replaces the current history items with an array of history items' do
+      history.replace(['foo', 'bar'])
+      expect(history).to eq build_history('foo', 'bar')
+    end
+
+    it 'replaces the current history items with a given HistoryBuffer' do
+      new_history = build_history('foo', 'bar')
+      history.replace(new_history)
+      expect(history).to eq new_history
+    end
+  end
+
+  describe '#resize' do
+    before do
+      history << 'item 1' << 'item 2' << 'item 3' << 'item 4'
+    end
+
+    it 'resizes the history' do
+      expect do
+        history.resize(2)
+      end.to change { history.size }.to 2
+    end
+
+    it 'forgets any history items older than the new size allows' do
+      history.resize(2)
+      expect(history).to eq build_history('item 3', 'item 4')
+    end
+  end
+
+  describe '#reverse' do
+    before { history << 'item 1' << 'item 2' }
+
+    it 'returns a new HistoryBuffer in reverse order' do
+      reversed_history = history.reverse
+      expect(reversed_history).to eq build_history('item 2', 'item 1');
+    end
+
+    it 'does not modify the original HistoryBuffer' do
+      reversed_history = history.reverse
+      expect(history).to eq build_history('item 1', 'item 2')
+    end
   end
+
+  describe '#size' do
+    it 'returns the size of the HistoryBuffer (regardless of history items)' do
+      expect(described_class.new(4).size).to eq(4)
+      expect(described_class.new(128).size).to eq(128)
+    end
+
+    it 'defaults to 1024 when provided as 0 or nil' do
+      expect(described_class.new(0).size).to eq(1024)
+      expect(described_class.new(nil).size).to eq(1024)
+    end
+
+    it 'defaults to 1024 when not provided' do
+      expect(described_class.new.size).to eq(1024)
+    end
+  end
+
+  describe '#to_a' do
+    it 'returns the history as an array' do
+      history << 'item 1' << 'item 2'
+      expect(history.to_a).to eq ['item 1', 'item 2']
+    end
+  end
+
 end