fiftytwo 0.0.1

data/lib/fiftytwo/deck.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "./has_cards"
+
+module FiftyTwo
+  class Deck
+    include HasCards
+
+    class << self
+      def standard
+        build(FiftyTwo::Rank::ALL.product(FiftyTwo::Suit::ALL))
+      end
+
+      private
+
+      def build(items)
+        new.tap do |deck|
+          items.each do |rank, suit|
+            deck << FiftyTwo::Card.new(deck, rank, suit).freeze
+          end
+        end
+      end
+    end
+
+    def deal(hands, hand_size: 1)
+      hand_size.times.each do |card_idx|
+        hands.each { |h| h << draw }
+      end
+
+      hands
+    end
+  end
+end

data/lib/fiftytwo/hand.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "./has_cards"
+
+module FiftyTwo
+  class Hand
+    include HasCards
+  end
+end

data/lib/fiftytwo/has_cards.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module FiftyTwo
+  module HasCards
+    extend Enumerable
+    attr_reader :cards
+    delegate :shuffle!, :sort!, :<<, :[], :each, :map, :count, :first, :last, to: :cards
+
+    CardUnavailableError = Class.new(StandardError)
+
+    def initialize(cards = [])
+      @cards = cards
+    end
+
+    def draw
+      cards.shift
+    end
+
+    def render
+      map(&:render).join(" ")
+    end
+
+    def locate(identifier)
+      cards.find { |c| c.identifier == identifier.upcase }
+    end
+
+    def transfer(card, destination = nil)
+      card = locate(card) unless card.is_a?(FiftyTwo::Card)
+      raise CardUnavailableError if card.nil?
+      raise CardUnavailableError unless cards.include?(card)
+      (destination || card.deck) << cards.delete(card)
+    end
+
+    FiftyTwo::Suit::ALL.each do |suit|
+      define_method(suit.name) { select(suit.name) }
+    end
+
+    FiftyTwo::Suit::Color::ALL.each do |color|
+      define_method(color.name.pluralize) { select(color.name) }
+    end
+
+    [*FiftyTwo::Rank::CATEGORIES, :jack, :king, :queen, :ace].each do |category|
+      define_method(category.to_s.pluralize) { select(category) }
+    end
+
+    private
+
+    def select(identifier)
+      self.class.new(cards.select { |c| c.send("#{identifier}?") })
+    end
+  end
+end

data/lib/fiftytwo/rank.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module FiftyTwo
+  class Rank
+    include Comparable
+    CATEGORIES = %i[pip face]
+
+    attr_reader :value, :name, :category
+
+    def initialize(value, name = nil, category = :pip)
+      @value = value
+      @name = name || value.to_s
+      @category = category
+    end
+
+    ALL = [
+      TWO = Rank.new(2).freeze,
+      THREE = Rank.new(3).freeze,
+      FOUR = Rank.new(4).freeze,
+      FIVE = Rank.new(5).freeze,
+      SIX = Rank.new(6).freeze,
+      SEVEN = Rank.new(7).freeze,
+      EIGHT = Rank.new(8).freeze,
+      NINE = Rank.new(9).freeze,
+      TEN = Rank.new(10).freeze,
+      JACK = Rank.new(11, "jack", :face).freeze,
+      QUEEN = Rank.new(12, "queen", :face).freeze,
+      KING = Rank.new(13, "king", :face).freeze,
+      ACE = Rank.new(14, "ace").freeze
+    ]
+
+    CATEGORIES.each do |category|
+      define_method("#{category}?") { self.category == category }
+    end
+
+    ALL.select(&:face?).each do |rank|
+      define_method("#{rank.name}?") { self == rank }
+    end
+
+    def ace?
+      name == "ace"
+    end
+
+    def <=>(other)
+      value <=> other.value
+    end
+
+    def to_s
+      name.titleize
+    end
+
+    def identifier
+      name.to_i > 0 ? name : name[0].upcase
+    end
+    alias_method :code, :identifier
+  end
+end

