wizardwerdna-pokerstats 1.0.14 → 1.0.15

data/lib/pokerstats/plugins/cash_statistics.rb

@@ -1,93 +1,95 @@
-class CashStatistics < HandStatistics::Plugin
-  def initialize handstatistics
-    super handstatistics
-    @posted = {}
-    @paid = {}
-    @paid_this_round = {}
-    @won = {}
-    @cards = {}
-    @stats = {:posted => @posted, :paid => @paid, :won => @won, :cards => @cards}
-  end
+module Pokerstats
+  class CashStatistics < HandStatistics::Plugin
+    def initialize handstatistics
+      super handstatistics
+      @posted = {}
+      @paid = {}
+      @paid_this_round = {}
+      @won = {}
+      @cards = {}
+      @stats = {:posted => @posted, :paid => @paid, :won => @won, :cards => @cards}
+    end
   
-  def posted(player)
-    @posted[player]
-  end
+    def posted(player)
+      @posted[player]
+    end
   
-  def paid(player)
-    @paid[player]
-  end
+    def paid(player)
+      @paid[player]
+    end
   
-  def paid_this_round(player)
-    @paid_this_round[player]    
-  end
+    def paid_this_round(player)
+      @paid_this_round[player]    
+    end
   
-  def won(player)
-    @won[player]
-  end
+    def won(player)
+      @won[player]
+    end
   
-  def cards(player)
-    @cards[player]
-  end
+    def cards(player)
+      @cards[player]
+    end
   
-  def self.report_specification
-    [
-      # [key,   sql_type,   function]
-      [:posted, 'decimal',  :posted],
-      [:paid,   'decimal',  :paid],
-      [:won,    'decimal',  :won],
-      [:cards,  'string',   :cards]
-    ]
-  end
+    def self.report_specification
+      [
+        # [key,   sql_type,   function]
+        [:posted, 'decimal',  :posted],
+        [:paid,   'decimal',  :paid],
+        [:won,    'decimal',  :won],
+        [:cards,  'string',   :cards]
+      ]
+    end
   
-  # def report(screen_name)
-  #   {
-  #     :posted => posted(screen_name),
-  #     :paid => paid(screen_name),
-  #     :won => won(screen_name),
-  #     :cards => cards(screen_name)
-  #   }
-  # end
+    # def report(screen_name)
+    #   {
+    #     :posted => posted(screen_name),
+    #     :paid => paid(screen_name),
+    #     :won => won(screen_name),
+    #     :cards => cards(screen_name)
+    #   }
+    # end
   
-  def stats(player=nil)
-    return @stats unless player
-    # @stats.inject({}){|last, pair| last.merge(pair[0] => pair[1][player])}
-  end
+    def stats(player=nil)
+      return @stats unless player
+      # @stats.inject({}){|last, pair| last.merge(pair[0] => pair[1][player])}
+    end
   
-  def register_player(screen_name, street)
-    @posted[screen_name] = 0
-    @paid[screen_name] = 0
-    @won[screen_name] = 0
-  end
+    def register_player(screen_name, street)
+      @posted[screen_name] = 0
+      @paid[screen_name] = 0
+      @won[screen_name] = 0
+    end
   
-  def street_transition_for_player street, player
-    @paid_this_round[player] = 0 unless street == :preflop
-  end
+    def street_transition_for_player street, player
+      @paid_this_round[player] = 0 unless street == :preflop
+    end
   
