deck_of_cards_handler 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ada5266ea6fced842e0110cfb42413202aecd0344b6e50d7e03284b148a3de12
-  data.tar.gz: 69e43292eb8d3476afd899093ec29391e96dcc97cc52c0378c08830c5b35b47e
+  metadata.gz: c7de6705b81dcdbf0b0a3401bb40a0a343fd6794ff909994c658c8a9f3d2304c
+  data.tar.gz: 8a4e77d32f0bf80d9fb5aab2b0fb79ce88c4a00715cc0ee40a13b019e1278ba4
 SHA512:
-  metadata.gz: b65f41b901b72be9ad9e8978b34cc2ada7f886ed5e6fe704d8fb630cd02cba94bbee162e9e09097b4496663e41cd50d251b653ed77ac9ff92bb7bb5f1458d19f
-  data.tar.gz: 62ce89b3c2cf352ad82a8fd3f8c2c86cfbe731cfe4c9f633b53dbd3ff6183d822d48916f6e1b5b66647c85e1e96a75038e1b00916f201119e51dc118e3cfc155
+  metadata.gz: 2493bd9f55e74662de828a3a4260bb4a0d4f638fb4e1d26326091921e654cf1f8313243dccecd0e06f152229a68f9d331429ff4a25621ea35b419d84506f3d73
+  data.tar.gz: 18f233fa7fd9626e39b49b599d39381a3a69cf2c7650e85d1b2f9b0c345a8d9be6a521fce8d05a84526c556630973b849033d62a9c64285977b63bf3a508287d

data/CHANGELOG.md

@@ -3,3 +3,7 @@
 ## [0.1.0] - 2025-09-26
 
 - Initial release
+
+## [0.1.6] - 2025-10-20
+
+- Added poker hand comparison

data/lib/deck_of_cards_handler/packet/packet.rb

@@ -70,10 +70,7 @@ class Packet
         cards << card
       end
 
-      packet = Packet.new(cards:)
-      packet.set_cards_positions
-
-      packet
+      Packet.new(cards:)
     end
   end
 

data/lib/deck_of_cards_handler/poker_hand.rb

@@ -1,123 +1,13 @@
-# typed: strict
 # frozen_string_literal: true
 
-# This represents a poker hands raking
-class PokerHand < Packet
-  extend T::Sig
-  extend T::Helpers
-
-  sig { params(cards: T::Array[Card]).void }
-  def initialize(cards:)
-    raise ArgumentError if cards.size != 5
-
-    super
-  end
-
-  class << self
-    sig { override.params(string: String).returns(PokerHand) }
-    def build_from_string(string:)
-      result = super
-      PokerHand.new(cards: result.cards)
-    end
-  end
-
-  HAND_RANKS = T.let(
-    {
-      nothing: 0,
-      pair: 1,
-      two_pairs: 2,
-      three_of_a_kind: 3,
-      straight: 4,
-      flush: 5,
-      full_house: 6,
-      four_of_a_kind: 7,
-      straight_flush: 8
-    }.freeze, T::Hash[Symbol, Integer]
-  )
-
-  sig { returns(Integer) }
-  def rank # rubocop:disable Metrics
-    return T.must(HAND_RANKS[:straight_flush]) if straight_flush?
-    return T.must(HAND_RANKS[:four_of_a_kind]) if four_of_a_kind?
-    return T.must(HAND_RANKS[:full_house]) if full_house?
-    return T.must(HAND_RANKS[:flush]) if flush?
-    return T.must(HAND_RANKS[:straight]) if straight?
-    return T.must(HAND_RANKS[:three_of_a_kind]) if three_of_a_kind?
-    return T.must(HAND_RANKS[:two_pairs]) if two_pairs?
-    return T.must(HAND_RANKS[:pair]) if pair?
-
-    T.must(HAND_RANKS[:nothing])
-  end
-
-  sig { returns(T::Boolean) }
-  def pair?
-    validate_hand_size
-
-    counts = cards.map(&:rank).flatten.tally
-    counts.values.count(2) == 1
-  end
-
-  sig { returns(T::Boolean) }
-  def two_pairs?
-    validate_hand_size
-
-    counts = cards.map(&:rank).flatten.tally
-    counts.values.count(2) == 2
-  end
-
-  sig { returns(T::Boolean) }
-  def three_of_a_kind?
-    validate_hand_size
-
-    counts = cards.map(&:rank).flatten.tally
-    counts.values.count(3) == 1
-  end
-
-  sig { returns(T::Boolean) }
-  def straight? # rubocop:disable Metrics/AbcSize
-    validate_hand_size
-
-    ranks = cards.map(&:rank).sort
-    return true if ranks.each_cons(2).all? { |a, b| b == T.must(a) + 1 }
-
-    ranks = cards.map { _1.rank(low_ace: true) }
-    ranks.each_cons(2).all? { |a, b| b == T.must(a) + 1 }
-  end
-
-  sig { returns(T::Boolean) }
-  def flush?
-    validate_hand_size
-
-    suit = T.must(cards.first).suit
-    cards.all? { _1.suit == suit }
-  end
-
-  sig { returns(T::Boolean) }
-  def full_house?
-    validate_hand_size
-
-    three_of_a_kind? && pair?
-  end
-
-  sig { returns(T::Boolean) }
-  def four_of_a_kind?
-    validate_hand_size
-
-    counts = cards.map(&:rank).flatten.tally
-    counts.values.count(4) == 1
-  end
-
-  sig { returns(T::Boolean) }
-  def straight_flush?
-    validate_hand_size
-
-    straight? && flush?
-  end
-
-  private
-
-  sig { void }
-  def validate_hand_size
-    raise StandardError unless size == 5
-  end
-end
+require_relative "poker_hands/poker_hand"
+
+require_relative "poker_hands/high_card"
+require_relative "poker_hands/one_pair"
+require_relative "poker_hands/two_pairs"
+require_relative "poker_hands/three_of_a_kind"
+require_relative "poker_hands/straight"
+require_relative "poker_hands/flush"
+require_relative "poker_hands/full_house"
+require_relative "poker_hands/four_of_a_kind"
+require_relative "poker_hands/straight_flush"

