console-poker 1.0.0

data/lib/poker.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'pry'
+
+require_relative 'poker/deck'
+require_relative 'poker/format'
+require_relative 'poker/hand'
+require_relative 'poker/menus'
+require_relative 'poker/utils'
+
+SAVE_FILE = 'poker.txt'
+MIN_BET = 500
+MAX_BET = 10_000_000
+
+class Poker
+  include Utils
+  include Menus
+
+  attr_accessor :deck, :money, :hand, :deck_type, :face_type, :current_bet, :quitting
+
+  def initialize
+    @face_type = 2
+    @deck_type = 1
+    @money = 10_000
+    @current_bet = 500
+  end
+
+  def run
+    load_game
+    @deck = Deck.new(self)
+
+    deal_new_hand
+    clear_draw_hand_bet_options until quitting
+  end
+
+  def build_new_hand
+    self.hand = Hand.new(self, current_bet)
+    5.times { hand.deal_card }
+  end
+
+  def deal_new_hand
+    deck.send("new_#{DECKS[deck_type]}")
+    build_new_hand
+
+    clear
+    draw_hand
+    hand.ask_hand_action
+    save_game
+  end
+
+  def clear
+    return if ENV['CLEAR_TERM'] == '0'
+
+    system('export TERM=linux; clear')
+  end
+
+  def draw_hand
+    out = String.new
+    out << "\n Player $"
+    out << Format.money(money / 100.0)
+    out << ":\n"
+    out << hand.draw
+    puts out
+  end
+
+  def new_bet(input)
+    clear
+    draw_hand
+
+    puts " Current Bet: $#{Format.money(current_bet / 100)}\n"
+    print ' Enter New Bet: $'
+
+    self.current_bet = input.gets.to_i * 100
+
+    normalize_current_bet
+    deal_new_hand
+  end
+
+  def normalize_current_bet
+    if current_bet < MIN_BET
+      self.current_bet = MIN_BET
+    elsif current_bet > MAX_BET
+      self.current_bet = MAX_BET
+    end
+
+    self.current_bet = money if current_bet > money
+  end
+
+  def self.getc(input)
+    begin
+      system('stty raw -echo')
+      c = input.getc
+    ensure
+      system('stty -raw echo')
+    end
+    c.chr
+  end
+end

data/poker.txt

@@ -0,0 +1 @@
+1|1|10000|500

data/spec/factories/card_factory.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :card do
+    poker { nil }
+    value { 0 }
+    suit { 0 }
+
+    trait :ace do
+      value { 0 }
+    end
+
+    trait :two do
+      value { 1 }
+    end
+
+    trait :three do
+      value { 2 }
+    end
+
+    trait :four do
+      value { 3 }
+    end
+
+    trait :five do
+      value { 4 }
+    end
+
+    trait :six do
+      value { 5 }
+    end
+
+    trait :seven do
+      value { 6 }
+    end
+
+    trait :eight do
+      value { 7 }
+    end
+
+    trait :nine do
+      value { 8 }
+    end
+
+    trait :ten do
+      value { 9 }
+    end
+
+    trait :jack do
+      value { 10 }
+    end
+
+    trait :queen do
+      value { 11 }
+    end
+
+    trait :king do
+      value { 12 }
+    end
+
+    trait :spades do
+      suit { 0 }
+    end
+
+    trait :hearts do
+      suit { 1 }
+    end
+
+    trait :clubs do
+      suit { 2 }
+    end
+
+    trait :diamonds do
+      suit { 3 }
+    end
+
+    initialize_with { new(poker, value, suit) }
+  end
+end

data/spec/factories/deck_factory.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :deck do
+    poker { nil }
+    cards { [] }
+
+    trait :new_regular do
+      after(:build, &:new_regular)
+    end
+
+    initialize_with { new(poker) }
+  end
+end

