fbtxt-parser 0.9.0

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

@@ -0,0 +1,309 @@
+###
+##  team prop mode e.g.
+##
+##
+##    Fri Jun 14 21:00  @ München Fußball Arena, München
+##     Germany  v  Scotland   5-1 (3-0)
+##  (Wirtz 10' Musiala 19' Havertz 45+1' (pen.) Füllkrug 68' Can 90+3'; Rüdiger 87' (o.g.))
+##
+## Germany:    Neuer - Kimmich, Rüdiger, Tah [Y], Mittelstädt - Andrich [Y] (Groß 46'),
+##       Kroos (Can 80') - Musiala (Müller 74'), Gündogan, Wirtz (Sane 63') -
+##       Havertz (Füllkrug 63')
+## Scotland:   Gunn - Porteous [R 44'], Hendry, Tierney (McKenna 78') - Ralston [Y],
+##       McTominay, McGregor (Gilmour 67'), Robertson - Christie (Shankland 82'),
+##       Adams (Hanley 46'), McGinn (McLean 67')
+
+
+module Fbtxt
+class Lexer
+
+
+##############
+#  add support for props/ attributes e.g.
+#
+#    Germany:    Neuer - Kimmich, Rüdiger, Tah [Y], Mittelstädt - Andrich [Y] (46' Groß),
+#      Kroos (80' Can) - Musiala (74' Müller), Gündogan,
+#      Wirtz (63' Sane) - Havertz (63' Füllkrug)
+#    Scotland:   Gunn - Porteous [R 44'], Hendry, Tierney (78' McKenna) - Ralston [Y],
+#      McTominay, McGregor (67' Gilmour), Robertson - Christie (82' Shankland),
+#      Adams (46' Hanley), McGinn (67' McLean)
+#
+## note:  colon (:) MUST be followed by one (or more) spaces
+##      make sure mon feb 12 18:10 will not match
+##        allow 1. FC Köln etc.
+##               Mainz 05:
+##           limit to 30 chars max
+##          only allow  chars incl. intl but (NOT ()[]/;)
+##
+##
+##  note - use special \G - Matches first matching position !!!!
+##     check for \G like backreference of regex tokens/parts if possible/available in ruby?
+
+
+
+  ## (i) starting w/ letters
+  ##                   note - incl./allows digits (0-9)
+  ##          e.g. a1, a2000, etc.
+  ##
+  ## note - added back optional trailing dot (.) for abbrev. word  !!!
+  PROP_KEY_WORD_ = %r{
+                           \p{L}
+                             [\p{L}\d]*
+                             \.?
+                    }ix
+
+  ## note - incl. optional dot or numsign e.g. 1. or 1°
+  PROP_KEY_NUM_ = %r{
+                              \d+
+                              [.°]?
+                   }ix
+
+  ## e.g. 1A, 1FC etc.
+  ##  note - no trailing dot (.) for now - check if any cases exist in real world
+  PROP_KEY_NUMALPHA_ = %r{
+                              \d+
+                              \p{L}
+                               [\p{L}\d]*
+                     }ix
+
+
+
+
+
+  START_WITH_PROP_KEY_RE = %r{
+                   \A         ## note - MUST start line; leading spaces optional (eat-up)
+                 (?<prop_key>
+                     [ ]*     ##  optional leading spaces
+                   (?<key>
+                       (?:
+                           ## (i) starting w/ letters
+                             #{PROP_KEY_WORD_}
+
+                           ## (ii) starting w/ number
+                           ##  e.g. 1fc, 1a,
+                           | #{PROP_KEY_NUMALPHA_}
+                           ##      followed by optional dot) and
+                           ##                  optional space
+                           ##      MUST be follow by letter (a to z)!!!!
+                           ##   eg. 1[ fc], 1.[ fc], 1.[fc],  etc.
+                           | #{PROP_KEY_NUM_}   (?= [ ]? \p{L})
+                       )
+                       (?:
+                           ## connectors  - note - no dot (.), must match with abbrev word or num!!
+                            (?: ## (i)   single space or WITHOUT surrounding spaces!! - slash (/), dash (-)
+                                ##     e.g. do NOT match   one - two     or one / two
+                                ##                        only one-two   or  one/two
+
+                                  [ /-]
+
+                                ## (ii)     surrounded by leading or trailing optional space
+                                ##            c & a, etc.
+                                ##            d'ivoire, d' ivoire
+                                ##            borusia 'gladbach etc.
+                                ##              exclude space ' space - why? why not? (or ignore for now)
+                                ##
+                                ##    check for quotes  ('') - not realy supported here
+                                ##              e.g. leading or trailing ' will NOT match
+
+                                 |  [ ]? & [ ]?
+                                 |  [ ]? '
+                                 |  ' [ ]?
+
+                                #### (iii)
+                                ##   note - special "hack"  to connect WITHOUT space
+                                ##     for   Union 1.FC  and SKN St.Pölten or St.Pölten
+                                ##       connects      1.FC      => NUM+WORD
+                                ##                     1°Mayo    => NUM+WORD
+                                ##                     St.Pölten => ABBREV+WORD
+                                ##
+                                ## note - match WITHOUT (space) connector
+                                ##                  1.FC  (Union 1.FC Stein)
+                                ##               [WORD: "Union"], [NUM: "1."], [WORD: "FC"]
+                                ##                  St.Pölten (SKN St.Pölten)
+                                ##                [WORD: "SKN"], [ABBREV: "St."], [WORD: "Pölten"]
+                                |   (?<=  [.°] )
+                                    (?=  \p{L})
+                            )
+                             (?:
+                                   #{PROP_KEY_NUMALPHA_}
+                                |  #{PROP_KEY_NUM_}
+                                |  #{PROP_KEY_WORD_}
+                               )
+                       )*
+                      )       ## close <key> capture
+                    [ ]*?     ## slurp trailing spaces
+                     :
+
+                ## positive lookahead (must be followed by space!!)
+                ##     or allow end-of-line too
+                    (?= [ ]+|$)
+                   )  ## close <prop_key> capture
+                 }ix
+
+
+
+
+
+################
+##     todo/check - use token for card short cuts?
+##                if m[:name] == 'Y'
+##                 [:YELLOW_CARD, m[:name]]
+##               elsif m[:name] == 'R'
+##                 [:RED_CARD, m[:name]]
+##           -  [Y], [R], [Y/R]  Yellow-Red Card
+##    check if minutes possible inside [Y 46']
+##     add [c] for captain too
+
+
+##  [c] or [C] for marking player as captain
+##   support [y ] too - or require Y - why? why not?
+  INLINE_CAPTAIN = %r{ (?<inline_captain>
+                           \[ [cC] \]
+                       )}x
+
+  INLINE_YELLOW  = %r{ (?<inline_yellow>
+                          \[ [yY]
+                              ## optional minute
+                              (?: [ ]+
+                                (?<minute> \d{1,3})
+                                   '?
+                                (?:
+                                   \+
+                                   (?<offset>\d{1,2})
+                                    '?
+                                )?
+                              )?
+                          \]
+                     )}x
+
+  INLINE_RED  = %r{ (?<inline_red>
+                          \[ [rR]
+                              ## optional minute
+                              (?: [ ]+
+                                (?<minute> \d{1,3})
+                                   '?
+                                (?:
+                                   \+
+                                   (?<offset>\d{1,2})
+                                    '?
+                                )?
+                              )?
+                          \]
+                     )}x
+
+  INLINE_YELLOW_RED  = %r{ (?<inline_yellow_red>
+                          \[ (?:y/r |
+                                Y/R  )
+                              ## optional minute
+                              (?: [ ]+
+                                (?<minute> \d{1,3})
+                                   '?
+                                (?:
+                                   \+
+                                   (?<offset>\d{1,2})
+                                    '?
+                                )?
+                              )?
+                          \]
+                     )}x
+
+
+
+
+### simple prop key for inline use e.g.
+###    Coach:  or Trainer:  or ...  add more here later
+
+  PROP_KEY_INLINE_RE = %r{
+                    \b
+                 (?<prop_key>    ## note: use prop_key (NOT prop_key_inline or such)
+                   (?<key>
+                       \p{L}+
+                   )
+                    ## note - NO spaces allowed for key for now!!!
+                     :
+                    ## possitive lookahead (must be followed by space!!)
+                    (?=[ ]+)
+                   )
+                 }ix
+
+
+
+## note allow underscore inline e.g.
+##  5_000
+## discuss/check - allow space inline (e.g. 5 000) - why? why not?
+
+PROP_NUM_RE = %r{
+             \b
+              (?<num>
+                  (?<value> [0-9]+
+                             (?: _ [0-9]+)*
+                  )
+              )
+             \b
+            }x
+
+
+### todo/fix - allow more chars in enclosed name  - why? why not?
+##                     e.g.  (') - Cote D'Ivore etc.
+##  change to PAREN_NAME or PARENTHESIS or such - why? why not?
+ENCLOSED_NAME_RE = %r{
+                 (?<enclosed_name>
+                    \(
+                   (?<name>
+                       \p{L}+
+                       (?:
+                          [ ]
+                            \p{L}+
+                       )*
+                   )
+                     \)
+                 )
+         }ix
+
+
+
+
+###
+##  e.g.   -; ...   or
+##         None - ... or
+CARDS_NONE_LEFT_RE = %r{ (?<cards_none_left>
+                         ## (i) w/ semicolon (;)
+                            (?:  (?: - | \bnone)
+                                  [ ]* ;
+                            )
+                         ## (ii) w/ dash (-)
+                          | (?:   (?: ∅ | \bnone)
+                                  [ ]+ -        ##    space REQUIRED
+                                  (?=[ ]|\z)    ## positive lookahead - speace required
+                            )
+                    )}ix
+
+## e.g   ... ;-
+##    or ... ; None
+CARDS_NONE_RIGHT_RE = %r{ (?<cards_none_right>
+                        ## (i) w/ semicolon (;)
+                           (?:   ; [ ]*
+                               (?:   - | none\b)
+                           )
+                        ## (ii) w/ dash (-)
+                          | (?:
+                               (?<=[ ])      ## positive lookbehind - space required
+                                - [ ]+       ##    space REQUIRED
+                               (?:  ∅ | none\b)
+                            )
+                      )}ix
+
+
+CARDS_SEP_ALT_RE = %r{(?<cards_sep_alt>
+              (?<=[ ])      ## positive lookbehind - space required
+                -
+              (?=[ ]|\z)    ## positive lookahead - speace required
+             )}x
+
+
+
+
+
+
+end  # class Lexer
+end  # module Fbtxt

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

