googlestaticmap 1.1.0

data/History.txt

@@ -0,0 +1,23 @@
+=== 1.1.0 / 2011-10-18
+* Added an option to make requests through a proxy server (thanks bardsley!)
+
+=== 1.0.1 / 2011-09-23
+* Added a scale parameter to the map (thanks backspace!)
+
+=== 1.0.0 / 2011-07-21
+* An explicitly set map center is now properly encoded - was previously being doubly encoded (thanks abecciu)
+* Gem will now load on some bad Rubygems installations (path issue)
+* Version 1.0, yeah!
+
+=== 0.1.5 / 2011-02-08
+* Fixed bug which caused require 'googlestaticmap' to not work on some versions of Ruby
+
+=== 0.1.4 / 2010-08-21
+* Added unit tests
+
+=== 0.1.2 / 2010-08-20
+* Now works in Ruby 1.8 as well as 1.9
+* Fixed a bug when getting a map without specifying a file
+
+=== 0.1.0 / 2010-08-19
+* Initial release

data/README

@@ -0,0 +1,54 @@
+= googlestaticmap gem
+
+This gem is on Gemcutter, simply type "gem install googlestaticmap" to install it.
+
+Available on github at http://github.com/brentsowers1/googlestaticmap
+
+Class for generating URLs for and downloading static maps from the Google Maps
+Static API service.  GoogleStaticMap is the main class to use, instantiate it,
+set the attributes to what you want, and call url on the instance to get the
+URL to download the map from.  You can also call get_map to actually
+download the map from Google, return the bytes, and optionally write the
+image to a file.
+
+== Examples:
+
+Get a simple static map centered at Washington, DC, with the default size
+(500 x 350), zoomed to level 11
+  require 'googlestaticmap'
+  map = GoogleStaticMap.new(:zoom => 11, :center => MapLocation.new(:address => "Washington, DC"))
+  image = map.get_map
+
+Get a map with blue markers at the White House and the Supreme Court, zoomed
+the closest that the map can be with both markers visible, at the default
+size.
+  require 'googlestaticmap'
+  map = GoogleStaticMap.new
+  map.markers << MapMarker.new(:color => "blue", :location => MapLocation.new(:address => "1600 Pennsylvania Ave., Washington, DC"))
+  map.markers << MapMarker.new(:color => "blue", :location => MapLocation.new(:address => "1 1st Street Northeast, Washington, DC"))
+  image = map.get_map
+
+Get a GIF satellite map, with a size of 640 x 480, with a
+semi transparent green box drawn around a set of 4 coordinates, with the box
+outline solid, centered at the middle of the box, written out to the file
+map.gif:
+  require 'googlestaticmap'
+  map = GoogleStaticMap.new(:maptype => "satellite", :format => "gif", :width => 640, :height => 480)
+  poly = MapPolygon.new(:color => "0x00FF00FF", :fillcolor => "0x00FF0060")
+  poly.points << MapLocation.new(:latitude => 38.8, :longitude => -77.5)
+  poly.points << MapLocation.new(:latitude => 38.8, :longitude => -76.9)
+  poly.points << MapLocation.new(:latitude => 39.2, :longitude => -76.9)
+  poly.points << MapLocation.new(:latitude => 39.2, :longitude => -77.5)
+  poly.points << MapLocation.new(:latitude => 38.8, :longitude => -77.5)
+  map.paths << poly
+  map.get_map("map.gif")
+
+If you're working behind a proxy, create the map object this way:
+  map = GoogleStaticMap.new(:proxy_address=>'my.proxy.host', :proxy_port=>8080, :width => 640, :height => 480)
+
+
+Author:: Brent Sowers (mailto:brent@coordinatecommons.com)
+License:: You're free to do whatever you want with this
+
+To post comments about this gem, go to my blog posting at
+http://rails.brentsowers.com/2010/08/gem-for-getting-google-static-maps.html

data/lib/googlestaticmap.rb

