sportdb-quick 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71f76e171de23b5062c30f432d5fece7bcb2cb0e7283d658dcf8ff79aefb6aa3
-  data.tar.gz: 74fc864d5c4b9ca42270abd3fdb941cebdb9857c072c7515e7e422829c018891
+  metadata.gz: 3d63bcffa581bc99cdc5dfaa7d80dd7dd8925dac90da349c43c6fdc5069e2c78
+  data.tar.gz: 1914dd71b5c39a2bea1eb58eca6126d31446a001ec0534656b943a865dc4a99b
 SHA512:
-  metadata.gz: 83fa67d7c4bbd0952ad9e02f93be65c488bd728b52f8a9a1159ab42bd299b6b9b37ff5e75573582ef4a7f20ebef1d97ff7da111334dd5f6b4b71bf4793ea84af
-  data.tar.gz: 9f832375e9d03fe1de7d83d14083428d0f3eda704645cf585449d13cf7929030552075549d68e0d91892be0d66c4bf92fbc41a2403cecee362025ed2b2058513
+  metadata.gz: e9ce783a2f8c21d49a6571b86310fe023578aa7604d39672b7b8a4468d708bbd0c9104522cf2632f38765043ef06707a2a39c33cb53146072ed17f86879b3ef7
+  data.tar.gz: 309f14ee3e37133d8d53d4c51f86e2ebecbe974a3489ce9571f840e9d6ab521956abc5adc6e4e6301e3267daccf3a61711bc0d4d13c129450044fdfa33ce15e3

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.5.1
+### 0.5.3
 ### 0.0.1 / 2024-08-27
 
 * Everything is new. First release.

data/Manifest.txt

@@ -4,6 +4,8 @@ README.md
 Rakefile
 lib/sportdb/quick.rb
 lib/sportdb/quick/match_parser.rb
-lib/sportdb/quick/quick_league_outline_reader.rb
+lib/sportdb/quick/outline.rb
+lib/sportdb/quick/outline_reader.rb
+lib/sportdb/quick/quick_league_outline.rb
 lib/sportdb/quick/quick_match_reader.rb
 lib/sportdb/quick/version.rb

data/lib/sportdb/quick/match_parser.rb

@@ -32,22 +32,36 @@ class MatchParser    ## simple match parser for team match schedules
 
 
 
-
-  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 = []
+  def _prep_lines( lines )   ## todo/check:  add alias preproc_lines or build_lines or prep_lines etc. - why? why not?
+
+    ## todo/fix - rework and make simpler
+    ##             no need to double join array of string to txt etc.
+
+    txt =  if lines.is_a?( Array )
+               ## join together with newline
+                lines.reduce( String.new ) do |mem,line|
+                                               mem << line; mem << "\n"; mem
+                                           end
+             else  ## assume single-all-in-one txt
+                lines
+             end
+
+    ##  preprocess automagically - why? why not?
+    ##   strip lines with comments and empty lines striped / removed
+    txt_new = String.new
     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
+       
+       txt_new << line
+       txt_new << "\n"
     end
-    lines
+    txt_new
   end
 
 
- 
   #
   # todo/fix: change start to start: too!!!
   #       might be optional in the future!! - why? why not?
@@ -58,10 +72,18 @@ class MatchParser    ## simple match parser for team match schedules
     ## todo/check: change to text instead of array of lines - why? why not?
 
     ## note - wrap in enumerator/iterator a.k.a lines reader
-    @lines = lines.is_a?( String ) ?
-                    _read_lines( lines ) : lines
+    ## @lines = lines.is_a?( String ) ?
+    ##                _read_lines( lines ) : lines
 
+    @txt          = _prep_lines( lines )    
+
+    ### todo/fix - FIX/FIX
+    ##     check start year from first date
+    ##    for now (auot-)update - @start with every date that incl. a year!!!
     @start        = start
+    @last_year    = nil
+
+
     @errors = []
   end
 
