sportdb-quick 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f2ce8e81bd6aece43872ba2718123dd2b34d6f52807ab8260a2e91f01a8c28ed
+  data.tar.gz: c91175dabbac6e590198df83151ee36d9a9daa853b77f0eedfa229f9db55edd0
+SHA512:
+  metadata.gz: 53f5ca14405552fe662d35e6b1d1672afce956f27cc40801265a9f9d44a4d622b320a00a5ba935a04bae0453872ecb0da27b21927b184a87ed2755973eef118b
+  data.tar.gz: a688b66358bf16ec13ccbb90b5e29eaf483ca3e69f64ca4816f7210038383ea002660fa62a8ac971e9764903490757c9a84864bf57075794d8e0a337970a55b4

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2024-08-27
+
+* Everything is new. First release.

data/Manifest.txt

@@ -0,0 +1,13 @@
+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

data/README.md

@@ -0,0 +1,5 @@
+# sportdb-quick - football.txt (quick) match parsers and more
+
+
+
+

data/Rakefile

@@ -0,0 +1,32 @@
+require 'hoe'
+require './lib/sportdb/quick/version.rb'
+
+
+Hoe.spec 'sportdb-quick' do
+
+  self.version = SportDb::Module::Quick::VERSION
+
+  self.summary = "sportdb-quick - football.txt (quick) match parsers and more"
+  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
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.licenses = ['Public Domain']
+
+  self.extra_deps = [
+       ['sportdb-parser',  '>= 0.2.2'],
+       ['sportdb-structs', '>= 0.4.0'],
+       ['logutils',        '>= 0.6.1'],
+  ]
+
+  self.spec_extras = {
+    required_ruby_version: '>= 3.1.0'
+  }
+end

data/bin/fbt

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+## tip: to test run:
+##   ruby -I ./lib bin/fbt
+##     -or-
+##   ruby -I ../parser/lib -I ./lib bin/fbt
+##     -or-
+##   ruby -I ../parser/lib -I ../sportdb-structs/lib -I ./lib bin/fbt
+
+
+## our own code
+require 'sportdb/quick'
+
+
+
+require 'optparse'
+
+##
+## read textfile
+##   and dump tokens
+##
+##   fbt  ../openfootball/.../euro.txt
+
+
+
+
+ args = ARGV
+ opts = { debug: false,
+          metal: false,
+          quick: false }
+
+ parser = OptionParser.new do |parser|
+  parser.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+##
+## check if git has a offline option?? (use same)
+##             check for other tools - why? why not?
+
+
+  parser.on( "--verbose", "--debug",
+               "turn on verbose / debug output (default: #{opts[:debug]})" ) do |debug|
+    opts[:debug] = debug
+  end
+
+  parser.on( "--metal",
+                 "turn off typed parse tree; show to the metal tokens"+
+                   " (default: #{opts[:metal]})" ) do |metal|
+    opts[:metal] = metal
+  end
+
+  parser.on( "--quick",
+                "use quick match reader; output matches in json"+
+                   " (default: #{opts[:quick]})" ) do |quick|
+     opts[:quick] = quick
+  end
+end
+parser.parse!( args )
+
+puts "OPTS:"
+p opts
+puts "ARGV:"
+p args
+
+
+
+
+
+paths =  if args.empty?
+            [
+              '../../../openfootball/euro/2021--europe/euro.txt',
+              '../../../openfootball/euro/2024--germany/euro.txt',
+            ]
+         else
+            ## check for directories
+            ##   and auto-expand
+
+            SportDb::Quick::Opts.expand_args( args )
+         end
+
+
+if opts[:quick]
+
+  paths.each_with_index do |path,i|
+    puts "==> [#{i+1}/#{paths.size}] reading >#{path}<..."
+
+    matches = SportDb::QuickMatchReader.read( path )
+    ## pp matches
+    ##  try json for matches
+    data = matches.map {|match| match.as_json }
+    pp data
+    puts
+    puts "  #{data.size} match(es)"
+  end
+else
+  SportDb::Quick::Linter.debug = true    if opts[:debug]
+
+  linter = SportDb::Quick::Linter.new
+
+  errors = []
+
+  paths.each_with_index do |path,i|
+    puts "==> [#{i+1}/#{paths.size}] reading >#{path}<..."
+    linter.read( path, parse: !opts[:metal] )
+
+    errors += linter.errors    if linter.errors?
+  end
+
+  if errors.size > 0
+    puts
+    pp errors
+    puts
+    puts "!!   #{errors.size} parse error(s) in #{paths.size} datafiles(s)"
+  else
+    puts
+    puts "OK   no parse errors found in #{paths.size} datafile(s)"
+  end
+end
+
+
+puts "bye"
+

