wizardwerdna-pokerstats 1.0.14 → 1.0.15

data/lib/pokerstats/hand_statistics_api.rb

@@ -1,62 +1,64 @@
-module HandStatisticsAPI
-  def initialize handstatistics
-    @hand_statistics = handstatistics
-  end
+module Pokerstats
+  module HandStatisticsAPI
+    def initialize handstatistics
+      @hand_statistics = handstatistics
+    end
 
-  def self.exposed_methods
-    self.public_instance_methods - StatisticsHolder.public_instance_methods
-  end
+    def self.exposed_methods
+      self.public_instance_methods - StatisticsHolder.public_instance_methods
+    end
 
-  def report screen_name
-    automatic_report screen_name
-  end
+    def report screen_name
+      automatic_report screen_name
+    end
 
-  def register_player screen_name, street
-  end
+    def register_player screen_name, street
+    end
 
-  def street_transition street
-  end
+    def street_transition street
+    end
 
-  def street_transition_for_player street, player
-  end
+    def street_transition_for_player street, player
+    end
 
-  def apply_action action, street
-  end
+    def apply_action action, street
+    end
   
-  def automatic_report screen_name
-    result = {}
-    self.class.report_specification.each do |each|
-      result[each[0]] = send(each[2], screen_name)
+    def automatic_report screen_name
+      result = {}
+      self.class.report_specification.each do |each|
+        result[each[0]] = send(each[2], screen_name)
+      end
+      result
     end
-    result
-  end
     
-  private
+    private
   
-  module ClassMethods
-    def report_specification
-      [
-        # [key,   sql_type,   function]
-      ]
-    end
+    module ClassMethods
+      def report_specification
+        [
+          # [key,   sql_type,   function]
+        ]
+      end
   
-    def rails_migration_segment_for_player_data
-      prefix = "\n" + " " * 10
-      result = "#{prefix}# FROM #{self.to_s}"
-      report_specification.each do |each|
-        result += "#{prefix}t.#{each[1]}\t#{each[0].inspect}"
+      def rails_migration_segment_for_player_data
+        prefix = "\n" + " " * 10
+        result = "#{prefix}# FROM #{self.to_s}"
+        report_specification.each do |each|
+          result += "#{prefix}t.#{each[1]}\t#{each[0].inspect}"
+        end
+        result += "\n"
       end
-      result += "\n"
-    end
     
-    def rails_generator_command_line_for_player_data
-      report_specification.inject("") do |string, each|
-        string + "#{each[0]}:#{each[1]} " 
+      def rails_generator_command_line_for_player_data
+        report_specification.inject("") do |string, each|
+          string + "#{each[0]}:#{each[1]} " 
+        end
       end
     end
-  end
     
-  def self.included(klass)
-    klass.extend ClassMethods
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
   end
 end

data/lib/pokerstats/player_statistics.rb

@@ -1,56 +1,58 @@
-class PlayerStatistics
+module Pokerstats
+  class PlayerStatistics
 
-  def initialize
-    @aggregate_statistics = {}
-  end
+    def initialize
+      @aggregate_statistics = {}
+    end
 
-  def reports
-    @aggregate_statistics
-  end
-  
-  def aggregate_numeric_statistic each_player, reports, aggregate_stat, hand_stat
-    @aggregate_statistics[each_player][aggregate_stat] ||= 0
-    @aggregate_statistics[each_player][aggregate_stat] += reports[each_player][hand_stat]
-  end
+    def reports
+      @aggregate_statistics
+    end
   
-  def aggregate_boolean_statistic each_player, reports, aggregate_stat, hand_stat
-    @aggregate_statistics[each_player][aggregate_stat] ||= 0
-    @aggregate_statistics[each_player][aggregate_stat] += 1 if reports[each_player][hand_stat]
-  end
+    def aggregate_numeric_statistic each_player, reports, aggregate_stat, hand_stat
+      @aggregate_statistics[each_player][aggregate_stat] ||= 0
+      @aggregate_statistics[each_player][aggregate_stat] += reports[each_player][hand_stat]
+    end
   