-  def apply_action action, street
-    player = action[:screen_name]
-    description = action[:description]
-    result = action[:result]
-    amount = action[:amount]
-    data = action[:data]
-    case result
-    when :post
-      @posted[player] += amount
-      @paid_this_round[player] += amount unless description == "antes"
-    when :pay
-      @paid[player] ||= 0
-      @paid[player] += amount
-      @paid_this_round[player] += amount
-    when :pay_to
-      net_amount_paid = amount - @paid_this_round[player]
-      action[:net_amount_paid] = net_amount_paid
-      @paid[player] += net_amount_paid
-      @paid_this_round[player] += net_amount_paid
-    when :win
-      @won[player] += amount
-    when :neutral
-    when :cards
-      @cards[player] = data
-    else raise "invalid action result: #{result.inspect}"
+    def apply_action action, street
+      player = action[:screen_name]
+      description = action[:description]
+      result = action[:result]
+      amount = action[:amount]
+      data = action[:data]
+      case result
+      when :post
+        @posted[player] += amount
+        @paid_this_round[player] += amount unless description == "antes"
+      when :pay
+        @paid[player] ||= 0
+        @paid[player] += amount
+        @paid_this_round[player] += amount
+      when :pay_to
+        net_amount_paid = amount - @paid_this_round[player]
+        action[:net_amount_paid] = net_amount_paid
+        @paid[player] += net_amount_paid
+        @paid_this_round[player] += net_amount_paid
+      when :win
+        @won[player] += amount
+      when :neutral
+      when :cards
+        @cards[player] = data
+      else raise "invalid action result: #{result.inspect}"
+      end
     end
   end
-end
+end

data/lib/pokerstats/plugins/continuation_bet_statistics.rb

@@ -1,65 +1,67 @@
-class ContinuationBetStatistics < HandStatistics::Plugin
-  def initialize handstatistics
-    super(handstatistics)
-    @last_preflop_raiser = nil
-    @number_preflop_raises = 0
-    @first_aggressor = {}
-    @first_aggression_opportunity = {}
-    @first_aggression_opportunity_taken = {}
-  end
-  
-  def cbet_opportunity?(screen_name, street = :flop)
-    # puts "cbet_opportunity?(#{screen_name}, #{street})"
-    # puts @first_aggression_opportunity.inspect
-    @number_preflop_raises==1 && @last_preflop_raiser==screen_name && @first_aggression_opportunity[street] && @first_aggression_opportunity[street][screen_name]
-  end
+module Pokerstats
+  class ContinuationBetStatistics < HandStatistics::Plugin
+    def initialize handstatistics
+      super(handstatistics)
+      @last_preflop_raiser = nil
+      @number_preflop_raises = 0
+      @first_aggressor = {}
+      @first_aggression_opportunity = {}
+      @first_aggression_opportunity_taken = {}
+    end
   
-  def cbet_opportunity_taken?(screen_name, street = :flop)
-    cbet_opportunity?(screen_name) && @first_aggression_opportunity_taken[street][screen_name]
-  end
+    def cbet_opportunity?(screen_name, street = :flop)
+      # puts "cbet_opportunity?(#{screen_name}, #{street})"
+      # puts @first_aggression_opportunity.inspect
+      @number_preflop_raises==1 && @last_preflop_raiser==screen_name && @first_aggression_opportunity[street] && @first_aggression_opportunity[street][screen_name]
+    end
   
-  def self.report_specification
-    [
-      # [key,                     sql_type,   function]
-      [:is_cbet_opportunity,       'integer',  :cbet_opportunity?],
-      [:is_cbet_opportunity_taken, 'integer',  :cbet_opportunity_taken?]
-    ]
-  end
+    def cbet_opportunity_taken?(screen_name, street = :flop)
+      cbet_opportunity?(screen_name) && @first_aggression_opportunity_taken[street][screen_name]
+    end
   
-  # 
-  # def report(screen_name)
-  #   {
-  #     :is_cbet_opportunity => cbet_opportunity?(screen_name),
-  #     :is_cbet_opportunity_taken => cbet_opportunity_taken?(screen_name)
-  #   }
-  # end
+    def self.report_specification
+      [
+        # [key,                     sql_type,   function]
+        [:is_cbet_opportunity,       'integer',  :cbet_opportunity?],
+        [:is_cbet_opportunity_taken, 'integer',  :cbet_opportunity_taken?]
+      ]
+    end
   
-  def street_transition street
-    @first_aggressor[street] = nil
-    @first_aggression_opportunity[street] = {}
-    @first_aggression_opportunity_taken[street] = {}
-    super(street)
-  end
+    # 
+    # def report(screen_name)
+    #   {
+    #     :is_cbet_opportunity => cbet_opportunity?(screen_name),
+    #     :is_cbet_opportunity_taken => cbet_opportunity_taken?(screen_name)
+    #   }
+    # end
   
