sportdb-formats 2.0.1 → 2.1.0

data/lib/sportdb/formats/league/league_outline_reader.rb

@@ -1,176 +0,0 @@
-# encoding: utf-8
-
-
-module SportDb
-
-## shared "higher-level" outline reader
-##  todo: add CountryOutlineReader - why? why not?
-
-class LeagueOutlineReader   ## todo/check - rename to LeaguePageReader / LeaguePageOutlineReader - why? why not?
-
-  def self.read( path, season: nil )   ## use - rename to read_file or from_file etc. - why? why not?
-    txt = File.open( path, 'r:utf-8' ) {|f| f.read }
-    parse( txt, season: season )
-  end
-
-  def self.parse( txt, season: nil )
-    new( txt ).parse( season: season )
-  end
-
-
-  def initialize( txt )
-    @txt = txt
-  end
-
-  def parse( season: nil )
-    secs=[]     # sec(tion)s
-    OutlineReader.parse( @txt ).each do |node|
-      if node[0] == :h1
-        ## check for league (and stage) and season
-        heading = node[1]
-        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:  []
-                   }
-        else
-          puts "** !!! ERROR - cannot match league and season in heading; season missing?"
-          pp heading
-          exit 1
-        end
-      elsif node[0] == :p   ## paragraph with (text) lines
-        lines = node[1]
-        ## note: skip lines if no heading seen
-        if secs.empty?
-          puts "** !!! WARN - skipping lines (no heading):"
-          pp lines
-        else
-          ## todo/check: unroll paragraphs into lines or pass along paragraphs - why? why not?
-          secs[-1][:lines] += lines
-        end
-      else
-        puts "** !!! ERROR - unknown line type; for now only heading 1 for leagues supported; sorry:"
-        pp node
-        exit 1
-      end
-    end
-
-
-    ## pass 2 - filter seasons if filter present
-    if season
-       filtered_secs = []
-       filter = norm_seasons( season )
-       secs.each do |sec|
-         if filter.include?( Season.parse( sec[:season] ).key )
-           filtered_secs << sec
-         else
-           puts "  skipping season >#{sec[:season]}< NOT matched by filter"
-         end
-       end
-       secs = filtered_secs
-    end
-
-    ## pass 3 - check & map; replace inline (string with data struct record)
-    secs.each do |sec|
-      sec[:season] = Season.parse( sec[:season ] )
-      sec[:league] = catalog.leagues.find!( sec[:league] )
-
-      check_stage( sec[:stage] )   if sec[:stage]   ## note: only check for now (no remapping etc.)
-    end
-
-    secs
-  end # method parse
-
-
-
-  def catalog() Import.catalog; end    ## shortcut convenience helper
-
-  ## split into league + season
-  ##  e.g. Österr. Bundesliga 2015/16   ## or 2015-16
-  ##       World Cup 2018
-  LEAGUE_SEASON_HEADING_RE =  %r{^
-         (?<league>.+?)     ## non-greedy
-            \s+
-         (?<season>\d{4}
-            (?:[\/-]\d{1,4})?     ## optional 2nd year in season
-         )
-            $}x
-
-
-  def norm_seasons( season_or_seasons )     ## todo/check: add alias norm_seasons - why? why not?
-
-      seasons = if season_or_seasons.is_a?( Array )  # is it an array already
-                  season_or_seasons
-                elsif season_or_seasons.is_a?( Range )  # e.g. Season(1999)..Season(2001) or such
-                  season_or_seasons.to_a
-                else  ## assume - single entry - wrap in array
-                  [season_or_seasons]
-                end
-
-      seasons.map { |season| Season( season ).key }
-  end
-
-
-  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
-    ##  etc.
-    values = str.split( /[,<>‹›]/ )  ## note: allow , > < or › ‹ for now
-    values = values.map { |value| value.strip }   ## remove all whitespaces
-    values
-  end
-
-
-  # note: normalize names e.g. downcase and remove all non a-z chars (e.g. space, dash, etc.)
-  KNOWN_STAGES = [
-    'Regular Season',
-    'Regular Stage',
-    'Championship Round',
-    'Championship Playoff',  # or Championship play-off
-    'Relegation Round',
-    'Relegation Playoff',
-    'Play-offs',
-    'Playoff Stage',
-    'Grunddurchgang',
-    'Finaldurchgang - Qualifikationsgruppe',
-    'Finaldurchgang - Qualifikation',
-    'Finaldurchgang - Meistergruppe',
-    'Finaldurchgang - Meister',
-    'EL Play-off',
-    'Europa League Play-off',
-    'Europa-League-Play-offs',
-    'Europa League Finals',
-    'Playoffs - Championship',
-    'Playoffs - Europa League',
-    'Playoffs - Europa League - Finals',
-    'Playoffs - Relegation',
-    'Playoffs - Challenger',
-    'Finals',
-    'Match 6th Place',  # e.g. Super League Greece 2012/13
-
-    'Apertura',
-    'Apertura - Liguilla',
-    'Clausura',
-    'Clausura - Liguilla',
-
-  ].map {|name| name.downcase.gsub( /[^a-z]/, '' ) }
-
-
-  def check_stage( name )
-    # note: normalize names e.g. downcase and remove all non a-z chars (e.g. space, dash, etc.)
-    if KNOWN_STAGES.include?( name.downcase.gsub( /[^a-z]/, '' ) )
-       ## everything ok
-    else
-      puts "** !!! ERROR - no (league) stage match found for >#{name}<, add to (builtin) stages table; sorry"
-      exit 1
-    end
-  end
-
- end # class LeagueOutlineReader
-
-end # module SportDb

