fbtxt-lexer 0.0.1

data/lib/fbtxt/lexer/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/lexer/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/lexer/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

data/lib/fbtxt/lexer/token-score.rb

@@ -0,0 +1,60 @@
+module Fbtxt
+class Lexer
+
+
+###
+##
+##  add support for score awarded (inline style)
+##    3-0 awd  3-0 awd. 3-0awd
+##    0-1 awd  or 0-1 AWD etc.
+
+##
+##   note - keep AWD w/o dot - why? why not?
+
+SCORE_AWD_RE  = %r{
+            (?<score_awd>
+              \b
+               (?<score1>\d{1,2}) - (?<score2>\d{1,2})
+                 [ ]?
+                   (?-i: awd\.? | AWD )
+               ## POSITIVE lookahead - requires space
+               (?= [ ])
+             )}ix
+
+###
+##
+##  add support for score abandoned (inline style)
+##       2-1 abd.   or 2-1 ABD
+SCORE_ABD_RE  = %r{
+            (?<score_abd>
+              \b
+               (?<score1>\d{1,2}) - (?<score2>\d{1,2})
+                 [ ]?
+                  (?-i: abd\.? | ABD )
+               ## POSITIVE lookahead - requires space
+               (?= [ ])
+             )}ix
+
+#####
+##      2-1
+###
+###  note - was SCORE__FT__RE
+###           changed to "generic" SCORE_RE
+###                and
+##             (?<ft1>\d{1,2}) - (?<ft2>\d{1,2})
+##      changed
+##             (?<score1>\d{1,2}) - (?<score2>\d{1,2})
+##                to
+##             pattern match not necessarily the full-time (ft) scoreline!!!
+##    - pattern also used for goal seq(uence) e.g. 1-0 Kane, 1-1 Johnson
+SCORE_RE  = %r{
+            (?<score>
+              \b
+               (?<score1>\d{1,2}) - (?<score2>\d{1,2})
+              \b
+             )}ix
+
+
+
+end # class Lexer
+end # module Fbtxt