cuboid 0.0.0 → 0.0.1alpha

data/spec/cuboid/state/options_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Cuboid::State::Options do
+
+    subject { described_class.new }
+    let(:dump_directory) do
+        "#{Dir.tmpdir}/options-#{Cuboid::Utilities.generate_token}"
+    end
+
+    it { is_expected.to respond_to :clear}
+
+    describe '#statistics' do
+        let(:statistics) { subject.statistics }
+    end
+
+    describe '#dump' do
+        it 'stores to disk' do
+            Cuboid::Options.datastore.my_custom_option = 'my value'
+            subject.dump( dump_directory )
+
+            expect(Cuboid::Options.load( "#{dump_directory}/options" ).
+                datastore.my_custom_option).to eq('my value')
+        end
+    end
+
+    describe '.load' do
+        it 'restores from disk' do
+            Cuboid::Options.datastore.my_custom_option = 'my value'
+            subject.dump( dump_directory )
+
+            described_class.load( dump_directory )
+
+            expect(Cuboid::Options.datastore.my_custom_option).to eq('my value')
+        end
+    end
+
+end

data/spec/cuboid/state_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Cuboid::State do
+
+    subject { described_class }
+    let(:dump_directory) do
+        "#{Dir.tmpdir}/state-#{Cuboid::Utilities.generate_token}"
+    end
+
+    describe '#application' do
+        it "returns an instance of #{described_class::Application}" do
+            expect(subject.application).to be_kind_of described_class::Application
+        end
+    end
+
+    describe '#options' do
+        it "returns an instance of #{described_class::Options}" do
+            expect(subject.options).to be_kind_of described_class::Options
+        end
+    end
+
+    describe '#statistics' do
+        %w(options application).each do |name|
+            it "includes :#{name} statistics" do
+                expect(subject.statistics[name.to_sym]).to eq(subject.send(name).statistics)
+            end
+        end
+    end
+
+    describe '.dump' do
+        %w(options application).each do |name|
+            it "stores ##{name} to disk" do
+                previous_instance = subject.send(name)
+
+                subject.dump( dump_directory )
+
+                new_instance = subject.load( dump_directory ).send(name)
+
+                expect(new_instance).to be_kind_of subject.send(name).class
+                expect(new_instance.object_id).not_to eq(previous_instance.object_id)
+            end
+        end
+    end
+
+    describe '#clear' do
+        %w(options application).each do |method|
+            it "clears ##{method}" do
+                expect(subject.send(method)).to receive(:clear).at_least(:once)
+                subject.clear
+            end
+        end
+    end
+end

data/spec/cuboid/support/buffer/autoflush_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Buffer::AutoFlush do
+    describe '#initialize' do
+        context 'when passed a max_size' do
+            context 'when the buffer reaches that size' do
+                it 'forces the buffer to #flush itself' do
+                    b = described_class.new( 10 )
+
+                    buffers = []
+                    b.on_flush do |buffer|
+                        buffers << buffer
+                    end
+
+                    20.times { |i| b << i }
+
+                    expect(buffers.size).to eq(2)
+                    expect(buffers.shift).to eq((0..9).to_a)
+                    expect(buffers.shift).to eq((10...20).to_a)
+
+                    expect(b).to be_empty
+                end
+            end
+        end
+
+        context 'when passed a max_pushes' do
+            context 'when the amount of pushes reaches that size' do
+                it 'forces the buffer to #flush itself' do
+                    b = described_class.new( 99999, 10 )
+
+                    buffers = []
+                    b.on_flush do |buffer|
+                        buffers << buffer
+                    end
+
+                    20.times { |i| b << i }
+
+                    expect(buffers.size).to eq(2)
+                    expect(buffers.shift).to eq((0..9).to_a)
+                    expect(buffers.shift).to eq((10...20).to_a)
+                    expect(b).to be_empty
+
+                    b = described_class.new( 99999, 10 )
+
+                    buffers = []
+                    b.on_flush do |buffer|
+                        buffers << buffer
+                    end
+
+                    20.times { |i| b.batch_push (0..1000).to_a }
+
+                    expect(buffers.size).to eq(2)
+                    expect(buffers.shift).to eq((0..1000).to_a)
+                    expect(buffers.shift).to eq((0..1000).to_a)
+                    expect(b).to be_empty
+                end
+            end
+        end
+
+        context 'when passed a type' do
+            it 'should be used for internal storage' do
+                b = described_class.new( 10, 999, Set )
+                b << 'test'
+                b << 'test'
+                expect(b.size).to eq(1)
+                expect(b.flush.class).to eq(Set)
+
+                b = described_class.new
+                b << 'test'
+                b << 'test'
+                expect(b.size).to eq(2)
+
+                expect(b.flush.class).to eq(Array)
+            end
+        end
+    end
+
+end

