gmaps4rails 1.5.1 → 1.5.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gmaps4rails (1.5.1)
+    gmaps4rails (1.5.2)
 
 GEM
   remote: http://rubygems.org/

data/app/assets/javascripts/gmaps4rails/gmaps4rails.base.js.coffee

@@ -415,37 +415,36 @@ class @Gmaps4Rails
     if @map_options.auto_adjust or @map_options.bounds isnt null
       @boundsObject = @createLatLngBounds()
 
-    #if autodjust is true, must get bounds from markers polylines etc...
-    if @map_options.auto_adjust
-      #from markers
-      @extendBoundsWithMarkers()
-
-      #from polylines:
-      for polyline in @polylines
-        polyline_points = polyline.serviceObject.latLngs.getArray()[0].getArray()
-        for point in polyline_points
-          @boundsObject.extend point
-
-      #from polygons:
-      for polygon in @polygons
-        polygon_points = polygon.serviceObject.latLngs.getArray()[0].getArray()
-        for point in polygon_points
-          @boundsObject.extend point
-
-      #from circles
-      for circle in @circles
-        @boundsObject.extend(circle.serviceObject.getBounds().getNorthEast())
-        @boundsObject.extend(circle.serviceObject.getBounds().getSouthWest())
-
-    #in every case, I've to take into account the bounds set up by the user
-    for bound in @map_options.bounds
-      #create points from bounds provided
-      #TODO:only works with google maps
-      bound = @createLatLng(bound.lat, bound.lng)
-      @boundsObject.extend bound
-
-    #SECOND_STEP: ajust the map to the bounds
-    if @map_options.auto_adjust or @map_options.bounds.length > 0
+      #if autodjust is true, must get bounds from markers polylines etc...
+      if @map_options.auto_adjust
+        #from markers
+        @extendBoundsWithMarkers()
+
+        #from polylines:
+        for polyline in @polylines
+          polyline_points = polyline.serviceObject.latLngs.getArray()[0].getArray()
+          for point in polyline_points
+            @boundsObject.extend point
+
+        #from polygons:
+        for polygon in @polygons
+          polygon_points = polygon.serviceObject.latLngs.getArray()[0].getArray()
+          for point in polygon_points
+            @boundsObject.extend point
+
+        #from circles
+        for circle in @circles
+          @boundsObject.extend(circle.serviceObject.getBounds().getNorthEast())
+          @boundsObject.extend(circle.serviceObject.getBounds().getSouthWest())
+
+      #in every case, I've to take into account the bounds set up by the user
+      for bound in @map_options.bounds
+        #create points from bounds provided
+        #TODO:only works with google maps
+        bound = @createLatLng(bound.lat, bound.lng)
+        @boundsObject.extend bound
+
+      #SECOND_STEP: ajust the map to the bounds
 
       #if autozoom is false, take user info into account
       if !@map_options.auto_zoom

data/lib/gmaps4rails.rb

@@ -8,11 +8,6 @@ module Gmaps4rails
        ActionView::Base.send :include, Gmaps4railsHelper
      end
      
-     initializer "deprecation warning" do |app|
-       warn "[Gmaps4rails]: DEPRECATION: Javascript Gmaps.map.map is now deprecated and will be removed in later version. Please use Gmaps.map.serviceObject instead."
-       warn "[Gmaps4rails]: Be sure to run 'rails g gmaps4rails:install' to get js and css files in your app they are not added automatically anymore see Readme on Github"
-     end
-     
   end
   
   class Railtie < Rails::Railtie

data/lib/gmaps4rails/geocoding.rb

@@ -48,7 +48,6 @@ module Gmaps4rails
     #parse result if result received properly
     if response.is_a?(Net::HTTPSuccess)             
       #parse the json
-      #parse = Crack::JSON.parse(response.body)
       parse = JSON.parse(response.body)
       #check if google went well
       if parse["status"] == "OK"
@@ -78,7 +77,6 @@ module Gmaps4rails
   def Gmaps4rails.handle_destination_response(request, response, output)
     if response.is_a?(Net::HTTPSuccess)             
       #parse the json
-      #parse = Crack::JSON.parse(response.body)
       parse = JSON.parse(response.body)
       #check if google went well
       if parse["status"] == "OK"

data/lib/gmaps4rails/js_builder.rb

@@ -1,14 +1,15 @@
 module Gmaps4rails
   
   def Gmaps4rails.create_js_from_hash(hash)