-  def aggregate_statistic each_player, reports, aggregate_stat, hand_stat
-    @aggregate_statistics[each_player][aggregate_stat] ||= 0
-    if /^is_/ =~ hand_stat.to_s
+    def aggregate_boolean_statistic each_player, reports, aggregate_stat, hand_stat
+      @aggregate_statistics[each_player][aggregate_stat] ||= 0
       @aggregate_statistics[each_player][aggregate_stat] += 1 if reports[each_player][hand_stat]
-    else
-      @aggregate_statistics[each_player][aggregate_stat] += reports[each_player][hand_stat]
     end
-  end
   
-  def record hand_statistics
-    reports = hand_statistics.reports
-    reports.keys.each do |each_player|
-      @aggregate_statistics[each_player] ||= {}
+    def aggregate_statistic each_player, reports, aggregate_stat, hand_stat
+      @aggregate_statistics[each_player][aggregate_stat] ||= 0
+      if /^is_/ =~ hand_stat.to_s
+        @aggregate_statistics[each_player][aggregate_stat] += 1 if reports[each_player][hand_stat]
+      else
+        @aggregate_statistics[each_player][aggregate_stat] += reports[each_player][hand_stat]
+      end
+    end
+  
+    def record hand_statistics
+      reports = hand_statistics.reports
+      reports.keys.each do |each_player|
+        @aggregate_statistics[each_player] ||= {}
       
-      @aggregate_statistics[each_player][:t_hands] ||= 0
-       @aggregate_statistics[each_player][:t_hands] += 1
-       @aggregate_statistics[each_player][:t_vpip] ||= 0
-       @aggregate_statistics[each_player][:t_vpip] += 1 unless reports[each_player][:paid].zero?
-       aggregate_numeric_statistic each_player, reports, :t_posted, :posted
-      aggregate_numeric_statistic each_player, reports, :t_paid, :paid
-      aggregate_numeric_statistic each_player, reports, :t_won, :won
-      aggregate_numeric_statistic each_player, reports, :t_preflop_passive, :preflop_passive
-      aggregate_numeric_statistic each_player, reports, :t_preflop_aggressive, :preflop_aggressive
-      aggregate_numeric_statistic each_player, reports, :t_postflop_passive, :postflop_passive
-      aggregate_numeric_statistic each_player, reports, :t_postflop_aggressive, :postflop_aggressive
-      aggregate_boolean_statistic each_player, reports, :t_blind_attack_opportunity, :is_blind_attack_opportunity
-      aggregate_boolean_statistic each_player, reports, :t_blind_attack_opportunity_taken, :is_blind_attack_opportunity_taken
-      aggregate_boolean_statistic each_player, reports, :t_blind_defense_opportunity, :is_blind_defense_opportunity
-      aggregate_boolean_statistic each_player, reports, :t_blind_defense_opportunity_taken, :is_blind_defense_opportunity_taken
-      aggregate_boolean_statistic each_player, reports, :t_pfr_opportunity, :is_pfr_opportunity
-      aggregate_boolean_statistic each_player, reports, :t_pfr_opportunity_taken, :is_pfr_opportunity_taken
-      aggregate_boolean_statistic each_player, reports, :t_cbet_opportunity, :is_cbet_opportunity
-      aggregate_boolean_statistic each_player, reports, :t_cbet_opportunity_taken, :is_cbet_opportunity_taken
+        @aggregate_statistics[each_player][:t_hands] ||= 0
+         @aggregate_statistics[each_player][:t_hands] += 1
+         @aggregate_statistics[each_player][:t_vpip] ||= 0
+         @aggregate_statistics[each_player][:t_vpip] += 1 unless reports[each_player][:paid].zero?
+         aggregate_numeric_statistic each_player, reports, :t_posted, :posted
+        aggregate_numeric_statistic each_player, reports, :t_paid, :paid
+        aggregate_numeric_statistic each_player, reports, :t_won, :won
+        aggregate_numeric_statistic each_player, reports, :t_preflop_passive, :preflop_passive
+        aggregate_numeric_statistic each_player, reports, :t_preflop_aggressive, :preflop_aggressive
+        aggregate_numeric_statistic each_player, reports, :t_postflop_passive, :postflop_passive
+        aggregate_numeric_statistic each_player, reports, :t_postflop_aggressive, :postflop_aggressive
+        aggregate_boolean_statistic each_player, reports, :t_blind_attack_opportunity, :is_blind_attack_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_blind_attack_opportunity_taken, :is_blind_attack_opportunity_taken
+        aggregate_boolean_statistic each_player, reports, :t_blind_defense_opportunity, :is_blind_defense_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_blind_defense_opportunity_taken, :is_blind_defense_opportunity_taken
+        aggregate_boolean_statistic each_player, reports, :t_pfr_opportunity, :is_pfr_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_pfr_opportunity_taken, :is_pfr_opportunity_taken
+        aggregate_boolean_statistic each_player, reports, :t_cbet_opportunity, :is_cbet_opportunity
+        aggregate_boolean_statistic each_player, reports, :t_cbet_opportunity_taken, :is_cbet_opportunity_taken
+      end
     end
   end
 end

