gooby 1.1.0 → 1.2.0

data/lib/gooby_code_scanner.rb

@@ -0,0 +1,288 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+  class CodeScanner < GoobyObject 
+         
+    def initialize(argv)
+
+      function = 'outline'
+      if (argv.size > 1)
+        function = argv[1]
+      end
+            
+      @code_file  = argv[0]
+      @test_file  = "ts_#{@code_file}"
+      @code_lines = read_lines("lib/#{@code_file}") 
+      @test_lines = read_lines("tests/#{@test_file}") 
+      
+      puts "code lines = #{@code_lines.size}" 
+      puts "test lines = #{@test_lines.size}"
+
+      @tokens_hash       = CounterHash.new      
+      @module_names_hash = CounterHash.new 
+      @class_names_hash  = CounterHash.new
+      @method_names_hash = CounterHash.new
+      @mc_line_num_array = Array.new
+      @type_names        = Hash.new      
+      @code_hash         = Hash.new
+      @test_hash         = Hash.new
+      @api_hash          = Hash.new
+      @merged_hash       = Hash.new
+      @exclude_classes   = Array.new 
+                        
+      regenerate_test_suite  if (function == 'regenerate_test_suite')
+      regenerate_test_suite  if (function == 'tests') 
+
+      model_class_outline    if (function == 'model_class_outline')  
+      model_class_outline    if (function == 'outline')  
+               
+      quick_reference_guide  if (function == 'quick_reference_guide')      
+      quick_reference_guide  if (function == 'qrg')   
+      
+      mcm_references         if (function == 'mcm_references')  
+      mcm_references         if (function == 'mcm') 
+    end 
+
+    private
+    
+    def regenerate_test_suite
+      @exclude_classes = %w( TestHelper CodeScanner )    
+      parse_code_lines
+      parse_test_lines    
+      merge_keys
+      regenerate(@test_file)
+    end
+    
+    def model_class_outline
+      parse_code_lines     
+      @mc_line_num_array.each { |line|
+        tokens = tokenize(line)
+        type  = tokens[0].ljust(6)
+        name  = tokens[1]
+        count = tokens[2].rjust(6)
+        #puts "  #{count}  #{type}  #{name}"   
+        puts "cp gooby.rb gooby_#{name.downcase}.rb"
+      }
+      puts hello
+    end
+      
+    def quick_reference_guide
+      parse_code_lines
+      determine_longest_names
+      quick_reference_guide_report('module')
+      quick_reference_guide_report('class')
+    end
+  
+    def quick_reference_guide_report(obj_type)
+      @api_hash.keys.sort.each { |key| 
+        val = @api_hash[key]
+        tokens = tokenize(key, '|')
+        if (tokens[0] == obj_type)
+          s1 = tokens[0].ljust(6)
+          s2 = tokens[1].ljust(@longest_classname + 1)
+          s3 = tokens[2]
+          # s = sprintf("%6s '%30s %s'", tokens[0], tokens[1], tokens[2])
+          puts "#{s1} #{s2} #{s3}"
+        end
+      }
+    end
+    
+    def determine_longest_names
+      @longest_classname = 0
+      @api_hash.keys.sort.each { |key| 
+        tokens = tokenize(@api_hash[key], '|')
+        @longest_classname = tokens[1].size  if tokens[1].size > @longest_classname
+      }     
+    end
+        
+    def mcm_references
+      parse_code_lines
+      determine_longest_names      
+      @module_names_hash.sorted_keys.each { |name|
+        count = @tokens_hash.value(name)
+        puts "module: #{name}   (#{count})" 
+      }
+      @class_names_hash.sorted_keys.each { |name|
+        count = @tokens_hash.value(name)
+        puts "class:  #{name}   (#{count})" 
+      }
+      @method_names_hash.sorted_keys.each { |name|
+        count = @tokens_hash.value(name)
+        puts "method: #{name}   (#{count})" 
+      }  
+    end
+  
+    def parse_code_lines
+      type      = ''
+      type_name = ''
+      meth_name = '' 
+      line_number = 0   
+      @code_lines.each { | line | 
+        line_number = line_number + 1
+        line.strip!
+        if (line.match(/^module /))
+          type      = 'module'
+          tokens    = line.split
+          type_name = tokens[1]  
+          @module_names_hash.increment(type_name)  
+          @mc_line_num_array << "module #{type_name} #{line_number}"       
+        elsif (line.match(/^class /))
+          type      = 'class'
+          tokens    = line.split
+          type_name = tokens[1]   
+          @class_names_hash.increment(type_name)   
+          @mc_line_num_array << "class #{type_name} #{line_number}"                            
+        elsif (line.match(/^def /))
+          signature = line[4...999]
+          short_method = parse_meth_name("#{signature}")
+          @code_hash["test_#{type}_#{type_name}"] = "#{type_name}"          
+          @code_hash["test_#{type}_#{type_name}_#{short_method}"] = "#{type_name}|#{signature}"  
+          @api_hash["#{type}|#{type_name}|#{signature}" ] = "#{type}|#{type_name}|#{signature}" 
+          @method_names_hash.increment(short_method)                                 
+        end 
+        increment_tokens(line)       
+      }          
+    end 
+    
+    def increment_tokens(line)
+      # see http://www.asciitable.com/
+      s = ''
+      line.each_byte { |b|
+        keep = false
+        keep = true if ((b >= 65) && (b <= 90))  # A-Z
+        keep = true if ((b >= 97) && (b <= 122)) # a-z
+        keep = true if ((b >= 48) && (b <= 57))  # 0-9
+        keep = true if (b == 95) # _
+        keep = true if (b == 64) # @
+        keep = true if (b == 63) # ?
+        keep = true if (b == 33) # !        
+        if keep
+          s << b.chr
+        else
+          s << ' '
+        end        
+      } 
+      @tokens_hash.increment_tokens(s)        
+    end
+
+    def parse_meth_name(string)
+      string.gsub!('(', ' ')
+      string.gsub!(')', ' ')    
+      tokens = string.split
+      tokens[0]
+    end
+  
+    def parse_test_lines
+      in_zone      = true
+      method_name  = 'a_start'
+      method_lines = Array.new
+      line_num = 0
+    
+      @test_lines.each { | line | 
+        line_num = line_num + 1  
+        line.chomp!
+        prefix   = line[0...5]   # '  def' or '   end' 
+        prefix42 = line [0..42]        
+            
+        if ((prefix == '  def') || (prefix == "\tdef"))
+          in_zone      = true 
+          tokens       = line.split
+          method_name  = tokens[1] 
+          method_lines = Array.new   
+        end
+                
+        if in_zone
+          method_lines << "#{line}"
+        end
+        if (prefix42 == '  # beginning of tests - keep this marker')
+          in_zone = false
+          @test_hash["aaa"] = method_lines                
+        end
+        if ((prefix == '  end') || (prefix == "\tend"))       
+          in_zone = false 
+          @test_hash["#{method_name}"] = method_lines            
+        end       
+      }      
+    end 
+  
+    def merge_keys
+      @merged_hash = Hash.new
+      @code_hash.keys.sort.each { |key| @merged_hash["#{key}"] = "code" }
+      @test_hash.keys.sort.each { |key| @merged_hash["#{key}"] = "test" }       
+    end
+  
+    def regenerate(test_file)
+      code = ''
+      @merged_hash.keys.sort.each { |key|
+        tokens = key.split('_')
+        type, name, meth = tokens[1], tokens[2], tokens[3]  
+        
+        processThisKey = true      
+        @exclude_classes.each { |xc| (xc == name) ? processThisKey = false : x = 0 }
+      
+        next if !processThisKey
+            
+        if @test_hash.has_key?(key)
+          # We already have a test method written in the test class, 
+          # so keep this currently existing test code!
+
+          if @code_hash.has_key?(key)
+            comment = nil
+          else
+            if key != 'aaa'
+              comment = "# Warning: possible obsolete test method - #{key}"
+            end
+          end
+        
+          code << "\n"  if key != 'aaa'
+          code << "\n#{comment}\n"   if comment
+          array = @test_hash["#{key}"]
+          array.each { |line| code << "\n#{line}" }
+        else
+          # We don't have this test method in the current test class,
+          # so generate a test method stub.        
+          code << "\n"
+          code << "\n  def #{key}"
+          code << "\n"
+        
+          if @gen_impl_stub
+            if type = 'class' 
+              code << "\n    #obj = #{type}.new"
+              code << "\n    #result   = obj.#{meth}"
+              code << "\n    #expected = ''"
+              s = "\n"
+              s << '    #assert_equal(expected, actual, "'
+              s << "#{type}.#{meth} "
+              s << 'values are not as expected; #{result} vs #{expected}")'
+              code << s      
+            else
+              code << "\n    #result   = #{type}.#{meth}"
+              code << "\n    #expected = ''"
+              s = "\n"
+              s <<  '    #assert_equal(expected, actual, "'
+              s << "#{type}.#{meth} "
+              s << 'values are not as expected; #{result} vs #{expected}")'
+              code << s         
+            end
+          end
+          code << "\n\n  end"
+        end
+      }
+      code << "\n\nend # end of class\n"
+      fn  = "tests/#{test_file}" 
+      out = File.new fn, "w+"
+      out.write code
+      out.flush
+      out.close
+      puts "file written: #{fn}"
+    end
+  end
+
+end # end of module

