sportdb-models 1.10.0

data/lib/sportdb/finders/scores.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module SportDb
+
+class ScoresFinder
+
+  include LogUtils::Logging
+
+  # e.g. 1:2 or 0:2 or 3:3  or
+  #      1-1 or 0-2 or 3-3
+  FT_REGEX = /\b
+            (?<score1>\d{1,2})
+               [:\-]
+            (?<score2>\d{1,2})
+           \b/x
+
+
+  # e.g. 1:2nV  => after extra time a.e.t
+    
+  # note: possible ending w/ . -> thus cannot use /b will not work w/ .; use zero look-ahead
+  ET_REGEX = /\b
+               (?<score1>\d{1,2})
+                  [:\-]
+               (?<score2>\d{1,2})
+                  \s?                # allow optional space
+                (?:nV|n\.V\.|aet|a\.e\.t\.)        # allow optional . e.g. nV or n.V.
+               (?=[\s\)\]]|$)/xi
+
+  ## todo: add/allow english markers e.g. pen or p  ??
+
+  # e.g. 5:4iE  => penalty / after penalty a.p
+
+
+  # note: possible ending w/ . -> thus cannot use /b will not work w/ .; use zero look-ahead
+  P_REGEX = /\b
+              (?<score1>\d{1,2})
+                  [:\-]
+              (?<score2>\d{1,2})
+                  \s?                # allow optional space
+                (?:iE|i\.E\.|p|pen|PSO)       # allow optional . e.g. iE or i.E.
+              (?=[\s\)\]]|$)/xi
+
+
+  ## todo: allow all-in-one "literal form a la kicker" e.g.
+  #  2:2 (1:1, 1:0) n.V. 5:1 i.E.
+
+  def initialize
+    # nothing here for now
+  end
+
+  def find!( line, opts={} )
+
+    ### fix: add and match all-in-one literal first, followed by
+
+    # note: always call after find_dates !!!
+    #  scores match date-like patterns!!  e.g. 10-11  or 10:00 etc.
+    #   -- note: score might have two digits too
+
+    ### fix: depending on language allow 1:1 or 1-1
+    ##   do NOT allow mix and match
+    ##  e.g. default to en is  1-1
+    ##    de is 1:1 etc.
+    
+
+    # extract score from line
+    # and return it
+    # NB: side effect - removes date from line string
+
+    score1   = nil
+    score2   = nil
+    
+    score1et = nil
+    score2et = nil
+    
+    score1p  = nil
+    score2p  = nil
+
+    if (md = ET_REGEX.match( line ))
+      score1et = md[:score1].to_i
+      score2et = md[:score2].to_i
+      
+      logger.debug "   score.et: >#{score1et}-#{score2et}<"
+      
+      line.sub!( md[0], '[SCORE.ET]' )
+    end
+
+    if (md = P_REGEX.match( line ))
+      score1p = md[:score1].to_i
+      score2p = md[:score2].to_i
+      
+      logger.debug "   score.p: >#{score1p}-#{score2p}<"
+      
+      line.sub!( md[0], '[SCORE.P]' )
+    end
+
+    ## let full time (ft) standard regex go last - has no marker
+
+    if (md = FT_REGEX.match( line ))
+      score1 = md[:score1].to_i
+      score2 = md[:score2].to_i
+
+      logger.debug "   score: >#{score1}-#{score2}<"
+      
+      line.sub!( md[0], '[SCORE]' )
+    end
+
+    ## todo: how to handle game w/o extra time
+    #   but w/ optional penalty ???  e.g. used in copa liberatores, for example
+    #    retrun 0,0 or nil,nil for extra time score ?? or -1, -1 ??
+    #    for now use nil,nil
+
+    scores = []
+    scores += [score1, score2]       if score1p || score2p || score1et || score2et || score1 || score2
+    scores += [score1et, score2et]   if score1p || score2p || score1et || score2et 
+    scores += [score1p,  score2p]    if score1p || score2p
+
+    scores
+  end
+
+end # class ScoresFinder
+
+end # module SportDb

