sportdb-formats 2.0.2 → 2.1.0

data/lib/sportdb/formats/country/country_reader.rb

@@ -1,142 +0,0 @@
-# encoding: utf-8
-
-
-module SportDb
-module Import
-
-
-class CountryReader
-
-
-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
-
-def parse
-  countries    = []
-  last_country = nil    ## note/check/fix: use countries[-1] - why? why not?
-
-  OutlineReader.parse( @txt ).each do |node|
-
-     node_type = node[0]
-
-     if [:h1, :h2].include?( node_type )
-       ## skip headings (and headings) for now too
-     elsif node_type == :p    ## paragraph
-      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(|)
-        ## strip and squish (white)spaces
-        #   e.g. East Germany        (-1989)  => East Germany (-1989)
-        values = values.map { |value| value.strip.gsub( /[ \t]+/, ' ' ) }
-        last_country.alt_names += values
-      elsif line =~ /^-[ ]*(\d{4})
-                        [ ]+
-                       (.+)$
-                    /x     ## check for historic lines e.g. -1989
-         year   = $1.to_i
-         parts  = $2.split( /=>|⇒/ )
-         values = parts[0].split( ',' )
-         values = values.map { |value| value.strip.gsub( /[ \t]+/, ' ' ) }
-
-         name = values[0]
-         code = values[1]
-
-         last_country = country = Country.new( name: "#{name} (-#{year})",
-                                               code: code )
-         ## country.alt_names << name    ## note: for now do NOT add name without year to alt_names - gets auto-add by index!!!
-
-         countries << country
-         ## todo/fix: add reference to country today (in parts[1] !!!!)
-      else
-        ## assume "regular" line
-        ##  check if starts with id  (todo/check: use a more "strict"/better regex capture pattern!!!)
-        ##   note: allow country codes upto 4 (!!) e.g. Northern Cyprus
-        if line =~ /^([a-z]{2,4})
-                        [ ]+
-                       (.+)$/x
-          key    = $1
-          values = $2.split( ',' )
-          ## strip and squish (white)spaces
-          #   e.g. East Germany        (-1989)  => East Germany (-1989)
-          values = values.map { |value| value.strip.gsub( /[ \t]+/, ' ' ) }
-
-          ## note: remove "overlords" from geo-tree marked territories  e.g. UK, US, etc. from name
-          ##    e.g. England › UK      => England
-          ##         Puerto Rico › US  => Puerto Rico
-          geos = split_geo( values[0] )
-          name = geos[0]    ## note: ignore all other geos for now
-
-          ##   note: allow country codes up to 4 (!!) e.g. Northern Cyprus
-          code = if values[1] && values[1] =~ /^[A-Z]{3,4}$/   ## note: also check format
-                   values[1]
-                 else
-                   if values[1]
-                     puts "** !!! ERROR !!! wrong code format >#{values[1]}<; expected three (or four)-letter all up-case"
-                   else
-                     puts "** !!! ERROR !!! missing code for (canonical) country name"
-                   end
-                   exit 1
-                 end
-
-          tags = if values[2]   ## check if tags presents
-                   split_tags( values[2] )
-                 else
-                   []
-                 end
-
-          last_country = country = Country.new( key: key,
-                                                name: name,
-                                                code: code,
-                                                tags: tags )
-          countries << country
-        else
-          puts "** !! ERROR - missing key for (canonical) country name"
-          exit 1
-        end
-      end
-      end  # each line
-    else
-      puts "** !! ERROR - unknown node type / (input) source line:"
-      pp node
-      exit 1
-    end
-  end    # each node
-
-  countries
-end  # method parse
-
-
-
-#######################################
-##  helpers
-def split_tags( str )
-  tags = str.split( /[|<>‹›]/ )   ## allow pipe (|) and (<>‹›) as divider for now - add more? why? why not?
-  tags = tags.map { |tag| tag.strip }
-  tags
-end
-
-def split_geo( str )   ## todo/check: rename to parse_geo(s) - why? why not?
-  ## split into geo tree
-  geos = str.split( /[<>‹›]/ )          ## note: allow > < or › ‹ for now
-  geos = geos.map { |geo| geo.strip }   ## remove all whitespaces
-  geos
-end
-
-end  # class CountryReader
-
-end   # module Import
-end   # module SportDb

data/lib/sportdb/formats/csv/goal.rb

