sportdb-formats 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4cdd2bc410771494ed506a24d384ca3c8b1c9684
-  data.tar.gz: 066f5288da503a00efe280369f57d6cd65bf4bf7
+  metadata.gz: 89c3ae173bed0c7a68f30a897e4cf34da8d72d6e
+  data.tar.gz: f3898e8b03177b62075cced2a90be2502555bf63
 SHA512:
-  metadata.gz: f61edee9495047fc49dfb5720c7afc1e0e316e5fab024d8fc0b1bd5fcdad70524f6e22d24d8fad0aa679380565e0a0c7e36fae79c170655f8a7a496dee170aca
-  data.tar.gz: b378202d2c8152ac46386618d3c69c03d802b1439e74175f8d84fad304ce111edb0bb1cd848fc969848ce55e0cf8de15a46bec322351d5d199652ed16d41b164
+  metadata.gz: 4c938af88f6dd86f1736532c9d8271a3e56f1769b955a31ce6d84a0b1fcf5a6eec7cfa42e0c019bd7072351d777a1988d6637c4297bee0dad9592bb8ec7450e8
+  data.tar.gz: a80df68f64e13eeb9a85931e2d2dd4381f204f94a4ea9254c89b4b28346db4c1542321aed4fd123aef5ddedc7e4cd2c08731dd340326fae5dc94b57fa6797835

data/Manifest.txt

@@ -8,6 +8,8 @@ lib/sportdb/formats/country/country_index.rb
 lib/sportdb/formats/country/country_reader.rb
 lib/sportdb/formats/datafile.rb
 lib/sportdb/formats/datafile_package.rb
+lib/sportdb/formats/event/event_index.rb
+lib/sportdb/formats/event/event_reader.rb
 lib/sportdb/formats/goals.rb
 lib/sportdb/formats/league/league_index.rb
 lib/sportdb/formats/league/league_outline_reader.rb
@@ -68,6 +70,7 @@ test/test_match_auto_worldcup.rb
 test/test_match_champs.rb
 test/test_match_eng.rb
 test/test_match_euro.rb
+test/test_match_start_date.rb
 test/test_match_worldcup.rb
 test/test_name_helper.rb
 test/test_outline_reader.rb

data/lib/sportdb/formats.rb

@@ -136,6 +136,20 @@ end   # module Import
 end   # module SportDb
 
 
+require 'sportdb/formats/event/event_reader'
+require 'sportdb/formats/event/event_index'
+
+## add convenience helper
+module SportDb
+module Import
+class EventInfo
+  def self.read( path )  EventInfoReader.read( path ); end
+  def self.parse( txt )  EventInfoReader.parse( txt ); end
+end   # class EventInfo
+end   # module Import
+end   # module SportDb
+
+
 
 
 

data/lib/sportdb/formats/event/event_index.rb

