sportdb-formats 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a60a673f546001d9e4314f6e958428f0f1bec3e
-  data.tar.gz: 453cfbf74d9afaebd2e06a51d2ac68b698f09559
+  metadata.gz: 421d04b4b20f49a37bb1a31161bb4ab7b5df3113
+  data.tar.gz: e533ef2bb8dbb3c1053416c98ede4c9d20c42546
 SHA512:
-  metadata.gz: 73282d87f64ec9c625dc6b0c3cce958b1a6b64fdb0f07fdb8bde5b13e5f7b1e00c932936c9c16094d0de722ce754e6cb1bc0ecb84469125d587892505b1d600e
-  data.tar.gz: 9d2575ea54a05c38582fe1354b520042be013747dc21db283cf5d5930e67976aadec9901be090fa89024917fdc6f3caaeb3b2819a807a7bb1015f118a48468e5
+  metadata.gz: 6256ca94b85f87865a44b4f892273cb4c2c9f17e7847e765cd3c73f408a005907181e202ec201498fd3214a603aed6af33b4ecbcf4e2af43cca851f7b1ac9a09
+  data.tar.gz: 750122be629a4b902356d845658cfcccbb0403e75e3f713e1ff4bd0da4aefb6b2355bc828aecb8e21d20addb5bfb9c1924df58830eb85e4743aa340c560924df

data/Manifest.txt

@@ -4,12 +4,16 @@ README.md
 Rakefile
 lib/sportdb/formats.rb
 lib/sportdb/formats/datafile.rb
+lib/sportdb/formats/goals.rb
 lib/sportdb/formats/outline_reader.rb
+lib/sportdb/formats/scores.rb
 lib/sportdb/formats/season_utils.rb
 lib/sportdb/formats/version.rb
 test/helper.rb
 test/test_csv_reader.rb
 test/test_datafile.rb
 test/test_datafile_match.rb
+test/test_goals.rb
 test/test_outline_reader.rb
+test/test_scores.rb
 test/test_season_utils.rb

data/Rakefile

@@ -21,7 +21,7 @@ Hoe.spec 'sportdb-formats' do
 
   self.extra_deps = [
     ['alphabets',     '>= 0.1.0'],
-    ['date-formats',  '>= 0.2.1'],
+    ['date-formats',  '>= 0.2.4'],
     ['csvreader',     '>= 1.2.4'],
     ['sportdb-langs', '>= 0.0.1'],
   ]

data/lib/sportdb/formats/goals.rb