data/lib/deck_of_cards_handler/poker_hands/flush.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class Flush < PokerHand
+    sig { override.returns(Integer) }
+    def rank
+      6
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      0
+    end
+
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        suit = T.must(cards.first).suit
+        cards.all? { _1.suit == suit }
+      end
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/four_of_a_kind.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class FourOfAKind < PokerHand
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        counts = cards.map(&:rank).flatten.tally
+        counts.values.count(4) == 1
+      end
+    end
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :four_of_a_kind
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :kicker
+
+    sig { params(cards: T::Array[Card]).void }
+    def initialize(cards:)
+      super
+      @four_of_a_kind = T.let(extract_four_of_a_kind, T::Array[Card])
+      @kicker = T.let(extract_kicker, T::Array[Card])
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      8
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      comparison = four_of_a_kind_value <=> other.four_of_a_kind_value
+      return comparison unless comparison.zero?
+
+      kicker_value <=> other.kicker_value
+    end
+
+    protected
+
+    sig { returns(Integer) }
+    def four_of_a_kind_value
+      T.must(four_of_a_kind.first).rank
+    end
+
+    sig { returns(Integer) }
+    def kicker_value
+      T.must(kicker.first).rank
+    end
+
+    private
+
+    sig { returns(T::Array[Card]) }
+    def extract_four_of_a_kind
+      cards.group_by(&:rank).values.select { _1.size == 4 }.flatten
+    end
+
+    sig { returns(T::Array[Card]) }
+    def extract_kicker
+      cards.group_by(&:rank).values.select { _1.size == 1 }.flatten
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/full_house.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class FullHouse < PokerHand
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        PokerHands::ThreeOfAKind.is?(cards) && PokerHands::OnePair.is?(cards)
+      end
+    end
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :three_of_a_kind
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :pair
+
+    sig { params(cards: T::Array[Card]).void }
+    def initialize(cards:)
+      super
+      @three_of_a_kind = T.let(extract_three_of_a_kind, T::Array[Card])
+      @pair = T.let(extract_pair, T::Array[Card])
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      7
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      comparison = three_of_a_kind_value <=> other.three_of_a_kind_value
+      return comparison unless comparison.zero?
+
+      pair_value <=> other.pair_value
+    end
+
+    protected
+
+    sig { returns(Integer) }
+    def three_of_a_kind_value
+      T.must(three_of_a_kind.first).rank
+    end
+
+    sig { returns(Integer) }
+    def pair_value
+      T.must(pair.first).rank
+    end
+
+    private
+
+    sig { returns(T::Array[Card]) }
+    def extract_three_of_a_kind
+      cards.group_by(&:rank).values.select { _1.size == 3 }.flatten
+    end
+
+    sig { returns(T::Array[Card]) }
+    def extract_pair
+      cards.group_by(&:rank).values.select { _1.size == 2 }.flatten
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/high_card.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class HighCard < PokerHand
+    sig { override.returns(Integer) }
+    def rank
+      1
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank if self.class != other.class
+
+      sum_cards_ranks(cards) <=> sum_cards_ranks(other.cards)
+    end
+
+    private
+
+    sig { params(cards: T::Array[Card]).returns(Integer) }
+    def sum_cards_ranks(cards)
+      T.must(cards.map(&:rank).reduce(&:+))
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/one_pair.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class OnePair < PokerHand
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        counts = cards.map(&:rank).flatten.tally
+        counts.values.count(2) == 1
+      end
+    end
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :pair
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :kickers
+
+    sig { params(cards: T::Array[Card]).void }
+    def initialize(cards:)
+      super
+      @pair = T.let(extract_pair, T::Array[Card])
+      @kickers = T.let(extract_kickers, T::Array[Card])
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      2
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      pair_comparison = pair_value <=> other.pair_value
+      return pair_comparison unless pair_comparison.zero?
+
+      kickers_value <=> other.kickers_value
+    end
+
+    protected
+
+    sig { returns(Integer) }
+    def pair_value
+      T.must(pair.first).rank
+    end
+
+    sig { returns(Integer) }
+    def kickers_value
+      T.must(kickers.map(&:rank).reduce(&:+))
+    end
+
+    private
+
+    sig { returns(T::Array[Card]) }
+    def extract_pair
+      cards.group_by(&:rank).values.select { _1.size == 2 }.flatten
+    end
+
+    sig { returns(T::Array[Card]) }
+    def extract_kickers
+      cards.group_by(&:rank).values.select { _1.size == 1 }.flatten
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/poker_hand.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module PokerHands
+  # This represents a poker hands raking
+  class PokerHand
+    extend T::Sig
+    extend T::Helpers
+    include Comparable
+    abstract!
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :cards
+
+    sig { params(cards: T::Array[Card]).void }
+    def initialize(cards:)
+      raise ArgumentError if cards.size != 5
+
+      @cards = cards
+    end
+
+    HANDS = %i[OnePair TwoPairs ThreeOfAKind Straight Flush FullHouse FourOfAKind StraightFlush].freeze
+
+    sig { abstract.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other); end
+
+    sig { abstract.returns(Integer) }
+    def rank; end
+
+    class << self
+      extend T::Sig
+      sig { params(string: String).returns(PokerHand) }
+      def build_from_string(string:)
+        cards = Packet.build_from_string(string:).cards
+        PokerHand.create(cards:)
+      end
+
+      sig do
+        params(cards: T::Array[Card]).returns(
+          T.any(
+            HighCard,
+            OnePair,
+            TwoPairs,
+            ThreeOfAKind,
+            Straight,
+            Flush,
+            FullHouse,
+            FourOfAKind,
+            StraightFlush
+          )
+        )
+      end
+      def create(cards:)
+        HANDS.reverse_each do |hand|
+          return PokerHands.const_get(hand).new(cards:) if PokerHands.const_get(hand).is?(cards)
+        end
+        HighCard.new(cards:)
+      end
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/straight.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class Straight < PokerHand
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        ranks = cards.map(&:rank).sort
+        return true if ranks.each_cons(2).all? { |a, b| b == T.must(a) + 1 }
+
+        ranks = cards.map { _1.rank(low_ace: true) }.sort
+        ranks.each_cons(2).all? { |a, b| b == T.must(a) + 1 }
+      end
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      5
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      c1 = cards.map { card_value(_1) }
+      c2 = other.cards.map { other.card_value(_1) }
+
+      c1 <=> c2
+    end
+
+    protected
+
+    sig { params(card: Card).returns(Integer) }
+    def card_value(card)
+      return card.rank unless card.value == "A"
+      return 1 if low_ace?
+
+      14
+    end
+
+    private
+
+    sig { returns(T::Boolean) }
+    def low_ace?
+      ranks = cards.map { _1.rank(low_ace: true) }.sort
+      ranks.each_cons(2).all? { |a, b| b == T.must(a) + 1 }
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/straight_flush.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class StraightFlush < PokerHand
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        Flush.is?(cards) && Straight.is?(cards)
+      end
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      9
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      c1 = cards.map { card_value(_1) }
+      c2 = other.cards.map { other.card_value(_1) }
+
+      c1 <=> c2
+    end
+
+    protected
+
+    sig { params(card: Card).returns(Integer) }
+    def card_value(card)
+      return card.rank unless card.value == "A"
+      return 1 if low_ace?
+
+      14
+    end
+
+    private
+
+    sig { returns(T::Boolean) }
+    def low_ace?
+      ranks = cards.map { _1.rank(low_ace: true) }.sort
+      ranks.each_cons(2).all? { |a, b| b == T.must(a) + 1 }
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/three_of_a_kind.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class ThreeOfAKind < PokerHand
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        counts = cards.map(&:rank).flatten.tally
+        counts.values.count(3) == 1
+      end
+    end
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :three_of_a_kind
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :kickers
+
+    sig { params(cards: T::Array[Card]).void }
+    def initialize(cards:)
+      super
+      @three_of_a_kind = T.let(extract_three_of_a_kind, T::Array[Card])
+      @kickers = T.let(extract_kickers, T::Array[Card])
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      4
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      comparison = three_of_a_kind_value <=> other.three_of_a_kind_value
+      return comparison unless comparison.zero?
+
+      kickers_value <=> other.kickers_value
+    end
+
+    protected
+
+    sig { returns(Integer) }
+    def three_of_a_kind_value
+      T.must(three_of_a_kind.first).rank
+    end
+
+    sig { returns(Integer) }
+    def kickers_value
+      T.must(kickers.map(&:rank).reduce(&:+))
+    end
+
+    private
+
+    sig { returns(T::Array[Card]) }
+    def extract_three_of_a_kind
+      cards.group_by(&:rank).values.select { _1.size == 3 }.flatten
+    end
+
+    sig { returns(T::Array[Card]) }
+    def extract_kickers
+      cards.group_by(&:rank).values.select { _1.size == 1 }.flatten
+    end
+  end
+end