@@ -0,0 +1,143 @@
+module SportDb
+module Import
+
+
+class EventIndex
+
+    def self.build( path )
+      datafiles = Package.find_seasons( path )
+
+      puts
+      puts "#{datafiles.size} seasons datafile(s):"
+      pp datafiles
+
+      index = new
+      datafiles.each do |datafile|
+        recs = EventInfoReader.read( datafile )
+        # pp recs
+
+        index.add( recs )
+      end
+
+      index
+    end
+
+
+    attr_reader :events
+    def initialize
+      @events  = []
+      @leagues = {}
+    end
+
+    def add( recs )
+      @events += recs  ## add to "linear" records
+
+      recs.each do |rec|
+        league = rec.league
+        season = rec.season
+
+        seasons = @leagues[ league.key ] ||= {}
+        seasons[season.key] = rec
+      end
+      ## build search index by leagues (and season)
+    end
+
+    def find_by( league:, season: )
+      league_key = league.is_a?( String ) ? league : league.key
+      season_key = season.is_a?( String ) ? season : season.key
+
+      seasons = @leagues[ league_key ]
+      if seasons
+        seasons[ season_key ]
+      else
+        nil
+      end
+    end # method find_by
+end  ## class EventIndex
+
+
+
+class SeasonIndex
+    def initialize( *args )
+       @leagues = {}   ## use a league hash by years for now; change later
+
+       if args.size == 1 && args[0].is_a?( EventIndex )
+         ## convenience setup/hookup
+         ##  (auto-)add all events from event index
+         add( args[0].events )
+       else
+         pp args
+         raise ArgumentError.new( 'unsupported arguments' )
+       end
+    end
+
+    def add( recs )
+      ## use a lookup index by year for now
+      ##  todo - find something better/more generic for searching/matching date periods!!!
+      recs.each do |rec|
+        league = rec.league
+        season = rec.season
+
+        years = @leagues[ league.key ] ||= {}
+        if season.year?
+          years[season.start_year] ||= []
+          years[season.start_year] << rec
+        else
+          years[season.start_year] ||= []
+          years[season.end_year]   ||= []
+          years[season.start_year] << rec
+          years[season.end_year]   << rec
+        end
+      end
+    end # method add
+
+    def find_by( date:, league: )
+       date = Date.strptime( date, '%Y-%m-%d' )   if date.is_a?( String )
+       league_key = league.is_a?( String ) ? league : league.key
+
+       years = @leagues[ league_key ]
+       if years
+           year = years[ date.year ]
+           if year
+               season_key = nil
+               year.each do |event|
+                 ##  todo/check: rename/use between? instead of include? - why? why not?
+                 if event.include?( date )
+                   season_key = event.season.key
+                   break
+                 end
+               end
+               if season_key.nil?
+                 puts "!! WARN: date >#{date}< out-of-seasons for year #{date.year} in league #{league_key}:"
+                 year.each do |event|
+                   puts "  #{event.season.key} |  #{event.start_date} - #{event.end_date}"
+                 end
+                 ## retry again and pick season with "overflow" at the end (date is great end_date)
+                 year.each do |event|
+                   if date > event.end_date
+                     diff_in_days = date.to_date.jd - event.end_date.to_date.jd
+                     puts "    +#{diff_in_days} days - adding overflow to #{event.season.key} ending on #{event.end_date} ++ #{date}"
+                     season_key = event.season.key
+                     break
+                   end
+                 end
+                 ## exit now for sure - if still empty!!!!
+                 if season_key.nil?
+                   puts "!! ERROR: CANNOT auto-fix / (auto-)append date at the end of an event; check season setup - sorry"
+                   exit 1
+                 end
+               end
+               season_key
+           else
+             nil   ## no year defined / found for league
+           end
+       else
+          nil   ## no league defined / found
+       end
+   end  # method find
+
+end # class SeasonIndex
+
+
+end   # module Import
+end   # module SportDb

data/lib/sportdb/formats/event/event_reader.rb

