sportdb-formats 0.2.1 → 0.3.0

data/lib/sportdb/formats/structs/matchlist.rb

@@ -0,0 +1,223 @@
+# encoding: utf-8
+
+
+##
+# note: add all "former" structs to the SportDb::Import module / namespace
+
+module SportDb
+  module Import
+
+
+class Matchlist  ## todo: find a better name - MatchStats, MatchFixtures, MatchSchedule, ...
+                       ## use MatchCache/Buffer/Summary/Snippet/Segment/List...
+                       ##    or MatchAnalyzer/Checker/Proofer/Query - why? why not?
+  attr_reader :matches    # count of matches
+              ## :name,
+              ## :goals,     # count of (total) goals - use total_goals - why? why not?
+              ## :teams, -- has its own reader
+              ## :rounds     # note: use if all teams have same match count
+ ## add last_updated/updated or something - why? why not?
+
+  def initialize( matches )
+    @matches = matches
+  end
+
+
+  def usage
+    @usage ||= build_usage( @matches )
+    @usage
+  end
+
+  def team_usage() usage.team_usage; end
+
+  def teams
+    @team_names ||= team_usage.keys.sort
+    @team_names
+  end
+
+  def goals() usage.goals; end
+
+  ## note: start_date and end_date might be nil / optional missing!!!!
+  def start_date?() usage.start_date?; end
+  def end_date?()   usage.end_date?; end
+
+  def start_date()  usage.start_date; end
+  def end_date()    usage.end_date; end
+
+  def has_dates?()  usage.has_dates?; end
+  def dates_str()   usage.dates_str; end
+  def days()        usage.days; end
+
+
+  def rounds() usage.rounds; end
+
+  ## todo: add has_rounds? alias for rounds? too
+  ## return true if all match_played in team_usage are the same
+  ##  e.g. assumes league with matchday rounds
+  def rounds?() usage.rounds?; end
+
+  def match_counts() usage.match_counts; end
+  def match_counts_str() usage.match_counts_str; end
+
+
+
+  def stage_usage
+    @stage_usage ||= build_stage_usage( @matches )
+    @stage_usage
+  end
+
+  def stages() stage_usage.keys; end  ## note: returns empty array for stages for now - why? why not?
+
+
+############################
+#  matchlist helpers
+private
+  class StatLine
+     attr_reader :team_usage,
+                 :matches,
+                 :goals,
+                 :rounds,   ## keep rounds - why? why not?
+                 :start_date,
+                 :end_date
+
+     def teams() @team_usage.keys.sort; end   ## (auto-)sort here always - why? why not?
+
+     def start_date?() @start_date.nil? == false; end
+     def end_date?()   @end_date.nil? == false; end
+
+     def has_dates?()  @start_date && @end_date; end
+     def dates_str
+      ## note: start_date/end_date might be optional/missing
+      if has_dates?
+        "#{start_date.strftime( '%a %d %b %Y' )} - #{end_date.strftime( '%a %d %b %Y' )}"
+      else
+        "??? - ???"
+      end
+    end
+
+    def days() end_date.jd - start_date.jd; end
+
+
+    def rounds
+      rounds?   ## note: use rounds? to calculate (cache) rounds
+      @rounds   ## note: return number of rounds or nil (for uneven matches played by teams)
+    end
+
+    ## todo: add has_rounds? alias for rounds? too
+    def rounds?
+       ## return true if all match_played in team_usage are the same
+       ##  e.g. assumes league with matchday rounds
+       if @has_rounds.nil?    ## check/todo: if undefined attribute is nil by default??
+          ## check/calc rounds
+          ##  note: values => matches_played by team
+          if match_counts.size == 1
+            @rounds = match_counts[0][0]
+          else
+            @rounds = nil
+          end
+          @has_rounds = @rounds ? true : false
+       end
+       @has_rounds
+    end
+
+
+    def build_match_counts   ## use/rename to matches_played - why? why not?
+      counts = Hash.new(0)
+      team_usage.values.each do |count|
+        counts[count] += 1
+      end
+
+      ## sort (descending) highest usage value first (in returned array)
+      ##  e.g. [[32,8],[31,2]]  ## 32 matches by 8 teams, 31 matches by 2 teams etc.
+      counts.sort_by {|count, usage| -count }
+    end
+
+    def match_counts
+      # match counts / nos played per team
+      @match_counts ||= build_match_counts
+      @match_counts
+    end
+
+    def match_counts_str
+      ## pretty print / formatted match_counts
+      buf = String.new('')
+      match_counts.each_with_index do |rec,i|
+        buf << ' '  if i > 0   ## add (space) separator
+        buf << "#{rec[0]}×#{rec[1]}"
+      end
+      buf
+    end
+
+
+
+     def initialize
+        @matches    = 0
+        @goals      = 0
+
+        @start_date = nil
+        @end_date   = nil
+
+        @team_usage = Hash.new(0)
+
+        @match_counts = nil
+     end
+
+
+     def update( match )
+        @matches += 1    ## match counter
+
+        if match.score1 && match.score2
+          @goals += match.score1
+          @goals += match.score2
+
+          ## todo: add after extra time? if knock out (k.o.) - why? why not?
+          ##   make it a flag/opt?
+        end
+
+        @team_usage[ match.team1 ] += 1
+        @team_usage[ match.team2 ] += 1
+
+        if match.date
+          ## return / store date as string as is - why? why not?
+          date = Date.strptime( match.date, '%Y-%m-%d' )
+
+          @start_date = date  if @start_date.nil? || date < @start_date
+          @end_date   = date  if @end_date.nil?   || date > @end_date
+        end
+     end
+  end  # class StatLine
+
+
+  ## collect total usage stats (for all matches)
+  def build_usage( matches )
+    stat = StatLine.new
+    matches.each do |match|
+      stat.update( match )
+    end
+    stat
+  end
+
+  ## collect usage stats by stage (e.g. regular / playoff / etc.)
+  def build_stage_usage( matches )
+    stages = {}
+
+    matches.each do |match|
+       stage_key = if match.stage.nil?
+                     'Regular'  ## note: assume Regular stage if not defined (AND not explicit unknown)
+                   else
+                     match.stage
+                   end
+
+        stages[ stage_key ] ||= StatLine.new
+        stages[ stage_key ].update( match )
+    end
+
+    stages
+  end
+
+end  # class Matchlist
+
+
+
+  end # module Import
+end # module SportDb

