simple-address-generator 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in simple-address-generator.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Chim Kan
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Simple::Address::Generator
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simple-address-generator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple-address-generator
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/rails/generators/simple_address_generator/USAGE

@@ -0,0 +1,6 @@
+******************************************************************
+  simple-address-generator is Rails 3 Address class generator
+******************************************************************
+
+Example:
+    rails g simple-address-generator

data/lib/rails/generators/simple_address_generator/simple_address_generator_generator.rb

@@ -0,0 +1,30 @@
+module SimpleAddressGenerator
+  module Generators
+    class SimpleAddressGeneratorGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_address_model
+        generate("model", "address address_line_1:string address_line_2:string city:string state:string postal_code:string country:string telephone_number:string latitude:float longitude:float category_id:integer")
+        rake("db:migrate")
+      end
+
+      def generate_everything_else
+        directory "gmaps4rails", "app/assets/javascripts/gmaps4rails/"
+        directory "addresses", "app/views/"
+        copy_file "addresses_controller.rb", "app/controllers/addresses_controller.rb"
+        copy_file "address.rb", "app/models/address.rb"
+        copy_file "icon-1.png", "app/assets/images/icon-1.png"
+      end
+
+      def insert_routes
+        route("resources :addresses")
+      end
+
+      def add_gems
+        gem("geocoder")
+        gem("gmaps4rails")
+      end
+
+    end
+  end
+end

data/lib/rails/generators/simple_address_generator/templates/address.rb

@@ -0,0 +1,43 @@
+class Address < ActiveRecord::Base
+  attr_accessible :address_line_1, :address_line_2, :city, :country, :full_name, :postal_code, :state, :telephone_number, :full_address, :latitude, :longitude, :gmaps, :category_id
+  attr_accessor :gmaps
+
+  geocoded_by :full_address
+
+  after_validation :geocode
+
+  acts_as_gmappable
+
+
+  def full_address
+    [self.address_line_1, self.address_line_2, self.city, self.state, self.country, self.postal_code].compact.join(", ")
+  end
+
+  def gmaps4rails_address
+  #describe how to retrieve the address from your model, if you use directly a db column, you can dry your code, see wiki
+      full_address
+  end
+
+  def gmaps4rails_infowindow
+      "#{full_address}"
+  end
+
+  def gmaps4rails_title
+      # add here whatever text you desire
+      "Testing"
+  end
+
+  def gmaps4rails_marker_picture
+    {
+     "picture" => "/assets/icon-#{self.category_id}.png",
+     "width" => 30,
+     "height" => 30,
+     "marker_anchor" => [ 5, 10],
+     "shadow_width" => "110",
+     "shadow_height" => "110",
+     "shadow_anchor" => [5, 10]
+    }
+  end
+
+
+end

data/lib/rails/generators/simple_address_generator/templates/addresses/_form.html.erb

@@ -0,0 +1,53 @@
+<%= form_for(@address) do |f| %>
+  <% if @address.errors.any? %>
+    <div id="error_explanation">
+      <h2><%= pluralize(@address.errors.count, "error") %> prohibited this address from being saved:</h2>
+
+      <ul>
+      <% @address.errors.full_messages.each do |msg| %>
+        <li><%= msg %></li>
+      <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div class="field">
+    <%= f.label :full_name %><br />
+    <%= f.text_field :full_name %>
+  </div>
+  <div class="field">
+    <%= f.label :address_line_1 %><br />
+    <%= f.text_field :address_line_1 %>
+  </div>
+  <div class="field">
+    <%= f.label :address_line_2 %><br />
+    <%= f.text_field :address_line_2 %>
+  </div>
+  <div class="field">
+    <%= f.label :city %><br />
+    <%= f.text_field :city %>
+  </div>
+  <div class="field">
+    <%= f.label :state %><br />
+    <%= f.text_field :state %>
+  </div>
+  <div class="field">
+    <%= f.label :postal_code %><br />
+    <%= f.text_field :postal_code %>
+  </div>
+  <div class="field">
+    <%= f.label :country %><br />
+    <%= f.text_field :country %>
+  </div>
+  <div class="field">
+    <%= f.label :telephone_number %><br />
+    <%= f.text_field :telephone_number %>
+  </div>
+  <div class="field">
+    <%= f.label :category_id %><br />
+    <%= f.text_field :category_id %>
+  </div>
+  <div class="actions">
+    <%= f.submit %>
+  </div>
+<% end %>

data/lib/rails/generators/simple_address_generator/templates/addresses/edit.html.erb

@@ -0,0 +1,6 @@
+<h1>Editing address</h1>
+
+<%= render 'form' %>
+
+<%= link_to 'Show', @address %> |
+<%= link_to 'Back', addresses_path %>

data/lib/rails/generators/simple_address_generator/templates/addresses/index.html.erb