@@ -0,0 +1,183 @@
+
+module SportDb
+module Import
+
+
+class EventInfo
+    ##  "high level" info (summary) about event  (like a "wikipedia infobox")
+    ##    use for checking dataset imports; lets you check e.g.
+    ##    - dates within range
+    ##    - number of teams e.g. 20
+    ##    - matches played e.g. 380
+    ##    - goals scored e.g. 937
+    ##    etc.
+
+    attr_reader :league,
+                :season,
+                :teams,
+                :matches,
+                :goals,
+                :start_date,
+                :end_date
+
+    def initialize( league:, season:,
+                    start_date: nil, end_date: nil,
+                    teams:   nil,
+                    matches: nil,
+                    goals:   nil )
+
+      @league      = league
+      @season      = season
+
+      @start_date  = start_date
+      @end_date    = end_date
+
+      @teams       = teams    ## todo/check: rename/use teams_count ??
+      @matches     = matches  ## todo/check: rename/use match_count ??
+      @goals       = goals
+    end
+
+    def include?( date )
+       ## todo/fix: add options e.g.
+       ##  - add delta/off_by_one or such?
+       ##  - add strict (for) only return true if date range (really) defined (no generic auto-rules)
+
+      ### note: for now allow off by one error (via timezone/local time errors)
+      ##    todo/fix: issue warning if off by one!!!!
+      if @start_date && @end_date
+        date >= (@start_date-1) &&
+        date <= (@end_date+1)
+      else
+        if @season.year?
+           # assume generic rule
+           ## same year e.g. Jan 1 - Dec 31; always true for now
+           date.year == @season.start_year
+        else
+           # assume generic rule
+           ##  July 1 - June 30 (Y+1)
+           ##  - todo/check -start for some countries/leagues in June 1 or August 1 ????
+           date >= Date.new( @season.start_year, 7, 1 ) &&
+           date <= Date.new( @season.end_year, 6, 30 )
+        end
+      end
+    end  # method include?
+    alias_method :between?, :include?
+  end # class EventInfo
+
+
+  class EventInfoReader
+    def catalog() Import.catalog; end
+
+
+    def self.read( path )
+      txt = File.open( path, 'r:utf-8') {|f| f.read }
+      new( txt ).parse
+    end
+
+    def self.parse( txt )
+      new( txt ).parse
+    end
+
+    def initialize( txt )
+      @txt = txt
+    end
+
+    def parse
+      recs = []
+
+      parse_csv( @txt ).each do |row|
+        league_col = row['League']
+        season_col = row['Season'] || row['Year']
+        dates_col  = row['Dates']
+
+        season = Import::Season.new( season_col )
+        league = catalog.leagues.find!( league_col )
+
+
+        dates = []
+        if dates_col.nil? || dates_col.empty?
+           ## do nothing; no dates - keep dates array empty
+        else
+          ## squish spaces
+          dates_col = dates_col.gsub( /[ ]{2,}/, ' ' )  ## squish/fold spaces
+
+          puts "#{league.name} (#{league.key}) | #{season.key} | #{dates_col}"
+
+          ### todo/check:  check what parts "Aug 15" return ???
+          ###                       short form for "Aug 15 -" - works?
+
+          ## todo/fix!!! - check EventInfo.include?
+          ##    now allow dates with only start_date too!! (WITHOUT end_date)
+          parts = dates_col.split( /[ ]*[–-][ ]*/ )
+          if parts.size == 1
+            pp parts
+            dates << DateFormats.parse( parts[0], start: Date.new( season.start_year, 1, 1 ), lang: 'en' )
+            pp dates
+          elsif parts.size == 2
+            pp parts
+            dates << DateFormats.parse( parts[0], start: Date.new( season.start_year, 1, 1 ), lang: 'en' )
+            dates << DateFormats.parse( parts[1], start: Date.new( season.end_year ? season.end_year : season.start_year, 1, 1 ), lang: 'en' )
+            pp dates
+
+            ## assert/check if period is less than 365 days for now
+            diff = dates[1].to_date.jd - dates[0].to_date.jd
+            puts "#{diff}d"
+            if diff > 365
+              puts "!! ERROR - date range / period assertion failed; expected diff < 365 days"
+              exit 1
+            end
+          else
+            puts "!! ERRROR - expected data range / period - one or two dates; got #{parts.size}:"
+            pp dates_col
+            pp parts
+            exit 1
+          end
+        end
+
+
+        teams_col    = row['Clubs'] || row['Teams']
+        goals_col    = row['Goals']
+
+        ## note: remove (and allow) all non-digits e.g. 370 goals, 20 clubs, etc.
+        teams_col    = teams_col.gsub( /[^0-9]/, '' )    if teams_col
+        goals_col    = goals_col.gsub( /[^0-9]/, '' )    if goals_col
+
+        teams  =   (teams_col.nil? || teams_col.empty?) ? nil : teams_col.to_i
+        goals  =   (goals_col.nil? || goals_col.empty?) ? nil : goals_col.to_i
+
+        matches_col  = row['Matches']
+        ## note: support additions in matches (played) e.g.
+        #   132 + 63 Play-off-Spiele
+        matches_col   = matches_col.gsub( /[^0-9+]/, '' )  if matches_col
+
+        matches =  if matches_col.nil? || matches_col.empty?
+                     nil
+                   else
+                     if matches_col.index( '+' )  ### check for calculations
+                        ## note: for now only supports additions
+                        matches_col.split( '+' ).reduce( 0 ) do |sum,str|
+                          sum + str.to_i
+                        end
+                     else            ## assume single (integer) number
+                        matches_col.to_i
+                     end
+                  end
+
+        rec = EventInfo.new( league:     league,
+                             season:     season,
+                             start_date: dates[0],
+                             end_date:   dates[1],
+                             teams:      teams,
+                             matches:    matches,
+                             goals:      goals
+                           )
+        recs << rec
+      end  # each row
+      recs
+    end  # method parse
+  end  # class EventInfoReader
+
+
+end ## module Import
+end ## module SportDb
+

