cardshark 0.0.1 → 0.0.2

data/lib/cardshark/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cardshark
+  class Error < StandardError
+    class AbstractClass < Error; end
+    class DeckAlreadyShuffled < Error; end
+    class DeckExhausted < Error; end
+    class DeckOrderInvalid < Error; end
+    class DimensionInheritanceLimit < Error; end
+  end
+end

data/lib/cardshark/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cardshark
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/spec/cardshark/abstract_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'cardshark/abstract'
+
+RSpec.describe Cardshark::Abstract do
+  context 'included into a new class' do
+    let(:klass) { Class.new { include Cardshark::Abstract } }
+
+    describe '::new' do
+      it 'raises a Cardshark::Error::AbstractClass' do
+        expect { klass.new }.to raise_error(Cardshark::Error::AbstractClass)
+      end
+
+      context 'it has been subclassed' do
+        let(:subclass) { Class.new(klass) }
+
+        it 'does not raise an error' do
+          expect { subclass.new }.not_to raise_error
+        end
+
+        it 'returns an instance of the subclass' do
+          expect(subclass.new).to be_a(subclass)
+        end
+      end
+    end
+  end
+end

data/spec/cardshark/card_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'cardshark/card'
+
+RSpec.describe Cardshark::Card do
+  let(:rank) { Class.new(Cardshark::Dimension) }
+  let(:suit) { Class.new(Cardshark::Dimension) }
+
+  let(:ace) { rank.new(:ace) }
+  let(:spades) { suit.new(:spades) }
+  let(:clubs) { suit.new(:clubs) }
+
+  describe '::new' do
+    context 'invalid arguments' do
+      context 'no arguments' do
+        it 'raises an ArgumentError' do
+          expect { described_class.new }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'invalid argument type' do
+        it 'raises an ArgumentError' do
+          expect { described_class.new('invalid-arguments') }
+            .to raise_error(ArgumentError)
+        end
+      end
+
+      context 'more than one argument of the same dimension' do
+        it 'raises an ArgumentError' do
+          expect { described_class.new(spades, clubs) }
+            .to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context 'valid arguments' do
+      it 'does not raise an error' do
+        expect { described_class.new(ace, spades) }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#dimensions' do
+    let(:card) { described_class.new(ace, spades) }
+
+    before do
+      @result = card.dimensions
+    end
+
+    it 'returns an Array' do
+      expect(@result).to be_an(Array)
+    end
+
+    it 'contains one entry for each type of dimension' do
+      expect(@result.count).to eq(2)
+    end
+
+    it 'contains a symbol for the first dimension' do
+      expect(@result).to include(rank.id)
+    end
+
+    it 'contains a symbol for the second dimension' do
+      expect(@result).to include(suit.id)
+    end
+  end
+
+  describe 'dynamic dimension methods' do
+    let(:card) { described_class.new(ace, spades) }
+
+    it 'has a method for the first dimension' do
+      expect(card.respond_to?(suit.id)).to eq(true)
+    end
+
+    it 'has a method for the second dimension' do
+      expect(card.respond_to?(rank.id)).to eq(true)
+    end
+
+    it 'returns the correct value for the first dimension' do
+      expect(card.send(suit.id)).to eq(spades)
+    end
+
+    it 'returns the correct value for the second dimension' do
+      expect(card.send(rank.id)).to eq(ace)
+    end
+  end
+end