@@ -1,192 +0,0 @@
-
-module Sports
-
-## "free-standing" goal event - for import/export  in separate event / goal datafiles
-##   returned by CsvGoalParser and others
-class GoalEvent
-
-  def self.build( row )  ## rename to parse or such - why? why not?
-
-  ## split match_id
-  team_str, more_str   = row['Match'].split( '|' )
-  team1_str, team2_str = team_str.split( ' - ' )
-
-  more_str  = more_str.strip
-  team1_str = team1_str.strip
-  team2_str = team2_str.strip
-
-   # check if more_str is a date otherwise assume round
-   date_fmt = if more_str =~ /^[A-Z]{3} [0-9]{1,2}$/i  ## Apr 4
-                '%b %d'
-              elsif more_str =~ /^[A-Z]{3} [0-9]{1,2} [0-9]{4}$/i  ## Apr 4 2019
-                '%b %d %Y'
-             else
-                nil
-             end
-
-   if date_fmt
-    date  = Date.strptime( more_str, date_fmt )
-    round = nil
-   else
-    date  = nil
-    round = more_str
-   end
-
-
-    values = row['Score'].split('-')
-    values = values.map { |value| value.strip }
-    score1 = values[0].to_i
-    score2 = values[1].to_i
-
-    minute = nil
-    offset = nil
-    if m=%r{([0-9]+)
-              (?:[ ]+
-                   \+([0-9]+)
-                )?
-                ['.]
-          $}x.match( row['Minute'])
-      minute = m[1].to_i
-      offset = m[2] ? m[2].to_i : nil
-    else
-      puts "!! ERROR - unsupported minute (goal) format >#{row['Minute']}<"
-      exit 1
-    end
-
-    attributes = {
-          team1:  team1_str,
-          team2:  team2_str,
-          date:   date,
-          round:  round,
-          score1: score1,
-          score2: score2,
-          minute: minute,
-          offset: offset,
-          player: row['Player'],
-          owngoal: ['(og)', '(o.g.)'].include?( row['Extra']),
-          penalty: ['(pen)', '(pen.)'].include?( row['Extra']),
-          notes:   (row['Notes'].nil? || row['Notes'].empty?) ? nil : row['Notes']
-        }
-
-    new( **attributes )
-  end
-
-
-  ## match id
-  attr_reader  :team1,
-               :team2,
-               :round,  ## optional
-               :date   ## optional
-
-  ## main attributes
-  attr_reader :score1,
-              :score2,
-              :player,
-              :minute,
-              :offset,
-              :owngoal,
-              :penalty,
-              :notes
-
-
-  ## todo/check: or just use match.hash or such if match mapping known - why? why not?
-  def match_id
-    if round
-      "#{@team1} - #{@team2} | #{@round}"
-    else
-      "#{@team1} - #{@team2} | #{@date}"
-    end
-  end
-
-
-  def owngoal?() @owngoal==true; end
-  def penalty?() @penalty==true; end
-
-  def initialize( team1:,
-                  team2:,
-                  round:   nil,
-                  date:    nil,
-                  score1:,
-                  score2:,
-                  player:,
-                  minute:,
-                  offset:  nil,
-                  owngoal: false,
-                  penalty: false,
-                  notes:   nil
-                )
-    @team1   = team1
-    @team2   = team2
-    @round   = round
-    @date    = date
-
-    @score1  = score1
-    @score2  = score2
-    @player  = player
-    @minute  = minute
-    @offset  = offset
-    @owngoal = owngoal
-    @penalty = penalty
-    @notes   = notes
-  end
-
-
-  ## note: lets you use normalize teams or such acts like a Match struct
-  def update( **kwargs )
-    ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
-    @team1 = kwargs[:team1]    if kwargs.has_key? :team1
-    @team2 = kwargs[:team2]    if kwargs.has_key? :team2
-  end
-end  # class GoalEvent
-
-
-### extend "basic" goal struct with goal event build
-class Goal  ### nested (non-freestanding) inside match (match is parent)
-
-  def self.build( events )  ## check/todo - rename to build_from_event/row or such - why? why not?
-    ## build an array of goal structs from (csv) recs
-    recs = []
-
-    last_score1 = 0
-    last_score2 = 0
-
-    events.each do |event|
-
-      if last_score1+1 == event.score1 && last_score2 == event.score2
-        team = 1
-      elsif last_score2+1 == event.score2 && last_score1 == event.score1
-        team = 2
-      else
-        puts "!! ERROR - unexpected score advance (one goal at a time expected):"
-        puts "  #{last_score1}-#{last_score2}=> #{event.score1}-#{event.score2}"
-        exit 1
-      end
-
-      last_score1 = event.score1
-      last_score2 = event.score2
-
-
-      attributes = {
-        score1:  event.score1,
-        score2:  event.score2,
-        team:    team,
-        minute:  event.minute,
-        offset:  event.offset,
-        player:  event.player,
-        owngoal: event.owngoal,
-        penalty: event.penalty,
-        notes:   event.notes
-      }
-
-      recs << new( **attributes )
-    end
-
-    recs
-  end
-end  # class Goal
-
-
-end # module Sports
-
-
-

data/lib/sportdb/formats/csv/goal_parser_csv.rb

@@ -1,28 +0,0 @@
-
-module SportDb
-  class CsvGoalParser
-
-
-  def self.read( path )
-     txt = File.open( path, 'r:utf-8' ) {|f| f.read }   ## note: make sure to use (assume) utf-8
-     parse( txt )
-  end
-
-  def self.parse( txt )
-     new( txt ).parse
-  end
-
-
-  def initialize( txt )
-    @txt = txt
-  end
-
-  def parse
-    rows = parse_csv( @txt )
-    recs = rows.map { |row| Sports::GoalEvent.build( row ) }
-    ## pp recs[0]
-    recs
-  end
-
-  end # class CsvGoalParser
-end # module Sports