data/lib/sportdb/formats/match/match_parser.rb

@@ -563,12 +563,29 @@ class MatchParser   ## simple match parser for team match schedules
 
     if date && team1.nil? && team2.nil?
       logger.debug( "date header line found: >#{line}<")
-      logger.debug( "    date: #{date}")
+      logger.debug( "    date: #{date} with start: #{@start}")
 
       @last_date = date   # keep a reference for later use
-      return true
+
+      ###  quick "corona" hack - support seasons going beyond 12 month (see swiss league 2019/20 and others!!)
+      ##    find a better way??
+      ##  set @start date to full year (e.g. 1.1.) if date.year  is @start.year+1
+      ##   todo/fix: add to linter to check for chronological dates!! - warn if NOT chronological
+      ###  todo/check: just turn on for 2019/20 season or always? why? why not?
+
+      ## todo/fix: add switch back to old @start_org
+      ##   if year is date.year == @start.year-1    -- possible when full date with year set!!!
+      if @start.month != 1
+         if date.year == @start.year+1
+           logger.debug( "!! hack - extending start date to full (next/end) year; assumes all dates are chronologigal - always moving forward" )
+           @start_org = @start   ## keep a copy of the original (old) start date - why? why not? - not used for now
+           @start = Date.new( @start.year+1, 1, 1 )
+         end
+      end
+
+      true
     else
-      return false
+      false
     end
   end
 

data/lib/sportdb/formats/match/match_parser_csv.rb

@@ -95,7 +95,7 @@ module SportDb
          headers_mapping[:score]  = find_header( headers, ['FT'] )
          headers_mapping[:scorei] = find_header( headers, ['HT'] )
 
-         headers_mapping[:round]  = find_header( headers, ['Round'] )
+         headers_mapping[:round]  = find_header( headers, ['Round', 'Matchday'] )
 
          ## optional headers - note: find_header returns nil if header NOT found
          header_stage = find_header( headers, ['Stage'] )
@@ -221,6 +221,9 @@ module SportDb
       end
 
 
+      ##
+      ## todo/fix:  round might not always be just a simple integer number!!!
+      ##             might be text such as Final | Leg 1 or such!!!!
       round   = nil
       ## check for (optional) round / matchday
       if headers_mapping[ :round ]

data/lib/sportdb/formats/package.rb

@@ -13,12 +13,22 @@ module SportDb
     ## leagues.txt or leagues_en.txt
     ##   remove support for en.leagues.txt - why? why not?
     LEAGUES_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.wiki.txt
+       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.leagues.txt
         leagues
           (?:_[a-z0-9_-]+)?
         \.txt$
     }x
 
+    ## seasons.txt or seasons_en.txt
+    ##   remove support for br.seasons.txt - why? why not?
+    SEASONS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.seasons.txt
+        seasons
+          (?:_[a-z0-9_-]+)?
+        \.txt$
+    }x
+
+
     ## clubs.txt or clubs_en.txt
     ##   remove support for en.clubs.txt - why? why not?
     CLUBS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
@@ -49,6 +59,8 @@ module SportDb
                       \.txt$
     }x
 
+
+    ###  todo/fix: change SEASON_RE to SEASON_KEY_RE (avoid confusion w/ SEASONS_RE for datafile?) - why? why not? !!!!!!!
     ### season folder:
     ##            e.g. /2019-20   or
     ##  year-only e.g. /2019      or
@@ -110,6 +122,10 @@ module SportDb
    def self.find_leagues( path, pattern: LEAGUES_RE )  find( path, pattern ); end
    def self.match_leagues( path )  LEAGUES_RE.match( path ); end
 
+   def self.find_seasons( path, pattern: SEASONS_RE )  find( path, pattern ); end
+   def self.match_seasons( path )  SEASONS_RE.match( path ); end
+
+
    def self.find_conf( path, pattern: CONF_RE )  find( path, pattern ); end
    def self.match_conf( path )  CONF_RE.match( path ); end
 