@@ -0,0 +1,40 @@
+<h1>Listing addresses</h1>
+
+<table>
+  <tr>
+    <th>Full name</th>
+    <th>Address line 1</th>
+    <th>Address line 2</th>
+    <th>City</th>
+    <th>State</th>
+    <th>Postal code</th>
+    <th>Country</th>
+    <th>Telephone number</th>
+    <th></th>
+    <th></th>
+    <th></th>
+  </tr>
+
+<% @addresses.each do |address| %>
+  <tr>
+    <td><%= address.full_name %></td>
+    <td><%= address.address_line_1 %></td>
+    <td><%= address.address_line_2 %></td>
+    <td><%= address.city %></td>
+    <td><%= address.state %></td>
+    <td><%= address.postal_code %></td>
+    <td><%= address.country %></td>
+    <td><%= address.telephone_number %></td>
+    <td><%= link_to 'Show', address %></td>
+    <td><%= link_to 'Edit', edit_address_path(address) %></td>
+    <td><%= link_to 'Destroy', address, confirm: 'Are you sure?', method: :delete %></td>
+  </tr>
+<% end %>
+</table>
+
+<br />
+<p>
+<%= gmaps("map_options" => { "center_longitude" => 180, "zoom" => 1, "auto_adjust" => true}, "markers" => {"data" => @json, "options" => {"rich_marker" => true } }) %>
+</p>
+
+<%= link_to 'New Address', new_address_path %>

data/lib/rails/generators/simple_address_generator/templates/addresses/new.html.erb

@@ -0,0 +1,5 @@
+<h1>New address</h1>
+
+<%= render 'form' %>
+
+<%= link_to 'Back', addresses_path %>

data/lib/rails/generators/simple_address_generator/templates/addresses/show.html.erb

@@ -0,0 +1,63 @@
+<p id="notice"><%= notice %></p>
+
+<p>
+  <b>Full name:</b>
+  <%= @address.full_name %>
+</p>
+
+<p>
+  <b>Address line 1:</b>
+  <%= @address.address_line_1 %>
+</p>
+
+<p>
+  <b>Address line 2:</b>
+  <%= @address.address_line_2 %>
+</p>
+
+<p>
+  <b>City:</b>
+  <%= @address.city %>
+</p>
+
+<p>
+  <b>State:</b>
+  <%= @address.state %>
+</p>
+
+<p>
+  <b>Postal code:</b>
+  <%= @address.postal_code %>
+</p>
+
+<p>
+  <b>Country:</b>
+  <%= @address.country %>
+</p>
+
+<p>
+  <b>Telephone number:</b>
+  <%= @address.telephone_number %>
+</p>
+
+<p>
+  <b>Latitude:</b>
+  <%= @address.latitude %>
+</p>
+
+<p>
+  <b>Longitude:</b>
+  <%= @address.longitude %>
+</p>
+
+<p>
+  <b>Full Address:</b>
+  <%= @address.full_address %>
+</p>
+
+<p>
+<%= gmaps("map_options" => { "center_longitude" => 180, "zoom" => 1, "auto_adjust" => true}, "markers" => {"data" => @json, "options" => {"rich_marker" => true } }) %>
+</p>
+
+<%= link_to 'Edit', edit_address_path(@address) %> |
+<%= link_to 'Back', addresses_path %>

data/lib/rails/generators/simple_address_generator/templates/addresses_controller.rb

