deck_of_cards_handler 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bb4b9ad9eeda85ab0251a2d2a0d1030ad1713956582d204726402254d1b423b
-  data.tar.gz: 61b9a15a482800bc77b55f3e81402314ad1668fdfb0d8d1076bec4388ab05cb6
+  metadata.gz: c7de6705b81dcdbf0b0a3401bb40a0a343fd6794ff909994c658c8a9f3d2304c
+  data.tar.gz: 8a4e77d32f0bf80d9fb5aab2b0fb79ce88c4a00715cc0ee40a13b019e1278ba4
 SHA512:
-  metadata.gz: f10d2d29dabdd04098c987d992e06c303cb3a142097973aceb4f0e11cbfaf52feeea8d23418f488167fa645742accfb44ac6841efc71b84cada89b5362275865
-  data.tar.gz: aa06d832d4e713cade2a60cd8a06fc7d7da776e3f86b9b1ce62c6101448c91c930f4248efd7a82c84587add52de9d3d08c05205a623eca53dde2d7c5f4fcb95a
+  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/README.md

@@ -46,6 +46,62 @@ gem install deck_of_cards_handler
   # assign a position value to the cards
   deck.set_cards_positions
 
+  deck
+#  =>
+# <Packet:0x000000012ae2b848
+#  @cards=
+    [#<Card:0x000000012ae2bd20 @position=1, @suit="S", @value="4">,
+    #<Card:0x000000012ae2cae0 @position=2, @suit="H", @value="2">,
+    #<Card:0x000000012ae2c220 @position=3, @suit="D", @value="7">,
+    #<Card:0x000000012ae2bd98 @position=4, @suit="S", @value="3">,
+    #<Card:0x000000012ae2c9f0 @position=5, @suit="H", @value="4">,
+    #<Card:0x000000012ae2c298 @position=6, @suit="D", @value="6">,
+    #<Card:0x000000012ae2df08 @position=7, @suit="C", @value="A">,
+    #<Card:0x000000012ae2c978 @position=8, @suit="H", @value="5">,
+    #<Card:0x000000012ae2ce00 @position=9, @suit="C", @value="9">,
+    #<Card:0x000000012ae2d260 @position=10, @suit="C", @value="2">,
+    #<Card:0x000000012ae2c630 @position=11, @suit="H", @value="Q">,
+    #<Card:0x000000012ae2c400 @position=12, @suit="D", @value="3">,
+    #<Card:0x000000012ae2b960 @position=13, @suit="S", @value="Q">,
+    #<Card:0x000000012ae2c810 @position=14, @suit="H", @value="8">,
+    #<Card:0x000000012ae2cf68 @position=15, @suit="C", @value="6">,
+    #<Card:0x000000012ae2cfe0 @position=16, @suit="C", @value="5">,
+    #<Card:0x000000012ae2c798 @position=17, @suit="H", @value="9">,
+    #<Card:0x000000012ae2b8e8 @position=18, @suit="S", @value="K">,
+    #<Card:0x000000012ae2c478 @position=19, @suit="D", @value="2">,
+    #<Card:0x000000012ae2c6a8 @position=20, @suit="H", @value="J">,
+    #<Card:0x000000012ae2d0d0 @position=21, @suit="C", @value="3">,
+    #<Card:0x000000012ae2ce78 @position=22, @suit="C", @value="8">,
+    #<Card:0x000000012ae2c900 @position=23, @suit="H", @value="6">,
+    #<Card:0x000000012ae2ba50 @position=24, @suit="S", @value="10">,
+    #<Card:0x000000012ae2c310 @position=25, @suit="D", @value="5">,
+    #<Card:0x000000012ae2bf50 @position=26, @suit="D", @value="K">,
+    #<Card:0x000000012ae2be10 @position=27, @suit="S", @value="2">,
+    #<Card:0x000000012ae2ca68 @position=28, @suit="H", @value="3">,
+    #<Card:0x000000012ae2c1a8 @position=29, @suit="D", @value="8">,
+    #<Card:0x000000012ae2bca8 @position=30, @suit="S", @value="5">,
+    #<Card:0x000000012ae2cc20 @position=31, @suit="C", @value="K">,
+    #<Card:0x000000012ae2c040 @position=32, @suit="D", @value="J">,
+    #<Card:0x000000012ae2bb40 @position=33, @suit="S", @value="8">,
+    #<Card:0x000000012ae2cd88 @position=34, @suit="C", @value="10">,
+    #<Card:0x000000012ae2c5b8 @position=35, @suit="H", @value="K">,
+    #<Card:0x000000012ae2b9d8 @position=36, @suit="S", @value="J">,
+    #<Card:0x000000012ae2cef0 @position=37, @suit="C", @value="7">,
+    #<Card:0x000000012ae2c720 @position=38, @suit="H", @value="10">,
+    #<Card:0x000000012ae2c4f0 @position=39, @suit="D", @value="A">,
+    #<Card:0x000000012ae2d058 @position=40, @suit="C", @value="4">,
+    #<Card:0x000000012ae2c888 @position=41, @suit="H", @value="7">,
+    #<Card:0x000000012ae2c388 @position=42, @suit="D", @value="4">,
+    #<Card:0x000000012ae2be88 @position=43, @suit="S", @value="A">,
+    #<Card:0x000000012ae2bac8 @position=44, @suit="S", @value="9">,
+    #<Card:0x000000012ae2cd10 @position=45, @suit="C", @value="J">,
+    #<Card:0x000000012ae2bfc8 @position=46, @suit="D", @value="Q">,
+    #<Card:0x000000012ae2bbb8 @position=47, @suit="S", @value="7">,
+    #<Card:0x000000012ae2cc98 @position=48, @suit="C", @value="Q">,
+    #<Card:0x000000012ae2c0b8 @position=49, @suit="D", @value="10">,
+    #<Card:0x000000012ae2bc30 @position=50, @suit="S", @value="6">,
+    #<Card:0x000000012ae2cb58 @position=51, @suit="H", @value="A">,
+    #<Card:0x000000012ae2c130 @position=52, @suit="D", @value="9">]>
 ```
 
 </details>
@@ -68,6 +124,9 @@ gem install deck_of_cards_handler
   deck.shuffle
 
   hands = deck.deal_into_piles(number_of_piles: 5, number_of_cards: 5)
+
+  hands.map(&:to_s)
+  # => [["5 of D", "8 of C", "6 of S", "10 of D", "5 of C"], ["7 of C", "5 of S", "4 of C", "2 of D", "Q of D"], ["3 of S", "8 of D", "A of D", "2 of C", "7 of D"], ["Q of H", "4 of S", "3 of D", "J of S", "9 of S"], ["6 of C", "6 of H", "10 of C", "4 of D", "A of H"]]
 ```
 
 </details>

data/lib/deck_of_cards_handler/card/card.rb

@@ -50,28 +50,20 @@ class Card
     other.suit == suit && other.value == value
   end
 
-  sig { returns(T::Array[Integer]) }
-  def rank
+  sig { params(low_ace: T::Boolean).returns(Integer) }
+  def rank(low_ace: false)
     case value
-    when "A" then [1, 14]
-    when "J" then [11]
-    when "Q" then [12]
-    when "K" then [13]
-    else [value.to_i]
+    when "A" then low_ace ? 1 : 14
+    when "J" then 11
+    when "Q" then 12
+    when "K" then 13
+    else value.to_i
     end
   end
 
   sig { params(other: Card).returns(Integer) }
   def <=>(other)
-    # compare by all possible ranks (Ace flexible)
-    my_ranks = rank
-    other_ranks = other.rank
-
-    # check if any ranks overlap (Ace == 1 or 14)
-    return 0 if (my_ranks & other_ranks).any?
-
-    # otherwise compare by highest possible
-    T.must(my_ranks.max) <=> T.must(other_ranks.max)
+    rank <=> other.rank
   end
 
   class << self

data/lib/deck_of_cards_handler/packet/packet.rb

@@ -52,9 +52,9 @@ class Packet
       packet
     end
 
-    sig { params(string: String).returns(Packet) }
+    sig { overridable.params(string: String).returns(Packet) }
     def build_from_string(string:) # rubocop:disable Metrics
-      content = string.split(",")
+      content = string.split(",").map(&:strip)
       cards = []
       cards_set = Set.new
 
@@ -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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+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.4"
+  VERSION = "0.1.6"
 end

data/lib/deck_of_cards_handler.rb

@@ -4,3 +4,4 @@ require "sorbet-runtime"
 require_relative "deck_of_cards_handler/version"
 require_relative "deck_of_cards_handler/card"
 require_relative "deck_of_cards_handler/packet"
+require_relative "deck_of_cards_handler/poker_hand"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deck_of_cards_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Simon Bernard
@@ -75,6 +75,17 @@ files:
 - lib/deck_of_cards_handler/packet/deals.rb
 - 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