@@ -139,6 +155,9 @@ module SportDb
      alias_method :match_leagues?, :match_leagues
      alias_method :leagues?,       :match_leagues
 
+     alias_method :match_seasons?, :match_seasons
+     alias_method :seasons?,       :match_seasons
+
      alias_method :match_conf?, :match_conf
      alias_method :conf?,       :match_conf
    end

data/lib/sportdb/formats/season_utils.rb

@@ -2,21 +2,10 @@
 
 
 module SeasonHelper ## use Helpers why? why not?
-
   ##############################################
   ### deprecated!!! use new Season class!!!
   ##   this code will get removed!!!!
   ###################################################
-
-  def prev( str )   SportDb::Import::Season.new( str ).prev;  end
-  def key( str )    SportDb::Import::Season.new( str ).key;   end
-  def directory( str, format: nil )  SportDb::Import::Season.new( str ).directory( format: format );  end
-
-  ## note: new start_year now returns an integer number (no longer a string)!!!
-  def start_year( str )  SportDb::Import::Season.new( str ).start_year;  end
-  ## note: new end_year now returns an integer number (no longer a string)!!!
-  ##       if now end_year (year? == true) than returns nil (no longer the start_year "as fallback")!!!
-  def end_year( str )   SportDb::Import::Season.new( str ).end_year;  end
 end  # module SeasonHelper
 
 

data/lib/sportdb/formats/structs/season.rb

@@ -1,26 +1,19 @@
 # encoding: utf-8
 
 
-module SportDb
-  module Import
+### note: make Season like Date a "top-level" / "generic" class
+
 
 
 class Season
   ##
   ##  todo: add (optional) start_date and end_date - why? why not?
-  ##        add next
-
-
-  attr_reader :start_year,
-              :end_year
 
-  def year?()  @end_year.nil?; end  ## single-year season e.g. 2011 if no end_year present
-
-
-  def initialize( str )   ## assume only string / line gets passed in for now
-    @start_year, @end_year = parse( str )
-  end
+  ## todo/todo/todo/check/check/check !!!
+  ## todo: add a kernel Seaons e.g. Season('2011/12')
+  ##    forward to Season.convert( *args )  - why? why not?
 
+  ## todo: add unicode - too - why? why not? see wikipedia pages, for example
 
   YYYY_YYYY_RE  = %r{^      ## e.g. 2011-2012 or 2011/2012
                     (\d{4})
@@ -45,79 +38,155 @@ class Season
                    $
                   }x
 
-  def parse( str )
+
+  def self.parse( str )
+    new( *_parse( str ))
+  end
+
+  def self._parse( str )   ## "internal" parse helper
     if str =~ YYYY_YYYY_RE    ## e.g. 2011/2012
       [$1.to_i, $2.to_i]
     elsif str =~ YYYY_YY_RE   ## e.g. 2011/12
       fst = $1.to_i
       snd = $2.to_i
       snd_exp = '%02d' % [(fst+1) % 100]    ## double check: e.g 00 == 00, 01==01 etc.
-      raise ArgumentError.new( "[Season#parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}")   if snd_exp != $2
+      raise ArgumentError, "[Season.parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}"   if snd_exp != $2
       [fst, fst+1]
     elsif str =~ YYYY_Y_RE    ## e.g. 2011/2
       fst = $1.to_i
       snd = $2.to_i
       snd_exp = '%d' % [(fst+1) % 10]      ## double check: e.g 0 == 0, 1==1 etc.
-      raise ArgumentError.new( "[Season#parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}")   if snd_exp != $2
+      raise ArgumentError, "[Season.parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}"   if snd_exp != $2
       [fst, fst+1]
     elsif str =~ YYYY_RE      ## e.g. 2011
       [$1.to_i]
     else