data/lib/sportdb/formats/structs/season.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+
+##
+# note: add all "former" structs to the SportDb::Import module / namespace
+
+module SportDb
+  module Import
+
+
+class Season
+  ##
+  ##  todo: add (optional) start_date and end_date - why? why not?
+  ##        add next
+
+
+  attr_reader :start_year,
+              :end_year
+
+  def year?()  @end_year.nil?; end  ## single-year season e.g. 2011 if no end_year present
+
+
+  def initialize( str )   ## assume only string / line gets passed in for now
+    @start_year, @end_year = parse( str )
+  end
+
+
+  YYYY_YYYY_RE  = %r{^      ## e.g. 2011-2012 or 2011/2012
+                    (\d{4})
+                      [/-]
+                    (\d{4})
+                   $
+                  }x
+  YYYY_YY_RE  = %r{^       ## e.g. 2011-12 or 2011/12
+                    (\d{4})
+                      [/-]
+                    (\d{2})
+                   $
+                  }x
+  YYYY_Y_RE  = %r{^       ## e.g. 2011-2 or 2011/2
+                  (\d{4})
+                    [/-]
+                  (\d{1})
+                 $
+                }x
+  YYYY_RE     = %r{^       ## e.g. 2011
+                    (\d{4})
+                   $
+                  }x
+
+  def parse( str )
+    if str =~ YYYY_YYYY_RE    ## e.g. 2011/2012
+      [$1.to_i, $2.to_i]
+    elsif str =~ YYYY_YY_RE   ## e.g. 2011/12
+      fst = $1.to_i
+      snd = $2.to_i
+      snd_exp = '%02d' % [(fst+1) % 100]    ## double check: e.g 00 == 00, 01==01 etc.
+      raise ArgumentError.new( "[Season#parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}")   if snd_exp != $2
+      [fst, fst+1]
+    elsif str =~ YYYY_Y_RE    ## e.g. 2011/2
+      fst = $1.to_i
+      snd = $2.to_i
+      snd_exp = '%d' % [(fst+1) % 10]      ## double check: e.g 0 == 0, 1==1 etc.
+      raise ArgumentError.new( "[Season#parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}")   if snd_exp != $2
+      [fst, fst+1]
+    elsif str =~ YYYY_RE      ## e.g. 2011
+      [$1.to_i]
+    else
+      raise ArgumentError.new( "[Season#parse] unkown season format >>#{str}<<; sorry cannot parse")
+    end
+  end
+
+
+
+  def prev
+    if year?
+      Season.new( "#{@start_year-1}" )
+    else
+      Season.new( "#{@start_year-1}/#{@start_year}" )
+    end
+  end
+
+  def key
+    if year?
+      '%d' % @start_year
+    else
+      '%d/%02d' % [@start_year, @end_year % 100]
+    end
+  end
+  alias_method :to_key, :key
+  alias_method :to_s,   :key
+
+
+  def path( format: nil )
+    ##  todo: find better names for formats - why? why not?:
+    ##    long | archive | decade(?)   =>   1980s/1988-89, 2010s/2017-18, ...
+    ##    short | std(?)   =>   1988-89, 2017-18, ...
+
+    ## convert season name to "standard" season name for directory
+
+    if ['l', 'long', 'archive' ].include?( format.to_s )   ## note: allow passing in of symbol to e.g. 'long' or :long
+      if year?   ## e.g. 2000s/2001
+        "%3d0s/%4d" % [@start_year / 10, @start_year]
+      else       ## e.g. 2000s/2001-02
+        "%3d0s/%4d-%02d" % [@start_year / 10, @start_year, @end_year % 100]
+      end
+    else  ## default 'short' format / fallback
+      if year?   ## e.g. 2001
+        "%4d" % @start_year
+      else       ## e.g. 2001-02
+        "%4d-%02d" % [@start_year, @end_year % 100]
+      end
+    end
+  end # method path
+  alias_method :directory, :path   ## keep "legacy" directory alias - why? why not?
+  alias_method :to_path,   :path
+
+
+end # class Season
+
+
+end  # module Import
+end  # module SportDb

