holdem 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0754af8abb3299e3d216afe08268d3a598d36b7f
+  data.tar.gz: 94286f69b8e84cf14d20c5592cef849621d3ddf0
+SHA512:
+  metadata.gz: b32781200a316d37424ea3723c49ef28fdaf2dc0f13db71a64e213008ab7bb064c08edb21cd59bf3d0b4d6215dd0a108400c98dd7f4bbfb35f93bebdaa1265c7
+  data.tar.gz: aec81c6ca0f148bc738482434c1dc1b8ad2f135beeaba5b3095093ec164c21fe5d5c18a0ea7f219eeaeccc9e8354059d86343a7ff6ac23e0c52468d6d3218f60

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in holdem.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jamie
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# Holdem
+
+A ruby module for creating and comparing Texas Holdem poker hands.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'holdem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install holdem
+
+## Example
+
+    require 'holdem'
+
+    deck = Deck.new
+    deck.shuffle!
+
+    hand1 = PokerHand.new(deck.deal(7))
+    hand2 = PokerHand.new(deck.deal(7))
+    hand3 = PokerHand.new("4c Kc 4h 5d 6s Kd Qs")
+
+    puts hand1                     # => 5♦ K♣ T♠ J♥ 8♥ 8♠ 2♥ -> Pair of 8s
+    puts hand2                     # => Q♦ 6♦ 2♦ 6♣ 5♥ 6♠ T♦ -> Three of a Kind (trip 6s)
+    puts hand3                     # => 4♣ K♣ 4♥ 5♦ 6♠ K♦ Q♠ -> Two Pairs (Ks and 4s)
+
+    puts hand1 > hand2             # => false
+    puts hand2 < hand3             # => false
+    puts [hand1, hand2, hand3].max # => Q♦ 6♦ 2♦ 6♣ 5♥ 6♠ T♦ -> Three of a Kind (trip 6s)
+
+
+## Usage
+
+Cards can be passed to the PokerHand constructor as a string of card representations
+or as an array of card objects.  
+
+Face cards (ten, jack, queen, king, and ace) are represented by (T, J, Q, K, A).
+
+Suits (club, diamond, spade, heart) are represented by (c, d, s, h).
+    
+    puts PokerHand.new('Ac 7d 4c Td Qc Qh Ks')     # => A♣ 7♦ 4♣ T♦ Q♣ Q♥ K♠ -> Pair of Qs
+
+    card1, card2 = Card.new('Ad'), Card.new('Ah')     
+    puts PokerHand.new([card1, card2])             # => A♦ A♥ -> Pair of As
+
+There is also a Deck class to facilitate random poker hands:
+    
+    deck  = Deck.new.shuffle!
+    cards = deck.deal(7)
+    hand  = PokerHand.new(cards)
+    puts hand    # => K♦ 5♣ 4♣ 8♣ J♠ 3♣ 7♦ -> K high
+
+A number of ranks can be asked about a hand:
+
+    hand.straight_flush?
+    hand.quads?           # or hand.four_of_a_kind?
+    hand.boat?            # or hand.full_house?
+    hand.flush?
+    hand.straight?
+    hand.trips?           # or hand.three_of_a_kind? 
+    hand.two_pairs?
+    hand.pair?
+
+## TODO
+
+Build Simulations, players, table, chips, and game objects.
+
+Add methods to PokerRank for:
+
+    hand.open_ended?
+    hand.four_to_flush?
+    hand.gutshot?
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/holdem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task default: :test