-      raise ArgumentError.new( "[Season#parse] unkown season format >>#{str}<<; sorry cannot parse")
+      raise ArgumentError, "[Season.parse] unkown season format >>#{str}<<; sorry cannot parse"
+    end
+  end
+
+
+
+  attr_reader :start_year,
+              :end_year
+
+  def initialize( *args )   ## assume only string / line gets passed in for now
+    if args.size == 1 && args[0].is_a?( String )
+      @start_year, @end_year = self.class._parse( args[0] )
+    elsif args.size == 1 && args[0].is_a?( Integer )
+      @start_year = args[0]
+      @end_year   = nil
+    elsif args.size == 2 && args[0].is_a?( Integer ) &&
+                            args[1].is_a?( Integer )
+      @start_year = args[0]
+      @end_year   = args[1]
+      end_year_exp = @start_year+1
+      raise ArgumentError, "[Season] invalid year in season >>#{to_s}<<; expected #{end_year_exp} but got #{@end_year}"   if end_year_exp != @end_year
+    else
+      pp args
+      raise ArgumentError, "[Season] expected season string or season start year (integer) with opt. end year"
+    end
+  end
+
+
+  ###
+  ## convenience helper
+  def start_date   ## generate "generic / syntetic start date" - keep helper - why? why not?
+    if year?
+      Date.new( start_year, 1, 1 )
+    else
+      Date.new( start_year 1, 7 )
     end
   end
 
 
+  ## single-year season e.g. 2011 if no end_year present - todo - find a better name?
+  def year?()  @end_year.nil?; end
 
   def prev
     if year?
-      Season.new( "#{@start_year-1}" )
+      Season.new( @start_year-1 )
     else
-      Season.new( "#{@start_year-1}/#{@start_year}" )
+      Season.new( @start_year-1, @start_year )
     end
   end
 
-  def key
+  def next
     if year?
-      '%d' % @start_year
+      Season.new( @start_year+1 )
     else
-      '%d/%02d' % [@start_year, @end_year % 100]
+      Season.new( @end_year, @end_year+1 )
     end
   end
-  alias_method :to_key, :key
-  alias_method :to_s,   :key
+  alias_method :succ, :next   ## add support for ranges
+
+  include Comparable
+  def <=>(other)
+    ## todo/fix/fix:  check if other is_a?( Season )!!!
+    ##  what to return if other type/class ??
 
-  alias_method :name,   :key
-  alias_method :title,  :key
+    res =  @start_year <=> other.start_year
 
+    ## check special edge case - year season and other e.g.
+    ##    2010 <=> 2010/2011
+    if res == 0 && @end_year != other.end_year
+      res =  @end_year ? 1 : -1   # the season with an end year is greater / wins for now
+    end
 
-  def path( format: nil )
-    ##  todo: find better names for formats - why? why not?:
-    ##    long | archive | decade(?)   =>   1980s/1988-89, 2010s/2017-18, ...
-    ##    short | std(?)   =>   1988-89, 2017-18, ...
+    res
+  end
 
-    ## convert season name to "standard" season name for directory
 
-    if ['l', 'long', 'archive' ].include?( format.to_s )   ## note: allow passing in of symbol to e.g. 'long' or :long
-      if year?   ## e.g. 2000s/2001
-        "%3d0s/%4d" % [@start_year / 10, @start_year]
-      else       ## e.g. 2000s/2001-02
-        "%3d0s/%4d-%02d" % [@start_year / 10, @start_year, @end_year % 100]
-      end
-    else  ## default 'short' format / fallback
-      if year?   ## e.g. 2001
-        "%4d" % @start_year
-      else       ## e.g. 2001-02
-        "%4d-%02d" % [@start_year, @end_year % 100]
+
+  def to_formatted_s( format=:default, sep: '/' )
+    if year?
+      '%d' % @start_year
+    else
+      case format
+      when :default, :short, :s   ## e.g. 1999/00 or 2019/20
+        "%d#{sep}%02d" % [@start_year, @end_year % 100]
+      when :long, :l              ## e.g. 1999/2000 or 2019/2020
+        "%d#{sep}%d" % [@start_year, @end_year]
+      else
+        raise ArgumentError, "[Season.to_s] unsupported format >#{format}<"
       end
     end
-  end # method path
-  alias_method :directory, :path   ## keep "legacy" directory alias - why? why not?
-  alias_method :to_path,   :path
+  end
+  alias_method :to_s, :to_formatted_s
+
+  def key()  to_s( :short ); end
+  alias_method :to_key,  :key
+  alias_method :name,    :key
+  alias_method :title,   :key
 