data/lib/sportdb/quick/linter.rb

@@ -0,0 +1,149 @@
+
+module SportDb
+module Quick
+
+###
+## note - Linter for now nested inside Parser - keep? why? why not?
+class Linter
+
+def self.debug=(value) @@debug = value; end
+def self.debug?() @@debug ||= false; end  ## note: default is FALSE
+def debug?()  self.class.debug?; end
+
+
+
+attr_reader :errors
+
+def initialize
+  @errors = []
+  @parser = Parser.new   ## use own parser instance (not shared) - why? why not?
+end
+
+
+def errors?() @errors.size > 0; end
+
+
+
+  ## note:  colon (:) MUST be followed by one (or more) spaces
+  ##      make sure mon feb 12 18:10 will not match
+  ##        allow 1. FC Köln etc.
+  ##               Mainz 05:
+  ##           limit to 30 chars max
+  ##          only allow  chars incl. intl buut (NOT ()[]/;)
+  ##
+  ##   Group A:
+  ##   Group B:   - remove colon
+  ##    or lookup first
+
+  ATTRIB_RE = %r{^
+                   [ ]*?     # slurp leading spaces
+                (?<key>[^:|\]\[()\/; -]
+                       [^:|\]\[()\/;]{0,30}
+                 )
+                   [ ]*?     # slurp trailing spaces
+                   :[ ]+
+                (?<value>.+)
+                    [ ]*?   # slurp trailing spaces
+                   $
+                }ix
+
+
+#########
+## parse - false (default) - tokenize (only)
+##       - true            - tokenize & parse
+def read( path, parse: false )
+  ## note: every (new) read call - resets errors list to empty
+  @errors = []
+
+  nodes = OutlineReader.read( path )
+
+  ##  process nodes
+  h1 = nil
+  orphans = 0    ## track paragraphs's with no heading
+
+  attrib_found = false
+
+
+  nodes.each do |node|
+    type = node[0]
+
+    if type == :h1
+        h1 = node[1]  ## get heading text
+        puts
+        puts "  = Heading 1 >#{node[1]}<"
+    elsif type == :p
+
+       if h1.nil?
+         orphans += 1    ## only warn once
+         puts "!! WARN - no heading for #{orphans} text paragraph(s); skipping parse"
+         next
+       end
+
+       lines = node[1]
+
+       tree = []
+       lines.each_with_index do |line,i|
+
+        if debug?
+         puts
+         puts "line >#{line}<"
+        end
+
+
+        ## skip new (experimental attrib syntax)
+        if attrib_found == false &&
+            ATTRIB_RE.match?( line )
+          ## note: check attrib regex AFTER group def e.g.:
+          ##         Group A:
+          ##         Group B:  etc.
+          ##     todo/fix - change Group A: to Group A etc.
+          ##                       Group B: to Group B
+           attrib_found = true
+           ## logger.debug "skipping key/value line - >#{line}<"
+           next
+        end
+
+        if attrib_found
+          ## check if line ends with dot
+          ##  if not slurp up lines to the next do!!!
+          ## logger.debug "skipping key/value line - >#{line}<"
+          attrib_found = false   if line.end_with?( '.' )
+              # logger.debug "skipping key/value line (cont.) - >#{line}<"
+              next
+        end
+
+        t, error_messages  =  if parse
+                                  @parser.parse_with_errors( line )
+                              else
+                                  @parser.tokenize_with_errors( line )
+                              end
+
+
+         if error_messages.size > 0
+            ## add to "global" error list
+            ##   make a triplet tuple (file / msg / line text)
+            error_messages.each do |msg|
+                @errors << [ path,
+                             msg,
+                             line
+                           ]
+            end
+         end
+
+         pp t   if debug?
+
+         tree << t
+       end
+
+       ## pp tree
+    else
+        pp node
+        raise ArgumentError, "unsupported (node) type >#{type}<"
+    end
+  end  # each node
+end  # read
+end  # class Linter
+
+
+end   # module Quick
+end   # module SportDb