data/lib/fiftytwo/suit.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "./suit/color"
+
+module FiftyTwo
+  class Suit
+    include Comparable
+
+    attr_reader :name, :color, :symbol
+    alias_method :code, :symbol
+
+    def initialize(name, color, symbol = nil)
+      @name = name
+      @color = color
+      @symbol = symbol
+    end
+
+    ALL = [
+      CLUBS = Suit.new("clubs", Color::BLACK, "♣").freeze,
+      DIAMONDS = Suit.new("diamonds", Color::RED, "♦").freeze,
+      HEARTS = Suit.new("hearts", Color::RED, "♥").freeze,
+      SPADES = Suit.new("spades", Color::BLACK, "♠").freeze
+    ]
+
+    Color::ALL.each do |color|
+      define_method("#{color.name}?") { self.color == color }
+    end
+
+    ALL.each do |suit|
+      define_method("#{suit.name.downcase}?") { self == suit }
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name.titleize
+    end
+
+    def identifier
+      name[0].upcase
+    end
+  end
+end

data/lib/fiftytwo/suit/color.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FiftyTwo
+  class Suit
+    class Color
+      attr_reader :name, :rgb
+
+      def initialize(name, rgb)
+        @name = name
+        @rgb = rgb
+      end
+
+      ALL = [
+        RED = new("red", "ff0000"),
+        BLACK = new("black", "000000")
+      ]
+
+      def ==(other)
+        name == other.name
+      end
+    end
+  end
+end

data/lib/fiftytwo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FiftyTwo
+  VERSION = "0.0.1"
+end

data/spec/lib/fiftytwo/card_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module FiftyTwo
+  describe Card do
+    let(:deck) { instance_double(FiftyTwo::Deck) }
+    let(:rank) { instance_double(FiftyTwo::Rank, code: "RC", identifier: "RI", to_s: "92") }
+    let(:suit) { instance_double(FiftyTwo::Suit, code: "SC", identifier: "SI", to_s: "Mittens") }
+    let(:subject) { described_class.new(deck, rank, suit) }
+
+    it "exposes its basics" do
+      expect(subject.deck).to eq deck
+      expect(subject.rank).to eq rank
+      expect(subject.suit).to eq suit
+    end
+
+    it "has a variety of serializations" do
+      expect(subject.code).to eq "RCSC"
+      expect(subject.identifier).to eq "RISI"
+      expect(subject.to_s).to eq "92 of Mittens"
+    end
+
+    describe "#render" do
+      let(:color) { instance_double(FiftyTwo::Suit::Color, name: "blue") }
+      before(:each) { allow(suit).to receive(:color).and_return color }
+
+      it "builds a proper rendering from 2 characters" do
+        allow(subject).to receive(:code).and_return "XY"
+        expect(subject.render).to eq "\e[0;34;49m XY\e[0m"
+      end
+
+      it "builds a proper rendering from 3 characters" do
+        allow(subject).to receive(:code).and_return "XYZ"
+        expect(subject.render).to eq "\e[0;34;49mXYZ\e[0m"
+      end
+    end
+
+    context "questions" do
+      before(:each) do
+        allow(rank).to receive(:face?).and_return "grumpy"
+        allow(rank).to receive(:pip?).and_return "pip hooray"
+        allow(suit).to receive(:red?).and_return "roses"
+        allow(suit).to receive(:diamonds?).and_return "drip"
+      end
+
+      it "can answer questions only its rank knows" do
+        expect(subject.face?).to eq "grumpy"
+        expect(subject.pip?).to eq "pip hooray"
+      end
+
+      it "can answer questions only its suit knows" do
+        expect(subject.red?).to eq "roses"
+        expect(subject.diamonds?).to eq "drip"
+      end
+
+      it "will not answer silly questions" do
+        subject.hungry?
+      rescue NoMethodError
+      end
+    end
+
+    context "comparable" do
+      context "different rank, different suit" do
+        it "orders by rank first" do
+          card1 = described_class.new(deck, FiftyTwo::Rank::FOUR, FiftyTwo::Suit::CLUBS)
+          card2 = described_class.new(deck, FiftyTwo::Rank::TWO, FiftyTwo::Suit::DIAMONDS)
+          expect(card2).to be < card1
+        end
+      end
+
+      context "different rank, same suit" do
+        it "orders by rank first" do
+          card1 = described_class.new(deck, FiftyTwo::Rank::FOUR, FiftyTwo::Suit::SPADES)
+          card2 = described_class.new(deck, FiftyTwo::Rank::SEVEN, FiftyTwo::Suit::SPADES)
+          expect(card2).to be > card1
+        end
+      end
+
+      context "same rank, different suit" do
+        it "orders by suit" do
+          card1 = described_class.new(deck, FiftyTwo::Rank::KING, FiftyTwo::Suit::SPADES)
+          card2 = described_class.new(deck, FiftyTwo::Rank::KING, FiftyTwo::Suit::HEARTS)
+          expect(card2).to be < card1
+        end
+      end
+
+      context "same rank, same suit" do
+        it "calls it a tie" do
+          card1 = described_class.new(deck, FiftyTwo::Rank::TEN, FiftyTwo::Suit::DIAMONDS)
+          card2 = described_class.new(deck, FiftyTwo::Rank::TEN, FiftyTwo::Suit::DIAMONDS)
+          expect(card2).to eq card1
+        end
+      end
+    end
+  end
+end

