gmaps4rails 1.4.8 → 1.5.0.pre

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

@@ -34,6 +34,7 @@ class @Gmaps4RailsGoogle extends Gmaps4Rails
       strokeWeight: 2
       fillColor: "#000000"
       fillOpacity: 0.35
+      clickable: false
 
     #Polyline Styling
     @polylines_conf =         #default style for polylines
@@ -111,7 +112,7 @@ class @Gmaps4RailsGoogle extends Gmaps4Rails
     markerLatLng = @createLatLng(args.Lat, args.Lng)
     #Marker sizes are expressed as a Size of X,Y
     if args.marker_picture == "" and args.rich_marker == null
-      defaultOptions = {position: markerLatLng, map: @map, title: args.marker_title, draggable: args.marker_draggable}
+      defaultOptions = {position: markerLatLng, map: @map, title: args.marker_title, draggable: args.marker_draggable, zIndex: args.zindex}
       mergedOptions  = @mergeObjectWithDefault @markers_conf.raw, defaultOptions
       return new google.maps.Marker mergedOptions
 
@@ -123,6 +124,7 @@ class @Gmaps4RailsGoogle extends Gmaps4Rails
         content:   args.rich_marker
         flat:      if args.marker_anchor == null then false else args.marker_anchor[1]
         anchor:    if args.marker_anchor == null then 0     else args.marker_anchor[0]
+        zIndex:    args.zindex
       })
 
     #default behavior
@@ -132,7 +134,7 @@ class @Gmaps4RailsGoogle extends Gmaps4Rails
     #create or retrieve existing MarkerImages
     markerImage = @createOrRetrieveImage(args.marker_picture, args.marker_width, args.marker_height, imageAnchorPosition)
     shadowImage = @createOrRetrieveImage(args.shadow_picture, args.shadow_width, args.shadow_height, shadowAnchorPosition)
-    defaultOptions = {position: markerLatLng, map: @map, icon: markerImage, title: args.marker_title, draggable: args.marker_draggable, shadow: shadowImage}
+    defaultOptions = {position: markerLatLng, map: @map, icon: markerImage, title: args.marker_title, draggable: args.marker_draggable, shadow: shadowImage,  zIndex: args.zindex}
     mergedOptions  = @mergeObjectWithDefault @markers_conf.raw, defaultOptions
     return new google.maps.Marker mergedOptions
 

data/app/views/gmaps4rails/_gmaps4rails.html.erb

@@ -1,19 +1,20 @@
-<% #thanks to enable_css, user can avoid this css to be loaded
-if enable_css == true && options[:scripts].nil? %>
-  <% unless gmaps4rails_pipeline_enabled? %>
-    <% content_for :head do %>
-      <%= stylesheet_link_tag 'gmaps4rails' %>
-    <% end %>
-	<% end %>
-<% end %>
-
 <% content_for :scripts do %>
+<%= javascript_include_tag *js_dependencies %>
 
-<%= gmaps4rails_js_files(options[:map_options], options[:scripts], enable_js, options[:markers].try(:[], :options)) %>
 <script type="text/javascript" charset="utf-8">
 <%=raw options.to_gmaps4rails %>
 </script>
-
 <% end %>
 
-<%= gmaps4rails_html(options[:map_options]) %>
+<% case dom.map_provider %>
+<% when "mapquest" %>
+<div id="<%= dom.map_id %>" style="width:750px; height:475px;">
+  <!-- TODO: change this style dynamically -->  
+</div>
+<% when "bing" %>
+  <div id="<%= dom.map_id %>" class="<%= dom.map_class %>"></div>
+<% else %>
+<div class="<%= dom.container_class %>"> 
+  <div id="<%= dom.map_id %>" class="<%= dom.map_class %>"></div>
+</div>
+<% end %>

data/gmaps4rails.gemspec

