sportdb-formats 0.4.0 → 1.0.0

data/lib/sportdb/formats/version.rb

@@ -4,8 +4,8 @@
 module SportDb
 module Formats
 
-  MAJOR = 0    ## todo: namespace inside version or something - why? why not??
-  MINOR = 4
+  MAJOR = 1    ## todo: namespace inside version or something - why? why not??
+  MINOR = 0
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/test/helper.rb

@@ -1,4 +1,6 @@
-## $:.unshift(File.dirname(__FILE__))
+## note: use the local version of gems
+$LOAD_PATH.unshift( File.expand_path( '../date-formats/lib' ))
+
 
 ## minitest setup
 require 'minitest/autorun'
@@ -6,3 +8,83 @@ require 'minitest/autorun'
 
 ## our own code
 require 'sportdb/formats'
+
+
+################
+## helper
+
+def parse_auto_conf( txt, lang: 'en', start: nil )
+  start = start ? start : Date.new( 2017, 7, 1 )
+
+  SportDb::Import.config.lang = lang
+
+  parser = SportDb::AutoConfParser.new( txt, start )
+  parser.parse
+end
+
+def parse_conf( txt )
+  parser = SportDb::ConfParser.new( txt )
+  parser.parse
+end
+
+
+## note: json always returns hash tables with string keys (not symbols),
+##        thus, always stringify keys before comparing!!!!
+class Object
+  def deep_stringify_keys
+    if self.is_a? Hash
+      self.reduce({}) {|memo,(k,v)| memo[k.to_s] = v.deep_stringify_keys; memo }
+    elsif self.is_a? Array
+      self.reduce([]) {|memo,v    | memo           << v.deep_stringify_keys; memo }
+    else
+      self
+    end
+  end
+end
+
+
+def read_blocks( path )
+  txt = File.open( path, 'r:utf-8' ).read
+
+  blocks = []
+  buf    = String.new('')
+  txt.each_line do |line|
+    if line =~ /^[ ]*
+              ([>]{3,} |
+               [<]{3,})
+              [ ]*
+             $/x   ## three or more markers
+      blocks << buf
+      buf = String.new('')
+    else
+      buf << line
+    end
+  end
+  blocks << buf
+  blocks
+end
+
+
+def parse_json( str )
+   ## note: allow empty string; fall back to empty hash
+  if str.strip.empty?
+    {}
+  else
+    JSON.parse( str )
+  end
+end
+
+def read_test( path )
+  blocks = read_blocks( "../football.txt/#{path}" )
+
+  if blocks.size == 2
+    [blocks[0], parse_json( blocks[1] )]
+  elsif blocks.size == 3
+    ## note: returned in different order
+    ##         optional option block that comes first returned last!
+    [blocks[1], parse_json( blocks[2] ), blocks[0]]
+  else
+    puts "!! ERROR: expected two or three text blocks in >#{path}<; got #{blocks.size}"
+    exit 1
+  end
+end

data/test/test_clubs.rb

@@ -11,14 +11,14 @@ class TestClubs < MiniTest::Test
 
   Club = SportDb::Import::Club
 
-  def test_create
-    club = Club.create( name: 'Rapid Wien' )
+
+  def test_new
+    club = Club.new( name: 'Rapid Wien' )
 
     assert_equal 'Rapid Wien',   club.name
     assert_equal ['Rapid Wien'], club.names
   end
 
-
   def test_duplicates
     club = Club.new
     club.name = 'Rapid Wien'

data/test/test_conf.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_conf.rb
+
+
+require 'helper'
+
+
+class TestConf < MiniTest::Test
+
+  COUNTRY_RE = SportDb::ConfParser::COUNTRY_RE
+  TABLE_RE   = SportDb::ConfParser::TABLE_RE
+
+  def test_re
+    m=COUNTRY_RE.match( 'Manchester United › ENG' )
+    pp m
+    pp m[0]
+    assert_equal  'ENG', m[:country]
+
+    m=COUNTRY_RE.match( 'Manchester United›ENG' )
+    pp m
+    pp m[0]
+    assert_equal  'ENG', m[:country]
+
+
+    m=TABLE_RE.match( '1  Manchester City         38  32  4  2 106-27 100' )
+    pp m
+    assert_equal 'Manchester City', m[:team]
+
+    m=TABLE_RE.match( '1.  Manchester City         38  32  4  2 106:27 100' )
+    pp m
+    assert_equal 'Manchester City', m[:team]
+
+    m=TABLE_RE.match( '-  Manchester City         38  32  4  2 106 - 27 100' )
+    pp m
+    assert_equal 'Manchester City', m[:team]
+
+
+    m=TABLE_RE.match( '1.  1. FC Mainz           38  32  4  2 106-27 100  [-7]' )
+    pp m
+    assert_equal '1. FC Mainz', m[:team]
+  end
+
+
+  def test_conf
+    %w[conf/at_cup.txt
+       conf/at_reg.txt
+       conf/at_champs.txt
+       conf/eng.txt
+       conf/champs.txt
+      ].each do |path|
+         txt, exp = read_test( path )
+
+         puts "testing conf #{path}..."
+         teams = parse_conf( txt )
+
+         ## note: json always returns hash tables with string keys (not symbols),
+         ##        thus, always stringify keys before comparing!!!!
+         assert_equal exp, teams.deep_stringify_keys
+      end
+  end
+
+end   # class TestConf

