sportdb-formats 1.2.0 → 2.0.0

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

@@ -1,319 +0,0 @@
-# encoding: utf-8
-
-module SportDb
-
-##
-## note: this was/is a cut-n-page (inline) copy of TextUtils::TitleMapper2
-##   see https://github.com/textkit/textutils/blob/master/textutils/lib/textutils/title_mapper2.rb
-
-
-class MapperV2      ## todo/check: rename to NameMapper ? why? why not??
-
-  include Logging
-
-  attr_reader :known_names   ## rename to mapping or mappings or just names - why? why not?
-
-  ########
-  ##  key:      e.g. augsburg
-  ##  name:     e.g. FC Augsburg
-  ##  length (of name(!!) - not regex pattern):   e.g. 11   -- do not count dots (e.g. U.S.A. => 3 or 6) why? why not?
-  MappingStruct =  Struct.new( :key, :name, :length, :pattern)     ## todo/check: use (rename to) NameStruct - why? why not??
-
-  ######
-  ## convenience helper - (auto)build ActiveRecord-like team records/structs
-  Record = Struct.new( :key, :name, :alt_names )
-  def build_records( txt_or_lines )
-    recs = []
-
-    if txt_or_lines.is_a?( String )
-        ## todo/fix: use ParserHelper read_lines !!! ????
-        txt = txt_or_lines
-        lines = []
-
-        txt.each_line do |line|
-          line = line.strip
-
-          next if line.empty? || line.start_with?( '#' )  ## note: skip empty and comment lines
-          lines << line
-        end
-    else
-        lines = txt_or_lines
-    end
-
-    lines.each do |line|
-      values = line.split( '|' )
-      values = values.map { |value| value.strip }
-
-      name      = values[0]
-      ## note: quick hack - auto-generate key, that is, remove all non-ascii chars and downcase
-      key       = name.downcase.gsub( /[^a-z]/, '' )
-      alt_names = values.size > 1 ? values[1..-1].join( '|' ) : nil
-
-      recs << Record.new( key, name, alt_names )
-    end
-    recs
-  end
-
-
-  def initialize( records_or_mapping, tag )
-    ## for convenience allow easy (auto-)convert text (lines) to records
-    ##  as 1) text block/string  or
-    ##     2) array of lines/strings
-    records_or_mapping = build_records( records_or_mapping )   if records_or_mapping.is_a?( String ) ||
-                                                                  (records_or_mapping.is_a?( Array ) && records_or_mapping[0].is_a?( String ))
-
-    ## build mapping lookup table
-    @known_names =  if records_or_mapping.is_a?( Hash )  ## assume "custom" mapping hash table (name=>record)
-                        build_name_table_for_mapping( records_or_mapping )
-                     else  ## assume array of records
-                        build_name_table_for_records( records_or_mapping )
-                     end
-
-    ## build lookup hash by record (e.g. team/club/etc.) key
-    records = if records_or_mapping.is_a?( Array )
-                  records_or_mapping
-              else   ## assume hash (uses values assuming to be all records - note might include duplicates)
-                  records_or_mapping.values
-              end
-
-    @records = records.reduce({}) { |h,rec| h[rec.key]=rec; h }
-
-
-    ## todo: rename tag to attrib or attrib_name - why ?? why not ???
-    @tag = tag   # e.g. tag name use for @@brewery@@ @@team@@ etc.
-  end
-
-
-
-  def map_names!( line )   ## rename to just map! - why?? why not???
-    begin
-      found = map_name_for!( @tag, line, @known_names )
-    end while found
-  end
-
-  def find_rec!( line )
-    find_rec_for!( @tag, line, @records )
-  end
-
-  def find_recs!( line )  # note: keys (plural!) - will return array
-    counter = 1
-    recs = []
-
-    rec = find_rec_for!( "#{@tag}#{counter}", line, @records )
-    while rec
-      recs << rec
-      counter += 1
-      rec = find_rec_for!( "#{@tag}#{counter}", line, @records )
-    end
-    recs
-  end
-
-
-private
-  def build_name_table_for_mapping( mapping )
-    known_names = []
-
-    mapping.each do |name, rec|
-      m = MappingStruct.new
-      m.key     = rec.key
-      m.name    = name
-      m.length  = name.length
-      m.pattern = Regexp.escape( name )   ## note: just use "standard" regex escape (e.g. no extras for umlauts,accents,etc.)
-
-      known_names << m
-    end
-
-    ## note: sort here by length (largest goes first - best match)
-    known_names = known_names.sort { |l,r| r.length <=> l.length }
-    known_names
-  end
-
-  def build_name_table_for_records( records )
-
-    ## build known tracks table w/ alt names e.g.
-    #
-    # [[ 'wolfsbrug', 'VfL Wolfsburg'],
-    #  [ 'augsburg',  'FC Augsburg'],
-    #  [ 'augsburg',  'Augi2'],
-    #  [ 'augsburg',  'Augi3' ],
-    #  [ 'stuttgart', 'VfB Stuttgart']]
-
-    known_names = []
-
-    records.each_with_index do |rec,index|
-
-      name_candidates = []
-      name_candidates << rec.name
-
-      name_candidates += rec.alt_names.split('|') if rec.alt_names && !rec.alt_names.empty?
-
-
-      ## check if name includes subname e.g. Grand Prix Japan (Suzuka Circuit)
-      #  make subname optional by adding name w/o subname e.g. Grand Prix Japan
-
-      names = []
-      name_candidates.each do |t|
-        names << t
-        if t =~ /\(.+\)/
-          extra_name = t.gsub( /\(.+\)/, '' ) # remove/delete subnames
-          # note: strip leading n trailing withspaces too!
-          #  -- todo: add squish or something if () is inline e.g. leaves two spaces?
-          extra_name.strip!
-          names << extra_name
-        end
-      end
-
-      names.each do |name|
-        m = MappingStruct.new
-        m.key     = rec.key
-        m.name    = name
-        m.length  = name.length
-        ## note: escape for regex plus allow subs for special chars/accents
-        m.pattern = name_esc_regex( name )
-
-        known_names << m
-      end
-
-      logger.debug "  #{rec.class.name}[#{index+1}] #{rec.key} >#{names.join('|')}<"
-
-      ## note: only include code field - if defined
-      if rec.respond_to?(:code) && rec.code && !rec.code.empty?
-        m = MappingStruct.new
-        m.key     = rec.key
-        m.name    = rec.code
-        m.length  = rec.code.length
-        m.pattern = rec.code   ## note: use code for now as is (no variants allowed fow now)
-
-        known_names << m
-      end
-    end
-
-    ## note: sort here by length (largest goes first - best match)
-      #  exclude code and key (key should always go last)
-    known_names = known_names.sort { |l,r| r.length <=> l.length }
-    known_names
-  end
-
-
-
-  def map_name_for!( tag, line, mappings )
-    mappings.each do |mapping|
-      key     = mapping.key
-      pattern = mapping.pattern
-      ## nb: \b does NOT include space or newline for word boundry (only alphanums e.g. a-z0-9)
-      ## (thus add it, allows match for Benfica Lis.  for example - note . at the end)
-
-      ## check add $ e.g. (\b| |\t|$) does this work? - check w/ Benfica Lis.$
-      re = /\b#{pattern}(\b| |\t|$)/   # wrap with world boundry (e.g. match only whole words e.g. not wac in wacker)
-      if line =~ re
-        logger.debug "     match for #{tag.downcase}  >#{key}< >#{pattern}<"
-        # make sure @@oo{key}oo@@ doesn't match itself with other key e.g. wacker, wac, etc.
-        line.sub!( re, "@@oo#{key}oo@@ " )    # NB: add one space char at end
-        return true    # break out after first match (do NOT continue)
-      end
-    end
-
-    false
-  end
-
-
-  def find_rec_for!( tag, line, records )
-    re = /@@oo([^@]+?)oo@@/     # e.g. everything in @@ .... @@ (use non-greedy +? plus all chars but not @, that is [^@])
-
-    if line =~ re
-      key = $1
-      logger.debug "   #{tag.downcase}: >#{key}<"
-
-      line.sub!( re, "[#{tag.upcase}]" )
-
-      records[ key ]  ## note: map key to record (using records hash table mapping)
-    else
-      nil
-    end
-  end # method find_key_for!
-
-
-####
-# name helper cut-n-paste copy from TextUtils
-##  see https://github.com/textkit/textutils/blob/master/textutils/lib/textutils/helper/title_helper.rb
-def name_esc_regex( name_unescaped )
-
-      ##  escape regex special chars e.g.
-      #    . to \. and
-      #    ( to \(
-      #    ) to \)
-      #    ? to \? -- zero or one
-      #    * to \* -- zero or more
-      #    + to \+ -- one or more
-      #    $ to \$ -- end of line
-      #    ^ to \^ -- start of line etc.
-
-      ### add { and } ???
-      ### add [ and ] ???
-      ### add \ too ???
-      ### add | too ???
-
-      # e.g. Benfica Lis.
-      # e.g. Club Atlético Colón (Santa Fe)
-      # e.g. Bauer Anton (????)
-
-      ## note: cannot use Regexp.escape! will escape space '' to '\ '
-      ## name = Regexp.escape( name_unescaped )
-      name = name_unescaped.gsub( '.', '\.' )
-      name = name.gsub( '(', '\(' )
-      name = name.gsub( ')', '\)' )
-      name = name.gsub( '?', '\?' )
-      name = name.gsub( '*', '\*' )
-      name = name.gsub( '+', '\+' )
-      name = name.gsub( '$', '\$' )
-      name = name.gsub( '^', '\^' )
-
-      ##  match accented char with or without accents
-      ##  add (ü|ue) etc.
-      ## also make - optional change to (-| ) e.g. Blau-Weiss == Blau Weiss
-
-      ## todo: add some more
-      ## see http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references  for more
-      ##
-      ##  reuse for all readers!
-
-      alternatives = [
-        ['-', '(-| )'],  ## e.g. Blau-Weiß Linz
-        ['æ', '(æ|ae)'],  ## e.g.
-        ['ä', '(ä|ae)'],  ## e.g.
-        ['Ö', '(Ö|Oe)'],  ## e.g. Österreich
-        ['ö', '(ö|oe)'],  ## e.g. Mönchengladbach
-        ['ß', '(ß|ss)'],  ## e.g. Blau-Weiß Linz
-        ['ü', '(ü|ue)'],  ## e.g.
-
-        ['á', '(á|a)'],  ## e.g. Bogotá, Sársfield
-        ['ã', '(ã|a)'],  ## e.g  São Paulo
-        ['ç', '(ç|c)'],  ## e.g. Fenerbahçe
-        ['é', '(é|e)'],  ## e.g. Vélez
-        ['ê', '(ê|e)'],  ## e.g. Grêmio
-        ['ï', '(ï|i)' ], ## e.g. El Djazaïr
-        ['ñ', '(ñ|n)'],  ## e.g. Porteño
-        ['ň', '(ň|n)'],  ## e.g. Plzeň
-        ['ó', '(ó|o)'],   ## e.g. Colón
-        ['ō', '(ō|o)'],  # # e.g. Tōkyō
-        ['ș', '(ș|s)'],   ## e.g. Bucarești
-        ['ú', '(ú|u)']  ## e.g. Fútbol
-      ]
-
-      ### fix/todo:  check for  dot+space e.g. . and make dot optional
-      ##
-      #  e.g. make  dot (.) optional plus allow alternative optional space e.g.
-      #   -- for U.S.A. => allow USA or U S A
-      #
-      ##    e.g. U. de G. or U de G or U.de G. ??
-      ##   collect some more (real-world) examples first!!!!!
-
-      alternatives.each do |alt|
-        name = name.gsub( alt[0], alt[1] )
-      end
-
-      name
-  end
-
-end # class MapperV2
-end # module SportDb

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

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-module SportDb
-
-class TeamMapper
-  def initialize( records_or_mapping )
-    @mapper = MapperV2.new( records_or_mapping, 'team' )
-  end
-
-  def find_teams!( line ) # Note: returns an array - note: plural! (teamsssss)
-    @mapper.find_recs!( line )
-  end
-
-  def find_team!( line )  # Note: returns key (string or nil)
-    @mapper.find_rec!( line )
-  end
-
-  def map_teams!( line )
-    @mapper.map_names!( line )
-  end
-end # class TeamMapper
-
-end # module SportDb

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