@@ -0,0 +1,38 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "gmaps4rails/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "gmaps4rails"
+  s.version     = Gmaps4rails::VERSION
+  s.authors     = [%q{Benjamin Roth}, %q{David Ruyer}]
+  s.email       = [%q{apnea.diving.deep@gmail.com}, %q{david.ruyer@gmail.com}]
+  s.homepage    = %q{http://github.com/apneadiving/Google-Maps-for-Rails}
+  s.summary     = %q{Maps made easy for Rails 3}
+  s.description = %q{Enables easy display of items (taken from a Rails 3 model) on a Google Maps (JS API V3), OpenLayers, Mapquest and Bing. Geocoding + Directions included.}
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- spec/*`.split("\n")
+
+  s.add_development_dependency "rails", "~> 3.2.1"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "jquery-rails"
+  
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency 'database_cleaner'
+  #s.add_development_dependency "capybara"
+  #s.add_development_dependency 'launchy'
+  
+  s.add_development_dependency "jasmine"
+  
+  s.add_development_dependency "guard", "~> 1.0.1"
+  s.add_development_dependency "guard-spork"
+  s.add_development_dependency 'guard-coffeescript'
+  s.add_development_dependency 'guard-jasmine'
+  s.add_development_dependency "guard-rspec"
+  
+  s.add_development_dependency "factory_girl_rails"  
+  
+  s.add_development_dependency 'pry'
+end

data/lib/gmaps4rails.rb

@@ -8,14 +8,6 @@ module Gmaps4rails
        ActionView::Base.send :include, Gmaps4railsHelper
      end
      
-     initializer "add asset directories to pipeline" do |app|
-       if Rails::VERSION::MAJOR >= 3 && Rails::VERSION::MINOR >= 1
-         app.config.assets.paths << "#{root}/public/stylesheets"
-       else
-         app.middleware.use ::ActionDispatch::Static, "#{root}/public"
-       end
-     end
-     
   end
   
   class Railtie < Rails::Railtie

data/lib/gmaps4rails/acts_as_gmappable.rb

@@ -8,34 +8,55 @@ module Gmaps4rails
     
     module InstanceMethods
       
-      # This is a before_filter to trigger the geocoding and save its results
-
+      # This is a validation method which triggers the geocoding and save its results
       def process_geocoding
         #to prevent geocoding each time a save is made
-        return true if gmaps4rails_options[:check_process] == true && self.send(gmaps4rails_options[:checker]) == true
-        #try to geocode
+        return true if gmaps4rails_prevent_geocoding?
         begin
           coordinates = Gmaps4rails.geocode(self.send(gmaps4rails_options[:address]), gmaps4rails_options[:language], false, gmaps4rails_options[:protocol])
         rescue GeocodeStatus, GeocodeInvalidQuery => e  #address was invalid, add error to address.
           Rails.logger.warn(e)
           errors[gmaps4rails_options[:address]] << gmaps4rails_options[:msg] if Gmaps4rails.condition_eval(self, gmaps4rails_options[:validation])
-        rescue GeocodeNetStatus => e #connection error, No need to prevent save.
+        rescue GeocodeNetStatus => e                    #connection error, No need to prevent save.
           Rails.logger.warn(e)
-          #TODO add customization here?
         else #if no exception, save the values
-          self.send("#{gmaps4rails_options[:lng_column]}=", coordinates.first[:lng]) if self.respond_to?("#{gmaps4rails_options[:lng_column]}=")
-          self.send("#{gmaps4rails_options[:lat_column]}=", coordinates.first[:lat]) if self.respond_to?("#{gmaps4rails_options[:lat_column]}=")
-          unless gmaps4rails_options[:normalized_address].nil?
-            self.send("#{gmaps4rails_options[:normalized_address]}=", coordinates.first[:matched_address])
-          end
-          # Call the callback method to let the user do what he wants with the data
-          self.send(gmaps4rails_options[:callback], coordinates.first[:full_data]) unless gmaps4rails_options[:callback].nil?
-          if Gmaps4rails.condition_eval(self, gmaps4rails_options[:check_process])
-            self.send("#{gmaps4rails_options[:checker]}=", true)
-          end
+          self.gmaps4rails_save_data(coordinates)
         end
       end
-
+      
+      # saves coordinates according to the various options
+      def gmaps4rails_save_data(coordinates)
+        self.send("#{gmaps4rails_options[:lng_column]}=", coordinates.first[:lng])
+        self.send("#{gmaps4rails_options[:lat_column]}=", coordinates.first[:lat])
+        # save normalized address if required
+        self.send("#{gmaps4rails_options[:normalized_address]}=", coordinates.first[:matched_address]) unless gmaps4rails_options[:normalized_address].nil?          
+        # Call the callback method to let the user do what he wants with the data
+        self.send(gmaps4rails_options[:callback], coordinates.first[:full_data]) unless gmaps4rails_options[:callback].nil?
+        # update checker if required
+        self.send("#{gmaps4rails_options[:checker]}=", true) if gmaps4rails_check_geocoding?
+      end
+      
+      # if process_geocoding is a TrueClass or a FalseClass, 'check_process' and 'checker' play an additional role
+      # if process_geocoding is a Proc or a Symbol, 'check_process' and 'checker' are skipped since process_geocoding bears the whole logic
+      def gmaps4rails_prevent_geocoding?
+        if gmaps4rails_options[:process_geocoding].is_a?(TrueClass) || gmaps4rails_options[:process_geocoding].is_a?(FalseClass)
+          return true if !Gmaps4rails.condition_eval(self, gmaps4rails_options[:process_geocoding])
+          Gmaps4rails.condition_eval(self, gmaps4rails_options[:check_process]) && self.send("#{gmaps4rails_options[:checker]}") == true 
+        else
+          !Gmaps4rails.condition_eval(self, gmaps4rails_options[:process_geocoding])
+        end
+      end
+      
+      # Do we have to check the geocoding 
+      def gmaps4rails_check_geocoding?
+        if gmaps4rails_options[:process_geocoding].is_a?(TrueClass) || gmaps4rails_options[:process_geocoding].is_a?(FalseClass)
+          Gmaps4rails.condition_eval(self, gmaps4rails_options[:check_process])
+        else
+          false
+        end
+      end
+      
+      # creates json for one instance 
       def to_gmaps4rails(&block)
         json = "["
         object_json = Gmaps4rails.create_json(self, &block)
@@ -49,26 +70,27 @@ module Gmaps4rails
 
       def acts_as_gmappable args = {}    
         
-        # disable before_filter if explicitly set
-              
-        unless args[:process_geocoding] == false
-          validate :process_geocoding
-        end
+        validate :process_geocoding
         
         #instance method containing all the options to configure the behaviour of the gem regarding the current Model
         define_method "gmaps4rails_options" do
           {
-            :lat_column         => args[:lat]                 || "latitude",
-            :lng_column         => args[:lng]                 || "longitude",
-            :check_process      => args[:check_process].nil?  ?   true : args[:check_process],
-            :checker            => args[:checker]             || "gmaps",
-            :msg                => args[:msg]                 || "Address invalid",
-            :validation         => args[:validation].nil?     ?   true  : args[:validation],
-            :normalized_address => args[:normalized_address], 
-            :address            => args[:address]             || "gmaps4rails_address",
-            :callback           => args[:callback],           
-            :language           => args[:language]            || "en",
-            :protocol           => args[:protocol]            || "http"
+            :process_geocoding  => args[:process_geocoding].nil? ?  true : args[:process_geocoding],
+            :check_process      => args[:check_process].nil?     ?  true : args[:check_process],
+            :checker            => args[:checker]                || "gmaps",
+                                                                 
+            :lat_column         => args[:lat]                    || "latitude",
+            :lng_column         => args[:lng]                    || "longitude",
+                                                                 
+            :msg                => args[:msg]                    || "Address invalid",
+            :validation         => args[:validation].nil?        ?   true  : args[:validation],
+                                                                                                                                 
+            :language           => args[:language]               || "en",
+            :protocol           => args[:protocol]               || "http",
+            
+            :address            => args[:address]                || "gmaps4rails_address",
+            :callback           => args[:callback],
+            :normalized_address => args[:normalized_address]
           }
         end
         

data/lib/gmaps4rails/base.rb

@@ -1,7 +1,8 @@
 require 'gmaps4rails/acts_as_gmappable'
 
-require 'gmaps4rails/js_handler'
-require 'gmaps4rails/json_handler'
+require 'gmaps4rails/js_builder'
+require 'gmaps4rails/json_builder'
+require 'gmaps4rails/view_helper'
 require 'gmaps4rails/geocoding'
 require 'gmaps4rails/google_places'
 require 'gmaps4rails/extensions/array'
@@ -27,20 +28,14 @@ module Gmaps4rails
   
   def Gmaps4rails.condition_eval(object, condition)
     case condition
-    when Symbol     then object.send condition
-    when Proc       then condition.call(object)
-    when TrueClass  then condition
-    when FalseClass then condition
+    when Symbol, String        then object.send condition
+    when Proc                  then condition.call(object)
+    when TrueClass, FalseClass then condition
     end
   end
   
   private
-  
-  # To create valid js, this method escapes everything but Numeric, true or false
-  def Gmaps4rails.filter(data)
-    data.to_json
-  end
-  
+
   # get the response from the url encoded address string
   def Gmaps4rails.get_response(url)
     url = URI.parse(url)

data/lib/gmaps4rails/helper/gmaps4rails_helper.rb

@@ -1,53 +1,27 @@
 module Gmaps4railsHelper
 
-  # shortcut helper for basic marker display
-
-  def gmaps4rails(builder, enable_css = true, enable_js = true )
+  # shortcut helper for marker display with convenient default settings
+  # @params [String] builder is a json string
+  def gmaps4rails(builder)
     options = {
       :map_options => { :auto_adjust => true},
       :markers     => { :data => builder, :options => {:do_clustering => true} }
     }
-    render :partial => '/gmaps4rails/gmaps4rails', :locals => { :options => options.with_indifferent_access, :enable_css => enable_css, :enable_js => enable_js }
+    gmaps(options)
   end
 
-  # complete helper to pass all variables alongside their options
-
-  def gmaps(options, enable_css = true, enable_js = true )
-    render :partial => '/gmaps4rails/gmaps4rails', :locals => { :options => options.with_indifferent_access, :enable_css => enable_css, :enable_js => enable_js }
+  # full helper to pass all variables and their options
+  # @params [Hash] options is a Hash containing data and options. Example: { markers:{ data: @json, options: { do_clustering: true } } }
+  def gmaps(options)
+    options_with_indifferent_access = options.with_indifferent_access
+    view_helper                     = Gmaps4rails::ViewHelper.new(options_with_indifferent_access)
+    
+    render :partial => '/gmaps4rails/gmaps4rails', 
+           :locals  => { 
+             :options         => options_with_indifferent_access, 
+             :js_dependencies => view_helper.js_dependencies_array,
+             :dom             => view_helper.dom_attributes
+            }
   end
 
-  def gmaps4rails_js_libraries(libraries_array)
-    return "" if libraries_array.nil?
-    "," + libraries_array.join(",")
-  end
-
-  def gmaps4rails_map_language(map_options)
-    "language=#{map_options.try(:[], :language) || ''}&hl=#{map_options.try(:[], :hl) || ''}&region=#{map_options.try(:[], :region) || ''}".html_safe
-  end
-
-  def gmaps4rails_map_id(map_options)
-    map_options.try(:[], :id) || Gmaps4rails::DEFAULT_MAP_ID
-  end
-
-  def gmaps4rails_container_class(map_options)
-    map_options.try(:[], :container_class) || "map_container"
-  end
-
-  def gmaps4rails_map_class(map_options)
-    default_class = map_options.try(:[], :provider) == "bing" ? "bing_map" : "gmaps4rails_map"
-    map_options.try(:[], :class) || default_class
-  end
-
-
-  def gmaps4rails_js_files(map_options = nil, scripts = nil, enable_js = true, marker_options = nil)
-    render "/gmaps4rails/scripts", :map_options => map_options, :scripts => scripts, :enable_js => enable_js, :marker_options => marker_options
-  end
-
-  def gmaps4rails_html(map_options = nil)
-    render "/gmaps4rails/html", :map_options => map_options
-  end
-  
-  def gmaps4rails_pipeline_enabled?
-    Rails.configuration.methods.include?(:assets) && Rails.configuration.assets.enabled
-  end
 end

data/lib/gmaps4rails/js_builder.rb

@@ -0,0 +1,121 @@
+module Gmaps4rails
+  
+  def Gmaps4rails.create_js_from_hash(hash)
+    ::Gmaps4rails::JsBuilder.new.create_js_from_hash(hash)
+  end
+  
+  class JsBuilder
+    
+    DEFAULT_MAP_ID     = "map"
+    
+    #the variable 'hash' must have the following structure
+    #{  
+    #   :map_options => hash,
+    #   :markers     => { :data => json, :options => hash },
+    #   :polylines   => { :data => json, :options => hash },
+    #   :polygons    => { :data => json, :options => hash },
+    #   :circles     => { :data => json, :options => hash },
+    #   :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
+        end
+      end
+      result << "#{map_id}.adjustMapToBounds();"
+      result << "#{map_id}.callback();"
+
+      result << "};"
+      if hash[:last_map].nil? || hash[:last_map] == true
+        result << "Gmaps.oldOnload = window.onload;\n window.onload = function() { Gmaps.triggerOldOnload(); Gmaps.loadMaps(); };"
+      end
+
+      result * ('
+')
+    end
+    
+    def js_function_name(hash)
+      "load_" + get_map_id(hash[:map_options])
+    end
+
+    def get_map_id(hash)
+      hash.nil? || hash[:id].nil? ? DEFAULT_MAP_ID : hash[:id]
+    end
+
+    def get_constructor(hash)
+      hash.nil? || hash[:provider].nil? ? "Gmaps4RailsGoogle()" : "Gmaps4Rails#{hash[:provider].capitalize}()"
+    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
+        end
+      end
+      output
+    end
+
+    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	
+      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
+          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
+    
+  end
+
+
+end
+