data/lib/sportdb/formats/league/league_reader.rb

@@ -1,152 +0,0 @@
-
-module SportDb
-module Import
-
-
-class LeagueReader
-
-  def world() Import.world; 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
-
-
-
-include Logging
-
-def initialize( txt )
-  @txt = txt
-end
-
-def parse
-  recs = []
-  last_rec = nil
-
-  country  = nil    # last country
-  intl     = false  # is international (league/tournament/cup/competition)
-  clubs    = true   # or clubs|national teams
-
-  OutlineReader.parse( @txt ).each do |node|
-    if [:h1,:h2,:h3,:h4,:h5,:h6].include?( node[0] )
-      heading_level  = node[0][1].to_i
-      heading        = node[1]
-
-      logger.debug "heading #{heading_level} >#{heading}<"
-
-      if heading_level != 1
-        puts "** !!! ERROR !!! unsupported heading level; expected heading 1 for now only; sorry"
-        pp line
-        exit 1
-      else
-        logger.debug "heading (#{heading_level}) >#{heading}<"
-        last_heading = heading
-        ## map to country or international / int'l or national teams
-        if heading =~ /national team/i   ## national team tournament
-          country = nil
-          intl    = true
-          clubs   = false
-        elsif heading =~ /international|int'l/i  ## int'l club tournament
-          country = nil
-          intl    = true
-          clubs   = true
-        else
-          ## assume country in heading; allow all "formats" supported by parse e.g.
-          ##   Österreich • Austria (at)
-          ##   Österreich • Austria
-          ##   Austria
-          ##   Deutschland (de) • Germany
-          country = world.countries.parse( heading )
-          intl    = false
-          clubs   = true
-
-          ## check country code - MUST exist for now!!!!
-          if country.nil?
-            puts "!!! error [league reader] - unknown country >#{heading}< - sorry - add country to config to fix"
-            exit 1
-          end
-        end
-      end
-    elsif node[0] == :p   ## paragraph with (text) lines
-      lines = node[1]
-      lines.each do |line|
-
-      if line.start_with?( '|' )
-          ## assume continuation with line of alternative names
-          ##  note: skip leading pipe
-          values = line[1..-1].split( '|' )   # team names - allow/use pipe(|)
-          values = values.map {|value| _norm(value) }  ## squish/strip etc.
-
-          logger.debug "alt_names: #{values.join( '|' )}"
-
-          last_rec.alt_names += values
-      else
-        ## assume "regular" line
-        ##  check if starts with id  (todo/check: use a more "strict"/better regex capture pattern!!!)
-        if line =~ /^([a-z0-9][a-z0-9.]*)[ ]+(.+)$/
-          league_key  = $1
-          ## 1) strip (commercial) sponsor markers/tags e.g $$
-          ## 2) strip and squish (white)spaces
-          league_name = _norm( $2 )
-
-          logger.debug "key: >#{league_key}<, name: >#{league_name}<"
-
-
-          ## prepend country key/code if country present
-          ##   todo/fix: only auto-prepend country if key/code start with a number (level) or incl. cup
-          ##    why? lets you "overwrite" key if desired - use it - why? why not?
-          if country
-            league_key = "#{country.key}.#{league_key}"
-          end
-
-          rec = League.new( key:            league_key,
-                            name:           league_name,
-                            country:        country,
-                            intl:           intl,
-                            clubs:          clubs)
-          recs << rec
-          last_rec = rec
-        else
-          puts "** !!! ERROR !!! missing key for (canonical) league name"
-          exit 1
-        end
-      end
-      end  # each line
-    else
-      puts "** !!! ERROR !!! [league reader] - unknown line type:"
-      pp node
-      exit 1
-    end
-    ## pp line
-  end
-  recs
-end # method parse
-
-
-
-#######################
-###  helpers
-
-## norm(alize) helper  - squish (spaces) 
-##                      and remove dollars ($$$)
-##                      and remove leading and trailing spaces
-def _norm( str )
-  ## only extra clean-up of dollars for now ($$$)
-  _squish( str.gsub( '$', '' ) )
-end
-
-def _squish( str )
-  str.gsub( /[ \t\u00a0]+/, ' ' ).strip
-end
-
-
-end # class LeagueReader
-
-end ## module Import
-end ## module SportDb

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