@@ -0,0 +1,284 @@
+# = googlestaticmap gem
+#
+# This gem is on Gemcutter, simply type "gem install googlestaticmap" to install it.
+#
+# Available on github at http://github.com/brentsowers1/googlestaticmap
+#
+# Class for generating URLs for and downloading static maps from the Google Maps
+# Static API service.  GoogleStaticMap is the main class to use, instantiate it,
+# set the attributes to what you want, and call full_url on the instance to get
+# the URL to download the map from.  You can also call get_map to actually
+# download the map from Google, return the bytes, and optionally write the
+# image to a file.
+#
+# Examples:
+#
+# Get a simple static map centered at Washington, DC, with the default size
+# (500 x 350), zoomed to level 11
+#   map = GoogleStaticMap.new(:zoom => 11, :center => MapLocation.new(:address => "Washington, DC"))
+#   image = map.get_map
+#
+# Get a map with blue markers at the White House and the Supreme Court, zoomed
+# the closest that the map can be with both markers visible, at the default
+# size.
+#   map = GoogleStaticMap.new
+#   map.markers << MapMarker.new(:color => "blue", :location => MapLocation.new(:address => "1600 Pennsylvania Ave., Washington, DC"))
+#   map.markers << MapMarker.new(:color => "blue", :location => MapLocation.new(:address => "1 1st Street Northeast, Washington, DC"))
+#   image = map.get_map
+#
+# Get a GIF satellite map, with a size of 640 x 480, with a
+# semi transparent green box drawn around a set of 4 coordinates, with the box
+# outline solid, centered at the middle of the box, written out to the file
+# map.gif:
+#   map = GoogleStaticMap.new(:maptype => "satellite", :format => "gif", :width => 640, :height => 480)
+#   poly = MapPolygon.new(:color => "0x00FF00FF", :fillcolor => "0x00FF0060")
+#   poly.points << MapLocation.new(:latitude => 38.8, :longitude => -77.5)
+#   poly.points << MapLocation.new(:latitude => 38.8, :longitude => -76.9)
+#   poly.points << MapLocation.new(:latitude => 39.2, :longitude => -76.9)
+#   poly.points << MapLocation.new(:latitude => 39.2, :longitude => -77.5)
+#   poly.points << MapLocation.new(:latitude => 38.8, :longitude => -77.5)
+#   map.paths << poly
+#   map.get_map("map.gif")
+#
+# If you're working behind a proxy, create the map object this way:
+# map = GoogleStaticMap.new(:proxy_address=>'my.proxy.host', :proxy_port=>8080, :width => 640, :height => 480)
+#
+# Author:: Brent Sowers (mailto:brent@coordinatecommons.com)
+# License:: You're free to do whatever you want with this
+
+require 'cgi'
+require 'net/http'
+require File.dirname(__FILE__) +  '/googlestaticmap_helper'
+
+# Main class for creating a static map.  Create an instance, Set attributes
+# that describe properties of the map.  Then call url to get a URL that you
+# can use as the src of an img tag.  You can also call get_map to actually
+# download the map from Google, and optionally write it to a file.
+class GoogleStaticMap
+  # Width of resulting image in pixels, defaults to 500, maximum 640
+  attr_accessor :width
+
+  # Height of resulting image in pixels, defaults to 350, maximum 640
+  attr_accessor :height
+
+  # An optional array of MapMarker instances
+  attr_accessor :markers
+
+  # An optional array of MapPath instances and/or MapPolygon instances to draw
+  attr_accessor :paths
+
+  # MapLocation for the center of the map. If this is not specified, the map
+  # will zoom to the markers
+  attr_accessor :center
+
+  # 0 (the whole world) to 21 (individual buildings)
+  attr_accessor :zoom
+
+  # Applications that determine the user's location via a sensor must set this
+  # to true, defaults to false
+  attr_accessor :sensor
+
+  # 1, 2, or 4 for Maps API Premier customers. Defaults to 1. Makes everything
+  # in the image appear larger, useful for displaying on high res mobile
+  # screens.  When setting this, the image's actual width and height in pixels
+  # will be scale * width and scale * height
+  attr_accessor :scale
+
+  # format of the image:
+  # * png8 - 8 bit PNG (default)
+  # * png32 - 32 bit PNG
+  # * gif
+  # * jpg
+  # * jpg-baseline - non-progressive JPEG
+  attr_accessor :format
+
+  # Type of map to create:
+  # * roadmap (default)
+  # * satellite
+  # * terrain
+  # * hybrid - satellite imagery with roads
+  attr_accessor :maptype
+  
+  # If you need to use a proxy server to reach Google, set the name/address
+  # of the proxy server here
+  attr_accessor :proxy_address
+
+  # If proxy_address is set, set this to the port of the proxy server
+  attr_accessor :proxy_port
+
+  # Takes an optional hash of attributes
+  def initialize(attrs={})
+    defaults = {:width => 500, :height => 350, :markers => [],
+                :sensor => false, :maptype => "roadmap", :paths => [],
+                :proxy_port => nil, :proxy_address => nil,}
+                
+    attributes = defaults.merge(attrs)
+    attributes.each {|k,v| self.send("#{k}=".to_sym,v)}
+  end
+
+  # Returns the full URL to retrieve this static map.  You can use this as the
+  # src for an img to display an image directly on a web page
+  # Example - "http://maps.google.com/maps/api/staticmap?params..."
+  def url
+    unless @center || @markers.length > 0 || @paths.length > 0
+      raise Exception.new("Need to specify either a center, markers, or a path")
+    end
+    u = "http://maps.google.com/maps/api/staticmap?"
+    attrs = GoogleStaticMapHelpers.safe_instance_variables(self,
+              ["markers", "paths", "width", "height", "center",
+               "proxy_address", "proxy_port"],
+              :cgi_escape_values => true).to_a
+    attrs << ["size", "#{@width}x#{@height}"] if @width && @height
+    markers.each {|m| attrs << ["markers",m.to_s] }
+    paths.each {|p| attrs << ["path",p.to_s] }
+    attrs << ["center", center.to_s] if !center.nil?
+    u << attrs.collect {|attr| "#{attr[0]}=#{attr[1]}"}.join("&")
+  end
+
+  # Returns the URL to retrieve the map, relative to http://maps.google.com
+  # Example - "/maps/api/staticmap?params..."
+  def relative_url
+    url.gsub(/http\:\/\/maps\.google\.com/, "")
+  end
+
+  # Connects to Google, retrieves the map, and returns the bytes for the image.
+  # Optionally, pass it an output name and the contents will get written to
+  # this file name
+  def get_map(output_file=nil)
+    http = Net::HTTP.Proxy(@proxy_address,@proxy_port).new("maps.google.com", 80)
+    resp, data = http.get2(relative_url)
+    if resp && resp.is_a?(Net::HTTPSuccess)
+      if output_file
+        File.open(output_file, "wb") {|f| f << data }
+      end
+      data
+    else
+      if resp
+        raise Exception.new("Error encountered while retrieving google map, code #{resp.code}, text #{resp.body}")
+      else
+        raise Exception.new("Error while retrieve google map, no response")
+      end
+    end
+  end
+end
+
+# Container class for a location on the map.  Set either a latitude and
+# longitude, or an address
+class MapLocation
+  # Decimal degrees, positive is north
+  attr_accessor :latitude
+
+  # Decimal degrees, positive is east
+  attr_accessor :longitude
+
+  # String address - can be a full address, city name, zip code, etc.  This is
+  # ignored if latitude and longitude are set.
+  attr_accessor :address
+
+  def initialize(attrs={})
+    attrs.each {|k,v| self.send("#{k}=".to_sym,v.to_s)}
+  end
+
+  def to_s
+    if latitude && longitude
+      "#{CGI.escape(latitude.to_s)},#{CGI.escape(longitude.to_s)}"
+    elsif address
+      CGI.escape(address)
+    else
+      raise Exception.new("Need to set either latitude and longitude, or address")
+    end
+  end
+end
+
+# A single marker to place on the map.  Initialize and pass
+class MapMarker
+  # A 24-bit color (example: 0xFFFFCC) or a predefined color from the set
+  # {black, brown, green, purple, yellow, blue, gray, orange, red, white}
+  attr_accessor :color
+
+  # MapLocation for the position of this marker
+  attr_accessor :location
+
+  # (optional) The size of marker from the set {tiny, small, mid}. Defaults to
+  # mid
+  attr_accessor :size
+
+  # (optional) A single uppercase alphanumeric character label from the set
+  # {A-Z, 0-9}.  Not allowed for tiny and small sizes
+  attr_accessor :label
+
+  # a URL to use as the marker's custom icon. Images may be in PNG, JPEG or GIF
+  # formats, though PNG is recommended
+  attr_accessor :icon
+
+  # true (default) indicates that the Static Maps service should construct an
+  # appropriate shadow for the image. This shadow is based on the image's
+  # visible region and its opacity/transparency.
+  attr_accessor :shadow
+
+  # Takes an optional hash of attributes
+  def initialize(attrs={})
+    attrs.each {|k,v| self.send("#{k}=".to_sym,v)}
+  end
+
+  def to_s
+    raise Exception.new("Need a location for the marker") unless @location && @location.is_a?(MapLocation)
+    attrs = GoogleStaticMapHelpers.safe_instance_variables(self, ["location"])
+    s = attrs.to_a.collect do |k|
+      # If the icon URL is URL encoded, it won't work
+      val = (k[0] == "icon" ? k[1] : CGI.escape(k[1].to_s))
+      "#{k[0]}:#{val}"
+    end.join("|")
+    s << "|#{@location.to_s}"
+  end
+end
+
+# A path line to draw on the map.  Initialize and set attributes.
+class MapPath
+  # Thickness of the path line in pixels, defaults to 5
+  attr_accessor :weight
+
+  # Color of the path, either as a 24-bit (example: color=0xFFFFCC), a 32-bit
+  # hexadecimal value (example: color=0xFFFFCCFF), or from the set
+  # {black, brown, green, purple, yellow, blue, gray, orange, red, white}
+  # When a 32-bit hex value is specified, the last two characters specify the
+  # 8-bit alpha transparency value. This value varies between 00
+  # (completely transparent) and FF (completely opaque).
+  attr_accessor :color
+
+  # MapPositions for each point on the line
+  attr_accessor :points
+
+  # Pass an optional hash of arguments
+  def initialize(attrs={})
+    @points = []
+    attrs.each {|k,v| self.send("#{k}=".to_sym,v)}
+  end
+
+  def to_s
+    raise Exception.new("Need more than one point for the path") unless @points && @points.length > 1
+    attrs = GoogleStaticMapHelpers.safe_instance_variables(self, ["points"])
+    s = attrs.to_a.collect {|k| "#{k[0]}:#{CGI.escape(k[1].to_s)}"}.join("|")
+    s << "|" << @points.join("|")
+  end
+end
+
+# A polygon to draw and fill on the map.  Has the same properties as a path
+# with the addition of a fill color.  The points do not need to form a closed
+# loop, the last point will automatically be joined the first point
+class MapPolygon < MapPath
+  # Color to fill in, either as a 24-bit (example: color=0xFFFFCC), a 32-bit
+  # hexadecimal value (example: color=0xFFFFCCFF), or from the set
+  # {black, brown, green, purple, yellow, blue, gray, orange, red, white}
+  # When a 32-bit hex value is specified, the last two characters specify the
+  # 8-bit alpha transparency value. This value varies between 00
+  # (completely transparent) and FF (completely opaque).
+  attr_accessor :fillcolor
+
+  def initialize(attrs={})
+    @points = []
+    attrs.each {|k,v| self.send("#{k}=".to_sym,v)}
+  end
+end
+
+