@@ -1,270 +0,0 @@
-
-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?
- 
-    ## note - wrap in enumerator/iterator a.k.a lines reader
-    @lines = LinesReader.new( lines.is_a?( String ) ?
-                                 read_lines( lines ) : 
-                                 lines 
-                            )
- 
-    @start        = start
-  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_REGEX = /^  
-                   [ ]*?     # slurp leading spaces
-                (?<key>[^:|\]\[()\/; -]
-                       [^:|\]\[()\/;]{0,30}
-                 )
-                   [ ]*?     # slurp trailing spaces
-                   :[ ]+
-                (?<value>.+)
-                    [ ]*?   # slurp trailing spaces
-                   $
-                /ix
-
-
-  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
-
-    ## note: ground incl. optional city (timezone) etc. - why? why not?
-    @grounds      = Hash.new(0)    
-  
-    @warns        = []    ## track list of warnings (unmatched lines)  too - why? why not?
-
-
-  ## todo/fix - use @lines.rewind first  here - why? why not?   
-    @lines.each do |line|
-      if 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 m=ATTRIB_REGEX.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
-
-        ## check if line ends with dot
-        ##  if not slurp up lines to the next do!!!
-        logger.debug "skipping key/value line - >#{line}<"
-        while !line.end_with?( '.' ) || line.nil? do
-            line = @lines.next
-            logger.debug "skipping key/value line (cont.) - >#{line}<"
-        end        
-      elsif is_goals?( line )
-        ## note - goals must be AFTER attributes!!!
-        logger.debug "skipping matched goals line: >#{line}<"
-      elsif try_parse_game( line )
-        # do nothing here
-      else
-        logger.warn "skipping line (no match found): >#{line}<"
-        @warns << line
-      end
-    end # lines.each
-
-    ## new - add grounds and cities
-    [@teams, @rounds, @groups, @round_defs, @group_defs,
-     @grounds,  ## note: ground incl. optional city (timezone) etc. 
-     @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( '@' )
-
-    ### check for ground/stadium and cities
-    if values.size == 1
-       ## no stadium
-    elsif values.size == 2   # bingo!!!
-       ## process stadium, city (timezone) etc.
-       ## for now keep it simple - pass along "unparsed" all-in-one
-       ground = values[1].gsub( /[ \t]+/, ' ').strip   ## squish
-       @grounds[ ground ] += 1
-    else
-       puts "!! ERROR - too many @-markers found in line:"
-       puts line
-       exit 1
-    end
-
-    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/outline_reader.rb

@@ -1,90 +0,0 @@
-
-module SportDb
-
-class OutlineReader
-
-  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
-
-        ## 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  = m[:marker].length   ## count number of = for heading level
-           heading        = m[:text].strip
-
-           puts "heading #{heading_level} >#{heading}<"
-           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