@@ -90,17 +112,9 @@ class MatchParser    ## simple match parser for team match schedules
     @tree   = []
 
 
-       ## flatten lines
-       txt  = []
-       @lines.each_with_index do |line,i|
-          txt << line
-          txt << "\n"
-       end
-       txt = txt.join
- 
          if debug?
            puts "lines:"
-           pp txt
+           pp @txt
          end
 
 =begin
@@ -123,7 +137,7 @@ class MatchParser    ## simple match parser for team match schedules
            @tree << t
 =end
 
-     parser = RaccMatchParser.new( txt )   ## use own parser instance (not shared) - why? why not?
+     parser = RaccMatchParser.new( @txt )   ## use own parser instance (not shared) - why? why not?
      @tree = parser.parse
      ## pp @tree
 
@@ -143,6 +157,8 @@ class MatchParser    ## simple match parser for team match schedules
           on_group_def( node )
        elsif node.is_a? RaccMatchParser::GroupHeader
           on_group_header( node )
+       elsif node.is_a? RaccMatchParser::RoundOutline
+          on_round_outline( node )
        elsif node.is_a? RaccMatchParser::RoundHeader
           on_round_header( node )
       elsif node.is_a? RaccMatchParser::DateHeader
@@ -151,6 +167,8 @@ class MatchParser    ## simple match parser for team match schedules
           on_match_line( node )
       elsif node.is_a? RaccMatchParser::GoalLine
           on_goal_line( node )
+      elsif node.is_a? RaccMatchParser::LineupLine
+           ## skip lineup for now
       else
         ## report error
         msg = "!! WARN - unknown node (parse tree type) - #{node.class.name}" 
@@ -159,7 +177,6 @@ class MatchParser    ## simple match parser for team match schedules
 
         log( msg )
         log( node.pretty_inspect )
-        ## exit 1
       end
     end  # tree.each
 
@@ -226,23 +243,31 @@ class MatchParser    ## simple match parser for team match schedules
       pp start
    end
 
+
     if y.nil?   ## try to calculate year
-      y =  if  m > start.month ||
-               (m == start.month && d >= start.day)
-                # assume same year as start_at event (e.g. 2013 for 2013/14 season)
-                start.year
-           else
-                 # assume year+1 as start_at event (e.g. 2014 for 2013/14 season)
-                start.year+1
-           end
+      if @last_year   ## use new formula
+         y = @last_year
+      else  ## fallback to "old" formula - FIX/FIX remove later
+         puts "[deprecated] WARN - do NOT use old year (date) auto-complete; add year to first date"
+         y =  if  m > start.month ||
+                 (m == start.month && d >= start.day)
+                  # assume same year as start_at event (e.g. 2013 for 2013/14 season)
+                  start.year
+              else
+                  # assume year+1 as start_at event (e.g. 2014 for 2013/14 season)
+                  start.year+1
+              end
+      end
+    else
+      ### note - reset @start to new date
+      ##            use @last_year
+      @last_year = y
     end
 
 
-
       Date.new( y,m,d )  ## y,m,d
   end
 
-
   def on_round_def( node )
     logger.debug "on round def: >#{node}<"
 
@@ -308,15 +333,51 @@ class MatchParser    ## simple match parser for team match schedules
   end
 
 
+
+  
+  def on_round_outline( node )
+    logger.debug "on round outline: >#{node}<"
+ 
+    ## always reset dates - why? why not?
+    ##    note - needs last_date for year
+    ##         track last_year with extra variable
+    
+    name  = node.outline
+
+    round = @rounds[ name ]
+    if round.nil?    ## auto-add / create if missing
+      ## todo/check: add num (was pos) if present - why? why not?
+      round = Import::Round.new( name: name )
+      @rounds[ name ] = round
+    end
+
+    ## todo/check: if pos match (MUST always match for now)
+    @last_round = round
+    @last_group = nil   # note: reset group to no group - why? why not?
+
+    ## todo/fix/check
+    ##  make round a scope for date(time) - why? why not?
+    ##   reset date/time e.g. @last_date = nil !!!!
+  end
+
+
   def on_round_header( node )
     logger.debug "on round header: >#{node}<"
 
-    name = node.names[0]    ## ignore more names for now
-                           ## fix later - fix more names!!!
+    ### note - auto-add names with - for now (use comma)
+    ##            why? why not?
+    ### check - use ' - ' for separator - why? why not?
+    name = node.names.join( ', ' )   
+=begin
+    ## note: was node.names[0]    ## ignore more names for now
+                                  ## fix later - fix more names!!!
+=end
 
-    # name = name.sub( ROUND_EXTRA_WORDS_RE, '' )
+   # name = name.sub( ROUND_EXTRA_WORDS_RE, '' )
     # name = name.strip
 
+
+
     round = @rounds[ name ]
     if round.nil?    ## auto-add / create if missing
       ## todo/check: add num (was pos) if present - why? why not?
@@ -566,18 +627,26 @@ class GoalStruct
     time_str = time    if date && time
 
 
-    ground = nil
+    ground   = nil
+    timezone = nil
+    if node.geo
+       ground = node.geo
+       ## note: only add/check for timezone if geo (aka ground) is present - why? why not?
+       timezone = node.timezone   if node.timezone
+    end
+
 
-    @matches << Import::Match.new( num:     num,
-                                   date:    date_str,
-                                   time:    time_str,
-                                   team1:   team1,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team1.name)
-                                   team2:   team2,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team2.name)
-                                   score:   score,
-                                   round:   round       ? round.name       : nil,   ## note: for now always use string (assume unique canonical name for event)
-                                   group:   @last_group ? @last_group.name : nil,   ## note: for now always use string (assume unique canonical name for event)
-                                   status:  status,
-                                   ground:  ground )
+    @matches << Import::Match.new( num:      num,
+                                   date:     date_str,
+                                   time:     time_str,
+                                   team1:    team1,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team1.name)
+                                   team2:    team2,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team2.name)
+                                   score:    score,
+                                   round:    round       ? round.name       : nil,   ## note: for now always use string (assume unique canonical name for event)
+                                   group:    @last_group ? @last_group.name : nil,   ## note: for now always use string (assume unique canonical name for event)
+                                   status:   status,
+                                   ground:   ground,
+                                   timezone: timezone )
     ### todo: cache team lookups in hash?
   end
 end # class MatchParser

data/lib/sportdb/quick/outline.rb

@@ -0,0 +1,96 @@
+
+module SportDb
+
+###
+#  add a simple Outline convenience class
+#            for processing OUtlines with OUtlineReader
+#   rename to simply Outline - why? why not?
+#     todo - add more processing options - why? why not?
+
+class Outline
+   def self.read( path )
+       nodes = OutlineReader.read( path ) 
+       new( nodes )
+   end    
+   
+   def self.parse( txt )
+       nodes = OutlineReader.parse( txt )
+       new( nodes )
+   end
+
+
+   def initialize( nodes )
+      @nodes = nodes
+   end
+
+   def each_para( &blk )
+     ## note: every (new) read call - resets errors list to empty
+     ### @errors = []
+
+     ##  process nodes
+     h1 = nil
+     h2 = nil
+     orphans = 0    ## track paragraphs's with no heading
+
+     @nodes.each do |node|
+        type = node[0]
+
+        if type == :h1
+           h1 = node[1]  ## get heading text
+           puts "  = Heading 1 >#{node[1]}<"
+        elsif type == :h2
+           if h1.nil?
+             puts "!! WARN - no heading for subheading; skipping processing"
+             next
+           end
+           h2 = node[1]  ## get heading text
+           puts "  == Heading 2 >#{node[1]}<"
+        elsif type == :p
+           if h1.nil?
+             orphans += 1    ## only warn once
+             puts "!! WARN - no heading for #{orphans} text paragraph(s); skipping parse"
+             next
+           end
+
+           lines = node[1]
+           blk.call( lines )
+        else
+          pp node
+          raise ArgumentError, "unsupported (node) type >#{type}<"
+        end
+     end  # each node
+   end  # each_para
+   alias_method :each_paragraph, :each_para
+
+
+## get all para(graphs) as text (not array of lines)
+##   make default - why? why not?
+#
+#   design - or wrap lines into a Para class
+#                       with properties  lines and text
+#                          and such - why? why not?
+#          downside - might be overkill/overengineered
+#               just use simple txt as string (buffer) for all - why? why not?
+##
+##  hacky alternative - add a to_text or text method to string and array - why? why not?
+
+
+   def each_para_text( &blk )   ## or use each_text or ? - why? why not=
+       each_para do |lines|
+           txt = lines.reduce( String.new ) do |mem,line| 
+                                     mem << line; mem << "\n"; mem 
+                                    end
+           blk.call( txt )
+       end
+   end
+end   # class Outline
+
+
+
+###
+#  add alternate alias - why? why not?
+QuickMatchOutline = Outline
+
+
+end   ## module SportDb
+ 

data/lib/sportdb/quick/outline_reader.rb

@@ -0,0 +1,98 @@
+
+
+module SportDb
+
+  
+class OutlineReader
+
+  def self.debug=(value) @@debug = value; end
+  def self.debug?() @@debug ||= false; end
+  def debug?()  self.class.debug?; end
+
+
+
+  def self.read( path )   ## use - rename to read_file or from_file etc. - why? why not?
+    txt = File.open( path, 'r:utf-8' ) {|f| f.read }
+    parse( txt )
+  end
+
+  def self.parse( txt )
+    new( txt ).parse
+  end
+
+  def initialize( txt )
+    @txt = txt
+  end
+
+  ## note: skip "decorative" only heading e.g. ========
+  ##  todo/check:  find a better name e.g. HEADING_EMPTY_RE or HEADING_LINE_RE or ???
+  HEADING_BLANK_RE = %r{\A
+                        ={1,}
+                        \z}x
+
+  ## note: like in wikimedia markup (and markdown) all optional trailing ==== too
+  HEADING_RE = %r{\A
+                  (?<marker>={1,})       ## 1. leading ======
+                    [ ]*
+                  (?<text>[^=]+)         ## 2. text   (note: for now no "inline" = allowed)
+                    [ ]*
+                    =*                   ## 3. (optional) trailing ====
+                  \z}x
+
+  def parse
+    outline=[]   ## outline structure
+    start_para = true      ## start new para(graph) on new text line?
+
+    @txt.each_line do |line|
+        line = line.strip      ## todo/fix: keep leading and trailing spaces - why? why not?
+
+        if line.empty?    ## todo/fix: keep blank line nodes?? and just remove comments and process headings?! - why? why not?
+          start_para = true
+          next
+        end
+
+        break if line == '__END__'
+
+        next if line.start_with?( '#' )   ## skip comments too
+        ## strip inline (until end-of-line) comments too
+        ##  e.g Eupen | KAS Eupen ## [de]
+        ##   => Eupen | KAS Eupen
+        ##  e.g bq   Bonaire,  BOE        # CONCACAF
+        ##   => bq   Bonaire,  BOE
+        line = line.sub( /#.*/, '' ).strip
+        pp line    if debug?
+
+        ## todo/check: also use heading blank as paragraph "breaker" or treat it like a comment ?? - why? why not?
+        next if HEADING_BLANK_RE.match( line )  # skip "decorative" only heading e.g. ========
+
+         ## note: like in wikimedia markup (and markdown) all optional trailing ==== too
+        if m=HEADING_RE.match( line )
+           start_para = true
+
+           heading_marker = m[:marker]
+           heading_level  = heading_marker.length   ## count number of = for heading level
+           heading        = m[:text].strip
+
+           puts "heading #{heading_level} >#{heading}<"   if debug?
+           outline << [:"h#{heading_level}", heading]
+        else    ## assume it's a (plain/regular) text line
+           if start_para
+             outline << [:p, [line]]
+             start_para = false
+           else
+             node = outline[-1]    ## get last entry
+             if node[0] == :p      ##  assert it's a p(aragraph) node!!!
+                node[1] << line    ## add line to p(aragraph)
+             else
+               puts "!! ERROR - invalid outline state / format - expected p(aragraph) node; got:"
+               pp node
+               exit 1
+             end
+           end
+        end
+    end
+    outline
+  end # method read
+end # class OutlineReader
+
+end # module SportDb

data/lib/sportdb/quick/{quick_league_outline_reader.rb → quick_league_outline.rb}

@@ -3,39 +3,66 @@
 module SportDb
 
 ## shared "higher-level" outline reader
-###   quick version WITHOUT any validation/mapping !!!
+###   quick version WITHOUT any (database) validation/mapping/normalization !!!
 
-class QuickLeagueOutlineReader
+
+class QuickLeagueOutline
 
   def self.read( path )
-    txt = File.open( path, 'r:utf-8' ) {|f| f.read }
-    parse( txt )
-  end
+    nodes = OutlineReader.read( path ) 
+    new( nodes )
+  end    
 
   def self.parse( txt )
-    new( txt ).parse
+    nodes = OutlineReader.parse( txt )
+    new( nodes )
   end
 
 
-  def initialize( txt )
-    @txt = txt
+
+  def initialize( nodes )
+    @nodes = nodes
   end
 
-  def parse
+
+  ###
+  # use Section struct for easier access - why? why not?
+  ##     e.g. sec.league instead of sec[:league] etc.
+
+  Section = Struct.new( :league, :season, :stage, :lines )  do
+     def text  ## for alternate line access (all-in-text string)
+        txt = lines.reduce( String.new ) do |mem,line| 
+                 mem << line; mem << "\n"; mem 
+              end
+        txt
+     end
+  end
+
+  def each_sec( &blk )
+     @secs ||= _parse
+
+     @secs.each do |sec|
+        blk.call( sec )
+     end 
+  end
+  alias_method :each_section, :each_sec
+
+
+  def _parse
     secs=[]     # sec(tion)s
-    OutlineReader.parse( @txt ).each do |node|
+    @nodes.each do |node|
       if node[0] == :h1
         ## check for league (and stage) and season
         heading = node[1]
-        values = split_league( heading )
+        values = _split_league( heading )
         if m=values[0].match( LEAGUE_SEASON_HEADING_RE )
           puts "league >#{m[:league]}<, season >#{m[:season]}<"
 
-           secs << { league: m[:league],
-                     season: m[:season],
-                     stage:  values[1],     ## note: defaults to nil if not present
-                     lines:  []
-                   }
+           secs << Section.new( league: m[:league],
+                                season: m[:season],
+                                stage:  values[1],   ## note: defaults to nil if not present
+                                lines:  [] 
+                              )
         else
           puts "** !!! ERROR - cannot match league and season in heading; season missing?"
           pp heading
@@ -44,12 +71,12 @@ class QuickLeagueOutlineReader
       elsif node[0] == :h2
          ## todo/check - make sure parsed h1 first
          heading = node[1]
-         ## reuse league, season from h1
-         secs << { league: secs[-1][:league],
-                   season: secs[-1][:season],
-                   stage:  heading,
-                   lines:  []
-                 }
+         ## note - reuse league, season from h1
+         secs << Section.new( league: secs[-1].league,
+                              season: secs[-1].season,
+                              stage:  heading,
+                              lines:  [] 
+                            )
       elsif node[0] == :p   ## paragraph with (text) lines
         lines = node[1]
         ## note: skip lines if no heading seen
@@ -58,7 +85,8 @@ class QuickLeagueOutlineReader
           pp lines
         else
           ## todo/check: unroll paragraphs into lines or pass along paragraphs - why? why not?
-          secs[-1][:lines] += lines
+          ##    add paragraphs not unrolled lines - why? why not?
+          secs[-1].lines += lines
         end
       else
         puts "** !!! ERROR - unknown line type; for now only heading 1 for leagues supported; sorry:"
@@ -67,7 +95,7 @@ class QuickLeagueOutlineReader
       end
     end
     secs
-  end # method parse
+  end # method _parse
 
 
   ## split into league + season
@@ -81,7 +109,7 @@ class QuickLeagueOutlineReader
          )
             $}x
 
-  def split_league( str )   ## todo/check: rename to parse_league(s) - why? why not?
+  def _split_league( str )   ## todo/check: rename to parse_league(s) - why? why not?
     ## split into league / stage / ... e.g.
     ##  => Österr. Bundesliga 2018/19, Regular Season
     ##  => Österr. Bundesliga 2018/19, Championship Round
@@ -91,5 +119,5 @@ class QuickLeagueOutlineReader
     values = values.map { |value| value.strip }   ## remove all whitespaces
     values
   end
- end # class QuickLeagueOutlineReader
+ end # class QuickLeagueOutline
 end # module SportDb

data/lib/sportdb/quick/quick_match_reader.rb

@@ -24,7 +24,7 @@ class QuickMatchReader
 
   def initialize( txt )
     @errors = []
-    @txt = txt
+    @outline = QuickLeagueOutline.parse( txt )
   end
 
   attr_reader :errors
@@ -55,17 +55,15 @@ class QuickMatchReader
     @errors = []
 
     @data = {}   # return data hash with leagues
-                #    and seasons
-                #   for now merge stage into matches
-
-    secs = QuickLeagueOutlineReader.parse( @txt )
-    pp secs    if debug?
-
-    secs.each do |sec|   ## sec(tion)s
-      season = Season.parse( sec[:season] )   ## convert (str) to season obj!!!
-      league = sec[:league]
-      stage  = sec[:stage]
-      lines  = sec[:lines]
+                 #    and seasons
+                 #   for now merge stage into matches
+
+    @outline.each_sec do |sec|   ## sec(tion)s
+      ### move season parse into outline upstream - why? why not?
+      season = Season.parse( sec.season )   ## convert (str) to season obj!!!
+      league = sec.league
+      stage  = sec.stage
+      lines  = sec.lines
 
       start =  if season.year?
                   Date.new( season.start_year, 1, 1 )

data/lib/sportdb/quick/version.rb

@@ -4,7 +4,7 @@ module SportDb
     module Quick
   MAJOR = 0    ## todo: namespace inside version or something - why? why not??
   MINOR = 5
-  PATCH = 1
+  PATCH = 3
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/sportdb/quick.rb

@@ -17,10 +17,17 @@ end
 ## our own code
 require_relative 'quick/version'
 
-
+## "generic" outline readers, documents & more
+##
+##  todo/check - move outline reader upstream to cocos - why? why not?
+##       use  read_outline(), parse_outline()  - why? why not?
+require_relative 'quick/outline_reader'
+require_relative 'quick/outline'
+
+##  match & league machinery
 require_relative 'quick/match_parser'
 
-require_relative 'quick/quick_league_outline_reader'
+require_relative 'quick/quick_league_outline'
 require_relative 'quick/quick_match_reader'
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sportdb-quick
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-18 00:00:00.000000000 Z
+date: 2025-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sportdb-parser
@@ -101,7 +101,9 @@ files:
 - Rakefile
 - lib/sportdb/quick.rb
 - lib/sportdb/quick/match_parser.rb
-- lib/sportdb/quick/quick_league_outline_reader.rb
+- lib/sportdb/quick/outline.rb
+- lib/sportdb/quick/outline_reader.rb
+- lib/sportdb/quick/quick_league_outline.rb
 - lib/sportdb/quick/quick_match_reader.rb
 - lib/sportdb/quick/version.rb
 homepage: https://github.com/sportdb/sport.db