data/spec/factories/hand_factory.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :hand do
+    poker { nil }
+    bet { 500 }
+    cards { [] }
+
+    trait :unknown do
+      cards do
+        [
+          build(:card, :ace, suit: 1),
+          build(:card, :five),
+          build(:card, :six),
+          build(:card, :seven),
+          build(:card, :eight)
+        ]
+      end
+    end
+
+    trait :royal_flush do
+      cards do
+        [
+          build(:card, :ace),
+          build(:card, :king),
+          build(:card, :queen),
+          build(:card, :jack),
+          build(:card, :ten)
+        ]
+      end
+    end
+
+    trait :straight_flush do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :queen),
+          build(:card, :jack),
+          build(:card, :ten),
+          build(:card, :nine)
+        ]
+      end
+    end
+
+    trait :four_of_a_kind do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :ace),
+          build(:card, :ace),
+          build(:card, :ace),
+          build(:card, :ace)
+        ]
+      end
+    end
+
+    trait :full_house do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :king),
+          build(:card, :ace),
+          build(:card, :ace),
+          build(:card, :ace)
+        ]
+      end
+    end
+
+    trait :flush do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :queen),
+          build(:card, :jack),
+          build(:card, :ten),
+          build(:card, :eight)
+        ]
+      end
+    end
+
+    trait :straight do
+      cards do
+        [
+          build(:card, :king, suit: 1),
+          build(:card, :queen),
+          build(:card, :jack),
+          build(:card, :ten),
+          build(:card, :nine)
+        ]
+      end
+    end
+
+    trait :three_of_a_kind do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :queen),
+          build(:card, :ace, suit: 1),
+          build(:card, :ace),
+          build(:card, :ace)
+        ]
+      end
+    end
+
+    trait :two_pair do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :king, suit: 1),
+          build(:card, :queen),
+          build(:card, :queen, suit: 1),
+          build(:card, :ace)
+        ]
+      end
+    end
+
+    trait :one_pair do
+      cards do
+        [
+          build(:card, :king),
+          build(:card, :king, suit: 1),
+          build(:card, :queen),
+          build(:card, :jack),
+          build(:card, :ace)
+        ]
+      end
+    end
+
+    initialize_with { new(poker, bet) }
+  end
+end

data/spec/factories/poker_factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :poker do
+    deck { nil }
+    money { 10_000 }
+    hand { nil }
+    face_type { 1 }
+    current_bet { 500 }
+  end
+
+  trait :with_deck do
+    deck { build(:deck, :new_regular) }
+  end
+
+  initialize_with { new }
+end

data/spec/lib/poker/card_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Card do
+  let(:poker) { build(:poker) }
+  let(:card) { build(:card, poker:) }
+
+  describe '.new' do
+    it 'creates a card' do
+      expect(card).to be
+    end
+
+    it 'has a value' do
+      expect(card.value).to eq(0)
+    end
+
+    it 'has a suit' do
+      expect(card.suit).to eq(0)
+    end
+  end
+
+  describe '#to_s' do
+    context 'with regular faces' do
+      it 'returns a string value' do
+        expect(card.to_s).to eq('🂡')
+      end
+    end
+
+    context 'with alternate faces' do
+      before do
+        poker.face_type = 2
+      end
+
+      it 'returns a string value' do
+        expect(card.to_s).to eq('A♠')
+      end
+    end
+  end
+
+  describe '.faces' do
+    it 'returns a five of clubs' do
+      expect(described_class.faces[4][3]).to eq('🃕')
+    end
+  end
+end

data/spec/lib/poker/deck_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+RSpec.describe Deck do
+  let(:poker) { build(:poker) }
+  let(:deck) { build(:deck, poker:) }
+
+  describe '.new' do
+    it 'creates a deck' do
+      expect(deck).to be
+    end
+  end
+
+  describe '#new_regular' do
+    let(:deck) { build(:deck, poker:) }
+
+    it 'creates a deck' do
+      deck.new_regular
+      expect(deck.cards.size).to eq(Deck::TOTAL_CARDS)
+    end
+
+    it 'calls shuffle' do
+      allow(deck).to receive(:shuffle)
+      deck.new_regular
+      expect(deck).to have_received(:shuffle)
+    end
+  end
+
+  describe '#new_aces' do
+    let(:deck) { build(:deck, poker:) }
+
+    it 'creates a deck' do
+      deck.new_aces
+      expect(deck.cards.size).to eq(Deck::TOTAL_CARDS)
+    end
+
+    it 'calls shuffle' do
+      allow(deck).to receive(:shuffle)
+      deck.new_aces
+      expect(deck).to have_received(:shuffle)
+    end
+  end
+
+  describe '#new_jacks' do
+    let(:deck) { build(:deck, poker:) }
+
+    it 'creates a deck' do
+      deck.new_jacks
+      expect(deck.cards.size).to eq(Deck::TOTAL_CARDS)
+    end
+
+    it 'calls shuffle' do
+      allow(deck).to receive(:shuffle)
+      deck.new_jacks
+      expect(deck).to have_received(:shuffle)
+    end
+  end
+
+  describe '#new_aces_jacks' do
+    let(:deck) { build(:deck, poker:) }
+
+    it 'creates a deck' do
+      deck.new_aces_jacks
+      expect(deck.cards.size).to eq(Deck::TOTAL_CARDS)
+    end
+
+    it 'calls shuffle' do
+      allow(deck).to receive(:shuffle)
+      deck.new_aces_jacks
+      expect(deck).to have_received(:shuffle)
+    end
+  end
+
+  describe '#new_sevens' do
+    let(:deck) { build(:deck, poker:) }
+
+    it 'creates a deck' do
+      deck.new_sevens
+      expect(deck.cards.size).to eq(Deck::TOTAL_CARDS)
+    end
+
+    it 'calls shuffle' do
+      allow(deck).to receive(:shuffle)
+      deck.new_sevens
+      expect(deck).to have_received(:shuffle)
+    end
+  end
+
+  describe '#new_eights' do
+    let(:deck) { build(:deck, poker:) }
+
+    it 'creates a deck' do
+      deck.new_eights
+      expect(deck.cards.size).to eq(Deck::TOTAL_CARDS)
+    end
+
+    it 'calls shuffle' do
+      allow(deck).to receive(:shuffle)
+      deck.new_eights
+      expect(deck).to have_received(:shuffle)
+    end
+  end
+
+  describe '#next_card' do
+    let(:deck) { build(:deck, :new_regular, poker:) }
+
+    it 'removes the next card' do
+      expect { deck.next_card }.to change(deck.cards, :size).by(-1)
+    end
+
+    it 'returns a Card' do
+      expect(deck.next_card).to be_an_instance_of(Card)
+    end
+  end
+end

