sportdb-quick 0.0.1

data/lib/sportdb/quick/opts.rb

@@ -0,0 +1,70 @@
+
+module SportDb
+module Quick
+
+###
+## note - Opts Helpers for now nested inside Parser - keep here? why? why not?
+class Opts
+
+    SEASON_RE = %r{ (?:
+                       \d{4}-\d{2}
+                     | \d{4}(--[a-z0-9_-]+)?
+                    )
+                  }x
+    SEASON = SEASON_RE.source    ## "inline" helper for embedding in other regexes - keep? why? why not?
+
+
+    ## note: if pattern includes directory add here
+    ##     (otherwise move to more "generic" datafile) - why? why not?
+    MATCH_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
+                       #{SEASON}
+                     /[a-z0-9_-]+\.txt$  ## txt e.g /1-premierleague.txt
+                }x
+
+
+def self.find( path )
+    datafiles = []
+
+    ## note: normalize path - use File.expand_path ??
+    ##    change all backslash to slash for now
+    ## path = path.gsub( "\\", '/' )
+    path = File.expand_path( path )
+
+    ## check all txt files
+    ## note: incl. files starting with dot (.)) as candidates
+    ##     (normally excluded with just *)
+    candidates = Dir.glob( "#{path}/**/{*,.*}.txt" )
+    ## pp candidates
+    candidates.each do |candidate|
+      datafiles << candidate    if MATCH_RE.match( candidate )
+    end
+
+    ## pp datafiles
+    datafiles
+end
+
+
+def self.expand_args( args )
+    paths = []
+
+    args.each do |arg|
+        ## check if directory
+        if Dir.exist?( arg )
+            datafiles = find( arg )
+            puts
+            puts "  found #{datafiles.size} match txt datafiles in #{arg}"
+            pp datafiles
+            paths += datafiles
+        else
+              ## assume it's a file
+            paths << arg
+        end
+    end
+
+    paths
+end
+end  # class Opts
+
+
+end   # module Quick
+end   # module SportDb

data/lib/sportdb/quick/outline_reader.rb

