sportdb-models_v2 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ebc3350f86107513b943494184c6974a0398b43935f76be2fc4577bb3fc89eaa
+  data.tar.gz: 429f8bbca4edf4a5ca2c1dda64a6c0a9ac418344bca8da3bd2edcc5fc4531272
+SHA512:
+  metadata.gz: 54b1eda6275a80eba81062324756e028ce9d99c8e56164fd1591ec3095c7ea6e7fd61dc63799c0d8d0b5a3b32d42875739923f5a50f623de80804539f34c08bb
+  data.tar.gz: 287499f53e769175bb5a77da7b1b4a311161391d4252b04b78a5563fe6097e25a02d0e01032cb77a147a2fc15b603ba19a2a942a863ccb6d2fa6f461f6676532

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+
+### 0.0.1 / 2025-04-07
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,18 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/sportdb/models_v2.rb
+lib/sportdb/models_v2/deleter.rb
+lib/sportdb/models_v2/match_reader.rb
+lib/sportdb/models_v2/models/event.rb
+lib/sportdb/models_v2/models/forward.rb
+lib/sportdb/models_v2/models/league.rb
+lib/sportdb/models_v2/models/match.rb
+lib/sportdb/models_v2/models/team.rb
+lib/sportdb/models_v2/schema.rb
+lib/sportdb/models_v2/stats.rb
+lib/sportdb/models_v2/sync/event.rb
+lib/sportdb/models_v2/sync/league.rb
+lib/sportdb/models_v2/sync/match.rb
+lib/sportdb/models_v2/version.rb

data/README.md

