fbtxt-parser 0.9.0

data/lib/fbtxt/parser/token-geo.rb

@@ -0,0 +1,134 @@
+module Fbtxt
+class Lexer
+
+
+##
+#  allow Cote'd Ivoir or such
+##   e.g. add '
+
+
+## todo/fix - make geo text regex more generic
+##               only care about two space rule
+
+
+GEO_TEXT_RE = %r{
+    ## must start with alpha (allow unicode letters!!)
+    (?<text>
+          ## positive lookbehind -  for now space (or beginning of line - for testing) only
+           ##  (MUST be fixed number of chars - no quantifier e.g. +? etc.)
+            (?<= [ ,›>\[\]]|^)
+            (?:
+                # opt 1 - start with alpha
+                 \p{L}+    ## all unicode letters (e.g. [a-z])
+                   |
+                # opt 2 - start with num!! -
+                     \d+  # check for num lookahead (MUST be space or dot)
+                      ## MAY be followed by (optional space) !
+                      ## MUST be follow by a to z!!!!
+                      [ ]?   ## make space optional too  - why? why not?
+                             ##  yes - eg. 1st, 2nd, 5th etc.
+                       \p{L}+
+                  |
+                ## opt 3 - add another weirdo case
+                ##   e.g.   's Gravenwezel-Schilde
+                ##   add more letters (or sequences here - why? why not?)
+                    '\p{L}+
+               )
+
+               ##
+               ## todo/check - find a different "more intuitive" regex/rule if possible?
+               ##    for single spaces only (and _/ MUST not be surround by spaces)
+
+              (?:
+                  (?:
+                    [ ]?   # only single (inline) space allowed - double spaces are breaks!!!
+                    (?:
+                       \p{L} | \d  | [.&'°]
+                        |
+                       (?: (?<! [ ])  ## no space allowed before (but possible after)
+                            [-]
+                       )
+                         |
+                       (?: (?<! [ ])  ## no spaces allowed around these characters
+                           [_/]
+                          (?! [ ])
+                       )
+                    )+
+                  )
+                  |
+              ## for now allow auto-add optional
+              ##   parenthesis enclosed closed text
+              ##   e.g. Dublin (Dalymount Park)
+              ##        Bucuresti (23 August)
+              ##        Paris (Parc des Princes)
+              ##        Ost-Berlin (Walter-Ulbricht)
+              ##        Athinai (OAKA - Maroussi)
+              ##
+              ##   or   Valencia (Spain) or Solna
+              (?:
+                    [ ]
+                    \(
+                        [^()\[\],;:›<>]+    ## todo - add more special chars
+                                            ##   maybe list only allowed ones??
+                                            ##   make pattern more strict - why? why not?
+                    \)
+              )
+          )*
+
+
+              ## must NOT end with space or dash(-)
+              ##  todo/fix - possible in regex here
+              ##     only end in alphanum a-z0-9 (not dot or & ???)
+
+            ## add lookahead/lookbehind
+           ##    must be space!!!
+           ##   (or comma or  start/end of string)
+           ##   kind of \b !!!
+            ## POSITIVE lookahead
+            (?=[ ,›>\[\]]|$)
+
+   )
+}ix
+
+
+
+
+
+
+##  note - add "hacky" check for comma that is followed by a prop(erty)
+##
+##  make sure to NOT match
+##      props  e.g.  att: 18000
+##   July 10 @ Paris, Parc des Princes, att: 18000
+##   July 10 @ Paris, Parc des Princes,   att: 18000
+##
+
+
+GEO_END_RE = %r{
+   (?<geo_end>
+        ,
+    )
+    ## POSITIVE lookahead for props
+    ##   todo/fix - use generic [a-z]+ - why? why not?
+    (?=
+        [ ]*  ## optional spaces
+         (?:     attendance|att
+              |  referee?s|refs?
+          )
+         :
+    )
+}ix
+
+
+
+
+GEO_RE = Regexp.union(
+                    SPACES_RE,
+                    GEO_END_RE,
+                    GEO_TEXT_RE,
+                    /  (?<sym> [,›>\[▪] ) /x,
+                    ANY_RE,
+                      )
+
+end # class Lexer
+end # module Fbtxt

data/lib/fbtxt/parser/token-goals--helpers.rb

@@ -0,0 +1,114 @@
+module Fbtxt
+class Lexer
+
+
+
+def self._build_goal_minute( m )
+    minute = {}
+
+    minute[:m]     =  m[:value].to_i(10)   ## always required
+
+    ## stoppage/injury time (offset)
+    minute[:offset] = m[:value2].to_i(10)   if m[:value2]
+
+    minute[:og]  = true       if m[:og]
+    minute[:pen] = true       if m[:pen]
+    minute[:freekick] = true  if m[:fk]
+    minute[:header] = true    if m[:hdr]
+
+    minute[:secs] = m[:secs].to_i(10)   if m[:secs]
+
+    minute
+end
+
+def self._build_goal_minute_na( m )
+    minute = {}
+
+    minute[:m]     =  '?'   ##  or use nil or 999 or -1 or ???
+
+    minute[:og]  = true       if m[:og]
+    minute[:pen] = true       if m[:pen]
+    minute[:freekick] = true  if m[:fk]
+    minute[:header] = true    if m[:hdr]
+
+    minute
+end
+
+
+
+def self._build_minute( m )
+    minute = {}
+    minute[:m]      = m[:value].to_i(10)   ## always required
+
+    ## stoppage/injury time (offset)
+    minute[:offset] = m[:value2].to_i(10)   if m[:value2]
+
+    minute
+end
+
+
+def self._build_goal_count( m )
+    count = {}
+    count[:count] = m[:value].to_i(10)        if m[:value]
+    count[:og]    = m[:og_value] ? m[:og_value].to_i(10) : 1      if m[:og]   ## check flag
+    count[:pen]   = m[:pen_value] ? m[:pen_value].to_i(10) : 1    if m[:pen]  ## check flag
+    count
+end
+
+def self._build_goal_type( m )
+    goal = {}
+    goal[:og]       = true  if m[:og]
+    goal[:pen]      = true  if m[:pen]
+    goal[:freekick] = true  if m[:fk]
+    goal[:header]   = true  if m[:hdr]
+    goal
+end
+
+
+def _build_goal_minute( m ) self.class._build_goal_minute( m ); end
+def _build_goal_minute_na( m ) self.class._build_goal_minute_na( m ); end
+def _build_minute( m ) self.class._build_minute( m ); end
+def _build_goal_count( m ) self.class._build_goal_count( m ); end
+def _build_goal_type( m ) self.class._build_goal_type( m ); end
+
+
+
+
+
+###
+# parse helpers
+
+def self._parse_goal_minute( str )
+    ## note - strip - leading/trailing spaces
+    m = GOAL_MINUTE_RE.match( str.strip )
+    if m && m.pre_match == '' && m.post_match == ''
+      _build_goal_minute( m )
+    elsif  m
+        ## note - match BUT not anchored to start and end-of-string!!!
+        ##  report, error somehow??
+      nil
+    else
+      nil  ## no match - return nil
+    end
+end
+
+def self._parse_goal_count( str )
+    ## note - strip - leading/trailing spaces
+    m = GOAL_COUNT_RE.match( str.strip )
+    if m && m.pre_match == '' && m.post_match == ''
+      _build_goal_count( m )
+    elsif  m
+        ## note - match BUT not anchored to start and end-of-string!!!
+        ##  report, error somehow??
+      nil
+    else
+      nil  ## no match - return nil
+    end
+end
+
+
+
+
+
+end   # class Lexer
+end   # module Fbtxt

data/lib/fbtxt/parser/token-goals.rb

@@ -0,0 +1,306 @@
+module Fbtxt
+class Lexer
+
+
+######################################################
+## goal mode
+##  note - must be enclosed in ()!!!
+##
+##          todo - add () in basics - why? why not?
+
+
+
+
+## note - assume lines starting with opening ( are goal lines!!!!
+##  note - use \A (instead of ^) - \A strictly matches the start of the string.
+##
+##   note -  check for negative lookahead
+##                 to exclude ord (numbers) e.g.  (1), (42), etc.!!!
+##
+##  todo/fix -- exclude (a), (h), (n)  - TEAM_AWAY, TEAM_HOME, TEAM_NEUTRAL tokens!!
+
+START_GOAL_LINE_RE = %r{
+                     \A
+                        [ ]*    ## ignore leading spaces (if any)
+                       \(
+
+                       # check NEGATIVE lookahead
+                       (?!
+                             ##  exclude (a), (h), (n)
+                             ##    TEAM_AWAY, TEAM_HOME, TEAM_NEUTRAL
+                             (?: a|h|n )
+                             \)
+                        )
+
+ }xi
+
+
+
+#############
+##  check for goal compat(ility) "legacy" line
+##         e.g.
+## (6' Puskás 0-1, 9' Czibor 0-2, 11' Morlock 1-2, 18' Rahn 2-2,
+##   84' Rahn 3-2)
+## (6 Puskás 0-1, 9 Czibor 0-2, 11 Morlock 1-2, 18 Rahn 2-2,
+##  84 Rahn 3-2)
+
+
+START_GOAL_LINE_COMPAT_RE = %r{
+                   \A
+                        [ ]*    ## ignore leading spaces (if any)
+                      \(
+
+                      ## (i) check NEGATIVE lookahead
+                      ##    exclude score e.g. 1-1 etc.
+                          (?! [ ]* \b \d-\d \b)
+
+                      ## (ii) check POSITIVE lookahead
+                          (?= [ ]*
+                               \d{1,3}
+                                   '?    ## optional minute marker
+                                  (?: \+
+                                      \d{1,2}
+                                    '?    ## optional minute marker
+                                  )?
+                            )
+}xi
+
+
+
+###
+##  check for goal line (alternate syntax)
+##    (1-0 Player, 1-1 Player, ...)
+#    must start-off OR yes, include score
+##
+##    note - allow "centered" style e.g.
+##           (    Player 44' (p)  1-0
+##                                1-1 Player 64'   )
+START_GOAL_LINE_ALT_RE = %r{
+                     \A
+                        [ ]*    ## ignore leading spaces (if any)
+                      \(
+
+                      # check POSITIVE lookahead
+                       (?=  .*?         ## note - non-greedy
+                                \b \d-\d \b    ## score e.g. 0-1
+                         )
+                 }xi
+
+
+
+
+
+
+
+###
+#  note - alternate goal separator dash (-) MUST have leading and trailing space!!!
+#    e.g.   (Metzger 83 - Krämer 29, 88, Cichy 33, Rahn 37)
+#    e.g.   (Metzger - Krämer (2), Cichy, Rahn)
+#            (Brunnenmeier 17 - Gerwien 74)
+#            (Brunnenmeier - Gerwien)
+#    that is,  NOT allowed
+#    e.g.   (Metzger 83-Krämer 29, 88, Cichy 33, Rahn 37)
+#            (Brunnenmeier 17-Gerwien 74)
+#            (Brunnenmeier-Gerwien)
+#
+#   note - allow split by - e.g.
+#     Frankfurt   4-2 Schalke     (Kreß 45, Solz 55, Trimhold 58, Huberts 73 p -
+#                                  Berz 7, Herrmann 74)
+
+
+GOAL_SEP_ALT_RE = %r{
+          (?<goal_sep_alt>
+              (?<=[ ])   ## positive lookbehind - space required
+              -
+              (?=[ ]|\z)    ## positive lookahead - speace required
+             )}x
+
+
+## e.g.  (2)
+##       (2/p), (2/pen.), (3/2p), (3/ 2 pen.)
+##      -or-  (2,1pen), (3, 2 pens)
+##
+##       (p), (pen.) (2 pen.), (2p)
+##       (og), (o.g.),
+##        (2og), (2 o.g.), (2ogs)
+#
+##
+
+GOAL_COUNT_RE = %r{
+   (?<goal_count>
+      \(
+        (?:
+          ## opt penalties
+            (?<pen>
+              (?:  (?<pen_value> \d{1,2}) [ ]? )?
+                 (?:pens|pen\.?|p)
+           )
+            |
+          ## opt own goals (og)
+            (?<og>
+             (?: (?<og_value> \d{1,2}) [ ]? )?
+                (?:ogs?|o\.g\.|o)
+            )
+            |
+          ## opt fallback - classic count/number
+          (?:  (?<value> [1-9])
+                ## check for option penalties
+                (?<pen>
+                     [,/] [ ]*
+                     (?: (?<pen_value> \d{1,2}) [ ]? )?
+                     (?:pens|pen\.?|p)
+                )?
+           )
+         )
+      \)
+)}ix
+
+
+
+
+##
+## note - inline \b check in MINUTE_RE excludes
+##      85pen  or 90+4pen or 38p
+##        (possible and NOT excluded in GOAL_MINUTE_RE  !!!)
+##
+##  minute with optional stoppage (offset)
+
+MINUTE_RE = %r{
+     (?<minute>
+               \b
+             (?<value>\d{1,3})      ## constrain numbers to 0 to 999!!!
+                \b
+                '?    ## optional minute marker
+
+                (?: \+ (?<value2>\d{1,2})
+                       \b
+                      '?    ## optional minute marker
+                 )?
+      )
+}ix
+
+
+
+##
+##  keep separate? or add simply inside GOAL_MINUTE_RE - why? why not?
+##   fix-fix-fix - move into GOAL_MINUTE_RE !!!
+
+GOAL_MINUTE_NA_RE = %r{
+     (?<goal_minute_na>
+
+       # positive lookbehind
+       (?<=[ ,;])
+
+       (?<value> \?{1,2})
+            '?    ## optional minute marker
+     ## note - add goal minute qualifiers here inline!!!
+        (?:
+            (?: [ ]? (?<og>   (?: \((?:og|o\.g\.|o)\))   ## allow (og)
+                                   |
+                              (?: (?:og|o\.g\.|o))      ## allow plain og
+                      )
+            )
+            |
+            (?: [ ]? (?<pen>  (?: \((?:pen\.?|p)\))   ## allow ()
+                                   |
+                              (?: (?:pen\.?|p))
+                      )
+            )
+            |
+            ## add experimental header qualifier
+            (?: [ ]? (?<hdr> \( (?:hdr\.?|h ) \) | (?: hdr\.?|h ) ))
+            |
+            ## add experimental free kick qualifier
+            (?: [ ]? (?<fk> \( (?:fk\.?|f ) \) | (?: fk\.?|f) ))
+        )?
+
+     ## note - check positive lookahead
+     (?=[ ,;)]|$)
+   )
+}ix
+
+
+##   goal types
+# (pen.) or (pen) or (p.) or (p)
+## (o.g.) or (og)
+##   todo/check - keep case-insensitive
+##                   or allow OG or P or PEN or
+##                   only lower case - why? why not?
+##
+##  add (gg) for golden goal - why? why not?
+##  add (sg) for silver goal - why? why not??
+
+GOAL_MINUTE_RE = %r{
+     (?<goal_minute>
+               \b
+             (?<value>\d{1,3})      ## constrain numbers to 0 to 999!!!
+                '?    ## optional minute marker
+
+                 (?: \+ (?<value2>\d{1,2})
+                      '?    ## optional minute marker
+                 )?
+
+        ## note - add goal minute qualifiers here inline!!!
+        (?:
+            (?: [ ]? (?<og>   (?: \((?:og|o\.g\.|o)\))   ## allow (og)
+                                   |
+                              (?: (?:og|o\.g\.|o))      ## allow plain og
+                      )
+            )
+            |
+            (?: [ ]? (?<pen>  (?: \((?:pen\.?|p)\))   ## allow ()
+                                   |
+                              (?: (?:pen\.?|p))
+                      )
+            )
+            |
+            ## add experimental header qualifier
+            (?: [ ]? (?<hdr> \( (?:hdr\.?|h ) \) | (?: hdr\.?|h ) ))
+            |
+            ## add experimental free kick qualifier
+            (?: [ ]? (?<fk> \( (?:fk\.?|f ) \) | (?: fk\.?|f) ))
+        )?
+
+        ##  add experimental seconds
+        ##    e.g. (95 secs) or (95sec) etc.
+        (?: [ ]*  \(
+                      (?<secs>\d{1,3})
+                         [ ]?secs?
+                   \)
+        )?
+     )
+
+     ## note - check positive lookahead
+     (?=[ ,;)]|$)
+}ix
+
+
+
+
+
+###
+## more regex  for goal alt
+
+
+GOAL_TYPE_RE = %r{
+     (?<goal_type>
+               \(
+                 (?:
+                      (?<og>  og|o\.g\.|o )
+                         |
+                      (?<pen> pen\.?|p )
+                         |
+                     ## add experimental header qualifier
+                      (?<hdr>  hdr\.?|h )
+                         |
+                     ## add experimental free kick qualifier
+                       (?<fk>  fk\.?|f )
+                  )
+                \)
+)}xi
+
+
+
+
+end  # class Lexer
+end # module Fbtxt

data/lib/fbtxt/parser/token-group.rb

@@ -0,0 +1,29 @@
+module Fbtxt
+class Lexer
+
+
+###
+#   check for start of group def line e.g.
+#       Group A  | ...
+#       Group 1  : ....
+#       Group A2 | ....
+##  note - use \A (instead of ^) - \A strictly matches the start of the string.
+
+START_WITH_GROUP_DEF_LINE_RE =  %r{
+                     \A
+                     [ ]*  ## ignore leading spaces (if any)
+                     (?<group_def>
+                         Group
+                          [ ]
+                          [a-z0-9]+   ## todo/check - allow dot (.) too e.g. 1.A etc.- why? why not?
+                     )
+                     ###   positive lookahead MUST be : OR |
+                     (?= [ ]*
+                         [:|]
+                         [ ])  ## note: requires space for now after [:|] - keep - why? why not?
+                  }ix
+
+
+
+end  #   class Lexer
+end  # module Fbtxt

data/lib/fbtxt/parser/token-note.rb

@@ -0,0 +1,40 @@
+module Fbtxt
+class Lexer
+
+
+### fix - use (?<text>) - text capture for inner text!!
+##         use (?<note> for complete match as a convention!! )
+NOTE_RE = %r{
+    \[
+      (?<note>
+         [^\[\]\#]*?    ## note - non-greedy/lazy operator
+                        ##    exclude comments inside note block - why? why not?
+      )
+    \]
+    }xi
+
+
+####
+##  fix - change NOTE_RE to MATCH_NOTE_RE !!!!
+##         and change NOTA_BENE_RE to NOTE_RE !!!
+
+
+
+## check for "literal"  (multi-line) note blocks
+##   eg.  nb:  or note:
+##   space required after double colon - why? why not?
+##
+##  note - use \A (instead of ^) - \A strictly matches the start of the string.
+NOTA_BENE_RE =  %r{   \A
+                           [ ]*  ## ignore leading spaces (if any)
+                        (?: nb | note) [ ]* : [ ]+
+                         (?<nota_bene>
+                              .+?  ## use non-greedy
+                          )
+                           [ ]*  ## ignore trailing spaces (if any)
+                          \z
+                       }xi
+
+
+end  #  class Lexer
+end  # module Fbtxt