gooby 1.2.0 → 2.0.0

data/README

@@ -1,418 +1,210 @@
 = Gooby = Google APIs + Ruby 
 
-Version: 1.2.0 - 2007/07/22
+Gooby is a set of Ruby code to assist you in creating Google Maps, and 
+Google Earth maps, from data exported from your Garmin GPS devices and
+your desktop software such as Garmin Training Center and/or MacGpsPro.
+Gooby will also process gpx data from the iPhone "MotionX GPS" application.
 
-Gooby = Google APIs + Ruby.  Release 1.2.0 generates Google maps from GPS data
-exported by your Garmin Forerunner GPS unit, or manually edited CSV file.
-Please see the README file.  Feedback is requested.  
+It will parse the exported Garmin xml/tcx/txt data, or MotionX gpx data, 
+into csv files in a "standard gooby format".  You then use Gooby to generate
+maps from specific csv files per yaml configuration files.
 
-Sample maps at:
-http://www.joakim-systems.com:8219/gmap/
-http://www.joakim-systems.com:8219/gmap/ccc_half_2005
-http://www.joakim-systems.com:8219/gmap/nashville_marathon_2005
-http://www.joakim-systems.com:8219/gmap/phoenix_marathon_2006
+The typical uses of Gooby are to create maps of your running, cycling, or
+hiking events, though Gooby is suitable for mapping any outdoor activity.
 
-This README document is available at:
-http://www.joakim-systems.com:8219/gooby/readme
-
----
-
-This gem contains 'Gooby', a set of Ruby code to assist you with using and
-producing content for the various Google APIs.  The initial focus of Gooby is 
-on the Google Maps API, version 2.0.  
-
-Google Maps can be produced using Gooby from your data in CSV format, 
-as created in one of the following three ways.
-1)  From exported and parsed Garmin ForerunnerLogbook XML files.
-2)  From exported and parsed Garmin TrainingCenter TCX(XML) files.
-3)  From your own manually edited Global Positioning System (GPS) data.
-    See any of the 'data/*.csv' files in the distribution for an example
-    of the CSV format. 
-
-Google maps are applicable really to any outdoor activity for which GPS data 
-can be obtained.  The focus of Gooby is on running, because the author is a 
-marathon runner, and the Garmin Forerunner (I use models 201, 205, and 305) 
-is primarily intended for running.  Other activities, such as cycling, hiking, 
-walking, driving, and even golfing are also well suited for Gooby.  Please let
-me know how you use Gooby!  Feedback is requested.
-
-All Gooby functionality is intended to be invoked from a command line.  Web
-and Rails integration may be done in a later release.  
+All Gooby functionality is intended to be invoked from a command line.
 
 = General
 
 Author::   Chris Joakim <chris@joakim-systems.com>
 Requires:: Ruby 1.8.4 or later
-License::  Copyright 2007 by Chris Joakim.
+License::  Copyright 2009 by Chris Joakim.
            GNU General Public License (GPL) license.
            See http://www.gnu.org/copyleft/gpl.html
-		
+        
 == License
 
 Gooby is available under GNU General Public License (GPL) license.
 
-== Download
-
-The latest version of gooby can be found at
-* http://rubyforge.org/projects/gooby/
-
-== Installation
-
-Gooby is packaged and installed as a ruby 'gem'.  Download the latest gem to 
-your computer, then run the following command from your download directory.
-
-gem install gooby-1.2.0.gem
-
-== Online Resources
-
-*  The Gooby home page http://rubyforge.org/projects/gooby/.
-   RubyForge provides CVS hosting for the project.
-
-   Sample Gooby-generated Google Maps are at www.joakim-systems.com, below:
-
-   http://www.joakim-systems.com:8219/gmap/
-   http://www.joakim-systems.com:8219/gmap/ccc_half_2005
-   http://www.joakim-systems.com:8219/gmap/nashville_marathon_2005
-   http://www.joakim-systems.com:8219/gmap/phoenix_marathon_2006
-   http://www.joakim-systems.com:8219/gmap/gps_data_capture
 