@@ -0,0 +1,83 @@
+module Fbtxt
+class Lexer
+
+
+##
+##  see token-text for TEXT_RE
+##          change PROP_NAME_RE to   TEXT_II or TEXT_???  - why? why not?
+###   no do NO change
+##    change TEXT_RE to TEAM_RE or TEAM_NAME_RE !!!!
+##          it is NOT generic TEXT regex!!!
+
+
+
+
+PROP_NAME_WORD_ = %r{
+                           \p{L}+
+                             \.?     ## optional dot
+                    }ix
+
+
+## todo/fix - remove support for double quotes e.g. "Rodri"  - why? why not?
+##
+
+## name different from text (**does NOT allow number in name/text**)
+##      different from PROP_KEY too
+PROP_NAME_RE = %r{
+                 (?<prop_name>
+                      \b
+                   (?<name>
+                        #{PROP_NAME_WORD_}
+
+                          ## connectors
+                          (?:
+                             ## (i) space - only one single space allowed inline!!!
+                              (?:
+                               ### check if negative lookbehind is redudant!!
+                               ##    next char is \p{L} and NOT space
+                               ##    thus double space not possible!!
+                                (?<! [ ])             ## use negative lookbehind
+                                  [ ]
+                                (?=  \p{L}|['"]\p{L})      ## use lookahead
+                              )
+                              ## (ii) support (inline) quoted name e.g. "Rodri" or such
+                                 | (?:
+                                     (?<=[ ])   ## use positive lookbehind
+                                     " \p{L}+ "
+                                      ## require space here too - why? why not?
+                                   )
+                              ## (iii) dash (-)
+                              | (?:
+                                ## use  POSITIVE lookBEHIND
+                                ## note - allow leading dot (.) e.g. K.-H.Förster
+                                ##                short for          Karl-Heinz Förster
+                                ##
+                                ##    change to negative lookBEHIND   [ '"-]
+                                ##      \p{L}\. | \p{L} - not MUST be fixed size
+                                 (?<=
+                                         [\p{L}.]
+                                      )
+                                 [-]   ## must be surrounded by letters
+                                       ## e.g. One-Two NOT
+                                       ##      One- Two or One - Two or One -Two etc.
+                                (?= \p{L})      ## use lookahead
+                              )
+                                 |
+                              (?:  ## flex rule for quote - allow any
+                                    ##  only check for double quotes e.g. cannot follow other ' for now - why? why not?
+                                    ##        allows  rodrigez 'rodri' for example
+                                (?<!')  ## use negative lookbehind
+                                   '
+                              )
+                            |   ## standard case with letter(s) and optional dot
+                              #{PROP_NAME_WORD_}
+                          )*
+                    )
+                ## add lookahead - must be non-alphanum
+                ##    add colon (:) too - why? why not?
+                  (?= [ ,;\]\)]|$)
+)}ix
+
+
+end  # class Lexer
+end  # module Fbtxt

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

@@ -0,0 +1,88 @@
+module Fbtxt
+class Lexer
+
+####
+#
+##  note - use \A (instead of ^) - \A strictly matches the start of the string.
+##
+##  todo - add support for trailing markers e.g.
+##    ▪ Round 1 ▪▪▪▪▪▪▪▪
+##    :: Round 1 ::::::::::::
+##
+##  check - allow without space (like in heading =Heading 1=) - why? why not?
+##    ▪Round 1▪▪▪▪▪▪▪▪
+##    ::Round 1::::::::::::
+
+ROUND_OUTLINE_I_RE = %r{   \A
+                           [ ]*  ## ignore leading spaces (if any)
+                         (?<round_marker>
+                               [▪]{1,3}     ## BLACK SMALL SQUARE e.g. ▪,▪▪,▪▪▪
+                          )
+                           [ ]+
+                            (?<round_outline>
+                               ## must start with letter - why? why not?
+                               ###   1st round
+                               ##  allow numbers e.g. Group A - 1
+                               ##
+                               ##  note - CANNOT incl. :| !!!
+                               ##   used for markers for defs/definitions
+                               [^:|]+?   ## use non-greedy
+                            )
+                            (?:
+                               [ ]+
+                               [▪]+
+                            )?
+                            [ ]*  ## ignore trailing spaces (if any)
+                          \z
+                       }xi
+
+ROUND_OUTLINE_II_RE =  %r{   \A
+                           [ ]*  ## ignore leading spaces (if any)
+                         (?<round_marker>
+                                ::{1,3}     ## e.g. ::,:::,::::
+                          )
+                           [ ]+
+                            (?<round_outline>
+                               ## must start with letter - why? why not?
+                               ###   1st round
+                               ##  allow numbers e.g. Group A - 1
+                               ##
+                               ##  note - CANNOT incl. :| !!!
+                               ##   used for markers for defs/definitions
+                               [^:|]+?   ## use non-greedy
+                            )
+                            (?:
+                               [ ]+
+                               ::+
+                            )?
+                           [ ]*  ## ignore trailing spaces (if any)
+                          \z
+                       }xi
+
+ROUND_OUTLINE_RE = Regexp.union(  ROUND_OUTLINE_I_RE,
+                                  ROUND_OUTLINE_II_RE,
+                               )
+
+
+###
+#  note -  for def(initions) only one level support
+#             that is, no round outline additions possible (e.g ▪▪ 1st leg etc.)
+ROUND_DEF_OUTLINE_RE = %r{   \A
+                           [ ]*  ## ignore leading spaces (if any)
+                          (?: [▪]  ## BLACK SMALL SQUARE
+                               |
+                              :: )
+                           [ ]+
+                            (?<round_outline>
+                               [^:|]+?   ## use non-greedy
+                            )
+                           [ ]*  ## ignore trailing spaces (if any)
+                          ###   possitive 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-score--helpers.rb

@@ -0,0 +1,189 @@
+module Fbtxt
+class Lexer
+
+
+def self._build_score( m )
+             ##  note - score is "generic"
+            ##      might be full-time (ft) or
+            ##         after extra-time (aet) or such
+            ##         or even undecided/unknown
+            ##    thus, use score1/score2 and NOT ft1/ft2
+            ##      thus, use (simply an) array e.g. [1,2]
+            ##           and NOT hash (table) e.g. { ft: [1,2] } !!!
+
+            score  = [m[:score1].to_i(10),
+                      m[:score2].to_i(10)]
+
+           score
+end
+
+def self._build_score_awd( m )    # score awarded (awd/awd.)
+            ### note - use "generic" score for now
+            ##         to match  A 3-0 B [awarded] etc.
+            score = [m[:score1].to_i(10),
+                      m[:score2].to_i(10)]
+            ## add score[:awarded] = true ???
+            ##  note - for now uses its own token e.g SCORE_AWD
+            score
+end
+
+def self._build_score_abd( m )      # score abandonded (abd/abd.)
+            ### note - use "generic" score for now
+            score   = [m[:score1].to_i(10),
+                       m[:score2].to_i(10)]
+            ## add score[:abd] = true ???
+            ##  note - for now uses its own token e.g SCORE_ABD
+            score
+end
+
+
+def self._build_score_full( m )
+              score = {}
+              score[:p] = [m[:p1].to_i(10),
+                           m[:p2].to_i(10)]  if m[:p1] && m[:p2]
+              score[:et] = [m[:et1].to_i(10),
+                            m[:et2].to_i(10)]  if m[:et1] && m[:et2]
+              score[:ft] = [m[:ft1].to_i(10),
+                            m[:ft2].to_i(10)]  if m[:ft1] && m[:ft2]
+              score[:ht] = [m[:ht1].to_i(10),
+                            m[:ht2].to_i(10)]  if m[:ht1] && m[:ht2]
+
+              ## add golden/silver flags
+              score[:golden] = true   if m[:aetgg]  ## golden goal (gg)/sudden death (sd)
+              score[:silver] = true   if m[:aetsg]  ## silver goal (sg)
+
+              score
+end
+
+def self._build_score_fuller( m )
+              score = {}
+              score[:p] = [m[:p1].to_i(10),
+                           m[:p2].to_i(10)]  if m[:p1] && m[:p2]
+              score[:et] = [m[:et1].to_i(10),
+                            m[:et2].to_i(10)]  if m[:et1] && m[:et2]
+              score[:ft] = [m[:ft1].to_i(10),
+                            m[:ft2].to_i(10)]  if m[:ft1] && m[:ft2]
+              score[:ht] = [m[:ht1].to_i(10),
+                            m[:ht2].to_i(10)]  if m[:ht1] && m[:ht2]
+              score[:agg] = [m[:agg1].to_i(10),
+                             m[:agg2].to_i(10)]  if m[:agg1] && m[:agg2]
+
+              if m[:away1] && m[:away2]
+                 score[:away] = [m[:away1].to_i(10),
+                                 m[:away2].to_i(10)]
+              elsif m[:away]    ## fallback if no away score; check away flag
+                 score[:away] = true
+              end
+
+              ## add golden/silver flags
+              score[:golden] = true   if m[:aetgg]  ## golden goal (gg)/sudden death (sd)
+              score[:silver] = true   if m[:aetsg]  ## silver goal (sg)
+
+              score
+end
+
+
+def self._build_score_fuller_more( m )
+               ##    SCORE + SCORE_FULLER_MORE
+               ## note -  after extra-time (aet) or full-time (ft)
+               ##           score may be present in SCORE!!!
+              score = {}
+              score[:p] = [m[:p1].to_i(10),
+                           m[:p2].to_i(10)]  if m[:p1] && m[:p2]
+              score[:et] = [m[:et1].to_i(10),
+                            m[:et2].to_i(10)]  if m[:et1] && m[:et2]
+              score[:ft] = [m[:ft1].to_i(10),
+                            m[:ft2].to_i(10)]  if m[:ft1] && m[:ft2]
+              score[:ht] = [m[:ht1].to_i(10),
+                            m[:ht2].to_i(10)]  if m[:ht1] && m[:ht2]
+              score[:agg] = [m[:agg1].to_i(10),
+                             m[:agg2].to_i(10)]  if m[:agg1] && m[:agg2]
+
+              if m[:away1] && m[:away2]
+                 score[:away] = [m[:away1].to_i(10),
+                                 m[:away2].to_i(10)]
+              elsif m[:away]    ## fallback if no away score; check away flag
+                 score[:away] = true
+              end
+
+              ## add golden/silver flags
+              score[:golden] = true   if m[:aetgg]  ## golden goal (gg)/sudden death (sd)
+              score[:silver] = true   if m[:aetsg]  ## silver goal (sg)
+
+              ## add flag in score for et/ft/ht
+              ##    used for "dangling" (generic) score
+              score[:score] = 'et'   if m[:aet] || m[:aetgg] || m[:aetsg]
+              score[:score] = 'ft'   if m[:ft]
+              score[:score] = 'ht'   if m[:ht]
+
+              score
+end
+
+
+def self._build_score_legs( m )
+              legs = {}
+
+              ############
+              ### build leg1 (score)
+              score = {}
+              score[:ft] = [m[:leg1_ft1].to_i(10),
+                            m[:leg1_ft2].to_i(10)]
+              legs['leg1'] = score
+
+              ##################
+              ### build leg2 (score)
+              score = {}
+              score[:ft] = [m[:leg2_ft1].to_i(10),
+                            m[:leg2_ft2].to_i(10)]  if m[:leg2_ft1] && m[:leg2_ft2]
+              score[:et] = [m[:leg2_et1].to_i(10),
+                            m[:leg2_et2].to_i(10)]  if m[:leg2_et1] && m[:leg2_et2]
+              score[:p]  = [m[:leg2_p1].to_i(10),
+                            m[:leg2_p2].to_i(10)]  if m[:leg2_p1] && m[:leg2_p2]
+              legs['leg2'] = score
+
+              ## check for (opt) aggregate - keep on "top-level"
+              legs[:agg] = [m[:agg1].to_i(10),
+                            m[:agg2].to_i(10)]  if m[:agg1] && m[:agg2]
+              legs[:away] = true  if m[:away]
+
+              legs
+end
+
+
+def _build_score( m )             self.class._build_score( m ); end
+def _build_score_awd( m )         self.class._build_score_awd( m ); end
+def _build_score_abd( m )         self.class._build_score_abd( m ); end
+def _build_score_full( m )        self.class._build_score_full( m ); end
+def _build_score_fuller( m )      self.class._build_score_fuller( m ); end
+def _build_score_fuller_more( m ) self.class._build_score_fuller_more( m ); end
+def _build_score_legs( m )        self.class._build_score_legs( m ); end
+
+
+
+
+###
+## add parser helpers
+
+def self._parse_score_full( str )
+    ## note - strip - leading/trailing spaces automatic - why? why not?
+
+    m = Regexp.union(
+              SCORE_FULL_1ST_RE,
+              SCORE_FULL_RE ).match( str.strip )
+
+    if m && m.pre_match == '' && m.post_match == ''
+       pp m
+       _build_score_full( 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