sportdb-catalogs 1.0.0 → 1.2.0

data/lib/sportdb/catalogs/ground.rb

@@ -0,0 +1,106 @@
+module CatalogDb
+module Metal
+
+class Ground < Record
+    self.tablename = 'grounds'
+
+    self.columns = ['key', 
+                    'name', 
+                    'alt_names',    #2
+                    'city_key',     #3
+                    'country_key',  #4
+                    'district',     #5
+                    'address',      #6
+                  ]
+
+
+    def self._build_ground( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin 
+                                ground = Sports::Ground.new(
+                                         key:  row[0],
+                                         name: row[1] )
+                                
+                                if row[2]
+                                  alt_names = row[2].split( '|' )
+                                  alt_names = alt_names.map { |name| name.strip }
+                                  ground.alt_names += alt_names 
+                                end
+                                ground.city     =  _to_city( row[3] )
+                                ground.country  =  _to_country( row[4] )
+                                ground.district =  row[5]
+                                ground.address  =  row[6]
+                                ground
+                              end                                                     
+    end                
+ 
+
+    def self._find_by_name( name )
+        rows = execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM grounds 
+        INNER JOIN ground_names ON grounds.key  = ground_names.key
+        WHERE ground_names.name = '#{name}' 
+SQL
+       rows 
+    end
+
+    def self._find_by_name_and_country( name, country )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM grounds 
+      INNER JOIN ground_names ON grounds.key  = ground_names.key
+      WHERE ground_names.name = '#{name}' AND 
+            grounds.country_key = '#{country}'
+SQL
+      rows 
+    end
+
+    def self._find_by_name_and_city( name, city )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM grounds 
+      INNER JOIN ground_names ON grounds.key  = ground_names.key
+      WHERE ground_names.name = '#{name}' AND 
+            grounds.city_key = '#{city}'
+SQL
+      rows 
+    end
+
+
+
+  ## match - always returns an array (with one or more matches)
+  def self.match_by( name:, 
+                     country: nil,
+                     city:    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) )
+
+    rows = if country && city.nil?
+              country = _country( country )
+              countryq = country.key
+              _find_by_name_and_country( nameq, countryq )
+           elsif city && country.nil?
+              city    = _city( city )
+              cityq   = city.key 
+              _find_by_name_and_city( nameq, cityq )
+           elsif city.nil? && country.nil?
+             _find_by_name( nameq )
+           else
+              raise ArgumentError, "unsupported city query params pairs; sorry"
+           end
+    
+    rows.map {|row| _build_ground( row )}
+  end
+end  # class Ground
+
+end  # module Metal
+end  # module CatalogDb
+

data/lib/sportdb/catalogs/league.rb