+== Download
 
-== This Release - 1.2.0
+Gooby is packaged and installed as a ruby 'gem'.  Download file 'gooby-2.0.0.gem'
+from http://rubyforge.org/projects/gooby/.
 
-*  Added support for the Garmin 305 Heartbeat monitor.  
-   - Heartbeat values are captured in the XML parsing process.
-   - CSV file format expanded to include heartbeat.
-   - Database DDL modified to add the heartbeat column.
-   - Generated Google Maps now have heartbeat in the popup windows.
-   - Legacy Garmin 201 and Garmin 205 CSV files and Google Maps simply
-     omit the heartbeat information.
-   - Heartbeat is displayed, if data is present, in the new Gooby 1.1.0 
-     "been_there" reports.  This may be interesting for hill-climbers
-     and interval-trainers.
 
-*  Added support for the English (miles) or Metric (kilometers) systems.
-   - Either 'mi' or 'km' is specified in the XML parsing process.
-   - mi or km unit-of-measure is retained in the CSV files.
-   - Generated Google Maps now generate markers at either integer
-     miles or kilometers, depending on the input CSV file.
-   - Generated Google Map popup windows display the unit-of-measure.
+== Installation
 
-     Special thanks to Karl Otto Emanuelsson for his suggestion to add
-     metric system support.
+1.  Ensure that you have the necessary prerequisites installed on your computer.  These 
+    include ruby itself, the rubygems package management system, and the libxml-ruby 0.9.7
+    and fastercsv 1.4.0 gems.  
 
-*  Refactored the codebase into individual class and module files, rather
-   than the previous monolithic gooby.rb file.
+    You will also need desktop software, such as Garmin Training Center and/or MacGpsPro,
+    which reads data from your GPS device, and enables it to be exported to files which
+    Gooby can process.  Garmin Training Center is a free download from Garmin.com.
 
+2.  Set the required GOOBY_HOME environment variable on your computer.  This variable
+    names the directory on your computer where you will store your Gooby-related files,
+    and where Gooby will generate content to.  Suggested values are 'C:\gooby' on Windows, 
+    and '~/gooby' on unix-based systems.
 
-== Previous Release - 1.1.0
+3.  From your downloads directory, run the following commands:
+      gem unpack gooby-2.0.0.gem
+      sudo gem install gooby-2.0.0.gem
 
-*  Greatly simplify usage and command-line argument handling.
-   See the shell scripts and ruby files in the /bin directory for examples.
+4.  Step 3 creates directory 'gooby-2.0.0' within your downloads directory.  Navigate
+    into this directory, then run the following command.
+      ruby setup.rb
 
-   Special thanks to Davis Kitchel for his several suggestions that resulted
-   in the following enhancements:
+    This will create subdirectories within your GOOBY_HOME, and will populate the /config
+    and /samples directories with several files.
 
-*  Gooby is a Garmin XML parser!  The 'marketing' focus on Gooby prior to now
-   has been on Google Map generation.  However, some users simply use it as
-   a Garmin XML to CSV parser, then use the parsed data for their own various
-   needs without creating a Google map.  This release recognizes that simple
-   parsing of Garmin data is a significant and "core" use of Gooby.
 
-*  Reformatted the parsed CSV files and added more fields to each output 
-   line, including a unique identifier (primary key), run_id, and lap-specific
-   info such as lap number, lap distance, and lap elapsed time.
+== Usage
 
-*  Renamed and enhanced yaml file 'gooby_config.yaml'.  Previously, this had
-   been Google-map biased.  This release allows you to define your own
-   "points of interest" (poi) in the yaml file.  Furthermore, you can define
-   "courses" or "subcourses" which consist of a given series of points-of-
-   interest.  See 'gooby_config.yaml' for examples.
+All Gooby functionality is invoked from a command line in your GOOBY_HOME directory.
+The rake program is used to execute all Gooby functions.
 