+  alias_method :inspect, :key  ## note: add inspect debug support change debug output to string!!
+
+
+
+  def to_path( format=:default )
+    case format
+    when :default, :short, :s    ## e.g. 1999-00 or 2019-20
+      to_s( :short, sep: '-' )
+    when :long, :l                ## e.g. 1999-2000 or 2019-2000
+      to_s( :long, sep: '-' )
+    when :archive, :decade, :d    ## e.g. 1990s/1999-00 or 2010s/2019-20
+      "%3d0s/%s" % [@start_year / 10, to_s( :short, sep: '-' )]
+    when :century, :c             ## e.g. 1900s/1990-00 or 2000s/2019-20
+      "%2d00s/%s" % [@start_year / 100, to_s( :short, sep: '-' )]
+    else
+      raise ArgumentError, "[Season.to_path] unsupported format >#{format}<"
+    end
+  end # method to_path
+  alias_method :directory, :to_path   ## keep "legacy" directory alias - why? why not?
+  alias_method :path,      :to_path
 
 end # class Season
 
 
+
+
+module SportDb
+module Import
+  Season = ::Season   ## add a convenience alias
 end  # module Import
 end  # module SportDb

data/lib/sportdb/formats/version.rb

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

data/test/test_match_start_date.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_match_start_date.rb
+
+
+require 'helper'
+
+
+class TestMatchStart < MiniTest::Test
+
+  def test_eng
+    txt =<<TXT
+Matchday 1
+[Aug 2]
+   A - B
+Matchday 2
+[Jan 3]
+   A - B
+Matchday 3
+[Aug 4]
+  A - B
+TXT
+
+   teams =<<TXT
+A
+B
+TXT
+    SportDb::Import.config.lang = 'en'
+
+    start = Date.new( 2017, 7, 1 )
+
+    parser = SportDb::MatchParser.new( txt, teams, start )
+    matches, rounds  = parser.parse
+
+    pp rounds
+    pp matches   ## only dump last record for now
+
+    assert_equal Date.new( 2017, 8, 2), matches[0].date
+    assert_equal Date.new( 2018, 1, 3), matches[1].date
+    assert_equal Date.new( 2018, 8, 4), matches[2].date
+  end   # method test_end
+end   # class TestMatchStart

data/test/test_season.rb

@@ -9,25 +9,35 @@ require 'helper'
 
 class TestSeason < MiniTest::Test
 
-  Season = SportDb::Import::Season
-
-  def test_path
-    assert_equal '2010-11',       Season.new( '2010-11' ).path
-    assert_equal '2010-11',       Season.new( '2010-2011' ).path
-    assert_equal '2010-11',       Season.new( '2010/11' ).path
-    assert_equal '2010-11',       Season.new( '2010/1' ).path
-    assert_equal '2010-11',       Season.new( '2010/2011' ).path
-    assert_equal '2010',          Season.new( '2010' ).path
-
-    assert_equal '2010s/2010-11', Season.new( '2010-11' ).path( format: 'long' )
-    assert_equal '2010s/2010-11', Season.new( '2010-2011' ).path( format: 'long' )
-    assert_equal '2010s/2010',    Season.new( '2010' ).path( format: 'long' )
-
-    assert_equal '1999-00',       Season.new( '1999-00' ).path
-    assert_equal '1999-00',       Season.new( '1999-2000' ).path
-    assert_equal '1990s/1999-00', Season.new( '1999-00' ).path( format: 'long' )
-    assert_equal '1990s/1999-00', Season.new( '1999-2000' ).path( format: 'long' )
-  end  # method test_path
+
+  def test_to_path
+    assert_equal '2010-11',       Season.new( '2010-11' ).to_path
+    assert_equal '2010-11',       Season.new( '2010-2011' ).to_path
+    assert_equal '2010-11',       Season.new( '2010/11' ).to_path
+    assert_equal '2010-11',       Season.new( '2010/1' ).to_path
+    assert_equal '2010-11',       Season.new( '2010/2011' ).to_path
+    assert_equal '2010',          Season.new( '2010' ).to_path
+
+    assert_equal '2010-11',       Season.new( 2010, 2011 ).to_path
+    assert_equal '2010',          Season.new( 2010 ).to_path
+
+    assert_equal '2010s/2010-11', Season.new( '2010-11' ).to_path( :decade )
+    assert_equal '2010s/2010-11', Season.new( '2010-2011' ).to_path( :decade )
+    assert_equal '2010s/2010',    Season.new( '2010' ).to_path( :decade )
+
+    assert_equal '1999-00',       Season.new( '1999-00' ).to_path
+    assert_equal '1999-00',       Season.new( '1999-2000' ).to_path
+    assert_equal '1990s/1999-00', Season.new( '1999-00' ).to_path( :decade )
+    assert_equal '1990s/1999-00', Season.new( '1999-2000' ).to_path( :decade )
+
+    assert_equal '2000s/2010-11', Season.new( '2010-11' ).to_path( :century )
+    assert_equal '2000s/2010-11', Season.new( '2010-2011' ).to_path( :century )
+    assert_equal '2000s/2010',    Season.new( '2010' ).to_path( :century )
+
+    assert_equal '1900s/1999-00', Season.new( '1999-00' ).to_path( :century )
+    assert_equal '1900s/1999-00', Season.new( '1999-2000' ).to_path( :century )
+  end  # method test_to_path
+
 
   def test_key
     assert_equal '2010/11',       Season.new( '2010-11' ).key
