sportdb-formats 1.1.5 → 1.1.6

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

@@ -1,202 +1,202 @@
-# encoding: utf-8
-
-module SportDb
-
-
-class AutoConfParser     ## todo/check: rename/change to MatchAutoConfParser - why? why not?
-
-  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
-    parser = new( lines, start )
-    parser.parse
-  end
-
-
-  include Logging         ## e.g. logger#debug, logger#info, etc.
-  include ParserHelper    ## e.g. read_lines, etc.
-
-
-  def initialize( lines, start )
-    # for convenience split string into lines
-    ##    note: removes/strips empty lines
-    ## todo/check: change to text instead of array of lines - why? why not?
-    @lines        = lines.is_a?( String ) ? read_lines( lines ) : lines
-    @start        = start
-  end
-
-  def parse
-    ## try to  find all teams in match schedule
-    @last_round   = nil
-    @last_group   = nil
-
-    ## definitions/defs
-    @round_defs = Hash.new(0)
-    @group_defs = Hash.new(0)
-
-    ## usage/refs
-    @rounds       = {}           ## track usage counter and match (two teams) counter
-    @groups       = {}           ##  -"-
-    @teams        = Hash.new(0)   ## keep track of usage counter
-
-    @warns        = []    ## track list of warnings (unmatched lines)  too - why? why not?
-
-
-    @lines.each do |line|
-      if is_goals?( line )
-        logger.debug "skipping matched goals line: >#{line}<"
-      elsif is_round_def?( line )
-        ## todo/fix:  add round definition (w begin n end date)
-        ## todo: do not patch rounds with definition (already assume begin/end date is good)
-        ##  -- how to deal with matches that get rescheduled/postponed?
-        logger.debug "skipping matched round def line: >#{line}<"
-        @round_defs[ line ] += 1
-      elsif is_round?( line )
-        logger.debug "skipping matched round line: >#{line}<"
-
-        round = @rounds[ line ] ||= {count: 0, match_count: 0}   ## usage counter, match counter
-        round[:count] +=1
-        @last_round = round
-      elsif is_group_def?( line ) ## NB: group goes after round (round may contain group marker too)
-        ### todo: add pipe (|) marker (required)
-        logger.debug "skipping matched group def line: >#{line}<"
-        @group_defs[ line ] += 1
-      elsif is_group?( line )
-        ##  -- lets you set group  e.g. Group A etc.
-        logger.debug "skipping matched group line: >#{line}<"
-
-        group = @groups[ line ] ||= {count: 0, match_count: 0}
-        group[:count] +=1
-        @last_group = group
-        ## todo/fix:  parse group line!!!
-      elsif try_parse_game( line )
-        # do nothing here
-      else
-        logger.warn "skipping line (no match found): >#{line}<"
-        @warns << line
-      end
-    end # lines.each
-
-    [@teams, @rounds, @groups, @round_defs, @group_defs, @warns]
-  end
-
-
-  def try_parse_game( line )
-    # note: clone line; for possible test do NOT modify in place for now
-    # note: returns true if parsed, false if no match
-    parse_game( line.dup )
-  end
-
-  def parse_game( line )
-    logger.debug "parsing game (fixture) line: >#{line}<"
-
-    ## remove all protected text runs e.g. []
-    ##   fix: add [ to end-of-line too
-    ##  todo/fix: move remove protected text runs AFTER find date!! - why? why not?
-
-    line = line.gsub( /\[
-                        [^\]]+?
-                       \]/x, '' ).strip
-    return true if line.empty?    ## note: return true (for valid line with no match/teams)
-
-
-    ## split by geo (@) - remove for now
-    values = line.split( '@' )
-    line = values[0]
-
-
-    ## try find date
-    date = find_date!( line, start: @start )
-    if date   ## if found remove tagged run too; note using singular sub (NOT global gsub)
-      line = line.sub( /\[
-                          [^\]]+?
-                         \]/x, '' ).strip
-
-    else
-      ##  check for leading hours only e.g.  20.30 or 20:30 or 20h30 or 20H30 or 09h00
-      ##   todo/fix: make language dependent (or move to find_date/hour etc.) - why? why not?
-      line = line.sub(  %r{^           ## MUST be anchored to beginning of line
-                            [012]?[0-9]
-                            [.:hH]
-                            [0-9][0-9]
-                           (?=[ ])    ## must be followed by space for now (add end of line too - why? why not?)
-                          }x, '' ).strip
-    end
-
-    return true if line.empty?    ## note: return true (for valid line with no match/teams)
-
-
-    score = find_score!( line )
-
-    logger.debug "  line: >#{line}<"
-
-    line = line.sub( /\[
-                        [^\]]+?
-                       \]/x, '$$' )  # note: replace first score tag with $$
-    line = line.gsub( /\[
-                    [^\]]+?
-                   \]/x, '' )    # note: replace/remove all other score tags with nothing
-
-     ##  clean-up  remove all text run inside () or empty () too
-     line = line.gsub( /\(
-                     [^)]*?
-                    \)/x, '' )
-
-
-     ## check for more match separators e.g. - or vs for now
-     line = line.sub( / \s+
-                          (   -
-                            | v
-                            | vs\.?    # note: allow optional dot eg. vs.
-                          )
-                        \s+
-                       /ix, '$$' )
-
-     values = line.split( '$$' )
-     values = values.map { |value| value.strip }        ## strip spaces
-     values = values.select { |value| !value.empty? }   ## remove empty strings
-
-     return true    if values.size == 0  ## note: return true (for valid line with no match/teams)
-
-     if values.size == 1
-       puts "(auto config) try matching teams separated by spaces (2+):"
-       pp values
-
-       values = values[0].split( /[ ]{2,}/ )
-       pp values
-     end
-
-     return false   if values.size != 2
-
-     puts "(auto config) try matching teams:"
-     pp values
-
-     @teams[ values[0] ] += 1    ## update usage counters
-     @teams[ values[1] ] += 1
-
-     @last_round[ :match_count ] += 1    if @last_round
-     @last_group[ :match_count ] += 1    if @last_group
-
-     true
-  end
-
-
-
-  def find_score!( line )
-    # note: always call after find_dates !!!
-    #  scores match date-like patterns!!  e.g. 10-11  or 10:00 etc.
-    #   -- note: score might have two digits too
-    ScoreFormats.find!( line )
-  end
-
-  def find_date!( line, start: )
-    ## NB: lets us pass in start_at/end_at date (for event)
-    #   for auto-complete year
-
-    # extract date from line
-    # and return it
-    # NB: side effect - removes date from line string
-    DateFormats.find!( line, start: start )
-  end
-end # class AutoConfParser
-end # module SportDb
+# encoding: utf-8
+
+module SportDb
+
+
+class AutoConfParser     ## todo/check: rename/change to MatchAutoConfParser - why? why not?
+
+  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
+    parser = new( lines, start )
+    parser.parse
+  end
+
+
+  include Logging         ## e.g. logger#debug, logger#info, etc.
+  include ParserHelper    ## e.g. read_lines, etc.
+
+
+  def initialize( lines, start )
+    # for convenience split string into lines
+    ##    note: removes/strips empty lines
+    ## todo/check: change to text instead of array of lines - why? why not?
+    @lines        = lines.is_a?( String ) ? read_lines( lines ) : lines
+    @start        = start
+  end
+
+  def parse
+    ## try to  find all teams in match schedule
+    @last_round   = nil
+    @last_group   = nil
+
+    ## definitions/defs
+    @round_defs = Hash.new(0)
+    @group_defs = Hash.new(0)
+
+    ## usage/refs
+    @rounds       = {}           ## track usage counter and match (two teams) counter
+    @groups       = {}           ##  -"-
+    @teams        = Hash.new(0)   ## keep track of usage counter
+
+    @warns        = []    ## track list of warnings (unmatched lines)  too - why? why not?
+
+
+    @lines.each do |line|
+      if is_goals?( line )
+        logger.debug "skipping matched goals line: >#{line}<"
+      elsif is_round_def?( line )
+        ## todo/fix:  add round definition (w begin n end date)
+        ## todo: do not patch rounds with definition (already assume begin/end date is good)
+        ##  -- how to deal with matches that get rescheduled/postponed?
+        logger.debug "skipping matched round def line: >#{line}<"
+        @round_defs[ line ] += 1
+      elsif is_round?( line )
+        logger.debug "skipping matched round line: >#{line}<"
+
+        round = @rounds[ line ] ||= {count: 0, match_count: 0}   ## usage counter, match counter
+        round[:count] +=1
+        @last_round = round
+      elsif is_group_def?( line ) ## NB: group goes after round (round may contain group marker too)
+        ### todo: add pipe (|) marker (required)
+        logger.debug "skipping matched group def line: >#{line}<"
+        @group_defs[ line ] += 1
+      elsif is_group?( line )
+        ##  -- lets you set group  e.g. Group A etc.
+        logger.debug "skipping matched group line: >#{line}<"
+
+        group = @groups[ line ] ||= {count: 0, match_count: 0}
+        group[:count] +=1
+        @last_group = group
+        ## todo/fix:  parse group line!!!
+      elsif try_parse_game( line )
+        # do nothing here
+      else
+        logger.warn "skipping line (no match found): >#{line}<"
+        @warns << line
+      end
+    end # lines.each
+
+    [@teams, @rounds, @groups, @round_defs, @group_defs, @warns]
+  end
+
+
+  def try_parse_game( line )
+    # note: clone line; for possible test do NOT modify in place for now
+    # note: returns true if parsed, false if no match
+    parse_game( line.dup )
+  end
+
+  def parse_game( line )
+    logger.debug "parsing game (fixture) line: >#{line}<"
+
+    ## remove all protected text runs e.g. []
+    ##   fix: add [ to end-of-line too
+    ##  todo/fix: move remove protected text runs AFTER find date!! - why? why not?
+
+    line = line.gsub( /\[
+                        [^\]]+?
+                       \]/x, '' ).strip
+    return true if line.empty?    ## note: return true (for valid line with no match/teams)
+
+
+    ## split by geo (@) - remove for now
+    values = line.split( '@' )
+    line = values[0]
+
+
+    ## try find date
+    date = find_date!( line, start: @start )
+    if date   ## if found remove tagged run too; note using singular sub (NOT global gsub)
+      line = line.sub( /\[
+                          [^\]]+?
+                         \]/x, '' ).strip
+
+    else
+      ##  check for leading hours only e.g.  20.30 or 20:30 or 20h30 or 20H30 or 09h00
+      ##   todo/fix: make language dependent (or move to find_date/hour etc.) - why? why not?
+      line = line.sub(  %r{^           ## MUST be anchored to beginning of line
+                            [012]?[0-9]
+                            [.:hH]
+                            [0-9][0-9]
+                           (?=[ ])    ## must be followed by space for now (add end of line too - why? why not?)
+                          }x, '' ).strip
+    end
+
+    return true if line.empty?    ## note: return true (for valid line with no match/teams)
+
+
+    score = find_score!( line )
+
+    logger.debug "  line: >#{line}<"
+
+    line = line.sub( /\[
+                        [^\]]+?
+                       \]/x, '$$' )  # note: replace first score tag with $$
+    line = line.gsub( /\[
+                    [^\]]+?
+                   \]/x, '' )    # note: replace/remove all other score tags with nothing
+
+     ##  clean-up  remove all text run inside () or empty () too
+     line = line.gsub( /\(
+                     [^)]*?
+                    \)/x, '' )
+
+
+     ## check for more match separators e.g. - or vs for now
+     line = line.sub( / \s+
+                          (   -
+                            | v
+                            | vs\.?    # note: allow optional dot eg. vs.
+                          )
+                        \s+
+                       /ix, '$$' )
+
+     values = line.split( '$$' )
+     values = values.map { |value| value.strip }        ## strip spaces
+     values = values.select { |value| !value.empty? }   ## remove empty strings
+
+     return true    if values.size == 0  ## note: return true (for valid line with no match/teams)
+
+     if values.size == 1
+       puts "(auto config) try matching teams separated by spaces (2+):"
+       pp values
+
+       values = values[0].split( /[ ]{2,}/ )
+       pp values
+     end
+
+     return false   if values.size != 2
+
+     puts "(auto config) try matching teams:"
+     pp values
+
+     @teams[ values[0] ] += 1    ## update usage counters
+     @teams[ values[1] ] += 1
+
+     @last_round[ :match_count ] += 1    if @last_round
+     @last_group[ :match_count ] += 1    if @last_group
+
+     true
+  end
+
+
+
+  def find_score!( line )
+    # note: always call after find_dates !!!
+    #  scores match date-like patterns!!  e.g. 10-11  or 10:00 etc.
+    #   -- note: score might have two digits too
+    ScoreFormats.find!( line )
+  end
+
+  def find_date!( line, start: )
+    ## NB: lets us pass in start_at/end_at date (for event)
+    #   for auto-complete year
+
+    # extract date from line
+    # and return it
+    # NB: side effect - removes date from line string
+    DateFormats.find!( line, start: start )
+  end
+end # class AutoConfParser
+end # module SportDb

