static-gmaps2 0.0.5

data/History.txt

@@ -0,0 +1,46 @@
+=== 0.0.5 / 2010-02-14 by nat.lownes@gmail.com
+* Updated most all of the Ruby API to match the most recent Google Static Maps API.  This includes:
+	- Changed the maximum_url_size to 2048
+	- Changing parameters to match their Google API equivalents. i.e.:
+		- Marker's "alpha_character" can be used simply as :label / Marker#label=
+		- Changed available colors restrictions
+		- Updated marker label restriction to capital letters A-Z, 0-9
+		- Added required sensor parameter to Map
+		- Remove requiring a Google Maps API key.  It can still be used via the original :key parameter.
+	- Updated Marker to accept:
+		- color
+		- label
+		- icon
+		- size
+		- shadow
+* Changed MissingArgument instances to ArgumentError instances
+* Added address support on both Map :center and Marker :location params/setters via a StaticGmaps::Location class.
+* Added block initializer support if you cannot wield a lengthy hash like a weapon.
+* All of these changes maintain backward compatibility with previous versions.
+
+=== 0.0.4 / 2009-02-18 by daniel.mattes@gmx.de
+
+* No Map::default_center, because of auto centering through google when markers.count > 1
+* If no option[:markers] are given, they will be set to []. Otherwise the constant markers array will grow to unlimited.
+* Setting constants like geokit do it.
+  In initializers you can overwrite it like
+  StaticGmaps::default_size = [ 170, 200 ]
+* Now on http://github.com/dmattes/static-gmaps/
+
+=== 0.0.3 / 2008-02-26
+
+* 2 Minor Enhancement:
+  * Now raises exception when there are too many markers.
+  * Now raises exception when the url becomes too long.
+
+=== 0.0.2 / 2008-02-25
+
+* 1 Major Enhancement:
+  * Now supports Markers!
+* 1 Minor Enhancement:
+  * Removed StaticGmaps::Map.to_blob
+
+=== 0.0.1 / 2008-02-25
+
+* 1 major enhancement
+  * Birthday!

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008 John Wulff <johnwulff@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,6 @@
+History.txt
+LICENSE.txt
+Manifest.txt
+Rakefile
+lib/static_gmaps.rb
+spec/static_gmaps_spec.rb

data/Rakefile

