gmaps4rails 2.0.0.pre → 2.0.0

data/lib/gmaps4rails/extensions/enumerable.rb

@@ -1,14 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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