data/lib/gooby_command.rb

@@ -0,0 +1,210 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+  
+  class GoobyCommand < GoobyObject 
+    
+    attr_reader :configuration, :csv_points, :csv_col_names
+    
+    def initialize(gooby_yaml_filename=nil)
+      @configuration = Gooby::Configuration.init(gooby_yaml_filename)
+    end
+    
+    def display_configuration
+      #puts @configuration.to_s
+      @configuration.print_all
+    end
+    
+    def display_version
+      s = "# #{project_name} #{project_version_number} #{project_date}.  #{project_copyright}."
+      puts s
+    end
+
+    def split_garmin_export_file(argv)
+      if (argv == nil)
+        puts "ERROR: no ARGV args passed."
+      elsif (argv.size < 3)
+        puts ""
+        puts "Invalid program args; three args required - format, input filename, output directory"
+        puts "  the first arg, format, should be one of: garmin201, garmin205, garmin305, etc."
+        puts "  the second arg is the input filename - which is a garmin export file"
+        puts "  the third arg is the output directory where the split files are written to\n\n"
+        puts "Please correct the program arguments and try again. \n\n"
+      else
+        format   = argv[0].downcase
+        filename = argv[1]
+        out_dir  = argv[2]
+        
+        if (format == 'garmin201')
+          split_garmin_forerunner_logbook_xml(filename, out_dir)
+        else
+          split_garmin_training_center_xml(filename, out_dir) 
+        end
+      end
+    end
+    
+    def split_garmin_forerunner_logbook_xml(xml_filename, out_dir)  
+      splitter = Gooby::ForerunnerXmlSplitter.new(xml_filename, out_dir)  
+      splitter.split
+    end
+    
+    def split_garmin_training_center_xml(tcx_filename, out_dir)  
+      splitter = Gooby::TrainingCenterXmlSplitter.new(tcx_filename, out_dir)  
+      splitter.split
+    end
+    
+    def parse_garmin_xml_file(argv)
+      if (argv == nil)
+        puts "ERROR: no ARGV args passed."
+      elsif (argv.size < 2)
+        puts ""
+        puts "Invalid program args; three args required - format, uom, input (xml) filename"
+        puts "  the first arg, format, should be one of: garmin201, garmin205, garmin305, etc."
+        puts "  the second arg, unit-of-measure, should be either 'english' or 'metric'." 
+        puts "  the third arg, input xml filename, was produced by the Gooby 'splitter.rb' program."
+        puts "Please correct the program arguments and try again. \n\n"
+      else
+        format   = argv[0].downcase
+        uom      = argv[1].downcase        
+        filename = argv[2]
+        puts Trackpoint.csv_header        
+        if (format == 'garmin201')
+          parse_garmin_forerunner_logbook_xml(filename, uom)
+        else
+          parse_garmin_training_center_xml(filename, uom) 
+        end
+      end
+    end    
+        
+    def parse_garmin_forerunner_logbook_xml(xml_filename, uom)  
+      handler = Gooby::ForerunnerXmlParser.new(uom)    
+      Document.parse_stream((File.new xml_filename), handler)
+      handler.put_all_run_tkpt_csv()
+    end
+    
+    def parse_garmin_training_center_xml(tcx_filename, uom)  
+      handler = Gooby::TrainingCenterXmlParser.new(uom)   
+      Document.parse_stream((File.new tcx_filename), handler)
+      handler.put_all_run_tkpt_csv()
+    end
+
+    def read_csv_files(array_of_filenames, record_index=0)
+      @csv_reader = Gooby::CsvReader.new(array_of_filenames)
+      @csv_points = @csv_reader.read
+      @csv_col_names = @csv_reader.col_names
+      puts @csv_reader.to_s
+      if (record_index > 0)
+        @csv_reader.display_formatted_record(record_index) 
+      end
+      @csv_points
+    end
+    
+    def been_there(course_id, proximity=0.0070, uom='deg')
+      unless @csv_points
+        puts "You must first invoke method 'read_csv_files' with a list of parsed CSV filenames."
+        return
+      end
+      course = configuration.get_course("#{course_id}")
+      unless course
+        puts "Unable to find course id '#{course_id}' in the gooby config yaml file."
+        return
+      end
+      puts ''
+      # collect the csv_points into run arrays
+      @curr_run_id = 'x'      
+      @csv_runs = Array.new  
+      @csv_points.each { |csv_point|      
+        if (csv_point.run_id == @curr_run_id)
+          @curr_run.add_point(csv_point)  
+        else
+          @curr_run_id = csv_point.run_id
+          @curr_run = Gooby::CsvRun.new(@curr_run_id)
+          @curr_run.add_point(csv_point)
+          @csv_runs << @curr_run
+        end
+      }
+      
+      # iterate the runs - looking for a match vs the course
+      @csv_runs.each { |csv_run|
+        puts "Scanning run id '#{csv_run.id}', point count= #{csv_run.points.size}" if false
+        run_points = csv_run.points
+        course.reset
+        course.points.each { |course_point|
+          closest_diff  = 999
+          closest_point = nil
+          run_points.each { |run_point|
+            diff  = course_point.degrees_diff(run_point) 
+            if ((diff < proximity) && (diff < closest_diff))
+                closest_diff  = diff
+                closest_point = run_point
+                closest_point.degrees_diff = diff
+                course.matched(course_point.number, run_point)
+            end            
+          }
+        }
+        if course.matched?
+          puts "Course '#{course.name}' matched vs run id '#{csv_run.id}'" 
+          course.display_matches
+        else
+          puts "course not matched" if false
+        end
+      }
+    end
+    
+    def first_trackpoints_as_poi(date_string)
+      # cat 2007_poi.csv | sort +4n > 2007_poi_sorted.csv
+      home_point = Point.new('35.495469007128285', '-80.83213448524475', '752.5755445824', 'Home at South Faulkner Way Stopsign') # TODO
+      # poi.123  35.484114   -80.820274    788.7661681152  2007-06-30 10:48:32 1.01214244648463
+      @csv_points.each { |csv_point|
+      proximity = home_point.proximity(csv_point, 'm')
+      if (csv_point.lap_number == 1)
+        if date_string
+          if csv_point.date == date_string
+            puts sprintf("%s %s %s %s %s %s %s", 'poi.   ', 
+              character_align('.', csv_point.latitude,  3, 7), 
+              character_align('.', csv_point.longitude, 4, 7), 
+              character_align('.', csv_point.altitude,  5, 11),
+              character_align('.', proximity.to_s,  3, 20),              
+              csv_point.date,  
+              csv_point.time,
+              csv_point.distance)
+          end
+        else
+          puts sprintf("%s %s %s %s %s %s %s", 'poi.   ', 
+            character_align('.', csv_point.latitude,  3, 7), 
+            character_align('.', csv_point.longitude, 4, 7), 
+            character_align('.', csv_point.altitude,  5, 11),
+            character_align('.', proximity.to_s,  3, 20),   
+            csv_point.date,  
+            csv_point.time,
+            csv_point.distance)
+        end
+      end
+      }
+    end
+        
+    def generate_google_map(argv)  
+      if (argv == nil)
+        puts "ERROR: no ARGV args passed."
+      elsif (argv.size < 1)
+        puts ""
+        puts "Invalid program args; one required - input csv filename"
+        puts "  the first arg, csv filename, was produced by the Gooby 'parser.rb' program."
+        puts "Please correct the program arguments and try again. \n\n"
+      else
+        csv_filename  = argv[0]
+        configuration = Gooby::Configuration.get_config
+        generator = Gooby::GoogleMapGenerator.new(csv_filename)  
+        generator.generate_page(configuration)
+      end      
+    end
+  
+  end
+  
+end # end of module