data/spec/lib/fiftytwo/deck_spec.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module FiftyTwo
+  describe Deck do
+    let(:subject) { described_class.standard }
+    let(:minideck) { described_class.new }
+    before(:each) do
+      minideck << FiftyTwo::Card.new(minideck, FiftyTwo::Rank::THREE, FiftyTwo::Suit::CLUBS)
+      minideck << FiftyTwo::Card.new(minideck, FiftyTwo::Rank::NINE, FiftyTwo::Suit::DIAMONDS)
+    end
+
+    it "is a deck, made up of cards" do
+      expect(subject).to be_a described_class
+      expect(subject.count).to eq 52
+      subject.each do |card|
+        expect(card).to be_a FiftyTwo::Card
+        expect(card.deck).to eq subject
+      end
+    end
+
+    it "has 13 distinct ranks" do
+      expect(subject.map(&:rank).uniq.count).to eq 13
+    end
+
+    it "has 4 distinct suits" do
+      expect(subject.map(&:suit).uniq.count).to eq 4
+    end
+
+    it "has 2 distinct colors" do
+      expect(subject.map(&:color).uniq.count).to eq 2
+    end
+
+    context "shuffling/sorting" do
+      def sorted?(deck)
+        is_sorted = true
+        deck[1..].each_with_index do |card, i|
+          is_sorted = false unless deck[i] < card
+        end
+        is_sorted
+      end
+
+      it "starts with cards ordered properly" do
+        expect(sorted?(subject)).to be true
+      end
+
+      it "can shuffle the cards" do
+        subject.shuffle!
+        expect(sorted?(subject)).to be false
+      end
+
+      it "can resort the cards" do
+        subject.shuffle!
+        subject.sort!
+        expect(sorted?(subject)).to be true
+      end
+    end
+
+    context "filtering" do
+      require "pry"
+      it "can find diamonds" do
+        cards = subject.diamonds
+        expect(cards.count).to eq 13
+      end
+
+      it "can find blacks" do
+        cards = subject.blacks
+        expect(cards.count).to eq 26
+      end
+
+      it "can find pips" do
+        cards = subject.pips
+        expect(cards.count).to eq 40
+      end
+
+      it "can find faces" do
+        cards = subject.faces
+        expect(cards.count).to eq 12
+      end
+
+      it "can find jacks" do
+        cards = subject.jacks
+        expect(cards.count).to eq 4
+      end
+
+      it "can find queens" do
+        cards = subject.queens
+        expect(cards.count).to eq 4
+      end
+
+      it "can find kings" do
+        cards = subject.kings
+        expect(cards.count).to eq 4
+      end
+
+      it "can find aces" do
+        cards = subject.aces
+        expect(cards.count).to eq 4
+      end
+
+      it "can find red faces" do
+        cards = subject.reds.faces
+        expect(cards.count).to eq 6
+      end
+
+      it "can find black jacks" do
+        cards = subject.jacks.blacks
+        expect(cards.count).to eq 2
+      end
+
+      it "can find pip spades" do
+        cards = subject.pips.spades
+        expect(cards.count).to eq 10
+      end
+    end
+
+    describe "#draw" do
+      let(:subject) { minideck }
+
+      it "takes cards in order from the deck" do
+        expect(subject.count).to eq 2
+
+        card = subject.draw
+        expect(subject.count).to eq 1
+        expect(card).to be_a FiftyTwo::Card
+        expect(card.identifier).to eq "3C"
+
+        card = subject.draw
+        expect(subject.count).to eq 0
+        expect(card).to be_a FiftyTwo::Card
+        expect(card.identifier).to eq "9D"
+
+        card = subject.draw
+        expect(subject.count).to eq 0
+        expect(card).to be nil
+      end
+    end
+
+    describe "#locate" do
+      it "can find the 3 of diamonds via 3D" do
+        card = subject.locate("3D")
+        expect(card.rank).to eq FiftyTwo::Rank::THREE
+        expect(card.suit).to eq FiftyTwo::Suit::DIAMONDS
+      end
+
+      it "can find the ace of spades via as" do
+        card = subject.locate("as")
+        expect(card.rank).to eq FiftyTwo::Rank::ACE
+        expect(card.suit).to eq FiftyTwo::Suit::SPADES
+      end
+
+      it "can find the 10 of clubs via 10C" do
+        card = subject.locate("10C")
+        expect(card.rank).to eq FiftyTwo::Rank::TEN
+        expect(card.suit).to eq FiftyTwo::Suit::CLUBS
+      end
+
+      it "returns nil on a nonsense code" do
+        card = subject.locate("MITTENS")
+        expect(card).to be nil
+      end
+
+      context "removed card" do
+        let(:subject) { minideck }
+
+        it "returns nil if the card is not currently in the deck" do
+          card = minideck.locate("10C")
+          expect(card).to be nil
+        end
+      end
+    end
+
+    describe "#transfer" do
+      let(:subject) { minideck }
+      let(:hand) { FiftyTwo::Hand.new }
+
+      it "has a deck with 2 cards, and a hand with none" do
+        expect(subject.count).to eq 2
+        expect(hand.count).to eq 0
+      end
+
+      it "can transfer a card by object" do
+        subject.transfer(subject[1], hand)
+        expect(subject.count).to eq 1
+        expect(hand.count).to eq 1
+      end
+
+      it "can transfer a card by identifier" do
+        subject.transfer("3C", hand)
+        expect(subject.count).to eq 1
+        expect(hand.count).to eq 1
+      end
+
+      context "missing card" do
+        let(:missing_card) { FiftyTwo::Card.new(subject, FiftyTwo::Rank::THREE, FiftyTwo::Suit::HEARTS) }
+
+        it "raises an error on a card not in the deck" do
+          expect { subject.transfer(missing_card, hand) }.to raise_error FiftyTwo::HasCards::CardUnavailableError
+        end
+
+        it "raises an error on an identifier not in the deck" do
+          expect { subject.transfer(missing_card.identifier, hand) }.to raise_error FiftyTwo::HasCards::CardUnavailableError
+        end
+      end
+
+      context "back to originating deck" do
+        let(:card) { subject[1] }
+        before(:each) { subject.transfer(card, hand) }
+
+        it "starts with a card in the hand and a card in the deck" do
+          expect(subject.count).to eq 1
+          expect(hand.count).to eq 1
+        end
+
+        it "can transfer a card from a hand back to the bottom of its originating deck" do
+          hand.transfer(card)
+          expect(subject.count).to eq 2
+          expect(hand.count).to eq 0
+          expect(subject.last).to eq card
+        end
+      end
+    end
+
+    describe "#render" do
+      let(:subject) { minideck }
+
+      before(:each) do
+        minideck.cards.each_with_index do |card, i|
+          allow(card).to receive(:render).and_return "CARD#{i}"
+        end
+      end
+
+      it "renders the set of cards in this deck" do
+        expect(subject.render).to eq "CARD0 CARD1"
+      end
+    end
+
+    describe "#deal" do
+      let(:hand1) { FiftyTwo::Hand.new }
+      let(:hand2) { FiftyTwo::Hand.new }
+      let(:hand3) { FiftyTwo::Hand.new }
+      let(:hands) { [hand1, hand2, hand3] }
+      before(:each) { subject.shuffle! }
+
+      it "starts out as expected" do
+        expect(subject.count).to eq 52
+        hands.each { |h| expect(h.count).to eq 0 }
+      end
+
+      it "can deal a single card to variety of hands" do
+        card1 = subject[0]
+        card2 = subject[1]
+        card3 = subject[2]
+
+        subject.deal(hands)
+        expect(subject.count).to eq 49
+        expect(hand1.cards).to match_array [card1]
+        expect(hand2.cards).to match_array [card2]
+        expect(hand3.cards).to match_array [card3]
+      end
+
+      it "can deal multiple cards to a variety of hands" do
+        card1 = subject[0]
+        card2 = subject[1]
+        card3 = subject[2]
+        card4 = subject[3]
+        card5 = subject[4]
+        card6 = subject[5]
+        card7 = subject[6]
+        card8 = subject[7]
+        card9 = subject[8]
+
+        subject.deal(hands, hand_size: 3)
+        expect(subject.count).to eq 43
+        expect(hand1.cards).to match_array [card1, card4, card7]
+        expect(hand2.cards).to match_array [card2, card5, card8]
+        expect(hand3.cards).to match_array [card3, card6, card9]
+      end
+    end
+  end
+end