sportdb-formats 0.4.0 → 1.0.0

data/lib/sportdb/formats/parser_helper.rb

@@ -0,0 +1,81 @@
+
+module SportDb
+  module ParserHelper
+
+
+  def read_lines( txt )   ## todo/check:  add alias preproc_lines or build_lines or prep_lines etc. - why? why not?
+    ## returns an array of lines with comments and empty lines striped / removed
+    lines = []
+    txt.each_line do |line|    ## preprocess
+       line = line.strip
+
+       next if line.empty? || line.start_with?('#')   ###  skip empty lines and comments
+       line = line.sub( /#.*/, '' ).strip             ###  cut-off end-of line comments too
+       lines << line
+    end
+    lines
+  end
+
+
+  def is_round?( line )
+    ## note: =~ return nil if not match found, and 0,1, etc for match
+    (line =~ SportDb.lang.regex_round) != nil
+  end
+
+  def is_knockout_round?( line )
+
+    ## todo: check for adding ignore case for regex (e.g. 1st leg/1st Leg)
+
+    if line =~ SportDb.lang.regex_leg1
+      logger.debug "  two leg knockout; skip knockout flag on first leg"
+      false
+    elsif line =~ SportDb.lang.regex_knockout_round
+      logger.debug "   setting knockout flag to true"
+      true
+    elsif line =~ /K\.O\.|K\.o\.|Knockout/
+        ## NB: add two language independent markers, that is, K.O. and Knockout
+      logger.debug "   setting knockout flag to true (lang independent marker)"
+      true
+    else
+      false
+    end
+  end
+
+  def is_round_def?( line )
+    ## must include bar (|) marker (make required)
+    ## todo/fix:  use split('|') and check is_round? only on left hand side!!!! not whole line
+    line =~ /\|/ && is_round?( line )
+  end
+
+
+
+
+  def is_group?( line )
+    # note: check after is_round? (round may contain group reference!)
+    ## note: =~ return nil if not match found, and 0,1, etc for match
+    (line =~ SportDb.lang.regex_group) != nil
+  end
+
+  def is_group_def?( line )
+    # note: check after is_round? (round may contain group reference!)
+    ## must include bar (|) marker (make required)
+    ## todo/fix:  use split('|') and check is_round? only on left hand side!!!! not whole line
+    line =~ /\|/ && is_group?( line )
+  end
+
+
+  def is_goals?( line )
+    # check if is goals line
+    #  e.g. looks like
+    #   Neymar 29', 71' (pen.) Oscar 90+1';  Marcelo 11' (o.g.)
+    #  check for
+    #    <space>90'  or
+    #    <space>90+1'
+
+    line =~ /[ ](\d{1,3}\+)?\d{1,3}'/
+  end
+
+
+  end  # module ParserHelper
+end   # module SportDb
+

data/lib/sportdb/formats/score/score_formats.rb

@@ -0,0 +1,180 @@
+
+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
+
+
+    ## 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 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__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__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/sportdb/formats/score/score_parser.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+
+## note: lets follow the model of DateFormats -see DateFormats gem for more!!!
+
+
+## note: make Score top-level and use like Date - why? why not?
+class Score
+
+  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?
+
+  def initialize( *values )
+    ## note: for now always assumes integers
+    ##  todo/check - check/require integer args - why? why not?
+
+    @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
+
+  def to_a
+    ## 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
+
+end  # class Score
+
+
+
+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
+
+
+class ScoreParser
+
+  include LogUtils::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 )
+    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
+
+    score1 = h[:score1].to_i
+    score2 = h[:score2].to_i
+
+    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
+