sportdb-structs 0.1.0

data/lib/sportdb/structs/match_status_parser.rb

@@ -0,0 +1,90 @@
+#####################
+# helpers for parsing & finding match status e.g.
+#    - cancelled / canceled
+#    - awarded
+#    - abandoned
+#    - replay
+#    etc.
+
+
+module SportDb
+
+
+  ### todo/fix: move Status inside Match struct - why? why not?
+
+  class Status
+# note: use a class as an "enum"-like namespace for now - why? why not?
+#   move class into Match e.g. Match::Status  - why? why not?
+    CANCELLED = 'CANCELLED'   # canceled (US spelling), cancelled (UK spelling) - what to use?
+    AWARDED   = 'AWARDED'
+    POSTPONED = 'POSTPONED'
+    ABANDONED = 'ABANDONED'
+    REPLAY    = 'REPLAY'
+  end # class Status
+
+
+
+  class StatusParser
+
+    def self.parse( str )
+      ## note: returns nil if no match found
+      ## note: english usage - cancelled (in UK), canceled (in US)
+      if str =~ /^(cancelled|
+                   canceled|
+                   can\.
+                  )/xi
+        Status::CANCELLED
+      elsif str =~ /^(awarded|
+                       awd\.
+                      )/xi
+        Status::AWARDED
+      elsif str =~ /^(postponed
+                      )/xi
+        Status::POSTPONED
+      elsif str =~ /^(abandoned|
+                       abd\.
+                      )/xi
+        Status::ABANDONED
+      elsif str =~ /^(replay
+                      )/xi
+        Status::REPLAY
+      else
+        # no match
+        nil
+      end
+    end
+
+
+    RUN_RE = /\[
+                 (?<text>[^\]]+)
+               \]
+             /x
+    def self.find!( line )
+      ## for now check all "protected" text run blocks e.g. []
+      ##  puts "line: >#{line}<"
+
+      status = nil
+
+      str = line
+      while m = str.match( RUN_RE )
+        str = m.post_match  ## keep on processing rest of line/str (a.k.a. post match string)
+
+        ## check for status match
+        match_str = m[0]  ## keep a copy of the match string (for later sub)
+        text = m[:text].strip
+        ## puts "  text: >#{text}<"
+
+        status = parse( text )
+
+        if status
+           line.sub!( match_str, "[STATUS.#{status}]" )
+           break
+        end
+      end  # while match
+
+      status
+    end # method find!
+  end # class StatusParser
+
+end # module SportDb
+

data/lib/sportdb/structs/name_helper.rb

@@ -0,0 +1,87 @@
+
+module SportDb
+  module NameHelper
+
+
+  ## note: allow placeholder years to e.g. (-___) or (-????)
+  ##    for marking missing (to be filled in) years
+  ##  e.g. (1887-1911), (-2013),
+  ##      (1946-2001, 2013-) etc.
+  ##  todo/check: make more strict  e.g. only accept 4-digit years? - why? why not?
+  YEAR_RE =  %r{\(
+                  [0-9, ?_-]+?     # note: non-greedy (minimum/first) match
+              \)}x
+
+  def strip_year( name )
+    ## check for year(s) e.g. (1887-1911), (-2013),
+    ##                        (1946-2001, 2013-) etc.
+    ##  todo/check: only sub once (not global) - why? why not?
+    name.gsub( YEAR_RE, '' ).strip
+  end
+
+  def has_year?( name ) name =~ YEAR_RE; end
+
+
+  LANG_RE =  %r{\[
+                [a-z]{1,2}    # note also allow single-letter [a] or [d] or [e] - why? why not?
+                \]}x
+  def strip_lang( name )
+     name.gsub( LANG_RE, '' ).strip
+  end
+
+  def has_lang?( name ) name =~ LANG_RE; end
+
+
+  def sanitize( name )
+    ## check for year(s) e.g. (1887-1911), (-2013),
+    ##                        (1946-2001,2013-) etc.
+    name = strip_year( name )
+    ## check lang codes e.g. [en], [fr], etc.
+    name = strip_lang( name )
+    name
+  end
+
+
+  ## note: also add (),’,−  etc. e.g.
+  ##   Estudiantes (LP) => Estudiantes LP
+  ##   Saint Patrick’s Athletic FC => Saint Patricks Athletic FC
+  ##   Myllykosken Pallo −47 => Myllykosken Pallo 47
+  ##
+  ##  add & too!!
+  ##   e.g. Brighton & Hove Albion => Brighton Hove Albion  -- and others in England
+
+  NORM_RE =  %r{
+                    [.'’º/()&_−-]
+                  }x   # note: in [] dash (-) if last doesn't need to get escaped
+  ## note: remove all dots (.), dash (-), ', º, /, etc.
+  #   .  U+002E (46) - FULL STOP
+  #   '  U+0027 (39) - APOSTROPHE
+  #   ’  U+2019 (8217) - RIGHT SINGLE QUOTATION MARK
+  #   º  U+00BA (186) - MASCULINE ORDINAL INDICATOR
+  #   /  U+002F (47) - SOLIDUS
+  #   (  U+0028 (40) - LEFT PARENTHESIS
+  #   )  U+0029 (41) - RIGHT PARENTHESIS
+  #   −  U+2212 (8722) - MINUS SIGN
+  #   -  U+002D (45) - HYPHEN-MINUS
+
+  ##         for norm(alizing) names
+  def strip_norm( name )
+    name.gsub( NORM_RE, '' )
+  end
+
+  def normalize( name )
+    # note: do NOT call sanitize here (keep normalize "atomic" for reuse)
+    name = strip_norm( name )
+    name = name.gsub( ' ', '' )  # note: also remove all spaces!!!
+
+    ## todo/check: use our own downcase - why? why not?
+    name = downcase_i18n( name )     ## do NOT care about upper and lowercase for now
+    name
+  end
+
+
+  def variants( name )  Variant.find( name ); end
+
+  end  # module NameHelper
+end   # module SportDb
+

data/lib/sportdb/structs/season.rb

@@ -0,0 +1,199 @@
+
+### 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/sportdb/structs/structs/country.rb

@@ -0,0 +1,26 @@
+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/sportdb/structs/structs/goal.rb

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