data/spec/cuboid/support/buffer/base_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Buffer::Base do
+
+    describe '#initialize' do
+        context 'when passed a max_size' do
+            it 'determines whether or not the buffer is full' do
+                b = described_class.new( 10 )
+                20.times { |i| b << i }
+                expect(b.full?).to be_truthy
+            end
+        end
+
+        context 'when passed a type' do
+            it 'determines the type to use for internal storage' do
+                b = described_class.new( 10, Set )
+                b << 'test'
+                b << 'test'
+                expect(b.size).to eq(1)
+                expect(b.flush.class).to eq(Set)
+
+                b = described_class.new
+                b << 'test'
+                b << 'test'
+                expect(b.size).to eq(2)
+
+                expect(b.flush.class).to eq(Array)
+            end
+        end
+    end
+
+    describe '#<<' do
+        it 'adds an element to the buffer' do
+            b = described_class.new
+            b << 'test'
+            b << 'test'
+            expect(b.size).to eq(2)
+        end
+        it 'aliased to #push' do
+            b = described_class.new
+            b.push 'test'
+            b.push 'test'
+            expect(b.size).to eq(2)
+        end
+    end
+
+    describe '#batch_push' do
+        it 'pushes a batch of entries' do
+            b = described_class.new
+            b.batch_push [ 'test', 'test2' ]
+            expect(b.size).to eq(2)
+        end
+    end
+
+    describe '#size' do
+        it 'returns the number of entries in the buffer' do
+            b = described_class.new
+            b.batch_push [ 'test', 'test2', 'test3' ]
+            expect(b.size).to eq(3)
+        end
+    end
+
+    describe '#empty?' do
+        context 'when the buffer' do
+            context 'is empty' do
+                it 'returns true' do
+                    b = described_class.new( 10 )
+                    expect(b.empty?).to be_truthy
+                end
+            end
+            context 'is not empty' do
+                it 'returns false' do
+                    b = described_class.new( 10 )
+                    b << 1
+                    expect(b.empty?).to be_falsey
+                end
+            end
+        end
+    end
+
+    describe '#full?' do
+        context 'when the buffer has' do
+            context 'reached its maximum size' do
+                it 'returns true' do
+                    b = described_class.new( 10 )
+                    20.times { |i| b << i }
+                    expect(b.full?).to be_truthy
+                end
+            end
+            context 'not reached its maximum size' do
+                it 'returns false' do
+                    b = described_class.new( 100 )
+                    20.times { |i| b << i }
+                    expect(b.full?).to be_falsey
+                end
+            end
+        end
+    end
+
+    describe '#flush' do
+        it 'returns buffer contents' do
+            b = described_class.new
+            b.batch_push [ 'test', 'test2', 'test3' ]
+            expect(b.size).to eq(3)
+
+            expect(b.flush).to eq([ 'test', 'test2', 'test3' ])
+            expect(b.size).to eq(0)
+        end
+        it 'empties the buffer' do
+            b = described_class.new
+            b.batch_push [ 'test', 'test2', 'test3' ]
+            expect(b.size).to eq(3)
+
+            expect(b.flush).to eq([ 'test', 'test2', 'test3' ])
+            expect(b.size).to eq(0)
+        end
+    end
+
+    describe '#on_push' do
+        it 'adds blocks to be called every time #<< (or #push) is called' do
+            item = :ya
+
+            b = described_class.new
+
+            call_args = []
+            expect(b.on_push do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            expect(b.on_push do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            b << item
+            expect(call_args).to eq([ item, item])
+
+            b = described_class.new
+
+            call_args = []
+            expect(b.on_push do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            expect(b.on_push do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            b.push item
+            expect(call_args).to eq([ item, item])
+        end
+    end
+
+    describe '#on_batch_push' do
+        it 'adds blocks to be called every time #batch_push is called' do
+            item = [:ya, :ya1]
+
+            b = described_class.new
+
+            call_args = []
+            expect(b.on_batch_push do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            expect(b.on_batch_push do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            b.batch_push item
+            expect(call_args).to eq([ item, item])
+        end
+    end
+
+    describe '#on_flush' do
+        it 'adds blocks to be called every time #flush is called' do
+            item = :ya
+
+            b = described_class.new
+            b << item
+
+            call_args = []
+            expect(b.on_flush do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            expect(b.on_flush do |buffer|
+                call_args << buffer
+            end).to eq(b)
+
+            b.flush
+            expect(call_args).to eq([ [item], [item]])
+        end
+    end
+end

data/spec/cuboid/support/cache/least_cost_replacement_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Cache::LeastCostReplacement do
+    it_behaves_like 'cache'
+
+    it 'prunes itself by removing the least costly entries' do
+        subject.max_size = 3
+
+        subject.store( :k,  '1', :high )
+        subject.store( :k2, '2', :high )
+        subject.store( :k3, '3', :medium )
+        subject.store( :k4, '4', :low )
+        expect(subject.size).to eq(3)
+
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_nil
+        expect(subject[:k2]).to be_truthy
+        expect(subject[:k]).to be_truthy
+
+        subject.clear
+
+        subject.max_size = 1
+
+        subject.store( :k,  '1', :medium )
+        subject.store( :k2, '2', :low )
+        subject.store( :k3, '3', :low )
+        subject.store( :k4, '4', :low )
+        expect(subject.size).to eq(1)
+
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_nil
+        expect(subject[:k2]).to be_nil
+        expect(subject[:k]).to be_nil
+    end
+
+    describe '#store' do
+        it 'stores an object by key' do
+            v = 'val'
+            expect(subject.store( :key, v, :low )).to eq(v)
+            expect(subject[:key]).to eq(v)
+        end
+        it 'assigns cost to object' do
+            v = 'val'
+            expect(subject.store( :key, v, :low )).to eq(v)
+            expect(subject[:key]).to eq(v)
+        end
+    end
+
+    describe '#[]=' do
+        it 'stores an object' do
+            v = 'val'
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
+        end
+        it 'alias of #store' do
+            v = 'val2'
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
+        end
+    end
+end

data/spec/cuboid/support/cache/least_recently_pushed_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Cache::LeastRecentlyPushed do
+    it_behaves_like 'cache'
+
+    it 'prunes itself by removing Least Recently Pushed entries' do
+        subject.max_size = 3
+
+        subject[:k]  = '1'
+        subject[:k2] = '2'
+        subject[:k3] = '3'
+        subject[:k4] = '4'
+        expect(subject.size).to eq(3)
+
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_truthy
+        expect(subject[:k2]).to be_truthy
+        expect(subject[:k]).to be_nil
+
+        subject.clear
+
+        subject.max_size = 1
+        subject[:k]  = '1'
+        subject[:k2] = '3'
+        subject[:k3] = '4'
+        expect(subject.size).to eq(1)
+
+        expect(subject[:k3]).to be_truthy
+        expect(subject[:k2]).to be_nil
+        expect(subject[:k]).to be_nil
+    end
+
+    describe '#[]=' do
+        it 'stores an object' do
+            v = 'val'
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
+        end
+        it 'alias of #store' do
+            v = 'val2'
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
+        end
+    end
+
+    describe '#[]' do
+        it 'retrieves an object by key' do
+            v = 'val2'
+            subject[:key] = v
+            expect(subject[:key]).to eq(v)
+            expect(subject.empty?).to be_falsey
+        end
+
+        context 'when the key does not exist' do
+            it 'returns nil' do
+                expect(subject[:some_key]).to be_nil
+            end
+        end
+    end
+
+    describe '#delete' do
+        context 'when the key exists' do
+            it 'deletes a key and return its value' do
+                v = 'my_val'
+                subject[:my_key] = v
+                expect(subject.delete( :my_key )).to eq(v)
+                expect(subject[:my_key]).to be_nil
+                expect(subject.include?( :my_key )).to be_falsey
+            end
+        end
+        context 'when the key does not exist' do
+            it 'returns nil' do
+                expect(subject.delete( :my_key2 )).to be_nil
+            end
+        end
+    end
+
+    describe '#clear' do
+        it 'empties the cache' do
+            subject[:my_key2] = 'v'
+            expect(subject.size).to be > 0
+            expect(subject.empty?).to be_falsey
+            subject.clear
+
+            expect(subject.size).to eq(0)
+            expect(subject.empty?).to be_truthy
+        end
+    end
+
+end