sports 0.0.1

data/lib/sports/structs/standings.rb

@@ -0,0 +1,264 @@
+##########
+# todo/fix:
+##   reuse standings helper/calculator from sportdb
+##   do NOT duplicate
+
+
+module Sports
+
+
+class Standings
+
+  class StandingsLine     ## nested class StandinsLine - todo/fix: change to Line - why? why not?
+    attr_accessor  :rank, :team,
+                   :played, :won, :lost, :drawn,                      ## -- total
+                   :goals_for, :goals_against, :pts,
+                   :home_played, :home_won, :home_lost, :home_drawn,  ## -- home
+                   :home_goals_for, :home_goals_against, :home_pts,
+                   :away_played, :away_won, :away_lost, :away_drawn,  ## -- away
+                   :away_goals_for, :away_goals_against, :away_pts
+
+     alias_method :team_name, :team     ## note: team for now always a string
+     alias_method :pos,       :rank     ##  rename back to use pos instead of rank - why? why not?
+
+
+    def initialize( team )
+      @rank = nil # use 0? why? why not?
+      ## change rank back to pos - why? why not?
+      @team = team
+      @played = @home_played = @away_played = 0
+      @won    = @home_won    = @away_won    = 0
+      @lost   = @home_lost   = @away_lost   = 0
+      @drawn  = @home_drawn  = @away_drawn  = 0
+      @goals_for     = @home_goals_for     = @away_goals_for     = 0
+      @goals_against = @home_goals_against = @away_goals_against = 0
+      @pts    = @home_pts    = @away_pts    = 0
+    end
+  end # (nested) class StandingsLine
+
+
+  def initialize( opts={} )
+    ## fix:
+    # passing in e.g. pts for win (3? 2? etc.)
+    # default to 3 for now
+
+    ## lets you pass in 2 as an alterantive, for example
+    @pts_won = opts[:pts_won] || 3
+
+    @lines = {}   # StandingsLines cached by team name/key
+  end
+
+
+  def update( match_or_matches )
+    ## convenience - update all matches at once
+    ## todo/check:  check for ActiveRecord_Associations_CollectionProxy and than use to_a (to "force" array) - why? why not?
+    matches = if match_or_matches.is_a?(Array)
+                match_or_matches
+              else
+                [match_or_matches]
+              end
+
+    matches.each_with_index do |match,i| # note: index(i) starts w/ zero (0)
+      update_match( match )
+    end
+    self  # note: return self to allow chaining
+  end
+
+
+  def to_a
+    ## return lines; sort and add rank
+    ## note: will update rank!!!! (side effect)
+
+    #############################
+    ### calc ranking position (rank)
+    ## fix/allow same rank e.g. all 1 or more than one team 3rd etc.
+
+    # build array from hash
+    ary = []
+    @lines.each do |k,v|
+      ary << v
+    end
+
+    ary.sort! do |l,r|
+      ## note: reverse order (thus, change l,r to r,l)
+      value = r.pts <=> l.pts
+      if value == 0 # same pts try goal diff
+        value = (r.goals_for-r.goals_against) <=> (l.goals_for-l.goals_against)
+        if value == 0 # same goal diff too; try assume more goals better for now
+          value = r.goals_for <=> l.goals_for
+        end
+      end
+      value
+    end
+
+    ## update rank using ordered array
+    ary.each_with_index do |line,i|
+      line.rank = i+1 ## add ranking (e.g. 1,2,3 etc.) - note: i starts w/ zero (0)
+    end
+
+    ary
+  end  # to_a
+
+
+
+  #####
+  ###
+  ## fix: move build to StandingsPart/Report   !!!!
+  def build( source: nil )   ## build / pretty print standings table in string buffer
+    ## keep pretty printer in struct - why? why not?
+
+
+    ## add standings table in markdown to buffer (buf)
+
+    ## todo: use different styles/formats (simple/ etc  ???)
+
+  ## simple table (only totals - no home/away)
+  ##       standings.to_a.each do |l|
+  ##         buf << '%2d. '  % l.rank
+  ##         buf << '%-28s  ' % l.team
+  ##         buf << '%2d '     % l.played
+  ##         buf << '%3d '     % l.won
+  ##         buf << '%3d '     % l.drawn
+  ##         buf << '%3d '     % l.lost
+  ##         buf << '%3d:%-3d ' % [l.goals_for,l.goals_against]
+  ##         buf << '%3d'       % l.pts
+  ##         buf << "\n"
+  ##       end
+
+    buf = ''
+    buf << "\n"
+    buf << "```\n"
+    buf << "                                        - Home -          - Away -            - Total -\n"
+    buf << "                                 Pld   W  D  L   F:A     W  D  L   F:A      F:A   +/-  Pts\n"
+
+    to_a.each do |l|
+      buf << '%2d. '  % l.rank
+      buf << '%-28s  ' % l.team
+      buf << '%2d  '     % l.played
+
+      buf << '%2d '      % l.home_won
+      buf << '%2d '      % l.home_drawn
+      buf << '%2d '      % l.home_lost
+      buf << '%3d:%-3d  ' % [l.home_goals_for,l.home_goals_against]
+
+      buf << '%2d '       % l.away_won
+      buf << '%2d '       % l.away_drawn
+      buf << '%2d '       % l.away_lost
+      buf << '%3d:%-3d  ' % [l.away_goals_for,l.away_goals_against]
+
+      buf << '%3d:%-3d ' % [l.goals_for,l.goals_against]
+
+      goals_diff = l.goals_for-l.goals_against
+      if goals_diff > 0
+        buf << '%3s  '  %  "+#{goals_diff}"
+      elsif goals_diff < 0
+        buf << '%3s  '  %  "#{goals_diff}"
+      else ## assume 0
+        buf << '     '
+      end
+
+      buf << '%3d'       % l.pts
+      buf << "\n"
+    end
+
+    buf << "```\n"
+    buf << "\n"
+
+    ## optinal: add data source if known / present
+    ##   assume (relative) markdown link for now in README.md
+    if source
+      buf << "(Source: [`#{source}`](#{source}))\n"
+      buf << "\n"
+    end
+
+    buf
+  end
+
+
+private
+  def update_match( m )   ## add a match
+
+    ## note: always use team as string for now
+    ##   for now allow passing in of string OR struct - why? why not?
+    ##   todo/fix:  change to m.team1_name and m.team2_name - why? why not?
+    team1 = m.team1.is_a?( String ) ? m.team1 : m.team1.name
+    team2 = m.team2.is_a?( String ) ? m.team2 : m.team2.name
+
+    score = m.score_str
+
+    ##  puts "   #{team1} - #{team2} #{score}"
+
+    unless m.over?
+      puts " !!!! skipping match - not yet over (date in the future) => #{m.date}"
+      return
+    end
+
+    unless m.complete?
+      puts "!!! [calc_standings] skipping match #{team1} - #{team2} w/ past date #{m.date} - scores incomplete => #{score}"
+      return
+    end
+
+
+
+    line1 = @lines[ team1 ] || StandingsLine.new( team1 )
+    line2 = @lines[ team2 ] || StandingsLine.new( team2 )
+
+    line1.played      += 1
+    line1.home_played += 1
+
+    line2.played      += 1
+    line2.away_played += 1
+
+    if m.winner == 1
+      line1.won      += 1
+      line1.home_won += 1
+
+      line2.lost      += 1
+      line2.away_lost += 1
+
+      line1.pts      += @pts_won
+      line1.home_pts += @pts_won
+    elsif m.winner == 2
+      line1.lost      += 1
+      line1.home_lost += 1
+
+      line2.won       += 1
+      line2.away_won  += 1
+
+      line2.pts      += @pts_won
+      line2.away_pts += @pts_won
+    else ## assume drawn/tie (that is, 0)
+      line1.drawn      += 1
+      line1.home_drawn += 1
+
+      line2.drawn      += 1
+      line2.away_drawn += 1
+
+      line1.pts      += 1
+      line1.home_pts += 1
+      line2.pts      += 1
+      line2.away_pts += 1
+    end
+
+    if m.score1 && m.score2
+      line1.goals_for      += m.score1
+      line1.home_goals_for += m.score1
+      line1.goals_against      += m.score2
+      line1.home_goals_against += m.score2
+
+      line2.goals_for      += m.score2
+      line2.away_goals_for += m.score2
+      line2.goals_against      += m.score1
+      line2.away_goals_against += m.score1
+    else
+      puts "*** warn: [standings] skipping match with missing scores: #{m.inspect}"
+    end
+
+    @lines[ team1 ] = line1
+    @lines[ team2 ] = line2
+  end  # method update_match
+
+end  # class Standings
+
+
+end # module Sports