@@ -59,4 +69,43 @@ class TestSeason < MiniTest::Test
     assert_equal '1998/99',       Season.new( '1999-00' ).prev.key
     assert_equal '1998/99',       Season.new( '1999-2000' ).prev.key
   end
+
+  def test_next
+    assert_equal '2009/10',       Season.new( '2008-09' ).next.key
+    assert_equal '2009/10',       Season.new( '2008-2009' ).next.key
+    assert_equal '2009',          Season.new( '2008' ).next.key
+
+    assert_equal '1998/99',       Season.new( '1997-98' ).next.key
+    assert_equal '1998/99',       Season.new( '1997-1998' ).next.key
+  end
+
+
+  def test_range
+    s2010 = Season.new( '2010' )..Season.new( '2019' )
+    pp s2010.to_a
+# => [2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019]
+
+    s2010 = Season.new( '2010-11')..Season.new( '2019-20')
+    pp s2010.to_a
+# => [2010/11, 2011/12, 2012/13, 2013/14, 2014/15,
+#     2015/16, 2016/17, 2017/18, 2018/19, 2019/20]
+
+    puts s2010 === Season.new( '2015-16' )  # true
+    puts s2010 === Season.new( '2015' )     # false  - why? if using >= <=
+    puts s2010 === Season.new( '1999-00' )  # false
+    puts s2010 === Season.new( '2020-21' )  # false
+
+    puts Season.new( '2010-11' ) < Season.new( '2015' )   # true
+    puts Season.new( '2015' )    < Season.new( '2019-20') # true
+
+    puts Season.new( '2015' ) == Season.new( '2015-16') # false
+    puts Season.new( '2015' ) < Season.new( '2015-16') # true
+    puts Season.new( '2015' ) == Season.new( '2015')    # true
+
+    puts
+    puts s2010.include? Season.new( '2015-16' )  # true
+    puts s2010.include? Season.new( '2015' )     # false
+    puts s2010.include? Season.new( '1999-00' )  # false
+  end
+
 end # class TestSeason

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sportdb-formats
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-15 00:00:00.000000000 Z
+date: 2020-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: alphabets
@@ -127,6 +127,8 @@ files:
 - lib/sportdb/formats/country/country_reader.rb
 - lib/sportdb/formats/datafile.rb
 - lib/sportdb/formats/datafile_package.rb
+- lib/sportdb/formats/event/event_index.rb
+- lib/sportdb/formats/event/event_reader.rb
 - lib/sportdb/formats/goals.rb
 - lib/sportdb/formats/league/league_index.rb
 - lib/sportdb/formats/league/league_outline_reader.rb
@@ -187,6 +189,7 @@ files:
 - test/test_match_champs.rb
 - test/test_match_eng.rb
 - test/test_match_euro.rb
+- test/test_match_start_date.rb
 - test/test_match_worldcup.rb
 - test/test_name_helper.rb
 - test/test_outline_reader.rb