-    ::Gmaps4rails::JsBuilder.new.create_js_from_hash(hash)
+    ::Gmaps4rails::JsBuilder.new(hash).create_js
   end
   
   class JsBuilder
     
-    DEFAULT_MAP_ID     = "map"
-    
-    #the variable 'hash' must have the following structure
+    DEFAULT_MAP_ID = "map"
+    DATA_KEYS      = [:markers, :polylines, :polygons, :circles, :direction, :kml]
+
+    #the 'option_hash' must have the following structure
     #{  
     #   :map_options => hash,
     #   :markers     => { :data => json, :options => hash },
@@ -18,102 +19,145 @@ module Gmaps4rails
     #   :direction   => { :data => hash, :options => hash },
     #   :kml         => { :data => json, :options => hash }
     #}
-    #should be with only symbol keys or with indifferent access
-    def create_js_from_hash(hash)
-      result = Array.new
-      map_id = "Gmaps." + get_map_id(hash[:map_options])
-
-      #means we are creating a new map
-      result << "#{map_id} = new #{get_constructor hash[:map_options] }" + ";"
-      result << "Gmaps.#{js_function_name hash } = function() {"
-      result << create_map_js(hash[:map_options], map_id) unless hash[:map_options].nil?
-      result << "#{map_id}.initialize();"
-
-      hash.each do |category, content| #loop through options hash
-        skipped_categories = [:map_options, :last_map, :scripts]
-        unless skipped_categories.include? category.to_sym
-          if category.to_sym == :direction
-            result << create_direction_js(content, map_id)
-          else  
-            result << create_general_js(content, map_id, category)
-          end
+    #should be with only symbol keys or with indifferent access    
+    def initialize(option_hash)
+      @js   = Array.new
+      @hash = option_hash
+    end
+
+    def create_js
+      @js << "#{gmap_id} = new #{ map_constructor };"
+      @js << "Gmaps.#{js_function_name} = function() {"
+      
+      process_map_options
+      
+      @js << "#{gmap_id}.initialize();"
+
+      process_data
+
+      @js << "#{gmap_id}.adjustMapToBounds();"
+      @js << "#{gmap_id}.callback();"
+      @js << "};"
+      @js << "Gmaps.oldOnload = window.onload;\n window.onload = function() { Gmaps.triggerOldOnload(); Gmaps.loadMaps(); };" if load_map?
+      
+      @js * ("\n")
+    end
+
+    def process_map_options
+      return unless map_options
+      map_options.each do |option_key, option_value|
+        next if [:class, :container_class].include? option_key.to_sym
+        case option_key.to_sym 
+        when :bounds, :raw #particular case, render the content unescaped
+          @js << "#{gmap_id}.map_options.#{option_key} = #{option_value};"
+        else
+          @js << "#{gmap_id}.map_options.#{option_key} = #{option_value.to_json};"
         end
       end
-      result << "#{map_id}.adjustMapToBounds();"
-      result << "#{map_id}.callback();"
+    end
 
-      result << "};"
-      if hash[:last_map].nil? || hash[:last_map] == true
-        result << "Gmaps.oldOnload = window.onload;\n window.onload = function() { Gmaps.triggerOldOnload(); Gmaps.loadMaps(); };"
+    def process_data
+      data.each do |name, hash|
+        datum = ::Gmaps4rails::JsBuilder::Datum.new(gmap_id, name, hash)
+        @js.concat datum.create_js
       end