@@ -0,0 +1,85 @@
+class AddressesController < ApplicationController
+  # GET /addresses
+  # GET /addresses.json
+  def index
+    @addresses = Address.all
+    @json = @addresses.to_gmaps4rails
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @addresses }
+    end
+  end
+
+  # GET /addresses/1
+  # GET /addresses/1.json
+  def show
+    @address = Address.find(params[:id])
+    @json = @address.to_gmaps4rails
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @address }
+    end
+  end
+
+  # GET /addresses/new
+  # GET /addresses/new.json
+  def new
+    @address = Address.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @address }
+    end
+  end
+
+  # GET /addresses/1/edit
+  def edit
+    @address = Address.find(params[:id])
+  end
+
+  # POST /addresses
+  # POST /addresses.json
+  def create
+    @address = Address.new(params[:address])
+
+    respond_to do |format|
+      if @address.save
+        format.html { redirect_to @address, notice: 'Address was successfully created.' }
+        format.json { render json: @address, status: :created, location: @address }
+      else
+        format.html { render action: "new" }
+        format.json { render json: @address.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /addresses/1
+  # PUT /addresses/1.json
+  def update
+    @address = Address.find(params[:id])
+
+    respond_to do |format|
+      if @address.update_attributes(params[:address])
+        format.html { redirect_to @address, notice: 'Address was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @address.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /addresses/1
+  # DELETE /addresses/1.json
+  def destroy
+    @address = Address.find(params[:id])
+    @address.destroy
+
+    respond_to do |format|
+      format.html { redirect_to addresses_url }
+      format.json { head :no_content }
+    end
+  end
+end

data/lib/rails/generators/simple_address_generator/templates/gmaps4rails/gmaps4rails.base.js.coffee

@@ -0,0 +1,502 @@
+Gmaps = {}
+
+Gmaps.triggerOldOnload = ->
+  Gmaps.oldOnload() if typeof(Gmaps.oldOnload) == 'function'
+
+Gmaps.loadMaps = ->
+  #loop through all variable names.
+  #there should only be maps inside so it trigger their load function
+  for key, value of Gmaps
+    searchLoadIncluded = key.search(/load/)
+    if searchLoadIncluded == -1
+      load_function_name = "load_" + key
+      Gmaps[load_function_name]()
+
+window.Gmaps = Gmaps
+
+class @Gmaps4Rails
+
+  constructor: ->
+    #map config
+    @map =  null               #DEPRECATED: will still contain a copy of serviceObject below as transition
+    @serviceObject = null      #contains the map we're working on
+    @visibleInfoWindow = null  #contains the current opened infowindow
+    @userLocation = null       #contains user's location if geolocalization was performed and successful
+
+    #empty slots
+    @geolocationFailure = -> false  #triggered when geolocation fails. If customized, must be like= function(navigator_handles_geolocation){} where 'navigator_handles_geolocation' is a boolean
+    @callback           = -> false  #to let user set a custom callback function
+    @customClusterer    = -> false  #to let user set custom clusterer pictures
+    @infobox            = -> false  #to let user use custom infoboxes
+    @jsTemplate         = false     #to let user create infowindows client side
+
+    @default_map_options =
+      id: 'map'
+      draggable: true
+      detect_location: false  # should the browser attempt to use geolocation detection features of HTML5?
+      center_on_user: false   # centers map on the location detected through the browser
+      center_latitude: 0
+      center_longitude: 0
+      zoom: 7
+      maxZoom: null
+      minZoom: null
+      auto_adjust : true      # adjust the map to the markers if set to true
+      auto_zoom: true         # zoom given by auto-adjust
+      bounds: []              # adjust map to these limits. Should be [{"lat": , "lng": }]
+      raw: {}                  # raw json to pass additional options
+
+    @default_markers_conf =
+      #Marker config
+      title: ""
+      #MarkerImage config
+      picture : ""
+      width: 22
+      length: 32
+      draggable: false         # how to modify: <%= gmaps( "markers" => { "data" => @object.to_gmaps4rails, "options" => { "draggable" => true }}) %>
+      #clustering config
+      do_clustering: false     # do clustering if set to true
+      randomize: false         # Google maps can't display two markers which have the same coordinates. This randomizer enables to prevent this situation from happening.
+      max_random_distance: 100 # in meters. Each marker coordinate could be altered by this distance in a random direction
+      list_container: null     # id of the ul that will host links to all markers
+      offset: 0                # used when adding_markers to an existing map. Because new markers are concated with previous one, offset is here to prevent the existing from being re-created.
+      raw: {}                  # raw json to pass additional options
+
+    #Stored variables
+    @markers = []            # contains all markers. A marker contains the following: {"description": , "longitude": , "title":, "latitude":, "picture": "", "width": "", "length": "", "sidebar": "", "serviceObject": google_marker}
+    @boundsObject = null     # contains current bounds from markers, polylines etc...
+    @polygons = []           # contains raw data, array of arrays (first element could be a hash containing options)
+    @polylines = []          # contains raw data, array of arrays (first element could be a hash containing options)
+    @circles = []            # contains raw data, array of hash
+    @markerClusterer = null  # contains all marker clusterers
+    @markerImages = []
+
+  #tnitializes the map
+  initialize : ->
+    @serviceObject = @createMap()
+    @map = @serviceObject #beware, soon deprecated
+    if (@map_options.detect_location == true or @map_options.center_on_user == true)
+      @findUserLocation(this)
+    #resets sidebar if needed
+    @resetSidebarContent()
+
+  findUserLocation : (map_object) ->
+    if (navigator.geolocation)
+      #try to retrieve user's position
+      positionSuccessful = (position) ->
+        map_object.userLocation = map_object.createLatLng(position.coords.latitude, position.coords.longitude)
+        #change map's center to focus on user's geoloc if asked
+        if(map_object.map_options.center_on_user == true)
+          map_object.centerMapOnUser()
+      positionFailure = ->
+        map_object.geolocationFailure(true)
+
+      navigator.geolocation.getCurrentPosition( positionSuccessful, positionFailure)
+    else
+      #failure but the navigator doesn't handle geolocation
+      map_object.geolocationFailure(false)
+
+
+  #////////////////////////////////////////////////////
+  #//////////////////// DIRECTIONS ////////////////////
+  #////////////////////////////////////////////////////
+
+  create_direction : ->
+    directionsDisplay = new google.maps.DirectionsRenderer()
+    directionsService = new google.maps.DirectionsService()
+
+    directionsDisplay.setMap(@serviceObject)
+    #display panel only if required
+    if @direction_conf.display_panel
+      directionsDisplay.setPanel(document.getElementById(@direction_conf.panel_id))
+
+    directionsDisplay.setOptions
+      suppressMarkers:     false
+      suppressInfoWindows: false
+      suppressPolylines:   false
+
+    request =
+      origin:             @direction_conf.origin
+      destination:        @direction_conf.destination
+      waypoints:          @direction_conf.waypoints
+      optimizeWaypoints:  @direction_conf.optimizeWaypoints
+      unitSystem:         google.maps.DirectionsUnitSystem[@direction_conf.unitSystem]
+      avoidHighways:      @direction_conf.avoidHighways
+      avoidTolls:         @direction_conf.avoidTolls
+      region:             @direction_conf.region
+      travelMode:         google.maps.DirectionsTravelMode[@direction_conf.travelMode]
+      language:           "en"
+
+    directionsService.route request, (response, status) ->
+      if (status == google.maps.DirectionsStatus.OK)
+        directionsDisplay.setDirections(response)
+
+  #////////////////////////////////////////////////////
+  #///////////////////// CIRCLES //////////////////////
+  #////////////////////////////////////////////////////
+
+  #Loops through all circles
+  #Loops through all circles and draws them
+  create_circles : ->
+    for circle in @circles
+      @create_circle circle
+
+  create_circle : (circle) ->
+    #by convention, default style configuration could be integrated in the first element
+    if circle == @circles[0]
+      @circles_conf.strokeColor   = circle.strokeColor   if circle.strokeColor?
+      @circles_conf.strokeOpacity = circle.strokeOpacity if circle.strokeOpacity?
+      @circles_conf.strokeWeight  = circle.strokeWeight  if circle.strokeWeight?
+      @circles_conf.fillColor     = circle.fillColor     if circle.fillColor?
+      @circles_conf.fillOpacity   = circle.fillOpacity   if circle.fillOpacity?
+
+    if circle.lat? and circle.lng?
+      # always check if a config is given, if not, use defaults
+      # NOTE: is there a cleaner way to do this? Maybe a hash merge of some sort?
+      newCircle = new google.maps.Circle
+        center:        @createLatLng(circle.lat, circle.lng)
+        strokeColor:   circle.strokeColor   || @circles_conf.strokeColor
+        strokeOpacity: circle.strokeOpacity || @circles_conf.strokeOpacity
+        strokeWeight:  circle.strokeWeight  || @circles_conf.strokeWeight
+        fillOpacity:   circle.fillOpacity   || @circles_conf.fillOpacity
+        fillColor:     circle.fillColor     || @circles_conf.fillColor
+        clickable:     circle.clickable     || @circles_conf.clickable
+        zIndex:        circle.zIndex        || @circles_conf.zIndex
+        radius:        circle.radius
+
+      circle.serviceObject = newCircle
+      newCircle.setMap(@serviceObject)
+
+  # clear circles
+  clear_circles : ->
+    for circle in @circles
+      @clear_circle circle
+
+  clear_circle : (circle) ->
+    circle.serviceObject.setMap(null)
+
+  hide_circles : ->
+    for circle in @circles
+      @hide_circle circle
+
+  hide_circle : (circle) ->
+    circle.serviceObject.setMap(null)
+
+  show_circles : ->
+    for circle in @circles
+      @show_circle @circle
+
+  show_circle : (circle) ->
+    circle.serviceObject.setMap(@serviceObject)
+
+  #////////////////////////////////////////////////////
+  #///////////////////// POLYGONS /////////////////////
+  #////////////////////////////////////////////////////
+
+  #polygons is an array of arrays. It loops.
+  create_polygons : ->
+    for polygon in @polygons
+      @create_polygon(polygon)
+
+  #creates a single polygon, triggered by create_polygons
+  create_polygon : (polygon) ->
+    polygon_coordinates = []
+
+    #Polygon points are in an Array, that's why looping is necessary
+    for point in polygon
+      latlng = @createLatLng(point.lat, point.lng)
+      polygon_coordinates.push(latlng)
+      #first element of an Array could contain specific configuration for this particular polygon. If no config given, use default
+      if point == polygon[0]
+        strokeColor   = point.strokeColor   || @polygons_conf.strokeColor
+        strokeOpacity = point.strokeOpacity || @polygons_conf.strokeOpacity
+        strokeWeight  = point.strokeWeight  || @polygons_conf.strokeWeight
+        fillColor     = point.fillColor     || @polygons_conf.fillColor
+        fillOpacity   = point.fillOpacity   || @polygons_conf.fillOpacity
+        clickable     = point.clickable     || @polygons_conf.clickable
+        
+    #Construct the polygon
+    new_poly = new google.maps.Polygon
+      paths:          polygon_coordinates
+      strokeColor:    strokeColor
+      strokeOpacity:  strokeOpacity
+      strokeWeight:   strokeWeight
+      fillColor:      fillColor
+      fillOpacity:    fillOpacity
+      clickable:      clickable
+      map:            @serviceObject
+
+    #save polygon in list
+    polygon.serviceObject = new_poly
+
+  #////////////////////////////////////////////////////
+  #/////////////////// POLYLINES //////////////////////
+  #////////////////////////////////////////////////////
+
+  #replace old markers with new markers on an existing map
+  replacePolylines : (new_polylines) ->
+    #reset previous polylines and kill them from map
+    @destroy_polylines()
+    #set new polylines
+    @polylines = new_polylines
+    #create
+    @create_polylines()
+    #.... and adjust map boundaries
+    @adjustMapToBounds()
+
+  destroy_polylines : ->
+    for polyline in @polylines
+      #delete polylines from map
+      polyline.serviceObject.setMap(null)
+    #empty array
+    @polylines = []
+
+  #polylines is an array of arrays. It loops.
+  create_polylines : ->
+    for polyline in @polylines
+      @create_polyline polyline
+
+  #creates a single polyline, triggered by create_polylines
+  create_polyline : (polyline) ->
+    polyline_coordinates = []
+
+    #2 cases here, either we have a coded array of LatLng or we have an Array of LatLng
+    for element in polyline
+      #if we have a coded array
+      if element.coded_array?
+        decoded_array = new google.maps.geometry.encoding.decodePath(element.coded_array)
+        #loop through every point in the array
+        for point in decoded_array
+          polyline_coordinates.push(point)
+
+      #or we have an array of latlng
+      else
+        #by convention, a single polyline could be customized in the first array or it uses default values
+        if element == polyline[0]
+          strokeColor   = element.strokeColor   || @polylines_conf.strokeColor
+          strokeOpacity = element.strokeOpacity || @polylines_conf.strokeOpacity
+          strokeWeight  = element.strokeWeight  || @polylines_conf.strokeWeight
+          clickable     = element.clickable     || @polylines_conf.clickable
+          zIndex        = element.zIndex        || @polylines_conf.zIndex
+
+        #add latlng if positions provided
+        if element.lat? && element.lng?
+          latlng = @createLatLng(element.lat, element.lng)
+          polyline_coordinates.push(latlng)
+
+    # Construct the polyline
+    new_poly = new google.maps.Polyline
+      path:         polyline_coordinates
+      strokeColor:  strokeColor
+      strokeOpacity: strokeOpacity
+      strokeWeight: strokeWeight
+      clickable:    clickable
+      zIndex:       zIndex
+
+    #save polyline
+    polyline.serviceObject = new_poly
+    new_poly.setMap(@serviceObject)
+
+  #////////////////////////////////////////////////////
+  #///////////////////// MARKERS //////////////////////
+  #////////////////////////////////////////////////////
+
+  #creates, clusterizes and adjusts map
+  create_markers : ->
+    @createServiceMarkersFromMarkers()
+    @clusterize()
+
+  #create google.maps Markers from data provided by user
+  createServiceMarkersFromMarkers : ->
+    for marker, index in @markers
+      if not @markers[index].serviceObject?
+        #extract options, test if value passed or use default
+        Lat = @markers[index].lat
+        Lng = @markers[index].lng
+
+        #alter coordinates if randomize is true
+        if @markers_conf.randomize
+          LatLng = @randomize(Lat, Lng)
+          #retrieve coordinates from the array
+          Lat = LatLng[0]
+          Lng = LatLng[1]
+
+        #save object
+        @markers[index].serviceObject = @createMarker
+          "marker_picture":   if @markers[index].picture  then @markers[index].picture else @markers_conf.picture
+          "marker_width":     if @markers[index].width    then @markers[index].width   else @markers_conf.width
+          "marker_height":    if @markers[index].height   then @markers[index].height  else @markers_conf.length
+          "marker_title":     if @markers[index].title    then @markers[index].title   else null
+          "marker_anchor":    if @markers[index].marker_anchor  then @markers[index].marker_anchor  else null
+          "shadow_anchor":    if @markers[index].shadow_anchor  then @markers[index].shadow_anchor  else null
+          "shadow_picture":   if @markers[index].shadow_picture then @markers[index].shadow_picture else null
+          "shadow_width":     if @markers[index].shadow_width   then @markers[index].shadow_width   else null
+          "shadow_height":    if @markers[index].shadow_height  then @markers[index].shadow_height  else null
+          "marker_draggable": if @markers[index].draggable      then @markers[index].draggable      else @markers_conf.draggable
+          "rich_marker":      if @markers[index].rich_marker    then @markers[index].rich_marker    else null
+          "zindex":           if @markers[index].zindex         then @markers[index].zindex         else null
+          "Lat":              Lat
+          "Lng":              Lng
+          "index":            index
+
+        #add infowindowstuff if enabled
+        @createInfoWindow(@markers[index])
+        #create sidebar if enabled
+        @createSidebar(@markers[index])
+
+    @markers_conf.offset = @markers.length
+
+  #creates Image Anchor Position or return null if nothing passed
+  createImageAnchorPosition : (anchorLocation) ->
+    if (anchorLocation == null)
+      return null
+    else
+      return @createPoint(anchorLocation[0], anchorLocation[1])
+
+
+  #replace old markers with new markers on an existing map
+  replaceMarkers : (new_markers) ->
+    @clearMarkers()
+    #reset previous markers
+    @markers = new Array
+    #reset current bounds
+    @boundsObject = @createLatLngBounds()
+    #reset sidebar content if exists
+    @resetSidebarContent()
+    #add new markers
+    @markers_conf.offset = 0
+    @addMarkers(new_markers)
+
+  #add new markers to on an existing map
+  addMarkers : (new_markers) ->
+    #update the list of markers to take into account
+    @markers = @markers.concat(new_markers)
+    #put markers on the map
+    @create_markers()
+    @adjustMapToBounds()
+
+  #////////////////////////////////////////////////////
+  #///////////////////// SIDEBAR //////////////////////
+  #////////////////////////////////////////////////////
+
+  #//creates sidebar
+  createSidebar : (marker_container) ->
+    if (@markers_conf.list_container)
+      ul = document.getElementById(@markers_conf.list_container)
+      li = document.createElement('li')
+      aSel = document.createElement('a')
+      aSel.href = 'javascript:void(0);'
+      html = if marker_container.sidebar? then marker_container.sidebar else "Marker"
+      aSel.innerHTML = html
+      currentMap = this
+      aSel.onclick = @sidebar_element_handler(currentMap, marker_container.serviceObject, 'click')
+      li.appendChild(aSel)
+      ul.appendChild(li)
+
+  #moves map to marker clicked + open infowindow
+  sidebar_element_handler : (currentMap, marker, eventType) ->
+    return () ->
+      currentMap.map.panTo(marker.position)
+      google.maps.event.trigger(marker, eventType)
+
+
+  resetSidebarContent : ->
+    if @markers_conf.list_container isnt null
+      ul = document.getElementById(@markers_conf.list_container)
+      ul.innerHTML = ""
+
+  #////////////////////////////////////////////////////
+  #////////////////// MISCELLANEOUS ///////////////////
+  #////////////////////////////////////////////////////
+
+  #to make the map fit the different LatLng points
+  adjustMapToBounds : ->
+    #FIRST_STEP: retrieve all bounds
+    #create the bounds object only if necessary
+    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 autozoom is false, take user info into account
+      if !@map_options.auto_zoom
+        map_center = @boundsObject.getCenter()
+        @map_options.center_latitude  = map_center.lat()
+        @map_options.center_longitude = map_center.lng()
+        @serviceObject.setCenter(map_center)
+      else
+        @fitBounds()
+
+  #////////////////////////////////////////////////////
+  #/////////////////        KML      //////////////////
+  #////////////////////////////////////////////////////
+
+  create_kml : ->
+    for kml in @kml
+      kml.serviceObject = @createKmlLayer kml
+
+  #////////////////////////////////////////////////////
+  #///////////////// Basic functions //////////////////
+  #///////////////////tests coded//////////////////////
+
+  #//basic function to check existence of a variable
+  exists : (var_name) ->
+    return (var_name	!= "" and typeof var_name != "undefined")
+
+
+  #randomize
+  randomize : (Lat0, Lng0) ->
+    #distance in meters between 0 and max_random_distance (positive or negative)
+    dx = @markers_conf.max_random_distance * @random()
+    dy = @markers_conf.max_random_distance * @random()
+    Lat = parseFloat(Lat0) + (180/Math.PI)*(dy/6378137)
+    Lng = parseFloat(Lng0) + ( 90/Math.PI)*(dx/6378137)/Math.cos(Lat0)
+    return [Lat, Lng]
+
+  mergeObjectWithDefault : (object1, object2) ->
+    copy_object1 = {}
+    for key, value of object1
+      copy_object1[key] = value
+
+    for key, value of object2
+      unless copy_object1[key]?
+        copy_object1[key] = value
+    return copy_object1
+
+  mergeWithDefault : (objectName) ->
+    default_object = @["default_" + objectName]
+    object = @[objectName]
+    @[objectName] = @mergeObjectWithDefault(object, default_object)
+    return true
+
+  #gives a value between -1 and 1
+  random : -> return(Math.random() * 2 -1)

data/lib/rails/generators/simple_address_generator/templates/gmaps4rails/gmaps4rails.googlemaps.js.coffee

@@ -0,0 +1,263 @@
+#######################################################################################################
+##############################################  Google maps  ##########################################
+#######################################################################################################
+
+class @Gmaps4RailsGoogle extends Gmaps4Rails
+
+  constructor: ->
+    super
+    #Map settings
+    @map_options =
+      disableDefaultUI:       false
+      disableDoubleClickZoom: false
+      type:                   "ROADMAP" # HYBRID, ROADMAP, SATELLITE, TERRAIN
+
+    #markers + info styling
+    @markers_conf =
+      clusterer_gridSize:      50
+      clusterer_maxZoom:       5
+      custom_cluster_pictures: null
+      custom_infowindow_class: null
+
+    @mergeWithDefault("map_options")
+    @mergeWithDefault("markers_conf")
+
+    @kml_options =
+      clickable: true
+      preserveViewport: false
+      suppressInfoWindows: false
+
+    #Polygon Styling
+    @polygons_conf =         # default style for polygons
+      strokeColor: "#FFAA00"
+      strokeOpacity: 0.8
+      strokeWeight: 2
+      fillColor: "#000000"
+      fillOpacity: 0.35
+      clickable: false
+
+    #Polyline Styling
+    @polylines_conf =         #default style for polylines
+      strokeColor: "#FF0000"
+      strokeOpacity: 1
+      strokeWeight: 2
+      clickable: false
+      zIndex: null
+
+    #Circle Styling
+    @circles_conf =           #default style for circles
+      fillColor: "#00AAFF"
+      fillOpacity: 0.35
+      strokeColor: "#FFAA00"
+      strokeOpacity: 0.8
+      strokeWeight: 2
+      clickable: false
+      zIndex: null
+
+    #Direction Settings
+    @direction_conf =
+      panel_id:           null
+      display_panel:      false
+      origin:             null
+      destination:        null
+      waypoints:          []       #[{location: "toulouse,fr", stopover: true}, {location: "Clermont-Ferrand, fr", stopover: true}]
+      optimizeWaypoints:  false
+      unitSystem:         "METRIC" #IMPERIAL
+      avoidHighways:      false
+      avoidTolls:         false
+      region:             null
+      travelMode:         "DRIVING" #WALKING, BICYCLING
+
+  #////////////////////////////////////////////////////
+  #/////////////// Basic Objects         //////////////
+  #////////////////////////////////////////////////////
+
+  createPoint : (lat, lng) ->
+    return new google.maps.Point(lat, lng)
+
+  createLatLng : (lat, lng) ->
+    return new google.maps.LatLng(lat, lng)
+
+  createLatLngBounds : ->
+    return new google.maps.LatLngBounds()
+
+  createMap : ->
+    defaultOptions =
+      maxZoom:                @map_options.maxZoom
+      minZoom:                @map_options.minZoom
+      zoom:                   @map_options.zoom
+      center:                 @createLatLng(@map_options.center_latitude, @map_options.center_longitude)
+      mapTypeId:              google.maps.MapTypeId[@map_options.type]
+      mapTypeControl:         @map_options.mapTypeControl
+      disableDefaultUI:       @map_options.disableDefaultUI
+      disableDoubleClickZoom: @map_options.disableDoubleClickZoom
+      draggable:              @map_options.draggable
+
+    mergedOptions = @mergeObjectWithDefault @map_options.raw, defaultOptions
+
+    return new google.maps.Map document.getElementById(@map_options.id), mergedOptions
+
+
+  createMarkerImage : (markerPicture, markerSize, origin, anchor, scaledSize) ->
+    return new google.maps.MarkerImage(markerPicture, markerSize, origin, anchor, scaledSize)
+
+  createSize : (width, height) ->
+    return new google.maps.Size(width, height)
+
+  #////////////////////////////////////////////////////
+  #////////////////////// Markers /////////////////////
+  #////////////////////////////////////////////////////
+
+  createMarker : (args) ->
+    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: @serviceObject, title: args.marker_title, draggable: args.marker_draggable, zIndex: args.zindex}
+      mergedOptions  = @mergeObjectWithDefault @markers_conf.raw, defaultOptions
+      return new google.maps.Marker mergedOptions
+
+    if (args.rich_marker != null)
+      return new RichMarker({
+        position: markerLatLng
+        map:       @serviceObject
+        draggable: args.marker_draggable
+        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
+    #calculate MarkerImage anchor location
+    imageAnchorPosition  = @createImageAnchorPosition args.marker_anchor
+    shadowAnchorPosition = @createImageAnchorPosition args.shadow_anchor
+    #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: @serviceObject, 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
+
+  #checks if obj is included in arr Array and returns the position or false
+  includeMarkerImage : (arr, obj) ->
+    for object, index in arr
+      return index if object.url == obj
+    return false
+
+  #checks if MarkerImage exists before creating a new one
+  #returns a MarkerImage or false if ever something wrong is passed as argument
+  createOrRetrieveImage : (currentMarkerPicture, markerWidth, markerHeight, imageAnchorPosition) ->
+    return null if (currentMarkerPicture == "" or currentMarkerPicture == null )
+
+    test_image_index = @includeMarkerImage(@markerImages, currentMarkerPicture)
+    switch test_image_index
+      when false
+        markerImage = @createMarkerImage(currentMarkerPicture, @createSize(markerWidth, markerHeight), null, imageAnchorPosition, null )
+        @markerImages.push(markerImage)
+        return markerImage
+        break
+      else
+        return @markerImages[test_image_index] if typeof test_image_index == 'number'
+        return false
+
+  #clear markers
+  clearMarkers : ->
+    for marker in @markers
+      @clearMarker marker
+
+  #show and hide markers
+  showMarkers : ->
+    for marker in @markers
+      @showMarker marker
+
+  hideMarkers : ->
+    for marker in @markers
+      @hideMarker marker
+
+  clearMarker : (marker) ->
+    marker.serviceObject.setMap(null)
+
+  showMarker : (marker) ->
+    marker.serviceObject.setVisible(true)
+
+  hideMarker : (marker) ->
+    marker.serviceObject.setVisible(false)
+
+  extendBoundsWithMarkers : ->
+    for marker in @markers
+      @boundsObject.extend(marker.serviceObject.position)
+
+  #////////////////////////////////////////////////////
+  #/////////////////// Clusterer //////////////////////
+  #////////////////////////////////////////////////////
+
+  createClusterer : (markers_array) ->
+    return new MarkerClusterer( @serviceObject, markers_array, {  maxZoom: @markers_conf.clusterer_maxZoom, gridSize: @markers_conf.clusterer_gridSize, styles: @customClusterer() })
+
+  clearClusterer : ->
+    @markerClusterer.clearMarkers()
+
+  #creates clusters
+  clusterize : ->
+    if @markers_conf.do_clustering == true
+      #first clear the existing clusterer if any
+      @clearClusterer() if @markerClusterer != null
+
+      markers_array = new Array
+      for marker in @markers
+        markers_array.push(marker.serviceObject)
+
+      @markerClusterer = @createClusterer(markers_array)
+
+  #////////////////////////////////////////////////////
+  #/////////////////// INFO WINDOW ////////////////////
+  #////////////////////////////////////////////////////
+
+  #// creates infowindows
+  createInfoWindow : (marker_container) ->
+    if typeof(@jsTemplate) == "function" or marker_container.description?
+      marker_container.description = @jsTemplate(marker_container) if typeof(@jsTemplate) == "function"
+      if @markers_conf.custom_infowindow_class != null
+        #creating custom infowindow
+        boxText = document.createElement("div")
+        boxText.setAttribute("class", @markers_conf.custom_infowindow_class) #to customize
+        boxText.innerHTML = marker_container.description
+        marker_container.infowindow = new InfoBox(@infobox(boxText))
+        currentMap = this
+        google.maps.event.addListener(marker_container.serviceObject, 'click', @openInfoWindow(currentMap, marker_container.infowindow, marker_container.serviceObject))
+      else
+        #create default infowindow
+        marker_container.infowindow = new google.maps.InfoWindow({content: marker_container.description })
+        #add the listener associated
+        currentMap = this
+        google.maps.event.addListener(marker_container.serviceObject, 'click', @openInfoWindow(currentMap, marker_container.infowindow, marker_container.serviceObject))
+
+  openInfoWindow : (currentMap, infoWindow, marker) ->
+    return ->
+      # Close the latest selected marker before opening the current one.
+      currentMap.visibleInfoWindow.close() if currentMap.visibleInfoWindow != null
+      infoWindow.open(currentMap.serviceObject, marker)
+      currentMap.visibleInfoWindow = infoWindow
+
+  #////////////////////////////////////////////////////
+  #/////////////////        KML      //////////////////
+  #////////////////////////////////////////////////////
+
+  createKmlLayer : (kml) ->
+    kml_options = kml.options || {}
+    kml_options = @mergeObjectWithDefault(kml_options, @kml_options)
+    kml =  new google.maps.KmlLayer( kml.url, kml_options)
+    kml.setMap(@serviceObject)
+    return kml
+
+
+  #////////////////////////////////////////////////////
+  #/////////////////// Other methods //////////////////
+  #////////////////////////////////////////////////////
+
+  fitBounds : ->
+    @serviceObject.fitBounds(@boundsObject) unless @boundsObject.isEmpty()
+
+  centerMapOnUser : ->
+    @serviceObject.setCenter(@userLocation)
+

data/lib/simple-address-generator.rb

@@ -0,0 +1,10 @@
+require "simple-address-generator/version"
+require 'rails/generators/base'
+
+module Simple
+  module Address
+    module Generator
+      # Your code goes here...
+    end
+  end
+end

data/lib/simple-address-generator/version.rb

@@ -0,0 +1,7 @@
+module Simple
+  module Address
+    module Generator
+      VERSION = "0.0.1"
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: simple-address-generator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chim Kan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-07 00:00:00.000000000 Z
+dependencies: []
+description: ! 'simple-address-generator allows you to create a complete Address model
+  with fields and two main plugins that geocode address into coordinates and a Google
+  Maps view with custom makers. To use, just add this gem to your Gemfile and then
+  in your Rails 3 application, run: rails g simple-address-generator. Then run rails
+  s and see in your browser http://localhost:3000/addresses.'
+email: designium+simple@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rails/generators/simple_address_generator/simple_address_generator_generator.rb
+- lib/rails/generators/simple_address_generator/templates/address.rb
+- lib/rails/generators/simple_address_generator/templates/addresses/_form.html.erb
+- lib/rails/generators/simple_address_generator/templates/addresses/edit.html.erb
+- lib/rails/generators/simple_address_generator/templates/addresses/index.html.erb
+- lib/rails/generators/simple_address_generator/templates/addresses/new.html.erb
+- lib/rails/generators/simple_address_generator/templates/addresses/show.html.erb
+- lib/rails/generators/simple_address_generator/templates/addresses_controller.rb
+- lib/rails/generators/simple_address_generator/templates/gmaps4rails/gmaps4rails.base.js.coffee
+- lib/rails/generators/simple_address_generator/templates/gmaps4rails/gmaps4rails.googlemaps.js.coffee
+- lib/rails/generators/simple_address_generator/templates/icon-1.png
+- lib/rails/generators/simple_address_generator/USAGE
+- lib/simple-address-generator/version.rb
+- lib/simple-address-generator.rb
+- Gemfile
+- LICENSE
+- Rakefile
+- README.md
+homepage: ''
+licenses: []
+post_install_message: ! '***************************************'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: simple-address-generator allows you to create a complete Address model integrated
+  to Google Maps.
+test_files: []