data/lib/deck_of_cards_handler/poker_hands/two_pairs.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# typed: strict
+
+module PokerHands
+  class TwoPairs < PokerHand
+    sig { returns(T::Array[Card]) }
+    attr_reader :pairs
+
+    sig { returns(T::Array[Card]) }
+    attr_reader :kicker
+
+    sig { params(cards: T::Array[Card]).void }
+    def initialize(cards:)
+      super
+      @pairs = T.let(extract_pairs, T::Array[Card])
+      @kicker = T.let(extract_kicker, T::Array[Card])
+    end
+
+    sig { override.returns(Integer) }
+    def rank
+      3
+    end
+
+    sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+    def <=>(other) # rubocop:disable Metrics/AbcSize
+      return rank <=> other.rank unless instance_of?(other.class)
+
+      first_pair_comparison = pair_values.first <=> other.pair_values.first
+      return first_pair_comparison unless T.must(first_pair_comparison).zero?
+
+      second_pair_comparison = pair_values.last <=> other.pair_values.last
+      return second_pair_comparison unless T.must(second_pair_comparison).zero?
+
+      kickers_value <=> other.kickers_value
+    end
+
+    class << self
+      sig { params(cards: T::Array[Card]).returns(T::Boolean) }
+      def is?(cards)
+        counts = cards.map(&:rank).flatten.tally
+        counts.values.count(2) == 2
+      end
+    end
+
+    protected
+
+    sig { returns(T::Array[Integer]) }
+    def pair_values
+      pairs.map(&:rank).sort.reverse
+    end
+
+    sig { returns(Integer) }
+    def kickers_value
+      T.must(kicker.map(&:rank).reduce(&:+))
+    end
+
+    private
+
+    sig { returns(T::Array[Card]) }
+    def extract_pairs
+      cards.group_by(&:rank).values.select { _1.size == 2 }.flatten
+    end
+
+    sig { returns(T::Array[Card]) }
+    def extract_kicker
+      cards.group_by(&:rank).values.select { _1.size == 1 }.flatten
+    end
+  end
+end

data/lib/deck_of_cards_handler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeckOfCardsHandler
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deck_of_cards_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Simon Bernard
@@ -76,6 +76,16 @@ files:
 - lib/deck_of_cards_handler/packet/packet.rb
 - lib/deck_of_cards_handler/packet/shuffles.rb
 - lib/deck_of_cards_handler/poker_hand.rb
+- lib/deck_of_cards_handler/poker_hands/flush.rb
+- lib/deck_of_cards_handler/poker_hands/four_of_a_kind.rb
+- lib/deck_of_cards_handler/poker_hands/full_house.rb
+- lib/deck_of_cards_handler/poker_hands/high_card.rb
+- lib/deck_of_cards_handler/poker_hands/one_pair.rb
+- lib/deck_of_cards_handler/poker_hands/poker_hand.rb
+- lib/deck_of_cards_handler/poker_hands/straight.rb
+- lib/deck_of_cards_handler/poker_hands/straight_flush.rb
+- lib/deck_of_cards_handler/poker_hands/three_of_a_kind.rb
+- lib/deck_of_cards_handler/poker_hands/two_pairs.rb
 - lib/deck_of_cards_handler/version.rb
 - sig/deck_of_cards.rbs
 - sorbet/config