score-formats 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ce70736d26500e8d3866ae96a2f75e6ce8c1725
+  data.tar.gz: 16e29461a44bb4c232039b82f38d805596b47acf
+SHA512:
+  metadata.gz: 28ed77625082a2f1b29713b03cf92354df0799c8b0189f5e40e4ccddbad34cb6e14b286b580adee97304cb3b84e8c14064dd26c33efcfea80e94e4caa7354d6e
+  data.tar.gz: bf023b724232b5ca987615d223c8d8aef928a3afcf7b9807e1f1b9167fbabfc2a80d78404220cb5de6633585be885ea5e9f05c0770d28da59a1cb89d827b63b7

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2020-08-17
+
+* Everything is new. First release.

data/Manifest.txt

@@ -0,0 +1,13 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/score-formats.rb
+lib/score-formats/formats.rb
+lib/score-formats/parser.rb
+lib/score-formats/score.rb
+lib/score-formats/version.rb
+lib/score/formats.rb
+test/helper.rb
+test/test_formats.rb
+test/test_score.rb

data/README.md

@@ -0,0 +1,29 @@
+#  score-formats - read / parse and print sports match scores (incl. half time, full time, extra time, penalties and more)
+
+
+* home  :: [github.com/sportdb/sport.db](https://github.com/sportdb/sport.db)
+* bugs  :: [github.com/sportdb/sport.db/issues](https://github.com/sportdb/sport.db/issues)
+* gem   :: [rubygems.org/gems/score-formats](https://rubygems.org/gems/score-formats)
+* rdoc  :: [rubydoc.info/gems/score-formats](http://rubydoc.info/gems/score-formats)
+* forum :: [opensport](http://groups.google.com/group/opensport)
+
+
+## Usage
+
+
+to be done
+
+
+
+
+## License
+
+The `score-formats` scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+
+## Questions? Comments?
+
+Send them along to the
+[Open Sports & Friends Forum/Mailing List](http://groups.google.com/group/opensport).
+Thanks!

data/Rakefile

@@ -0,0 +1,27 @@
+require 'hoe'
+require './lib/score-formats/version.rb'
+
+Hoe.spec 'score-formats' do
+
+  self.version = ScoreFormats::VERSION
+
+  self.summary = "score-formats - read / parse and print sports match scores (incl. half time, full time, extra time, penalties and more)"
+  self.description = summary
+
+  self.urls = ['https://github.com/sportdb/sport.db']
+
+  self.author = 'Gerald Bauer'
+  self.email = 'opensport@googlegroups.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.licenses = ['Public Domain']
+
+  self.extra_deps = []
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.2.2'
+  }
+end

data/lib/score-formats.rb

@@ -0,0 +1,72 @@
+require 'pp'
+require 'date'
+require 'time'
+
+
+###
+# our own code
+require 'score-formats/version' # let version always go first
+
+## todo/fix: make logging class configurable - lets you use logutils etc.
+module ScoreFormats
+  module Logging
+    def logger() @logger ||= Logger.new; end
+
+    class Logger   ## for now use quick "dummy" logger to
+      def debug( msg ) puts "[debug] #{msg}"; end
+    end # class Logger
+  end  # module Logging
+end # module ScoreFormats
+
+
+
+require 'score-formats/score'
+require 'score-formats/formats'
+require 'score-formats/parser'
+
+
+
+module ScoreFormats
+  def self.lang
+    @@lang ||= :en            ## defaults to english (:en)
+  end
+  def self.lang=( value )
+    @@lang = value.to_sym    ## note: make sure lang is always a symbol for now (NOT a string)
+    @@lang      ## todo/check: remove  =() method always returns passed in value? double check
+  end
+
+  def self.parser( lang: )  ## find parser
+    lang = lang.to_sym  ## note: make sure lang is always a symbol for now (NOT a string)
+
+    ## note: cache all "built-in" lang versions (e.g. formats == nil)
+    @@parser ||= {}
+    parser = @@parser[ lang ] ||= ScoreParser.new( lang: lang )
+  end
+
+  def self.parse( line, lang: ScoreFormats.lang )
+    parser( lang: lang ).parse( line )
+  end
+
+  def self.find!( line, lang: ScoreFormats.lang )
+    parser( lang: lang ).find!( line )
+  end
+end
+
+
+
+##
+# add more convenience / shortcut helpers / named ctors to score class itself
+
+class Score
+  def self.parse( line, lang: ScoreFormats.lang )
+    ScoreFormats.parse( line, lang: lang )
+  end
+
+  def self.find!( line, lang: ScoreFormats.lang )
+    ScoreFormats.find!( line, lang: lang )
+  end
+end
+
+
+
+puts ScoreFormats.banner   # say hello

data/lib/score-formats/formats.rb

@@ -0,0 +1,239 @@
+
+module ScoreFormats
+
+    ## todo/check: use ‹› (unicode chars) to mark optional parts in regex constant name - why? why not?
+
+    #####
+    #  english helpers (penalty, extra time, ...)
+    P_EN  =  '(?: p | pen\.? | pso )'     # e.g. p, pen, pen., PSO, etc.
+    ET_EN =  '(?: aet | a\.e\.t\.? )'     # note: make last . optional (e.g a.e.t) allowed too
+
+
+    ##  note: allow SPECIAL cases WITHOUT full time scores (just a.e.t or pen. + a.e.t.)
+    ##      3-4 pen. 2-2 a.e.t.
+    ##               2-2 a.e.t.
+    EN__P_ET__RE = /\b
+            (?:
+               (?<score1p>\d{1,2})
+                 [ ]* - [ ]*          # note: sep in optional block; CANNOT use a reference
+               (?<score2p>\d{1,2})
+                 [ ]* #{P_EN} [ ]*
+             )?            # note: make penalty (P) score optional for now
+            (?<score1et>\d{1,2})
+               [ ]* - [ ]*
+            (?<score2et>\d{1,2})
+               [ ]* #{ET_EN}
+               (?=[ \]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
+                   ## note: \b works only after non-alphanum e.g. )
+
+
+    ## e.g. 3-4 pen. 2-2 a.e.t. (1-1, 1-1)  or
+    ##      3-4 pen. 2-2 a.e.t. (1-1, )     or
+    ##      3-4 pen. 2-2 a.e.t. (1-1)       or
+    ##               2-2 a.e.t. (1-1, 1-1)  or
+    ##               2-2 a.e.t. (1-1, )     or
+    ##               2-2 a.e.t. (1-1)
+
+    EN__P_ET_FT_HT__RE = /\b
+               (?:
+                (?<score1p>\d{1,2})
+                   [ ]* - [ ]*          # note: sep in optional block; CANNOT use a reference
+                (?<score2p>\d{1,2})
+                   [ ]* #{P_EN} [ ]*
+                )?            # note: make penalty (P) score optional for now
+               (?<score1et>\d{1,2})
+                   [ ]* - [ ]*
+               (?<score2et>\d{1,2})
+                   [ ]* #{ET_EN} [ ]*
+                   \(
+                   [ ]*
+              (?<score1>\d{1,2})
+                   [ ]* - [ ]*
+              (?<score2>\d{1,2})
+                   [ ]*
+                (?:
+                     , [ ]*
+                    (?: (?<score1i>\d{1,2})
+                        [ ]* - [ ]*
+                        (?<score2i>\d{1,2})
+                        [ ]*
+                    )?
+                )?              # note: make half time (HT) score optional for now
+              \)
+             (?=[ \]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
+                               ## note: \b works only after non-alphanum e.g. )
+
+    ###
+    ##   special case for case WITHOUT extra time!!
+    ##     same as above (but WITHOUT extra time and pen required)
+    EN__P_FT_HT__RE = /\b
+     (?<score1p>\d{1,2})
+        [ ]* - [ ]*          # note: sep in optional block; CANNOT use a reference
+     (?<score2p>\d{1,2})
+        [ ]* #{P_EN} [ ]*
+        \(
+        [ ]*
+   (?<score1>\d{1,2})
+        [ ]* - [ ]*
+   (?<score2>\d{1,2})
+        [ ]*
+     (?:
+          , [ ]*
+         (?: (?<score1i>\d{1,2})
+             [ ]* - [ ]*
+             (?<score2i>\d{1,2})
+             [ ]*
+         )?
+     )?              # note: make half time (HT) score optional for now
+   \)
+  (?=[ \]]|$)/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) or
+    ##      2-1
+    ## note: for now add here used in Brazil / Portugal
+    ##  e.g 1x1 or 1X1 or 0x2 or 3x3  too
+    ##   todo/check/fix: move to its own use PT__FT_HT etc!!!!
+
+    EN__FT_HT__RE = /\b
+              (?<score1>\d{1,2})
+                [ ]* (?<sep>[x-]) [ ]*
+              (?<score2>\d{1,2})
+               (?:
+                   [ ]* \( [ ]*
+                (?<score1i>\d{1,2})
+                   [ ]* \k<sep> [ ]*
+                (?<score2i>\d{1,2})
+                   [ ]* \)
+               )?   # note: make half time (HT) score optional for now
+             (?=[ \]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
+                               ## note: \b works only after non-alphanum e.g. )
+
+
+    #####
+    #  deutsch / german helpers (penalty, extra time, ...)
+    ## todo add more marker e.g. im Elf. or such!!!
+    P_DE  =  '(?: ie | i\.e\.? )'     # e.g. iE, i.E., i.E etc.
+    ET_DE =  '(?: nv | n\.v\.? )'     # e.g. nV, n.V., n.V etc.
+
+
+    ## support alternate all-in-one score e.g.
+    ##     i.E. 2:4, n.V. 3:3 (1:1, 1:1)  or
+    ##               n.V. 3:2 (2:2, 1:2)
+    DE__P_ET_FT_HT__RE = /\b
+                     (?:
+                     #{P_DE}
+                      [ ]*
+                     (?<score1p>\d{1,2})
+                      [ ]* : [ ]*
+                     (?<score2p>\d{1,2})
+                      [ ]* (?:, [ ]*)?
+                     )?   # note: make penalty (P) score optional for now
+                      #{ET_DE}
+                      [ ]*
+                     (?<score1et>\d{1,2})
+                      [ ]* : [ ]*
+                     (?<score2et>\d{1,2})
+                      [ ]*
+                    \(
+                 [ ]*
+             (?<score1>\d{1,2})
+                  [ ]* : [ ]*
+             (?<score2>\d{1,2})
+                  [ ]*
+               (?:
+                   , [ ]*
+                   (?:
+                    (?<score1i>\d{1,2})
+                      [ ]* : [ ]*
+                    (?<score2i>\d{1,2})
+                      [ ]*
+                   )?
+               )?    # note: make half time (HT) score optional for now
+             \)
+            (?=[ \]]|$)
+              /xi
+
+    ## support all-in-one "literal form e.g.
+    #  2:2 (1:1, 1:0) n.V. 5:1 i.E.   or
+    #  2-2 (1-1, 1-0) n.V. 5-1 i.E.
+    DE__ET_FT_HT_P__RE = /\b
+               (?<score1et>\d{1,2})
+                   [ ]* (?<sep>[:-]) [ ]*     ## note: for now allow : or - as separator!!
+               (?<score2et>\d{1,2})
+                   [ ]*
+                   \(
+                  [ ]*
+              (?<score1>\d{1,2})
+                   [ ]* \k<sep> [ ]*
+              (?<score2>\d{1,2})
+                   [ ]*
+                (?:
+                    , [ ]*
+                    (?:
+                     (?<score1i>\d{1,2})
+                       [ ]* \k<sep> [ ]*
+                     (?<score2i>\d{1,2})
+                       [ ]*
+                    )?
+                )?    # note: make half time (HT) score optional for now
+              \)
+               [ ]*
+               #{ET_DE}
+              (?:
+                [ ]*
+                (?<score1p>\d{1,2})
+                 [ ]* \k<sep> [ ]*
+                (?<score2p>\d{1,2})
+                  [ ]*
+                #{P_DE}
+              )?       # note: make penalty (P) score optional for now
+             (?=[ \]]|$)
+               /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)  or
+    ##      2-1 (1-1)  or
+    ##      2:1        or
+    ##      2-1
+    DE__FT_HT__RE = /\b
+              (?<score1>\d{1,2})
+                [ ]* (?<sep>[:-]) [ ]*
+              (?<score2>\d{1,2})
+               (?:
+                  [ ]* \( [ ]*
+                      (?<score1i>\d{1,2})
+                        [ ]* \k<sep> [ ]*
+                      (?<score2i>\d{1,2})
+                  [ ]* \)
+               )?   # note: make half time (HT) score optional for now
+             (?=[ \]]|$)/x    ## todo/check:  remove loakahead assertion here - why require space?
+                               ## note: \b works only after non-alphanum e.g. )
+
+
+#############################################
+# map tables - 1) regex,  2) tag - note: order matters; first come-first matched/served
+
+
+FORMATS_EN = [
+  [ EN__P_ET_FT_HT__RE, '[SCORE.EN__P?_ET_(FT_HT?)]' ], # e.g. 5-1 pen. 2-2 a.e.t. (1-1, 1-0)
+  [ EN__P_FT_HT__RE,    '[SCORE.EN__P_(FT_HT?)]'     ], # e.g. 5-1 pen. (1-1)
+  [ EN__P_ET__RE,       '[SCORE.EN__P?_ET]'          ], # e.g. 2-2 a.e.t.  or  5-1 pen. 2-2 a.e.t.
+  [ EN__FT_HT__RE,      '[SCORE.EN__FT_(HT)?]'       ], # e.g. 1-1 (1-0)
+]
+
+FORMATS_DE = [
+  [ DE__ET_FT_HT_P__RE, '[SCORE.DE__ET_(FT_HT?)_P?]' ], # e.g. 2:2 (1:1, 1:0) n.V. 5:1 i.E.
+  [ DE__P_ET_FT_HT__RE, '[SCORE.DE__P?_ET_(FT_HT?)]' ], # e.g. i.E. 2:4, n.V. 3:3 (1:1, 1:1)
+  [ DE__FT_HT__RE,      '[SCORE.DE__FT_(HT)?]'       ], # e.g. 1:1 (1:0)
+]
+
+FORMATS = {
+  en: FORMATS_EN,
+  de: FORMATS_DE,
+}
+
+end # module ScoreFormats

data/lib/score-formats/parser.rb

@@ -0,0 +1,129 @@
+
+module ScoreFormats
+
+class ScoreParser
+
+  include Logging
+
+  def initialize( lang: )
+    @lang    = lang.to_sym   ## note: make sure lang is always a symbol for now (NOT a string)
+
+    ## fallback to english if lang not available
+    ##  todo/fix: add/issue warning - why? why not?
+    @formats = FORMATS[ @lang ] || FORMATS[ :en ]
+  end
+
+
+  def parse( line )
+
+     ##########
+     ## todo/fix/check: add unicode to regular dash conversion - why? why not?
+     ##  e.g. – becomes -  (yes, the letters a different!!!)
+     #############
+
+    score = nil
+    @formats.each do |format|
+      re = format[0]
+      m = re.match( line )
+      if m
+        score = parse_matchdata( m )
+        break
+      end
+      # no match; continue; try next regex pattern
+    end
+
+    ## todo/fix - raise ArgumentError - invalid score; no format match found
+    score  # note: nil if no match found
+  end # method parse
+
+
+  def find!( line )
+    ### 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
+
+    score = nil
+    @formats.each do |format|
+      re  = format[0]
+      tag = format[1]
+      m = re.match( line )
+      if m
+        score = parse_matchdata( m )
+        line.sub!( m[0], tag )
+        break
+      end
+      # no match; continue; try next regex pattern
+    end
+
+    score  # note: nil if no match found
+  end # method find!
+
+private
+  def parse_matchdata( m )
+    # convert regex match_data captures to hash
+    # - note: cannont use match_data like a hash (e.g. raises exception if key/name not present/found)
+    h = {}
+    # - note: do NOT forget to turn name into symbol for lookup in new hash (name.to_sym)
+    m.names.each { |name| h[name.to_sym] = m[name] }  # or use match_data.names.zip( match_data.captures )  - more cryptic but "elegant"??
+
+    ## puts "[parse_date_time] match_data:"
+    ## pp h
+    logger.debug "   [parse_matchdata] hash: >#{h.inspect}<"
+
+    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 h[:score1i] && h[:score2i]   ## note: half time (HT) score is optional now
+      score1i   = h[:score1i].to_i
+      score2i   = h[:score2i].to_i
+    end
+
+    if h[:score1] && h[:score2]     ## note: full time (FT) score can be optional too!!!
+      score1 = h[:score1].to_i
+      score2 = h[:score2].to_i
+    end
+
+    if h[:score1et] && h[:score2et]
+      score1et = h[:score1et].to_i
+      score2et = h[:score2et].to_i
+    end
+
+    if h[:score1p] && h[:score2p]
+      score1p   = h[:score1p].to_i
+      score2p   = h[:score2p].to_i
+    end
+
+    score = Score.new( score1i,  score2i,
+                       score1,   score2,
+                       score1et, score2et,
+                       score1p,  score2p   )
+    score
+  end  # method parse_matchdata
+
+
+
+end  # class ScoreParser
+end  # module ScoreFormats
+

data/lib/score-formats/score.rb

@@ -0,0 +1,165 @@
+
+
+## note: make Score top-level and use like Date - yes, yes, yes - why? why not?
+class Score
+
+  SCORE_SPLIT_RE = %r{^  [ ]*
+                        ([0-9]+)
+                         [ ]*
+                         [:x–-]      ## note: allow some unicode dashes too
+                         [ ]*
+                        ([0-9]+)
+                         [ ]*  $}xi
+
+ def self.split( str )   ## note: return array of two integers or empty array
+   ## e.g. allow/support
+   ##      1-1 or 1 - 1      - "english" style
+   ##      1:1               - "german / deutsch" style
+   ##      1x1 1X1           - "brazil/portugese" style
+
+   ## note: add unicode "fancy" dash too (e.g. –)
+   ## add some more - why? why not?
+
+   if m=SCORE_SPLIT_RE.match(str)
+     [m[1].to_i, m[2].to_i]
+   else
+     # no match - warn if str is not empty? why? why not?
+     ##
+     ## todo/fix:
+     ## do NOT warn on
+     ##    assert_equal [], Score.split( '-' )
+     ##    assert_equal [], Score.split( '-:-' )
+     ##    assert_equal [], Score.split( '?' )
+     ## for now - add more?
+
+     puts "!! WARN - cannot match (split) score format >#{str}<"  unless str.empty?
+     []
+   end
+ end
+
+
+
+
+ attr_reader :score1i,  :score2i,   # half time (ht) score
+             :score1,   :score2,    # full time (ft) score
+             :score1et, :score2et,  # extra time (et) score
+             :score1p,  :score2p    # penalty (p) score
+             ## todo/fix: add :score1agg, score2agg too - why? why not?!!!
+             ##  add state too e.g. canceled or abadoned etc - why? why not?
+
+ ## alternate accessor via array e.g. ft[0] and ft[1]
+ def ft()  [@score1,   @score2];   end  ## e.g. 90 mins (in football)
+ def ht()  [@score1i,  @score2i];  end  ## e.g. 45 mins
+ def et()  [@score1et, @score2et]; end  ## e.g. 90+15mins
+ def p()   [@score1p,  @score2p];  end  ## e.g. note - starts "fresh" score from 0-0
+ alias_method :pen, :p   ## add alias - why? why not?
+
+ ## todo/check: allow one part missing why? why not?
+ ##   e.g.  1-nil  or nil-1  - why? why not?
+ def ft?()  @score1   && @score2;   end
+ def ht?()  @score1i  && @score2i;  end
+ def et?()  @score1et && @score2et; end
+ def p?()   @score1p  && @score2p;  end
+ alias_method :pen?, :p?
+
+
+
+ def initialize( *values )
+   ## note: for now always assumes integers
+   ##  todo/check - check/require integer args - why? why not?
+
+   ### todo/fix: add more init options
+   ##   allow kwargs (keyword args) via hash - why? why not?
+   ##     use kwargs for "perfect" init where you can only set the half time (ht) score
+   ##          or only the penalty or other "edge" cases
+   ##   allow int pairs e.g. [1,2], [2,2]
+   ##   allow values array MUST be of size 8 (or 4 or 6) - why? why not?
+
+   raise ArgumentError, "expected even integer number (pairs), but got #{values.size}"   if values.size % 2 == 1
+
+   if values.size == 2
+     @score1   = values[0]    # full time (ft) score
+     @score2   = values[1]
+
+     @score1i  = @score2i  = nil
+     @score1et = @score2et = nil
+     @score1p  = @score2p  = nil
+   else
+     @score1i  = values[0]    # half time (ht) score
+     @score2i  = values[1]
+
+     @score1   = values[2]    # full time (ft) score
+     @score2   = values[3]
+
+     @score1et = values[4]    # extra time (et) score
+     @score2et = values[5]
+
+     @score1p  = values[6]    # penalty (p) score
+     @score2p  = values[7]
+   end
+ end
+
+
+
+ def to_h( format = :default )
+    case format.to_sym
+    when :default, :std
+      ## check/todo:  only add entries if ft, ht, etc. have values (non-null) or always - why? why not?
+      h = {}
+      h[:ht] = [@score1i,  @score2i]   if @score1i  || @score2i
+      h[:ft] = [@score1,   @score2]    if @score1   || @score2
+      h[:et] = [@score1et, @score2et]  if @score1et || @score2et
+      h[:p]  = [@score1p,  @score2p]   if @score1p  || @score2p
+      h
+    when :db
+      ## use a "flat" structure with "internal" std names
+      { score1i:  @score1i,   score2i:  @score2i,
+        score1:   @score1,    score2:   @score2,
+        score1et: @score1et,  score2et: @score2et,
+        score1p:  @score1p,   score2p:  @score2p
+      }
+    else
+      puts "!! ERROR: unknown score to_h format >#{format}<"
+      exit 1
+    end
+ end
+ alias_method :to_hash, :to_h  ## add alias - why? why not?
+
+
+ def values
+   ## todo/ fix: always return complete array
+   ##  e.g. [score1i, score2i, score1, score2, score1et, score2et, score1p, score2p]
+
+   ## 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
+   score = []
+   score += [@score1i,  @score2i]     if @score1p || @score2p || @score1et || @score2et || @score1 || score2 || score1i || score2i
+   score += [@score1,   @score2]      if @score1p || @score2p || @score1et || @score2et || @score1 || score2
+   score += [@score1et, @score2et]    if @score1p || @score2p || @score1et || @score2et
+   score += [@score1p,  @score2p]     if @score1p || @score2p
+   score
+ end
+
+ def to_a
+   ## pairs with values
+   pairs = []
+   ## note: allow 1-nil, nil-1 for now in pairs (or use && and NOT ||) - why? why not?
+   pairs << [@score1i,  @score2i]   if @score1i  || @score2i
+   pairs << [@score1,   @score2]    if @score1   || @score2
+   pairs << [@score1et, @score2et]  if @score1et || @score2et
+   pairs << [@score1p,  @score2p]   if @score1p  || @score2p
+
+   if pairs.empty?
+     pairs   # e.g. return []
+   elsif pairs.size == 1
+     pairs[0]  # return single pair "unwrapped" e.g. [0,1] instead of [[0,1]] - why? why not?
+   else
+     pairs
+   end
+ end
+
+end  # class Score
+
+

data/lib/score-formats/version.rb

@@ -0,0 +1,19 @@
+
+module ScoreFormats
+  MAJOR = 0    ## todo: namespace inside version or something - why? why not??
+  MINOR = 0
+  PATCH = 1
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "score-formats/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+  end
+
+  def self.root
+    File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )
+  end
+end   # module ScoreFormats

data/lib/score/formats.rb

@@ -0,0 +1,5 @@
+# note: allow require 'score/formats' too
+#       (in addition to require 'score-formats')
+
+require_relative '../score-formats'
+

data/test/helper.rb

@@ -0,0 +1,12 @@
+## $:.unshift(File.dirname(__FILE__))
+
+## minitest setup
+
+require 'minitest/autorun'
+
+
+## our own code
+
+require 'score/formats'     ## or require 'score-formats'
+
+

data/test/test_formats.rb

@@ -0,0 +1,129 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_formats.rb
+
+
+require 'helper'
+
+class TestFormats < MiniTest::Test
+
+  def test_de
+    ScoreFormats.lang = :de
+    data = [
+      [ '10:0',  [nil,nil, 10,0]],
+      [ '1:22',  [nil,nil, 1,22]],
+      [ '1-22',  [nil,nil, 1,22]],
+
+      ## do not support three digits for now - why? why not?
+      [ '1:222', nil],
+      [ '111:0', nil],
+      [ '1-222', nil],
+      [ '111-0', nil],
+
+      [ '2:2 (1:1, 1:0) n.V. 5:1 i.E.',  [1,0, 1,1, 2,2, 5,1]],
+      [ '2:2 (1:1, 1:0) n.V.',           [1,0, 1,1, 2,2]],
+      [ '2:2 (1:1, ) n.V. 5:1 i.E.',     [nil,nil, 1,1, 2,2, 5,1]],
+      [ '2:2 (1:1, ) n.V.',              [nil,nil, 1,1, 2,2]],
+
+      [ '2:2 (1:1) n.V. 5:1 i.E.',       [nil,nil, 1,1, 2,2, 5,1]],
+      [ '2:2 (1:1) n.V.',                [nil,nil, 1,1, 2,2]],
+
+      [ '2-2 (1-1, 1-0) n.V. 5-1 i.E.',  [1,0, 1,1, 2,2, 5,1]],
+      [ '2-2 (1-1, 1-0) n.V.',           [1,0, 1,1, 2,2]],
+      [ '2-2 (1-1, ) n.V. 5-1 i.E.',     [nil,nil, 1,1, 2,2, 5,1]],
+      [ '2-2 (1-1, ) n.V.',              [nil,nil, 1,1, 2,2]],
+
+      [ '2 : 2 ( 1 : 1 , 1 : 0 ) n.V. 5 : 1 i.E.',  [1,0, 1,1, 2,2, 5,1]],
+      [ '2 : 2 ( 1 : 1 , 1 : 0 ) n.V.',             [1,0, 1,1, 2,2]],
+      [ '2 : 2 ( 1 : 1 , ) n.V. 5 : 1 i.E.',        [nil,nil, 1,1, 2,2, 5,1]],
+      [ '2 : 2 ( 1 : 1 , ) n.V.',                   [nil,nil, 1,1, 2,2]],
+
+      ## alternate format
+      ['i.E. 2:4, n.V. 3:3 (1:1, 1:0)',  [1,0, 1,1, 3,3, 2,4]],
+      ['iE 2:4 nV 3:3 (1:1, 1:0)',       [1,0, 1,1, 3,3, 2,4]],
+      ['i.E. 2:4 n.V. 3:3 (1:1, 1:0)',   [1,0, 1,1, 3,3, 2,4]],
+      ['i.E. 2:4, n.V. 3:3 (1:1)',       [nil, nil, 1,1, 3,3, 2,4]],
+      ['i.E. 2:4 n.V. 3:3 (1:1)',        [nil, nil, 1,1, 3,3, 2,4]],
+      ['n.V. 3:2 (2:2, 1:2)',            [1,2, 2,2, 3,2]],
+      ['n.V. 3:2 (2:2)',                 [nil, nil, 2,2, 3,2]],
+    ]
+
+    assert_score( data )
+  end
+
+  def test_en
+    ScoreFormats.lang = :en
+
+    data = [
+     [ '1-22',  [nil,nil, 1, 22]],
+     [ '1x22',  [nil,nil, 1, 22]],
+     [ '1X22',  [nil,nil, 1,22]],
+
+     ## do not support three digits for now - why? why not?
+     [ '1-222', nil],
+     [ '111-0', nil],
+     [ '111x0', nil],
+     [ '111X0', nil],
+
+     ## do not support colon sep for now in en locale - why? why not?
+     [ '2:1',       nil],
+     [ '2:1 (1:1)', nil],
+
+
+     [ '2-1 (1-1)', [1,1, 2,1]],
+     [ '2x1 (1x1)', [1,1, 2,1]],
+     [ '2X1 (1X1)', [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]],
+     [ '2-1 a.e.t.',            [nil,nil,nil,nil, 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]],
+     [ '3-4 pen. 2-2 a.e.t.',            [nil,nil,nil,nil, 2,2, 3,4]],
+
+     [ '4-3 pen. 1-0 a.e.t. (1-0, )', [nil,nil, 1,0, 1,0, 4,3]],
+     [ '3-4 pen. 2-1 a.e.t. (2-1, )', [nil,nil, 2,1, 2,1, 3,4]],
+     [ '4-1 a.e.t. (3-1, )',          [nil,nil, 3,1, 4,1]],
+     [ '3-4aet (1-1,)',               [nil,nil, 1,1, 3,4]],
+     [ '3-4 a.e.t. (1-1,)',           [nil,nil, 1,1, 3,4]],
+
+     [ '4-3 pen. 1-0 a.e.t. (1-0)', [nil,nil, 1,0, 1,0, 4,3]],
+     [ '3-4 pen. 2-1 a.e.t. (2-1)', [nil,nil, 2,1, 2,1, 3,4]],
+     [ '4-1 a.e.t. (3-1)',          [nil,nil, 3,1, 4,1]],
+     [ '3-4aet (1-1)',               [nil,nil, 1,1, 3,4]],
+     [ '3-4 a.e.t. (1-1)',           [nil,nil, 1,1, 3,4]],
+
+     [ '3-1 pen (1-1)',               [nil,nil, 1,1, nil, nil, 3,1]],
+
+     ## try with more "liberal" spaces
+     [ '2 - 1 ( 1 - 1 )',                [1,1, 2,1]],
+     [ '2 - 1 a.e.t. ( 1 - 1 , 0 - 0 )', [0,0, 1,1, 2,1]],
+     [ '4 - 1 a.e.t. ( 3 - 1, )',        [nil,nil, 3,1, 4,1]],
+   ]
+
+    assert_score( data )
+  end
+
+private
+  def assert_score( data )
+    data.each do |rec|
+      line = rec[0].dup
+      exp  = rec[1]
+
+      score = ScoreFormats.find!( line )
+      ## pp score
+
+      if exp.nil?
+        assert_nil score, "failed >#{rec[0]}< - >#{line}<"
+      else
+        assert_equal exp, score.values, "failed >#{rec[0]}< - >#{line}<"
+      end
+    end
+  end
+end # class TestScores

data/test/test_score.rb

@@ -0,0 +1,76 @@
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_score.rb
+
+
+require 'helper'
+
+class TestScore < MiniTest::Test
+
+  def test_split
+    assert_equal [], Score.split( '' )
+    assert_equal [], Score.split( '-' )
+    assert_equal [], Score.split( '-:-' )
+    assert_equal [], Score.split( '?' )
+
+    assert_equal [0,1], Score.split( '0-1' )
+    assert_equal [0,1], Score.split( ' 0 - 1 ' )
+    assert_equal [0,1], Score.split( '0:1' )
+    assert_equal [0,1], Score.split( ' 0 : 1 ' )
+    assert_equal [0,1], Score.split( '0x1' )
+    assert_equal [0,1], Score.split( '0X1' )
+
+    assert_equal [10,11], Score.split( '10 - 11' )
+    assert_equal [10,11], Score.split( '10 : 11' )
+  end
+
+  def test_to_h
+    assert_equal  Hash( ft: [1,0] ), Score.parse( '1-0' ).to_h
+    assert_equal  Hash( ht: [1,0],
+                        ft: [3,2] ), Score.parse( '3-2 (1-0)' ).to_h
+  end
+
+
+  def test_new_et_al
+    score = Score.new
+    assert_equal [],        score.to_a
+    assert_equal [],        score.values
+    assert_equal [nil,nil], score.ft
+    assert_equal [nil,nil], score.ht
+    assert_equal Hash({}),  score.to_h    ## e.g. {} - empty hash
+    assert_equal Hash( score1i:  nil, score2i:  nil,
+                       score1:   nil, score2:   nil,
+                       score1et: nil, score2et: nil,
+                       score1p:  nil, score2p:  nil ), score.to_h( :db )
+
+
+    [
+     Score.new( 0, 1 ),
+     Score.new( nil, nil, 0, 1 ),
+    ].each do |score|
+      assert_equal [0,1],           score.to_a
+      assert_equal [nil,nil,0,1],   score.values
+      assert_equal [nil,nil],       score.ht
+      assert_equal [0,1],           score.ft
+      assert_equal Hash(ft: [0,1]), score.to_h
+      assert_equal Hash( score1i:  nil, score2i:  nil,
+                         score1:   0,   score2:   1,
+                         score1et: nil, score2et: nil,
+                         score1p:  nil, score2p:  nil ), score.to_h( :db )
+    end
+
+
+    score = Score.new( 0, 1, 2, 3 )
+    assert_equal [[0,1],[2,3]],   score.to_a
+    assert_equal [0,1,2,3],       score.values
+    assert_equal [0,1],           score.ht
+    assert_equal [2,3],           score.ft
+    assert_equal Hash(ht: [0,1],
+                      ft: [2,3]), score.to_h
+    assert_equal Hash( score1i:  0,   score2i: 1,
+                       score1:   2,   score2:  3,
+                       score1et: nil, score2et: nil,
+                       score1p:  nil, score2p:  nil ), score.to_h( :db )
+ end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: score-formats
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+description: score-formats - read / parse and print sports match scores (incl. half
+  time, full time, extra time, penalties and more)
+email: opensport@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/score-formats.rb
+- lib/score-formats/formats.rb
+- lib/score-formats/parser.rb
+- lib/score-formats/score.rb
+- lib/score-formats/version.rb
+- lib/score/formats.rb
+- test/helper.rb
+- test/test_formats.rb
+- test/test_score.rb
+homepage: https://github.com/sportdb/sport.db
+licenses:
+- Public Domain
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: score-formats - read / parse and print sports match scores (incl. half time,
+  full time, extra time, penalties and more)
+test_files: []