sportdb-structs 0.1.0

data/lib/sportdb/structs/structs/group.rb

@@ -0,0 +1,16 @@
+module Sports
+
+    class Group
+      attr_reader :key, :name, :teams
+
+      def initialize( key: nil,
+                      name:,
+                      teams: )
+        @key    = key    ## e.g. A,B,C  or 1,2,3, - note: always a string or nil
+        @name   = name
+        @teams  = teams
+      end
+    end  # class Group
+
+end # module Sports
+

data/lib/sportdb/structs/structs/league.rb

@@ -0,0 +1,35 @@
+
+module Sports
+
+
+class League
+  attr_reader   :key, :name, :country, :intl
+  attr_accessor :alt_names
+
+  ## special import only attribs
+  attr_accessor :alt_names_auto    ## auto-generated alt names
+
+  def initialize( key:, name:, alt_names: [], alt_names_auto: [],
+                  country: nil, intl: false, clubs: true )
+    @key            = key
+    @name           = name
+    @alt_names      = alt_names
+    @alt_names_auto = alt_names_auto
+
+    @country        = country
+    @intl           = intl
+    @clubs          = clubs
+  end
+
+  def intl?()      @intl == true; end
+  def national?()  @intl == false; end
+  alias_method   :domestic?, :national?
+
+  def clubs?()            @clubs == true; end
+  def national_teams?()   @clubs == false; end
+  alias_method   :club?,          :clubs?
+  alias_method   :national_team?, :national_teams?
+
+end   # class League
+
+end   # module Sports

data/lib/sportdb/structs/structs/match.rb

