gmaps4rails 1.5.8 → 2.0.0.pre

data/lib/gmaps4rails/extensions/enumerable.rb

@@ -0,0 +1,14 @@
+module Enumerable
+  #Scopes on models generate Arrays
+  #this method enables short call to the json creation for all elements in the array
+  def to_gmaps4rails(&block)
+    output = "["
+    json_array = []
+    each do |object|
+      json = Gmaps4rails.create_json(object, &block)
+      json_array << json.to_s unless json.nil?
+    end
+    output << json_array * (",")
+    output << "]"
+  end
+end

data/lib/gmaps4rails/extensions/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  
+  # this method extracts all info from the hash to create javascript
+  # this javascript is then rendered raw to the view so it can be interpreted and executed
+  def to_gmaps4rails
+    Gmaps4rails.create_js_from_hash(self.with_indifferent_access)
+  end
+  
+end

data/lib/gmaps4rails/helper/gmaps4rails_helper.rb

@@ -0,0 +1,33 @@
+module Gmaps4railsHelper
+
+  # 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} }
+    }
+    gmaps(options)
+  end
+
+  # 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)
+    
+    js_dependencies = if Gmaps4rails.escape_js_url
+                        view_helper.js_dependencies_array
+                      else
+                        view_helper.js_dependencies_array.map(&:html_safe)
+                      end
+
+    render :partial => '/gmaps4rails/gmaps4rails', 
+           :locals  => { 
+             :options         => options_with_indifferent_access, 
+             :js_dependencies => js_dependencies,
+             :dom             => view_helper.dom_attributes
+            }
+  end
+
+end

data/lib/gmaps4rails/js_builder.rb

@@ -0,0 +1,154 @@
+module Gmaps4rails
+  class JsBuilder
+    
+    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 },
+    #   :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 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
+    end
+
+    def process_data
+      data.each do |name, hash|
+        datum = ::Gmaps4rails::JsBuilder::Datum.new(gmap_id, name, hash)
+        @js.concat datum.create_js
+      end
+    end
+    
+    def map_options
+      @hash[:map_options]
+    end
+    
+    def data
+      @hash.select{|key, value| DATA_KEYS.include?(key.to_sym) }
+    end
+    
+    def load_map?
+      @hash[:last_map].nil? || @hash[:last_map] == true
+    end
+    
+    def js_function_name
+      "load_" + map_id
+    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 }
+      
+      delegate :options, :data, :to => :@element_info
+      
+      def initialize(gmap_id, name, hash)
+        @gmap_id, @name, @js = gmap_id, name, Array.new
+        @element_info = OpenStruct.new(hash)
+      end
+      
+      def create_js
+        if @name.to_sym == :direction
+          create_direction_js
+        else  
+          create_standard_js
+        end
+      end
+      
+      def create_standard_js
+        set_configuration_variables
+        @js << "#{@gmap_id}.add#{@name.capitalize}(#{data});"
+      end
+
+      def create_direction_js
+        @js << "#{@gmap_id}.direction_conf.origin = '#{data["from"]}';"
+        @js << "#{@gmap_id}.direction_conf.destination = '#{data["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
+        end
+      end
+      
+    end
+  end
+
+
+end
+  

data/lib/gmaps4rails/json_builder.rb