-  def street_transition_for_player street, player
-    @first_aggression_opportunity[street][player] = nil
-    @first_aggression_opportunity_taken[street][player] = false
-  end
+    def street_transition street
+      @first_aggressor[street] = nil
+      @first_aggression_opportunity[street] = {}
+      @first_aggression_opportunity_taken[street] = {}
+      super(street)
+    end
   
-  def apply_action action, street
-    player = action[:screen_name]
-    aggression = action[:aggression]
-    result = action[:result]
-    if street == :preflop and result == :pay_to
-      @number_preflop_raises += 1
-      @last_preflop_raiser = player
+    def street_transition_for_player street, player
+      @first_aggression_opportunity[street][player] = nil
+      @first_aggression_opportunity_taken[street][player] = false
     end
-    if aggression != :neutral && @first_aggressor[street].nil? && @first_aggression_opportunity[street][player].nil?
-      @first_aggression_opportunity[street][player] = true
-      if aggression == :aggressive
-        @first_aggressor[street] = player
-        @first_aggression_opportunity_taken[street][player] = true
-        @hand_statistics.players.each {|player| @first_aggression_opportunity[street][player] ||= false}
+  
+    def apply_action action, street
+      player = action[:screen_name]
+      aggression = action[:aggression]
+      result = action[:result]
+      if street == :preflop and result == :pay_to
+        @number_preflop_raises += 1
+        @last_preflop_raiser = player
+      end
+      if aggression != :neutral && @first_aggressor[street].nil? && @first_aggression_opportunity[street][player].nil?
+        @first_aggression_opportunity[street][player] = true
+        if aggression == :aggressive
+          @first_aggressor[street] = player
+          @first_aggression_opportunity_taken[street][player] = true
+          @hand_statistics.players.each {|player| @first_aggression_opportunity[street][player] ||= false}
+        end
       end
     end
   end

data/lib/pokerstats/plugins/preflop_raise_statistics.rb

@@ -1,47 +1,49 @@
-class PreflopRaiseStatistics < HandStatistics::Plugin
+module Pokerstats
+  class PreflopRaiseStatistics < HandStatistics::Plugin
 
-  def initialize handstatistics
-    super handstatistics
-    @pfr_opportunity = {}
-    @pfr_opportunity_taken = {}
-    @pfr_size_in_bb = {}
-  end
+    def initialize handstatistics
+      super handstatistics
+      @pfr_opportunity = {}
+      @pfr_opportunity_taken = {}
+      @pfr_size_in_bb = {}
+    end
   
-  def pfr_opportunity?(screen_name)
-    @pfr_opportunity[screen_name]
-  end
+    def pfr_opportunity?(screen_name)
+      @pfr_opportunity[screen_name]
+    end
   
-  def pfr_opportunity_taken?(screen_name)
-    @pfr_opportunity[screen_name] && @pfr_opportunity_taken[screen_name]
-  end
+    def pfr_opportunity_taken?(screen_name)
+      @pfr_opportunity[screen_name] && @pfr_opportunity_taken[screen_name]
+    end
   
-  def self.report_specification
-    [
-      # [key,                     sql_type,   function]
-      [:is_pfr_opportunity,       'integer',  :pfr_opportunity?],
-      [:is_pfr_opportunity_taken, 'integer',  :pfr_opportunity_taken?]
-    ]
-  end
+    def self.report_specification
+      [
+        # [key,                     sql_type,   function]
+        [:is_pfr_opportunity,       'integer',  :pfr_opportunity?],
+        [:is_pfr_opportunity_taken, 'integer',  :pfr_opportunity_taken?]
+      ]
+    end
     
-  # def report screen_name
-  #   {
-  #     :is_pfr_opportunity => pfr_opportunity?(screen_name),
-  #     :is_pfr_opportunity_taken => pfr_opportunity_taken?(screen_name)
-  #   }
-  # end
+    # def report screen_name
+    #   {
+    #     :is_pfr_opportunity => pfr_opportunity?(screen_name),
+    #     :is_pfr_opportunity_taken => pfr_opportunity_taken?(screen_name)
+    #   }
+    # end
   