data/lib/googlestaticmap_helper.rb

@@ -0,0 +1,27 @@
+# Helper methods used in this code
+module GoogleStaticMapHelpers #:nodoc: all
+  # Returns a hash of instance variables for the passed in Object, where the
+  # key is the instance variable name ("@instance_variable"), and the value is
+  # the current instance variable value.  This is safe for Ruby 1.8 and 1.9.
+  # Pass an optional array of instance variable name strings
+  # (["instance_variable_1", "instance_variable_2"]) to not include in the
+  # result.  Example result:
+  # {"variable_1" => 123, "variable_2" => "2 value"}
+  # All inputs and outputs do NOT have the @ in the instance variable name
+  # options -
+  #   :cgi_escape_values - set this to true to return all values as
+  #   CGI escaped strings
+  def self.safe_instance_variables(object, ivs_to_exclude=[], options={})
+    ivs = {}
+    object.instance_variables.each do |i|
+      # Don't include the @
+      iv_name = i.to_s[1..-1]
+      unless ivs_to_exclude.include?(iv_name)
+        val = object.instance_variable_get(i)
+        val = CGI.escape(val.to_s) if options.has_key?(:cgi_escape_values)
+        ivs[iv_name] = val
+      end
+    end
+    ivs
+  end
+end

data/test/tc_google_static_map.rb