@@ -0,0 +1,28 @@
+# sportdb-models gem - sport.db schema 'n' models for easy (re)use
+
+
+
+* home  :: [github.com/sportdb/sport.db](https://github.com/sportdb/sport.db)
+* bugs  :: [github.com/sportdb/sport.db/issues](https://github.com/sportdb/sport.db/issues)
+* gem   :: [rubygems.org/gems/sportdb-models](https://rubygems.org/gems/sportdb-models)
+* rdoc  :: [rubydoc.info/gems/sportdb-models](http://rubydoc.info/gems/sportdb-models)
+
+
+
+## Usage Models
+
+![](sportdb-models.png)
+
+
+## License
+
+The `sportdb-models` scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+
+## Questions? Comments?
+
+Yes, you can. More than welcome.
+See [Help & Support »](https://github.com/openfootball/help)
+
+

data/Rakefile

@@ -0,0 +1,35 @@
+require 'hoe'
+require './lib/sportdb/models_v2/version.rb'
+
+
+Hoe.spec 'sportdb-models_v2' do
+
+  self.version = SportDbV2::Module::Models::VERSION
+
+  self.summary = "sportdb-models_v2 - sport.db schema 'n' models for easy (re)use"
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/sportdb/sport.db' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'gerald.bauer@gmail.com'
+
+  # switch extension to .markdown for gihub formatting
+  #  -- NB: auto-changed when included in manifest
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+    ['cocos'],
+    ## add props & logutils (or props/logutils-activerecord good enough?) - why? why not? 
+    ['props-activerecord'],    ## pulls in activerecord
+    ['logutils-activerecord'],
+    ['sportdb-quick'],
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 3.1.0'
+  }
+end

data/lib/sportdb/models_v2/deleter.rb

@@ -0,0 +1,51 @@
+
+module SportDbV2
+
+  class Deleter
+    ######
+    # note: make models available in sportdb module by default with namespace
+    #  e.g. lets you use Team instead of Model::Team
+    ## include Models
+
+    def run
+       puts "todo - add delete all tables here"
+=begin
+      # for now delete all tables
+
+      ## stats
+      AlltimeStandingEntry.delete_all
+      AlltimeStanding.delete_all
+      GroupStandingEntry.delete_all
+      GroupStanding.delete_all
+
+
+      Goal.delete_all
+
+      Match.delete_all
+      Event.delete_all
+      EventTeam.delete_all
+      EventGround.delete_all
+      Group.delete_all
+      GroupTeam.delete_all
+      Stage.delete_all
+      StageTeam.delete_all
+      Round.delete_all
+      Badge.delete_all
+
+      Lineup.delete_all
+
+      Team.delete_all
+
+      League.delete_all
+      Season.delete_all
+
+      Ground.delete_all   # stadiums
+
+      Assoc.delete_all       # associations / organizations
+      AssocAssoc.delete_all  # associations / organizations
+=end
+    end
+
+  end # class Deleter
+
+end # module SportDbV2

data/lib/sportdb/models_v2/match_reader.rb

@@ -0,0 +1,108 @@
+
+module SportDbV2
+class MatchReader   
+  
+
+  def self.read( path )   ## use - rename to read_file or from_file etc. - why? why not?
+    txt = File.open( path, 'r:utf-8' ) {|f| f.read }
+    parse( txt )
+  end
+
+  def self.parse( txt )
+    new( txt ).parse
+  end
+
+
+
+  include Logging
+
+
+  def initialize( txt )
+    @errors = []
+    @outline = QuickLeagueOutline.parse( txt )
+  end
+
+  attr_reader :errors
+  def errors?() @errors.size > 0; end
+
+
+  def parse( season: nil )
+    ## note: every (new) read call - resets errors list to empty
+    @errors = []
+
+    ### todo/fix - add back season filter - maybe upstream to outline - why? why not?
+    ########
+    #  step 1 - prepare secs
+    # -- filter seasons if filter present
+    #
+    # secs = filter_secs( sec, season: season )   if season
+
+
+    @outline.each_sec do |sec|   ## sec(tion)s
+      ### move season parse into outline upstream - why? why not?
+      season = Season.parse( sec.season )   ## convert (str) to season obj!!!
+      lines  = sec.lines
+
+ ## quick hack - assume "Regular" or "Regular Season"
+ ##    as default stage (thus, no stage)
+      stage = sec.stage   ## check if returns nil or empty string?
+  
+       stage = nil   if stage && ['regular',
+                                  'regular season',
+                                  'regular stage',
+                                 ].include?( stage.downcase )
+
+     
+      ### todo/fix - remove "legacy/old" requirement for start date!!!!
+        start = if season.year?
+                  Date.new( season.start_year, 1, 1 )
+                else
+                  Date.new( season.start_year, 7, 1 )
+                end
+              
+
+      parser = MatchParser.new( lines,
+                                start )   ## note: keep season start_at date for now (no need for more specific stage date need for now)
+
+      auto_conf_teams,  matches, rounds, groups = parser.parse
+
+      ## auto-add "upstream" errors from parser
+      @errors += parser.errors  if parser.errors?
+
+      puts ">>> #{auto_conf_teams.size} teams:"
+      pp auto_conf_teams
+      puts ">>> #{matches.size} matches:"
+      ## pp matches
+      puts ">>> #{rounds.size} rounds:"
+      pp rounds
+      puts ">>> #{groups.size} groups:"
+      pp groups
+
+
+      puts "league:"
+      league_rec = Sync::League.find_or_create( name: sec.league )
+      pp league_rec
+
+      event_rec = Sync::Event.find_or_create( league_rec: league_rec,
+                                                  season: season )
+      pp event_rec                                               
+
+  
+  
+      matches.each do |match|
+        ## note: pass along stage (if present): stage  - optional from heading!!!!
+           ### use | instead of comma (,) for stage separator in (full) round - why? why not?
+          match = match.update( stage: stage )    if stage
+ 
+        match_rec = Sync::Match.create!( match, event_rec: event_rec )
+        pp match
+        pp match_rec       
+      end
+    end
+
+    true   ## success/ok
+  end # method parse
+
+
+end # class MatchReader
+end # module SportDbV2

data/lib/sportdb/models_v2/models/event.rb

@@ -0,0 +1,44 @@
+
+module SportDbV2
+  module Model
+
+
+class Event < ActiveRecord::Base
+
+  belongs_to :league
+ 
+  ## has_many :matches, -> { order('pos') }, class_name: 'Match'
+  def matches
+    Match.where( league_id: league_id, season: season )
+  end
+
+
+  ## use event_rounds - why? why not?
+  ##   round ALWAYS specific to event
+  has_many :rounds, class_name: 'EventRound'
+  
+  ## note - pass teams through to get shared team record
+  ##        for "local" event name use event_teams - why? why not?
+  has_many :event_teams,  class_name: 'EventTeam'
+  has_many :teams, :through => :event_teams
+end # class Event
+
+
+class EventTeam < ActiveRecord::Base
+  self.table_name = 'event_teams'
+
+  belongs_to :event
+  belongs_to :team
+end # class EventTeam
+
+
+class EventRound < ActiveRecord::Base
+  self.table_name = 'event_rounds'
+
+  belongs_to :event
+  has_many   :matches, class_name: 'Match', foreign_key: 'event_round_id'
+end # class EventRound
+
+
+  end # module Model
+end # module SportDb

data/lib/sportdb/models_v2/models/forward.rb

@@ -0,0 +1,22 @@
+
+### forward references
+##   require first to resolve circular references
+
+module SportDbV2
+  module Model
+
+  Prop      = ConfDb::Model::Prop
+
+  ## note: for now only team and league use worlddb tables
+  #   e.g. with belongs_to assoc (country,region)
+
+  class Team   < ActiveRecord::Base ; end
+  class League < ActiveRecord::Base ; end
+
+  end
+
+  ## add backwards compatible n convenience namespace
+  Models = Model
+end # module SportDb
+
+

data/lib/sportdb/models_v2/models/league.rb

@@ -0,0 +1,20 @@
+module SportDbV2
+  module Model
+
+
+class League < ActiveRecord::Base
+
+  ## leagues also used for conferences, world series, cups, etc.
+  #
+  ## league (or cup/conference/series/etc.) + season (or year) = event
+
+  has_many :events
+  has_many :seasons, :through => :events
+
+  belongs_to :country, :class_name => 'WorldDb::Model::Country', :foreign_key => 'country_id'
+
+end  # class League
+
+
+  end # module Model
+end # module SportDbV2

data/lib/sportdb/models_v2/models/match.rb

@@ -0,0 +1,31 @@
+
+module SportDbV2
+  module Model
+
+
+class Match < ActiveRecord::Base
+
+  self.table_name = 'matches'
+
+  belongs_to :team1, class_name: 'Team', foreign_key: 'team1_id'
+  belongs_to :team2, class_name: 'Team', foreign_key: 'team2_id'
+
+  def team1_name()  team1.name; end
+  def team2_name()  team2.name; end
+
+  
+  belongs_to :league
+
+  ##  todo - add via
+  ## belongs_to :event
+  def event 
+    ## check if where always returns array or single record too??
+    Event.where( league_id: league_id, season: season )
+  end
+  belongs_to :event_round    # round is optional
+
+
+end # class Match
+
+  end # module Model
+end # module SportDbV2

data/lib/sportdb/models_v2/models/team.rb

@@ -0,0 +1,40 @@
+
+module SportDbV2
+  module Model
+
+
+class Team < ActiveRecord::Base
+
+  has_many :home_matches, class_name: 'Match', foreign_key: 'team1_id'
+  has_many :away_matches, class_name: 'Match', foreign_key: 'team2_id'
+
+  ## note: for now allow any key and code
+  ## validates :key,  format: { with: TEAM_KEY_RE,  message: TEAM_KEY_MESSAGE }
+  ## validates :code, format: { with: TEAM_CODE_RE, message: TEAM_CODE_MESSAGE }, allow_nil: true
+
+  has_many :event_teams, class_name: 'EventTeam'  # join table (events+teams)
+  has_many :events, :through => :event_teams
+
+  ### fix!!! - how to do it with has_many macro? use finder_sql?
+  ##  finder_sql is depreciated in Rails 4!!!
+  #   use -> { where()  } etc.  -- try it if it works
+  ##   keep as is! best solution ??
+  ##   a discussion here -> https://github.com/rails/rails/issues/9726
+  ##   a discussion here (not really helpful) -> http://stackoverflow.com/questions/2125440/activerecord-has-many-where-two-columns-in-table-a-are-primary-keys-in-table-b
+
+  def matches
+    Match.where( 'team1_id = ? or team2_id = ?', id, id ).order( 'date' )
+  end
+
+  def upcoming_matches
+    Match.where( 'team1_id = ? or team2_id = ?', id, id ).where( 'date > ?', Date.today ).order( 'date' )
+  end
+
+  def past_matches
+    Match.where( 'team1_id = ? or team2_id = ?', id, id ).where( 'date < ?', Date.today ).order( 'date desc' )
+  end
+end  # class Team
+
+
+  end # module Model
+end # module SportDbV2

data/lib/sportdb/models_v2/schema.rb

@@ -0,0 +1,260 @@
+
+##  check/todos:
+#  for start/end_date 
+#    use first/last_date for auto calculation - why? why not?
+#
+
+
+module SportDbV2
+
+class CreateDb
+
+def up
+  ActiveRecord::Schema.define do
+
+
+create_table :leagues do |t|  ## also for cups/conferences/tournaments/world series/etc.
+  # t.string     :key,   null: false
+  t.string     :name,  null: false     # e.g. Premier League, Deutsche Bundesliga, World Cup, Champions League, etc.
+  ## t.string     :alt_names  # comma separated list of alt names / synonyms
+
+  ## t.references :country,       index: false   ##  optional for now    ### todo: create "virtual" country for international leagues e.g. use int? or world (ww?)/europe (eu)/etc. similar? already taken??
+
+  ## fix: rename to :clubs from :club - why? why not?
+  ## fix: rename to :intl  from :international - why? why not? shorter? better?
+  ## todo/check:  flip clup to league flag? why? why not?
+  ## t.boolean    :clubs,    null: false, default: false  # club teams or national teams?
+  ## t.boolean    :intl,     null: false, default: false  # national league or international?
+  ## t.boolean    :cup,      null: false, default: false  ## or regular season league?? use a tournament type field with enums - why? why not?
+
+  ## t.integer    :level       ## use tier?  e.g. level 1, level 2, etc.
+
+  ## t.integer    :start_year
+  ## t.integer    :end_year
+
+  ## todo: add t.boolean  :national flag? for national teams?
+  t.timestamps
+end
+add_index :leagues, :name, unique: true
+
+
+
+create_table :teams do |t|
+  ## for now only name required
+
+
+  ## t.string  :key,   null: false   # import/export key
+  t.string  :name,  null: false   # "canonical" unique name
+
+  ## t.string  :code       #  three letter code (short name)
+  ## t.string  :alt_names  # comma separated list of alt names / synonyms
+
+  ## t.references :country,                index: false
+  ## t.references :city,                   index: false # note: city is optional (should be required for clubs e.g. non-national teams)
+  ## t.references :district,               index: false # note: optional district (in city)
+
+  ##  todo/check/fix: use team type or such e.g. club/national/etc. - why? why not?
+  ###   or remove and add virtual attribute in model instead - why? why not?
+  ## t.boolean  :club,     null: false, default: false  # is it a club (not a national team)?
+  ## t.boolean  :national, null: false, default: false  # is it a national selection team (not a club)?
+
+  ## todo/fix:  add team reference for a and b team!!!!
+
+
+  ## t.integer :start_year     # founding year  -fix change to start_year / founded - why? why not?
+  ## t.integer :end_year
+  ## add more? - start_year2, end_year2 - why? why not?
+  #  e.g. founded   = 1946, 2013 (refounded)
+  #       dissolved = 1997
+
+  ## t.string  :address
+  ## t.string  :web
+
+  ## t.string      :comments
+
+  t.timestamps
+end
+add_index :teams, :name, unique: true
+
+
+
+
+create_table :events do |t|
+  ## t.string      :key,        null: false   # import/export key
+  t.references  :league,     null: false, index: false
+  t.string      :season,     null: false   ## e.g. 2024/25 or 2024
+
+  t.string      :name    ## ,       null: false   # league name for this season
+  
+  t.date        :start_date                 # note: only use date (w/o time)
+  t.date        :end_date                   # note: only use date (w/o time)
+
+  ## t.integer     :num       ## optional series counter e.g. World Cup No. 2, Bundesliga No. 43 etc. etc.
+
+  ## t.boolean     :team3,    null: false, default: true   ## e.g. Champions League has no 3rd place (only 1st and 2nd/final)
+  ## todo: add league/cup flag/flags  or to league itself?
+  ##   or add add a tournament type field  - why? why not?
+
+  ## auto-added flag (e.g. start_at n end_at dates got calculated)
+  ##  if auto-added flag is false - do NOT auto-update start_at, end_at etc.
+  ## t.boolean    :auto, null: false, default: true
+
+
+  #### track 1-n sources (from repos)  - # todo move to its own table later
+  ## NB: relative to event.yml - use mapper to "resolve" to full path w/ repo; use league+season keys
+  # t.string      :sources    #  e.g. cup or bl,bl_ii   # NB: for now store all in on string separated by comma
+  # t.string      :config  # e.g. cup or bl #  e.g assumes cup.yml, bl.yml etc. for now
+
+
+  t.timestamps
+end
+add_index :events, [:league_id, :season], unique: true
+
+
+## add_index :events, :key, unique: true
+
+# todo: remove id from join table (without extra fields)? why?? why not??
+create_table :event_teams do |t|
+  t.references :event,  null: false, index: false    ## Note: do NOT auto-add index
+  t.references :team,   null: false, index: false    ## Note: do NOT auto-add index
+  t.string     :name   ##,   null: false     ## team name in use for this event (season)
+
+  t.timestamps
+end
+add_index :event_teams, [:event_id, :team_id], unique: true
+
+
+create_table :event_rounds do |t|
+  t.references :event,    null: false, index: false  ## Note: do NOT auto-add index
+  t.string     :name,     null: false
+  ## t.integer    :pos,      null: false   ## use only for "internal" sort order (defaults to insertion order)
+
+  ## t.integer    :num       ## optional match day/week number
+  ## t.string     :key       ## optional match day/week number key (as string)
+
+  ## add new table stage/stages for grouping rounds in group rounds and playoff rounds, for example???
+  ## # "regular" season (group) matches or post-season (playoff) knockouts (k.o's)
+  ## t.boolean    :knockout, null: false, default: false
+  ## todo: add leg  (e.g. leg1, leg2, etc. why? why not?)
+  t.date   :start_date   # note: only use date (w/o time)  - fix: change to start_date!!!
+  t.date   :end_date     # note: only use date (w/o time)  - fix: change to end_date!!!
+  ## t.date   :start_date2  # note: only use date (w/o time)  - fix: change to start_date!!!
+  ## t.date   :end_date2    # note: only use date (w/o time)  - fix: change to end_date!!!
+
+  ## add last_date/first-date(auto) - for "real" last and first dates - auto-added - why? why not?
+
+  ## auto-added flag (e.g. start_at n end_at dates got calculated)
+  ##  if auto-added flag is false - do NOT auto-update start_at, end_at etc.
+  ## t.boolean    :auto, null: false, default: true
+
+  t.timestamps
+end
+add_index :event_rounds, [:event_id, :name],  unique: true
+
+
+
+
+create_table :matches do |t|
+  ## t.string     :key          # import/export key
+  t.references :league,   null: false, index: false
+  t.string     :season,   null: false
+
+
+  ## t.integer    :pos,      null: false       ## note: use only for "internal" sort order (defaults to insertion order)
+  ## t.integer    :num       ## optional - "event global" match number e.g. World Cup - Match 1, Match 2, etc.
+
+ 
+  t.references :team1,    null: false, index: false   ## Note: do NOT auto-add index
+  t.references :team2,    null: false, index: false   ## Note: do NOT auto-add index
+
+  ## add team1_name and team2_name - for alternative name - why? why not?
+
+  ## event same as league+season - keep - why? why not?
+  ##  todo/fix -- use composite key in event ("upstream")!!!! 
+  ##                  do NOT duplicate - why? why not? 
+  ## t.references :event,    null: false, index: false
+  t.references :event_round,      index: false   ## Note: do NOT auto-add index
+  
+  ## t.references :group,                 index: false   ## Note: do NOT auto-add index  -- group is optional
+  ## t.references :stage,                 index: false     # optional - regular seasion / champions round etc.
+
+  ## "inline" helper keys auto-populate for easier "no-join/single-table" queries
+  ## t.string    :team1_key
+  ## t.string    :team2_key
+  ## t.string    :event_key
+  ## t.string    :round_key
+  ## t.integer   :round_num   ## e.g. 1,2,3 for match day/match week
+  ## t.string    :group_key
+  ## t.string    :stage_key
+
+
+  t.date      :date      # optional play date  - todo/fix: split into play_date AND play_time!!!
+  ## note:  activerecord(rails) will auto-add date (2000-01-01) to hours/time!!!
+  ##   work around - save a string type!!!!
+  ##  e.g.  19:00 etc.
+  ## t.time      :time
+  t.string    :time
+
+
+  ## t.boolean    :postponed, null: false, default: false
+  ## t.date   :date2   # optional old date (when postponed)
+  ## t.date   :date3   # optional old date (when postponed twice)
+
+  t.string    :status     ## optional match status  - note: uses UPCASE string constants for now
+                          ## e.g. CANCELLED / ABANDONED / REPLAY / AWARDED / POSTPONED / etc.
+
+
+  ## t.references :ground, index: false    # optional - stadium (lets you get city,region,country,etc)
+  ## t.references :city,   index: false    # optional - convenience for ground.city_id ???
+
+  ## change home to neutral - why? why not?
+  ## t.boolean    :home,     null: false, default: true    # is team1 play at home or neutral (that is, at its home stadium)
+  ## t.boolean    :knockout, null: false, default: false
+
+  t.integer    :score1      ## "generic" score
+  t.integer    :score2      ## "generic" score - undetermined - might be a.e.t or full time
+
+  ## add score1_agg  ??
+  ##     score2_agg
+  t.integer    :score1ht   # half time (45min)
+  t.integer    :score2ht  # half time 
+  t.integer    :score1ft  # full time (90min)
+  t.integer    :score2ft  # full time 
+
+  ## add flag for aet?  (or after sudden death goal/golden goal or such?)
+  ##   add score_note or such - why? why not?
+  t.integer    :score1et  # extratime (120min) - team 1 
+  t.integer    :score2et  # extratime         - team 2 
+  t.integer    :score1p   # penalty  - team 1 (opt)
+  t.integer    :score2p   # penalty  - team 2 (opt) elfmeter (opt)
+  
+  ## t.references :next_match, index: false   ## Note: do NOT auto-add index  -- for hinspiel bei rueckspiel in knockout match
+  ## t.references :prev_match, index: false   ## Note: do NOT auto-add index
+
+  ## t.integer    :winner      # 1,2,0,nil  calculate on save  - "real" winner (after 90 or extra time or penalty, aggregated first+second leg?)
+  ## t.integer    :winner90    # 1,2,0,nil  calculate on save  - winner after 90 mins (or regugular play time depending on sport - add alias or find  a better name!)
+
+  ## t.string     :comments
+
+  t.timestamps
+end
+
+=begin
+add_index :matches, :key,  unique: true
+add_index :matches, :event_id      # fk event_id index
+add_index :matches, :round_id      # fk round_id index
+add_index :matches, :group_id      # fk group_id index
+add_index :matches, :next_match_id  # fk next_match_id index
+add_index :matches, :prev_match_id  # fk next_match_id index
+add_index :matches, :team1_id
+add_index :matches, :team2_id
+=end
+
+
+  end  # Schema.define
+end # method up
+
+
+end # class CreateDb
+
+end # module SportDbV2

data/lib/sportdb/models_v2/stats.rb

@@ -0,0 +1,16 @@
+
+module SportDbV2
+
+  class Stats
+    include Models
+
+    def tables
+      puts "  #{League.count} leagues"
+      puts "  #{Event.count} events (league+season) / #{EventRound.count} event_rounds"
+      puts "  #{Team.count} teams"
+      puts "  #{Match.count} matches"
+    end
+
+  end  # class Stats
+
+end  # module SportDbV2

data/lib/sportdb/models_v2/sync/event.rb

@@ -0,0 +1,26 @@
+module SportDbV2
+  module Sync
+
+    class Event
+      def self.find_or_create( league_rec:, season: )
+        ## note: allow passing in of activerecord db records too - why? why not?
+        ## raise ArgumentError, "league struct record expected; got #{league.class.name}"  unless league.is_a?( Model::League )
+        raise ArgumentError, "season expected; got #{season.class.name}"  unless season.is_a?( Season )
+
+        rec = Model::Event.find_by( league_id: league_rec.id,
+                                    season:    season.to_key )
+        if rec.nil?
+          attribs = {
+            league_id: league_rec.id,
+            season:    season.to_key,
+          }
+
+          rec = Model::Event.create!( attribs )
+        end
+        rec
+      end
+    end  # class Event
+
+  end   # module Sync
+end   # module SportDbV2
+

data/lib/sportdb/models_v2/sync/league.rb

@@ -0,0 +1,18 @@
+module SportDbV2
+  module Sync
+    class League
+
+    def self.find_or_create( name: )
+       rec = Model::League.find_by( name: name )
+      if rec.nil?
+         attribs = { name: name }
+
+         rec = Model::League.create!( attribs )
+       end
+       rec
+    end
+
+  end # class League
+end   # module Sync
+end   # module SportDb
+

data/lib/sportdb/models_v2/sync/match.rb

@@ -0,0 +1,108 @@
+module SportDbV2
+module Sync
+
+
+  class Team
+    def self.find_or_create( name: )
+       rec = Model::Team.find_by( name: name )
+       if rec.nil?
+         attribs = { name: name }
+
+         rec = Model::Team.create!( attribs )
+       end
+       rec
+    end
+  end # class Team
+
+  class EventRound
+    def self.find_or_create( name:, event_rec: )
+       rec = Model::EventRound.find_by( name: name, event_id: event_rec.id )
+       if rec.nil?
+ 
+         attribs = { event_id: event_rec.id,
+                     name:     name
+                   }
+
+         ## todo/fix:  check if round has (optional) start or end date and add!!!
+         ## attribs[ :start_date] = round.start_date.to_date
+         rec = Model::EventRound.create!( attribs )
+       end
+       rec
+    end
+  end # class EventRound
+
+
+
+  class Match
+    def self.create!( match, event_rec: )
+       ## note: MUST find round, thus, use bang (!)
+
+       ## todo/check: allow strings too - why? why not?
+
+
+       ## todo/check:
+       ##   how to model "same" rounds in different stages
+       ##   e.g. Belgium
+       ##    in regular season (stage) - round 1, round 2, etc.
+       ##    in playoff        (stage) - round 1, round 2, etc.
+       ## reference same round or create a new one for each stage!!???
+       ##  and lookup by name AND stage??
+
+       round_rec = if match.round || match.stage || match.group
+                     ## note - for now use "all-in-one" super round
+                     ###     stage, round, group    - is the layout
+                     ## query for round - allow string or round rec
+                     ## todo/fix - also allow stage.name and group.name - why? why not?
+                     ##  e.g.      group_name = match.group.is_a?( String ) ? match.group : match.group.name
+ 
+                     round_name  = match.round.is_a?( String ) ? match.round : match.round.name
+                     round_name = "#{match.stage}, #{round_name}"   if match.stage
+                     round_name = "#{round_name}, #{match.group}"   if match.group
+
+                     Sync::EventRound.find_or_create( name: round_name, 
+                                                      event_rec: event_rec )
+                   else    # note: allow matches WITHOUT rounds too (e.g. England Football League 1888 and others)
+                     nil
+                   end
+
+ 
+
+       team1_name   = match.team1.is_a?( String ) ? match.team1 : match.team1.name
+       team2_name   = match.team2.is_a?( String ) ? match.team2 : match.team2.name
+       team1_rec    = Team.find_or_create( name: team1_name )
+       team2_rec    = Team.find_or_create( name: team2_name )
+
+  
+        rec = nil   ## match record
+
+         attribs = { league_id: event_rec.league.id,  
+                     season:    event_rec.season,
+               
+                     team1_id: team1_rec.id,
+                     team2_id: team2_rec.id,
+
+                     # pos:      max_pos,
+                     # num:      match.num,   ## note - might be nil (not nil for euro, world cup, etc.)
+                     date:     match.date,  # assume iso format as string e.g. 2021-07-10 !!!
+                     time:     match.time,  # assume iso format as string e.g. 21:00 !!!
+                    
+                     score1ft:   match.score1,
+                     score2ft:   match.score2,
+                     score1ht:  match.score1i,
+                     score2ht:  match.score2i,
+                    
+                     score1et: match.score1et,
+                     score2et: match.score2et,
+                     score1p:  match.score1p,
+                     score2p:  match.score2p,
+                     status:   match.status }
+
+         attribs[ :event_round_id ] = round_rec.id   if round_rec
+        
+         rec = Model::Match.create!( attribs )
+        rec
+    end
+  end # class Match
+
+end # module Sync
+end # module SportDbV2

data/lib/sportdb/models_v2/version.rb

@@ -0,0 +1,27 @@
+module SportDbV2
+module Module
+module Models
+  MAJOR = 0
+  MINOR = 0
+  PATCH = 1
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "sportdb-models_v2/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+  end
+
+  def self.root
+    File.expand_path( File.dirname(File.dirname(File.dirname(File.dirname(__FILE__)))) )
+  end
+end  # module Models
+end  # module Module
+
+#################
+## add convenience shortcuts
+VERSION = Module::Models::VERSION
+end  # module SportDbV2
+

data/lib/sportdb/models_v2.rb

@@ -0,0 +1,233 @@
+require 'cocos'
+
+
+require 'props'           # see github.com/rubylibs/props
+require 'logutils'        # see github.com/rubylibs/logutils
+
+require 'active_record'   ## todo: add sqlite3? etc.
+
+## add more activerecords addons/utils
+##  -- require 'tagutils'
+require 'activerecord/utils'    ### check what used for what??
+require 'props/activerecord'      # includes ConfDb (ConfDb::Model::Prop, etc.)
+require 'logutils/activerecord'   # includes LogDb (LogDb::Model::Log, etc.)
+
+
+### pull-in  sportdb parser machinery
+require  'sportdb/quick'
+
+######
+## add V2 references (from "V1")
+module SportDbV2
+  Logging               = SportDb::Logging
+  QuickLeagueOutline    = SportDb::QuickLeagueOutline
+  MatchParser           = SportDb::MatchParser
+end  # module SportDbV2
+
+
+
+
+# our own code
+require_relative 'models_v2/version'    # let version always go first
+
+=begin
+require_relative 'models/formats'
+
+require_relative 'models/models/world/city'
+require_relative 'models/models/world/country'
+require_relative 'models/models/world/continent'
+require_relative 'models/models/world/state'
+
+require_relative 'models/models/assoc'
+require_relative 'models/models/badge'
+require_relative 'models/models/goal'
+require_relative 'models/models/ground'
+require_relative 'models/models/group'
+require_relative 'models/models/lineup'
+require_relative 'models/models/person'
+require_relative 'models/models/round'
+require_relative 'models/models/season'
+require_relative 'models/models/stage'
+=end
+
+
+require_relative 'models_v2/models/forward'
+require_relative 'models_v2/models/event'
+require_relative 'models_v2/models/league'
+require_relative 'models_v2/models/match'
+
+require_relative 'models_v2/models/team'
+
+require_relative 'models_v2/schema'       # note: requires sportdb/models (include SportDB::Models)
+
+
+require_relative 'models_v2/deleter'
+require_relative 'models_v2/stats'
+
+####
+#   pull in reader & friends
+require_relative 'models_v2/match_reader'
+
+
+require_relative 'models_v2/sync/league'
+require_relative 'models_v2/sync/event'
+require_relative 'models_v2/sync/match'
+
+
+
+####
+#  more db machinery
+
+module SportDbV2
+
+  def self.create
+    CreateDb.new.up
+    ConfDb::Model::Prop.create!( key: 'db.schema.sport_v2.version', value: VERSION )
+  end
+
+  def self.create_all
+    ## build schema - convenience helper
+    LogDb.create
+    ConfDb.create
+    SportDbV2.create
+  end
+
+  def self.auto_migrate!
+    ### todo/fix:
+    ##    check props table and versions!!!!!
+
+    # first time? - auto-run db migratation, that is, create db tables
+    unless LogDb::Model::Log.table_exists?
+      LogDb.create     # add logs table
+    end
+
+    unless ConfDb::Model::Prop.table_exists?
+      ConfDb.create    # add props table
+    end
+
+    unless SportDbV2::Model::League.table_exists?
+      SportDbV2.create
+    end
+  end # method auto_migrate!
+
+=begin
+  # delete ALL records (use with care!)
+  def self.delete!
+    puts '*** deleting sport table records/data...'
+    Deleter.new.run
+  end # method delete!
+=end
+
+  def self.tables
+    Stats.new.tables
+  end
+
+
+  ###  use/change to **config - to allow "inline" conif with keywords
+  ##          (without enclosing {}) - why? why not?
+  def self.connect!( config={} )  # convenience shortcut w/ automigrate
+    connect( config )
+    auto_migrate!
+  end
+
+  def self.connect( config={} )
+    if 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' )
+
+      config =  if db.scheme == 'postgres'
+                    { adapter: 'postgresql',
+                      host:     db.host,
+                      port:     db.port,
+                      username: db.user,
+                      password: db.password,
+                      database: db.path[1..-1],
+                      encoding: 'utf8'
+                    }
+                  else # assume sqlite3
+                    { adapter:  db.scheme,       # sqlite3
+                      database: db.path[1..-1]   # sport.db (NB: cut off leading /, thus 1..-1)
+                    }
+                  end
+    else
+      ## note: for compatibility lets you also pass-in/use string keys
+      ##   e.g. YAML.load uses/returns always string keys - always auto-convert to symbols
+      config = config.symbolize_keys
+    end
+
+
+    ## todo/check/fix: move jruby "hack" to attic - why? why not?
+    ## 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 )
+
+    ## if sqlite3 add (use) some pragmas for speedups
+    if config[:adapter]  == 'sqlite3'  &&
+       config[:database] != ':memory:'
+      ## note: if in memory database e.g. ':memory:' no pragma needed!!
+      ## try to speed up sqlite
+      ##   see http://www.sqlite.org/pragma.html
+      con = ActiveRecord::Base.connection
+      con.execute( 'PRAGMA synchronous=OFF;' )
+      con.execute( 'PRAGMA journal_mode=OFF;' )
+      con.execute( 'PRAGMA temp_store=MEMORY;' )
+    end
+  end
+
+
+
+  def self.open( path )  ## shortcut for sqlite only
+    config = {
+      adapter:  'sqlite3',
+      database: path  # e.g. ':memory', './sport.db'
+    }
+    connect!( config )
+  end
+
+  def self.setup_in_memory_db
+    # Database Setup & Config
+    ##  add logger as option - why? why not?
+    ##  e.g.  open_mem( logger: true ) or
+    ##         always possible to add logger "manually" before 
+    ##         thus, no need for option/flag really ??
+    ## ActiveRecord::Base.logger = Logger.new( STDOUT )
+    ## ActiveRecord::Base.colorize_logging = false  - no longer exists - check new api/config setting?
+   
+    config = {
+      adapter:  'sqlite3',
+      database: ':memory:'
+    }
+    connect( config )
+
+    ## build schema
+    create_all
+  end # setup_in_memory_db (using SQLite :memory:)
+
+
+  ###########
+  #   add more aliases/alt names for in memory db - why? why not?
+  ##    rename to open_mem for canonical name - why? why not?
+  class << self
+     alias_method :open_mem,       :setup_in_memory_db
+     alias_method :open_memory,    :setup_in_memory_db
+     alias_method :open_in_memory, :setup_in_memory_db
+  end
+end  # module SportDb
+
+
+## say hello
+puts SportDbV2::Module::Models.banner
+
+

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: sportdb-models_v2
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cocos
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: props-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logutils-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sportdb-quick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: sportdb-models_v2 - sport.db schema 'n' models for easy (re)use
+email: gerald.bauer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/sportdb/models_v2.rb
+- lib/sportdb/models_v2/deleter.rb
+- lib/sportdb/models_v2/match_reader.rb
+- lib/sportdb/models_v2/models/event.rb
+- lib/sportdb/models_v2/models/forward.rb
+- lib/sportdb/models_v2/models/league.rb
+- lib/sportdb/models_v2/models/match.rb
+- lib/sportdb/models_v2/models/team.rb
+- lib/sportdb/models_v2/schema.rb
+- lib/sportdb/models_v2/stats.rb
+- lib/sportdb/models_v2/sync/event.rb
+- lib/sportdb/models_v2/sync/league.rb
+- lib/sportdb/models_v2/sync/match.rb
+- lib/sportdb/models_v2/version.rb
+homepage: https://github.com/sportdb/sport.db
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: sportdb-models_v2 - sport.db schema 'n' models for easy (re)use
+test_files: []