sportdb-formats 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bd2657cda87fd1024bec068f79453d73b0bbac5
-  data.tar.gz: 7c35301f832b66bf691c9d1964de00c9a9b2371d
+  metadata.gz: 1188cc0edf55cd83ccdee10638662c64b302a44e
+  data.tar.gz: 06b6b09902513298357a9f47deef83cdf6962b9e
 SHA512:
-  metadata.gz: 90ef6ad29934fc9bb692045d9f5e2a447a2dcaf80ab8ca0a3e1b50ae34e95bae7a139e88ef454314c0a26bc978784abb6abd117bf1961e71c65a95046d21efe1
-  data.tar.gz: 73e55608b287d974d40c4529c3f104496acde866dc3908509adcee6ed8a40dc0f10f8e48f193cd6184ef29c31bdfa3ebd9eb38a38c85924dde207cc0433ea318
+  metadata.gz: 337fdb0f298625e847e40a29e47f2ee2e6c638e1ed8a4e72e340008b16de6d10ea5907923530594c0e4739de1a477dd4fe847f10d062372a64c5e4103ef3c06b
+  data.tar.gz: 72c0281e3f32a74750f8eb494aafd26b25a3c5f497842f389ea714bcf430f41451346b9aec7aac005dba7b8e8ab283945aca58a49ef7ecc8df6f8116d87b6370

data/Manifest.txt

@@ -3,31 +3,51 @@ Manifest.txt
 README.md
 Rakefile
 lib/sportdb/formats.rb
+lib/sportdb/formats/config.rb
 lib/sportdb/formats/datafile.rb
+lib/sportdb/formats/datafile_package.rb
 lib/sportdb/formats/goals.rb
+lib/sportdb/formats/match/conf_parser.rb
+lib/sportdb/formats/match/mapper.rb
+lib/sportdb/formats/match/mapper_teams.rb
+lib/sportdb/formats/match/match_parser.rb
+lib/sportdb/formats/match/match_parser_auto_conf.rb
+lib/sportdb/formats/name_helper.rb
 lib/sportdb/formats/outline_reader.rb
 lib/sportdb/formats/package.rb
-lib/sportdb/formats/scores.rb
+lib/sportdb/formats/parser_helper.rb
+lib/sportdb/formats/score/score_formats.rb
+lib/sportdb/formats/score/score_parser.rb
 lib/sportdb/formats/season_utils.rb
-lib/sportdb/formats/structs/club.rb
 lib/sportdb/formats/structs/country.rb
+lib/sportdb/formats/structs/group.rb
 lib/sportdb/formats/structs/league.rb
 lib/sportdb/formats/structs/match.rb
 lib/sportdb/formats/structs/matchlist.rb
 lib/sportdb/formats/structs/round.rb
 lib/sportdb/formats/structs/season.rb
 lib/sportdb/formats/structs/standings.rb
+lib/sportdb/formats/structs/team.rb
 lib/sportdb/formats/structs/team_usage.rb
 lib/sportdb/formats/version.rb
 test/helper.rb
-test/test_club_helpers.rb
 test/test_clubs.rb
+test/test_conf.rb
 test/test_csv_reader.rb
 test/test_datafile.rb
-test/test_datafile_match.rb
 test/test_goals.rb
 test/test_match.rb
+test/test_match_auto.rb
+test/test_match_auto_champs.rb
+test/test_match_auto_euro.rb
+test/test_match_auto_worldcup.rb
+test/test_match_champs.rb
+test/test_match_eng.rb
+test/test_match_euro.rb
+test/test_match_worldcup.rb
+test/test_name_helper.rb
 test/test_outline_reader.rb
 test/test_package.rb
+test/test_package_match.rb
 test/test_scores.rb
 test/test_season.rb

data/Rakefile

@@ -20,10 +20,10 @@ Hoe.spec 'sportdb-formats' do
   self.licenses = ['Public Domain']
 
   self.extra_deps = [
-    ['alphabets',     '>= 0.1.3'],
-    ['date-formats',  '>= 0.2.4'],
+    ['alphabets',     '>= 1.0.0'],
+    ['date-formats',  '>= 1.0.0'],
     ['csvreader',     '>= 1.2.4'],
-    ['sportdb-langs', '>= 0.0.1'],
+    ['sportdb-langs', '>= 0.1.0'],
 
     ['rubyzip',       '>= 1.2.4' ],
   ]

