fbtxt-parser 0.9.0

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

@@ -0,0 +1,112 @@
+module Fbtxt
+class Lexer
+
+##  (match) status inline versions
+
+
+
+
+## "inline" match status e.g.
+##  Clapham Rovers     w/o  Hitchin
+##  Queen's Park       bye
+
+## add support for WO or W-0 too - why? why not?
+INLINE_WO_RE = %r{
+                   (?<inline_wo>
+                       \b (?: w/o | W/O ) \b
+               )}x   ## note - NOT case insensitive
+
+INLINE_BYE_RE = %r{
+                  (?<inline_bye>
+                      \b (?: bye | BYE ) \b
+               )}x   ## note - NOT case insensitive
+
+
+###
+#   A n/p  B    (note - basically a inline short form of  A v B [cancelled] )
+#     N/P
+INLINE_NP_RE = %r{
+                   (?<inline_np>
+                       \b (?: n/p | N/P ) \b
+               )}x   ## note - NOT case insensitive
+
+
+###
+#  abd/abd. or aban/aban.  [abandoned]
+#  ABD/ABAN
+INLINE_ABD_RE = %r{
+                   (?<inline_abd>
+                       \b (?: abd\.? |
+                              aban\.? |
+                              ABD | ABAN
+                          )
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x  ## note - NOT case insensitive
+
+####
+#  susp/susp.  [suspended]
+#   SUSP
+INLINE_SUSP_RE = %r{
+                   (?<inline_susp>
+                       \b (?: susp\.? |
+                               SUSP )
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x  ## note - NOT case insensitive
+
+
+####
+# ppd/ppd. or pst/pst. or pstp/pstp. or postp/postp.   [postponed]
+#  PPD/PSTP/POSTP/P-P
+#   todo/check - add/allow p-p too - why? why not?
+INLINE_PPD_RE = %r{
+                   (?<inline_ppd>
+                       \b (?: ppd\.? |
+                              pst\.? |
+                              po?stp\.? |
+                              PPD | PST | PO?STP | P-P
+                           )
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x   ## note - NOT case insensitive
+
+####
+#  void via   x-x X-X
+#     todo/check - only allow X-X - why? why not?
+INLINE_VOID_RE = %r{
+                      (?<inline_void>
+                          \b (?: x-x |
+                                 X-X
+                             )
+                        ## POSITIVE lookahead - requires space
+                           (?= [ ])
+                )}x ## note - NOT case insensitive
+
+
+####
+#  awd/awd.                [awarded]
+#   AWD
+#   note - recommendation is to allways include score
+#            thus, use/prefer SCORE_AWD e.g. 0-3 awd
+INLINE_AWD_RE =  %r{
+                   (?<inline_awd>
+                       \b (?: awd\.? | AWD )
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x   ## note - NOT case insensitive
+
+###
+#  canc/canc.           [cancelled]
+#    CANC
+INLINE_CANC_RE =  %r{
+                   (?<inline_canc>
+                       \b (?: canc\.?  | CANC )
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x   ## note - NOT case insensitive
+
+
+
+end  # class Lexer
+end  # module Fbtxt

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

@@ -0,0 +1,221 @@
+module Fbtxt
+class Lexer
+
+
+##
+## todo/fix - change TEXT_RE  to TEAM_RE !!!!
+##    do NOT use (anymore) as generic TEXT_RE
+
+
+## note - TEXT_RE used for TEAM_NAMES
+##       plus as "legacy" shortcut for (simple) group or round names e.g.
+##                       Group A, Group 1, ..
+##                        Matchday 1, 1. Round,
+##        note - no exception for (shortcut) group or round (MUST match team name pattern!)
+
+
+
+##  note - do NOT allow single alpha text for now
+##   add later??      A - B    C - D  - why?
+## opt 1) one alpha
+## (?<text_i> [a-z])    # only allow single letter text (not numbers!!)
+
+## opt 2) more than one alphanum
+
+
+### allow special case - starting text with number e.g.
+##    number must be follow by space or dot ()
+# 1 FC   ##    allow 1-FC or 1FC   - why? why not?
+# 1FC"
+# 1. FC
+# 1.FC
+# 23° Noviembre
+# 1890 Munich
+# 1-FC    - XXXX  - not allowed for now, parse error
+# 1/FC    - XXXX  - not allowed for now
+
+
+##
+#  allow Cote'd Ivoir or such
+##   e.g. add '
+
+## note:
+##  make sure these do NOT match!!!
+## TEXT  =>  "Matchday 1 / Group A"
+## TEXT  =>  "Matchday 2 / Group A"
+## TEXT  =>  "Matchday 3 / Group A"
+
+
+
+TEXT_RE = %r{
+    ## must start with alpha (allow unicode letters!!)
+    (?<text>
+           ## positive lookbehind
+           ##  (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!! - allow special case (e.g. 1. FC)
+                     \d+  # check for num lookahead (MUST be space or dot)
+                      ## MUST be followed by (optional dot) and
+                      ##                      required space !!!
+                      ## MUST be follow by a to z!!!!
+                      [.°]?     ## optional dot (.) or degree(°) - todo - add number sign too!!
+                      [ ]?   ## 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
+                    '[s] [ ] \p{L}+
+               )
+
+
+              (?:(?:  (?:[ ]   # only single spaces allowed inline!!!
+                          ## note - exclude (v[ ]/vs[ ]/vs.[ ])
+                          ##    AND switch to case-sensitive (via -i!!!)
+                        (?! (?-i: (?:  ## note - (big) V not matching for versus!!!
+                                      vs\.?|v|
+
+                                      n/p|N/P|
+                                      w/o|W/O|
+                                      abd\.?|ABD|
+                                      aban\.?|ABAN|
+                                      susp\.?|SUSP|
+                                      ppd\.?|PPD|
+                                      pst\.?|PST|
+                                      po?stp\.?|PO?STP|P-P|
+                                      x-x|X-X|
+                                      awd\.?|AWD|
+                                      canc\.?|CANC ) [ ]
+                                        |
+                                  (?: bye|BYE ) (?:[ ]|$))
+                          )
+                      )
+                      |
+                     [/-]   ## must NOT be surrounded by spaces
+                  )?
+                (?:
+                  \p{L}
+                     |
+                  (?:   ## note - restrict [.&'] to single char usage (no doubled e.g. && etc.)
+                    \. (?! \.)  ## allow single points only (now two or more etc.)
+                     |
+                    & (?! &)
+                     |
+                    ' (?! ')
+                   )
+                     |
+                 (?:
+                   \d+
+                   (?!
+                     [0-9h'+] |    ## protected break on 12h / 12' / 1-1
+                                    ##  check usege for 3+4 - possible? where ? why?
+                     (?:[.:-]\d)     ## protected/exclude/break on 12.03 / 12:03 / 12-12
+                                      ##  BUT allow Park21-Arena for example e.g. 21-A :-)
+                    )
+                    [°]?  ## followed by optional ord
+                   ## negative lookahead for numbers
+                   ##   note - include digits itself!!!
+                   ##   note - remove / (slash) e.g. allows UDI'19/Beter Bed
+                 )
+               )
+              )*  ## must NOT end with space or dash(-)
+              ##  todo/fix - possible in regex here
+              ##     only end in alphanum a-z0-9 (not dot or & ???)
+
+
+            ## allow optional at the end
+            ##  tag or year
+            ##   make it and in the future - why? why not?
+            ##
+            ## change - fix
+            ##   do NOT use (A) for amateur
+            ##   use A or A. with NO ()!!!
+            ## (A) -    allow with predined  alpha only for now
+            ##          e.g. (A) - amateur a team or b?
+            ###  same for U21 or U9 etc
+            ##        use with NO ()!!! - why? why not?
+            ##      or U21 U9 etc.   - why? why not?
+            ##       or etc.
+            ## (1879-1893) or allow years e.g. (1879-1893)
+            ###
+            ##    add allow country code three to five letters for now
+            ##       change to generic 1 to 5 - why? why not?
+            ##     e.g. (A), (I),
+            ##          (AUT)
+            ##          (TRNC)   five? for UEFA code for northern cyprus
+            ##     change to 1 to 4 - why? why not?
+            ##   check - fix possible for upper case only here
+            ##                     inline for this group only?
+            (?:
+               [ ]
+               \(
+                  \d{4}-\d{4}
+               \)
+            )?
+             (?:
+                ######
+                # check for country code (cc)
+                #       e.g. (AUT) or ,AUT or AUT
+                (?:
+               [ ]   ## note - do NOT allow more than one space!!! - why? why not?
+                   \(
+                       ## note - auto-exclude reserved (aet)  from SCORE_FULLER_MORE!!!
+                       ##     plus golden goal (gg)/sudden death (sd), silver goal (sg)
+                       ##    (ht), (ft)
+                       (?! (?: aet | agget | asdet | asget | ht | ft )
+                             \)
+                       )
+                     (?:
+                       [A-Z]{1,5}
+                     )
+                  \)
+                )
+                  |
+                (?:
+                    [ ]*[,›>][ ]*
+                        [A-Z]{1,5}
+                     \b
+                )
+             )?
+            ## add lookahead/lookbehind
+           ##    must be space!!!
+           ##   (or comma or  start/end of string)
+           ##   kind of \b !!!
+            ## positive lookahead
+            (?=[ ,;@|\[\]]
+                 |$
+            )
+   )
+}ix
+
+
+
+
+
+###
+## helper for testing regex match for team names
+
+def self._parse_team( str )
+    ## note - strip - leading/trailing spaces
+    m = TEXT_RE.match( str.strip )
+    if m && m.pre_match == '' && m.post_match == ''
+      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-time.rb

@@ -0,0 +1,144 @@
+module Fbtxt
+class Lexer
+
+
+
+##
+#  keep 18h30 - why? why not?
+#    add support for 6:30pm 8:20am etc. - why? why not?
+#
+#    check - only support h e.g. 18h30  or 18H30 too - why? why not?
+# e.g. 18:30 (or 18h30)
+#   note - optional timezone possible e.g.
+#        18:30 UTC+1   or 18:30 BST/UTC+1  or such!!!
+#        18:30 UTC+01  or 18:30 BST/UTC+01
+#
+#
+#  note  18.30 no longer supported - MUST use 18:30 or 18h30 !!!
+#
+#
+#
+#   note -  local time is now (inline) part of time!!!
+#              and, thus, must always follow time
+#                     e.g. 18:30 (19:30 BST)
+#
+##    local time e.g (19:30 UTC+1) or (19:30 BST/UTC+1) or
+##   note - timezone is optional!  e.g. (19:30) works too
+
+
+TIME_RE = %r{
+        \b
+    (?<time>
+             (?<hour>\d{1,2})
+                   [:h]
+              (?<minute>\d{2})
+
+                 #### optional (inline) timezone
+                 ##    note - non-utc timezone MUST be hard-coded (added) here!!!
+                 ##     avoids eating-up team names (separated by one space)
+                 ##            e.g.  18:30 MEX v MEX
+                 (?:
+                    [ ]  ## require space - why? why not
+                     (?<timezone>
+                        (?:
+                          ## GMT   - Greenwich Mean Time
+                          ## BST   - British Summer Time
+                          ## CES?T - Central European (Summer) Time
+                          ## EES?T - Eastern European (Summer) Time
+                          ##
+                          (?: GMT|BST|CES?T|EES?T)
+                               (?: /
+                                   UTC  (?: [+-]\d{1,4} | ±0)
+                               )?
+                          )
+                          |
+                          (?:
+                             UTC  (?: [+-]\d{1,4} | ±0)
+                          )
+                     )
+                 )?
+        )
+      \b
+
+####
+###  note - local time is now INLINE and MUST follow time
+       (?:
+           [ ]+   ## todo/check - make space optional - why? why not?
+           \(
+        (?<time_local>
+                (?<local_hour>\d{1,2})
+                   [:h]    ### todo/fix - MUST match style in time above!!!
+                           ###   use capture with backref!!!!
+                (?<local_minute>\d{2})
+
+                ####
+                ## optional "local" timezone name eg. BRT or CEST etc.
+                (?:
+                    [ ] ## require space - why? why not
+                   (?<local_timezone>
+                      (?:  [A-Z]{3,4}
+                           (?: /
+                                   UTC (?: [+-]\d{1,4} | ±0)
+                           )?
+                      )
+                      |
+                      (?:     ## e.g. 0 or 00 or 0000
+                          UTC   (?: [+-]\d{1,4} | ±0)
+                      )
+                  )
+               )?  # note - make timezone  optional!!!
+          )
+      \)
+       )?
+}ix
+
+
+def self._build_time( m )
+              ## unify to iso-format
+              ###   12.40 => 12:40
+              ##    12h40 => 12:40 etc.
+              ##  keep string (no time-only type in ruby)
+              data = { time: {} }
+
+              hour     = m[:hour].to_i(10)  ## allow 08/07/etc.
+              minute   = m[:minute].to_i(10)
+
+              ##   check if 24:00 possible? or only 0:00 (23:59)
+              unless (hour   >=0 && hour   <=23) &&
+                     (minute >=0 && minute <=59)
+                 raise ArgumentError, "parse error - time >#{m[:time]}< out-of-range"
+              end
+
+              data[:time][:h] = hour
+              data[:time][:m] = minute
+              data[:time][:timezone] = m[:timezone]    if m[:timezone]
+
+
+              ## check if local time present e.g.
+              ##    18:30 (19:30)
+              ##    18:30 (19:30 BST)  etc.
+              if m[:time_local]
+                  data[:time_local] = {}
+
+                local_hour     = m[:local_hour].to_i(10)  ## allow 08/07/etc.
+                local_minute   = m[:local_minute].to_i(10)
+
+                ##   check if 24:00 possible? or only 0:00 (23:59)
+                unless (hour   >=0 && hour   <=23) &&
+                       (minute >=0 && minute <=59)
+                   raise ArgumentError, "parse error - local time >#{m[:time_local]}< out-of-range"
+                end
+
+                data[:time_local][:h] = local_hour
+                data[:time_local][:m] = local_minute
+                data[:time_local][:timezone] = m[:local_timezone]    if m[:local_timezone]
+              end
+
+              data
+end
+def _build_time(m) self.class._build_time(m); end
+
+
+
+end  #   class Lexer
+end  # module Fbtxt

data/lib/fbtxt/parser/token.rb

@@ -0,0 +1,224 @@
+
+
+module Fbtxt
+class Lexer
+
+
+
+###
+## add att(endance) e.g.  att: 18000
+##
+##    A v B 2-1  att: 18000
+
+ATTENDANCE_RE = %r{
+    (?<attendance>
+     \b
+        (?: attendance|att )
+            : [ ]*
+         (?<value>
+              [1-9]
+              (?: _? \d+ )*
+         )
+     \b
+)}ix
+
+
+
+
+###
+##   home/away/neutral  - (h), (a), (n)
+##    add support for h/a/n
+##       with (?-i \b [han] \b) lower-case and \b boundry - why? why not?
+
+TEAM_HOME_RE     = %r{  (?<team_home> \(h\) )}ix
+TEAM_AWAY_RE     = %r{  (?<team_away> \(a\)  )}ix
+TEAM_NEUTRAL_RE  = %r{  (?<team_neutral> \(n\) )}ix
+
+
+
+
+
+##
+## note VS
+##  remove VS for now
+##  e.g.     Olympia Wijgmaal v VS Kortenaken
+
+
+
+## note - only match case sensitive (downcased letters)!!!
+## note -  bigger match first e.g. vs than v etc.
+VS_RE = %r{
+    (?<vs>
+       (?<=[ ])	# positive lookBEHIND for space
+       (?-i:
+           vs\.?|v
+       )
+       (?=[ ])   # positive lookAHEAD for space
+    )
+}ix
+
+
+##
+## ▪SF  or ▪1,▪17, etc.
+##   note - only numbers and upcase allowed
+##                limited to two-letters for now - make more generic - why? why not?
+##                may add SF1, SF2, or such later !!!
+INLINE_ROUND_SHORT_RE = %r{
+         (?<inline_round_short>
+               ▪
+            (?<inline_round_text>
+                    [0-9]+
+                  | [A-Z]{1,2} [0-9]*
+              )
+          (?= [ ]|$)   # positive lookAHEAD for space (or end-of-line)
+        )}x
+
+###
+##  ▪ Replay
+##  ▪ 1st Leg
+INLINE_ROUND_BIG_RE = %r{
+       (?<inline_round_big>
+            ▪ [ ]
+             (?<inline_round_text>
+                [^\[\(@]+?  ## note - non-greedy
+                            ##   allow commas (,) or slash(/) - why? why not?
+              )
+          (?= [ ]{2}|$)   # positive lookAHEAD for TWO(!) spaces (or end-of-line)
+        )}x
+
+
+
+
+##############
+## "top-level" regex used for:
+##    - date_header
+##    - match_header & match_line_more
+##    - match_line
+
+RE = Regexp.union(
+                    SPACES_RE,
+
+                    INLINE_ROUND_SHORT_RE,
+                    INLINE_ROUND_BIG_RE,
+
+                    STATUS_RE,   ## match status e.g. [cancelled], etc.
+
+                    INLINE_WO_RE,    ## (inline) match status - w/o (walkout)
+                    INLINE_NP_RE,    ## (inline) match status - n/p (not played)
+                    INLINE_BYE_RE,   ## (inline) match status - bye (advance to next round)
+                    INLINE_ABD_RE,   ## (inline) match status - abd/abd. (abandoned)
+                    INLINE_SUSP_RE,  ## (inline) match status - susp/susp.  (suspended)
+                    INLINE_PPD_RE,   ## (inline) match status - ppd/ppd. or pstp/pstp. or postp/postp. or p-p (postponed)
+                    INLINE_VOID_RE,  ## (inline) match status - x-x (voided)
+                    INLINE_AWD_RE,   ## (inline) match status - awd/awd. (awarded)
+                    INLINE_CANC_RE,  ## (inline) match status - canc/canc. (cancelled/canceled)
+
+
+                    TEAM_HOME_RE,     ## (H)
+                    TEAM_AWAY_RE,     ## (A)
+                    TEAM_NEUTRAL_RE,  ## (N)
+
+                    NOTE_RE,  ### fix - change to INLINE_NOTE !!!
+                    DATE_LEGS_RE,  # note - must go before date!!!
+                    DATE_RE,  ## note - date must go before time (e.g. 12.12. vs 12.12)
+                    TIME_RE,
+
+                    ATTENDANCE_RE,   # note - allow att: for now inline in matches too - why? why not?
+
+                    SCORE_FULL_1ST_RE, # note - MUST go before SCORE_LEGS_RE!!
+                                       ##   e.g. 2-2, 5-1 pen.
+                    SCORE_LEGS_RE,
+                    SCORE_FULL_RE,
+                    SCORE_FULLER_RE,
+                    SCORE_FULLER_MORE_RE,
+                    SCORE_AWD_RE,   #  (inline) score awarded e.g. 3-0 awd or 0-1 awd. etc.
+                    SCORE_ABD_RE,   #  (inline) score abandoned e.g. 2-1 abd.
+                    SCORE_RE,   ## note basic score e.g. 1-1 must go after SCORE_FULL_RE!!!
+
+                    VS_RE,
+
+                   TEXT_RE,
+
+              %r{ (?<sym> [,@()-] ) }x,   ## todo - check if "standalone" comma (,) in use?
+                   ANY_RE,
+                      )
+
+
+
+
+
+
+##  ord (for ordinal number)
+##   e.g. (51) or (1) etc.  - limit digits of number - why? why not???
+
+START_WITH_ORD = %r{
+   \A
+    [ ]*    ## ignore leading spaces (if any)
+     (?<ord>
+       \(
+        (?<value>\d+)
+       \)
+     )}ix
+
+
+###
+##   e.g. 1930, 1986, 2002, 2010, 2022, 2026
+##         note - only YYYY
+##    note - look out for clubs like  1860 München (de) !!!
+##                                    1899 Hoffenheim (de)
+##                                    1896 Löwenherz  (ch - a.k.a. FC Winterthur ??)
+##                    any others starting with YYYY ?!
+##    note - YEAR requires TWO (trailing) spaces !!!!! e.g.
+##       1930    Uruguay             4-2 Argentina
+##       1934    Italy               2-1 Czechoslovakia   (AET)
+##       2022    Argentina           3-3 France           (AET, 4-2 pen)
+##
+##     do NOT match (iso date!!) -  2020-11-12
+##                                  2020/11/12
+##                                  2020.11.12 etc.
+
+START_WITH_YEAR = %r{
+   \A
+       [ ]*    ## ignore leading spaces (if any)
+     (?<year>
+        \d{4}
+     )
+     ## positive lookahead
+       (?= [ ]{2} |   ## min. TWO spaces!!! or
+           [ ]@ |   ##   space with geo marker or
+           [ ]* \z  ##    year (date) header (end-of-line/string)
+        )
+}x
+
+
+
+###
+## check for headings
+##    e.g.  = heading 1
+##          == heading 2  etc.
+##          =Eurochampionship=
+##    note  -  no spaces required (same as in wikipedia!!)
+##             same as in wikipedia support six (6) levels
+##
+##  note - use \A (instead of ^) - \A strictly matches the start of the string.
+
+
+HEADING_RE = %r{   \A
+                           [ ]*  ## ignore leading spaces (if any)
+                         (?<heading_marker> ={1,6} )
+                           [ ]*
+                            (?<heading>
+                               ## must start with letter - why? why not?
+                               ###   1st round
+                               ##  allow numbers e.g. Group A - 1
+                               [^=]+?   ## use non-greedy
+                            )
+                           [ ]*  ## ignore trailing spaces (if any)
+                            (?: =*)  ## allow any trailing heading markers
+                           [ ]*  ## ignore trailing spaces (if any)
+                         \z
+                       }ix
+
+
+end  # class Lexer
+end # module Fbtxt