-*  Added proximity-based "been_there" reporting logic (method 'been_there' of
-   class GoobyCommand).  This functionality allows you to scan your CVS data
-   file(s) where you have been on user-specified "courses", within a given
-   proximity.  Your courses are defined in the yaml file (see the above item).
-   Proximity is specified in "degrees difference" between the course point
-   definition coordinates, and the actual observed GPS coordinates.  Degrees
-   difference is defined as the absolute value of lat1 - lat2, plus the
-   absolute value of lng1 - lng2.  
+I encourage the reader to read the cucumber test file, 'features/gooby.feature' to become
+familiar with how to use Gooby.  Cucumber is a ruby testing tool that allows you to specify
+tests and requirements in English, then have ruby translate and execute the English text.
 
-   For an example report, see file 'been_there.txt' in the /samples directory.
+1.  Run command 'rake' from your GOOBY_HOME to see the list of Gooby commands available to you.  
+    The list you see will look like the following:
 
-   This functionality essentially lets you retroactively "click the Lap button"
-   on your Garmin GPS receiver and examine split-times between given points.
-   Typical usage is to examine "hill climb", "time trial", or "speedwork" 
-   zones within your runs or rides. 
+    rake                                    # Default Task; Display Gooby usage instructions.
+    rake gooby:help                         # Display Gooby usage instructions.
+    rake gooby:extract_activities_from_tcx  # Extract individual Activity xml files from a Garmin tcx file
+    rake gooby:parse_activity_xml_to_csv    # Parse an extracted Activity xml file to a corresponding csv file.
+    rake gooby:parse_track_log_to_csv       # Parse a GPS Track Log file a corresponding csv file.
+    rake gooby:parse_gpx_to_csv             # Parse a GPX file a corresponding csv file.
+    rake gooby:generate_google_map          # Generate a Google Map from a csv file.
+    rake gooby:generate_google_earth_map    # Generate a Google Earth kml file from a csv file.
  
-*  Optional support for loading your GPS data into a MySQL database.  See the
-   generate and load scripts in the /sql directory.  
-
-   Note that Gooby data does NOT need to be loaded into a database; the CSV 
-   format is preferred.  However, users may find it useful to store this data 
-   in a database for their required processing.
-
-=== Road Map / TODO List
-
-*  IE or Google Bug - The Google Map v2 JavaScript has not run properly in
-   Internet Explorer at times.  Script error after loading the map background,
-   but before the map route is drawn.
-
-   Note: The Google Map v2 code seems to have been significantly improved for
-   Windows Explorer during Q2 2007, as the Gooby-generated Google Maps now
-   display properly in IE.
-
-*  Add Rails support for realtime dynamic map/content generation.
-
-*  Parse cadence information from Garmin export file for cyclists.
-   Note: Please provide me a sample file.
-
-*  Add other Google APIs (earth, search, sitemaps, froogle, etc).
-
-== Support
-
-Please see http://rubyforge.org/projects/gooby/ to submit a request or report
-a bug, on the Tracker page.
-
-----
-
-= Usage
-
-See the 'run_xxx.sh' shell scripts and corresponding ruby files in the /bin directory 
-for actual working examples used during Gooby development and testing.
-
-The following in-line text shows both the shell and ruby code.
-
-Function 1 - Gooby Version Information
--------------------------------------------
-	shell:
-	
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_version.rb 
+2.  Run command 'rake', or 'rake gooby:help' to display the "help content" for Gooby;
+    it contains specific examples of each command, and a description of the directory structure.
+
+3.  The typical usage sequence is as follows.
+
+    Part 1 - outside of the realm of Gooby:
+    a.  Do some outdoor event, with your Garmin GPS device recording your movements.
+        Or with your MotionX application on your iPhone.  Or with another device that
+        can emit data in gpx format.
+    b.  Connect your Garmin device to your computer, typically via a USB port.
+    c.  Use your desktop software, such as Garmin Training Center, to import the GPS
+        data from your GPS device.
+    d.  Use your desktop software to export its data to a file in your 'GOOBY_HOME/data' directory.
+        In Garmin Training Center, this is done with the File -> Export... menu.
     