data/lib/sports/structs/team.rb

@@ -0,0 +1,147 @@
+
+module Sports
+
+##
+##  todo/fix:  remove self.create in structs!!!  use just new!!!
+
+class Team
+  ##  todo: use just names for alt_names - why? why not?
+  attr_accessor :key, :name, :alt_names,
+                :code,    ## code == abbreviation e.g. ARS etc.
+                :year, :year_end,   ## todo/fix: change year to start_year and year_end to end_year (like in season)!!!
+                :country
+
+
+  def names
+    ## todo/check: add alt_names_auto too? - why? why not?
+    [@name] + @alt_names
+  end   ## all names
+
+  def key
+    ## note: auto-generate key "on-the-fly" if missing for now - why? why not?
+    ## note: quick hack - auto-generate key, that is, remove all non-ascii chars and downcase
+    @key || @name.downcase.gsub( /[^a-z]/, '' )
+  end
+
+
+  ## special import only attribs
+  attr_accessor :alt_names_auto    ## auto-generated alt names
+  attr_accessor :wikipedia   # wikipedia page name (for english (en))
+
+
+  def historic?()  @year_end ? true : false; end
+  alias_method  :past?, :historic?
+
+  def wikipedia?()  @wikipedia; end
+  def wikipedia_url
+    if @wikipedia
+      ##  note: replace spaces with underscore (-)
+      ##  e.g. Club Brugge KV => Club_Brugge_KV
+      ##  todo/check/fix:
+      ##    check if "plain" dash (-) needs to get replaced with typographic dash??
+      "https://en.wikipedia.org/wiki/#{@wikipedia.gsub(' ','_')}"
+    else
+      nil
+    end
+  end
+
+
+  def initialize( **kwargs )
+    @alt_names      = []
+    @alt_names_auto = []
+
+    update( kwargs )  unless kwargs.empty?
+  end
+
+  def update( **kwargs )
+    @key         = kwargs[:key]        if kwargs.has_key? :key
+    @name        = kwargs[:name]       if kwargs.has_key? :name
+    @code        = kwargs[:code]       if kwargs.has_key? :code
+    @alt_names   = kwargs[:alt_names]  if kwargs.has_key? :alt_names
+    self   ## note - MUST return self for chaining
+  end
+
+
+
+  ##############################
+  ## helper methods for import only??
+  ## check for duplicates
+  include NameHelper
+
+  def duplicates?
+    names = [name] + alt_names + alt_names_auto
+    names = names.map { |name| normalize( sanitize(name) ) }
+
+    names.size != names.uniq.size
+  end
+
+  def duplicates
+    names = [name] + alt_names + alt_names_auto
+
+    ## calculate (count) frequency and select if greater than one
+    names.reduce( {} ) do |h,name|
+       norm = normalize( sanitize(name) )
+       h[norm] ||= []
+       h[norm] << name; h
+    end.select { |norm,names| names.size > 1 }
+  end
+
+
+  def add_variants( name_or_names )
+    names = name_or_names.is_a?(Array) ? name_or_names : [name_or_names]
+    names.each do |name|
+      name = sanitize( name )
+      self.alt_names_auto += variants( name )
+    end
+  end
+end   # class Team
+
+
+
+class NationalTeam < Team
+  def initialize( **kwargs )
+    super
+  end
+
+  def update( **kwargs )
+    super
+    self   ## note - MUST return self for chaining
+  end
+
+end  # class NationalTeam
+
+
+########
+# more attribs - todo/fix - also add "upstream" to struct & model!!!!!
+#   district, geos, year_end, country, etc.
+
+class Club < Team
+  attr_accessor  :ground
+
+  attr_accessor :a, :b
+  def a?()  @a == nil; end  ## is a (1st) team / club (i)?            if a is NOT set
+  def b?()  @a != nil; end  ## is b (2nd/reserve/jr) team / club (ii) if a is     set
+
+  ## note: delegate/forward all geo attributes for team b for now (to team a) - keep - why? why not?
+  attr_writer  :city, :district, :geos
+  def city()      @a == nil ?  @city     : @a.city;     end
+  def district()  @a == nil ?  @district : @a.district; end
+  def country()   @a == nil ?  @country  : @a.country;  end
+  def geos()      @a == nil ?  @geos     : @a.geos;     end
+
+
+  def initialize( **kwargs )
+    super
+  end
+
+  def update( **kwargs )
+    super
+    @city        = kwargs[:city]       if kwargs.has_key? :city
+    ## todo/fix:  use city struct - why? why not?
+    ## todo/fix: add country too  or report unused keywords / attributes - why? why not?
+
+    self   ## note - MUST return self for chaining
+  end
+end # class Club
+
+end   # module Sports