@@ -0,0 +1,277 @@
+# encoding: utf-8
+
+module SportDb
+
+
+
+class GoalsPlayerStruct
+  ##
+  # note: player with own goal (o.g) gets listed on other team
+  #  (thus, player might have two entries if also scored for its own team)
+  #
+  attr_accessor :name
+  attr_accessor :minutes   # ary of minutes e.g. 30', 45+2', 72'
+
+  def initialize
+    @minutes = []
+  end
+end
+
+
+class GoalsMinuteStruct
+  attr_accessor :minute, :offset
+  attr_accessor :penalty, :owngoal    # flags
+
+  def initialize
+    @offset  = 0
+    @penalty = false
+    @owngoal = false
+  end
+end
+
+
+class GoalStruct
+  ######
+  # flat struct for goals - one entry per goals
+  attr_accessor :name
+  attr_accessor :team   #  1 or 2 ? check/todo: add team1 or team2 flag?
+  attr_accessor :minute, :offset
+  attr_accessor :penalty, :owngoal
+  attr_accessor :score1, :score2  # gets calculated
+
+  ## add pos  for sequence number? e.g. 1,2,3,4  (1st goald, 2nd goal, etc.) ???
+
+
+  def initialize( **kwargs )    ## add/allow quick and dirty quick init with keywords
+    if kwargs.empty?
+      # do nothing
+    else
+      kwargs.each do |key,value|
+        send( "#{key}=", value )
+      end
+    end
+  end
+
+  def ==(o)
+    o.class == self.class && o.state == state
+  end
+
+  def state
+    [@name, @team, @minute, @offset, @penalty, @owngoal, @score1, @score2]
+  end
+end
+
+
+
+# todo: find a better name? to avoid confusing w/ GoalsParser? use MatchGoalsParser or similar?
+class GoalsFinder
+  include LogUtils::Logging
+
+
+  def initialize
+    # nothing here for now
+  end
+
+  def find!( line, opts={} )
+    # remove end-of-line comments
+    line = line.sub( /#.*$/ ) do |_|
+             logger.debug "   cutting off end of line comment - >>#{$&}<<"
+             ''
+           end
+
+    # remove [] if presents e.g. [Neymar 12']
+    line = line.gsub( /[\[\]]/, '' )
+    # remove (single match) if line starts w/ - (allow spaces)  e.g. [-;Neymar 12'] or [ - ;Neymar 12']
+    line = line.sub( /^[ ]*-[ ]*/, '' )
+
+    # split into left hand side (lhs) for team1 and
+    #            right hand side (rhs) for team2
+
+    values = line.split( ';' )
+
+    # note: allow empty right hand side (e.g. team2 did NOT score any goals e.g. 3-0 etc.)
+    lhs = values[0]
+    rhs = values[1]
+
+    lhs = lhs.strip   unless lhs.nil?
+    rhs = rhs.strip   unless rhs.nil?
+
+    parser = GoalsParser.new
+    ## todo/check: only call if not nil?
+
+    logger.debug "  lhs (team1): >#{lhs}<"
+    lhs_data = parser.parse!( lhs )
+    pp lhs_data
+
+    logger.debug "  rhs (team2): >#{rhs}<"
+    rhs_data = parser.parse!( rhs )
+    pp rhs_data
+
+    ### merge into flat goal structs
+    goals = []
+    lhs_data.each do |player|
+      player.minutes.each do |minute|
+        goal = GoalStruct.new
+        goal.name    = player.name
+        goal.team    = 1
+        goal.minute  = minute.minute
+        goal.offset  = minute.offset
+        goal.penalty = minute.penalty
+        goal.owngoal = minute.owngoal
+        goals << goal
+      end
+    end
+
+    rhs_data.each do |player|
+      player.minutes.each do |minute|
+        goal = GoalStruct.new
+        goal.name    = player.name
+        goal.team    = 2
+        goal.minute  = minute.minute
+        goal.offset  = minute.offset
+        goal.penalty = minute.penalty
+        goal.owngoal = minute.owngoal
+        goals << goal
+      end
+    end
+
+
+    # sort by minute + offset
+    goals = goals.sort do |l,r|
+      res = l.minute <=> r.minute
+      if res == 0
+        res =  l.offset <=> r.offset  # pass 2: sort by offset
+      end
+      res
+    end
+
+    ## calc score1,score2
+    score1 = 0
+    score2 = 0
+    goals.each do |goal|
+      if goal.team == 1
+        score1 += 1
+      elsif goal.team == 2
+        score2 += 1
+      else
+        # todo: should not happen: issue warning
+      end
+      goal.score1 = score1
+      goal.score2 = score2
+    end
+
+    logger.debug "  #{goals.size} goals:"
+    pp goals
+
+    goals
+  end
+
+end  # class GoalsFinder
+
+
+class GoalsParser
+  include LogUtils::Logging
+
+
+  # note: use ^ for start of string only!!!
+  # - for now slurp everything up to digits (inlc. spaces - use strip to remove)
+  # todo/check: use/rename to NAME_UNTIL_REGEX ??? ( add lookahead for spaces?)
+  NAME_REGEX = /^
+                [^0-9]+
+               /x
+
+
+  # todo/check: change to MINUTE_REGEX ??
+  # add MINUTE_SKIP_REGEX or MINUTE_SEP_REGEX /^[ ,]+/
+  # todo/fix:  split out  penalty and owngoal flag in PATTERN constant for reuse
+  MINUTES_REGEX = /^      # note: use ^ for start of string only!!!
+                    (?<minute>[0-9]{1,3})
+                    (?:\+
+                      (?<offset>[1-9]{1})
+                    )?
+                    '
+                    (?:[ ]*
+                      \(
+                      (?<type>P|pen\.|o\.g\.)
+                      \)
+                    )?
+                  /x
+
+
+
+  def initialize
+    # nothing here for now
+  end
+
+  def parse!( line, opts={} )
+
+    ## for now assume
+    ##    everything up-to  0-9 and , and () is part of player name
+
+    ## try parsing lhs
+    ##  todo: check for  empty -    remove (make it same as empty string)
+
+    players = []
+
+    name = get_player_name!( line )
+    while name
+      logger.debug "  found player name >#{name}< - remaining >#{line}<"
+
+      player = GoalsPlayerStruct.new
+      player.name = name
+
+      minute_hash = get_minute_hash!( line )
+      while minute_hash
+        logger.debug "  found minutes >#{minute_hash.inspect}< - remaining >#{line}<"
+
+        minute = GoalsMinuteStruct.new
+        minute.minute = minute_hash[:minute].to_i
+        minute.offset = minute_hash[:offset].to_i  if minute_hash[:offset]
+        if minute_hash[:type]
+          minute.owngoal = true  if minute_hash[:type] =~ /o\.g\./
+          minute.penalty = true  if minute_hash[:type] =~ /P|pen\./
+        end
+        player.minutes << minute
+
+        # remove commas and spaces (note: use ^ for start of string only!!!)
+        line.sub!( /^[ ,]+/, '' )
+        minute_hash = get_minute_hash!( line )
+      end
+
+      players << player
+      name = get_player_name!( line )
+    end
+
+    players
+  end   # method parse!
+
+private
+  def get_player_name!( line )
+    m = NAME_REGEX.match( line )
+    if m
+      ## remove from line
+      line.slice!( 0...m[0].length )
+      m[0].strip    # remove leading and trailing spaces
+    else
+      nil
+    end
+  end
+
+  def get_minute_hash!( line )
+    m = MINUTES_REGEX.match( line ) # note: use ^ for start of string only!!!
+    if m
+      h = {}
+      # - note: do NOT forget to turn name into symbol for lookup in new hash (name.to_sym)
+      m.names.each { |n| h[n.to_sym] = m[n] } # or use match_data.names.zip( match_data.captures ) - more cryptic but "elegant"??
+
+      ## remove matched string from line
+      line.slice!( 0...m[0].length )
+      h
+    else
+      nil
+    end
+  end
+
+end # class GoalsParser
+
+end # module SportDb

data/lib/sportdb/formats/scores.rb

@@ -0,0 +1,241 @@
+# encoding: utf-8
+
+module SportDb
+
+class ScoresFinder
+
+  include LogUtils::Logging
+
+
+  ## e.g. 3-4 pen. 2-2 a.e.t. (1-1, 1-1)
+  EN__P_ET_FT_HT__REGEX = /\b
+             (?<score1p>\d{1,2})
+                   -
+             (?<score2p>\d{1,2})
+                 \s*                # allow optional spaces
+             (?:p|pen\.?|pso)       # e.g. pen, pen., PSO, p etc.
+                 \s*                # allow optional spaces
+             (?<score1et>\d{1,2})
+                   -
+             (?<score2et>\d{1,2})
+                 \s*                # allow optional spaces
+             (?:aet|a\.e\.t\.)
+                 \s*                # allow optional spaces
+                 \(
+            (?<score1>\d{1,2})
+                 -
+            (?<score2>\d{1,2})
+                \s*
+                ,
+                \s*
+            (?<score1i>\d{1,2})
+               -
+            (?<score2i>\d{1,2})
+               \)
+           (?=[\s\]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
+                             ## note: \b works only after non-alphanum e.g. )
+
+
+  ## e.g. 2-1 a.e.t. (1-1, 0-0)
+  EN__ET_FT_HT__REGEX = /\b
+             (?<score1et>\d{1,2})
+                   -
+             (?<score2et>\d{1,2})
+                 \s*                # allow optional spaces
+             (?:aet|a\.e\.t\.)
+                 \s*                # allow optional spaces
+                 \(
+            (?<score1>\d{1,2})
+                 -
+            (?<score2>\d{1,2})
+                \s*
+                ,
+                \s*
+            (?<score1i>\d{1,2})
+               -
+            (?<score2i>\d{1,2})
+               \)
+           (?=[\s\]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
+                             ## note: \b works only after non-alphanum e.g. )
+
+
+  ## e.g. 2-1 (1-1)
+  EN__FT_HT__REGEX = /\b
+            (?<score1>\d{1,2})
+               -
+            (?<score2>\d{1,2})
+             \s*
+             \(
+            (?<score1i>\d{1,2})
+               -
+            (?<score2i>\d{1,2})
+               \)
+           (?=[\s\]]|$)/x    ## todo/check:  remove loakahead assertion here - why require space?
+                             ## note: \b works only after non-alphanum e.g. )
+
+
+
+###################
+# more
+
+  # e.g. 1:2 or 0:2 or 3:3  or
+  #      1-1 or 0-2 or 3-3  or
+  #      1x1 or 1X1 or 0x2 or 3x3   -- used in Brazil / Portugal
+  FT_REGEX = /\b
+            (?<score1>\d{1,2})
+               [:\-xX]
+            (?<score2>\d{1,2})
+           \b/x
+
+
+  # e.g. 1:2nV  => after extra time a.e.t
+
+  # note: possible ending w/ . -> thus cannot use /b will not work w/ .; use zero look-ahead
+  ET_REGEX = /\b
+               (?<score1>\d{1,2})
+                  [:\-xX]
+               (?<score2>\d{1,2})
+                  \s?                # allow optional space
+                (?:nv|n\.v\.|aet|a\.e\.t\.)        # allow optional . e.g. nV or n.V.
+               (?=[\s\)\]]|$)/xi
+
+  ## todo: add/allow english markers e.g. pen or p  ??
+
+  # e.g. 5:4iE  => penalty / after penalty a.p
+
+
+  # note: possible ending w/ . -> thus cannot use /b will not work w/ .; use zero look-ahead
+  P_REGEX = /\b
+              (?<score1>\d{1,2})
+                  [:\-xX]
+              (?<score2>\d{1,2})
+                  \s?                # allow optional space
+                (?:iE|i\.E\.|p|pen|PSO)       # allow optional . e.g. iE or i.E.
+              (?=[\s\)\]]|$)/xi
+
+
+  ## todo: allow all-in-one "literal form a la kicker" e.g.
+  #  2:2 (1:1, 1:0) n.V. 5:1 i.E.
+
+  def initialize
+    # nothing here for now
+  end
+
+  def find!( line, opts={} )
+
+    ### fix: add and match all-in-one literal first, followed by
+
+    # note: always call after find_dates !!!
+    #  scores match date-like patterns!!  e.g. 10-11  or 10:00 etc.
+    #   -- note: score might have two digits too
+
+    ### fix: depending on language allow 1:1 or 1-1
+    ##   do NOT allow mix and match
+    ##  e.g. default to en is  1-1
+    ##    de is 1:1 etc.
+
+
+    # extract score from line
+    # and return it
+    # note: side effect - removes date from line string
+
+
+    score1i   = nil    # half time (ht) scores
+    score2i   = nil
+
+    score1   = nil    # full time (ft) scores
+    score2   = nil
+
+    score1et = nil    # extra time (et) scores
+    score2et = nil
+
+    score1p  = nil   # penalty (p) scores
+    score2p  = nil
+
+
+    if (md = EN__P_ET_FT_HT__REGEX.match( line ))
+      score1i   = md[:score1i].to_i
+      score2i   = md[:score2i].to_i
+      score1    = md[:score1].to_i
+      score2    = md[:score2].to_i
+      score1et  = md[:score1et].to_i
+      score2et  = md[:score2et].to_i
+      score1p   = md[:score1p].to_i
+      score2p   = md[:score2p].to_i
+
+      logger.debug "   score.en__p_et_ft_ht: >#{score1p}-#{score2p} pen. #{score1et}-#{score2et} a.e.t. (#{score1}-#{score2}, #{score1i}-#{score2i})<"
+
+      line.sub!( md[0], '[SCORES.EN__P_ET_FT_HT]' )
+
+    elsif (md = EN__ET_FT_HT__REGEX.match( line ))
+      score1i   = md[:score1i].to_i
+      score2i   = md[:score2i].to_i
+      score1    = md[:score1].to_i
+      score2    = md[:score2].to_i
+      score1et  = md[:score1et].to_i
+      score2et  = md[:score2et].to_i
+
+      logger.debug "   score.en__et_ft_ht: >#{score1et}-#{score2et} a.e.t. (#{score1}-#{score2}, #{score1i}-#{score2i})<"
+
+      line.sub!( md[0], '[SCORES.EN__ET_FT_HT]' )
+
+    elsif (md = EN__FT_HT__REGEX.match( line ))
+      score1i = md[:score1i].to_i
+      score2i = md[:score2i].to_i
+      score1  = md[:score1].to_i
+      score2  = md[:score2].to_i
+
+      logger.debug "   score.en__ft_ht: >#{score1}-#{score2} (#{score1i}-#{score2i})<"
+
+      line.sub!( md[0], '[SCORES.EN__FT_HT]' )
+    else
+      #######################################################
+      ## try "standard" generic patterns for fallbacks
+
+      if (md = ET_REGEX.match( line ))
+        score1et = md[:score1].to_i
+        score2et = md[:score2].to_i
+
+        logger.debug "   score.et: >#{score1et}-#{score2et}<"
+
+        line.sub!( md[0], '[SCORE.ET]' )
+      end
+
+      if (md = P_REGEX.match( line ))
+        score1p = md[:score1].to_i
+        score2p = md[:score2].to_i
+
+        logger.debug "   score.p: >#{score1p}-#{score2p}<"
+
+        line.sub!( md[0], '[SCORE.P]' )
+      end
+
+      ## let full time (ft) standard regex go last - has no marker
+
+      if (md = FT_REGEX.match( line ))
+        score1 = md[:score1].to_i
+        score2 = md[:score2].to_i
+
+        logger.debug "   score: >#{score1}-#{score2}<"
+
+        line.sub!( md[0], '[SCORE]' )
+      end
+    end
+
+    ## todo: how to handle game w/o extra time
+    #   but w/ optional penalty ???  e.g. used in copa liberatores, for example
+    #    retrun 0,0 or nil,nil for extra time score ?? or -1, -1 ??
+    #    for now use nil,nil
+
+    scores = []
+    scores += [score1i, score2i]     if score1p || score2p || score1et || score2et || score1 || score2 || score1i || score2i
+    scores += [score1, score2]       if score1p || score2p || score1et || score2et || score1 || score2
+    scores += [score1et, score2et]   if score1p || score2p || score1et || score2et
+    scores += [score1p,  score2p]    if score1p || score2p
+
+    scores
+  end
+
+end # class ScoresFinder
+
+end # module SportDb

