google_static_maps_helper 1.3.5 → 1.3.6

data/VERSION

@@ -1 +0,0 @@
-1.3.5

data/spec/google_static_maps_helper_spec.rb

@@ -1,62 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe GoogleStaticMapsHelper do
-  describe "Friendly DSL API" do
-    describe "url_for" do
-      before do
-        GoogleStaticMapsHelper.size = '300x500'
-        GoogleStaticMapsHelper.sensor = false
-      end
-
-      it "should have a responding method" do
-        GoogleStaticMapsHelper.respond_to?(:url_for).should be_true
-      end
-
-      it "should be possible to add markers to map through a b block" do
-        out = GoogleStaticMapsHelper.url_for do
-          marker :lat => 1, :lng => 2
-        end
-
-        out.should include('markers=color:red|size:mid|1,2')
-      end
-
-      it "should be possible to override the default map construction values" do
-        out = GoogleStaticMapsHelper.url_for(:size => '600x400') do
-          marker :lat => 1, :lng => 2
-        end
-
-        out.should include('size=600x400')
-      end
-
-      it "should be able to add paths" do
-        point = {:lat => 1, :lng => 2}
-        point2 = {:lat => 3, :lng => 4}
-
-        out = GoogleStaticMapsHelper.url_for do
-          path point, point2, :color => :red, :encode_points => false
-        end
-
-        out.should include('path=color:red|1,2|3,4')
-      end
-
-      it "should be possible to use inside a class, using attributes of that class" do
-        class TestingClass
-          attr_reader :location
-
-          def initialize
-            @location = {:lat => 1, :lng => 5} 
-          end
-
-          def url
-            GoogleStaticMapsHelper.url_for do |map|
-              map.marker location
-            end
-          end
-        end
-
-        TestingClass.new.url.should include('markers=color:red|size:mid|1,5')
-      end
-    end
-  end
-end

data/spec/location_spec.rb