data/lib/sports/structs/team_usage.rb

@@ -0,0 +1,84 @@
+
+module Sports
+
+
+class TeamUsage
+
+  class TeamUsageLine   ## nested class
+    attr_accessor  :team,
+                   :matches,  ## number of matches (played),
+                   :seasons,  ## (optianl) array of seasons, use seasons.size for count
+                   :levels    ## (optional) hash of levels (holds mapping level to TeamUsageLine)
+
+    def initialize( team )
+      @team = team
+
+      @matches  = 0
+      @seasons  = []
+      @levels   = {}
+    end
+  end # (nested) class TeamUsageLine
+
+
+
+  def initialize( opts={} )
+    @lines = {}   # StandingsLines cached by team name/key
+  end
+
+
+  def update( matches, season: '?', level: nil )
+    ## convenience - update all matches at once
+    matches.each_with_index do |match,i| # note: index(i) starts w/ zero (0)
+      update_match( match, season: season, level: level )
+    end
+    self  # note: return self to allow chaining
+  end
+
+  def to_a
+    ## return lines; sort
+
+    # build array from hash
+    ary = []
+    @lines.each do |k,v|
+      ary << v
+    end
+
+    ## for now sort just by name (a-z)
+    ary.sort! do |l,r|
+      ## note: reverse order (thus, change l,r to r,l)
+      l.team <=> r.team
+    end
+
+    ary
+  end  # to_a
+
+
+private
+  def update_match( m, season: '?', level: nil )   ## add a match
+
+    line1 = @lines[ m.team1 ] ||= TeamUsageLine.new( m.team1 )
+    line2 = @lines[ m.team2 ] ||= TeamUsageLine.new( m.team2 )
+
+    line1.matches +=1
+    line2.matches +=1
+
+    ## include season if not seen before (allow season in multiple files!!!)
+    line1.seasons << season    unless line1.seasons.include?( season )
+    line2.seasons << season    unless line2.seasons.include?( season )
+
+    if level
+      line1_level = line1.levels[ level ] ||= TeamUsageLine.new( m.team1 )
+      line2_level = line2.levels[ level ] ||= TeamUsageLine.new( m.team2 )
+
+      line1_level.matches +=1
+      line2_level.matches +=1
+
+      line1_level.seasons << season    unless line1_level.seasons.include?( season )
+      line2_level.seasons << season    unless line2_level.seasons.include?( season )
+    end
+  end  # method update_match
+
+
+end # class TeamUsage
+
+end # module Sports