@@ -0,0 +1,135 @@
+require 'rubygems'
+require 'test/unit'
+require 'cgi'
+require 'net/http'
+require 'mocha'
+require File.dirname(__FILE__) +  '/../lib/googlestaticmap'
+
+class MockSuccess < Net::HTTPSuccess #:nodoc: all
+  def initialize
+  end
+end
+
+class MockFailure < Net::HTTPServiceUnavailable #:nodoc: all
+  def initialize
+  end
+  def code
+    100
+  end
+  def body
+    "epic fail"
+  end
+end
+
+class MockHttp #:nodoc: all
+  def initialize
+  end
+end
+
+class GoogleStaticMapTest < Test::Unit::TestCase #:nodoc: all
+
+  class MockFile #:nodoc: all
+    @@file = nil
+    def self.open(name, &block)
+      @@file = {name => yield}
+    end
+  end
+
+  def test_exception_no_items
+    g = GoogleStaticMap.new
+    assert_raise Exception do
+      g.url
+    end
+  end
+
+  def test_set_attributes
+    g = nil
+    assert_nothing_raised { g = default_map }
+    assert_equal 600, g.width
+    assert_equal "hybrid", g.maptype
+    assert_equal 1, g.markers.length
+  end
+
+  def test_url
+    g = default_map
+    u = nil
+    assert_nothing_raised { u = g.url }
+    assert_equal 7, u.split("&").length, u
+    assert u.include?("size=600x400"), "width and height did not get converted in to a size"
+    assert u.include?("maptype=hybrid")
+    assert u.include?("scale=2")
+    assert u.include?("asdf")
+    assert u.include?("http://maps.google.com")
+    assert u.include?("color:0x00FF00FF|fillcolor:0x00FF0060|38.8,-77.5|38.8,-76.9|39.2,-76.9|39.2,-77.5|38.8,-77.5"), "Polygon not in URL"
+    assert u.include?("Washington%2C+DC")
+
+    f = nil
+    assert_nothing_raised {f = g.relative_url}
+    assert !f.include?("http://maps.google.com")
+  end
+
+  def test_get_map_success_no_file
+    test_data = "asdf"
+    MockHttp.any_instance.expects(:get2).returns([MockSuccess.new,test_data])
+    Net::HTTP.expects(:new).returns(MockHttp.new)
+
+    g = default_map
+    r = nil
+    assert_nothing_raised {r = g.get_map}
+    assert_equal r, test_data
+  end
+
+  def test_get_map_success_write_file
+    test_data = "asdf"
+    MockHttp.any_instance.expects(:get2).returns([MockSuccess.new,test_data])
+    Net::HTTP.expects(:new).returns(MockHttp.new)
+    file_data = ""
+    file_name = "testdata.png"
+    # File.open should be called, with the name of the file and write binary
+    # passed in.  The object passed to the yield should be a file object that
+    # gets the test data appended to it.  If we sub out a string for the
+    # file object we can later check the contents
+    File.expects(:open).with(file_name, "wb").yields(file_data)
+    g = default_map
+    r = nil
+    assert_nothing_raised {r = g.get_map(file_name)}
+    assert_equal r, test_data
+    assert_equal file_data, test_data
+  end
+
+
+  def test_get_map_failure
+    MockHttp.any_instance.expects(:get2).returns([MockFailure.new,""])
+    Net::HTTP.expects(:new).returns(MockHttp.new)
+    g = default_map
+    assert_raise Exception do
+      g.get_map
+    end
+  end
+
+  def test_get_map_nothing
+    MockHttp.any_instance.expects(:get2).returns(nil)
+    Net::HTTP.expects(:new).returns(MockHttp.new)
+    g = default_map
+    assert_raise Exception do
+      g.get_map
+    end
+  end
+
+  private
+  def default_map
+    poly = MapPolygon.new(:color => "0x00FF00FF", :fillcolor => "0x00FF0060")
+    poly.points << MapLocation.new(:latitude => 38.8, :longitude => -77.5)
+    poly.points << MapLocation.new(:latitude => 38.8, :longitude => -76.9)
+    poly.points << MapLocation.new(:latitude => 39.2, :longitude => -76.9)
+    poly.points << MapLocation.new(:latitude => 39.2, :longitude => -77.5)
+    poly.points << MapLocation.new(:latitude => 38.8, :longitude => -77.5)
+
+    GoogleStaticMap.new(:width => 600, :height => 400,
+                        :markers => [MapMarker.new(:location => MapLocation.new(:address => "asdf"))],
+                        :center => MapLocation.new(:address => "Washington, DC"),
+                        :paths => [poly],
+                        :scale => 2,
+                        :maptype => "hybrid")
+  end
+end

