sports 0.1.0 → 0.2.0

data/lib/sports/season.rb

@@ -1,199 +0,0 @@
-
-### note: make Season like Date a "top-level" / "generic" class
-
-
-class Season
-  ##
-  ##  todo: add (optional) start_date and end_date - why? why not?
-
-  ## todo/todo/todo/check/check/check !!!
-  ## todo: add a kernel Seaons e.g. Season('2011/12')
-  ##    forward to Season.convert( *args )  - why? why not?
-
-  ## todo: add unicode - too - why? why not? see wikipedia pages, for example
-
-  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 self.parse( str )
-    new( *_parse( str ))
-  end
-
-  def self._parse( str )   ## "internal" parse helper
-    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, "[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, "[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, "[Season.parse] unkown season format >>#{str}<<; sorry cannot parse"
-    end
-  end
-
-
-  def self.convert( *args )  ## note: used by Kernel method Season()
-    if args.size == 1 && args[0].is_a?( Season )
-      args[0]  # pass through / along as is 1:1
-    elsif args.size == 1 && args[0].is_a?( String )
-      parse( args[0] )
-    elsif args.size == 1 && args[0].is_a?( Integer ) && args[0] > 9999
-      ## note: allow convenience "hack" such as:
-      # 202021   or 2020_21   => '2020/21' or
-      # 2020_1   or 2020_1    => '2020/21' or
-      # 20202021 or 2020_2021 => '2020/21'
-      str = args[0].to_s
-      parse( "#{str[0..3]}/#{str[4..-1]}" )
-    else ## assume all integer args e.g.  2020 or 2020, 2021 and such
-      new( *args ) ## try conversion with new
-    end
-  end
-
-
-  attr_reader :start_year,
-              :end_year
-
-  def initialize( *args )   ## change args to years - why? why not?
-    if args.size == 1 && args[0].is_a?( Integer )
-      @start_year = args[0]
-      @end_year   = args[0]
-    elsif args.size == 2 && args[0].is_a?( Integer ) &&
-                            args[1].is_a?( Integer )
-      @start_year = args[0]
-      @end_year   = args[1]
-      end_year_exp = @start_year+1
-      raise ArgumentError, "[Season] invalid year in season >>#{to_s}<<; expected #{end_year_exp} but got #{@end_year}"   if end_year_exp != @end_year
-    else
-      pp args
-      raise ArgumentError, "[Season] expected season start year (integer) with opt. end year"
-    end
-  end
-
-
-
-  ## convenience helper  - move to sportdb or such - remove - why - why not???
-  def start_date   ## generate "generic / syntetic start date" - keep helper - why? why not?
-    if year?
-      Date.new( start_year, 1, 1 )
-    else
-      Date.new( start_year 1, 7 )
-    end
-  end
-
-
-  ## single-year season e.g. 2011 if start_year is end_year - todo - find a better name?
-  def year?()  @start_year == @end_year; end
-
-  def prev
-    if year?
-      Season.new( @start_year-1 )
-    else
-      Season.new( @start_year-1, @end_year-1 )
-    end
-  end
-
-  def next
-    if year?
-      Season.new( @start_year+1 )
-    else
-      Season.new( @start_year+1, @end_year+1 )
-    end
-  end
-  alias_method :succ, :next   ## add support for ranges
-
-
-  include Comparable
-  def <=>(other)
-    ## todo/fix/fix:  check if other is_a?( Season )!!!
-    ##  what to return if other type/class ??
-    ## note: check special edge case - year season and other e.g.
-    ##    2010 <=> 2010/2011
-
-    res = @start_year <=> other.start_year
-    res = @end_year   <=> other.end_year     if res == 0
-    res
-  end
-
-
-  def to_formatted_s( format=:default, sep: '/' )
-    if year?
-      '%d' % @start_year
-    else
-      case format
-      when :default, :short, :s   ## e.g. 1999/00 or 2019/20
-        "%d#{sep}%02d" % [@start_year, @end_year % 100]
-      when :long, :l              ## e.g. 1999/2000 or 2019/2020
-        "%d#{sep}%d" % [@start_year, @end_year]
-      else
-        raise ArgumentError, "[Season.to_s] unsupported format >#{format}<"
-      end
-    end
-  end
-  alias_method :to_s, :to_formatted_s
-
-  def key()  to_s( :short ); end
-  alias_method :to_key,  :key
-  alias_method :name,    :key
-  alias_method :title,   :key
-
-  alias_method :inspect, :key  ## note: add inspect debug support change debug output to string!!
-
-
-
-  def to_path( format=:default )
-    case format
-    when :default, :short, :s    ## e.g. 1999-00 or 2019-20
-      to_s( :short, sep: '-' )
-    when :long, :l                ## e.g. 1999-2000 or 2019-2000
-      to_s( :long, sep: '-' )
-    when :archive, :decade, :d    ## e.g. 1990s/1999-00 or 2010s/2019-20
-      "%3d0s/%s" % [@start_year / 10, to_s( :short, sep: '-' )]
-    when :century, :c             ## e.g. 1900s/1990-00 or 2000s/2019-20
-      "%2d00s/%s" % [@start_year / 100, to_s( :short, sep: '-' )]
-    else
-      raise ArgumentError, "[Season.to_path] unsupported format >#{format}<"
-    end
-  end # method to_path
-  alias_method :directory, :to_path   ## keep "legacy" directory alias - why? why not?
-  alias_method :path,      :to_path
-
-end # class Season
-
-
-
-### note: add a convenience "shortcut" season kernel method conversion method
-##  use like Season( '2012/3' )  or such
-module Kernel
-  def Season( *args ) Season.convert( *args ); end
-end

data/lib/sports/structs/country.rb

@@ -1,26 +0,0 @@
-module Sports
-
-##
-#  note: check that shape/structure/fields/attributes match
-#            the ActiveRecord model !!!!
-
-class Country
-
-  ## note: is read-only/immutable for now - why? why not?
-  ##          add cities (array/list) - why? why not?
-  attr_reader   :key, :name, :code, :tags
-  attr_accessor :alt_names
-
-  def initialize( key: nil, name:, code:, tags: [] )
-    ## 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 = key || name.downcase.gsub( /[^a-z]/, '' )
-    @name, @code = name, code
-    @alt_names      = []
-    @tags           = tags
-  end
-
-end  # class Country
-
-end   # module Sports
-

data/lib/sports/structs/goal.rb

@@ -1,231 +0,0 @@
-
-module Sports
-
-
-## "free-standing" goal event - for import/export  in separate event / goal datafiles
-##   returned by CsvGoalParser and others
-class GoalEvent
-
-  def self.build( row )  ## rename to parse or such - why? why not?
-
-  ## split match_id
-  team_str, more_str   = row['Match'].split( '|' )
-  team1_str, team2_str = team_str.split( ' - ' )
-
-  more_str  = more_str.strip
-  team1_str = team1_str.strip
-  team2_str = team2_str.strip
-
-   # check if more_str is a date otherwise assume round
-   date_fmt = if more_str =~ /^[A-Z]{3} [0-9]{1,2}$/i  ## Apr 4
-                '%b %d'
-              elsif more_str =~ /^[A-Z]{3} [0-9]{1,2} [0-9]{4}$/i  ## Apr 4 2019
-                '%b %d %Y'
-             else
-                nil
-             end
-
-   if date_fmt
-    date  = Date.strptime( more_str, date_fmt )
-    round = nil
-   else
-    date  = nil
-    round = more_str
-   end
-
-
-    values = row['Score'].split('-')
-    values = values.map { |value| value.strip }
-    score1 = values[0].to_i
-    score2 = values[1].to_i
-
-    minute = nil
-    offset = nil
-    if m=%r{([0-9]+)
-              (?:[ ]+
-                   \+([0-9]+)
-                )?
-                ['.]
-          $}x.match( row['Minute'])
-      minute = m[1].to_i
-      offset = m[2] ? m[2].to_i : nil
-    else
-      puts "!! ERROR - unsupported minute (goal) format >#{row['Minute']}<"
-      exit 1
-    end
-
-    attributes = {
-          team1:  team1_str,
-          team2:  team2_str,
-          date:   date,
-          round:  round,
-          score1: score1,
-          score2: score2,
-          minute: minute,
-          offset: offset,
-          player: row['Player'],
-          owngoal: ['(og)', '(o.g.)'].include?( row['Extra']),
-          penalty: ['(pen)', '(pen.)'].include?( row['Extra']),
-          notes:   (row['Notes'].nil? || row['Notes'].empty?) ? nil : row['Notes']
-        }
-
-    new( **attributes )
-  end
-
-
-  ## match id
-  attr_reader  :team1,
-               :team2,
-               :round,  ## optional
-               :date   ## optional
-
-  ## main attributes
-  attr_reader :score1,
-              :score2,
-              :player,
-              :minute,
-              :offset,
-              :owngoal,
-              :penalty,
-              :notes
-
-
-  ## todo/check: or just use match.hash or such if match mapping known - why? why not?
-  def match_id
-    if round
-      "#{@team1} - #{@team2} | #{@round}"
-    else
-      "#{@team1} - #{@team2} | #{@date}"
-    end
-  end
-
-
-  def owngoal?() @owngoal==true; end
-  def penalty?() @penalty==true; end
-
-  def initialize( team1:,
-                  team2:,
-                  round:   nil,
-                  date:    nil,
-                  score1:,
-                  score2:,
-                  player:,
-                  minute:,
-                  offset:  nil,
-                  owngoal: false,
-                  penalty: false,
-                  notes:   nil
-                )
-    @team1   = team1
-    @team2   = team2
-    @round   = round
-    @date    = date
-
-    @score1  = score1
-    @score2  = score2
-    @player  = player
-    @minute  = minute
-    @offset  = offset
-    @owngoal = owngoal
-    @penalty = penalty
-    @notes   = notes
-  end
-
-
-  ## note: lets you use normalize teams or such acts like a Match struct
-  def update( **kwargs )
-    ## 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
-  end
-end  # class GoalEvent
-
-
-
-
-class Goal  ### nested (non-freestanding) inside match (match is parent)
-  def self.build( events )  ## check/todo - rename to build_from_event/row or such - why? why not?
-    ## build an array of goal structs from (csv) recs
-    recs = []
-
-    last_score1 = 0
-    last_score2 = 0
-
-    events.each do |event|
-
-      if last_score1+1 == event.score1 && last_score2 == event.score2
-        team = 1
-      elsif last_score2+1 == event.score2 && last_score1 == event.score1
-        team = 2
-      else
-        puts "!! ERROR - unexpected score advance (one goal at a time expected):"
-        puts "  #{last_score1}-#{last_score2}=> #{event.score1}-#{event.score2}"
-        exit 1
-      end
-
-      last_score1 = event.score1
-      last_score2 = event.score2
-
-
-      attributes = {
-        score1:  event.score1,
-        score2:  event.score2,
-        team:    team,
-        minute:  event.minute,
-        offset:  event.offset,
-        player:  event.player,
-        owngoal: event.owngoal,
-        penalty: event.penalty,
-        notes:   event.notes
-      }
-
-      recs << Goal.new( **attributes )
-    end
-
-    recs
-  end
-
-
-
-  attr_reader :score1,
-              :score2,
-              :team,
-              :player,
-              :minute,
-              :offset,
-              :owngoal,
-              :penalty,
-              :notes
-
-
-
-  def owngoal?() @owngoal==true; end
-  def penalty?() @penalty==true; end
-  def team1?()   @team == 1; end
-  def team2?()   @team == 2; end
-
-  def initialize( score1:,
-                  score2:,
-                  team:,
-                  player:,
-                  minute:,
-                  offset:  nil,
-                  owngoal: false,
-                  penalty: false,
-                  notes:   nil
-                )
-    @score1  = score1
-    @score2  = score2
-    @team    = team     # 1 or 2
-    @player  = player
-    @minute  = minute
-    @offset  = offset
-    @owngoal = owngoal
-    @penalty = penalty
-    @notes   = notes
-  end
-end # class Goal
-
-
-end # module Sports
-

data/lib/sports/structs/group.rb

@@ -1,16 +0,0 @@
-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/sports/structs/league.rb

@@ -1,35 +0,0 @@
-
-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/sports/structs/match.rb

@@ -1,180 +0,0 @@
-
-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
-
-