@@ -0,0 +1,52 @@
+# The MIT License
+# 
+# Copyright (c) 2008 John Wulff <johnwulff@gmail.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'rubygems'
+require 'hoe'
+require './lib/static_gmaps.rb'
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts 'To use rspec for testing you must install rspec gem:'
+  puts '$ sudo gem install rspec'
+  exit
+end
+
+Hoe.new('static-gmaps', StaticGmaps::version) do |p|
+  p.rubyforge_name = 'static-gmaps'
+  p.author = 'Daniel Mattes'
+  p.email = 'daniel.mattes@gmx.de'
+  p.summary = 'Provides an interface to the Google Static Maps API.'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = ''
+end
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/*.rb']
+end
+
+task :default => :spec
+
+# vim: syntax=Ruby

data/lib/static_gmaps.rb

@@ -0,0 +1,258 @@
+require 'net/http'
+
+module StaticGmaps 
+  @@version = '0.0.5' 
+  
+  #map  
+  @@maximum_url_size = 2048
+  @@maximum_markers  = 50
+  @@default_center   = [ 0, 0 ]
+  @@default_zoom     = 1
+  @@default_size     = [ 500, 400 ]
+  @@default_map_type = :roadmap
+  @@default_key      = 'ABQIAAAAzr2EBOXUKnm_jVnk0OJI7xSosDVG8KKPE1-m51RBrvYughuyMxQ-i1QfUnH94QxWIa6N4U6MouMmBA'
+  @@base_uri         = 'http://maps.google.com/maps/api/staticmap'
+  
+  #marker
+  @@default_latitude        = nil
+  @@default_longitude       = nil
+  @@default_color           = nil
+  @@default_alpha_character = nil
+  @@valid_colors            = [ :black, :brown, :green, :purple, :yellow, :blue, :gray, :orange, :red, :white ]
+  @@valid_alpha_characters  = []    
+  ("A").upto("Z") do |letter|
+    @@valid_alpha_characters << letter
+  end
+  0.upto(9) do |n|
+    @@valid_alpha_characters << n.to_s
+  end
+  
+  [:version, :maximum_url_size, :maximum_markers, :default_center, :default_zoom, :default_size, :default_map_type, :default_key,
+  :default_latitude, :default_longitude, :default_color, :default_alpha_character, :valid_colors, :valid_alpha_characters, :base_uri].each do |sym|
+    class_eval <<-EOS
+      def self.#{sym}
+        @@#{sym}
+      end
+
+      def self.#{sym}=(obj)
+        @@#{sym} = obj
+      end
+    EOS
+  end  
+  
+  class Map
+  
+    attr_accessor :zoom,
+                  :size,
+                  :map_type,
+                  :key,
+                  :markers,
+                  :sensor,
+                  :format
+    
+    def initialize(options = {}, &block)
+      self.center   = options[:center]
+      self.zoom     = options[:zoom]     || StaticGmaps::default_zoom
+      self.size     = options[:size]     || StaticGmaps::default_size
+      self.map_type = options[:map_type] || StaticGmaps::default_map_type
+      self.sensor   = options[:sensor]   || false
+      self.key      = options[:key]
+      self.format   = options[:format]
+      self.markers  = options[:markers]  || [ ]
+      yield self if block_given?
+    end
+    
+    def width
+      size[0]
+    end
+
+    def height
+      size[1]
+    end
+    
+    def center=(array_or_string)
+      @center = Location.new(array_or_string)
+    end
+    
+    def center
+      @center ? @center.value : nil
+    end
+
+    # http://code.google.com/apis/maps/documentation/staticmaps/index.html#URL_Parameters
+    def url
+      raise ArgumentError.new("Size must be set before a url can be generated for Map.") if !size || !size[0] || !size[1]
+      
+      if(!self.center && !(markers && markers.size >= 1))
+        self.center = StaticGmaps::default_center
+      end
+      
+      if !(markers && markers.size >= 1)
+        raise ArgumentError.new("Center must be set before a url can be generated for Map (or multiple markers can be specified).") if !center
+        raise ArgumentError.new("Zoom must be set before a url can be generated for Map (or multiple markers can be specified).") if !zoom
+      end
+      raise "Google will not display more than #{StaticGmaps::maximum_markers} markers." if markers && markers.size > StaticGmaps::maximum_markers
+      parameters = {}
+      parameters[:size]     = "#{size[0]}x#{size[1]}"
+      parameters[:key]      = "#{key}"                    if key
+      parameters[:map_type] = "#{map_type}"               if map_type
+      parameters[:center]   = "#{@center.to_s}" if center
+      parameters[:zoom]     = "#{zoom}"                   if zoom
+      parameters[:markers]  = "#{markers_url_fragment}"   if markers_url_fragment
+      parameters[:sensor]   = "#{sensor}"
+      parameters[:format]   = "#{format}"                 if format
+      parameters = parameters.to_a.sort { |a, b| a[0].to_s <=> b[0].to_s }
+      parameters = parameters.collect { |parameter| "#{parameter[0]}=#{parameter[1]}" }
+      parameters = parameters.join '&'
+      x = "#{StaticGmaps.base_uri}?#{parameters}"
+      raise "Google doesn't like the url to be longer than #{StaticGmaps::maximum_url_size} characters.  Try fewer or less precise markers." if x.size > StaticGmaps::maximum_url_size
+      return x
+    end  
+    
+    def markers_url_fragment
+      if markers && markers.any?
+        return markers.collect{|marker| marker.url_fragment }.join('&markers=')
+      else
+        return nil
+      end
+    end
+
+    def to_blob
+      fetch
+      return @blob
+    end
+
+    private
+      def fetch
+        if !@last_fetched_url || @last_fetched_url != url || !@blob
+          uri = URI.parse url
+          request = Net::HTTP::Get.new uri.path
+          response = Net::HTTP.start(uri.host, uri.port) { |http| http.request request }
+          @blob = response.body
+          @last_fetched_url = url
+        end
+      end
+  end
+
+  # http://code.google.com/apis/maps/documentation/staticmaps/index.html#Markers
+  class Marker
+    
+    attr_reader :color,
+                :label,
+                :size,
+                :icon,
+                :shadow
+    
+    def initialize(options = {}, &block)
+      self.location        = options[:location]        || [StaticGmaps::default_latitude, StaticGmaps::default_longitude]
+      self.label           = options[:label]           || StaticGmaps::default_alpha_character
+      self.color           = options[:color]           || StaticGmaps::default_color
+      # original api compatibility
+      self.label           = options[:alpha_character] if options[:alpha_character]
+      self.latitude        = options[:latitude]        if options[:latitude]
+      self.longitude       = options[:longitude]       if options[:longitude]
+      yield self if block_given?
+    end
+    
+    def available_parameters
+      [:location, :color, :label, :size, :icon, :shadow]
+    end
+    
+    def attributes
+      self.available_parameters.inject({}) do |store, parameter_name|
+        value = self.send(parameter_name)
+        store[parameter_name] = value if value
+        store
+      end
+    end
+    
+    def color=(value)
+      if value
+        value = value.to_s.downcase.to_sym
+        if !StaticGmaps::valid_colors.include?(value)
+          raise ArgumentError.new("#{value} is not a supported color.  Supported colors are #{StaticGmaps::valid_colors.join(', ')}.")
+        end
+      end
+      @color = value
+    end
+    
+    def icon=(url)
+      @icon = (URI.encode(url, "?|&"))
+    end
+    
+    def location=(array_or_string)
+      @location = Location.new(array_or_string)
+    end
+    
+    def location
+      @location ? @location.value : nil
+    end
+    
+    def latitude=(f)
+      @location.value[0] = f
+    end
+    
+    def longitude=(f)
+      @location.value[1] = f
+    end
+    
+    def latitude
+      @location.value[0] if @location.value.is_a?(Array)
+    end
+    
+    def longitude
+      @location.value[1] if @location.value.is_a?(Array)
+    end
+    
+    def label=(value)
+      if value
+        value = value.to_s.upcase
+        if !StaticGmaps::valid_alpha_characters.include?(value)
+          raise ArgumentError.new("#{value} is not a supported label.  Supported labels are #{StaticGmaps::valid_alpha_characters.join(', ')}.")
+        end
+      end
+      @label = value
+    end
+    
+    # for compatibility with original ruby api
+    def alpha_character=(value)
+      self.label = value
+    end
+    
+    def alpha_character
+      self.label
+    end
+    
+    def url_fragment
+      # markers=color:blue|label:S|62.107733,-145.541936&markers=size:tiny|color:green|Delta+Junction,AK
+      raise ArgumentError.new("Location must be set before a url_fragment can be generated for Marker.") if !location
+      marker_parameter_separator = "|"
+      marker_value_separator = ":"
+      location = @location.to_s
+      str = ""
+      attrs = self.attributes
+      attrs.delete(:location)
+      if !attrs.empty?
+        str << attrs.map {|parameter, value| "#{parameter}#{marker_value_separator}#{value}"}.join(marker_parameter_separator)
+        str << marker_parameter_separator
+      end
+      str << location
+      str
+    end
+  end#Marker
+  
+  class Location
+    attr_reader :value
+    def initialize(coordinates_array_or_address)
+      @value = if coordinates_array_or_address.is_a?(String)
+        URI.encode(coordinates_array_or_address)
+      else
+        coordinates_array_or_address
+      end
+    end
+    
+    def to_s
+      @value.is_a?(Array) ? @value.join(",") : @value
+    end
+  end
+  
+end

data/spec/static_gmaps_spec.rb

@@ -0,0 +1,230 @@
+require 'rubygems'
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'static_gmaps')
+include StaticGmaps
+
+STATIC_GOOGLE_MAP_DEFAULT_PARAMETERS_TEST_IMAGE_PATH = File.join File.dirname(__FILE__), 'test_image.gif'
+
+describe StaticGmaps do
+  describe Map do
+    context "initializing with empty attributes" do
+      before(:each) do 
+        @map = StaticGmaps::Map.new 
+      end
+    
+      #it 'should set center to default'   do @map.center.should   == StaticGmaps::default_center end
+      # no default center, because of auto adjustment
+      it 'should set zoom to default' do
+        @map.zoom.should     == StaticGmaps::default_zoom
+      end
+      it 'should set size to default' do
+        @map.size.should     == StaticGmaps::default_size
+      end
+      it 'should set map_type to default' do
+        @map.map_type.should == StaticGmaps::default_map_type
+      end
+      it 'should not set key if not provided' do
+        @map.key.should be_nil
+      end
+    end # initialize without attr
+    
+    context 'initializing with all attributes' do
+      before(:each) do
+        @marker = StaticGmaps::Marker.new :latitude => 0, :longitude => 0
+        @map = StaticGmaps::Map.new :center   => [ 40.714728, -73.998672 ],
+                                    :zoom     => 12,
+                                    :size     => [ 500, 400 ],
+                                    :map_type => :roadmap,
+                                    :key      => 'ABQIAAAAzr2EBOXUKnm_jVnk0OJI7xSosDVG8KKPE1-m51RBrvYughuyMxQ-i1QfUnH94QxWIa6N4U6MouMmBA',
+                                    :markers  => [ @marker ]
+      end
+      
+      it 'should set center' do 
+        @map.center.should   == [ 40.714728, -73.998672 ] 
+      end
+      it 'should set zoom' do 
+        @map.zoom.should     == 12 
+      end
+      it 'should set size' do 
+        @map.size.should     == [ 500, 400 ] 
+      end
+      it 'should set map_type' do 
+        @map.map_type.should == :roadmap 
+      end
+      it 'should set key if provided' do 
+        @map.key.should      == 'ABQIAAAAzr2EBOXUKnm_jVnk0OJI7xSosDVG8KKPE1-m51RBrvYughuyMxQ-i1QfUnH94QxWIa6N4U6MouMmBA' 
+      end
+      it 'should set markers'  do 
+        @map.markers.should  == [ @marker ] 
+      end
+      
+    end#initialize w/all attrs
+    
+    context 'with default attributes' do
+      before(:each) do
+        @map = StaticGmaps::Map.new
+      end
+
+      it 'should have a url' do
+        @map.url.should == "#{StaticGmaps.base_uri}?center=0,0&map_type=roadmap&sensor=false&size=500x400&zoom=1"
+      end
+      
+      it 'should have a width' do
+        @map.width.should    == 500
+      end
+      
+      it 'should have a height' do
+        @map.height.should   == 400
+      end
+      
+      it 'should set sensor attribute to false' do
+        @map.sensor.should be_false
+      end
+    end
+    
+    context 'with default attributes and markers' do
+      before(:each) do
+        @marker_1 = StaticGmaps::Marker.new :latitude => 10, :longitude => 20, :color => 'green', :label => 'A'
+        @marker_2 = StaticGmaps::Marker.new :latitude => 15, :longitude => 25, :color => 'blue', :label => 'B'
+        @map = StaticGmaps::Map.new :markers  => [ @marker_1, @marker_2 ]
+      end
+      
+      it 'should have a markers_url_fragment' do 
+        # the first "markers" parameter for multiple markers will be added on in Map#url
+        @map.markers_url_fragment.should match(/color:green/)
+        @map.markers_url_fragment.should match(/color:blue/)
+        @map.markers_url_fragment.should match(/label:A/)
+        @map.markers_url_fragment.should match(/label:B/)
+        @map.markers_url_fragment.should match(/10,20/)
+        @map.markers_url_fragment.should match(/15,25/)
+      end
+      
+      it 'should include the markers_url_fragment its url' do 
+        @map.url.should include(@map.markers_url_fragment) 
+      end
+    end
+  end #describe Map
+  
+  describe Marker do 
+    context 'initializing with no attributes' do
+      before(:each) do 
+        @marker = StaticGmaps::Marker.new
+      end
+      it 'should set latitude to default' do 
+        @marker.latitude.should        == StaticGmaps::default_latitude 
+      end
+      it 'should set longitude to default' do
+        @marker.longitude.should       == StaticGmaps::default_longitude
+      end
+      it 'should set color to default'           do
+        @marker.color.should           == StaticGmaps::default_color
+      end
+      it 'should set alpha_character to default' do 
+        @marker.label.should == StaticGmaps::default_alpha_character
+      end
+    end
+    
+    context 'initialize with all attributes' do
+      before(:each) do
+        @marker = StaticGmaps::Marker.new :latitude => 12,
+                                          :longitude => 34,
+                                          :color => 'red',
+                                          :alpha_character => 'z'
+      end
+      
+      it 'should set latitude' do 
+        @marker.latitude.should        == 12
+      end
+      
+      it 'should set longitude' do
+        @marker.longitude.should       == 34
+      end
+      
+      it 'should set color' do
+        @marker.color.should           == :red
+      end
+      
+      it 'should set alpha_character' do 
+        @marker.alpha_character.should == "Z"
+      end
+    end
+    
+    context 'initialize with address as location' do
+      before :each do
+        @address = '1234 Market St. Philadelphia, PA'
+        @marker = Marker.new do |m|
+          m.location = @address
+        end
+      end
+      
+      it 'should return a uri encoded address for location' do
+        @marker.location.should == URI.encode(@address)
+      end
+      
+      it 'should return nil for latitude' do
+        @marker.latitude.should be_nil
+      end
+      
+      it 'should return nil for longitude' do
+        @marker.longitude.should be_nil
+      end
+    end
+    
+    context 'url_fragment ordering' do
+      before :each do
+        @address = '1234 Market St. Philadelphia, PA'
+        @marker = Marker.new do |m|
+          m.location = @address
+          m.color = "red"
+          m.label = 1
+        end
+      end
+      
+      it 'should end with the address/coordinates' do
+        @marker.url_fragment.should match /.PA$/
+      end
+    end
+    
+    context "using a custom icon" do
+      before :each do
+        @uri = 'http://chart.apis.google.com/chart?chst=d_map_pin_icon&chld=home|FFFF00'
+        @marker = Marker.new do |m|
+          m.location = [40.000, -33.000]
+          m.icon = @uri
+        end
+      end
+      
+      it 'should also encode |, &, and ?' do
+        @marker.icon.should == 'http://chart.apis.google.com/chart%3Fchst=d_map_pin_icon%26chld=home%7CFFFF00'
+      end
+      
+    end
+    
+  end #Marker
+  
+  describe Location do
+    before(:each) do
+      @coordinates = [39.967648,-75.156784]
+      @address = '1234 Market St. Philadelphia, PA'
+    end
+    
+    it 'should initialize with either an array or a string' do
+      lambda {
+        Location.new(@coordinates)
+      }.should_not raise_error
+      
+      lambda {
+        Location.new(@address)
+      }.should_not raise_error
+    end
+    
+    it 'should URI.encode an address string' do
+      Location.new(@address).value.should == URI.encode(@address)
+    end
+    
+    it 'should return either array of coordinates or address with Location#value()' do
+      Location.new(@coordinates).value.should == @coordinates
+    end
+  
+  end #describe Location
+end #describe StaticGmaps

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: static-gmaps2
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- John Wulff
+- Daniel Mattes
+- Nat Lownes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-30 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 1
+        - 8
+        - 3
+        version: 1.8.3
+  type: :development
+  version_requirements: *id001
+description: |-
+  == DESCRIPTION:  Provides an interface to the Google Static Maps API V3. Based on static-gmaps
+    == FEATURES/PROBLEMS:  * Provides an interface to the Google Static Maps API.
+email: nat.lownes@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- Rakefile
+- lib/static_gmaps.rb
+- spec/static_gmaps_spec.rb
+has_rdoc: true
+homepage: http://github.com/natlownes/static-gmaps/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- readme.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: static-gmaps
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: Provides an interface to the Google Static Maps API.
+test_files: []
+