sportdb-catalogs 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0e5965c765923646871f9c4b5544ea651c476614
-  data.tar.gz: 6387ea829d97c82a6aafada09f3caf7fa193a530
+SHA256:
+  metadata.gz: 5912ceb7d640f68512000d72620ff285eb8aaba12758fb6eda9db0f2bba6c3c8
+  data.tar.gz: 6a1022811416867e7ae9fc7bb4519a4fa6cd42cc6ad12a32b1675a26a3d51ab6
 SHA512:
-  metadata.gz: d36f04f85b69b4163c7262b50e690679a8133f409b3712e550e4cb4aaad74c7dbba9760e3d23718ff3e13274fb7d9a9bdaa2e2c1e5c052a43e9d461fb8db94b9
-  data.tar.gz: aa7666f61f3ed5964e1eb29cba7cf956510d98f63e9ea3c5192a9e7321a79ee5f185e2768208adfe05784b55d2e300a8bd82433ba8142678937652016f60ae42
+  metadata.gz: 33efb321b2fa039a836f037acd4c57367bea8f2f5d9faeffa77b5eec047590feaa405eb230c15cf073c7e42a6818f60d73914d4d0bd576b7f5baec1c85686722
+  data.tar.gz: 3d2862394fad3aa68e0c970e9b6e74b6ed7f2a34eb04a28e8578ff83ce2379651eb146580593d7b13f75705a7ee55b643e73cce2aee8725391e2fea2e787b684

data/CHANGELOG.md

@@ -1,3 +1,4 @@
+### 1.2.0
 ### 0.0.1 / 2019-06-29
 
 * Everything is new. First release.

data/Manifest.txt

@@ -1,17 +1,15 @@
 CHANGELOG.md
 Manifest.txt
-NOTES.md
 README.md
 Rakefile
 lib/sportdb/catalogs.rb
-lib/sportdb/catalogs/catalog.rb
-lib/sportdb/catalogs/config.rb
+lib/sportdb/catalogs/base.rb
+lib/sportdb/catalogs/city.rb
+lib/sportdb/catalogs/club.rb
+lib/sportdb/catalogs/country.rb
+lib/sportdb/catalogs/event_info.rb
+lib/sportdb/catalogs/ground.rb
+lib/sportdb/catalogs/league.rb
+lib/sportdb/catalogs/national_team.rb
+lib/sportdb/catalogs/player.rb
 lib/sportdb/catalogs/version.rb
-lib/sportdb/catalogs/wiki_index.rb
-test/helper.rb
-test/test_clubs.rb
-test/test_clubs_history.rb
-test/test_countries.rb
-test/test_leagues.rb
-test/test_national_teams.rb
-test/test_wiki_index.rb

data/README.md