@@ -0,0 +1,97 @@
+
+
+module SportDb
+
+class OutlineReader
+
+  def self.debug=(value) @@debug = value; end
+  def self.debug?() @@debug ||= false; end
+  def debug?()  self.class.debug?; end
+
+
+
+  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
+
+  def initialize( txt )
+    @txt = txt
+  end
+
+  ## note: skip "decorative" only heading e.g. ========
+  ##  todo/check:  find a better name e.g. HEADING_EMPTY_RE or HEADING_LINE_RE or ???
+  HEADING_BLANK_RE = %r{\A
+                        ={1,}
+                        \z}x
+
+  ## note: like in wikimedia markup (and markdown) all optional trailing ==== too
+  HEADING_RE = %r{\A
+                  (?<marker>={1,})       ## 1. leading ======
+                    [ ]*
+                  (?<text>[^=]+)         ## 2. text   (note: for now no "inline" = allowed)
+                    [ ]*
+                    =*                   ## 3. (optional) trailing ====
+                  \z}x
+
+  def parse
+    outline=[]   ## outline structure
+    start_para = true      ## start new para(graph) on new text line?
+
+    @txt.each_line do |line|
+        line = line.strip      ## todo/fix: keep leading and trailing spaces - why? why not?
+
+        if line.empty?    ## todo/fix: keep blank line nodes?? and just remove comments and process headings?! - why? why not?
+          start_para = true
+          next
+        end
+
+        break if line == '__END__'
+
+        next if line.start_with?( '#' )   ## skip comments too
+        ## strip inline (until end-of-line) comments too
+        ##  e.g Eupen | KAS Eupen ## [de]
+        ##   => Eupen | KAS Eupen
+        ##  e.g bq   Bonaire,  BOE        # CONCACAF
+        ##   => bq   Bonaire,  BOE
+        line = line.sub( /#.*/, '' ).strip
+        pp line    if debug?
+
+        ## todo/check: also use heading blank as paragraph "breaker" or treat it like a comment ?? - why? why not?
+        next if HEADING_BLANK_RE.match( line )  # skip "decorative" only heading e.g. ========
+
+         ## note: like in wikimedia markup (and markdown) all optional trailing ==== too
+        if m=HEADING_RE.match( line )
+           start_para = true
+
+           heading_marker = m[:marker]
+           heading_level  = heading_marker.length   ## count number of = for heading level
+           heading        = m[:text].strip
+
+           puts "heading #{heading_level} >#{heading}<"   if debug?
+           outline << [:"h#{heading_level}", heading]
+        else    ## assume it's a (plain/regular) text line
+           if start_para
+             outline << [:p, [line]]
+             start_para = false
+           else
+             node = outline[-1]    ## get last entry
+             if node[0] == :p      ##  assert it's a p(aragraph) node!!!
+                node[1] << line    ## add line to p(aragraph)
+             else
+               puts "!! ERROR - invalid outline state / format - expected p(aragraph) node; got:"
+               pp node
+               exit 1
+             end
+           end
+        end
+    end
+    outline
+  end # method read
+end # class OutlineReader
+
+end # module SportDb

data/lib/sportdb/quick/quick_league_outline_reader.rb

@@ -0,0 +1,85 @@
+
+
+module SportDb
+
+## shared "higher-level" outline reader
+###   quick version WITHOUT any validation/mapping !!!
+
+class QuickLeagueOutlineReader
+
+  def self.read( path )
+    txt = File.open( path, 'r:utf-8' ) {|f| f.read }
+    parse( txt )
+  end
+
+  def self.parse( txt )
+    new( txt ).parse
+  end
+
+
+  def initialize( txt )
+    @txt = txt
+  end
+
+  def parse
+    secs=[]     # sec(tion)s
+    OutlineReader.parse( @txt ).each do |node|
+      if node[0] == :h1
+        ## check for league (and stage) and season
+        heading = node[1]
+        values = split_league( heading )
+        if m=values[0].match( LEAGUE_SEASON_HEADING_RE )
+          puts "league >#{m[:league]}<, season >#{m[:season]}<"
+
+           secs << { league: m[:league],
+                     season: m[:season],
+                     stage:  values[1],     ## note: defaults to nil if not present
+                     lines:  []
+                   }
+        else
+          puts "** !!! ERROR - cannot match league and season in heading; season missing?"
+          pp heading
+          exit 1
+        end
+      elsif node[0] == :p   ## paragraph with (text) lines
+        lines = node[1]
+        ## note: skip lines if no heading seen
+        if secs.empty?
+          puts "** !!! WARN - skipping lines (no heading):"
+          pp lines
+        else
+          ## todo/check: unroll paragraphs into lines or pass along paragraphs - why? why not?
+          secs[-1][:lines] += lines
+        end
+      else
+        puts "** !!! ERROR - unknown line type; for now only heading 1 for leagues supported; sorry:"
+        pp node
+        exit 1
+      end
+    end
+    secs
+  end # method parse
+
+
+  ## split into league + season
+  ##  e.g. Österr. Bundesliga 2015/16   ## or 2015-16
+  ##       World Cup 2018
+  LEAGUE_SEASON_HEADING_RE =  %r{^
+         (?<league>.+?)     ## non-greedy
+            \s+
+         (?<season>\d{4}
+            (?:[\/-]\d{1,4})?     ## optional 2nd year in season
+         )
+            $}x
+
+  def split_league( str )   ## todo/check: rename to parse_league(s) - why? why not?
+    ## split into league / stage / ... e.g.
+    ##  => Österr. Bundesliga 2018/19, Regular Season
+    ##  => Österr. Bundesliga 2018/19, Championship Round
+    ##  etc.
+    values = str.split( /[,<>‹›]/ )  ## note: allow , > < or › ‹ for now
+    values = values.map { |value| value.strip }   ## remove all whitespaces
+    values
+  end
+ end # class QuickLeagueOutlineReader
+end # module SportDb

data/lib/sportdb/quick/quick_match_reader.rb

@@ -0,0 +1,95 @@
+#####
+## quick match reader for datafiles with league outlines
+
+module SportDb
+class QuickMatchReader
+
+  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 )
+    @txt = txt
+  end
+
+  def parse
+    data = {}   # return data hash with leagues
+                #    and seasons
+                #   for now merge stage into matches
+
+    secs = QuickLeagueOutlineReader.parse( @txt )
+    pp secs
+
+    secs.each do |sec|   ## sec(tion)s
+      season = Season.parse( sec[:season] )   ## convert (str) to season obj!!!
+      league = sec[:league]
+      stage  = sec[:stage]
+      lines  = sec[:lines]
+
+      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
+
+      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
+
+      ## note: pass along stage (if present): stage  - optional from heading!!!!
+      if stage
+        matches.each do |match|
+          match = match.update( stage: stage )
+        end
+      end
+
+      data[ league ] ||= {}
+      data[ league ][ season.key ] ||= []
+
+      data[ league ][ season.key ] += matches
+      ## note - skip teams, rounds, and groups for now
+    end
+
+## check - only one league and one season
+##             allowed in quick style
+
+
+    leagues = data.keys
+    if leagues.size != 1
+        puts "!! (QUICK) PARSE ERROR - expected one league only; got #{leagues.size}:"
+        pp leagues
+        exit 1
+    end
+
+    seasons = data[ leagues[0] ].keys
+    if seasons.size != 1
+        puts "!! (QUICK) PARSE ERROR - expected one #{leagues[0]} season only; got #{seasons.size}:"
+        pp seasons
+        exit 1
+    end
+
+    data[ leagues[0] ][ seasons[0] ]
+  end # method parse
+
+end # class QuickMatchReader
+end # module SportDb
+