-  def apply_action action, street
-    # puts "pfr: apply_action #{street}, #{action.inspect}"
-    result = action[:result]
-    player = action[:screen_name]
-    if street == :preflop and [:pay, :pay_to, :neutral].member?(result) and @pfr_opportunity[player].nil?
-      case result
-      when :pay, :neutral
-        @pfr_opportunity[player] = true
-        @pfr_opportunity_taken[player] = false
-      when :pay_to
-        @hand_statistics.players.each {|each_player| @pfr_opportunity[each_player] ||= (each_player == player)}
-        @pfr_opportunity_taken[player] = true
+    def apply_action action, street
+      # puts "pfr: apply_action #{street}, #{action.inspect}"
+      result = action[:result]
+      player = action[:screen_name]
+      if street == :preflop and [:pay, :pay_to, :neutral].member?(result) and @pfr_opportunity[player].nil?
+        case result
+        when :pay, :neutral
+          @pfr_opportunity[player] = true
+          @pfr_opportunity_taken[player] = false
+        when :pay_to
+          @hand_statistics.players.each {|each_player| @pfr_opportunity[each_player] ||= (each_player == player)}
+          @pfr_opportunity_taken[player] = true
+        end
       end
     end
   end

data/lib/pokerstats/poker-edge.rb

@@ -2,54 +2,56 @@ require 'rubygems'
 require 'hpricot'
 require 'open-uri'
 
-class PokerEdge
+module Pokerstats
+  class PokerEdge
   
-  def initialize screen_name
-    @screen_name = URI.escape(screen_name)
-  end
+    def initialize screen_name
+      @screen_name = URI.escape(screen_name)
+    end
   
-  def get_response_from_internet
-    url = "http://www.poker-edge.com/whoami.php?name=#{@screen_name}"
-    puts url
-    open(url) do |f|
-      @response = f.read
+    def get_response_from_internet
+      url = "http://www.poker-edge.com/whoami.php?name=#{@screen_name}"
+      puts url
+      open(url) do |f|
+        @response = f.read
+      end
+      @response
     end
-    @response
-  end
   
-  def response
-    @response ||= get_response_from_internet
-  end
+    def response
+      @response ||= get_response_from_internet
+    end
   
-  def preflop_style
-    if self.response =~ /(Pre-Flop Tend.*\n)/
-      verbose = $1.gsub(/<\/?[^>]*>/, "")
-      if verbose =~ /Pre-Flop Tendency: ([^-]*) -/
-        preflop_style = $1
-      else
-        preflop_style = "N/A"
+    def preflop_style
+      if self.response =~ /(Pre-Flop Tend.*\n)/
+        verbose = $1.gsub(/<\/?[^>]*>/, "")
+        if verbose =~ /Pre-Flop Tendency: ([^-]*) -/
+          preflop_style = $1
+        else
+          preflop_style = "N/A"
+        end
       end
+      preflop_style
     end
-    preflop_style
-  end
   
-  def player_type
-    if response =~ /(Player Type.*\n)/
-      verbose = $1.gsub(/<\/?[^>]*>/, "")
-      if verbose =~ /[Yy]ou are a ([^(]* \(.*\))/
-        player = $1
-      else
-        player = ""
+    def player_type
+      if response =~ /(Player Type.*\n)/
+        verbose = $1.gsub(/<\/?[^>]*>/, "")
+        if verbose =~ /[Yy]ou are a ([^(]* \(.*\))/
+          player = $1
+        else
+          player = ""
+        end
       end
+      player
     end
-    player
-  end
   
-  def report format = "%20s -- %s -- %s\n"
-    open("foo.html", "w+") do |file|
-      file.write(response)
+    def report format = "%20s -- %s -- %s\n"
+      open("foo.html", "w+") do |file|
+        file.write(response)
+      end
+      `open foo.html`
+      printf(format, @screen_name, preflop_style, player_type)
     end
-    `open foo.html`
-    printf(format, @screen_name, preflop_style, player_type)
   end
 end