Module: Fbtree

Defined in:
lib/fbtok/command-fbtree.rb

Class Method Summary collapse

Class Method Details

.dump_tree_stats(tree) ⇒ Object 



171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/fbtok/command-fbtree.rb', line 171

def self.dump_tree_stats( tree )
  stats = Hash.new(0)  ## track counts only for now
  tree.each do |node|
     stats[ node.class ] += 1
  end

  match_count  = stats[ RaccMatchParser::MatchLine ]
  goal_count   = stats[ RaccMatchParser::GoalLine ]
  lineup_count = stats[ RaccMatchParser::LineupLine ]

  puts "   #{match_count} MatchLine(s)"     if match_count > 0
  puts "   #{goal_count} GoalLine(s)"       if goal_count > 0
  puts "   #{lineup_count} LineupLine(s)"   if lineup_count > 0
end

.main(args = ARGV) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/fbtok/command-fbtree.rb', line 4

def self.main( args=ARGV )


opts = {
    debug: true,
    file:  nil,
    seasons: [],
##    warn:  false,
}

parser = OptionParser.new do |parser|
  parser.banner = "Usage: #{$PROGRAM_NAME} [options] DATAFILE or DIR"


  parser.on( "-q", "--quiet",
             "less debug output/messages (default: #{!opts[:debug]})" ) do |debug|
    opts[:debug] = false
  end
  parser.on( "--verbose", "--debug",
               "turn on verbose / debug output (default: #{opts[:debug]})" ) do |debug|
    opts[:debug] = true
  end
#  parser.on( "-w", "--warn",
#              "turn warnings into errors (default: #{opts[:warn]})" ) do |warn|
#    opts[:warn] = true
#  end


  parser.on( "--seasons SEASONS",
               "filter by seasons (default: #{opts[:seasons]})") do |seasons|
    opts[:seasons] = seasons
                        .split( /[,:]/ )
                        .map { |season| Season.parse(season.strip) }
  end

  parser.on( "-f FILE", "--file FILE",
                "read datafiles (pathspecs) via .csv file") do |file|
    opts[:file] = file
    ## note: for batch (massive) processing auto-set debug (verbose output) to false (as default)
    opts[:debug] = false
  end

end
parser.parse!( args )

if opts[:debug]
  puts "OPTS:"
  p opts
  puts "ARGV:"
  p args
end






## todo/check - use packs or projects or such
##                instead of specs - why? why not?
specs =  if opts[:file]
            read_pathspecs( opts[:file] )
         else
            ## check for filepack
            filepack =  if File.file?( './filepack.txt')
                            read_filepack( './filepack.txt' )
                        else
                             nil
                        end

            path = SportDb::Pathspec.path(
                          ['/sports/sportdb/sport.db.v2/parser/fbtxt-specs',
                           '/sports/sportdb/sport.db.v2/parser/fbtxt-samples',
                           '/sports/openfootball'])

            build_pathspecs( args, path: path,
                                   filepack: filepack )
         end



## if more than single datafile
##     auto-switch into quite mode for now
## if specs.size > 0  && specs[0]['datafiles'].size > 1
##   opts[:debug] = false
## end

# SportDb::Parser::Linter.debug = opts[:debug]
# SportDb::Parser::Linter.warn  = opts[:warn]



if opts[:seasons].size > 0
   specs = filter_pathspecs( specs, seasons: opts[:seasons] )
end



specs.each_with_index do |rec,i|
    datafiles = rec['datafiles']

    errors = []
    log    = []   ## quick one-line summary per datafile

   datafiles.each_with_index do |path,j|
      puts "==> [#{i+1}/#{specs.size}, #{j+1}/#{datafiles.size}] reading >#{path}<..."

      txt = read_text( path )
      parser = RaccMatchParser.new( txt, debug: opts[:debug] )
      tree = parser.parse

      dump_tree_stats( tree )

      if parser.errors?
         ## note - auto-add filename to errors
         parser.errors.each do |msg|
          ###
          ###   errors << [ path, *msg ] # note: use splat (*) to add extra values (starting with msg)
              errors << [path, msg]
         end

         log << [:ERROR, path, "#{parser.errors.size} parse error(s), #{tree.size} tree node(s)"]
      else
         log << [:OK, path, "#{tree.size} tree node(s)"]
      end
   end


   if errors.size > 0
      puts
      pp errors
      puts
      puts
      pp log
      puts "!!   #{errors.size} parse error(s) in #{datafiles.size} datafiles(s)"
   else
      puts
      pp log
      puts "OK   no parse errors found in #{datafiles.size} datafile(s)"
   end

   ## add errors to rec via rec['errors'] to allow
   ##   for further processing/reporting
   rec['errors'] = errors
end


###
## generate a report if --file option used
if opts[:file]

  buf = SportDb::PathspecReport.new(
            specs,
            title: 'fbtree summary report' ).build

  puts
  puts "SUMMARY:"
  puts buf

  #  maybe write out in the future?
  # basedir  = File.dirname( opts[:file] )
  # basename = File.basename( opts[:file], File.extname( opts[:file] ))
end

puts "bye"
end