data/lib/sportdb/lang.rb

@@ -0,0 +1,216 @@
+# encoding: utf-8
+
+module SportDb
+
+class Lang
+
+  include LogUtils::Logging
+
+  attr_reader :lang
+
+  def initialize
+    # fix/todo: load on demand; only if no fixtures loaded/configured use builtin
+    load_builtin_words
+  end
+
+
+  def load_builtin_words
+    builtin_words = {
+      'en' => 'fixtures/en',
+      'de' => 'fixtures/de',
+      'es' => 'fixtures/es',
+      'fr' => 'fixtures/fr',
+      'it' => 'fixtures/it',
+      'pt' => 'fixtures/pt',
+      'ro' => 'fixtures/ro'
+    }
+
+    load_words( builtin_words, SportDb.config_path )
+  end
+
+
+  def load_words( h, include_path )
+    @lang = 'en'   # make default lang english/en
+    @words = {}  # resets fixtures
+    @cache = {}  # reset cached values
+
+    h.each_with_index do |(key,value),i|
+      name = value
+      path = "#{include_path}/#{name}.yml"
+      logger.debug( "loading words #{key} (#{i+1}/#{h.size}) in '#{name}' (#{path})..." )
+      @words[ key ] = YAML.load( File.read_utf8( path ))
+    end
+
+    @classifier = TextUtils::Classifier.new
+    @words.each_with_index do |(key,value),i|
+      logger.debug "train classifier for #{key} (#{i+1}/#{@words.size})"
+      @classifier.train( key, value )
+    end
+    
+    @classifier.dump  # for debugging dump all words
+  end
+
+  def classify( text )
+    @classifier.classify( text )
+  end
+
+  def classify_file( path )
+    @classifier.classify_file( path )
+  end
+
+  def lang=(value)
+    logger.debug "setting lang to #{value}"
+    
+    if @lang != value
+      
+      ### todo: make reset cached values into method/function for reuse (see load_words)
+      # reset cached values on language change
+      logger.debug "reseting cached lang values (lang changed from #{@lang} to #{value})"
+
+      @cache = {}
+    end
+    
+    @lang = value
+    
+  end
+
+
+  def group
+    @cache[ :group ] ||= group_getter
+  end
+  
+  def round
+    @cache[ :round ] ||= round_getter
+  end
+
+  def knockout_round
+    @cache[ :knockout_round ] ||= knockout_round_getter
+  end
+  
+  def leg1
+    @cache[ :leg1 ] ||= leg1_getter
+  end
+  
+  def leg2
+    @cache[ :leg2 ] ||= leg2_getter
+  end
+
+
+
+  def regex_group
+    @cache [ :regex_group ] ||= regex_group_getter
+  end
+
+  def regex_round
+    @cache[ :regex_round ] ||= regex_round_getter
+  end
+
+  def regex_knockout_round
+    @cache[ :regex_knockout_round ] ||= regex_knockout_round_getter
+  end
+  
+  def regex_leg1
+    @cache[ :regex_leg1 ] ||= regex_leg1_getter
+  end
+  
+  def regex_leg2
+    @cache[ :regex_leg2 ] ||= regex_leg2_getter
+  end
+
+private
+  def group_getter
+    h = @words[ lang ]
+    values = ""   # NB: always construct a new string (do NOT use a reference to hash value)
+    values << h['group']
+    values
+  end
+
+  def round_getter
+    # e.g. Spieltag|Runde|Achtelfinale|Viertelfinale|Halbfinale|Finale
+    
+    ## fix/todo:
+    ##  sort by length first - to allow best match e.g.
+    ##    3rd place play-off  instead of Play-off ?? etc.  - why? why not?
+
+    h = @words[ lang ]
+    values = ""   # NB: always construct a new string (do NOT use a reference to hash value)
+    values << h['round']
+    
+    ### add knockout rounds values too
+    values << "|" << h['round32']
+    values << "|" << h['round16']
+    values << "|" << h['quarterfinals']
+    values << "|" << h['semifinals']
+    values << "|" << h['fifthplace']  if h['fifthplace']   # nb: allow empty/is optional!!
+    values << "|" << h['thirdplace']
+    values << "|" << h['final']
+    values << "|" << h['playoffs']    if h['playoffs']   # nb: allow empty/is optional!!
+    values
+  end
+
+  def leg1_getter
+    h = @words[ lang ]
+    values = ""  # NB: always construct a new string (do NOT use a reference to hash value)
+    values << h['leg1']
+    values
+  end
+
+  def leg2_getter
+    h = @words[ lang ]
+    values = ""  # NB: always construct a new string (do NOT use a reference to hash value)
+    values << h['leg2']
+    values
+  end
+
+  def knockout_round_getter
+    h = @words[ lang ]
+    values = ""  # NB: always construct a new string (do NOT use a reference to hash value)
+    values << h['round32']
+    values << "|" << h['round16']
+    values << "|" << h['quarterfinals']
+    values << "|" << h['semifinals']
+    values << "|" << h['fifthplace']  if h['fifthplace']   # nb: allow empty/is optional!!
+    values << "|" << h['thirdplace']
+    values << "|" << h['final']
+    values << "|" << h['playoffs']    if h['playoffs']   # nb: allow empty/is optional!!
+    values
+  end
+  
+  def regex_group_getter
+    ## todo: escape for regex?
+    ## NB: let's ignore case (that is, UPCASE,downcase); always use /i flag
+    /#{group}/i
+  end
+  
+  def regex_round_getter
+    ## todo: escape for regex?
+    ## todo: sort by length - biggest words go first? does regex match biggest word automatically?? - check
+    ##  todo/fix: make - optional e.g. convert to ( |-) or better [ \-] ??
+    ## NB: let's ignore case (that is, UPCASE,downcase); always use /i flag
+    /#{round}/i
+  end
+
+  def regex_knockout_round_getter
+    ## todo: escape for regex?
+    ## todo: sort by length - biggest words go first? does regex match biggest word automatically?? - check
+    ##  todo/fix: make - optional e.g. convert to ( |-) or better [ \-] ??
+    ## NB: let's ignore case (that is, UPCASE,downcase); always use /i flag
+    /#{knockout_round}/i
+  end
+
+  def regex_leg1_getter
+    ## todo: escape for regex?
+    ## NB: let's ignore case (that is, UPCASE,downcase); always use /i flag
+    /#{leg1}/i
+  end
+
+  def regex_leg2_getter
+    ## todo: escape for regex?
+    ## NB: let's ignore case (that is, UPCASE,downcase); always use /i flag
+    /#{leg2}/i
+  end
+
+end # class Lang
+
+
+end # module SportDb