@@ -0,0 +1,180 @@
+
+module Sports
+
+
+class Match
+
+  attr_reader :date,
+              :time,
+              :team1,     :team2,      ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
+              :score1,    :score2,     ## full time
+              :score1i,   :score2i,    ## half time (first (i) part)
+              :score1et,  :score2et,   ## extra time
+              :score1p,   :score2p,    ## penalty
+              :score1agg, :score2agg,  ## full time (all legs) aggregated
+              :winner,    # return 1,2,0   1 => team1, 2 => team2, 0 => draw/tie
+              :round,     ## todo/fix:  use round_num or similar - for compat with db activerecord version? why? why not?
+              :leg,      ## e.g. '1','2','3','replay', etc.   - use leg for marking **replay** too - keep/make leg numeric?! - why? why not?
+              :stage,
+              :group,
+              :status,    ## e.g. replay, cancelled, awarded, abadoned, postponed, etc.
+              :conf1,    :conf2,      ## special case for mls e.g. conference1, conference2 (e.g. west, east, central)
+              :country1, :country2,    ## special case for champions league etc. - uses FIFA country code
+              :comments,
+              :league      ## (optinal) added as text for now (use struct?)
+
+
+  attr_accessor :goals  ## todo/fix: make goals like all other attribs!!
+
+  def initialize( **kwargs )
+    @score1    =  @score2    = nil  ## full time
+    @score1i   =  @score2i   = nil  ## half time (first (i) part)
+    @score1et  =  @score2et  = nil  ## extra time
+    @score1p   =  @score2p   = nil  ## penalty
+    @score1agg =  @score2agg = nil  ## full time (all legs) aggregated
+
+
+    update( kwargs )  unless kwargs.empty?
+  end
+
+  def update( **kwargs )
+    ## note: check with has_key?  because value might be nil!!!
+    @date     = kwargs[:date]     if kwargs.has_key? :date
+    @time     = kwargs[:time]     if kwargs.has_key? :time
+
+    ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
+    @team1    = kwargs[:team1]    if kwargs.has_key? :team1
+    @team2    = kwargs[:team2]    if kwargs.has_key? :team2
+
+    @conf1    = kwargs[:conf1]    if kwargs.has_key? :conf1
+    @conf2    = kwargs[:conf2]    if kwargs.has_key? :conf2
+    @country1 = kwargs[:country1]  if kwargs.has_key? :country1
+    @country2 = kwargs[:country2]  if kwargs.has_key? :country2
+
+    ## note: round is a string!!!  e.g. '1', '2' for matchday or 'Final', 'Semi-final', etc.
+    ##   todo: use to_s - why? why not?
+    @round    = kwargs[:round]    if kwargs.has_key? :round
+    @stage    = kwargs[:stage]    if kwargs.has_key? :stage
+    @leg      = kwargs[:leg]      if kwargs.has_key? :leg
+    @group    = kwargs[:group]    if kwargs.has_key? :group
+    @status   = kwargs[:status]   if kwargs.has_key? :status
+    @comments = kwargs[:comments] if kwargs.has_key? :comments
+
+    @league   = kwargs[:league]   if kwargs.has_key? :league
+
+
+    if kwargs.has_key?( :score )   ## check all-in-one score struct for convenience!!!
+      score = kwargs[:score]
+      if score.nil?   ## reset all score attribs to nil!!
+        @score1     = nil
+        @score1i    = nil
+        @score1et   = nil
+        @score1p    = nil
+        ## @score1agg  = nil
+
+        @score2     = nil
+        @score2i    = nil
+        @score2et   = nil
+        @score2p    = nil
+        ## @score2agg  = nil
+      else
+        @score1     = score.score1
+        @score1i    = score.score1i
+        @score1et   = score.score1et
+        @score1p    = score.score1p
+        ## @score1agg  = score.score1agg
+
+        @score2     = score.score2
+        @score2i    = score.score2i
+        @score2et   = score.score2et
+        @score2p    = score.score2p
+        ## @score2agg  = score.score2agg
+      end
+    else
+      @score1     = kwargs[:score1]      if kwargs.has_key? :score1
+      @score1i    = kwargs[:score1i]     if kwargs.has_key? :score1i
+      @score1et   = kwargs[:score1et]    if kwargs.has_key? :score1et
+      @score1p    = kwargs[:score1p]     if kwargs.has_key? :score1p
+      @score1agg  = kwargs[:score1agg]   if kwargs.has_key? :score1agg
+
+      @score2     = kwargs[:score2]      if kwargs.has_key? :score2
+      @score2i    = kwargs[:score2i]     if kwargs.has_key? :score2i
+      @score2et   = kwargs[:score2et]    if kwargs.has_key? :score2et
+      @score2p    = kwargs[:score2p]     if kwargs.has_key? :score2p
+      @score2agg  = kwargs[:score2agg]   if kwargs.has_key? :score2agg
+
+      ## note: (always) (auto-)convert scores to integers
+      @score1     = @score1.to_i      if @score1
+      @score1i    = @score1i.to_i     if @score1i
+      @score1et   = @score1et.to_i    if @score1et
+      @score1p    = @score1p.to_i     if @score1p
+      @score1agg  = @score1agg.to_i   if @score1agg
+
+      @score2     = @score2.to_i      if @score2
+      @score2i    = @score2i.to_i     if @score2i
+      @score2et   = @score2et.to_i    if @score2et
+      @score2p    = @score2p.to_i     if @score2p
+      @score2agg  = @score2agg.to_i   if @score2agg
+    end
+
+    ## todo/fix:
+    ##  gr-greece/2014-15/G1.csv:
+    ##     G1,10/05/15,Niki Volos,OFI,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+    ##
+
+    ##  for now score1 and score2 must be present
+    ## if @score1.nil? || @score2.nil?
+    ##  puts "** WARN: missing scores for match:"
+    ##  pp kwargs
+    ##  ## exit 1
+    ## end
+
+    ## todo/fix: auto-calculate winner
+    # return 1,2,0   1 => team1, 2 => team2, 0 => draw/tie
+    ### calculate winner - use 1,2,0
+    ##
+    ##  move winner calc to score class - why? why not?
+    if @score1 && @score2
+       if @score1 > @score2
+          @winner = 1
+       elsif @score2 > @score1
+          @winner = 2
+       elsif @score1 == @score2
+          @winner = 0
+       else
+       end
+    else
+      @winner = nil   # unknown / undefined
+    end
+
+    self   ## note - MUST return self for chaining
+  end
+
+
+
+  def over?()      true; end  ## for now all matches are over - in the future check date!!!
+  def complete?()  true; end  ## for now all scores are complete - in the future check scores; might be missing - not yet entered
+
+
+  def score
+    Score.new( @score1i,   @score2i,    ## half time (first (i) part)
+               @score1,    @score2,     ## full time
+               @score1et,  @score2et,   ## extra time
+               @score1p,   @score2p )   ## penalty
+  end
+
+
+  ####
+  ##  deprecated - use score.to_s and friends - why? why not?
+  # def score_str    # pretty print (full time) scores; convenience method
+  #  "#{@score1}-#{@score2}"
+  # end
+
+  # def scorei_str    # pretty print (half time) scores; convenience method
+  #  "#{@score1i}-#{@score2i}"
+  # end
+end  # class Match
+
+end # module Sports
+
+

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

@@ -0,0 +1,215 @@
+
+
+module Sports
+
+
+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 Sports

data/lib/sportdb/structs/structs/round.rb

@@ -0,0 +1,23 @@
+module Sports
+
+  class Round
+      attr_reader   :name, :start_date, :end_date, :knockout
+      attr_accessor :num   # note: make read & writable - why? why not?
+
+      def initialize( name:,
+                      num: nil,
+                      start_date: nil,
+                      end_date: nil,
+                      knockout: false,
+                      auto: true )
+        @name       = name
+        @num        = num
+        @start_date = start_date
+        @end_date   = end_date
+        @knockout   = knockout
+        @auto       = auto        # auto-created (inline reference/header without proper definition before)
+      end
+  end  # class Round
+
+end # module Sports
+