@@ -0,0 +1,87 @@
+module CatalogDb
+module Metal
+
+class League < Record
+    self.tablename = 'leagues'
+
+    self.columns = ['key', 
+                    'name', 
+                    'intl',  # international tournament?
+                    'clubs', # clubs or national teams? 
+                    'country_key']
+          
+
+    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 leagues 
+      WHERE leagues.key = '#{key}' 
+SQL
+ 
+          ## todo/fix: also assert for rows == 1 AND NOT MULTIPLE records - why? why not?
+          if rows.empty? 
+            raise ArgumentError, "league record with key #{key} not found" 
+          else 
+            _build_league( rows[0] )
+          end
+        end
+     end
+
+     def self._build_league( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        cache[ row[0] ] ||= Sports::League.new(
+                                key: row[0],
+                                name: row[1],
+                                intl: _to_bool( row[2] ),   
+                                clubs: _to_bool( row[3] ),
+                                country: row[4] ? _to_country( row[4] ) : nil,
+                             )
+     end                
+          
+
+      def self.match_by( name:, 
+                         country: nil )
+        ## note: match must for now always include name
+        name = normalize( unaccent(name) )
+
+        rows = nil 
+        if country.nil? 
+            ## note: returns empty array if no match and NOT nil
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM leagues 
+        INNER JOIN league_names ON leagues.key  = league_names.key
+        WHERE league_names.name = '#{name}' 
+SQL
+        else  ## filter by country
+          ## note: also skip international leagues & cups (e.g. champions league etc.) for now - why? why not?
+ 
+          ## note: country assumes / allows the country key or fifa code for now
+          ## note: allow passing in of country struct too
+          country_rec = _country( country )
+
+          rows = execute( <<-SQL )
+          SELECT #{self.columns.join(', ')}
+          FROM leagues 
+          INNER JOIN league_names ON leagues.key  = league_names.key
+          WHERE league_names.name = '#{name}' AND
+                leagues.country_key = '#{country_rec.key}'
+
+SQL
+        end
+
+         ## wrap results array into struct records
+         rows.map {|row| _build_league( row )}
+      end
+
+end  # class League
+end  # module Metal
+end  # module CatalogDb
+
+

data/lib/sportdb/catalogs/national_team.rb

@@ -0,0 +1,61 @@
+module CatalogDb
+module Metal
+
+class NationalTeam < Record
+    self.tablename = 'national_teams'
+
+    self.columns = ['key', 
+                    'name', 
+                    'code', 
+                    'country_key']
+
+     def self._build_national_team( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin
+                               team = Sports::NationalTeam.new(
+                                        key: row[0],
+                                        name: row[1],
+                                        code: row[2]   
+                                      )
+
+                                ## note: country for now NOT supported 
+                                ##       via keyword on init!!!
+                                ##    fix - why? why not?
+                                team.country = row[3] ? _to_country( row[3] ) : nil
+                                team      
+                             end
+     end                
+
+    
+
+  def self.find( q )
+    q = normalize( unaccent(q.to_s) )  ## allow symbols too (e.g. use to.s first)
+   
+    rows = execute( <<-SQL )
+    SELECT #{self.columns.join(', ')}
+    FROM national_teams 
+    INNER JOIN national_team_names ON national_teams.key  = national_team_names.key
+    WHERE national_team_names.name = '#{q}' 
+ SQL
+ 
+      if rows.empty? 
+         nil 
+      else 
+          _build_national_team( rows[0] )
+      end   
+  end
+
+
+  def self.find!( q )
+    team = find( q )
+    if team.nil?
+      puts "** !!! ERROR - no match for national team >#{q}< found"
+      exit 1
+    end
+    team
+  end
+end  # class NationalTeam
+
+end  # module Metal
+end  # module CatalogDb

data/lib/sportdb/catalogs/player.rb

@@ -0,0 +1,125 @@
+module CatalogDb
+module Metal
+
+class Player < PlayerRecord
+
+    ## note - tablename is persons!! (NOT players or even people)
+    self.tablename = 'persons'
+
+    self.columns = ['id',           #0
+                    'name',         #1
+                    'alt_names',    #2
+                    'nat',          #3
+                    'height',       #4
+                    'pos',          #5
+                    'birthdate',    #6
+                    'birthplace',   #7
+                  ]
+
+
+    ### todo/fix:
+    ##   change sqlite config to return records as hash NOT array!!!!
+    ##
+
+    def self._build_player( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin 
+                                ## use Sports::Player.new  - why? why not?
+                                player = Sports::Player.new(
+                                           name:       row[1],
+                                           nat:        row[3],
+                                           height:     row[4],
+                                           pos:        row[5],  ## make pos into an array??
+                                           birthdate:  row[6],  ## todo/fix - convert to date??
+                                           birthplace: row[7],
+                                            )
+                                
+                                if row[2]
+                                  alt_names = row[2].split( '|' )
+                                  alt_names = alt_names.map { |name| name.strip }
+                                  player.alt_names += alt_names 
+                                end
+                                player
+                              end                                                     
+    end                
+ 
+
+    def self._find_by_name( name )
+        rows = execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM persons 
+        INNER JOIN person_names ON persons.id  = person_names.person_id
+        WHERE person_names.name = '#{name}' 
+SQL
+       rows 
+    end
+
+    def self._find_by_name_and_country( name, country )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM persons 
+      INNER JOIN person_names ON persons.id  = person_names.person_id
+      WHERE person_names.name = '#{name}' AND 
+            persons.nat = '#{country}'
+SQL
+      rows 
+    end
+
+    def self._find_by_name_and_year( name, year )
+      ## check if there's a date function for year 
+      ##  (using integer compare instead of string with qoutes???) 
+      ##  use cast to convert year to integer - why? why not? 
+
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM persons 
+      INNER JOIN person_names ON persons.id  = person_names.person_id
+      WHERE person_names.name = '#{name}' AND 
+            CAST(strftime('%Y',persons.birthdate) AS INTEGER) = #{year}
+SQL
+      rows 
+    end
+
+    def self._find_by_name_and_year_and_country( name, year, country )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM persons 
+      INNER JOIN person_names ON persons.id  = person_names.person_id
+      WHERE person_names.name = '#{name}' AND 
+            CAST(strftime('%Y',persons.birthdate) AS INTEGER) = #{year} AND
+            persons.nat = '#{country}'
+SQL
+      rows 
+    end
+
+
+  ## match - always returns an array (with one or more matches)
+  def self.match_by( name:, 
+                     country: nil,
+                     year:    nil )
+    nameq = normalize( unaccent(name) )
+
+    rows = if country 
+              country = _country( country )
+              countryq = country.key
+              if year
+                _find_by_name_and_year_and_country( nameq, year, countryq ) 
+              else    ## no year (country only)
+                _find_by_name_and_country( nameq, countryq )
+              end
+           elsif year && country.nil?
+              _find_by_name_and_year( nameq, year )
+           elsif year.nil? && country.nil?
+             _find_by_name( nameq )
+           else
+              raise ArgumentError, "unsupported query for player; sorry"
+           end
+    
+    rows.map {|row| _build_player( row )}
+  end
+end  # class Player
+
+end  # module Metal
+end  # module CatalogDb
+

data/lib/sportdb/catalogs/version.rb

@@ -1,12 +1,10 @@
-# encoding: utf-8
-
 
 module SportDb
 module Module
 module Catalogs
 
   MAJOR = 1    ## todo: namespace inside version or something - why? why not??
-  MINOR = 0
+  MINOR = 2
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
@@ -15,7 +13,7 @@ module Catalogs
   end
 
   def self.banner
-    "sportdb-catalogs/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+    "sportdb-catalogs/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
   end
 
   def self.root

data/lib/sportdb/catalogs.rb

@@ -1,20 +1,182 @@
-# encoding: utf-8
-
 ### our own sportdb libs / gems
+###  try min. dependencies  - change to structs only (NOT formats) - why? why not?
+## require 'sportdb/structs'
 require 'sportdb/formats'
 
-### "built-in" default dataset libs / gems
-require 'fifa'    ## get a list of all fifa countries with (three letter) codes
-require 'footballdb/leagues'
-require 'footballdb/clubs'
+require 'sqlite3'
+
 
 
 ###
 # our own code
-require 'sportdb/catalogs/version' # let version always go first
-require 'sportdb/catalogs/wiki_index'
-require 'sportdb/catalogs/catalog'
-require 'sportdb/catalogs/config'
+require_relative 'catalogs/version' # let version always go first
+
+require_relative 'catalogs/base'       ## base record
+require_relative 'catalogs/country'
+require_relative 'catalogs/city'
+
+require_relative 'catalogs/club'   
+require_relative 'catalogs/national_team'
+require_relative 'catalogs/league'
+require_relative 'catalogs/event_info'
+require_relative 'catalogs/ground'   
+
+## more
+require_relative 'catalogs/player'
+
+
+
+module SportDb
+module Import
+
+class Configuration
+  ## note: add more configs (open class), see sportdb-structs for original config!!!
+
+  ###   
+  #  find a better name for setting - why? why not?
+  #     how about catalogdb or ???
+  attr_reader   :catalog_path 
+  def catalog_path=(path)
+      @catalog_path = path
+      ######## 
+      # reset database here to new path
+      CatalogDb::Metal::Record.database = path
+
+      ##  plus automagically set world search too (to use CatalogDb)
+      self.world = WorldSearch.new( 
+                          countries: CatalogDb::Metal::Country,
+                          cities:    CatalogDb::Metal::City, 
+                        ) 
+
+      @catalog_path
+  end
+
+  def catalog      
+       @catalog ||= SportSearch.new( 
+                           leagues:        CatalogDb::Metal::League,
+                           national_teams: CatalogDb::Metal::NationalTeam,
+                           clubs:          CatalogDb::Metal::Club,
+                           grounds:        CatalogDb::Metal::Ground,
+                           events:         CatalogDb::Metal::EventInfo,
+                           players:        CatalogDb::Metal::Player,    # note - via players.db !!!
+                        )
+  end
+
+  ###   
+  #  find a better name for setting - why? why not?
+  #     how about playersdb or ???
+  attr_reader   :players_path 
+  def players_path=(path)
+      @players_path = path
+      ######## 
+      # reset database here to new path
+      CatalogDb::Metal::PlayerRecord.database = path
+
+      @players_path
+  end
+end # class Configuration
+
+
+  ##  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
+
+
+
+
+
+###
+# add status
+module CatalogDb
+module Metal
+
+def self.tables
+
+  puts "==> table stats"
+  catalog_path = SportDb::Import.config.catalog_path 
+  if catalog_path
+    puts "  #{File.basename(catalog_path)} in (#{File.dirname(catalog_path)})"
+    puts "    #{Country.count} countries / #{City.count} cities" 
+    puts "    #{NationalTeam.count} national teams"
+    puts "    #{League.count} leagues"
+    puts "    #{Club.count} clubs"
+    puts "    #{Ground.count} grounds"
+      ## add more
+
+  else
+    puts "  - no catalog.db set - "
+  end
+
+  ## todo/fix:
+  ##   check if players_path configured???
+  players_path = SportDb::Import.config.players_path 
+  if players_path
+    puts "  #{File.basename(players_path)} in (#{File.dirname(players_path)})"
+    puts "    #{Player.count} players"
+  else
+    puts " - no players.db set -"
+  end
+end
+
+end # module Metal
+end # module CatalogDb
+        
+
+
+###
+# global helpers
+#    find a better name/place in module(s) or such
+##
+##  what name to use?
+##    find_countries_for_league_clubs or such
+##     find_countries_for_league  - why? why not?
+##     note -  returns array of countries OR single country 
+
+def find_countries_for_league( league )
+    ## todo/fix: assert league is a League with country record/struct !!!!! 
+
+    countries = [] 
+    countries << league.country   ### assume league.country is already db record/struct - why? why not?
+    ## check for 2nd countries for known leagues 
+    ## (re)try with second country - quick hacks for known leagues
+    ##  e.g. Swanse, cardiff  in premier league
+    ##       san mariono in serie a (italy)
+    ##       monaco  in ligue 1 (france)
+    ##       etc.
+    ##   add  andorra to spanish la liga (e.g. andorra fc???)
+ 
+    case league.country.key
+    when 'eng' then countries << CatalogDb::Metal::Country._record('wal') 
+    when 'sco' then countries << CatalogDb::Metal::Country._record('eng')
+    when 'ie'  then countries << CatalogDb::Metal::Country._record('nir')   
+    when 'fr'  then countries << CatalogDb::Metal::Country._record('mc') 
+    when 'es'  then countries << CatalogDb::Metal::Country._record('ad') 
+    when 'it'  then countries << CatalogDb::Metal::Country._record('sm')
+    when 'ch'  then countries << CatalogDb::Metal::Country._record('li') 
+    when 'us'  then countries << CatalogDb::Metal::Country._record('ca')
+    when 'au'  then countries << CatalogDb::Metal::Country._record('nz')
+    end 
+
+    ## use single ("unwrapped") item for one country 
+    ##    otherwise use array
+    country =  countries.size == 1 ? countries[0] : countries
+    country
+end
+
+
+
+
+
+
+require 'footballdb/data'   ## pull in catalog.db (built-in/default data/db)
+
+###
+## add default/built-in catalog here - why? why not?
+##  todo/fix  - set catalog_path on demand 
+##   note:  for now required for world search setup etc.
+SportDb::Import.config.catalog_path = "#{FootballDb::Data.data_dir}/catalog.db"
+
 
 
 puts SportDb::Module::Catalogs.banner   # say hello