@@ -1,132 +0,0 @@
-module SportDb
-
-  class ConfParser
-
-    def self.parse( lines )
-      parser = new( lines )
-      parser.parse
-    end
-
-    include Logging         ## e.g. logger#debug, logger#info, 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.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
-      end
-      lines
-    end
-
-
-    def initialize( lines )
-      # 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
-    end
-
-
-
-    COUNTRY_RE = %r{ [<>‹›,]
-                     [ ]*
-                     (?<country>[A-Z]{2,4})   ## todo/check: allow one-letter (motor vehicle plates) or 5 letter possible?
-                    \b}xi
-
-
-    ## standings table row regex matcher e.g.
-    ##     1  Manchester City         38  32  4  2 106-27 100
-    ## or  1. Manchester City         38  32  4  2 106:27 100
-    TABLE_RE = %r{ ^
-                    (?:
-                      (?<rank>\d+)\.?
-                         |
-                        [-]
-                     )
-                    [ ]+
-                      (?<team>.+?)   ## note: let's use non-greedy (MINIMUM length) match for now
-                    [ ]+
-                      (?<pld>\d+)    ## (pl)aye(d)
-                    [ ]+
-                      (?<w>\d+)      ## (w)ins
-                    [ ]+
-                      (?<d>\d+)     ## (d)raws
-                    [ ]+
-                      (?<l>\d+)      ## (l)ost
-                    [ ]+
-                      (?<gf>\d+)     ## (g)oal (f)or
-                        [ ]*
-                        [:-]    ## note: allow 10-10 or 10:10 or 10 - 10 or 10 : 10 etc.
-                        [ ]*
-                      (?<ga>\d+)      ## (g)oal (a)gainst
-                     (?:          ## allow optional (g)oal (d)ifference
-                        [ ]+
-                        (?<gd>[±+-]?\d+)  ## (g)oal (d)ifference
-                      )?
-                     [ ]+
-                      (?<pts>\d+)      ## (p)oin(ts)
-                         (?:     ## allow optional deductions e.g. [-7]
-                               [ ]+
-                            \[(?<deduction>-\d+)\]
-                         )?
-                      $}x
-
-    def parse
-      teams = {}    ## convert lines to teams
-
-      @lines.each do |line|
-        next if line =~ /^[ -]+$/   ## skip decorative lines with dash only (e.g. ---- or - - - -) etc.
-
-
-        ## quick hack - check for/extract (optional) county code (for teams) first
-        ##  allow as separators <>‹›,  NOTE: includes (,) comma for now too
-        m = nil
-        country = nil
-        if m=COUNTRY_RE.match( line )
-          country = m[:country]
-          line = line.sub( m[0], '' )  ## replace match with nothing for now
-        end
-
-        if m=TABLE_RE.match( line )
-          puts "  matching table entry >#{line}<"
-
-          name = m[:team]
-          rank = m[:rank] ? Integer(m[:rank]) : nil
-
-          standing = {
-            pld: Integer(m[:pld]),
-            w:   Integer(m[:w]),
-            d:   Integer(m[:d]),
-            l:   Integer(m[:l]),
-            gf:  Integer(m[:gf]),
-            ga:  Integer(m[:ga]),
-          }
-          standing[ :gd ]        = Integer(m[:gd].gsub(/[±+]/,''))    if m[:gd]
-          standing[ :pts ]       = Integer(m[:pts])
-          standing[ :deduction ] = Integer(m[:deduction])  if m[:deduction]
-
-
-          ## todo/fix: track double usage - why? why not? report/raise error/exception on duplicates?
-          team = teams[ name ] ||= { }
-          team[ :country ]   = country     if country
-
-          team[ :rank ]      = rank        if rank
-          team[ :standing ]  = standing    if standing
-        else
-          ## assume team is full line
-          name = line.strip  # note: strip leading and trailing spaces
-
-          team = teams[ name ] ||= { }
-          team[ :country ]  = country     if country
-        end
-      end
-
-      teams
-    end # method parse
-
-  end # class ConfParser
-end # module SportDb