data/test/tc_helper.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'cgi'
+require File.dirname(__FILE__) +  '/../lib/googlestaticmap_helper'
+
+class GoogleStaticMapHelperTest < Test::Unit::TestCase #:nodoc: all
+
+  IVS = {"@var1" => 1, "@var2" => 2, "@var3" => 3,
+         "@url" => "http://maps.google.com"}
+
+  class MockRuby18Object
+    def self.instance_variables
+      IVS.keys
+    end
+    def self.instance_variable_get(variable)
+      IVS[variable]
+    end
+  end
+
+  # Ruby 1.9 refers to instance variables as symbols, like :@var1.  The
+  # helper class needs to handle both cases
+  class MockRuby19Object
+    def self.instance_variables
+      IVS.keys.collect {|k| k.to_sym}
+    end
+    def self.instance_variable_get(variable)
+      IVS[variable.to_s]
+    end
+  end
+
+
+  def test_safe_instance_variables_no_params
+    [MockRuby18Object, MockRuby19Object].each do |o|
+      assert_equal ivs_no_at, GoogleStaticMapHelpers.safe_instance_variables(o)
+    end
+  end
+
+  def test_safe_instance_variables_exclude
+    [MockRuby18Object, MockRuby19Object].each do |o|
+      sivs = GoogleStaticMapHelpers.safe_instance_variables(o, ["var2"])
+      assert_equal IVS.length-1, sivs.length
+      assert !sivs.has_key?("@var2")
+    end
+  end
+
+  def test_safe_instance_variables_cgi
+    [MockRuby18Object, MockRuby19Object].each do |o|
+      sivs = GoogleStaticMapHelpers.safe_instance_variables(o, [], :cgi_escape_values => true)
+      assert_equal IVS.length, sivs.length
+      assert_equal CGI.escape(IVS["@url"]), sivs["url"]
+    end
+  end
+
+  private
+  def ivs_no_at
+    ivs = {}
+    IVS.each do |k,v|
+      ivs[k[1..-1]] = v
+    end
+    ivs
+  end
+end