-	ruby:
-
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
-
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
-
-	gooby = Gooby::GoobyCommand.new(config_filename)
-	gooby.display_version
-	
-	
-Function 2 - Gooby Configuration YAML Contents
-----------------------------------------------
-	shell:
-
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_config.rb
-
-	ruby:
-
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
-
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
-
-	gooby = Gooby::GoobyCommand.new(config_filename)
-	gooby.display_configuration
-
-
-Function 3 - Garmin XML/TCX file splitting:
--------------------------------------------
-	shell:
-	
-	rm   /temp/splits/*.*
-
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_splitter.rb  garmin201  /devtools/workspace/RF_Gooby/data/raw/forerunner_201_2007.xml  /temp/splits
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_splitter.rb  garmin205  /devtools/workspace/RF_Gooby/data/raw/forerunner_205_2007.tcx  /temp/splits
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_splitter.rb  garmin305  /devtools/workspace/RF_Gooby/data/raw/forerunner_305_2007.tcx  /temp/splits
-
-	ls -al /temp/splits
-	
-    ruby:
-
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
+    Part 2 - within the realm of Gooby:
+    e.  Depending on your GPS device and desktop software, you'll use the following commands
+        to parse a data file into the "gooby standard csv format":
+        - rake gooby:extract_activities_from_tcx   # Garmin 305 & Garmin Training Center
+        - rake gooby:parse_activity_xml_to_csv     # Garmin 305 & Garmin Training Center
+        - rake gooby:parse_track_log_to_csv        # Garmin eTrex Venture & MacGpsPro
+        - rake gooby:parse_gpx_to_csv              # MotionX app on iPhone
 
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
+        Note that files in "gooby standard csv format" can be used to generate either 
+        Google Maps or Google Earth Maps... there is no need to recreate the csv file
+        depending on what type of map you wish to create.
 
-	gooby = Gooby::GoobyCommand.new(config_filename)
-	gooby.display_version
-	gooby.split_garmin_export_file(ARGV)
-	
-	
-Function 4 - Garmin XML/TCX file parsing:
------------------------------------------
-    shell:
+    f.  Manually create and edit a yaml configuration file in the /config directory for the
+        specific map you want to generate.  For example: config/big_sur_marathon.yaml  
+        Specify its input csv file, and any other appropriate yaml parameter values.
+        This design approach was taken so that you can create a configuration file for
+        each map, then essentially not have to modify that file again to regenerate the map.
+        Be sure to set the value of 'gmap_key' to your own Google Maps key.
 
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_parser.rb garmin201 mi /devtools/workspace/RF_Gooby/data/20060115_phoenix_marathon.xml   > /devtools/workspace/RF_Gooby/data/20060115_phoenix_marathon.csv
+    g.  Run command 'rake gooby:generate_google_map' to generate a Google Map html file.
+        View the file in your browser, and optionally deploy it to your web site.
 
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_parser.rb garmin205 km /devtools/workspace/RF_Gooby/data/20070505_davidson_5k.xml        > /devtools/workspace/RF_Gooby/data/20070505_davidson_5k_km.csv
+    h.  Run command 'rake gooby:generate_google_earth_map' to generate a Google Earth kml file.
+        View the file in your Google Earth software.
 
-	ruby:
+    i.  Example commands, see file samples.sh
 
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
+        rake 
 
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
+        rake gooby:extract_activities_from_tcx
 
-	gooby = Gooby::GoobyCommand.new(config_filename)
-	gooby.parse_garmin_xml_file(ARGV)
+        rake gooby:parse_activity_xml_to_csv  config_file=config/big_sur_marathon.yaml
 
+        rake gooby:parse_track_log_to_csv     config_file=config/crowders_mtn_hike.yaml
 
-Function 5 - CSV File Validation
---------------------------------
-	shell:
+        rake gooby:parse_gpx_to_csv           config_file=config/ballantyne.yaml
 
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_csv_validation.rb
+        rake gooby:generate_google_map        config_file=config/big_sur_marathon.yaml
+        rake gooby:generate_google_map        config_file=config/crowders_mtn_hike.yaml
+        rake gooby:generate_google_map        config_file=config/ballantyne.yaml
 
-    ruby:
+        rake gooby:generate_google_earth_map  config_file=config/big_sur_marathon.yaml
+        rake gooby:generate_google_earth_map  config_file=config/crowders_mtn_hike.yaml
+        rake gooby:generate_google_earth_map  config_file=config/ballantyne.yaml
 
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
 
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
-
-	full_files = false
-
-	list = Array.new
-	list << '/devtools/workspace/RF_Gooby/data/hrm1.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20050305_corporate_cup_hm.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20050430_nashville_marathon_km.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20060115_phoenix_marathon.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20070101_davidson_11m.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20070505_davidson_5k_km.csv'
-
-	list << '/devtools/workspace/RF_Gooby/data/2007_g201.csv'  if full_files
-	list << '/devtools/workspace/RF_Gooby/data/2007_g205.csv'  if full_files
-	list << '/devtools/workspace/RF_Gooby/data/2007_g305.csv'  if full_files
-
-	gooby = Gooby::GoobyCommand.new(config_filename)
-	@csv_points    = gooby.read_csv_files(list)
-	@csv_col_names = gooby.csv_col_names
-
-	puts "#{@csv_points.size} points read from csv file(s)."
-	puts "#{@csv_col_names.size} fields per line."
-
-	index = 0
-	@csv_col_names.each {|col_name| 
-	  puts sprintf("--    %s   %2s   [%s]", col_name.ljust(16), index, @csv_points[-1].tokens[index])
-	  index = index + 1
-	}
-
-	@csv_points.each {|csv_point| 
-	  puts csv_point.rawdata if csv_point.token_count != 15  
-	}
-
-
-Function 6 - "been_there":
---------------------------
-	shell:
-	
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_been_there.rb > /devtools/workspace/RF_Gooby/samples/been_there.txt
-
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_been_there.rb
-	
-	ruby:
-	
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
-
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
-
-	gooby = Gooby::GoobyCommand.new(config_filename)
+== Online Resources
 
-	# first read the csv file(s) parsed from your Garmin export tcx/xml files.
-	list = Array.new
-	list << '/devtools/workspace/RF_Gooby/data/20070101_davidson_11m.csv'
-	list << '/devtools/workspace/RF_Gooby/data/hrm1.csv'
-	gooby.read_csv_files(list)   
+*   Gooby may be downloaded from http://rubyforge.org/projects/gooby/.
 
-	# first arg to 'been_there' is the course number, second arg is the 'proximity' specified as
-	# 'degrees difference'.  Degrees difference is defined as the absolute value of lat1 - lat2, 
-	# plus the absolute value of lng1 - lng2.  Your courses and points of interest (poi) are defined
-	# in the yaml file.
+*   Gooby project site is http://www.joakim-systems.com/gooby
 
-	gooby.been_there('1', 0.0025) 
-	gooby.been_there('2', 0.0025) 
-	gooby.been_there('999', 0.0005)
+*   Sample maps are available at: http://www.joakim-systems.com/maps
 
+*   Gooby cucumber tests are available at: http://www.joakim-systems.com/cuke
 
-Function 7 - Google Map Generation:
------------------------------------
-	shell:
-	
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_gen_gmap.rb  /devtools/workspace/RF_Gooby/data/20060115_phoenix_marathon.csv      > /devtools/workspace/RF_Gooby/samples/20060115_phoenix_marathon.html
 
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_gen_gmap.rb  /devtools/workspace/RF_Gooby/data/20070505_davidson_5k_km.csv        > /devtools/workspace/RF_Gooby/samples/20070505_davidson_5k.html
+== This Release - version 2.0.0
 
-	ruby:
+*  The gooby 2.0.0 codebase is essentially a complete rewrite, featuring:
 
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
+   - 'libxml' is now used for xml parsing instead of 'rexml'.
 
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
+   - csv creation and reading with 'fastercsv'.
 
-	gooby = Gooby::GoobyCommand.new(config_filename)
-	gooby.generate_google_map(ARGV)
-		
+   - use of cucumber and rspec rather than test/unit for automated testing.
 
-    Note: The input file passed to the Google Map generation process is the CSV file, not the Garmin XML file.
+*  Simplified functionality:
 
+   - Device focus - parses data from your Garmin 205/305 and Garmin eTrex devices
+     via your desktop software such as Garmin Training Center and/or MacGpsPro.
 
-Function 8 - Extract First Trackpoints as (potential) Points-of-Interest (POI)
-------------------------------------------------------------------------------
-	shell:
+     A late addition to this release was gpx xml file support, such as from the
+     iPhone "MotionX GPS" application.
 
-	ruby /devtools/workspace/RF_Gooby/bin/gooby_first_trackpoints_as_poi.rb 
+   - Data focus - the specific Garmin device data is formatted into a common csv format.
+     You may optionally import the csv files created by gooby into your database of choice.
+     Gooby itself, however, does not require the use of a database.
 
-	ruby:
+   - Google Map html generation, from common csv input.
 
-	require 'rubygems' 
-	require 'gooby'
-	include REXML
+   - Google Earth kml generation, from common csv input.
 
-	config_filename = '/devtools/workspace/RF_Gooby/config/gooby_config.yaml'
+   - The 'GOOBY_HOME' environment variable is required; a user-defined value.
+     Rails-like "sensible default" directory structure within your 'GOOBY_HOME' directory.
 
-	gooby = Gooby::GoobyCommand.new(config_filename)
+   - Configuration yaml files are now a "base plus map-specific" design.  A core yaml file
+     defines most configuration parameters; while map-specific configuration yaml files
+     enable you to override the base values for each particular map you create.  
+     This results in less need to constantly modify the configuration values for each map
+     you want to generate.
 
-	# first read the csv file(s) parsed from your Garmin export tcx/xml files.
-	list = Array.new
-	list << '/devtools/workspace/RF_Gooby/data/hrm1.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20050305_corporate_cup_hm.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20050430_nashville_marathon_km.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20060115_phoenix_marathon.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20070101_davidson_11m.csv'
-	list << '/devtools/workspace/RF_Gooby/data/20070505_davidson_5k_km.csv'
-	gooby.read_csv_files(list)
+   - Focus is on the English system of units, rather than the metric system.
 
-	# optional first arg is the date of the run, otherwise the all dates.
-	gooby.first_trackpoints_as_poi(ARGV[0])
 
+== Road Map / TODO List
 
-Function 9 - Create a MySQL database table for your parsed CSV data
--------------------------------------------------------------------
-	shell:
-	
-	/usr/local/mysql/bin/mysql < /devtools/workspace/RF_Gooby/sql/gooby.ddl -u <your_db_id> -p		
+*  No specific plans currently.  Future functionality is dependent on my future mapping
+   needs, Google API evolution, and user feedback.  Interesting ideas are appreciated.
 
 
-Function 10 - Populate the MySQL database table with your parsed CSV data
--------------------------------------------------------------------------
-	shell:
+== Support
 
-	/usr/local/mysql/bin/mysql < /devtools/workspace/RF_Gooby/sql/gooby_load.dml -u <your_db_id> -p	
+*  Please see the Tracker page at http://rubyforge.org/projects/gooby/ to submit a request
+   or to report a bug.
 
-	
+    
 == Warranty
 
-This software is provided "as is" and without any express or implied warranties, 
-including, without limitation, the implied warranties of merchantibility and 
-fitness for a particular purpose.
+This software is provided "as is" and without any express or implied warranties, including, 
+without limitation, the implied warranties of merchantibility and  fitness for a particular purpose.