data/lib/sportdb/formats/version.rb

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

data/lib/sportdb/formats.rb

@@ -27,6 +27,10 @@ require 'sportdb/formats/datafile'
 require 'sportdb/formats/season_utils'
 
 
+require 'sportdb/formats/scores'
+require 'sportdb/formats/goals'
+
+
 ## let's put test configuration in its own namespace / module
 module SportDb
 class Test    ## todo/check: works with module too? use a module - why? why not?

data/test/test_goals.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_goals.rb
+
+
+require 'helper'
+
+class TestGoals < MiniTest::Test
+
+
+  def test_world_cup_1930
+     line = "   [L. Laurent 19' Langiller 40' Maschinot 43', 87'; Carreño 70']"
+
+     assert_equal [
+       SportDb::GoalStruct.new(
+         name:   'L. Laurent',
+         minute:  19,
+         offset:  0,
+         owngoal: false,
+         penalty: false,
+         score1:  1,
+         score2:  0,
+         team:    1),
+       SportDb::GoalStruct.new(
+         name:   'Langiller',
+         minute:  40,
+         offset:  0,
+         owngoal: false,
+         penalty: false,
+         score1:  2,
+         score2:  0,
+         team:    1),
+      SportDb::GoalStruct.new(
+         name:   'Maschinot',
+         minute:  43,
+         offset:  0,
+         owngoal: false,
+         penalty: false,
+         score1:  3,
+         score2:  0,
+         team:    1),
+      SportDb::GoalStruct.new(
+         name:   'Carreño',
+         minute:  70,
+         offset:  0,
+         owngoal: false,
+         penalty: false,
+         score1:  3,
+         score2:  1,
+         team:    2),
+      SportDb::GoalStruct.new(
+         name:   'Maschinot',
+         minute:  87,
+         offset:  0,
+         owngoal: false,
+         penalty: false,
+         score1:  4,
+         score2:  1,
+         team:    1)], parse_goals( line )
+
+
+     line = "     [Monti 81'] "
+     assert_equal [
+       SportDb::GoalStruct.new(
+         name:   'Monti',
+         minute:  81,
+         offset:  0,
+         owngoal: false,
+         penalty: false,
+         score1:  1,
+         score2:  0,
+         team:    1)], parse_goals( line )
+
+
+    line = "     [Vidal 3', 65' M. Rosas 51' (o.g.)]"
+    assert_equal [
+      SportDb::GoalStruct.new(
+        name:   'Vidal',
+        minute:  3,
+        offset:  0,
+        owngoal: false,
+        penalty: false,
+        score1:  1,
+        score2:  0,
+        team:    1),
+      SportDb::GoalStruct.new(
+        name:   'M. Rosas',
+        minute:  51,
+        offset:  0,
+        owngoal: true,
+        penalty: false,
+        score1:  2,
+        score2:  0,
+        team:    1),
+      SportDb::GoalStruct.new(
+        name:   'Vidal',
+        minute:  65,
+        offset:  0,
+        owngoal: false,
+        penalty: false,
+        score1:  3,
+        score2:  0,
+        team:    1)], parse_goals( line )
+  end
+
+ private
+   def parse_goals( line )
+     SportDb::GoalsFinder.new.find!( line )
+   end
+
+end # class TestGoals