data/lib/sportdb/formats.rb

@@ -23,29 +23,52 @@ end
 require 'sportdb/langs'
 
 
+## todo/fix: move shortcut to sportdb/langs!!!
+module SportDb
+  Logging = LogUtils::Logging     ## logging machinery shortcut; use LogUtils for now
+end
+
+
+
 ###
 # our own code
 require 'sportdb/formats/version' # let version always go first
+
+require 'sportdb/formats/config'  # let "global" config "framework" go next - why? why not?
+
 require 'sportdb/formats/outline_reader'
 require 'sportdb/formats/datafile'
+require 'sportdb/formats/datafile_package'
 require 'sportdb/formats/package'
 require 'sportdb/formats/season_utils'
 
+require 'sportdb/formats/name_helper'
+require 'sportdb/formats/parser_helper'
+
 require 'sportdb/formats/structs/country'
 require 'sportdb/formats/structs/season'
 require 'sportdb/formats/structs/league'
-require 'sportdb/formats/structs/club'
+require 'sportdb/formats/structs/team'
 require 'sportdb/formats/structs/round'
+require 'sportdb/formats/structs/group'
 require 'sportdb/formats/structs/match'
 require 'sportdb/formats/structs/matchlist'
 require 'sportdb/formats/structs/standings'
 require 'sportdb/formats/structs/team_usage'
 
 
-require 'sportdb/formats/scores'
+require 'sportdb/formats/score/score_formats'
+require 'sportdb/formats/score/score_parser'
 require 'sportdb/formats/goals'
 
 
+require 'sportdb/formats/match/mapper'
+require 'sportdb/formats/match/mapper_teams'
+require 'sportdb/formats/match/match_parser'
+require 'sportdb/formats/match/match_parser_auto_conf'
+require 'sportdb/formats/match/conf_parser'
+
+
 ## let's put test configuration in its own namespace / module
 module SportDb
 class Test    ## todo/check: works with module too? use a module - why? why not?

data/lib/sportdb/formats/config.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module SportDb
+  module Import
+
+class Configuration
+  ##
+  ##  todo: allow configure of countries_dir like clubs_dir
+  ##         "fallback" and use a default built-in world/countries.txt
+
+  attr_accessor   :catalog
+
+  attr_reader   :lang
+  def lang=(value)
+    ## check/todo: always use to_sym - why? needed?
+    DateFormats.lang  = value
+    ScoreFormats.lang = value
+    SportDb.lang.lang = value
+
+    ## todo/fix:  change SportDb.lang to SportDb.parser.lang or lang_parser or utils or someting !!!!
+    ##   use Sport.lang only as a read-only shortcut a la catalog for config.lang!!!!
+  end
+
+end # class Configuration
+
+
+## lets you use
+##   SportDb::Import.configure do |config|
+##      config.lang = 'it'
+##   end
+
+def self.configure()  yield( config ); end
+
+def self.config()  @config ||= Configuration.new;  end
+
+##  e.g. use config.catalog  -- keep Import.catalog as a shortcut (for "read-only" access)
+def self.catalog() config.catalog;  end
+
+end   # module Import
+end   # module SportDb

data/lib/sportdb/formats/datafile.rb

@@ -3,77 +3,57 @@
 
 module Datafile      # note: keep Datafile in its own top-level module/namespace for now - 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}/**/{*,.*}.txt" )
-     pp candidates
-     candidates.each do |candidate|
-       datafiles << candidate    if pattern.match( candidate )
-     end
-
-     pp datafiles
-     datafiles
+  def self.read( path )   ## todo/check: use as a shortcut helper - why? why not?
+     ## note: always assume utf-8 for now!!!
+     File.open( path, 'r:utf-8') {|f| f.read }
   end
 
 