data/lib/pokerstats/plugins/aggression_statistics.rb

@@ -1,55 +1,57 @@
-class AggressionStatistics < HandStatistics::Plugin
+module Pokerstats
+  class AggressionStatistics < HandStatistics::Plugin
 
-  def self.report_specification
-    [
-      # [key,                               sql_type,   function]
-      [:preflop_passive,      'integer',  :preflop_passive],
-      [:postflop_passive,     'integer',  :postflop_passive],
-      [:preflop_aggressive,   'integer',  :preflop_aggressive],
-      [:postflop_aggressive,  'integer',  :postflop_aggressive]
-    ]
-  end
+    def self.report_specification
+      [
+        # [key,                               sql_type,   function]
+        [:preflop_passive,      'integer',  :preflop_passive],
+        [:postflop_passive,     'integer',  :postflop_passive],
+        [:preflop_aggressive,   'integer',  :preflop_aggressive],
+        [:postflop_aggressive,  'integer',  :postflop_aggressive]
+      ]
+    end
 
-  def initialize handstatistics
-    super handstatistics
-    @preflop_passive = {}
-    @preflop_aggressive = {}
-    @postflop_passive = {}
-    @postflop_aggressive = {}
-  end
+    def initialize handstatistics
+      super handstatistics
+      @preflop_passive = {}
+      @preflop_aggressive = {}
+      @postflop_passive = {}
+      @postflop_aggressive = {}
+    end
     
-  def preflop_passive(screen_name)
-    @preflop_passive[screen_name]
-  end
+    def preflop_passive(screen_name)
+      @preflop_passive[screen_name]
+    end
   
-  def postflop_passive(screen_name)
-    @postflop_passive[screen_name]
-  end
+    def postflop_passive(screen_name)
+      @postflop_passive[screen_name]
+    end
   
-  def preflop_aggressive(screen_name)
-    @preflop_aggressive[screen_name]
-  end
+    def preflop_aggressive(screen_name)
+      @preflop_aggressive[screen_name]
+    end
   
-  def postflop_aggressive(screen_name)
-    @postflop_aggressive[screen_name]
-  end
+    def postflop_aggressive(screen_name)
+      @postflop_aggressive[screen_name]
+    end
 