data/lib/sportdb/formats/structs/standings.rb

@@ -0,0 +1,250 @@
+# encoding: utf-8
+
+##########
+# todo/fix:
+##   reuse standings helper/calculator from sportdb
+##   do NOT duplicate
+
+
+##
+# note: add all "former" structs to the SportDb::Import module / namespace
+
+module SportDb
+  module Import
+
+
+class Standings
+
+  class StandingsLine     ## nested class StandinsLine
+    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
+
+    def initialize( team )
+      @rank = nil # use 0? 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
+    matches = match_or_matches.is_a?(Array) ? match_or_matches : [match_or_matches]
+
+    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
+
+    ##  puts "   #{m.team1} - #{m.team2} #{m.score_str}"
+    unless m.over?
+      puts " !!!! skipping match - not yet over (play_at date in the future)"
+      return
+    end
+
+    unless m.complete?
+      puts "!!! [calc_standings] skipping match #{m.team1} - #{m.team2} - scores incomplete #{m.score_str}"
+      return
+    end
+
+    line1 = @lines[ m.team1 ] || StandingsLine.new( m.team1 )
+    line2 = @lines[ m.team2 ] || StandingsLine.new( m.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[ m.team1 ] = line1
+    @lines[ m.team2 ] = line2
+  end  # method update_match
+
+end  # class Standings
+
+
+end # module Import
+end # module SportDb

data/lib/sportdb/formats/structs/team_usage.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+
+##
+# note: add all "former" structs to the SportDb::Import module / namespace
+
+module SportDb
+  module Import
+
+
+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 Import
+end # module SportDb

data/lib/sportdb/formats/version.rb

@@ -5,8 +5,8 @@ module SportDb
 module Formats
 
   MAJOR = 0    ## todo: namespace inside version or something - why? why not??
-  MINOR = 2
-  PATCH = 1
+  MINOR = 3
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/sportdb/formats.rb

@@ -31,6 +31,13 @@ require 'sportdb/formats/datafile'
 require 'sportdb/formats/package'
 require 'sportdb/formats/season_utils'
 
+require 'sportdb/formats/structs/season'
+require 'sportdb/formats/structs/club'
+require 'sportdb/formats/structs/match'
+require 'sportdb/formats/structs/matchlist'
+require 'sportdb/formats/structs/standings'
+require 'sportdb/formats/structs/team_usage'
+
 
 require 'sportdb/formats/scores'
 require 'sportdb/formats/goals'