-
-      result * ('
-')
     end
     
-    def js_function_name(hash)
-      "load_" + get_map_id(hash[:map_options])
+    def map_options
+      @hash[:map_options]
     end
-
-    def get_map_id(hash)
-      hash.nil? || hash[:id].nil? ? DEFAULT_MAP_ID : hash[:id]
+    
+    def data
+      @hash.select{|key, value| DATA_KEYS.include?(key.to_sym) }
     end
-
-    def get_constructor(hash)
-      hash.nil? || hash[:provider].nil? ? "Gmaps4RailsGoogle()" : "Gmaps4Rails#{hash[:provider].capitalize}()"
+    
+    def load_map?
+      @hash[:last_map].nil? || @hash[:last_map] == true
+    end
+    
+    def js_function_name
+      "load_" + map_id
     end
 
-    def create_map_js(map_hash, map_id)
-      output = Array.new
-      skipped_keys = [:class, :container_class]
-      map_hash.each do |option_k, option_v|
-        unless skipped_keys.include? option_k.to_sym
-          case option_k.to_sym 
-          when :bounds, :raw #particular case, render the content unescaped
-            output << "#{map_id}.map_options.#{option_k} = #{option_v};"
-          else
-            output << "#{map_id}.map_options.#{option_k} = #{option_v.to_json};"
-          end
+    def gmap_id
+      @gmap_id ||= "Gmaps." + map_id
+    end
+    
+    def map_id
+      @map_id ||= map_options.try(:[],:id) || DEFAULT_MAP_ID
+    end
+    
+    def map_constructor
+      map_options.try(:[],:provider) ? "Gmaps4Rails#{map_options[:provider].capitalize}()" : "Gmaps4RailsGoogle()"
+    end
+    
+    class Datum
+      # example:
+      # - name: :markers
+      # - hash: { :data => json, :options => hash }      
+      def initialize(gmap_id, name, hash)
+        @gmap_id, @hash, @name, @js = gmap_id, hash, name, Array.new
+      end
+      
+      def create_js
+        if @name.to_sym == :direction
+          create_direction_js
+        else  
+          create_standard_js
         end
       end
-      output
-    end
+      
+      def create_standard_js
+        @js << "#{@gmap_id}.#{@name} = #{value};"
 
-    def create_general_js(hash, map_id, category)
-      output = Array.new
-      output << "#{map_id}.#{category} = #{hash[:data]};"
-      hash[:options] ||= Array.new
-      hash[:options].each do |option_k, option_v|
-        if option_k.to_sym == :raw
-          output << "#{map_id}.#{category}_conf.#{option_k} = #{option_v};"
-        else
-          output << "#{map_id}.#{category}_conf.#{option_k} = #{option_v.to_json};"
-        end	
+        set_configuration_variables
+
+        @js << "#{@gmap_id}.create_#{@name}();"
       end
-      output << "#{map_id}.create_#{category}();"
-      output
-    end
 
-    def create_direction_js(hash, map_id)
-      output = Array.new
-      output << "#{map_id}.direction_conf.origin = '#{hash["data"]["from"]}';"
-      output << "#{map_id}.direction_conf.destination = '#{hash["data"]["to"]}';"
-      hash[:options] ||= Array.new
-  	  hash[:options].each do |option_k, option_v|
-        if option_k.to_sym == :waypoints
-          waypoints = Array.new
-          option_v.each do |waypoint|
-            waypoints << { "location" => waypoint, "stopover" => true }.to_json
+      def create_direction_js
+        @js << "#{@gmap_id}.direction_conf.origin = '#{value["from"]}';"
+        @js << "#{@gmap_id}.direction_conf.destination = '#{value["to"]}';"
+
+        set_direction_variables
+
+        @js << "#{@gmap_id}.create_direction();"
+      end
+
+      def set_configuration_variables
+        return unless options
+        options.each do |option_key, option_value|
+          @js << if option_key.to_sym == :raw
+                   "#{@gmap_id}.#{@name}_conf.#{option_key} = #{option_value};"
+                 else
+                   "#{@gmap_id}.#{@name}_conf.#{option_key} = #{option_value.to_json};"
+                 end	
+        end
+      end
+
+      def set_direction_variables
+        return unless options
+        options.each do |option_key, option_value|
+          if option_key.to_sym == :waypoints
+            waypoints = Array.new
+            option_value.each do |waypoint|
+              waypoints << { "location" => waypoint, "stopover" => true }.to_json
+            end
+            @js << "#{@gmap_id}.direction_conf.waypoints = [#{waypoints * (",")}];"
+          else
+            @js << "#{@gmap_id}.direction_conf.#{option_key} = #{option_value.to_json};"
           end
-          output << "#{map_id}.direction_conf.waypoints = [#{waypoints * (",")}];"
-        else #option_k != "waypoint"
-          output << "#{map_id}.direction_conf.#{option_k} = #{option_v.to_json};"
         end
-      end #end .each
-      output << "#{map_id}.create_direction();"
-      output
+      end
+      
+      def options
+        @hash[:options]
+      end
+      
+      def value
+        @hash[:data]
+      end
     end
-    
   end
 
 

data/lib/gmaps4rails/version.rb

@@ -1,3 +1,3 @@
 module Gmaps4rails
-  VERSION = "1.5.1"
+  VERSION = "1.5.2"
 end

data/spec/base/base_spec.rb

@@ -1,45 +1,5 @@
 require 'spec_helper'
 
-describe "JS building methods" do
-  
-  subject { ::Gmaps4rails::JsBuilder.new }
-  
-  describe "constructor name retrieval" do
-    it "should render google if nothing passed" do
-      subject.get_constructor(nil).should eq "Gmaps4RailsGoogle()"
-    end
-    
-    it "should render proper provider when provided" do
-      options_hash = { "provider" => "bing" }
-      subject.get_constructor(options_hash.with_indifferent_access).should eq "Gmaps4RailsBing()"
-      
-      options_hash = { "provider" => "mapquest" }
-      subject.get_constructor(options_hash.with_indifferent_access).should eq "Gmaps4RailsMapquest()"
-      
-      options_hash = { "provider" => "openlayers" }
-      subject.get_constructor(options_hash.with_indifferent_access).should eq "Gmaps4RailsOpenlayers()"
-    end
-  end
-  
-  describe "map ID retrieval" do
-    it "should return the default ID when nothing is passed" do
-      options_hash = nil
-      subject.get_map_id(options_hash).should eq subject.class::DEFAULT_MAP_ID
-    end
-  
-    it "should return the default ID when no id is passed within map_options" do
-      options_hash = { "foo" => "bar" }
-      subject.get_map_id(options_hash).should eq subject.class::DEFAULT_MAP_ID
-    end
-  
-    it "should return the proper ID when id passed" do
-      options_hash = { "id" => "foo" }
-      subject.get_map_id(options_hash.with_indifferent_access).should eq "foo"    
-    end
-  
-  end
-end
-
 describe "to_gmaps4rails for hash" do  
   it "should accept hashes with indifferent access" do
     hash1 = {:markers => {:data => @json, :options => {:do_clustering => true, :draggable => true  } }}
@@ -163,7 +123,7 @@ describe "to_gmaps4rails for hash" do
     
     it "should not call map builder if not last_map" do
       hash = {:last_map => false}
-      hash.to_gmaps4rails.should_not include "window.onload = Gmaps.loadMaps;"
+      hash.to_gmaps4rails.should_not include "window.onload"
     end
 
     it "should call map builder if last_map" do

data/spec/dummy/app/assets/javascripts/application.js

@@ -10,6 +10,6 @@
 // WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
 // GO AFTER THE REQUIRES BELOW.
 //
-//= require jquery
-//= require jquery_ujs
-//#= require_tree .
+// require jquery
+// require jquery_ujs
+//= require_tree ./gmaps4rails

data/spec/dummy/app/models/user.rb

@@ -3,4 +3,10 @@ class User < ActiveRecord::Base
   
   attr_accessor :lat_test, :long_test, :bool_test
   
+  after_initialize :set_lat_test
+  
+  def set_lat_test
+    self.lat_test = address 
+  end
+  
 end

data/spec/dummy/app/views/users/index.html.erb

@@ -70,12 +70,24 @@ window.onload =alert('ok');
  <%#= gmaps(:map_options => { :auto_adjust => true }, 
    :markers => {
      :data => @json,
-     #:options => {:do_clustering => true}
+     :options => {:do_clustering => true}
     }) %>
 