data/test/tc_map_location.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'cgi'
+require File.dirname(__FILE__) +  '/../lib/googlestaticmap'
+
+class MapLocationTest < Test::Unit::TestCase #:nodoc: all
+  def test_exception_no_location
+    m = MapLocation.new
+    assert_raise Exception do
+      m.to_s
+    end
+  end
+
+  def test_attributes_filled_in
+    m = MapLocation.new(:latitude => 39, :longitude => -77)
+    assert_equal "39", m.latitude
+    assert_equal "-77", m.longitude
+    assert_nil m.address
+    m = MapLocation.new(:address => "Washington, DC")
+    assert_equal "Washington, DC", m.address
+    assert_nil m.latitude
+    assert_nil m.longitude
+  end
+
+  def test_with_address
+    m = MapLocation.new(:address => "Washington, DC")
+    s = ""
+    assert_nothing_raised { s = m.to_s }
+    assert_equal s, CGI.escape("Washington, DC")
+  end
+
+  def test_with_latitude_longitude
+    m = MapLocation.new(:latitude => 39, :longitude => -77)
+    s = ""
+    assert_nothing_raised { s = m.to_s }
+    assert_equal s, "39,-77"
+  end
+end

data/test/tc_map_marker.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require 'cgi'
+require File.dirname(__FILE__) +  '/../lib/googlestaticmap'
+
+class MapMarkerTest < Test::Unit::TestCase #:nodoc: all
+  def test_exception_no_location
+    m = MapMarker.new
+    assert_raise Exception do
+      m.to_s
+    end
+  end
+
+  def test_exception_invalid_location
+    m = MapMarker.new
+    m.location = 99
+    assert_raise Exception do
+      m.to_s
+    end
+  end
+
+  def test_set_parameters
+    m = nil
+    assert_nothing_raised { m = default_marker }
+    assert_equal "green", m.color
+    assert_equal "Washington, DC", m.location.address
+    assert_equal "tiny", m.size
+    assert_equal "B", m.label
+    assert_equal "http://www.google.com", m.icon
+    assert_equal false, m.shadow
+  end
+
+  def test_get_string
+    m = default_marker
+    s = nil
+    assert_nothing_raised {s = m.to_s}
+    assert_equal 6, s.split("|").length
+    assert s.include?(CGI.escape("Washington, DC"))
+    assert s.include?("color:green")
+    assert s.include?("icon:http://www.google.com")
+  end
+
+  private
+  def default_marker
+    MapMarker.new(:color => "green",
+                  :location => MapLocation.new(:address => "Washington, DC"),
+                  :size => "tiny",
+                  :label => "B",
+                  :icon => "http://www.google.com",
+                  :shadow => false)
+  end
+end