data/spec/lib/poker/format_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.describe Format do
+  describe '#money' do
+    it 'returns a formatted money string' do
+      str = described_class.money(1)
+      expect(str).to eq('1.00')
+    end
+  end
+end

data/spec/lib/poker/hand_ranker_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.describe HandRanker do
+  let(:poker) { build(:poker) }
+  let(:ranker) { described_class.new(hand) }
+
+  describe '.new' do
+    let(:hand) { build(:hand, :unknown, poker:) }
+
+    it 'creates a hand ranker' do
+      expect(ranker).to be
+      expect(hand.rank).to eq(:unknown)
+    end
+
+    context 'with less than 5 cards' do
+      let(:hand) { build(:hand, poker:) }
+
+      it 'raises an error' do
+        expect { ranker }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#rank_hand' do
+    before { ranker }
+
+    context 'with a royal_flush' do
+      let(:hand) { build(:hand, :royal_flush, poker:) }
+
+      it 'detects a royal_flush' do
+        expect(hand.rank).to eq(:royal_flush)
+      end
+    end
+
+    context 'with a straight_flush' do
+      let(:hand) { build(:hand, :straight_flush, poker:) }
+
+      it 'detects a straight_flush' do
+        expect(hand.rank).to eq(:straight_flush)
+      end
+    end
+
+    context 'with a four_of_a_kind' do
+      let(:hand) { build(:hand, :four_of_a_kind, poker:) }
+
+      it 'detects a four_of_a_kind' do
+        expect(hand.rank).to eq(:four_of_a_kind)
+      end
+    end
+
+    context 'with a full_house' do
+      let(:hand) { build(:hand, :full_house, poker:) }
+
+      it 'detects a full_house' do
+        expect(hand.rank).to eq(:full_house)
+      end
+    end
+
+    context 'with a flush' do
+      let(:hand) { build(:hand, :flush, poker:) }
+
+      it 'detects a flush' do
+        expect(hand.rank).to eq(:flush)
+      end
+    end
+
+    context 'with a straight' do
+      let(:hand) { build(:hand, :straight, poker:) }
+
+      it 'detects a straight' do
+        expect(hand.rank).to eq(:straight)
+      end
+    end
+
+    context 'with a three_of_a_kind' do
+      let(:hand) { build(:hand, :three_of_a_kind, poker:) }
+
+      it 'detects a three_of_a_kind' do
+        expect(hand.rank).to eq(:three_of_a_kind)
+      end
+    end
+
+    context 'with a two_pair' do
+      let(:hand) { build(:hand, :two_pair, poker:) }
+
+      it 'detects :two_pair' do
+        expect(hand.rank).to eq(:two_pair)
+      end
+    end
+
+    context 'with pair of twos and a pair of queens' do
+      let(:hand) do
+        build(:hand, poker:, cards: [build(:card, :two, :diamonds),
+                                     build(:card, :queen, :clubs),
+                                     build(:card, :queen, :hearts),
+                                     build(:card, :two, :spades),
+                                     build(:card, :ten, :hearts)])
+      end
+
+      it 'detects :two_pair' do
+        expect(hand.rank).to eq(:two_pair)
+      end
+    end
+
+    context 'with a one_pair' do
+      let(:hand) { build(:hand, :one_pair, poker:) }
+
+      it 'detects a one_pair' do
+        expect(hand.rank).to eq(:one_pair)
+      end
+    end
+
+    context 'with two successive values' do
+      let(:hand) do
+        build(:hand, poker:, cards:
+          [
+            build(:card, :king, suit: 1),
+            build(:card, :queen),
+            build(:card, :jack),
+            build(:card, :ten),
+            build(:card, :two)
+          ])
+      end
+
+      it 'is not a straight' do
+        expect(hand.rank).to eq(:unknown)
+      end
+    end
+  end
+end