@@ -0,0 +1,140 @@
+module Gmaps4rails  
+  # the to_gmaps4rails method accepts a block to customize:
+  # - infowindow
+  # - picture
+  # - title
+  # - sidebar
+  # - json
+  #
+  # This works this way:
+  #   @json = User.all.to_gmaps4rails do |user, marker|
+  #     marker.infowindow render_to_string(:partial => "/users/my_template", :locals => { :object => user}).gsub(/\n/, '').gsub(/"/, '\"')
+  #     marker.picture({
+  #                     :picture => "http://www.blankdots.com/img/github-32x32.png",
+  #                     :width   => "32",
+  #                     :height  => "32"
+  #                    })
+  #     marker.title   "i'm the title"
+  #     marker.sidebar "i'm the sidebar"
+  #     marker.json({ :id => user.id })
+  #   end
+  #
+  # For backward compability, a mere string could be passed:
+  #   @json = User.all.to_gmaps4rails do |user, marker|
+  #     "\"id\": #{user.id}"
+  #   end
+  #
+  class JsonBuilder
+
+    delegate :position, :lat_column, :lng_column, :to => :@options
+    
+    def initialize(object)
+      @object, @json_hash, @custom_json = object, Hash.new, nil
+      @options = OpenStruct.new @object.gmaps4rails_options
+    end
+    
+    def process(&block)
+      if compliant?
+        handle_block(&block) if block_given?
+        handle_model_methods
+        return_json
+      else
+        nil
+      end
+    end
+    
+    def infowindow(string)
+      @json_hash[:description] = string
+      true
+    end
+
+    def title(string)
+      @json_hash[:title] = string
+      true
+    end
+
+    def sidebar(string)
+      @json_hash[:sidebar] = string
+      true
+    end
+
+    def json(json)
+      return @json_hash.merge! json if json.is_a? Hash
+      true
+    end
+
+    def picture(hash)
+      @json_hash.merge! hash
+      true
+    end
+
+    private
+
+    def model_attributes
+      { 
+        :description    => :gmaps4rails_infowindow,
+        :title          => :gmaps4rails_title,
+        :sidebar        => :gmaps4rails_sidebar,
+        :marker_picture => :gmaps4rails_marker_picture
+      }.merge(coordinates_attributes)
+    end
+
+    def coordinates_attributes
+      position_from_array? ? {:position => position } : {:lat => lat_column, :lng => lng_column}
+    end
+
+    def handle_model_methods
+      model_attributes.each do |json_name, method_name|
+        if @object.respond_to? method_name
+          if json_name == :marker_picture
+            @json_hash.merge!(@object.send(method_name)) unless @json_hash.has_key? "picture"
+          elsif json_name == :position
+            @json_hash.merge!(:lat => lat, :lng => lng)
+          else
+            @json_hash[json_name] = @object.send(method_name) unless @json_hash.has_key? json_name
+          end
+        end
+      end
+    end
+
+    # returns the proper json
+    # three cases here:
+    # - no custom json provided
+    # - custom json provided as a hash (marker.json { :id => user.id })     => merge hashes then create json
+    # - custom json provided as string (marker.json {"\"id\": #{user.id}" } => create json from hash then insert string inside
+    def return_json
+      return @json_hash.to_json if @custom_json.nil?
+      case @custom_json
+      when Hash
+        @json_hash.merge! @custom_json
+        return @json_hash.to_json
+      when String
+        output = @json_hash.to_json
+        return output.insert(1, @custom_json + ",")
+      end
+    end
+
+    def compliant?
+      !(lat.blank? && lng.blank?)
+    end
+
+    def handle_block(&block)
+      block_result = yield(@object, self)
+      @custom_json = block_result unless block_result == true
+    end
+
+    def position_from_array?
+      position #if gmaps4rails_options[:position] is filled, means user is indicating an array
+    end
+
+    def lat
+      position_from_array? ? @object.send("#{position}")[0] : @object.send("#{lat_column}")
+    end
+
+    def lng
+      position_from_array? ? @object.send("#{position}")[1] : @object.send("#{lng_column}")
+    end
+
+  end  
+  
+end

data/lib/gmaps4rails/model_handler.rb

@@ -0,0 +1,101 @@
+module Gmaps4rails
+  
+  class ModelHandler
+    
+    attr_accessor :options, :object 
+    
+    delegate :process_geocoding, :check_process, :checker, :lat_column, :lng_column, :position, :msg, :validation,
+             :language, :protocol, :address, :callback, :normalized_address,
+             :to => :options
+  
+    def initialize(object, gmaps4rails_options)
+      @options = ::OpenStruct.new(gmaps4rails_options)
+      @object  = object
+    end
+    
+    # saves coordinates according to the various options
+    def retrieve_coordinates
+      return if prevent_geocoding?
+      checked_coordinates do
+        position? ? set_position : set_lat_lng
+        # save normalized address if required
+        object.send("#{normalized_address}=", coordinates.first[:matched_address]) if normalized_address
+        # Call the callback method to let the user do what he wants with the data
+        object.send callback, coordinates.first[:full_data] if callback
+        # update checker if required
+        object.send("#{checker}=", true) if check_geocoding?
+      end
+    end
+    
+    private
+
+    # sets array for non relationnal db
+    def set_position
+      object.send("#{position}=", [lat, lng])
+    end
+
+    #sets regular columns
+    def set_lat_lng
+      object.send("#{lng_column}=", lng)
+      object.send("#{lat_column}=", lat)
+    end
+
+    def lat
+      coordinates.first[:lat]
+    end
+
+    def lng
+      coordinates.first[:lng]
+    end
+
+    def position?
+      position
+    end
+    
+    def checked_coordinates(&block)
+      yield if coordinates
+    end
+    
+    def coordinates
+      @coordinates ||= get_coordinates
+    end
+    
+    def get_coordinates
+      Gmaps4rails.geocode(object.send(address), language, false, protocol)
+    rescue GeocodeStatus, GeocodeInvalidQuery => e  #address was invalid, add error to address.
+      Rails.logger.warn(e)
+      object.errors[address] << msg if condition_eval(object, validation)
+      false
+    rescue GeocodeNetStatus => e                    #connection error, No need to prevent save.
+      Rails.logger.warn(e)
+      false
+    end
+    
+    # to prevent geocoding each time a save is made
+    # 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 prevent_geocoding?
+      if process_geocoding.is_a?(TrueClass) || process_geocoding.is_a?(FalseClass)
+        return true if !condition_eval(object, process_geocoding)
+        condition_eval(object, check_process) && object.send(checker)
+      else
+        !condition_eval(object, process_geocoding)
+      end
+    end
+    
+    # Do we have to check the geocoding 
+    def check_geocoding?
+      if process_geocoding.is_a?(TrueClass) || process_geocoding.is_a?(FalseClass)
+        condition_eval(object, check_process)
+      else
+        false
+      end
+    end
+    
+    def condition_eval(*args)
+      Gmaps4rails.condition_eval(*args)
+    end
+
+  end
+
+end