-  def register_player screen_name, street
-    @preflop_passive[screen_name] = 0
-    @preflop_aggressive[screen_name] = 0
-    @postflop_passive[screen_name] = 0
-    @postflop_aggressive[screen_name] = 0
-  end
+    def register_player screen_name, street
+      @preflop_passive[screen_name] = 0
+      @preflop_aggressive[screen_name] = 0
+      @postflop_passive[screen_name] = 0
+      @postflop_aggressive[screen_name] = 0
+    end
 
-  def apply_action action, street
-    aggression = action[:aggression]
-    player = action[:screen_name]
-    if [:prelude, :preflop].member?(street)
-      @preflop_aggressive[player] +=1 if aggression == :aggressive
-      @preflop_passive[player] += 1 if aggression == :passive
-    else
-      @postflop_aggressive[player] +=1 if aggression == :aggressive
-      @postflop_passive[player] +=1 if aggression == :passive
+    def apply_action action, street
+      aggression = action[:aggression]
+      player = action[:screen_name]
+      if [:prelude, :preflop].member?(street)
+        @preflop_aggressive[player] +=1 if aggression == :aggressive
+        @preflop_passive[player] += 1 if aggression == :passive
+      else
+        @postflop_aggressive[player] +=1 if aggression == :aggressive
+        @postflop_passive[player] +=1 if aggression == :passive
+      end
     end
   end
 end

data/lib/pokerstats/plugins/blind_attack_statistics.rb

@@ -1,76 +1,78 @@
-class BlindAttackStatistics < HandStatistics::Plugin
-  def initialize handstatistics
-    super(handstatistics)
-    @blind_attack_state = :no_action_taken
-    @blind_attack_opportunity = {}
-    @blind_attack_opportunity_taken ={}
-    @blind_defense_opportunity = {}
-    @blind_defense_opportunity_taken = {}
-  end
+module Pokerstats
+  class BlindAttackStatistics < HandStatistics::Plugin
+    def initialize handstatistics
+      super(handstatistics)
+      @blind_attack_state = :no_action_taken
+      @blind_attack_opportunity = {}
+      @blind_attack_opportunity_taken ={}
+      @blind_defense_opportunity = {}
+      @blind_defense_opportunity_taken = {}
+    end
   
-  def blind_attack_opportunity?(screen_name)
-    @blind_attack_opportunity[screen_name]
-  end
+    def blind_attack_opportunity?(screen_name)
+      @blind_attack_opportunity[screen_name]
+    end
   
-  def blind_attack_opportunity_taken?(screen_name)
-    @blind_attack_opportunity_taken[screen_name]
-  end
+    def blind_attack_opportunity_taken?(screen_name)
+      @blind_attack_opportunity_taken[screen_name]
+    end
   
-  def blind_defense_opportunity?(screen_name)
-    @blind_defense_opportunity[screen_name]
-  end
+    def blind_defense_opportunity?(screen_name)
+      @blind_defense_opportunity[screen_name]
+    end
   
-  def blind_defense_opportunity_taken?(screen_name)
-    @blind_defense_opportunity_taken[screen_name]
-  end
+    def blind_defense_opportunity_taken?(screen_name)
+      @blind_defense_opportunity_taken[screen_name]
+    end
   
-  def self.report_specification
-    [
-      # [key,                               sql_type,   function]
-      [:is_blind_attack_opportunity,        'integer',  :blind_attack_opportunity?],
-      [:is_blind_attack_opportunity_taken,  'integer',  :blind_attack_opportunity_taken?],
-      [:is_blind_defense_opportunity,       'integer',  :blind_defense_opportunity?],
-      [:is_blind_defense_opportunity_taken, 'integer',  :blind_defense_opportunity_taken?]
-    ]
-  end
+    def self.report_specification
+      [
+        # [key,                               sql_type,   function]
+        [:is_blind_attack_opportunity,        'integer',  :blind_attack_opportunity?],
+        [:is_blind_attack_opportunity_taken,  'integer',  :blind_attack_opportunity_taken?],
+        [:is_blind_defense_opportunity,       'integer',  :blind_defense_opportunity?],
+        [:is_blind_defense_opportunity_taken, 'integer',  :blind_defense_opportunity_taken?]
+      ]
+    end
   