data/test/tc_map_path_and_polygon.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'cgi'
+require File.dirname(__FILE__) +  '/../lib/googlestaticmap'
+
+class MapPathAndPolygonTest < Test::Unit::TestCase #:nodoc: all
+  def test_exception_no_points
+    m = MapPath.new
+    assert_raise Exception do
+      m.to_s
+    end
+  end
+
+  def test_exception_empty_points
+    m = MapPath.new
+    m.points = [MapLocation.new(:address => "asdf")]
+    assert_raise Exception do
+      m.to_s
+    end
+  end
+
+  def test_set_parameters
+    p = nil
+    assert_nothing_raised { p = default_path }
+    assert_equal 2, p.weight
+    assert_equal "0xFF0000FF", p.color
+    assert_equal 2, p.points.length
+  end
+
+  def test_get_string
+    p = default_path
+    s = nil
+    assert_nothing_raised { s = p.to_s }
+    assert_equal 4, s.split("|").length
+    assert s.include?("color:0xFF0000FF")
+    assert s.include?("loc1")
+    assert s.include?("loc2")
+  end
+
+  def test_polygon
+    # Polygon inherits from MapPath and uses MapPath's to_s method, so only
+    # limited testing needs to happen here
+    p = nil
+    assert_nothing_raised do
+      p = MapPolygon.new(:fillcolor => "0xFFFF00FF",
+                         :color => "0xFF0000FF",
+                         :points => [MapLocation.new(:address => "loc1"),
+                                     MapLocation.new(:address => "loc2")])
+    end
+    assert_equal "0xFFFF00FF", p.fillcolor
+    assert_equal "0xFF0000FF", p.color
+  end
+
+  private
+  def default_path
+    MapPath.new(:weight => 2, :color => "0xFF0000FF",
+                :points => [MapLocation.new(:address => "loc1"),
+                            MapLocation.new(:address => "loc2")])
+  end
+
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: googlestaticmap
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Brent Sowers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-18 00:00:00 Z
+dependencies: []
+
+description: Easily retrieve single PNG, GIF, or JPG map images from Google with your own custom markers and paths using the Static Maps API service with this gem.  Simply set the attributes you want for your map and GoogleStaticMap will take care of getting the map for you, or giving your the URL to retrieve the map.
+email: brent@coordinatecommons.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- History.txt
+files: 
+- lib/googlestaticmap.rb
+- lib/googlestaticmap_helper.rb
+- test/tc_map_path_and_polygon.rb
+- test/tc_map_location.rb
+- test/tc_google_static_map.rb
+- test/tc_helper.rb
+- test/tc_map_marker.rb
+- README
+- History.txt
+homepage: http://www.coordinatecommons.com/googlestaticmap/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: Class for retrieving maps from the Google Maps Static API service
+test_files: 
+- test/tc_map_path_and_polygon.rb
+- test/tc_map_location.rb
+- test/tc_google_static_map.rb
+- test/tc_helper.rb
+- test/tc_map_marker.rb