data/lib/sportdb/matcher.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module SportDb
+
+module Matcher
+
+  include WorldDb::Matcher
+
+  def match_leagues_for_country( name, &blk )
+    match_xxx_for_country( name, 'leagues', &blk )
+  end
+
+  def match_teams_for_country( name, &blk )
+    match_xxx_for_country( name, 'teams', &blk )
+  end
+
+  def match_clubs_for_country( name, &blk )
+    match_xxx_for_country( name, 'clubs', &blk )
+  end
+
+  def match_players_for_country( name, &blk )
+    match_xxx_for_country( name, 'players', &blk )
+  end
+
+  def match_stadiums_for_country( name, &blk )
+    match_xxx_for_country( name, 'stadiums', &blk )
+  end
+
+end # module Matcher
+
+end # module SportDb

data/lib/sportdb/models.rb

@@ -0,0 +1,259 @@
+# encoding: utf-8
+
+
+# core and stlibs  (note: get included via worlddb-models gem; see worlddb-models gem/lib)
+
+
+require 'worlddb/models'     # NOTE: include worlddb-models gem (not cli tools gem, that is, worlddb)
+require 'persondb'
+
+
+## todo: check if already included in worlddb ???
+## require 'fetcher'   # for fetching/downloading fixtures via HTTP/HTTPS etc.
+
+
+# our own code
+
+require 'sportdb/version'    # let version always go first
+
+require 'sportdb/patterns'
+require 'sportdb/models/forward'
+require 'sportdb/models/world/city'
+require 'sportdb/models/world/country'
+require 'sportdb/models/world/continent'
+require 'sportdb/models/world/region'
+require 'sportdb/models/assoc'
+require 'sportdb/models/assoc_assoc'
+require 'sportdb/models/badge'
+require 'sportdb/models/event'
+require 'sportdb/models/event_ground'
+require 'sportdb/models/event_team'
+require 'sportdb/models/game'
+require 'sportdb/models/goal'
+require 'sportdb/models/ground'
+require 'sportdb/models/group'
+require 'sportdb/models/group_team'
+require 'sportdb/models/league'
+require 'sportdb/models/person'
+require 'sportdb/models/roster'
+require 'sportdb/models/round'
+require 'sportdb/models/season'
+require 'sportdb/models/team'
+require 'sportdb/models/team_comp'
+
+
+require 'sportdb/models/stats/alltime_standing'
+require 'sportdb/models/stats/alltime_standing_entry'
+require 'sportdb/models/stats/event_standing'
+require 'sportdb/models/stats/event_standing_entry'
+require 'sportdb/models/stats/group_standing'
+require 'sportdb/models/stats/group_standing_entry'
+
+require 'sportdb/models/utils'   # e.g. GameCursor
+
+
+require 'sportdb/schema'       # NB: requires sportdb/models (include SportDB::Models)
+
+require 'sportdb/finders/date'
+require 'sportdb/finders/scores'
+
+require 'sportdb/utils'
+require 'sportdb/utils_date'
+require 'sportdb/utils_group'
+require 'sportdb/utils_map'
+require 'sportdb/utils_round'
+require 'sportdb/utils_scores'
+require 'sportdb/utils_teams'
+require 'sportdb/utils_goals'
+require 'sportdb/matcher'
+require 'sportdb/calc'       # fix/todo: obsolete - replace w/ standings
+require 'sportdb/standings'
+
+
+require 'sportdb/finders/goals'   # no: requires FixturesHelpers
+
+require 'sportdb/readers/assoc'
+require 'sportdb/readers/event'
+require 'sportdb/readers/game'
+require 'sportdb/readers/ground'
+require 'sportdb/readers/league'
+require 'sportdb/readers/season'
+require 'sportdb/readers/squad_club'    # roster
+require 'sportdb/readers/squad_national_team'
+require 'sportdb/readers/team'
+require 'sportdb/reader'
+require 'sportdb/reader_file'
+require 'sportdb/reader_zip'
+
+
+
+require 'sportdb/lang'
+
+require 'sportdb/deleter'
+require 'sportdb/stats'
+
+
+module SportDb
+
+  def self.config_path
+    "#{root}/config"
+  end
+
+  def self.data_path
+    "#{root}/data"
+  end
+
+  def self.test_data_path
+    "#{root}/test/data"
+  end
+
+
+  def self.lang
+    # todo/fix: find a better way for single instance ??
+    #  will get us ruby warning:  instance variable @lang not initialized   => find a better way!!!
+    #   just use @lang w/o .nil?  e.g.
+    #  @lang =|| Lang.new   why? why not??  or better use @@lang =|| Lang.new  for class variable!!!
+     if @lang.nil?
+       @lang = Lang.new
+     end
+     @lang
+  end
+
+
+  def self.create
+    CreateDb.new.up
+    ConfDb::Model::Prop.create!( key: 'db.schema.sport.version', value: VERSION )
+  end
+
+  def self.create_all
+    ## build schema - convenience helper
+    LogDb.create
+    ConfDb.create
+    TagDb.create
+    WorldDb.create
+    PersonDb.create
+    SportDb.create
+  end
+
+
+  def self.read_setup( setup, include_path )
+    reader = Reader.new( include_path )
+    reader.load_setup( setup )
+  end
+
+  def self.read_setup_from_zip( zip_name, setup, include_path, opts={} ) ## todo/check - use a better (shorter) name ??
+    reader = ZipReader.new( zip_name, include_path, opts )
+    reader.load_setup( setup )
+    reader.close
+  end
+
+  def self.read_all( include_path )   # convenience helper
+    read_setup( 'setups/all', include_path )
+  end
+
+  def self.read_builtin
+    read_setup( 'setups/all', data_path )
+  end
+
+
+  # load built-in (that is, bundled within the gem) named plain text seeds
+  # - pass in an array of pairs of event/seed names e.g.
+  #   [['at.2012/13', 'at/2012_13/bl'],
+  #    ['cl.2012/13', 'cl/2012_13/cl']] etc.
+
+  def self.read( ary, include_path )
+    reader = Reader.new( include_path )
+    ## todo: check kind_of?( Array ) or kind_of?(String) to support array or string
+    ary.each do |name|
+      reader.load( name )
+    end
+  end
+
+
+  # delete ALL records (use with care!)
+  def self.delete!
+    puts '*** deleting sport table records/data...'
+    Deleter.new.run
+  end # method delete!
+
+  def self.update!
+    puts '*** update event fixtures...'
+    Updater.new.run
+  end
+
+
+  def self.stats
+    Stats.new.tables   # NOTE: same as tables (remove??? why? why not??)
+  end
+
+  def self.tables
+    Stats.new.tables
+  end
+
+
+  def self.connect( db_config={} )
+
+    if db_config.empty?
+      puts "ENV['DATBASE_URL'] - >#{ENV['DATABASE_URL']}<"
+
+      ### change default to ./sport.db ?? why? why not?
+      db = URI.parse( ENV['DATABASE_URL'] || 'sqlite3:///sport.db' )
+
+      if db.scheme == 'postgres'
+        config = {
+          adapter: 'postgresql',
+          host: db.host,
+          port: db.port,
+          username: db.user,
+          password: db.password,
+          database: db.path[1..-1],
+          encoding: 'utf8'
+        }
+      else # assume sqlite3
+       config = {
+         adapter: db.scheme, # sqlite3
+         database: db.path[1..-1] # sport.db (NB: cut off leading /, thus 1..-1)
+      }
+      end
+    else
+      config = db_config  # use passed in config hash
+    end
+
+    ## todo/check: use if defined?( JRUBY_VERSION ) instead ??
+    if RUBY_PLATFORM =~ /java/ && config[:adapter] == 'sqlite3' 
+      # quick hack for JRuby sqlite3 support via jdbc
+      puts "jruby quick hack - adding jdbc libs for jruby sqlite3 database support"
+      require 'jdbc/sqlite3'
+      require 'active_record/connection_adapters/jdbc_adapter'
+      require 'active_record/connection_adapters/jdbcsqlite3_adapter'
+    end
+
+    puts "Connecting to db using settings: "
+    pp config
+    ActiveRecord::Base.establish_connection( config )
+    # ActiveRecord::Base.logger = Logger.new( STDOUT )
+  end
+
+
+  def self.setup_in_memory_db
+
+    # Database Setup & Config
+    ActiveRecord::Base.logger = Logger.new( STDOUT )
+    ## ActiveRecord::Base.colorize_logging = false  - no longer exists - check new api/config setting?
+
+    self.connect( adapter:  'sqlite3',
+                  database: ':memory:' )
+
+    ## build schema
+    SportDb.create_all
+
+    ## read builtins - why? why not?
+    SportDb.read_builtin
+  end # setup_in_memory_db (using SQLite :memory:)
+
+
+end  # module SportDb
+
+
+## say hello
+puts SportDb.banner   if $DEBUG || (defined?($RUBYLIBS_DEBUG) && $RUBYLIBS_DEBUG)