-  # def report(screen_name)
-  #   {
-  #     :is_blind_attack_opportunity => blind_attack_opportunity?(screen_name),
-  #     :is_blind_attack_opportunity_taken => blind_attack_opportunity_taken?(screen_name),
-  #     :is_blind_defense_opportunity => blind_defense_opportunity?(screen_name),
-  #     :is_blind_defense_opportunity_taken => blind_defense_opportunity_taken?(screen_name)
-  #   }
-  # end
+    # def report(screen_name)
+    #   {
+    #     :is_blind_attack_opportunity => blind_attack_opportunity?(screen_name),
+    #     :is_blind_attack_opportunity_taken => blind_attack_opportunity_taken?(screen_name),
+    #     :is_blind_defense_opportunity => blind_defense_opportunity?(screen_name),
+    #     :is_blind_defense_opportunity_taken => blind_defense_opportunity_taken?(screen_name)
+    #   }
+    # end
       
-  def apply_action action, street
-    player = action[:screen_name]
-    aggression = action[:aggression]
+    def apply_action action, street
+      player = action[:screen_name]
+      aggression = action[:aggression]
 
-    return if aggression == :neutral || street != :preflop
+      return if aggression == :neutral || street != :preflop
 
-    @blind_defense_opportunity[player] ||= @hand_statistics.blind?(player) && @blind_attack_state == :attacker_raised_first_in
-    @blind_defense_opportunity_taken[player] ||= @blind_defense_opportunity[player] && aggression != :fold
-    case @blind_attack_state
-    when :no_action_taken
-      @blind_attack_opportunity[player] ||= @hand_statistics.attacker?(player)
-      @blind_attack_opportunity_taken[player] ||= @hand_statistics.attacker?(player) && aggression == :aggressive
-      @blind_attack_state = case aggression
-      when :aggressive
-        @hand_statistics.attacker?(player) ? :attacker_raised_first_in : :responsive_action_taken
-      when :passive
-        :responsive_action_taken
-      else
-        :no_action_taken
+      @blind_defense_opportunity[player] ||= @hand_statistics.blind?(player) && @blind_attack_state == :attacker_raised_first_in
+      @blind_defense_opportunity_taken[player] ||= @blind_defense_opportunity[player] && aggression != :fold
+      case @blind_attack_state
+      when :no_action_taken
+        @blind_attack_opportunity[player] ||= @hand_statistics.attacker?(player)
+        @blind_attack_opportunity_taken[player] ||= @hand_statistics.attacker?(player) && aggression == :aggressive
+        @blind_attack_state = case aggression
+        when :aggressive
+          @hand_statistics.attacker?(player) ? :attacker_raised_first_in : :responsive_action_taken
+        when :passive
+          :responsive_action_taken
+        else
+          :no_action_taken
+        end
+      when :attacker_raised_first_in
+        @blind_attack_opportunity[player] ||= false
+        @blind_attack_opportunity_taken[player] ||= false
+        @blind_attack_state = :responsive_action_taken unless [:check, :fold].member?(aggression)
+      when :responsive_action_taken
+        @blind_attack_opportunity[player] ||= false
+        @blind_attack_opportunity_taken[player] ||= false      
+      else raise "invalid state: #{@blind_attack_state}"
       end
-    when :attacker_raised_first_in
-      @blind_attack_opportunity[player] ||= false
-      @blind_attack_opportunity_taken[player] ||= false
-      @blind_attack_state = :responsive_action_taken unless [:check, :fold].member?(aggression)
-    when :responsive_action_taken
-      @blind_attack_opportunity[player] ||= false
-      @blind_attack_opportunity_taken[player] ||= false      
-    else raise "invalid state: #{@blind_attack_state}"
     end
   end
 end