acpc_poker_types 0.0.10 → 1.0.0

data/lib/acpc_poker_types/board_cards.rb

@@ -1,10 +1,10 @@
 
 require 'dmorrill10-utils/class'
 
-require File.expand_path('../pile_of_cards', __FILE__)
+require 'acpc_poker_types/pile_of_cards'
 
 # List of community board cards.
-class BoardCards < PileOfCards
+class AcpcPokerTypes::BoardCards < AcpcPokerTypes::PileOfCards
 
   exceptions :too_many_board_cards
 
@@ -14,7 +14,7 @@ class BoardCards < PileOfCards
 
   def next_round!
     @round = if @round then @round + 1 else 0 end
-    self[@round] = PileOfCards.new
+    self[@round] = AcpcPokerTypes::PileOfCards.new
     self
   end
 
@@ -42,7 +42,7 @@ class BoardCards < PileOfCards
     if all? { |pile_for_round| pile_for_round.empty? }
       ''
     else
-      '/' + (map do |pile_for_round| 
+      '/' + (map do |pile_for_round|
         (pile_for_round.map { |card| card.to_acpc }).join
       end).join('/')
     end

data/lib/acpc_poker_types/card.rb

@@ -4,59 +4,59 @@ require 'dmorrill10-utils'
 require File.expand_path('../rank', __FILE__)
 require File.expand_path('../suit', __FILE__)
 
-class Card
-  exceptions :unable_to_parse_acpc_card
+class AcpcPokerTypes::Card
+  exceptions :parse_error
 
   # @param [String] acpc_string_of_cards A string of cards in ACPC format
-  # @return [Array<Card>]
+  # @return [Array<AcpcPokerTypes::Card>]
   def self.cards(acpc_string_of_cards)
-    all_ranks = Rank::DOMAIN.map do |rank, rank_properties|
+    all_ranks = AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
      rank_properties[:acpc_character]
     end.join
-    all_suits = Suit::DOMAIN.map do |suit, suit_properties| 
+    all_suits = AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
       suit_properties[:acpc_character]
     end.join
 
     acpc_string_of_cards.scan(/[#{all_ranks}][#{all_suits}]/).inject([]) do |pile, acpc_card|
-      pile.push << Card.from_acpc(acpc_card)
+      pile.push << AcpcPokerTypes::Card.from_acpc(acpc_card)
     end
   end
 
   # @return [Integer] The numeric ACPC representation of the card.
   def self.acpc_card_number(rank, suit)
-    rank.to_i * Suit::DOMAIN.length + suit.to_i
+    rank.to_i * AcpcPokerTypes::Suit::DOMAIN.length + suit.to_i
   end
 
   attr_reader :rank, :suit
 
-  # @return Card
+  # @return AcpcPokerTypes::Card
   def self.from_acpc(acpc_card)
-    all_ranks = Rank::DOMAIN.values.map do |card_rank|
+    all_ranks = AcpcPokerTypes::Rank::DOMAIN.values.map do |card_rank|
       card_rank[:acpc_character]
     end.join
-    all_suits = Suit::DOMAIN.values.map do |card_suit| 
-      card_suit[:acpc_character] 
+    all_suits = AcpcPokerTypes::Suit::DOMAIN.values.map do |card_suit|
+      card_suit[:acpc_character]
     end.join
 
     if acpc_card.match(/([#{all_ranks}])([#{all_suits}])/)
       rank = $1
       suit = $2
 
-      Card.from_components rank, suit
+      AcpcPokerTypes::Card.from_components rank, suit
     else
-      raise UnableToParseAcpcCard, acpc_card
+      raise ParseError, acpc_card
     end
   end
 
   alias_new :from_components
 
   def initialize(rank, suit)
-    @rank = Rank.new rank
-    @suit = Suit.new suit
+    @rank = AcpcPokerTypes::Rank.new rank
+    @suit = AcpcPokerTypes::Suit.new suit
   end
 
   def to_i
-    Card.acpc_card_number(@rank, @suit)
+    AcpcPokerTypes::Card.acpc_card_number(@rank, @suit)
   end
 
   def to_str

data/lib/acpc_poker_types/chip_stack.rb

@@ -3,7 +3,7 @@ require 'dmorrill10-utils/class'
 
 require 'delegate'
 
-class ChipStack < DelegateClass(Rational)
+class AcpcPokerTypes::ChipStack < DelegateClass(Rational)
   exceptions :illegal_number_of_chips
 
   # @param [#to_i] number_of_chips The number of chips to be made into a stack.

data/lib/acpc_poker_types/game_definition.rb

@@ -3,13 +3,13 @@ require 'dmorrill10-utils/enumerable'
 require 'dmorrill10-utils/integer'
 require 'set'
 
-require File.expand_path('../chip_stack', __FILE__)
-require File.expand_path('../suit', __FILE__)
-require File.expand_path('../rank', __FILE__)
+require 'acpc_poker_types/chip_stack'
+require 'acpc_poker_types/suit'
+require 'acpc_poker_types/rank'
 
 # Class that parses and manages game definition information from a game definition file.
-class GameDefinition
-  exceptions :game_definition_parse_error
+class AcpcPokerTypes::GameDefinition
+  exceptions :parse_error
 
   # @return [String] The string designating the betting type.
   attr_reader :betting_type
@@ -72,8 +72,8 @@ class GameDefinition
   }
 
   MAX_VALUES = {
-    :@number_of_suits => Suit::DOMAIN.length,
-    :@number_of_ranks => Rank::DOMAIN.length
+    :@number_of_suits => AcpcPokerTypes::Suit::DOMAIN.length,
+    :@number_of_ranks => AcpcPokerTypes::Rank::DOMAIN.length
   }
 
   # @return [Hash] Betting types understood by this class.
@@ -110,10 +110,10 @@ class GameDefinition
   end
 
   # @param [Integer] number_of_players The number of players that require stacks.
-  # @return [Array<ChipStack>] The default list of initial stacks for every player.
+  # @return [Array<AcpcPokerTypes::ChipStack>] The default list of initial stacks for every player.
   def self.default_chip_stacks(number_of_players)
     number_of_players.to_i.times.inject([]) do |list, i|
-      list << ChipStack.new(DEFAULT_CHIP_STACK)
+      list << AcpcPokerTypes::ChipStack.new(DEFAULT_CHIP_STACK)
     end
   end
 
@@ -145,7 +145,7 @@ class GameDefinition
       (0..values.length-1).each do |i|
         values[i] = values[i].to_i
       end
-      GameDefinition.flatten_if_single_element_array values
+      flatten_if_single_element_array values
     end
   end
 
@@ -156,27 +156,21 @@ class GameDefinition
   # @return [String] line The line to check.
   # @return [Boolean] +true+ if the line is not informative, +false+ otherwise.
   def self.game_def_line_not_informative?(line)
-    GameDefinition.line_is_comment_or_empty?(line) || line.match(/\s*gamedef\s*/i)
+    line_is_comment_or_empty?(line) || line.match(/\s*gamedef\s*/i)
   end
 
   # @param [String] game_definition_file_name The name of the game definition file that this instance should parse.
-  # @raise (see #initialize)
   def self.parse_file(game_definition_file_name)
-    File.open(game_definition_file_name, 'r') { |file|  GameDefinition.parse file }
+    File.open(game_definition_file_name, 'r') { |file|  parse file }
   end
 
   alias_new :parse
 
-  # @raise GameDefinitionParseError
   def initialize(definitions)
     initialize_members!
-    begin
-      parse_definitions! definitions
-    rescue => unable_to_read_or_open_file_error
-      raise GameDefinitionParseError, unable_to_read_or_open_file_error.message
-    end
+    parse_definitions! definitions
 
-    @chip_stacks = GameDefinition.default_chip_stacks(@number_of_players) if @chip_stacks.empty?
+    @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks(@number_of_players) if @chip_stacks.empty?
 
     unless @first_player_positions.any? { |pos| pos <= 0 }
       @first_player_positions.map! { |position| position - 1 }
@@ -228,9 +222,9 @@ class GameDefinition
     @blinds = @number_of_players.times.inject([]) { |blinds, i| blinds << 0 }
     @number_of_rounds = MIN_VALUES[:@number_of_rounds]
     @number_of_board_cards = @number_of_rounds.times.inject([]) { |cards, i| cards << 0 }
-    @first_player_positions = GameDefinition.default_first_player_positions @number_of_rounds
-    @max_number_of_wagers = GameDefinition.default_max_number_of_wagers @number_of_rounds
-    @chip_stacks = GameDefinition.default_chip_stacks @number_of_players
+    @first_player_positions = AcpcPokerTypes::GameDefinition.default_first_player_positions @number_of_rounds
+    @max_number_of_wagers = AcpcPokerTypes::GameDefinition.default_max_number_of_wagers @number_of_rounds
+    @chip_stacks = AcpcPokerTypes::GameDefinition.default_chip_stacks @number_of_players
     @number_of_suits = MIN_VALUES[:@number_of_suits]
     @number_of_ranks = MIN_VALUES[:@number_of_ranks]
     @number_of_hole_cards = MIN_VALUES[:@number_of_hole_cards]
@@ -239,7 +233,10 @@ class GameDefinition
   end
 
   def set_defintion_if_present!(definition_symbol, line, definition_label_in_line)
-    new_definition = GameDefinition.check_game_def_line_for_definition line, definition_label_in_line
+    new_definition = AcpcPokerTypes::GameDefinition.check_game_def_line_for_definition(
+      line,
+      definition_label_in_line
+    )
     if new_definition
       instance_variable_set(definition_symbol, new_definition)
       true
@@ -251,9 +248,8 @@ class GameDefinition
   def parse_definitions!(definitions)
     definitions.each do |line|
       break if line.match(/\bend\s*gamedef\b/i)
-
       next if (
-        GameDefinition.game_def_line_not_informative?(line) ||
+        AcpcPokerTypes::GameDefinition.game_def_line_not_informative?(line) ||
         BETTING_TYPES.any? do |type_and_name|
           type = type_and_name.first
           name = type_and_name[1]
@@ -273,21 +269,21 @@ class GameDefinition
     self
   end
 
-  # @raise GameDefinitionParseError
+  # @raise ParseError
   def sanity_check_game_definitions!
     adjust_definitions_if_necessary!
 
-    raise GameDefinitionParseError, "list of player stacks not specified" unless @chip_stacks
-    raise GameDefinitionParseError, "list of blinds not specified" unless @blinds
-    raise GameDefinitionParseError, "raise size in each round not specified" unless min_wagers
-    raise GameDefinitionParseError, "first player position in each round not specified" unless @first_player_positions
-    raise GameDefinitionParseError, "maximum raise in each round not specified" unless @max_number_of_wagers
-    raise GameDefinitionParseError, "number of board cards in each round not specified" unless @number_of_board_cards
+    raise ParseError, "list of player stacks not specified" unless @chip_stacks
+    raise ParseError, "list of blinds not specified" unless @blinds
+    raise ParseError, "raise size in each round not specified" unless min_wagers
+    raise ParseError, "first player position in each round not specified" unless @first_player_positions
+    raise ParseError, "maximum raise in each round not specified" unless @max_number_of_wagers
+    raise ParseError, "number of board cards in each round not specified" unless @number_of_board_cards
 
     MIN_VALUES.each do |symbol, min_value|
       if instance_variable_get(symbol) < min_value
         raise(
-          GameDefinitionParseError,
+          ParseError,
           "Invalid definition, #{DEFINITION[symbol]} must be greater than #{min_value} but was set to #{instance_variable_get(symbol)}"
         )
       end
@@ -296,7 +292,7 @@ class GameDefinition
     (0..@number_of_players-1).each do |i|
       if @blinds[i] > @chip_stacks[i]
         raise(
-          GameDefinitionParseError,
+          ParseError,
           "Blind for player #{i+1} (#{@blinds[i]}) is greater than stack size (#{@chip_stacks[i]})"
         )
       end
@@ -305,7 +301,7 @@ class GameDefinition
     @number_of_rounds.times do |i|
       unless @first_player_positions[i].seat_in_bounds? @number_of_players
         raise(
-          GameDefinitionParseError,
+          ParseError,
           "Invalid first player #{@first_player_positions[i]} on round #{i+1}"
         )
       end
@@ -314,7 +310,7 @@ class GameDefinition
     MAX_VALUES.each do |symbol, max_value|
       if instance_variable_get(symbol) > max_value
         raise(
-          GameDefinitionParseError,
+          ParseError,
           "Invalid definition, #{DEFINITIONS[symbol]} must be less than #{max_value} but was set to #{instance_variable_get(symbol)}"
         )
       end
@@ -324,7 +320,7 @@ class GameDefinition
 
     if number_of_cards_required > (@number_of_suits * @number_of_ranks)
       raise(
-        GameDefinitionParseError,
+        ParseError,
         "Too many hole and board cards (#{number_of_cards_required}) for specified deck (#{(@number_of_suits * @number_of_ranks)})"
       )
     end

data/lib/acpc_poker_types/hand.rb

@@ -1,17 +1,17 @@
 
-require File.expand_path('../pile_of_cards', __FILE__)
-require File.expand_path('../card', __FILE__)
+require 'acpc_poker_types/pile_of_cards'
+require 'acpc_poker_types/card'
 
-class Hand < PileOfCards
+class AcpcPokerTypes::Hand < AcpcPokerTypes::PileOfCards
   # @return [Hand]
   def self.draw_cards(*cards)
-    Hand.new cards
+    AcpcPokerTypes::Hand.new cards
   end
 
   # @param [String] acpc_string_hand ACPC string description of a hand.
   # @return [Hand]
   def self.from_acpc(acpc_string_hand)
-    Hand.new Card.cards(acpc_string_hand)
+    AcpcPokerTypes::Hand.new AcpcPokerTypes::Card.cards(acpc_string_hand)
   end
 
   def to_s

data/lib/acpc_poker_types/match_state.rb

@@ -1,15 +1,14 @@
 
 require 'dmorrill10-utils'
 
-require File.expand_path('../board_cards', __FILE__)
-require File.expand_path('../hand', __FILE__)
-require File.expand_path('../rank', __FILE__)
-require File.expand_path('../suit', __FILE__)
-require File.expand_path('../poker_action', __FILE__)
-
+require 'acpc_poker_types/board_cards'
+require 'acpc_poker_types/hand'
+require 'acpc_poker_types/rank'
+require 'acpc_poker_types/suit'
+require 'acpc_poker_types/poker_action'
 
 # Model to parse and manage information from a given match state string.
-class MatchState
+class AcpcPokerTypes::MatchState
   exceptions :incomplete_match_state
 
   # @return [Integer] The position relative to the dealer of the player that
@@ -24,13 +23,13 @@ class MatchState
   # @return [Integer] The hand number.
   attr_reader :hand_number
 
-  # @return [Array<Array<PokerAction>>] The sequence of betting actions.
+  # @return [Array<Array<AcpcPokerTypes::PokerAction>>] The sequence of betting actions.
   attr_reader :betting_sequence
 
-  # @return [Array<Hand>] The list of visible hole card sets for each player.
+  # @return [Array<AcpcPokerTypes::Hand>] The list of visible hole card sets for each player.
   attr_reader :list_of_hole_card_hands
 
-  # @return [BoardCards] All visible community cards on the board.
+  # @return [AcpcPokerTypes::BoardCards] All visible community cards on the board.
   attr_reader :board_cards
 
   # @return [Array<Integer>] The list of first seats for each round.
@@ -51,9 +50,9 @@ class MatchState
   # @return [String] The constructed match state string.
   def self.build_match_state_string(
     position_relative_to_dealer,
-    hand_number, 
+    hand_number,
     betting_sequence,
-    all_hole_cards, 
+    all_hole_cards,
     board_cards
   )
     string = LABEL +
@@ -74,11 +73,11 @@ class MatchState
   # @param [String] raw_match_state A raw match state string to be parsed.
   # @raise IncompleteMatchState
   def initialize(raw_match_state)
-    raise IncompleteMatchState, raw_match_state if MatchState.line_is_comment_or_empty? raw_match_state
+    raise IncompleteMatchState, raw_match_state if AcpcPokerTypes::MatchState.line_is_comment_or_empty? raw_match_state
 
-    all_actions = PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join
-    all_ranks = (Rank::DOMAIN.map { |rank, properties| properties[:acpc_character] }).join
-    all_suits = (Suit::DOMAIN.map { |suit, properties| properties[:acpc_character] }).join
+    all_actions = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join
+    all_ranks = (AcpcPokerTypes::Rank::DOMAIN.map { |rank, properties| properties[:acpc_character] }).join
+    all_suits = (AcpcPokerTypes::Suit::DOMAIN.map { |suit, properties| properties[:acpc_character] }).join
     all_card_tokens = all_ranks + all_suits
     if raw_match_state.match(
       /#{LABEL}:(\d+):(\d+):([\d#{all_actions}\/]*):([|#{all_card_tokens}]+)\/*([\/#{all_card_tokens}]*)/)
@@ -92,12 +91,12 @@ class MatchState
     raise IncompleteMatchState, raw_match_state if incomplete_match_state?
   end
 
-  # @return [String] The MatchState in raw text form.
+  # @return [String] The AcpcPokerTypes::MatchState in raw text form.
   def to_str
-    MatchState.build_match_state_string(
+    AcpcPokerTypes::MatchState.build_match_state_string(
       @position_relative_to_dealer,
       @hand_number, betting_sequence_string,
-      hole_card_strings, 
+      hole_card_strings,
       @board_cards
     )
   end
@@ -105,7 +104,7 @@ class MatchState
   # @see to_str
   alias_method :to_s, :to_str
 
-  # @param [MatchState] another_match_state A match state string to compare against this one.
+  # @param [AcpcPokerTypes::MatchState] another_match_state A match state string to compare against this one.
   # @return [Boolean] +true+ if this match state string is equivalent to +another_match_state+, +false+ otherwise.
   def ==(another_match_state)
     another_match_state.to_s == to_s
@@ -114,8 +113,8 @@ class MatchState
   # @return [Integer] The number of players in this match.
   def number_of_players() @list_of_hole_card_hands.length end
 
-  # @param [Array<Array<PokerAction>>] betting_sequence The betting sequence from which the last action should be retrieved.
-  # @return [PokerAction] The last action taken.
+  # @param [Array<Array<AcpcPokerTypes::PokerAction>>] betting_sequence The betting sequence from which the last action should be retrieved.
+  # @return [AcpcPokerTypes::PokerAction] The last action taken.
   # @raise NoActionsHaveBeenTaken if no actions have been taken.
   def last_action(betting_sequence=@betting_sequence)
     if betting_sequence.nil? || betting_sequence.empty?
@@ -127,7 +126,7 @@ class MatchState
     end
   end
 
-  # @return [Hand] The user's hole cards.
+  # @return [AcpcPokerTypes::Hand] The user's hole cards.
   # @example An ace of diamonds and a 4 of clubs is represented as
   #     'Ad4c'
   def users_hole_cards
@@ -136,7 +135,7 @@ class MatchState
 
   # @return [Array] The list of opponent hole cards that are visible.
   # @example If there are two opponents, one with AhKs and the other with QdJc, then
-  #     list_of_opponents_hole_cards == [AhKs:Hand, QdJc:Hand]
+  #     list_of_opponents_hole_cards == [AhKs:AcpcPokerTypes::Hand, QdJc:AcpcPokerTypes::Hand]
   def list_of_opponents_hole_cards
     local_list_of_hole_card_hands = @list_of_hole_card_hands.dup
     local_list_of_hole_card_hands.delete_at @position_relative_to_dealer
@@ -209,7 +208,7 @@ class MatchState
   end
 
   def list_of_actions_from_acpc_characters(betting_sequence)
-    all_actions = PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
+    all_actions = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
     betting_sequence.scan(/[#{all_actions}]\d*/)
   end
 
@@ -221,11 +220,11 @@ class MatchState
   def parse_list_of_hole_card_hands(string_of_hole_cards)
     list_of_hole_card_hands = []
     for_every_set_of_cards(string_of_hole_cards, '\|') do |string_hand|
-      hand = Hand.from_acpc string_hand
+      hand = AcpcPokerTypes::Hand.from_acpc string_hand
       list_of_hole_card_hands.push hand
     end
     while list_of_hole_card_hands.length < (string_of_hole_cards.count('|') + 1)
-      list_of_hole_card_hands.push Hand.new
+      list_of_hole_card_hands.push AcpcPokerTypes::Hand.new
     end
     list_of_hole_card_hands
   end
@@ -236,13 +235,13 @@ class MatchState
     list_of_actions_by_round = string_betting_sequence.split(/\//)
     betting_sequence = list_of_actions_by_round.inject([]) do |list_of_actions, betting_string_in_a_particular_round|
       list_of_actions_in_a_particular_round = list_of_actions_from_acpc_characters(betting_string_in_a_particular_round).inject([]) do |list, action|
-        list.push PokerAction.new(action)
+        list.push AcpcPokerTypes::PokerAction.new(action)
       end
       list_of_actions.push list_of_actions_in_a_particular_round
     end
     # Increase the resolution of the last action
-    # @todo I'm creating one too many PokerActions, but I'm not going to worry about it for now.
-    betting_sequence[-1][-1] = PokerAction.new(
+    # @todo I'm creating one too many AcpcPokerTypes::PokerActions, but I'm not going to worry about it for now.
+    betting_sequence[-1][-1] = AcpcPokerTypes::PokerAction.new(
       last_action(betting_sequence).to_acpc_character,
       {
         amount_to_put_in_pot: last_action(betting_sequence).amount_to_put_in_pot,
@@ -259,7 +258,7 @@ class MatchState
   end
 
   def parse_board_cards(string_board_cards)
-    board_cards = BoardCards.new
+    board_cards = AcpcPokerTypes::BoardCards.new
     for_every_set_of_cards(string_board_cards, '\/') do |string_board_card_set|
       next if string_board_card_set.match(/^\s*$/)
       for_every_card(string_board_card_set) do |card|
@@ -277,7 +276,7 @@ class MatchState
   end
 
   def for_every_card(string_of_cards)
-    Card.cards(string_of_cards).each do |card|
+    AcpcPokerTypes::Card.cards(string_of_cards).each do |card|
       yield card
     end
   end