+<%#= gmaps("markers" => { "data" => @json, "options" => { 
+  "picture" => "/logo.png", 
+  "width" => 30, "marker_length" => 32 } }) %>
+
+
 <%#= gmaps( {:map_options => { :disableDefaultUI => true, :auto_adjust => true, :center_on_user => true, :detect_location => true,  :center_latitude => 41.574361,
  :center_longitude => -72.949219 }}) %>
-<%= gmaps(:markers => {:data => @json, :options => {:do_clustering => false, "custom_infowindow_class" => "yellow", :raw => "{ flat: true, draggable: true}" } },
+ <%#= gmaps(:map_options => {:type => "ROADMAP"}, 
+           :markers => {:data => @json,
+                        :options => {"list_container" => "markers_list" }
+                       })%>
+<div id="markers_list"></div>
+<%= gmaps(:markers => {:data => @json}, :map_options =>
+    {:auto_adjust => false, :bounds => '[{"lat":42.3124,"lng":-71.1712},{"lat":42.3997,"lng":-71.0531}]', :auto_zoom => false }) %>
+<%#= gmaps(:markers => {:data => @json, :options => {:do_clustering => false, "custom_infowindow_class" => "yellow", :raw => "{ flat: true, draggable: true}" } },
           :polygons => {:data =>  '[[
   {"lng": 5.190262, "lat": 25.774252},
   {"lng": 7.118292, "lat": 45.466465},

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmaps4rails
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000 Z
+date: 2012-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -346,7 +346,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2348507473355438696
+      hash: 3704430434536150863
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -355,7 +355,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2348507473355438696
+      hash: 3704430434536150863
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.21