data/lib/sportdb/formats/package.rb

@@ -1,374 +1,374 @@
-
-module SportDb
-  class Package
-
-    ## todo/fix:   make all regexes case-insensitive with /i option - why? why not?
-    ##                e.g. .TXT and .txt
-    ##   yes!! use /i option!!!!!
-
-    CONF_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-        \.conf\.txt$
-    }x
-
-    ## 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.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 (/)
-       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.txt
-        clubs
-          (?:_[a-z0-9_-]+)?
-        \.txt$
-    }x
-
-    CLUBS_WIKI_RE = %r{  (?:^|/)               # beginning (^) or beginning of path (/)
-        (?:[a-z]{1,4}\.)?   # optional country code/key e.g. eng.clubs.wiki.txt
-       clubs
-         (?:_[a-z0-9_-]+)?
-       \.wiki\.txt$
-    }x
-
-    ## todo/fix: rename to CLUBS too e.g. CLUBS_PROPS to reflect filename - why? why not?
-    CLUBS_PROPS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-      (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.props.txt
-        clubs
-          (?:_[a-z0-9_-]+)?
-        \.props\.txt$
-    }x
-    CLUB_PROPS_RE = CLUBS_PROPS_RE  ## add alias for now (fix later - why? why not?)
-
-
-    CLUBS_HISTORY_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-      (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.history.txt
-        clubs
-          (?:_[a-z0-9_-]+)?
-        \.history\.txt$
-    }x
-
-    ##  teams.txt or teams_history.txt
-    TEAMS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-                      teams
-                        (?:_[a-z0-9_-]+)?
-                      \.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
-    ##                 /2016--france
-    SEASON_RE = %r{ (?:
-                       \d{4}-\d{2}
-                     | \d{4}(--[a-z0-9_-]+)?
-                    )
-                  }x
-    SEASON = SEASON_RE.source    ## "inline" helper for embedding in other regexes - keep? why? why not?
-
-
-    ## note: if pattern includes directory add here
-    ##     (otherwise move to more "generic" datafile) - why? why not?
-    MATCH_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
-                       #{SEASON}
-                     /[a-z0-9_-]+\.txt$  ## txt e.g /1-premierleague.txt
-                }x
-
-    MATCH_CSV_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
-                         #{SEASON}
-                       /[a-z0-9_.-]+\.csv$  ## note: allow dot (.) too e.g /eng.1.csv
-                    }x
-
-    ### add "generic" pattern to find all csv datafiles
-    CSV_RE = %r{ (?: ^|/ )
-                   [a-z0-9_.-]+\.csv$  ## note: allow dot (.) too e.g /eng.1.csv
-               }x
-
-
-    ## move class-level "static" finders to DirPackage (do NOT work for now for zip packages) - why? why not?
-
-    def self.find( path, pattern )
-      datafiles = []
-
-      ## check all txt files
-      ## note: incl. files starting with dot (.)) as candidates (normally excluded with just *)
-      candidates = Dir.glob( "#{path}/**/{*,.*}.*" )
-      pp candidates
-      candidates.each do |candidate|
-        datafiles << candidate    if pattern.match( candidate )
-      end
-
-      pp datafiles
-      datafiles
-   end
-
-
-   def self.find_teams( path, pattern: TEAMS_RE )  find( path, pattern ); end
-   def self.match_teams( path )  TEAMS_RE.match( path ); end
-
-   def self.find_clubs( path, pattern: CLUBS_RE )                 find( path, pattern ); end
-   def self.find_clubs_wiki( path, pattern: CLUBS_WIKI_RE )       find( path, pattern ); end
-   def self.find_clubs_history( path, pattern: CLUBS_HISTORY_RE ) find( path, pattern ); end
-
-   def self.match_clubs( path )         CLUBS_RE.match( path ); end
-   def self.match_clubs_wiki( path )    CLUBS_WIKI_RE.match( path ); end
-   def self.match_clubs_history( path ) CLUBS_HISTORY_RE.match( path); end
-   def self.match_clubs_props( path, pattern: CLUBS_PROPS_RE ) pattern.match( path ); end
-
-   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
-
-   def self.find_match( path, format: 'txt' )
-      if format == 'csv'
-        find( path, MATCH_CSV_RE )
-      else  ## otherwise always assume txt for now
-        find( path, MATCH_RE )
-      end
-   end
-   ## add match_match and match_match_csv  - why? why not?
-
-
-   class << self
-     alias_method :match_teams?, :match_teams
-     alias_method :teams?,       :match_teams
-
-     alias_method :match_clubs?, :match_clubs
-     alias_method :clubs?,       :match_clubs
-
-     alias_method :match_clubs_wiki?, :match_clubs_wiki
-     alias_method :clubs_wiki?,       :match_clubs_wiki
-
-     alias_method :match_clubs_history?, :match_clubs_history
-     alias_method :clubs_history?,       :match_clubs_history
-
-     alias_method :match_club_props,      :match_clubs_props
-     alias_method :match_club_props?,     :match_clubs_props
-     alias_method :club_props?,           :match_clubs_props
-     alias_method :match_clubs_props?,    :match_clubs_props
-     alias_method :clubs_props?,          :match_clubs_props
-
-     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
-
-
-    ## attr_reader :pack     ## allow access to embedded ("low-level") delegate package (or hide!?) - why? why not?
-    attr_accessor :include, :exclude
-
-    ## private helpers - like select returns true for keeping and false for skipping entry
-    def filter_clause( filter, entry )
-      if filter.is_a?( String )
-        entry.name.index( filter ) ? true : false
-      elsif filter.is_a?( Regexp )
-        filter.match( entry.name )  ? true : false
-      else  ## assume
-        ## todo/check: pass in entry (and NOT entry.name) - why? why not?
-        filter.call( entry )
-      end
-    end
-
-    def filter( entry )
-      if @include
-        if filter_clause( @include, entry )   ## todo/check: is include a reserved keyword????
-          true  ## todo/check: check for exclude here too - why? why not?
-        else
-          false
-        end
-      else
-        if @exclude && filter_clause( @exclude, entry )
-          false
-        else
-          true
-        end
-      end
-    end
-
-
-    def initialize( path_or_pack )
-      @include = nil
-      @exclude = nil
-
-      if path_or_pack.is_a?( Datafile::Package )
-        @pack = path_or_pack
-      else   ## assume it's a (string) path
-        path = path_or_pack
-        if !File.exist?( path )  ## file or directory
-          puts "** !!! ERROR !!! file NOT found >#{path}<; cannot open package"
-          exit 1
-        end
-
-        if File.directory?( path )
-          @pack = Datafile::DirPackage.new( path )     ## delegate to "generic" package
-        elsif File.file?( path ) && File.extname( path ) == '.zip'  # note: includes dot (.) eg .zip
-          @pack = Datafile::ZipPackage.new( path )
-        else
-          puts "** !!! ERROR !!! cannot open package - directory or file with .zip extension required"
-          exit 1
-        end
-      end
-    end
-
-
-    def each( pattern:, &blk )
-      @pack.each( pattern: pattern ) do |entry|
-        next unless filter( entry )   ## lets you use include/exclude filters
-        blk.call( entry )
-      end
-    end
-
-    def each_conf( &blk )       each( pattern: CONF_RE, &blk ); end
-    def each_match( format: 'txt', &blk )
-      if format == 'csv'
-         each( pattern: MATCH_CSV_RE, &blk );
-      else
-         each( pattern: MATCH_RE, &blk );
-      end
-    end
-    def each_match_csv( &blk )  each( pattern: MATCH_CSV_RE, &blk ); end
-    def each_csv( &blk )        each( pattern: CSV_RE, &blk );       end
-
-    def each_club_props( &blk ) each( pattern: CLUB_PROPS_RE, &blk ); end
-
-    def each_leagues( &blk )    each( pattern: LEAGUES_RE, &blk ); end
-    def each_clubs( &blk )      each( pattern: CLUBS_RE, &blk ); end
-    def each_clubs_wiki( &blk ) each( pattern: CLUBS_WIKI_RE, &blk ); end
-    def each_clubs_history( &blk )  each( pattern: CLUBS_HISTORY_RE, &blk ); end
-
-    def each_seasons( &blk )    each( pattern: SEASONS_RE, &blk ); end
-
-
-    ## return all match datafile entries
-    def match( format: 'txt' )
-      ary=[]; each_match( format: format ) {|entry| ary << entry  }; ary;
-    end
-    alias_method :matches, :match
-
-
-    ## todo/check:  rename/change to match_by_dir - why? why not?
-    ##  still in use somewhere? move to attic? use match_by_season and delete by_season_dir? - why? why not?
-    def match_by_season_dir( format: 'txt' )
-      ##
-      ## [["1950s/1956-57",
-      ##    ["1950s/1956-57/1-division1.csv",
-      ##     "1950s/1956-57/2-division2.csv",
-      ##     "1950s/1956-57/3a-division3n.csv",
-      ##     "1950s/1956-57/3b-division3s.csv"]],
-      ##   ...]
-
-      h = {}
-      match( format: format ).each do |entry|
-        season_path = File.dirname( entry.name )
-
-        h[ season_path ] ||= []
-        h[ season_path ] << entry
-      end
-
-      ##  todo/fix:  - add sort entries by name - why? why not?
-      ## note: assume 1-,2- etc. gets us back sorted leagues
-      ##  - use sort. (will not sort by default?)
-
-      h.to_a    ## return as array (or keep hash) - why? why not?
-    end # method match_by_season_dir
-
-    def match_by_season( format: 'txt', start: nil )   ## change/rename to by_season_key - why? why not?
-
-      ## todo/note: in the future - season might be anything (e.g. part of a filename and NOT a directory) - why? why not?
-
-      ##  note: fold all sames seasons (even if in different directories)
-      ##     into same datafile list e.g.
-      ##   ["1957/58",
-      ##     ["1950s/1957-58/1-division1.csv",
-      ##      "1950s/1957-58/2-division2.csv",
-      ##      "1950s/1957-58/3a-division3n.csv",
-      ##      "1950s/1957-58/3b-division3s.csv"]],
-      ## and
-      ##   ["1957/58",
-      ##      ["archives/1950s/1957-58/1-division1.csv",
-      ##       "archives/1950s/1957-58/2-division2.csv",
-      ##       "archives/1950s/1957-58/3a-division3n.csv",
-      ##       "archives/1950s/1957-58/3b-division3s.csv"]],
-      ##  should be together - why? why not?
-
-      ####
-      # Example package:
-      # [["2012/13", ["2012-13/1-proleague.csv"]],
-      #  ["2013/14", ["2013-14/1-proleague.csv"]],
-      #  ["2014/15", ["2014-15/1-proleague.csv"]],
-      #  ["2015/16", ["2015-16/1-proleague.csv"]],
-      #  ["2016/17", ["2016-17/1-proleague.csv"]],
-      #  ["2017/18", ["2017-18/1-proleague.csv"]]]
-
-      ## todo/fix:  (re)use a more generic filter instead of start for start of season only
-
-      ##  todo/fix: use a "generic" filter_season helper for easy reuse
-      ##     filter_season( clause, season_key )
-      ##   or better filter = SeasonFilter.new( clause )
-      ##             filter.skip? filter.include? ( season_sason_key )?
-      ##             fiteer.before?( season_key )  etc.
-      ##              find some good method names!!!!
-      season_start = start ? Season( start ) : nil
-
-      h = {}
-      match( format: format ).each do |entry|
-        ## note: assume last directory in datafile path is the season part/key
-        season_q = File.basename( File.dirname( entry.name ))
-        season   = Season.parse( season_q )  ## normalize season
-
-        ## skip if start season before this season
-        next if season_start && season_start.start_year > season.start_year
-
-        h[ season.key ] ||= []
-        h[ season.key ] << entry
-      end
-
-      ##  todo/fix:  - add sort entries by name - why? why not?
-      ## note: assume 1-,2- etc. gets us back sorted leagues
-      ##  - use sort. (will not sort by default?)
-
-      ## sort by season
-      ##   latest / newest first (and oldest last)
-
-      h.to_a.sort do |l,r|    ## return as array (or keep hash) - why? why not?
-        r[0] <=> l[0]
-      end
-    end # method match_by_season
-  end   # class Package
-
-
-  class DirPackage < Package
-    def initialize( path )   super( Datafile::DirPackage.new( path ) ); end
-  end
-
-  class ZipPackage < Package
-    def initialize( path )   super( Datafile::ZipPackage.new( path ) ); end
-  end
-end   # module SportDb
+
+module SportDb
+  class Package
+
+    ## todo/fix:   make all regexes case-insensitive with /i option - why? why not?
+    ##                e.g. .TXT and .txt
+    ##   yes!! use /i option!!!!!
+
+    CONF_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+        \.conf\.txt$
+    }x
+
+    ## 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.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 (/)
+       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.txt
+        clubs
+          (?:_[a-z0-9_-]+)?
+        \.txt$
+    }x
+
+    CLUBS_WIKI_RE = %r{  (?:^|/)               # beginning (^) or beginning of path (/)
+        (?:[a-z]{1,4}\.)?   # optional country code/key e.g. eng.clubs.wiki.txt
+       clubs
+         (?:_[a-z0-9_-]+)?
+       \.wiki\.txt$
+    }x
+
+    ## todo/fix: rename to CLUBS too e.g. CLUBS_PROPS to reflect filename - why? why not?
+    CLUBS_PROPS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+      (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.props.txt
+        clubs
+          (?:_[a-z0-9_-]+)?
+        \.props\.txt$
+    }x
+    CLUB_PROPS_RE = CLUBS_PROPS_RE  ## add alias for now (fix later - why? why not?)
+
+
+    CLUBS_HISTORY_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+      (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.history.txt
+        clubs
+          (?:_[a-z0-9_-]+)?
+        \.history\.txt$
+    }x
+
+    ##  teams.txt or teams_history.txt
+    TEAMS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+                      teams
+                        (?:_[a-z0-9_-]+)?
+                      \.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
+    ##                 /2016--france
+    SEASON_RE = %r{ (?:
+                       \d{4}-\d{2}
+                     | \d{4}(--[a-z0-9_-]+)?
+                    )
+                  }x
+    SEASON = SEASON_RE.source    ## "inline" helper for embedding in other regexes - keep? why? why not?
+
+
+    ## note: if pattern includes directory add here
+    ##     (otherwise move to more "generic" datafile) - why? why not?
+    MATCH_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
+                       #{SEASON}
+                     /[a-z0-9_-]+\.txt$  ## txt e.g /1-premierleague.txt
+                }x
+
+    MATCH_CSV_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
+                         #{SEASON}
+                       /[a-z0-9_.-]+\.csv$  ## note: allow dot (.) too e.g /eng.1.csv
+                    }x
+
+    ### add "generic" pattern to find all csv datafiles
+    CSV_RE = %r{ (?: ^|/ )
+                   [a-z0-9_.-]+\.csv$  ## note: allow dot (.) too e.g /eng.1.csv
+               }x
+
+
+    ## move class-level "static" finders to DirPackage (do NOT work for now for zip packages) - why? why not?
+
+    def self.find( path, pattern )
+      datafiles = []
+
+      ## check all txt files
+      ## note: incl. files starting with dot (.)) as candidates (normally excluded with just *)
+      candidates = Dir.glob( "#{path}/**/{*,.*}.*" )
+      pp candidates
+      candidates.each do |candidate|
+        datafiles << candidate    if pattern.match( candidate )
+      end
+
+      pp datafiles
+      datafiles
+   end
+
+
+   def self.find_teams( path, pattern: TEAMS_RE )  find( path, pattern ); end
+   def self.match_teams( path )  TEAMS_RE.match( path ); end
+
+   def self.find_clubs( path, pattern: CLUBS_RE )                 find( path, pattern ); end
+   def self.find_clubs_wiki( path, pattern: CLUBS_WIKI_RE )       find( path, pattern ); end
+   def self.find_clubs_history( path, pattern: CLUBS_HISTORY_RE ) find( path, pattern ); end
+
+   def self.match_clubs( path )         CLUBS_RE.match( path ); end
+   def self.match_clubs_wiki( path )    CLUBS_WIKI_RE.match( path ); end
+   def self.match_clubs_history( path ) CLUBS_HISTORY_RE.match( path); end
+   def self.match_clubs_props( path, pattern: CLUBS_PROPS_RE ) pattern.match( path ); end
+
+   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
+
+   def self.find_match( path, format: 'txt' )
+      if format == 'csv'
+        find( path, MATCH_CSV_RE )
+      else  ## otherwise always assume txt for now
+        find( path, MATCH_RE )
+      end
+   end
+   ## add match_match and match_match_csv  - why? why not?
+
+
+   class << self
+     alias_method :match_teams?, :match_teams
+     alias_method :teams?,       :match_teams
+
+     alias_method :match_clubs?, :match_clubs
+     alias_method :clubs?,       :match_clubs
+
+     alias_method :match_clubs_wiki?, :match_clubs_wiki
+     alias_method :clubs_wiki?,       :match_clubs_wiki
+
+     alias_method :match_clubs_history?, :match_clubs_history
+     alias_method :clubs_history?,       :match_clubs_history
+
+     alias_method :match_club_props,      :match_clubs_props
+     alias_method :match_club_props?,     :match_clubs_props
+     alias_method :club_props?,           :match_clubs_props
+     alias_method :match_clubs_props?,    :match_clubs_props
+     alias_method :clubs_props?,          :match_clubs_props
+
+     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
+
+
+    ## attr_reader :pack     ## allow access to embedded ("low-level") delegate package (or hide!?) - why? why not?
+    attr_accessor :include, :exclude
+
+    ## private helpers - like select returns true for keeping and false for skipping entry
+    def filter_clause( filter, entry )
+      if filter.is_a?( String )
+        entry.name.index( filter ) ? true : false
+      elsif filter.is_a?( Regexp )
+        filter.match( entry.name )  ? true : false
+      else  ## assume
+        ## todo/check: pass in entry (and NOT entry.name) - why? why not?
+        filter.call( entry )
+      end
+    end
+
+    def filter( entry )
+      if @include
+        if filter_clause( @include, entry )   ## todo/check: is include a reserved keyword????
+          true  ## todo/check: check for exclude here too - why? why not?
+        else
+          false
+        end
+      else
+        if @exclude && filter_clause( @exclude, entry )
+          false
+        else
+          true
+        end
+      end
+    end
+
+
+    def initialize( path_or_pack )
+      @include = nil
+      @exclude = nil
+
+      if path_or_pack.is_a?( Datafile::Package )
+        @pack = path_or_pack
+      else   ## assume it's a (string) path
+        path = path_or_pack
+        if !File.exist?( path )  ## file or directory
+          puts "** !!! ERROR !!! file NOT found >#{path}<; cannot open package"
+          exit 1
+        end
+
+        if File.directory?( path )
+          @pack = Datafile::DirPackage.new( path )     ## delegate to "generic" package
+        elsif File.file?( path ) && File.extname( path ) == '.zip'  # note: includes dot (.) eg .zip
+          @pack = Datafile::ZipPackage.new( path )
+        else
+          puts "** !!! ERROR !!! cannot open package - directory or file with .zip extension required"
+          exit 1
+        end
+      end
+    end
+
+
+    def each( pattern:, &blk )
+      @pack.each( pattern: pattern ) do |entry|
+        next unless filter( entry )   ## lets you use include/exclude filters
+        blk.call( entry )
+      end
+    end
+
+    def each_conf( &blk )       each( pattern: CONF_RE, &blk ); end
+    def each_match( format: 'txt', &blk )
+      if format == 'csv'
+         each( pattern: MATCH_CSV_RE, &blk );
+      else
+         each( pattern: MATCH_RE, &blk );
+      end
+    end
+    def each_match_csv( &blk )  each( pattern: MATCH_CSV_RE, &blk ); end
+    def each_csv( &blk )        each( pattern: CSV_RE, &blk );       end
+
+    def each_club_props( &blk ) each( pattern: CLUB_PROPS_RE, &blk ); end
+
+    def each_leagues( &blk )    each( pattern: LEAGUES_RE, &blk ); end
+    def each_clubs( &blk )      each( pattern: CLUBS_RE, &blk ); end
+    def each_clubs_wiki( &blk ) each( pattern: CLUBS_WIKI_RE, &blk ); end
+    def each_clubs_history( &blk )  each( pattern: CLUBS_HISTORY_RE, &blk ); end
+
+    def each_seasons( &blk )    each( pattern: SEASONS_RE, &blk ); end
+
+
+    ## return all match datafile entries
+    def match( format: 'txt' )
+      ary=[]; each_match( format: format ) {|entry| ary << entry  }; ary;
+    end
+    alias_method :matches, :match
+
+
+    ## todo/check:  rename/change to match_by_dir - why? why not?
+    ##  still in use somewhere? move to attic? use match_by_season and delete by_season_dir? - why? why not?
+    def match_by_season_dir( format: 'txt' )
+      ##
+      ## [["1950s/1956-57",
+      ##    ["1950s/1956-57/1-division1.csv",
+      ##     "1950s/1956-57/2-division2.csv",
+      ##     "1950s/1956-57/3a-division3n.csv",
+      ##     "1950s/1956-57/3b-division3s.csv"]],
+      ##   ...]
+
+      h = {}
+      match( format: format ).each do |entry|
+        season_path = File.dirname( entry.name )
+
+        h[ season_path ] ||= []
+        h[ season_path ] << entry
+      end
+
+      ##  todo/fix:  - add sort entries by name - why? why not?
+      ## note: assume 1-,2- etc. gets us back sorted leagues
+      ##  - use sort. (will not sort by default?)
+
+      h.to_a    ## return as array (or keep hash) - why? why not?
+    end # method match_by_season_dir
+
+    def match_by_season( format: 'txt', start: nil )   ## change/rename to by_season_key - why? why not?
+
+      ## todo/note: in the future - season might be anything (e.g. part of a filename and NOT a directory) - why? why not?
+
+      ##  note: fold all sames seasons (even if in different directories)
+      ##     into same datafile list e.g.
+      ##   ["1957/58",
+      ##     ["1950s/1957-58/1-division1.csv",
+      ##      "1950s/1957-58/2-division2.csv",
+      ##      "1950s/1957-58/3a-division3n.csv",
+      ##      "1950s/1957-58/3b-division3s.csv"]],
+      ## and
+      ##   ["1957/58",
+      ##      ["archives/1950s/1957-58/1-division1.csv",
+      ##       "archives/1950s/1957-58/2-division2.csv",
+      ##       "archives/1950s/1957-58/3a-division3n.csv",
+      ##       "archives/1950s/1957-58/3b-division3s.csv"]],
+      ##  should be together - why? why not?
+
+      ####
+      # Example package:
+      # [["2012/13", ["2012-13/1-proleague.csv"]],
+      #  ["2013/14", ["2013-14/1-proleague.csv"]],
+      #  ["2014/15", ["2014-15/1-proleague.csv"]],
+      #  ["2015/16", ["2015-16/1-proleague.csv"]],
+      #  ["2016/17", ["2016-17/1-proleague.csv"]],
+      #  ["2017/18", ["2017-18/1-proleague.csv"]]]
+
+      ## todo/fix:  (re)use a more generic filter instead of start for start of season only
+
+      ##  todo/fix: use a "generic" filter_season helper for easy reuse
+      ##     filter_season( clause, season_key )
+      ##   or better filter = SeasonFilter.new( clause )
+      ##             filter.skip? filter.include? ( season_sason_key )?
+      ##             fiteer.before?( season_key )  etc.
+      ##              find some good method names!!!!
+      season_start = start ? Season( start ) : nil
+
+      h = {}
+      match( format: format ).each do |entry|
+        ## note: assume last directory in datafile path is the season part/key
+        season_q = File.basename( File.dirname( entry.name ))
+        season   = Season.parse( season_q )  ## normalize season
+
+        ## skip if start season before this season
+        next if season_start && season_start.start_year > season.start_year
+
+        h[ season.key ] ||= []
+        h[ season.key ] << entry
+      end
+
+      ##  todo/fix:  - add sort entries by name - why? why not?
+      ## note: assume 1-,2- etc. gets us back sorted leagues
+      ##  - use sort. (will not sort by default?)
+
+      ## sort by season
+      ##   latest / newest first (and oldest last)
+
+      h.to_a.sort do |l,r|    ## return as array (or keep hash) - why? why not?
+        r[0] <=> l[0]
+      end
+    end # method match_by_season
+  end   # class Package
+
+
+  class DirPackage < Package
+    def initialize( path )   super( Datafile::DirPackage.new( path ) ); end
+  end
+
+  class ZipPackage < Package
+    def initialize( path )   super( Datafile::ZipPackage.new( path ) ); end
+  end
+end   # module SportDb