sports 0.1.0 → 0.1.1

data/lib/sports/match_status_parser.rb

@@ -1,90 +0,0 @@
-#####################
-# 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/sports/name_helper.rb

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