data/test/test_scores.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_scores.rb
+
+
+require 'helper'
+
+class TestScores < MiniTest::Test
+
+
+  def test_scores
+    data = [
+     [ '10:0',  [nil,nil,10,0]],
+     [ '1:22',  [nil,nil,1,22]],
+     [ '1-22',  [nil,nil,1,22]],
+     [ '1x22',  [nil,nil,1,22]],
+     [ '1X22',  [nil,nil,1,22]],
+
+
+     ## do not support three digits
+     [ '1-222', []],
+     [ '111-0', []],
+     [ '1:222', []],
+     [ '111:0', []],
+     [ '111x0', []],
+     [ '111X0', []],
+
+     ## penality only
+     [ '3-4iE',    [nil,nil,nil,nil,nil,nil,3,4]],
+     [ '3:4iE',    [nil,nil,nil,nil,nil,nil,3,4]],
+     [ '3:4 iE',   [nil,nil,nil,nil,nil,nil,3,4]],
+     [ '3:4 i.E.', [nil,nil,nil,nil,nil,nil,3,4]],
+     [ '3-4 pen',  [nil,nil,nil,nil,nil,nil,3,4]],
+     [ '3-4 PSO',  [nil,nil,nil,nil,nil,nil,3,4]],   # PSO  => penalty shotout
+     [ '3-4p',     [nil,nil,nil,nil,nil,nil,3,4]],
+     [ '3-4 p',    [nil,nil,nil,nil,nil,nil,3,4]],
+
+     ## extra time only - allow ?? why not ?? only allow penalty w/ missing extra time?
+     ## todo/fix: issue warning or error in parser!!!
+     [ '3-4nV',      [nil,nil,nil,nil,3,4]],
+     [ '3:4nV',      [nil,nil,nil,nil,3,4]],
+     [ '3-4 aet',    [nil,nil,nil,nil,3,4]],
+     [ '3-4 a.e.t.', [nil,nil,nil,nil,3,4]],
+
+     [ '3:4nV 1:1',    [nil,nil,1,1,3,4]],
+     [ '1:1 3:4nV',    [nil,nil,1,1,3,4]],
+     [ '3:4 nV 1:1',   [nil,nil,1,1,3,4]],
+     [ '3:4 n.V. 1:1', [nil,nil,1,1,3,4]],
+
+     [ '3:4iE 1:1', [nil,nil,1,1,nil,nil,3,4]],
+     [ '1:1 3:4iE', [nil,nil,1,1,nil,nil,3,4]],
+
+     [ '1:1 2:2nV 3:4iE',       [nil,nil,1,1,2,2,3,4]],
+     [ '3:4iE 2:2nV 1:1',       [nil,nil,1,1,2,2,3,4]],
+     [ '3:4 i.E. 2:2 n.V. 1:1', [nil,nil,1,1,2,2,3,4]],
+     [ '3-4p 2-2aet 1-1',       [nil,nil,1,1,2,2,3,4]],
+     [ '3-4 pen 2-2 aet 1-1',   [nil,nil,1,1,2,2,3,4]],
+
+     #####################################################
+     ## check new all-in-one english (en) formats / patterns
+     [ '2-1 (1-1)', [1,1,2,1]],
+     [ '2-1 a.e.t. (1-1, 0-0)', [0,0,1,1,2,1]],
+     [ '2-1aet (1-1, 0-0)', [0,0,1,1,2,1]],
+     [ '2-1 A.E.T. (1-1, 0-0)', [0,0,1,1,2,1]],
+     [ '2-1AET (1-1, 0-0)', [0,0,1,1,2,1]],
+     [ '3-4 pen. 2-2 a.e.t. (1-1, 1-1)', [1,1,1,1,2,2,3,4]],
+     [ '3-4 pen 2-2 a.e.t. (1-1, 1-1)', [1,1,1,1,2,2,3,4]],
+     [ '3-4 pen 2-2 a.e.t. (1-1, 1-1)', [1,1,1,1,2,2,3,4]],
+     [ '3-4p 2-2aet (1-1, 1-1)', [1,1,1,1,2,2,3,4]],
+     [ '3-4PSO 2-2AET (1-1, 1-1)', [1,1,1,1,2,2,3,4]],
+    ]
+
+    assert_scores( data )
+  end
+
+private
+  def assert_scores( data )
+    data.each do |rec|
+      line = rec[0]
+      exp  = rec[1]
+
+      assert_equal exp, parse_scores( line )
+    end
+  end
+
+  def parse_scores( line )
+     finder = SportDb::ScoresFinder.new
+     finder.find!( line )
+  end
+
+end # class TestScores

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sportdb-formats
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-01 00:00:00.000000000 Z
+date: 2019-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: alphabets
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.4
 - !ruby/object:Gem::Dependency
   name: csvreader
   requirement: !ruby/object:Gem::Requirement
@@ -109,14 +109,18 @@ files:
 - Rakefile
 - lib/sportdb/formats.rb
 - lib/sportdb/formats/datafile.rb
+- lib/sportdb/formats/goals.rb
 - lib/sportdb/formats/outline_reader.rb
+- lib/sportdb/formats/scores.rb
 - lib/sportdb/formats/season_utils.rb
 - lib/sportdb/formats/version.rb
 - test/helper.rb
 - test/test_csv_reader.rb
 - test/test_datafile.rb
 - test/test_datafile_match.rb
+- test/test_goals.rb
 - test/test_outline_reader.rb
+- test/test_scores.rb
 - test/test_season_utils.rb
 homepage: https://github.com/sportdb/sport.db
 licenses: