sportdb-quick 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d352420645cf51612b5f1c1185f955ac0766d6bb26d84cae1a9e2adc16b2bd1e
-  data.tar.gz: fa83e99ca9c5b86ad8f9a101513d537e52338d03e181809579ef06ad03788cff
+  metadata.gz: d7f373cf63aa06b60bfe3f654df254e3e04d5a47c499a6be1dc4f9d90c061f84
+  data.tar.gz: ec5b8ea56ef5785b4133cd814254a0a4290873b453e806ad27f974dac4ac8594
 SHA512:
-  metadata.gz: 3f962bf9735b43bf53aa733c7543679f00daa08582862b4c4624fdc96556d148a2bcb2ea7a16f7a9637bae908cd71591bbc6f0b2fd7b7a0124d3106712a9094b
-  data.tar.gz: 818778f17464a71e2e8f7997661a00d4fd0844a5ebffdb22eb7800590f55bf7a7ccbd49aefe7fdd2d325eef84cb4669cdfb1287b5f819d5e5d6aae438c7ae759
+  metadata.gz: 19dd7b607f4c3288f176f941a570c1f316956ee2867f1cfebaebcf180506a3d640a797ea723ee889406f8f6682c326a95ab89a0877250b4709fa8bb5b6eb8aef
+  data.tar.gz: b6a76be55c06acb1f4487794a9097d2f6e1d5ea4414b2f1fabbf32d3f18df2a90cc8024d1c51b8f42d7be1e610ba7543dc9c6b41e3eea4822e16e8b689ca7687

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.5.0
+### 0.5.2
 ### 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/Rakefile

@@ -21,7 +21,7 @@ Hoe.spec 'sportdb-quick' do
   self.licenses = ['Public Domain']
 
   self.extra_deps = [
-       ['sportdb-parser',  '>= 0.5.0'],
+       ['sportdb-parser',  '>= 0.5.4'],
        ['sportdb-structs', '>= 0.5.0'],
        ['logutils',        '>= 0.6.1'],
   ]

data/lib/sportdb/quick/match_parser.rb

@@ -9,7 +9,19 @@ class MatchParser    ## simple match parser for team match schedules
 
   include Logging         ## e.g. logger#debug, logger#info, etc.
 
+  def log( msg )
+    ## append msg to ./logs.txt
+    ##     use ./errors.txt - why? why not?
+    File.open( './logs.txt', 'a:utf-8' ) do |f|
+      f.write( msg )
+      f.write( "\n" )
+    end
+  end
+ 
+
 
+
+  
   def self.parse( lines, start: )
     ##  todo/fix: add support for txt and lines
     ##    check if lines_or_txt is an array or just a string
@@ -20,44 +32,36 @@ class MatchParser    ## simple match parser for team match schedules
 
 
 
+  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.
 
-  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 = []
+    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
 
 
-  ## 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 buut (NOT ()[]/;)
-  ##
-  ##   Group A:
-  ##   Group B:   - remove colon
-  ##    or lookup first
-
-  ATTRIB_RE = %r{^
-                   [ ]*?     # slurp leading spaces
-                (?<key>[^:|\]\[()\/; -]
-                       [^:|\]\[()\/;]{0,30}
-                 )
-                   [ ]*?     # slurp trailing spaces
-                   :[ ]+
-                (?<value>.+)
-                    [ ]*?   # slurp trailing spaces
-                   $
-                }ix
-
   #
   # todo/fix: change start to start: too!!!
   #       might be optional in the future!! - why? why not?
@@ -68,9 +72,10 @@ 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 )    
     @start        = start
     @errors = []
   end
@@ -99,41 +104,12 @@ class MatchParser    ## simple match parser for team match schedules
 
     @tree   = []
 
-    attrib_found = false
-
-
-    lines = []
-    @lines.each_with_index do |line,i|
 
          if debug?
-           puts
-           puts "line >#{line}<"
+           puts "lines:"
+           pp @txt
          end
 
-          ## skip new (experimental attrib syntax)
-          if attrib_found == false &&
-              ATTRIB_RE.match?( line )
-            ## note: check attrib regex AFTER group def e.g.:
-            ##         Group A:
-            ##         Group B:  etc.
-            ##     todo/fix - change Group A: to Group A etc.
-            ##                       Group B: to Group B
-             attrib_found = true
-             ## logger.debug "skipping key/value line - >#{line}<"
-             next
-          end
-
-          if attrib_found
-            ## check if line ends with dot
-            ##  if not slurp up lines to the next do!!!
-            ## logger.debug "skipping key/value line - >#{line}<"
-            attrib_found = false   if line.end_with?( '.' )
-                # logger.debug "skipping key/value line (cont.) - >#{line}<"
-            next
-          end
-
-          lines << line
-
 =begin
           t, error_messages  =  @parser.parse_with_errors( line )
 
@@ -153,15 +129,11 @@ class MatchParser    ## simple match parser for team match schedules
 
            @tree << t
 =end
-    end  # each lines
 
-     txt = lines.join( "\n") + "\n"     
-     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
 
-    ## pp @tree
-
     ## report parse errors here - why? why not?
 
 
@@ -186,11 +158,16 @@ 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
-        puts "!! ERROR - unknown node (parse tree type)"
+        msg = "!! WARN - unknown node (parse tree type) - #{node.class.name}" 
+        puts msg
         pp node
-        exit 1
+
+        log( msg )
+        log( node.pretty_inspect )
       end
     end  # tree.each
 
@@ -478,7 +455,8 @@ class GoalStruct
     ## note - there's no time (-only) type in ruby
     ##  use string (e.g. '14:56', '1:44')
     ##   use   01:44 or 1:44 ?
-    ##  check for 0:00 or 24:00  possible?                         
+    ##  check for 0:00 or 24:00  possible?  
+    time   = nil                       
     time   =  ('%d:%02d' % [node.time[:h], node.time[:m]])  if node.time
  
 
@@ -497,17 +475,20 @@ class GoalStruct
       score = Score.new( *values )
     end
  
-    more   = []
 
     status = nil
+    status =  node.status   if node.status   ### assume text for now             
     ## if node_type == :status  # e.g. awarded, canceled, postponed, etc.
     ##  status = node[1]
-
-
- #
-## todo - add    ## find (optional) match status e.g. [abandoned] or [replay] or [awarded]
-##                                   or [cancelled] or [postponed] etc.
-##    status = find_status!( line )   ## todo/check: allow match status also in geo part (e.g. after @) - why? why not?
+    #
+    ## todo - add    ## find (optional) match status e.g. [abandoned] or [replay] or [awarded]
+    ##                                   or [cancelled] or [postponed] etc.
+    ##    status = find_status!( line )   ## todo/check: allow match status also in geo part (e.g. after @) - why? why not?
+
+    
+    ###############
+    #  add more for ground (and timezone!!!)
+    more   = []
 #
 #        elsif node_type == :'@' ||
 #              node_type == :',' ||
@@ -593,18 +574,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
+                 #    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]
+    @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 )
@@ -73,6 +71,14 @@ class QuickMatchReader
                   Date.new( season.start_year, 7, 1 )
                 end
 
+     # if debug?
+     #   puts "  (sec) lines:"
+     #   pp lines
+     # end
+
+      ### note - skip section if no lines !!!!!
+      next if lines.empty?     ## or use lines.size == 0
+
 
       parser = MatchParser.new( lines,
                                 start )   ## note: keep season start_at date for now (no need for more specific stage date need for now)

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 = 0
+  PATCH = 2
   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.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-15 00:00:00.000000000 Z
+date: 2025-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sportdb-parser
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: sportdb-structs
   requirement: !ruby/object:Gem::Requirement
@@ -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