data/test/test_datafile.rb

@@ -10,54 +10,45 @@ require 'helper'
 
 class TestDatafile < MiniTest::Test
 
+
   def test_exclude
-    assert Datafile.match_exclude( '.build/' )
-    assert Datafile.match_exclude( '.git/' )
+    assert Datafile::Package.match_exclude?( '.build/' )
+    assert Datafile::Package.match_exclude?( '.git/' )
+    assert Datafile::Package.exclude?( '.build/' )
+    assert Datafile::Package.exclude?( '.git/' )
 
-    assert Datafile.match_exclude( '/.build/' )
-    assert Datafile.match_exclude( '/.git/' )
 
-    assert Datafile.match_exclude( '.build/leagues.txt' )
-    assert Datafile.match_exclude( '.git/leagues.txt' )
+    assert Datafile::Package.match_exclude?( '/.build/' )
+    assert Datafile::Package.match_exclude?( '/.git/' )
 
-    assert Datafile.match_exclude( '/.build/leagues.txt' )
-    assert Datafile.match_exclude( '/.git/leagues.txt' )
-  end
+    assert Datafile::Package.match_exclude?( '.build/leagues.txt' )
+    assert Datafile::Package.match_exclude?( '.git/leagues.txt' )
 
+    assert Datafile::Package.match_exclude?( '/.build/leagues.txt' )
+    assert Datafile::Package.match_exclude?( '/.git/leagues.txt' )
+  end
 
 
   CLUBS_DIR   = '../../../openfootball/clubs'    ## source repo directory path
   LEAGUES_DIR = '../../../openfootball/leagues'
-  AUSTRIA_DIR = '../../../openfootball/austria'
-
-  def test_find
-    datafiles = Datafile.find_clubs( CLUBS_DIR )
-    pp datafiles
-
-    datafiles = Datafile.find_clubs_wiki( CLUBS_DIR )
-    pp datafiles
-
-    datafiles = Datafile.find_leagues( LEAGUES_DIR )
-    pp datafiles
-
-    datafiles = Datafile.find_conf( AUSTRIA_DIR )
-    pp datafiles
-  end
-
 
   def test_bundle
-    datafiles = Datafile.find_clubs( CLUBS_DIR )
+    datafiles = SportDb::Package.find_clubs( CLUBS_DIR )
     pp datafiles
 
-    Datafile.write_bundle( './tmp/clubs.txt',
-                           datafiles: datafiles,
-                           header: <<TXT )
+    ## todo/fix: turn into Datafile::Bundle.new  and Bundle#write/save -why? why not?
+    bundle = Datafile::Bundle.new( './tmp/clubs.txt' )
+    bundle.write <<TXT
 ##########################################
 # auto-generated all-in-one single datafile clubs.txt bundle
 #    on #{Time.now} from #{datafiles.size} datafile(s)
 TXT
+    bundle.write datafiles
+    bundle.close
+  end
 
