Converting KML/XML to Javascript

I'd suggest Nokogiri for parsing the KML/XML. It's a more full-featured library, which makes things easier. For instance, you can get rid of all those long lines of [:symbol][0][:another_symbol][0]... (or maybe xmlsimple is brilliant, but, frankly, the docs are a rambling mess, so I'd steer clear)

I'd also suggest skipping the new google.maps.LatLng(...). All it does is guarantee a bunch of processing the moment the JS file is loaded. Possibly a lot of errors, too, in case GMaps hasn't loaded or isn't involved - perhaps you just want the actual coordinates, not LatLng objects. Or perhaps you just want one state, and don't want to bother instantiating LatLng objects for every state in the Union. And so on - much simpler to just write out the data

I'd also skip a lot of the "manual" string construction in the output, and use a JSON library to do the heavy lifting. In fact, I'd consider simply producing a JSON file - not a JS file. As with avoiding the new google.maps.LatLng stuff above, the point would be to keep data and logic separate. Although the different between JSON and JS is a matter of adding var ... = at the start and ; at the end, it still changes the file from a pure data format to code.

But you know your needs better than I do, so I've mimicked your code's output in my code.

I've split everything up into methods to keep things clean. It also lets you use the parsed data for something other than JS/JSON output, if need be.

require 'rubygems'
require 'nokogiri'
require 'json/ext'

# Parse the file at the given path
# See #parse_kml_doc for return value
def parse_kml_file(file)
  doc = File.open(file, 'r') { |io| Nokogiri::XML.parse(io) }
  parse_kml_doc(doc)
end

# Parse the given Nokogiri doc
# Returns an array of 2-element arrays containing
# the name and coordinates of the states
def parse_kml_doc(kml_doc)
  kml_doc.css("Placemark").map do |node| # CSS-type selectors
    state  = node.css("name").first.content.strip  # get state abbreviation
    coords = node.css("coordinates").first.content # get coords string
    coords = coords.strip.each_line.map do |line|  # parse the string
      line.strip.split(/,/).map(&:to_f) # I've skipped the rounding
    end
    [ state,  coords ] # return a tuple
  end
end

# Write out a JavaScript file with the data
def write_js_file(data, file)
  json = Hash[data].to_json
  File.open(file, 'w+') do |io|
    io << "var stateBorders = "
    io << json
    io << ";"
  end
end

# Read a KML file and write a JS file
def kml_to_js(kml_file, js_file)
  data = parse_kml_file(kml_file)
  write_js_file(data, js_file)
end

# Do everything!
kml_to_js("stateborders.kml", "stateborders.js")

It runs about 1.25x faster than the original; nothing spectacular there, but the code really only needs to run once anyway (at least until a state secedes)

Update: Ok, so if you truely want LatLng objects, I'd suggest doing this: Include a small snippet of JS in the file, which'll do the LatLng instantion when the file's loaded. I.e. something like

var stateBorders = (function () {
   var state, i, l, json = { .. plain json data .. };
   for(state in json) {
     if(json.hasOwnProperty(state)) {
       for(i = 0, l = json[state].length ; i++) {
         json[state][i] = new google.maps.LatLng(json[state][i][0], json[state][i][1]);
       }
     }
   }
   return json;
}());

It will cut the file size in half, to about 280kb (if you include the round(6)).

Or, if you want a file with new google.map.LatLng(...) repeating thousands of times, you can define a simple class:

 LatLng = Struct.new(:lat, :lng) do
   def to_json(*a)
     "new google.maps.LatLng(#{lat.round(6)},#{lng.round(6)})"
   end
 end

Use it to model coordinates (changing a line in the parse_kml_doc method):

# ...
coords = coords.strip.each_line.map do |line|
  LatLng.new(*line.strip.split(/,/).map(&:to_f))
end
# ...

And done. Leave the rest as-is, and it'll write out a file like you want.