data/holdem.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'holdem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "holdem"
+  spec.version       = Holdem::VERSION
+  spec.authors       = ["Jamie Berczel"]
+  spec.email         = ["jxberc@gmail.com"]
+  spec.summary       = %q{A ruby module for creating and comparing Texas Holdem poker hands.}
+  spec.description   = %q{A ruby module for creating and comparing Texas Holdem poker hands.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'minitest', '~> 5.4.3'
+end

data/lib/holdem/card.rb

@@ -0,0 +1,35 @@
+class Card
+  include Comparable
+  attr_reader :rank, :suit, :icon
+
+  RANKS       = %w(2 3 4 5 6 7 8 9 T J Q K A)
+  SUITS       = %w(c s d h)
+  ICONS       = { 'c' => '♣', 's' => '♠', 'd' => '♦', 'h' => '♥' }
+  FACE_CARDS  = { 'T' => 10, 'J' => 11, 'Q' => 12, 'K' => 13, 'A' => 14 }
+
+  def initialize(card)
+    @rank, @suit = card.split(//)
+    @icon        = ICONS[suit]
+    validate(card)
+  end
+
+  def value
+    rank[/\d/] ? rank.to_i : FACE_CARDS[rank]
+  end
+
+  def to_s
+    "#{rank}#{icon}"
+  end
+
+  def <=>(other)
+    value <=> other.value
+  end
+
+  private
+
+  def validate(card)
+    unless RANKS.include?(rank) && SUITS.include?(suit)
+      fail ArgumentError
+    end
+  end
+end

data/lib/holdem/card_generator.rb

@@ -0,0 +1,11 @@
+class CardGenerator
+  def self.build(cards)
+    new(cards).cards
+  end
+
+  attr_reader :cards
+  
+  def initialize(cards)
+    @cards = cards.each.map { |c| Card.new(c) }
+  end
+end

data/lib/holdem/deck.rb

@@ -0,0 +1,16 @@
+class Deck < Array
+  def initialize
+    build_deck
+  end
+
+  # add test for #deal
+  alias_method :deal, :pop
+
+  private
+
+  def build_deck
+    Card::RANKS.each do |rank|
+      Card::SUITS.each { |suit| self << Card.new(rank + suit) }
+    end
+  end
+end

data/lib/holdem/poker_hand.rb

@@ -0,0 +1,33 @@
+class PokerHand
+  include Comparable
+  extend Forwardable
+
+  def_delegators :@poker_rank, :rank, :score
+  rank_methods = [ :straight_flush?, :quads?, :four_of_a_kind?, :boat?,
+                   :full_house?, :flush?, :straight?, :three_of_a_kind?,
+                   :trips?, :two_pairs?, :two_pair?, :pair? ]
+  def_delegators :@poker_rank, *rank_methods
+
+  attr_reader :cards, :poker_rank
+
+  def initialize(cards)
+    @cards = cards.is_a?(String) ? CardGenerator.build(cards.split) : cards
+    @poker_rank = PokerRank.new(@cards)
+  end
+
+  def count
+    cards.size
+  end
+
+  def <=>(other)
+    score <=> other.score
+  end
+
+  def just_cards
+    "#{cards.map{ |card| card.to_s }.join(' ')}"
+  end
+
+  def to_s
+    "#{just_cards} -> #{rank}"
+  end
+end

data/lib/holdem/poker_rank.rb

@@ -0,0 +1,191 @@
+class PokerRank
+  attr_reader :cards, :score, :rank
+
+  def initialize(cards)
+    @cards = cards
+    @score, @rank = build_ranking
+  end
+
+  def build_ranking
+    # return ["Straight flush", straight_flush_score]  if straight_flush?
+    # return ["Four of a kind", four_kind_score]       if four_of_a_kind?
+    # return ["Full House", full_house_score]          if full_house?
+    # return ["Flush", flush_score]                    if flush?
+    # return ["Straight", straight_score]              if straight?
+    # return ["Three of a Kind", three_kind_score]     if three_of_a_kind?
+    # return ["Two Pairs", two_pairs_score]            if two_pairs?
+    # return ["One Pair", pair_score]                  if pair?
+    # 
+    case 
+      when straight_flush?   then build_straight_flush
+      when four_of_a_kind?   then build_four_kind
+      when full_house?       then build_full_house
+      when flush?            then build_flush
+      when straight?         then build_straight
+      when three_of_a_kind?  then build_three_kind
+      when two_pairs?        then build_two_pairs
+      when pair?             then build_pair
+      else
+        build_high_card
+    end
+  end
+
+# POKER HAND RANKINGS
+# These methods determine type of poker hand. Hands are sorted by pair, then by
+# values in descending order using the #pairs method.  The hand ranking methods
+# below filter the pairs array to determine type of hand.
+
+  #need to fix
+  def straight_flush?
+    straight? && flush?              
+  end
+
+  def four_of_a_kind?
+    kinds?(4)
+  end
+
+  def full_house?
+    three_of_a_kind? && pair?
+  end
+
+  def flush?
+    suits.any? { |_,count| count >= 5 }
+  end
+
+  def straight?
+    card_values = sorted_values
+    # check for low ace straight
+    card_values.push(1) if card_values.include?(14)
+    card_values.each_cons(5) do |vals|
+      return true if five_card_straight?(vals)
+    end
+    false
+  end
+
+  def five_card_straight?(list)
+    (list.first - list.last).abs == 4 && list.uniq.length == 5
+  end
+
+  def three_of_a_kind?
+    kinds?(3)
+  end
+
+  def two_pairs?
+    num_of_pairs = pairs.select { |count,_cards| count == 2 }.size
+    num_of_pairs > 1
+  end
+
+  def pair?
+    kinds?(2)
+  end
+
+  def kinds?(size)
+    pairs.any? { |count,_cards| count == size }
+  end
+
+  alias_method :quads?, :four_of_a_kind?
+  alias_method :trips?, :three_of_a_kind?
+  alias_method :boat?, :full_house?
+  alias_method :two_pair?, :two_pairs?
+
+
+# BUILD HAND RANKINGS
+# Score are first ranked by type of hand [0-9].  If equal, then compared by pairs, 
+# high cards, and/or remaining cards.  Also includes description of hand.
+
+  def build_high_card
+    [ [0] + sorted_values, "#{high_card.rank} high" ]
+  end
+
+  def build_pair
+    [ [1] + pair_card_values, "Pair of #{pair_card.rank}s" ]
+  end
+
+  def build_two_pairs
+    [ [2] + pair_card_values,
+      "Two Pairs (#{pair_card(1).rank}s and #{pair_card(2).rank}s)",
+    ]
+  end
+
+  def build_three_kind
+    [ [3] + pair_card_values, "Three of a Kind (trip #{pair_card.rank}s)" ]
+  end
+
+  def build_straight
+    [ [4, highest_straight_card], "Straight" ]
+  end
+
+  def build_flush
+    [ [5, highest_flush_card], "Flush" ]
+  end
+
+  def build_full_house
+    [ [6] + pair_card_values, 
+      "Full House (#{pair_card(1).rank}s over #{pair_card(2).rank}s)",    
+    ]
+  end
+
+  def build_four_kind
+    [ [7] + pair_card_values, 
+      "Four of a kind (quad #{pair_card(1).rank}s)",
+    ]
+  end
+
+  def build_straight_flush
+    [ [8, highest_straight_card], "Straight Flush" ]
+  end
+
+  # HELPER METHODS
+
+  def pair_card_values
+    pairs.map { |_count, cards| cards.first.value }
+  end
+
+  def high_card
+    sorted_cards.first
+  end
+
+  def highest_straight_card
+    sorted_values.each_cons(5) do |vals|
+      return vals.first if five_card_straight?(vals)
+    end
+  end
+
+  def highest_flush_card
+    cards.select { |card| card.suit == flush_suit }.max.value
+  end
+
+  def flush_suit
+    suit, count = suits.first
+    return suit if count >= 5 
+  end
+
+  def pair_card(num=1)
+    pairs.take(num).map { |_count, cards| cards.last }.last
+  end
+
+  #private
+
+  def sorted_cards
+    @sorted_cards ||= cards.sort_by { |card| card.value * -1 }
+  end
+
+  def pairs
+    @pairs ||= cards.group_by { |card| card.value }
+                    .map { |_val,cards| [cards.count, cards] }
+                    .sort_by { |count,cards| [count*-1, cards.first.value*-1] }
+  end
+
+  def suits
+    @suits ||= cards.group_by { |card| card.suit }
+                    .map { |k,v| [k, v.count] }
+                    .sort_by { |k,count| [count*-1] }
+  end
+
+  def sorted_values
+    @sorted_values ||= sorted_cards.map(&:value)
+  end
+end
+
+
+

data/lib/holdem/version.rb

@@ -0,0 +1,3 @@
+module Holdem
+  VERSION = "1.0.0"
+end

data/lib/holdem.rb

@@ -0,0 +1,9 @@
+require "holdem/version"
+require 'holdem/card'
+require 'holdem/card_generator'
+require 'holdem/deck'
+require 'holdem/poker_hand'
+require 'holdem/poker_rank'
+
+module Holdem
+end

data/test/card_test.rb

@@ -0,0 +1,34 @@
+require 'minitest/autorun'
+require 'holdem'
+
+class CardTest < Minitest::Test
+  def setup
+    @card1 = Card.new('Kd')
+    @card2 = Card.new('Th')
+    @card3 = Card.new('4s')
+    @card4 = Card.new('7c')
+  end
+
+  def test_card_rank
+    assert_equal 'K', @card1.rank
+    assert_equal 'T', @card2.rank
+    assert_equal '4', @card3.rank
+  end
+
+  def test_card_suit
+    assert_equal 'd', @card1.suit
+    assert_equal 'h', @card2.suit
+    assert_equal 's', @card3.suit
+    assert_equal 'c', @card4.suit
+  end
+
+   def test_has_icons
+    assert_equal '♦', @card1.icon
+    assert_equal '♥', @card2.icon
+  end
+
+  def test_invalid_cards
+    assert_raises(ArgumentError) { Card.new('9k') }
+    assert_raises(ArgumentError) { Card.new('d2') }
+  end
+end

data/test/deck_test.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require 'holdem'
+
+class DeckTest < Minitest::Test
+
+  def setup
+    @deck = Deck.new
+  end
+
+  def test_deck_has_52_cards
+    assert_equal 52, @deck.count
+  end
+
+  def test_deck_next_card
+    card = @deck.dup.pop
+    assert_equal card, @deck.pop
+    assert_equal 51, @deck.size
+  end
+
+  def test_shuffle
+    unshuffled = @deck.dup
+    shuffled = @deck.shuffle
+    refute_equal unshuffled, shuffled
+  end
+end

data/test/poker_hand_test.rb

@@ -0,0 +1,58 @@
+require 'minitest/autorun'
+require 'holdem'
+
+class PokerHandTest < Minitest::Test
+  def setup
+    hand1      = CardGenerator.build(%w(4c 4h 5s Qs Jc 9c Tc))
+    hand2      = CardGenerator.build(%w(7c 4h 7s Qs Kc Qc Tc))
+    hand3      = CardGenerator.build(%w(Ac 2c 3h 4h 5s 6c Qd))
+    hand4      = CardGenerator.build(%w(Ac 9c 9h 9h 5s 6c Qd)) 
+    @pair       = PokerHand.new(hand1)
+    @two_pairs  = PokerHand.new(hand2)
+    @three_kind = PokerHand.new(hand4)
+    @straight   = PokerHand.new(hand3)
+  end
+
+  def test_poker_ranking_dependency
+    assert_equal @pair.poker_rank.class, PokerRank
+  end
+
+  def test_initialize_with_string_representation
+    assert_equal 7, PokerHand.new("Ac Ad Kd 5s 5h 4c 5c").count
+  end
+
+  def test_rank
+    assert_equal "Straight", @straight.rank
+  end
+
+  def test_score
+    assert_equal [2, 12, 7, 13, 10, 4], @two_pairs.score
+  end
+
+  def test_comparisons
+    assert @pair < @two_pairs
+    assert @pair < @straight
+    assert @three_kind > @two_pairs
+  end
+
+  def test_three_kind_less_than_straight
+    assert @three_kind < @straight
+  end
+
+  def test_comparison_with_kicker
+    other_cards = CardGenerator.build(%w(Ac 4c 4h 9h 6c Jh Qd)) 
+    other_pair  = PokerHand.new(other_cards)
+    assert_equal [1, 4, 14, 12, 11, 9, 6], other_pair.score
+    assert_equal [1, 4, 12, 11, 10, 9, 5], @pair.score
+    assert  other_pair > @pair
+  end
+
+  def test_delegated_methods
+    refute @pair.quads?
+    refute @pair.straight_flush?
+    refute @pair.trips?
+    assert @pair.pair?
+    assert @two_pairs.two_pairs?
+    assert @straight.straight?
+  end
+end

data/test/poker_rank_test.rb

@@ -0,0 +1,93 @@
+require 'minitest/autorun'
+require 'holdem'
+
+class PokerRankingTest < Minitest::Test
+
+  def test_pair
+    cards = CardGenerator.build(%w(Kd 8s 5s Kh Kc 5c Kc))
+    hand = PokerRank.new(cards)
+    assert hand.pair?
+    hand = PokerRank.new(cards.first(3))
+    refute hand.pair?
+  end
+
+  def test_two_pair
+    cards = CardGenerator.build(%w(7d 8s 5s 7h Kc 5c Kc))
+    hand = PokerRank.new(cards)
+    assert hand.two_pairs?
+  end
+
+  def test_three_of_a_kind
+    cards = CardGenerator.build(%w(Kh Kc 5c Kc))
+    hand = PokerRank.new(cards)
+    assert hand.three_of_a_kind?
+    refute hand.pair?
+  end
+
+  def test_four_of_a_kind
+    cards = CardGenerator.build(%w(Ah Ac 5c 4c As Ad))
+    hand = PokerRank.new(cards)
+    assert_equal true, hand.four_of_a_kind?
+  end
+
+  def test_flush?
+    cards = CardGenerator.build(%w(6c Tc 2c 4c As Ac Qh))
+    hand = PokerRank.new(cards)
+    assert hand.flush?
+  end
+
+  def test_not_a_flush?
+    cards = CardGenerator.build(%w(6c Ts 2d 4c As Ac Qh))
+    hand = PokerRank.new(cards)
+    refute hand.flush?
+  end
+
+  def test_for_straight?
+    cards = CardGenerator.build(%w(Td Kd Js Qd Kh Ad 9c 8c))
+    hand = PokerRank.new(cards)
+    assert_equal true, hand.straight?
+    hand = PokerRank.new(cards.drop(1))
+    refute hand.straight?
+  end
+
+  def test_low_ace_straight?
+    cards = CardGenerator.build(%w(2d 3s Ad 5h 4d Td 9c 8c))
+    hand = PokerRank.new(cards)
+    assert_equal true, hand.straight?
+  end
+
+   def test_full_house?
+    cards = CardGenerator.build(%w(Jd 8s Jh 5h 8d Jd Tc))
+    hand = PokerRank.new(cards)
+    assert_equal true, hand.full_house?
+  end
+
+   def test_straight_flush?
+    skip
+    cards1 = CardGenerator.build(%w(Jd Qd Ad Kd Td 7d Tc))
+    hand1  = PokerRank.new(cards1)
+    cards2 = CardGenerator.build(%w(2d 3h 4h 5h 6h 7d 8h))
+    hand2  = PokerRank.new(cards2)
+    assert hand1.straight_flush?
+    refute hand2.straight_flush?
+  end
+
+  def test_alias_method_trips?
+    cards = CardGenerator.build(%w(Jd Qd Jd Jd Td 7d Tc))
+    hand  = PokerRank.new(cards)
+    assert hand.trips?
+  end
+
+  def test_alias_method_quads?
+    cards = CardGenerator.build(%w(Jd Jd Jd Jd Td 7d Tc))
+    hand  = PokerRank.new(cards)
+    assert hand.quads?
+  end
+
+  def test_alias_method_boat?
+    cards = CardGenerator.build(%w(Jd Jd Jd Td Td 7d 6c))
+    hand  = PokerRank.new(cards)
+    assert hand.boat?
+  end
+
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: holdem
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamie Berczel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+description: A ruby module for creating and comparing Texas Holdem poker hands.
+email:
+- jxberc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- holdem.gemspec
+- lib/holdem.rb
+- lib/holdem/card.rb
+- lib/holdem/card_generator.rb
+- lib/holdem/deck.rb
+- lib/holdem/poker_hand.rb
+- lib/holdem/poker_rank.rb
+- lib/holdem/version.rb
+- test/card_test.rb
+- test/deck_test.rb
+- test/poker_hand_test.rb
+- test/poker_rank_test.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: A ruby module for creating and comparing Texas Holdem poker hands.
+test_files:
+- test/card_test.rb
+- test/deck_test.rb
+- test/poker_hand_test.rb
+- test/poker_rank_test.rb