-    datafiles = Datafile.find_leagues( LEAGUES_DIR )
+  def test_bundle_old
+    datafiles = SportDb::Package.find_leagues( LEAGUES_DIR )
     pp datafiles
 
     Datafile.write_bundle( './tmp/leagues.txt',

data/test/test_match.rb

@@ -25,12 +25,6 @@ class TestMatch < MiniTest::Test
     m.update( round: 4 )
     pp m
     assert_equal 4, m.round
-
-    m = Match.create( team1: 'Team 1',
-                      team2: 'Team 2',
-                      round: 5 )
-    pp m
-    assert_equal 5, m.round
   end  # method test_round
 
 end # class TestMatch

data/test/test_match_auto.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_match_auto.rb
+
+
+require 'helper'
+
+
+class TestMatchAuto < MiniTest::Test
+
+  def test_pt
+    txt, exp = read_test( 'match_auto/pt/br.txt' )
+
+    teams, rounds = parse_auto_conf( txt, lang: 'pt' )
+
+    assert_equal exp['teams'],  teams.deep_stringify_keys
+    assert_equal exp['rounds'], rounds.deep_stringify_keys
+  end
+
+
+  def test_de
+    txt, exp = read_test( 'match_auto/de/at.txt' )
+
+    teams, rounds = parse_auto_conf( txt, lang: 'de' )
+
+    assert_equal exp['teams'],  teams.deep_stringify_keys
+    assert_equal exp['rounds'], rounds.deep_stringify_keys
+  end
+
+  def test_es
+    %w[match_auto/es/es.txt
+       match_auto/es/mx.txt
+      ].each do |path|
+        txt, exp = read_test( path )
+
+        puts "testing match auto conf #{path}..."
+        teams, rounds = parse_auto_conf( txt, lang: 'es' )
+
+        assert_equal exp['teams'],  teams.deep_stringify_keys
+        assert_equal exp['rounds'], rounds.deep_stringify_keys
+      end
+  end
+
+
+  def test_fr
+    txt, exp = read_test( 'match_auto/fr/fr.txt' )
+
+    teams, rounds = parse_auto_conf( txt, lang: 'fr' )
+
+    assert_equal exp['teams'],  teams.deep_stringify_keys
+    assert_equal exp['rounds'], rounds.deep_stringify_keys
+  end
+
+
+  def test_en
+    %w[match_auto/eng.txt
+       match_auto/eng_ii.txt
+       match_auto/mu.txt
+      ].each do |path|
+       txt, exp = read_test( path )
+
+       puts "testing match auto conf #{path}..."
+       teams, rounds = parse_auto_conf( txt )
+
+       assert_equal exp['teams'],  teams.deep_stringify_keys
+       assert_equal exp['rounds'], rounds.deep_stringify_keys
+    end
+  end   # method test_parse
+
+end  # class TestMatchAuto

data/test/test_match_auto_champs.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_match_auto_champs.rb
+
+
+require 'helper'
+
+
+class TestMatchAutoChamps < MiniTest::Test
+
+  def test_champs_group
+    txt, exp = read_test( 'match_auto/champs_group.txt')
+
+    teams, rounds, groups, round_defs, group_defs = parse_auto_conf( txt, lang: 'en' )
+
+     assert_equal exp['teams'],  teams.deep_stringify_keys
+     assert_equal exp['rounds'], rounds.deep_stringify_keys
+     assert_equal exp['groups'], groups.deep_stringify_keys
+
+    puts "teams:"
+    pp teams
+    puts "rounds:"
+    pp rounds
+    puts "groups:"
+    pp groups
+    puts "round defs:"
+    pp round_defs
+    puts "group defs:"
+    pp group_defs
+  end
+
+  def test_champs_finals
+    txt, exp = read_test( 'match_auto/champs_finals.txt')
+
+    teams, rounds = parse_auto_conf( txt, lang: 'en' )
+
+    assert_equal exp['teams'],  teams.deep_stringify_keys
+    assert_equal exp['rounds'], rounds.deep_stringify_keys
+
+    pp teams
+    pp rounds
+  end
+end   # class TestMatchAutChamps

data/test/test_match_auto_euro.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_match_auto_euro.rb
+
+
+require 'helper'
+
+
+class TestMatchAutoEuro < MiniTest::Test
+
+  def test_euro_2016
+    txt, exp = read_test( 'match_auto/euro_2016.txt')
+
+    teams, rounds, groups, round_defs, group_defs = parse_auto_conf( txt, lang: 'en' )
+
+     # puts JSON.pretty_generate( { teams: teams,
+     #                             rounds: rounds,
+     #                             groups: groups } )
+
+     assert_equal exp['teams'],  teams.deep_stringify_keys
+     assert_equal exp['rounds'], rounds.deep_stringify_keys
+     assert_equal exp['groups'], groups.deep_stringify_keys
+
+    puts "teams:"
+    pp teams
+    puts "rounds:"
+    pp rounds
+    puts "groups:"
+    pp groups
+    puts "round defs:"
+    pp round_defs
+    puts "group defs:"
+    pp group_defs
+  end
+end   # class TestMatchAutoEuro

data/test/test_match_auto_worldcup.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_match_auto_worldcup.rb
+
+
+require 'helper'
+
+
+class TestMatchAutoWorldCup < MiniTest::Test
+
+  def test_2018
+    txt, exp = read_test( 'match_auto/worldcup_2018.txt')
+
+    start = Date.new( 2018, 1, 1 )
+
+    teams, rounds, groups, round_defs, group_defs = parse_auto_conf( txt, lang: 'en', start: start )
+
+     # puts JSON.pretty_generate( { teams: teams,
+     #                             rounds: rounds,
+     #                             groups: groups } )
+
+     assert_equal exp['teams'],  teams.deep_stringify_keys
+     assert_equal exp['groups'], groups.deep_stringify_keys
+
+    puts "teams:"
+    pp teams
+    puts "rounds:"
+    pp rounds
+    puts "groups:"
+    pp groups
+    puts "round defs:"
+    pp round_defs
+    puts "group defs:"
+    pp group_defs
+  end
+
+  def test_2018_finals
+    txt, exp = read_test( 'match_auto/worldcup_2018_finals.txt')
+
+    start = Date.new( 2018, 1, 1 )
+
+    teams, rounds, groups, round_defs, group_defs = parse_auto_conf( txt, lang: 'en', start: start )
+
+     assert_equal exp['teams'],  teams.deep_stringify_keys
+     assert_equal exp['rounds'], rounds.deep_stringify_keys
+
+    puts "teams:"
+    pp teams
+    puts "rounds:"
+    pp rounds
+    puts "groups:"
+    pp groups
+    puts "round defs:"
+    pp round_defs
+    puts "group defs:"
+    pp group_defs
+  end
+
+end   # class TestMatchAutoWorldCup