data/lib/sportdb/quick/version.rb

@@ -0,0 +1,24 @@
+
+module SportDb
+  module Module
+    module Quick
+  MAJOR = 0    ## todo: namespace inside version or something - why? why not??
+  MINOR = 0
+  PATCH = 1
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "sportdb-quick/#{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 Quick
+  end
+end

data/lib/sportdb/quick.rb

@@ -0,0 +1,31 @@
+require 'sportdb/structs'  # deps:  score-foramts
+                           #         season-formats
+                           #         alphabets
+require 'sportdb/parser'   # deps:   cocos
+                           #         season-formats
+
+
+
+require 'logutils'
+module SportDb
+  ## logging machinery shortcut; use LogUtils for now
+  Logging = LogUtils::Logging
+end
+
+
+
+## our own code
+require_relative 'quick/version'
+require_relative 'quick/opts'
+require_relative 'quick/linter'
+require_relative 'quick/outline_reader'
+
+require_relative 'quick/match_parser'
+
+require_relative 'quick/quick_league_outline_reader'
+require_relative 'quick/quick_match_reader'
+
+
+puts SportDb::Module::Quick.banner    # say hello
+
+

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: sportdb-quick
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sportdb-parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: sportdb-structs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: logutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !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.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+description: sportdb-quick - football.txt (quick) match parsers and more
+email: gerald.bauer@gmail.com
+executables:
+- fbt
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- bin/fbt
+- lib/sportdb/quick.rb
+- lib/sportdb/quick/linter.rb
+- lib/sportdb/quick/match_parser.rb
+- lib/sportdb/quick/opts.rb
+- lib/sportdb/quick/outline_reader.rb
+- lib/sportdb/quick/quick_league_outline_reader.rb
+- lib/sportdb/quick/quick_match_reader.rb
+- lib/sportdb/quick/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.4.10
+signing_key:
+specification_version: 4
+summary: sportdb-quick - football.txt (quick) match parsers and more
+test_files: []