@@ -1,142 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe GoogleStaticMapsHelper::Location do
-  before :each do
-    @location_hash = {:lat => 10, :lng => 20}
-    @location_object = mock(:location, @location_hash)
-  end
-  
-  describe "initialize" do
-    it "should raise ArgumentError if no arguments are given" do
-      lambda {GoogleStaticMapsHelper::Location.new}.should raise_error(ArgumentError)
-    end
-
-    describe "get location as object" do
-      [:lat, :lng].each do |location_property|
-        it "should extract #{location_property} from first argument if that is object" do
-          marker = GoogleStaticMapsHelper::Location.new(@location_object)
-          marker.send(location_property).should == @location_object.send(location_property)
-        end
-      end
-
-      it "should raise NoLngMethod if object doesn't respond to lng" do
-        lambda {GoogleStaticMapsHelper::Location.new(mock(:location, :lat => 10))}.should raise_error(GoogleStaticMapsHelper::Location::NoLngMethod)
-      end
-
-      it "should raise NoLatMethod if object doesn't respond to lat" do
-        lambda {GoogleStaticMapsHelper::Location.new(mock(:location, :lng => 20))}.should raise_error(GoogleStaticMapsHelper::Location::NoLatMethod)
-      end
-    end
-
-    describe "get location from hash" do
-      [:lat, :lng].each do |location_property|
-        it "should extract #{location_property} from hash" do
-          marker = GoogleStaticMapsHelper::Location.new(@location_hash)
-          marker.send(location_property).should == @location_object.send(location_property)
-        end
-      end
-      
-      it "should raise NoLngKey if hash doesn't have key lng" do
-        lambda {GoogleStaticMapsHelper::Location.new(:lat => 10)}.should raise_error(GoogleStaticMapsHelper::Location::NoLngKey)
-      end
-
-      it "should raise NoLatKey if hash doesn't have key lat" do
-        lambda {GoogleStaticMapsHelper::Location.new(:lng => 20)}.should raise_error(GoogleStaticMapsHelper::Location::NoLatKey)
-      end
-    end
-  end
-
-  it "should return to_url with its lat and lng value" do
-    GoogleStaticMapsHelper::Location.new(@location_hash).to_url.should == '10,20'
-  end
-
-  describe "reduce and round off lng and lat" do
-    before do
-      @location = GoogleStaticMapsHelper::Location.new(:lng => 0, :lat => 1)
-    end
-
-    [:lng, :lat].each do |attribute|
-      it "should not round #{attribute} when it is a number with a precision less than 6" do
-        @location.send("#{attribute}=", 12.000014)
-        @location.send(attribute).should == 12.000014
-      end
-
-      it "should round #{attribute} when it is a number with a precision above 6" do
-        @location.send("#{attribute}=", 12.0000051)
-        @location.send(attribute).should == 12.000005
-      end
-
-      it "should round and reduce #{attribute} when it's value is a float which can be represented with a descrete value" do
-        @location.send("#{attribute}=", 12.00000000001)
-        @location.send(attribute).to_s.should == "12"
-      end
-    end
-  end
-
-  describe "helper methods" do
-    [
-      [{:lat => 60, :lng => 0}, 0],
-      [{:lat => 60, :lng => 1}, 55597],
-      [{:lat => 61, :lng => 0}, 111195],
-      [{:lat => 60, :lng => 0.01}, 556]
-    ].each do |point_distance|
-      it "should calculate correct distance to another location" do
-        another_point, expected_distance = point_distance
-        base = GoogleStaticMapsHelper::Location.new(:lat => 60, :lng => 0)
-        another_point = GoogleStaticMapsHelper::Location.new(another_point)
-        base.distance_to(another_point).should == expected_distance
-      end
-    end
-
-
-    [
-      [1000, 360, {:lat => 59.841958, :lng => 10.439303}],
-      [1000, 324, {:lat => 59.84024, :lng => 10.428782}],
-      [1000, 114, {:lat => 59.829306, :lng=> 10.45565}],
-      [1000, 18, {:lat => 59.841518, :lng => 10.444835}]
-    ].each do |distance_heading_new_point|
-      it "should calculate new end point with given distance and heading" do
-        distance, heading, excpexted_point = distance_heading_new_point
-        base = GoogleStaticMapsHelper::Location.new(:lat => 59.832964751405214, :lng => 10.439303436108082)
-        new_point = base.endpoint(distance, heading)
-
-        new_point.lat.should == excpexted_point[:lat]
-        new_point.lng.should == excpexted_point[:lng]
-      end
-    end
-
-    describe "endpoints_for_circle_with_radius" do
-      it "should 30 + 1 end points for circle as default" do
-        base = GoogleStaticMapsHelper::Location.new(:lat => 59.832964751405214, :lng => 10.439303436108082)
-        endpoints = base.endpoints_for_circle_with_radius(1000)
-        endpoints.length.should == 31
-      end
-
-      it "should have the same point as start and end (to make a closed circle)" do
-        base = GoogleStaticMapsHelper::Location.new(:lat => 59.832964751405214, :lng => 10.439303436108082)
-        endpoints = base.endpoints_for_circle_with_radius(1000)
-        endpoints.first.should == endpoints.last
-      end
-
-      it "should reley on endpoint method to calculate new endpoints when creating circle points" do
-        base = GoogleStaticMapsHelper::Location.new(:lat => 59.832964751405214, :lng => 10.439303436108082)
-        base.should_receive(:endpoint).with(1000, 0 * 360 / 4)
-        base.should_receive(:endpoint).with(1000, 1 * 360 / 4)
-        base.should_receive(:endpoint).with(1000, 2 * 360 / 4)
-        base.should_receive(:endpoint).with(1000, 3 * 360 / 4)
-        endpoints = base.endpoints_for_circle_with_radius(1000, 4)
-      end
-
-      it "should raise argument error if number of points asked to returned when creating a circle is above 360" do
-        base = GoogleStaticMapsHelper::Location.new(:lat => 59, :lng => 10)
-        lambda {base.endpoints_for_circle_with_radius(1000, 361)}.should raise_error(ArgumentError)
-      end
-
-      it "should raise argument error if number of points asked to returned when creating a circle is less than 1" do
-        base = GoogleStaticMapsHelper::Location.new(:lat => 59, :lng => 10)
-        lambda {base.endpoints_for_circle_with_radius(1000, 0)}.should raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/map_spec.rb