data/spec/cardshark/deck_spec.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'cardshark/card'
+require 'cardshark/deck'
+
+RSpec.describe Cardshark::Deck do
+  context 'class methods' do
+    describe '::new' do
+      context 'invalid arguments' do
+        context 'no arguments' do
+          it 'raises an ArgumentError' do
+            expect { described_class.new }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'invalid arguments' do
+          it 'raises an ArgumentError' do
+            expect { described_class.new('invalid-arguments') }
+              .to raise_error(ArgumentError)
+          end
+        end
+
+        context 'valid arguments' do
+          it 'does not raise an error' do
+            expect { described_class.new {} }.not_to raise_error
+          end
+        end
+      end
+    end
+  end
+
+  context 'instance methods' do
+    let(:suit)    { Class.new(Cardshark::Dimension) }
+    let!(:spades) { suit.new(:spades) }
+    let!(:hearts) { suit.new(:hearts) }
+
+    let(:rank)   { Class.new(Cardshark::Dimension) }
+    let!(:king)  { rank.new(:king)  }
+    let!(:queen) { rank.new(:queen) }
+    let!(:jack)  { rank.new(:jack)  }
+
+    let(:cards)  do
+      cards = []
+      suit.all.each do |suit|
+        rank.all.each do |rank|
+          cards << Cardshark::Card.new(rank, suit)
+        end
+      end
+      cards
+    end
+
+    describe '#draw' do
+      context 'new deck' do
+        let(:deck) { described_class.new { cards } }
+
+        before do
+          @one = deck.draw
+          @two = deck.draw
+          @three = deck.draw
+          @four = deck.draw
+          @five = deck.draw
+          @six = deck.draw
+        end
+
+        it 'returns a Cardshark::Card' do
+          expect(@one).to be_a(Cardshark::Card)
+        end
+
+        it 'returns the first card first' do
+          expect(@one).to eq(cards[0])
+        end
+
+        it 'returns the second card second' do
+          expect(@two).to eq(cards[1])
+        end
+
+        it 'returns the third card third' do
+          expect(@three).to eq(cards[2])
+        end
+
+        it 'returns the fourth card fourth' do
+          expect(@four).to eq(cards[3])
+        end
+
+        it 'returns the fifth card fifth' do
+          expect(@five).to eq(cards[4])
+        end
+
+        it 'returns the sixth card sixth' do
+          expect(@six).to eq(cards[5])
+        end
+
+        context 'all cards drawn' do
+          it 'raises an error' do
+            expect { deck.draw }.to raise_error(Cardshark::Error::DeckExhausted)
+          end
+        end
+      end
+
+      context 'shuffled  deck' do
+        let(:deck) { described_class.new { cards } }
+
+        before do
+          deck.shuffle!([3, 4, 1, 5, 2, 0])
+
+          @one = deck.draw
+          @two = deck.draw
+          @three = deck.draw
+          @four = deck.draw
+          @five = deck.draw
+          @six = deck.draw
+        end
+
+        it 'returns a Cardshark::Card' do
+          expect(@one).to be_a(Cardshark::Card)
+        end
+
+        it 'returns the fourth card first' do
+          expect(@one).to eq(cards[3])
+        end
+
+        it 'returns the fifth card second' do
+          expect(@two).to eq(cards[4])
+        end
+
+        it 'returns the second card third' do
+          expect(@three).to eq(cards[1])
+        end
+
+        it 'returns the sixth card fourth' do
+          expect(@four).to eq(cards[5])
+        end
+
+        it 'returns the third card fifth' do
+          expect(@five).to eq(cards[2])
+        end
+
+        it 'returns the first card sixth' do
+          expect(@six).to eq(cards[0])
+        end
+
+        context 'all cards drawn' do
+          it 'raises an error' do
+            expect { deck.draw }.to raise_error(Cardshark::Error::DeckExhausted)
+          end
+        end
+      end
+    end
+
+    describe '#count' do
+      let(:deck) { described_class.new { cards } }
+
+      it 'returns the correct number of cards' do
+        expect(deck.count).to eq(6)
+      end
+    end
+
+    describe '#shuffled?' do
+      context 'new deck' do
+        let(:deck) { described_class.new { cards } }
+
+        it 'returns false' do
+          expect(deck.shuffled?).to eq(false)
+        end
+      end
+
+      context 'shuffled deck' do
+        let(:deck) { described_class.new { cards } }
+
+        before do
+          deck.shuffle!([3, 1, 2, 0, 5, 4])
+        end
+
+        it 'returns true' do
+          expect(deck.shuffled?).to eq(true)
+        end
+      end
+    end
+
+    describe 'shuffle!' do
+      let(:deck) { described_class.new { cards } }
+
+      context 'invalid arguments' do
+        context 'no arguments' do
+          it 'raises an ArgumentError' do
+            expect { deck.shuffle! }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'wrong argument type' do
+          it 'raises an ArgumentError' do
+            expect { deck.shuffle!('invalid-argument') }
+              .to raise_error(ArgumentError)
+          end
+        end
+
+        context 'invalid deck mapping' do
+          context 'non-integer elements' do
+            it 'raises an Cardshark::Error::DeckOrderInvalid' do
+              expect { deck.shuffle!(['a', 1, 2, 3, 4, 5]) }
+                .to raise_error(Cardshark::Error::DeckOrderInvalid)
+            end
+          end
+
+          context 'elements out of bounds' do
+            it 'raises an Cardshark::Error::DeckOrderInvalid' do
+              expect { deck.shuffle!([0, 1, 2, 3, 4, 6]) }
+                .to raise_error(Cardshark::Error::DeckOrderInvalid)
+            end
+          end
+
+          context 'too many elements' do
+            it 'raises an Cardshark::Error::DeckOrderInvalid' do
+              expect { deck.shuffle!([0, 1, 2, 3, 4, 5, 6]) }
+                .to raise_error(Cardshark::Error::DeckOrderInvalid)
+            end
+          end
+
+          context 'too few elements' do
+            it 'raises an Cardshark::Error::DeckOrderInvalid' do
+              expect { deck.shuffle!([0, 1, 2, 3]) }
+                .to raise_error(Cardshark::Error::DeckOrderInvalid)
+            end
+          end
+        end
+      end
+
+      context 'valid arguments' do
+        let(:deck_mapping) { [5, 4, 3, 2, 1, 0] }
+
+        before do
+          @result = deck.shuffle!(deck_mapping)
+        end
+
+        it 'returns an instance of the described class' do
+          expect(@result).to be_a(described_class)
+        end
+
+        it 'returns the same instance' do
+          expect(@result).to equal(deck)
+        end
+
+        context 'alredy shuffled' do
+          it 'raises a Cardshark::Error::AlreadyShuffled' do
+            expect { deck.shuffle!(deck_mapping) }
+              .to raise_error(Cardshark::Error::DeckAlreadyShuffled)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cardshark/dimension_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'cardshark/dimension'
+
+RSpec.describe Cardshark::Dimension do
+  describe '::new' do
+    it 'raises an Error::AbstractClass' do
+      expect { described_class.new(:id) }
+        .to raise_exception(Cardshark::Error::AbstractClass)
+    end
+  end
+
+  context 'when subclassed' do
+    let(:subclass) { Class.new(described_class) }
+
+    describe '::new' do
+      context 'invalid arguments' do
+        context 'no arguments' do
+          it 'raises an ArgumentError' do
+            expect { subclass.new }.to raise_exception(ArgumentError)
+          end
+        end
+
+        context 'invalid arguments' do
+          it 'raises an ArgumentError' do
+            expect { subclass.new('invalid-argument') }
+              .to raise_exception(ArgumentError)
+          end
+        end
+      end
+
+      context 'valid arguments' do
+        before do
+          @result = subclass.new(:id)
+        end
+
+        context 'return value' do
+          it 'is a an instance of the class' do
+            expect(@result).to be_an_instance_of(subclass)
+          end
+
+          it 'is a subclass of the described class' do
+            expect(@result.class.superclass).to eq(described_class)
+          end
+
+          it 'returns the same object for the same id' do
+            expect(@result).to equal(subclass.new(:id))
+          end
+        end
+      end
+    end
+
+    describe '::all' do
+      before { @result = subclass.all }
+
+      it 'returns an Array' do
+        expect(@result).to be_an(Array)
+      end
+
+      context 'it has not been instantiated' do
+        it 'returns an empty Array' do
+          expect(@result.count).to eq(0)
+        end
+      end
+
+      context 'it has been instantiated' do
+        before do
+          @instances = []
+          3.times { |i| @instances.push(subclass.new(i.to_s.to_sym)) }
+          @result = subclass.all
+        end
+        after { clear_instance_metadata }
+
+        it 'returns an array of instances' do
+          expect(@result.first.class).to eq(subclass)
+        end
+
+        it 'returns all of the instances' do
+          expect(@result).to match_array(@instances)
+        end
+      end
+    end
+
+    describe '::id' do
+      it 'returns a symbol' do
+        expect(subclass.id.class).to eq(Symbol)
+      end
+
+      context 'named subclass' do
+        before { class NamedClassExample < described_class; end }
+        after { Object.send(:remove_const, 'NamedClassExample') }
+
+        it 'returns a symbol version of the class name' do
+          expect(NamedClassExample.id).to eq(:named_class_example)
+        end
+      end
+    end
+
+    describe '#to_s' do
+      let(:instance) { subclass.new(:name) }
+
+      it 'returns a capitalized string' do
+        expect(instance.to_s).to eq('Name')
+      end
+    end
+  end
+
+  # This cleans up metadata about subclasses so that
+  # these specs can be run reliably in any order
+  def clear_instance_metadata
+    subclass.instance_variable_set(:@instances, {})
+  end
+end