@@ -5,12 +5,11 @@
 * bugs  :: [github.com/sportdb/sport.db/issues](https://github.com/sportdb/sport.db/issues)
 * gem   :: [rubygems.org/gems/sportdb-catalogs](https://rubygems.org/gems/sportdb-catalogs)
 * rdoc  :: [rubydoc.info/gems/sportdb-catalogs](http://rubydoc.info/gems/sportdb-catalogs)
-* forum :: [opensport](http://groups.google.com/group/opensport)
 
 
 
 
-## Usage
+## Usage  
 
 Let's use the [/clubs datasets](https://github.com/openfootball/clubs)
 (1500+ football clubs from around the world)
@@ -74,55 +73,6 @@ m[0].name; m[0].city; m[0].country
 # ...
 ```
 
-Let's print all names that have duplicate (more than one) matching club:
-
-``` ruby
-CLUBS.mappings.each do |name, clubs|
-  if clubs.size > 1
-    puts "#{clubs.size} matching clubs for `#{name}`:"
-    clubs.each do |club|
-      puts "  - #{club.name}, #{club.city}, #{club.country.name} (#{club.country.key})"
-    end
-    puts
-  end
-end
-```
-
-resulting in:
-
-```
-2 matching clubs for `valencia`:
-  - Valencia FC, Léogâne, Haiti (ht)
-  - Valencia CF, Valencia, Spain (es)
-
-2 matching clubs for `apollon`:
-  - Apollon Limassol FC, , Cyprus (cy)
-  - Apollon Smyrnis FC, Athens, Greece (gr)
-
-3 matching clubs for `arsenal`:
-  - Arsenal FC, London, England (eng)
-  - Arsenal Tula, Tula, Russia (ru)
-  - Arsenal de Sarandí, Sarandí, Argentina (ar)
-
-2 matching clubs for `liverpool`:
-  - Liverpool FC, Liverpool, England (eng)
-  - Liverpool Montevideo, Montevideo, Uruguay (uy)
-
-2 matching clubs for `barcelona`:
-  - FC Barcelona, Barcelona, Spain (es)
-  - Barcelona Guayaquil, Guayaquil, Ecuador (ec)
-
-3 matching clubs for `nacional`:
-  - CD Nacional Madeira, Funchal, Portugal (pt)
-  - Club Nacional, Asunción, Paraguay (py)
-  - Nacional de Montevideo, Montevideo, Uruguay (uy)
-
-2 matching clubs for `sanjose`:
-  - San Jose Earthquakes, San Jose, United States (us)
-  - Club Deportivo San José, Oruro, Bolivia (bo)
-
-...
-```
 
 That's it.
 
@@ -136,6 +86,5 @@ Use it as you please with no restrictions whatsoever.
 
 ## Questions? Comments?
 
-Send them along to the
-[Open Sports & Friends Forum/Mailing List](http://groups.google.com/group/opensport).
-Thanks!
+Yes, you can. More than welcome.
+See [Help & Support »](https://github.com/openfootball/help)

data/Rakefile

@@ -8,10 +8,10 @@ Hoe.spec 'sportdb-catalogs' do
   self.summary = "sportdb-catalogs - sport.db (search 'n' find) catalogs for countries, leagues, clubs, national teams, and more"
   self.description = summary
 
-  self.urls = ['https://github.com/sportdb/sport.db']
+  self.urls = { home: 'https://github.com/sportdb/sport.db' }
 
   self.author = 'Gerald Bauer'
-  self.email  = 'opensport@googlegroups.com'
+  self.email  = 'gerald.bauer@gmail.com'
 
   # switch extension to .markdown for gihub formatting
   self.readme_file  = 'README.md'
@@ -20,11 +20,9 @@ Hoe.spec 'sportdb-catalogs' do
   self.licenses = ['Public Domain']
 
   self.extra_deps = [
-    ['sportdb-formats',    '>= 1.1.3'],
-    ## dataset libs / gems
-    ['fifa',               '>= 2020.5.18'],    ## for (builtin/default) countries
-    ['footballdb-leagues', '>= 2020.7.7'],    ## for (builtin/default) leagues & cups
-    ['footballdb-clubs',   '>= 2020.7.7'],     ## for (builtin/default) clubs
+    ['sportdb-formats'],
+    ['sqlite3'],          ## add sqlite for "metal" use (no activerecord etc.)
+    ['footballdb-data']   ## add builtin default db  
   ]
 
   self.spec_extras = {

data/lib/sportdb/catalogs/base.rb

@@ -0,0 +1,154 @@
+module CatalogDb
+module Metal
+
+##
+#   change BaseRecord to Record again
+##    AND  PlayerRecord   to PlayerBase or PlayerDatabase ?
+##    AND  (Catalog)Record to CatalogBase or CatalogDatabase  - why? why not?
+
+
+class BaseRecord   ## or just use Base or such - why? why not?
+ 
+      def self.execute( sql ) 
+         ## puts "==> sql query [#{self.name}]"
+         ## puts sql
+         database.execute( sql ) 
+      end
+ 
+      def self.tablename=(name) @tablename = name; end
+      def self.tablename() @tablename; end
+ 
+      def self.columns=(names) 
+         ## note: auto-add table name to qualify
+         @columns = names.map {|name| "#{self.tablename}.#{name}" } 
+         @columns
+      end
+      def self.columns() @columns; end
+ 
+      def self.count
+         sql = "SELECT count(*) FROM #{self.tablename}"
+         rows = execute( sql )
+         rows[0][0]    # e.g. returns [[241]]
+      end
+ 
+  ## helpers from country - use a helper module for includes (share with clubs etc.) - why? why not?
+  # include NameHelper
+  extend SportDb::NameHelper
+  ## incl. strip_year( name )
+  ##       has_year?( name)
+  ##       strip_lang( name )
+  ##       normalize( name )
+
+   def self._to_bool( value )
+     if value == 0
+       false
+     elsif value == 1
+       true
+     else
+       ## use TypeError - why? why not? or if exits ValueError?
+       raise ArgumentError, "0 or 1 expected for bool in sqlite; got #{value}"
+     end
+   end             
+
+
+   ##
+   #  todo/check - make _country available to all dbs/records? why? why not?
+
+   def self._country( country )
+      if country.is_a?( String ) || country.is_a?( Symbol )
+        # note: query/find country via catalog db
+        rec = Country.find_by_code( country )
+        rec = Country.find_by_name( country )  if rec.nil?  
+        if rec.nil?
+          puts "** !!! ERROR !!! - unknown country >#{country}< - no match found, sorry - add to world/countries.txt in config"
+          exit 1
+        end
+        rec
+      else
+        country  ## (re)use country struct - no need to run lookup again
+      end
+   end
+end  # class BaseRecord
+
+
+class PlayerRecord  < BaseRecord
+      def self.database
+         ### note: only one database for all derived records/tables!!!
+         ##   thus MUST use @@ and not @!!!!!
+         ##  todo - change later to built-in database
+         ##   or download on request???
+         @@db ||= SQLite3::Database.new( './players.db' ) 
+         @@db
+      end
+ 
+      def self.database=(path)
+         puts "==> setting (internal) players db to: >#{path}<"
+         @@db = SQLite3::Database.new( path )
+         pp @@db
+         @@db
+      end 
+end   # class PlayerRecord
+
+
+
+##############
+### todo (fix) / rename to CatalogRecord - why? why not?
+class Record  < BaseRecord    
+    ## add db alias why? why not?
+     def self.database
+        ### note: only one database for all derived records/tables!!!
+        ##   thus MUST use @@ and not @!!!!!
+        ##
+        ##  default to built-in via footballdb-data gem for now!!!
+        @@db ||= SQLite3::Database.new( './catalog.db' ) 
+        @@db
+     end
+
+     def self.database=(path)
+        puts "==> setting (internal) catalog db to: >#{path}<"
+        @@db = SQLite3::Database.new( path )
+        pp @@db
+        @@db
+     end
+
+###########
+### share common methods for reuse
+
+def self._to_league( key )
+   League._record( key )
+end
+
+def self._to_country( key ) 
+   # note: use cached record or (faster) key lookup on fallback
+   Country._record( key )   
+end
+
+def self._to_city( key )   ### rename; use find_by_key / find_by( key: )
+   # note: use cached record or (faster) key lookup on fallback
+   City._record( key )   
+end
+
+
+def self._city( city )
+   if city.is_a?( String ) || city.is_a?( Symbol )
+     # note: query/find country via catalog db
+     recs = City.match_by( name: city )
+     if recs.empty?
+       puts "** !!! ERROR !!! - unknown city >#{city}< - no match found, sorry"
+       exit 1
+     elsif recs.size > 1
+       puts "** !!! ERROR !!! - city >#{city}< - too many matches found (#{recs.size}), sorry"
+       pp recs
+       exit 1
+     end
+     recs[0]
+   else
+     city  ## (re)use city struct - no need to run lookup again
+   end
+end
+end  # class Record
+
+
+
+end # module Metal
+end # module CatalogDb

data/lib/sportdb/catalogs/city.rb

@@ -0,0 +1,78 @@
+module CatalogDb
+module Metal
+
+class City < Record
+    self.tablename = 'cities'
+
+    self.columns = ['key', 
+                    'name', 
+                    'alt_names', 
+                    'country_key',  #3
+                  ]
+
+    def self.cache() @cache ||= Hash.new; end
+
+    def self._record( key )  ## use _record! as name - why? why not?
+        if (rec = cache[ key ])
+          rec   ## return cached
+        else  ## query and cache and return
+        rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM cities 
+      WHERE cities.key = '#{key}' 
+SQL
+ 
+          ## todo/fix: also assert for rows == 1 AND NOT MULTIPLE records - why? why not?
+          if rows.empty? 
+            raise ArgumentError, "city record with key #{key} not found" 
+          else 
+            _build_city( rows[0] )
+          end
+        end
+    end
+
+    def self._build_city( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        cache[ row[0] ] ||= begin 
+                                city = Sports::City.new(
+                                         key:     row[0],
+                                         name:    row[1],
+                                         ## fix - add alt_names here too 
+                                         country: _to_country( row[3] ) 
+                                       )
+                                city
+                              end                                                    
+    end                
+ 
+
+    def self._find_by_name( name )
+        rows = execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM cities 
+        INNER JOIN city_names ON cities.key  = city_names.key
+        WHERE city_names.name = '#{name}' 
+SQL
+       rows 
+    end
+
+
+  ## match - always returns an array (with one or more matches)
+  def self.match_by( name:  )
+    ## note: allow passing in of country key too (auto-counvert)
+    ##       and country struct too
+    ##     - country assumes / allows the country key or fifa code for now
+
+    ##  note: ALWAYS unaccent 1st in normalize  
+    ##            - add upstream - why? why not?
+    # note: returns empty array (e.g. []) if no match and NOT nil
+    nameq = normalize( unaccent(name) )
+
+    rows = _find_by_name( nameq )
+           
+    rows.map {|row| _build_city( row )}
+  end
+end  # class City
+
+end  # module Metal
+end  # module CatalogDb
+

data/lib/sportdb/catalogs/club.rb

@@ -0,0 +1,104 @@
+module CatalogDb
+module Metal
+
+class Club < Record
+    self.tablename = 'clubs'
+
+    self.columns = ['key', 
+                    'name', 
+                    'code', 
+                    'city',   #3 
+                    'district', #4
+                    'country_key',  #5
+                  ]
+
+    def self._build_club( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin 
+                                club = Sports::Club.new(
+                                         key:  row[0],
+                                         name: row[1],
+                                         code: row[2] )
+
+                                club.city     = row[3]  ## might be nil
+                                club.district = row[4]  
+                                ## note: country for now NOT supported 
+                                ##       via keyword on init!!!
+                                ##    fix - why? why not?
+                                club.country = row[5] ? _to_country( row[5] ) : nil
+                                club 
+                              end   
+                                                   
+    end                
+ 
+
+    def self._find_by_name( name )
+        rows = execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM clubs 
+        INNER JOIN club_names ON clubs.key  = club_names.key
+        WHERE club_names.name = '#{name}' 
+SQL
+       rows 
+    end
+
+
+    def self._find_by_name_and_country( name, country_or_countries )
+          sql = <<-SQL
+      SELECT #{self.columns.join(', ')}
+      FROM clubs 
+      INNER JOIN club_names ON clubs.key  = club_names.key
+      WHERE club_names.name = '#{name}' AND 
+SQL
+       
+        ## check if single country or n countries         
+         if country_or_countries.is_a?(Array) 
+          countries = country_or_countries
+          ## add (single) quotes and join with comma 
+          ##       e.g.  'at','de'  
+          country_list = countries.map {|country| %Q<'#{country}'>}.join(',')
+          sql <<  "clubs.country_key in (#{country_list})\n"
+         else ## assume string/symbol (single country key)
+          country = country_or_countries
+          sql <<  "clubs.country_key = '#{country}'\n"
+         end
+          
+      rows = execute( sql )
+      rows 
+    end
+
+
+
+  ## match - always returns an array (with one or more matches)
+  def self.match_by( name:, 
+                     country: nil )
+    ## note: allow passing in of country key too (auto-counvert)
+    ##       and country struct too
+    ##     - country assumes / allows the country key or fifa code for now
+
+    ##  note: ALWAYS unaccent 1st in normalize  
+    ##            - add upstream - why? why not?
+    # note: returns empty array (e.g. []) if no match and NOT nil
+    nameq = normalize( unaccent(name) )
+
+    ## todo - check for empty array passed in?
+    rows = if country    
+              ### always wrap country in array
+              countries =  country.is_a?(Array) ? country : [country]
+              country_keys = countries.map {|country| _country( country ).key }
+              ## unwrap key if array with single country key
+              countryq = country_keys.size == 1 ? country_keys[0] : country_keys
+
+              _find_by_name_and_country( nameq, countryq )
+           else
+              _find_by_name( nameq )
+           end
+    
+    rows.map {|row| _build_club( row )}
+  end
+end  # class Club
+
+end  # module Metal
+end  # module CatalogDb
+

data/lib/sportdb/catalogs/country.rb

@@ -0,0 +1,110 @@
+
+module CatalogDb
+module Metal
+
+class Country  < Record
+     self.tablename = 'countries'
+
+     self.columns = ['key', 
+                     'name', 
+                     'code',
+                     'tags',
+                     'alt_names']
+
+     def self.cache() @cache ||= Hash.new; end
+
+
+     def self._record( key )  ## use _record! as name - why? why not?
+        if (rec = cache[ key ])
+          rec   ## return cached
+        else  ## query and cache and return
+        rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM countries 
+      WHERE countries.key = '#{key}' 
+SQL
+ 
+          ## todo/fix: also assert for rows == 1 AND NOT MULTIPLE records - why? why not?
+          if rows.empty? 
+            raise ArgumentError, "country record with key #{key} not found" 
+          else 
+            _build_country( rows[0] )
+          end
+        end
+     end
+
+  
+     def self._build_country( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        cache[ row[0] ] ||= begin
+                              ## note: split tags & alt names (PLUS remove leading//trailing spaces)
+                              tags      = row[3].split(',').map {|tag| tag.strip }
+                              alt_names = row[4].split('|').map {|alt_name| alt_name.strip } 
+                              country = Sports::Country.new(
+                                 key: row[0],
+                                 name: row[1],
+                                 code: row[2],
+                                 tags: tags   
+                              )
+                              country.alt_names = alt_names
+                              country
+                            end
+     end                
+                     
+
+  ##  fix/todo: add  find_by (alias for find_by_name/find_by_code)
+  def self.find_by_code( code )
+   q = code.to_s.downcase   ## allow symbols (and always downcase e.g. AUT to aut etc.)
+   
+   ## note: results in
+   ##    Côte d'Ivoire  => côte d'ivoire
+   ##  quote will break sql!!!
+   ##   remove - spaces etc.
+   ##     for now remove only single quote (will break sql) - add more?
+   ##
+   ## or use escape_sql_string - possible??
+
+   q = q.gsub( /[']/, '' )
+
+
+   rows = execute( <<-SQL )
+   SELECT #{self.columns.join(', ')}
+   FROM countries 
+   INNER JOIN country_codes ON countries.key  = country_codes.key
+   WHERE country_codes.code = '#{q}' 
+SQL
+   
+     if rows.empty? 
+        nil 
+     else 
+         _build_country( rows[0] )
+     end
+  end
+
+
+ ##
+ ##
+ ## note - need to escape name ?
+ ##  e.g.  Côte d'Ivoire 
+ ##  make sure normalize removes single quotes (')!!!
+
+ def self.find_by_name( name )
+   q = normalize( unaccent( name.to_s ))  ## allow symbols too (e.g. use to.s first)
+   
+   rows = execute( <<-SQL )
+   SELECT #{self.columns.join(', ')}
+   FROM countries 
+   INNER JOIN country_names ON countries.key  = country_names.key
+   WHERE country_names.name = '#{q}' 
+SQL
+
+     if rows.empty? 
+        nil 
+     else 
+         _build_country( rows[0] )
+     end   
+ end
+end  # class Country
+end  # module Metal
+end  # module CatalogDb
+ 

data/lib/sportdb/catalogs/event_info.rb

@@ -0,0 +1,74 @@
+module CatalogDb
+module Metal
+
+class EventInfo < Record
+    self.tablename = 'event_infos'
+
+    self.columns = ['league_key', 
+                    'season', 
+                    'teams',    
+                    'matches',
+                    'goals',
+                    'start_date',  
+                    'end_date']
+          
+
+     def self._build_event_info( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        ## note: move EventInfo from sports/format to structs - why? why not?
+        @cache[ row[0] ] ||= SportDb::Import::EventInfo.new(
+                                league: _to_league( row[0] ),
+                                season: Season.parse(row[1]),
+                                teams: row[2],
+                                matches: row[3],
+                                goals: row[4],
+                                start_date: row[5] ? Date.strptime( row[5], '%Y-%m-%d' ) : nil,
+                                end_date: row[6]   ? Date.strptime( row[6], '%Y-%m-%d' ) : nil,
+                              )   
+     end                
+          
+
+    def self.seasons( league )
+      league_key = league.is_a?( String ) ? League.find!( league ).key 
+                                          : league.key
+
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM event_infos 
+        WHERE event_infos.league_key = '#{league_key}' 
+SQL
+
+         rows.map {|row| _build_event_info( row ) }
+    end
+
+    
+    def self.find_by( league:, season: )
+      league_key = league.is_a?( String ) ? League.find!( league ).key 
+                                          : league.key
+      season_key = season.is_a?( String ) ? Season.parse(season).key 
+                                          : season.key
+
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM event_infos 
+        WHERE event_infos.league_key = '#{league_key}' AND
+              event_infos.season     = '#{season_key}' 
+SQL
+
+      if rows.empty?
+           nil
+      elsif rows.size > 1  ## not possible in theory
+       puts "** !!! ERROR - expected zero or one rows; got (#{rows.size}):"
+       pp rows
+       exit 1
+      else
+         _build_event_info( rows[0] )
+      end
+    end
+
+end  # class EventInfo
+end  # module Metal
+end  # module CatalogDb
+
+