@@ -1,406 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe GoogleStaticMapsHelper::Map do
-  reguire_options = {
-    :size => '600x400',
-    :sensor => false
-  }
-
-  describe "initialize" do
-    before do
-      reguire_options.each_key {|k| GoogleStaticMapsHelper.send("#{k}=", nil)}
-    end
-
-    reguire_options.each_key do |key|
-      it "should raise OptionMissing if #{key} is not given" do
-        option_with_missing_option = reguire_options.dup
-        option_with_missing_option.delete(key)
-        lambda {GoogleStaticMapsHelper::Map.new(option_with_missing_option)}.should raise_error(GoogleStaticMapsHelper::OptionMissing)
-      end
-    end
-
-    it "should raise OptionNotExist if incomming option doesn't exists" do
-      lambda {GoogleStaticMapsHelper::Map.new(reguire_options.merge(:invalid_option => 'error?'))}.should raise_error(GoogleStaticMapsHelper::OptionNotExist)
-    end
-
-    it "should be able to read initialized key option from object" do
-      GoogleStaticMapsHelper::Map.new(reguire_options).key.should == reguire_options[:key]
-    end
-    
-    reguire_options.each_key do |key|
-      it "should use #{key} from GoogleStaticMapsHelper class attribute if set" do
-        option_with_missing_option = reguire_options.dup
-        GoogleStaticMapsHelper.send("#{key}=", option_with_missing_option.delete(key))
-        map = GoogleStaticMapsHelper::Map.new(option_with_missing_option)
-        map.send(key).should == GoogleStaticMapsHelper.send(key)
-      end
-    end
-
-    it "should be able to call new with no arguments if GoogleStaticMapsHelper class attributes are set" do
-      reguire_options.each_pair {|key, value| GoogleStaticMapsHelper.send("#{key}=", value)}
-      lambda {GoogleStaticMapsHelper::Map.new}.should_not raise_error
-    end
-  end
-
-  describe "markers" do
-    before :each do
-      @marker = GoogleStaticMapsHelper::Marker.new(:lat => 1, :lng => 2)
-      @map = GoogleStaticMapsHelper::Map.new(reguire_options)
-    end
-
-    it "should be empty as default" do
-      @map.should be_empty
-    end
-
-    it "should be able to push markers onto map" do
-      @map << @marker
-    end
-
-    it "should not be possible to push the same marker twice" do
-      @map << @marker
-      @map << @marker
-      @map.length.should == 1
-    end
-
-    it "should be able to push map << marker << marker" do
-      @map << @marker << GoogleStaticMapsHelper::Marker.new(:lat => 3, :lng => 5)
-      @map.length.should == 2
-    end
-
-    it "should return it's markers via markers" do
-      @map << @marker
-      @map << GoogleStaticMapsHelper::Path.new
-      @map.markers.should == [@marker]
-    end
-  end
-
-  
-  describe "Grouped markers" do
-    before :each do
-      @marker1  = GoogleStaticMapsHelper::Marker.new(:lng => 1, :lat => 2)
-      @marker11 = GoogleStaticMapsHelper::Marker.new(:lng => 3, :lat => 4)
-
-      @marker2  = GoogleStaticMapsHelper::Marker.new(:lng => 5, :lat => 6, :color => 'green')
-      @marker22 = GoogleStaticMapsHelper::Marker.new(:lng => 7, :lat => 8, :color => 'green')
-      @map = GoogleStaticMapsHelper::Map.new(:size => @size, :sensor => @sensor)
-    end
-
-    it "should return options_to_url_params as key, array with markers as value" do
-      @map << @marker1
-      @map << @marker11
-      @map << @marker2
-      @map << @marker22
-      @map.grouped_markers.should == {
-        @marker1.options_to_url_params => [@marker1, @marker11],
-        @marker2.options_to_url_params => [@marker2, @marker22]
-      }
-    end
-  end
-
-  describe "paths" do
-    before do
-      @path = GoogleStaticMapsHelper::Path.new
-      @point = GoogleStaticMapsHelper::Location.new(:lat => 1, :lng => 2)
-      @point2 = GoogleStaticMapsHelper::Location.new(:lat => 3, :lng => 4)
-      @path << @point << @point2
-
-      @map = GoogleStaticMapsHelper::Map.new(reguire_options)
-    end
-    
-    it "should be able to push paths on to map" do
-      @map << @path
-      @map.first.should == @path
-    end
-
-    it "should be able to paths via paths" do
-      @marker = GoogleStaticMapsHelper::Marker.new(:lat => 1, :lng => 2)
-      @map << @path
-      @map << @marker
-      @map.paths.should == [@path]
-    end
-  end
-
-
-  describe "size" do
-    before do
-      @map = GoogleStaticMapsHelper::Map.new(reguire_options)
-      @map.size = '300x400'
-    end
-
-    it "should return map's width" do
-      @map.width.should == 300
-    end
-
-    it "should return map's height" do
-      @map.height.should == 400
-    end
-
-    it "should be able to set width with width :-)" do
-      @map.width = '300'
-      @map.width.should == 300
-    end
-
-    it "should be able to set height" do
-      @map.height = '300'
-      @map.height.should == 300
-    end
-
-    it "should be able to set width and height via size as an array" do
-      @map.size = [200, 300]
-      @map.size.should == '200x300'
-    end
-
-    it "should be able to set width and height via size as a hash" do
-      @map.size = {:width => 100, :height => 500}
-      @map.size.should == '100x500'
-    end
-
-    it "should be possible to only set height via size as a hash" do
-      @map.size = {:height => 500}
-      @map.size.should == '300x500'
-    end
-
-    it "should be possible to only set width via size as a hash" do
-      @map.size = {:width => 500}
-      @map.size.should == '500x400'
-    end
-
-    it "should raise an error if width is above 640px as it is not supported by Google Maps" do
-      lambda {@map.width = 641}.should raise_error
-    end
-
-    it "should raise an error if height is above 640px as it is not supported by Google Maps" do
-      lambda {@map.height = 641}.should raise_error
-    end
-  end
-
-  describe "format" do
-    before do
-      @map = GoogleStaticMapsHelper::Map.new(reguire_options)
-    end
-
-    %w{png png8 png32 gif jpg jpg-basedline}.each do |format|
-      it "should be possible to set a format to #{format}" do
-        @map.format = format
-        @map.format.should == format
-      end
-    end
-
-    it "should be able to set format as symbol" do
-      @map.format = :jpg
-      @map.format.should == 'jpg'
-    end
-
-    it "should raise an error if format is not supported" do
-      lambda {@map.format = :not_supported}.should raise_error(GoogleStaticMapsHelper::UnsupportedFormat)
-    end
-  end
-
-  describe "map type" do
-    before do
-      @map = GoogleStaticMapsHelper::Map.new(reguire_options)
-    end
-
-    %w{roadmap satellite terrain hybrid}.each do |type|
-      it "should be possible to set map type to #{type}" do
-        @map.maptype = type
-        @map.maptype.should == type
-      end
-    end
-
-    it "should be possible to set map type as a symbol" do
-      @map.maptype = :satellite
-      @map.maptype.should == 'satellite'
-    end
-
-    it "should raise error if map type is not supported" do
-      lambda {@map.maptype = :not_supported}.should raise_error(GoogleStaticMapsHelper::UnsupportedMaptype)
-    end
-  end
-
-  describe "URL" do
-    before :each do
-      @key = 
-      @size = '400x600'
-      @sensor = false
-      @map = GoogleStaticMapsHelper::Map.new(:size => @size, :sensor => @sensor)
-      
-      @marker1  = GoogleStaticMapsHelper::Marker.new(:lng => 1, :lat => 2)
-      @marker11 = GoogleStaticMapsHelper::Marker.new(:lng => 3, :lat => 4)
-
-      @marker2  = GoogleStaticMapsHelper::Marker.new(:lng => 5, :lat => 6, :color => 'green')
-      @marker22 = GoogleStaticMapsHelper::Marker.new(:lng => 7, :lat => 8, :color => 'green')
-
-      @marker3 = GoogleStaticMapsHelper::Marker.new(:lng => 9, :lat => 10, :icon => 'http://image.com/')
-      @marker33 = GoogleStaticMapsHelper::Marker.new(:lng => 11, :lat => 12, :icon => 'http://image.com/')
-    end
-
-    describe "valid state to run URL" do
-      it "should raise exception if called with no markers nor center and zoom" do
-        lambda{@map.url}.should raise_error(GoogleStaticMapsHelper::BuildDataMissing)
-      end
-
-      it "should not raise exception if markers are in map" do
-        @map << @marker1
-        lambda{@map.url}.should_not raise_error(GoogleStaticMapsHelper::BuildDataMissing)
-      end
-
-      it "should not raise exception if center and zoom is set" do
-        @map.zoom = 1
-        @map.center = '1,1'
-        lambda{@map.url}.should_not raise_error(GoogleStaticMapsHelper::BuildDataMissing)
-      end
-    end
-
-    describe "required parameters" do
-      before :each do
-        @map.zoom = 1
-        @map.center = '1,1'
-      end
-
-      it "should start with the URL to the API" do
-        @map.url.should include(GoogleStaticMapsHelper::API_URL)
-      end
-
-      it "should include the key" do
-        @map.key_without_warning = 'MY_GOOGLE_KEY'
-        @map.url.should include("key=MY_GOOGLE_KEY")
-      end
-
-      it "should not include key if it's nil" do
-        @map.key_without_warning = nil
-        @map.url.should_not include("key=")
-      end
-      
-      it "should include the size" do
-        @map.url.should include("size=#{@size}")
-      end
-      
-      it "should include the sensor" do
-        @map.url.should include("sensor=#{@sensor}")
-      end
-
-      it "should not include format as default" do
-        @map.url.should_not include("format=")
-      end
-
-      it "should include format if it has been set" do
-        @map.format = :jpg
-        @map.url.should include("format=jpg")
-      end
-
-      it "should not include map type as default" do
-        @map.url.should_not include("maptype=")
-      end
-
-      it "should include map type if it has been set" do
-        @map.maptype = :satellite
-        @map.url.should include("maptype=satellite")
-      end
-    end
-
-    describe "with no markers in map" do
-      before :each do
-        @map.zoom = 1
-        @map.center = '1,1'
-      end
-      
-      it "should contain center=2,3" do
-        @map.url.should include("center=1,1")
-      end
-      
-      it "should contain zoom=1" do
-        @map.url.should include("zoom=1")
-      end
-
-      it "should not include markers param" do
-        @map.url.should_not include("markers=")
-      end
-    end
-
-
-    describe "with markers, no one grouped" do
-      before :each do
-        @map << @marker1
-        @map << @marker2
-        @map << @marker3
-      end
-      
-      [
-        ['sensor', 'false'],
-        ['size', '400x600'],
-        ['markers', 'color:green|size:mid|6,5'],
-        ['markers', 'color:red|size:mid|2,1'],
-        ['markers', 'icon:http://image.com/|10,9']
-      ].each do |(key, value)|
-        it "should have key: #{key} and value: #{value}" do
-          @map.url.should include("#{key}=#{value}")
-        end
-      end
-    end
-
-    describe "with markers grouped together" do
-      before :each do
-        @map.sensor = true
-        @map << @marker1
-        @map << @marker11
-        @map << @marker2
-        @map << @marker22
-        @map << @marker3
-        @map << @marker33
-      end
-
-      [
-        ['sensor', 'true'],
-        ['size', '400x600'],
-        ['markers', 'color:green|size:mid|6,5|8,7'],
-        ['markers', 'color:red|size:mid|2,1|4,3'],
-        ['markers', 'icon:http://image.com/|10,9|12,11']
-      ].each do |(key, value)|
-        it "should have key: #{key} and value: #{value}" do
-          @map.url.should include("#{key}=#{value}")
-        end
-      end
-    end
-
-    describe "paths" do
-      before do
-        @path = GoogleStaticMapsHelper::Path.new :encode_points => false
-        @point = GoogleStaticMapsHelper::Location.new(:lat => 1, :lng => 2)
-        @point2 = GoogleStaticMapsHelper::Location.new(:lat => 3, :lng => 4)
-        @path << @point << @point2
-      end
-      
-      it "should not include path in url if no paths are represented in the map" do
-        @map.center = '1,2'
-        @map.zoom = 11
-        @map.url.should_not include("path=")
-      end
-
-      it "should include path in url if paths are represented in the map" do
-        @map << @path
-        @map.url.should include("path=")
-      end
-
-      [
-        ['sensor', 'false'],
-        ['size', '400x600'],
-        ['path', 'weight:5|1,2|3,4'],
-      ].each do |pair|
-        key, value = pair
-        it "should have key: #{key} and value: #{value}" do
-          @path.weight = 5
-          @map << @path
-          @map.url.should include("#{key}=#{value}")
-        end
-      end
-    end
-  end
-  
-  it "should provide a helper method named marker which will create a new marker and add it to the map" do
-    map = GoogleStaticMapsHelper::Map.new(reguire_options)
-    map.marker(:lat => 1, :lng => 2)
-    map.length.should eql(1)
-  end
-end