-  CLUBS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-                       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.txt
-                       clubs\.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\.wiki\.txt$
-                       }x
-
-  CLUB_PROPS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-                       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.props.txt
-                      clubs\.props\.txt$
-                   }x
-
-  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.match_clubs( path )       CLUBS_RE.match( path ); end
-  def self.match_clubs_wiki( path )  CLUBS_WIKI_RE.match( path ); end
-  def self.match_club_props( path, pattern: CLUB_PROPS_RE ) pattern.match( path ); end
-
-
-  LEAGUES_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-                        (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.wiki.txt
-                     leagues\.txt$
-                    }x
-
-  def self.find_leagues( path, pattern: LEAGUES_RE )  find( path, pattern ); end
-  def self.match_leagues( path )  LEAGUES_RE.match( path ); end
-
-
-  CONF_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
-                     \.conf\.txt$
-                 }x
+  ########################
+  ## todo/fix: turn into Datafile::Bundle.new  and Bundle#write/save -why? why not?
+  class Bundle
+    def initialize( path )
+      @path = path
+      @buf  = String.new('')
+    end
 
-  def self.find_conf( path, pattern: CONF_RE )  find( path, pattern ); end
-  def self.match_conf( path )  CONF_RE.match( path ); end
+    def <<(value)
+       if value.is_a?( Array )  ## assume array of datafiles (file paths)
+         datafiles = value
+         datafiles.each do |datafile|
+           text = Datafile.read( datafile )
+           ## todo/fix/check:  move  sub __END__ to Datafile.read and turn it always on  -  why? why not?
+           text = text.sub( /__END__.*/m, '' )    ## note: add/allow support for __END__; use m-multiline flag
+           @buf << text
+           @buf << "\n\n"
+          end
+        else ## assume string (e.g. header, comments, etc.)
+          text = value
+          @buf << text
+          @buf << "\n\n"
+        end
+    end
+    alias_method :write, :<<
 
+    ## todo/fix/check: write only on close? or write on every write and use close for close?
+    def close
+      File.open( @path, 'w:utf-8' ) do |f|
+        f.write @buf
+      end
+    end
+  end  # class Bundle
 
 
   def self.write_bundle( path, datafiles:, header: nil )
-    File.open( path, 'w:utf-8') do |fout|
-      if header
-        fout.write( header )
-        fout.write( "\n\n" )
-      end
-      datafiles.each do |datafile|
-        File.open( datafile, 'r:utf-8') do |fin|
-          text = fin.read
-          text = text.sub( /__END__.*/m, '' )    ## note: add/allow support for __END__; use m-multiline flag
-          fout.write( text )
-        end
-      end
+    bundle = Bundle.new( path )
+    bundle.write( header )   if header
+    datafiles.each do |datafile|
+      text = read( datafile )
+      ## todo/fix/check:  move  sub __END__ to Datafile.read and turn it always on  -  why? why not?
+      text = text.sub( /__END__.*/m, '' )    ## note: add/allow support for __END__; use m-multiline flag
+      bundle.write( text )
     end
+    bundle.close
   end
 
 end # module Datafile

data/lib/sportdb/formats/datafile_package.rb

@@ -0,0 +1,160 @@
+
+module Datafile      # note: keep Datafile in its own top-level module/namespace for now - why? why not?
+
+
+class Package    ## use a shared base class for DirPackage, ZipPackage, etc.
+  ## exclude pattern
+  ##  for now exclude all files in directories starting with a dot (e.g. .git/ or .github/ or .build/ etc.)
+  ##  todo/check: rename to EXCLUDE_DOT_DIRS_RE - why? why not?
+  EXCLUDE_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+                        \.[a-zA-Z0-9_-]+  ## (almost) any name BUT must start with dot e.g.  .git, .build, etc.
+                        /
+                     }x
+  def self.match_exclude( path, pattern: EXCLUDE_RE ) pattern.match( path ); end
+  class << self    ## check if module << self is possible? (like class << self)  - check if there's a better / more idomatic way??
+    alias_method :match_exclude?, :match_exclude
+    alias_method :exclude?,       :match_exclude
+  end
+end  # class Package
+
+
+class DirPackage < Package    ## todo/check: find a better name e.g. UnzippedPackage, FilesystemPackage, etc. - why? why not?
+class Entry
+  def initialize( pack, path )
+    @pack = pack  ## parent package
+    @path = path
+    ## note: calculate name (cut-off pack.path!!!), that is, make path relative (to pack)
+    ##   e.g.
+    ##    ../../../openfootball/austria/2011-12/1-bundesliga-i.txt
+    ##      becomes =>                  2011-12/1-bundesliga-i.txt
+    @name = path[ pack.path.length+1..-1 ]
+  end
+  def name()  @name; end
+  def read()  File.open( @path, 'r:utf-8' ).read; end
+end  # class DirPackage::Entry
+
+
+  attr_reader :name, :path
+
+  def initialize( path )
+    ## todo/fix:  expand_path ?! - why? why not? if you pass in ./ basename will be . and NOT directory name, for example!!!
+    @path = path   ## rename to root_path or base_path or somehting - why? why not?
+
+    basename = File.basename( path )   ## note: ALWAYS keeps "extension"-like name if present (e.g. ./austria.zip => austria.zip)
+    @name = basename
+  end
+
+  def each( pattern:,  extension: 'txt' )    ## todo/check: rename to glob or something - why? why not?
+    ##   use just .* for extension or remove and check if File.file? and skip File.directory? - why? why not?
+    ## note: incl. files starting with dot (.)) as candidates (normally excluded with just *)
+    Dir.glob( "#{@path}/**/{*,.*}.#{extension}" ).each do |path|
+      ## todo/fix: (auto) skip and check for directories
+      if EXCLUDE_RE.match( path )
+        ## note: skip dot dirs (e.g. .build/, .git/, etc.)
+      elsif pattern.match( path )
+        yield( Entry.new( self, path ))
+      else
+        ## puts "  skipping >#{path}<"
+      end
+    end
+  end
+
+  def find( name )
+    Entry.new( self, "#{@path}/#{name}" )
+  end
+end  # class DirPackage
+
+
+## helper wrapper for datafiles in zips
+class ZipPackage < Package
+class Entry
+  def initialize( pack, entry )
+    @pack  = pack
+    @entry = entry
+  end
+
+  def name()  @entry.name; end
+  def read
+    txt = @entry.get_input_stream.read
+    ##  puts "** encoding: #{txt.encoding}"  #=> encoding: ASCII-8BIT
+    txt = txt.force_encoding( Encoding::UTF_8 )
+    txt
+  end
+end # class ZipPackage::Entry
+
+  attr_reader :name, :path
+
+  def initialize( path )
+    @path = path
+
+    extname  = File.extname( path )    ## todo/check: double check if extension is .zip - why? why not?
+    basename = File.basename( path, extname )
+    @name = basename
+  end
+
+  def each( pattern: )
+    Zip::File.open( @path ) do |zipfile|
+      zipfile.each do |entry|
+        if entry.directory?
+          next ## skip
+        elsif entry.file?
+          if EXCLUDE_RE.match( entry.name )
+            ## note: skip dot dirs (e.g. .build/, .git/, etc.)
+          elsif pattern.match( entry.name )
+            yield( Entry.new( self, entry ) )   # wrap entry in uniform access interface / api
+          else
+            ## puts "  skipping >#{entry.name}<"
+          end
+        else
+          puts "** !!! ERROR !!! #{entry.name} is unknown zip file type in >#{@path}<, sorry"
+          exit 1
+        end
+      end
+    end
+  end
+
+  def find( name )
+     entries = match_entry( name )
+     if entries.empty?
+       puts "** !!! ERROR !!! zip entry >#{name}< not found in >#{@path}<; sorry"
+       exit 1
+     elsif entries.size > 1
+       puts "** !!! ERROR !!! ambigious zip entry >#{name}<; found #{entries.size} entries in >#{@path}<:"
+       pp entries
+       exit 1
+     else
+       Entry.new( self, entries[0] )    # wrap entry in uniform access interface / api
+     end
+  end
+
+private
+  def match_entry( name )
+    ## todo/fix:  use Zip::File.glob or find_entry or something better/faster?  why? why not?
+
+    pattern = %r{ #{Regexp.escape( name )}    ## match string if ends with name
+                   $
+                }x
+
+    entries = []
+    Zip::File.open( @path ) do |zipfile|
+      zipfile.each do |entry|
+        if entry.directory?
+          next ## skip
+        elsif entry.file?
+          if EXCLUDE_RE.match( entry.name )
+            ## note: skip dot dirs (e.g. .build/, .git/, etc.)
+          elsif pattern.match( entry.name )
+            entries << entry
+          else
+            ## no match; skip too
+          end
+        else
+          puts "** !!! ERROR !!! #{entry.name} is unknown zip file type in >#{@path}<, sorry"
+          exit 1
+        end
+      end
+    end
+    entries
+  end
+end  # class ZipPackage
+end  # module Datafile