bhm-google-maps 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+*.tmproj
+tmtags
+*~
+\#*
+.\#*
+*.swp
+coverage
+rdoc
+pkg
+build

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2010, Youth Tree
+All rights reserved.
+ 
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. All advertising materials mentioning features or use of this software
+   must display the following acknowledgement:
+   This product includes software developed by the Youth Tree.
+4. Neither the name of the Youth Tree nor the
+   names of its contributors may be used to endorse or promote products
+   derived from this software without specific prior written permission.
+ 
+THIS SOFTWARE IS PROVIDED BY YOUTH TREE ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL YOUTH TREE BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,93 @@
+# BHM Google Maps #
+
+Helpers for Google Maps v3 in Rails - Using html 5, the google maps api v3 and the static maps api
+Supports unobtrusive maps in Rails 3 (and 2.3, but preferably 3) using the new google maps v3 api.
+
+## Installation ##
+
+Installing bhm-google-maps is simple. To get started with a rails 3 app:
+
+1. Add the gem to your Gemfile: Add `gem "bhm-google-maps"`
+2. Generate the js into your app: `rake bhm-google-maps:install`
+3. Configure as needed
+
+Some parts of bhm-google-maps may need to be configured - e.g. out of the box, it will append the google
+maps js url to the page and the gmap.js from where it was called, as an example of changing this, we suggest
+creating `config/initializers/bhm_google_maps_config.rb` and configuring from there. e.g:
+
+    # t is the scope of the view / helpers.
+    # This will append it to a content_for section
+    # instead of directly in the page.
+    BHM::GoogleMaps.include_js_proc = proc do |t|
+      t.content_for :extra_head, t.javascript_include_tag(t.google_maps_url(false), "gmap.js")
+    end
+    
+For a fuller / more in depth reference, see configuration below.
+
+## Usage ##
+
+Currently, bhm-google-maps is designed to show a single map w/ static fallback. To do this,
+you use the `draw_map_of` helper. You pass it an object you wish to plot, typically following the
+convention that:
+
+1. `object.lat` and `object.lng` return latitude / longitude respectively
+2. `object.to_s` returns the string representing the address / the address
+
+Of course, this can be changed via other conventions. For this example, we'll use the following
+class demo:
+
+    class Location
+      attr_accessor :address, :lat, :lng
+      
+      def initialize(address, lat, lng)
+        @address = address
+        @lat = lat
+        @lng = lng
+      end
+      
+      def to_s; address.to_s; end
+      
+    end
+    
+Then, in your view, you could simple call:
+
+    <%= draw_map_of Location.new("My House", 12.345, 56.789) %>
+  
+Optionally, `draw_map_of` accepts a hash of options for:
+
+* `:static_map_html` - options to pass to the image\_tag for the static map.
+* `:static_map` - options to pass to the BHM::GoogleMaps::StaticMap constructor. These include `:type`, `:width` and `:height`
+* `:marker` - options to pass to the `google.maps.Marker` in js.
+
+You also get the following helpers:
+
+* `using_gmaps_js?` - whether or not the embed method has been called
+* `use_gmaps_js` - calls your embed method for the js - see configuration.
+* `google_maps_url(sensor = false)` - returns the url for the google maps api v3.
+* `static_map_of_addresses(addresses)` - returns an image tag for an array of addresses.
+* `static_map_of_address(address)` - returns an image tag for a given address
+
+## Configuration ##
+
+For configuration purposes, there are a set of options on `BHM::GoogleMaps`. You can
+set them via `BHM::GoogleMaps.option_name = value`
+
+* `container_class` - the map class for the container div, defaults to gmap. If changed, you must update the js.
+* `static_map_class` - the class of the container div, removed via js when made dynamic.
+* `include_js_proc` - how to embed js in the page (e.g. using content\_for), defaults to using concat. Is called as a proc w/ the template passed as the only argument.
+* `address_to_s_proc` - passed an address, converts it to a string (defaults to to_s)
+* `address_to_lat_lng_proc` - passed an address, returns an array w/ lat and lng.
+
+Ideally these options should be set in an initializer.
+
+## Note on Patches/Pull Requests ##
+ 
+1. Fork the project.
+2. Make your feature addition or bug fix.
+3. Add tests for it. This is important so I don't break it in a future version unintentionally.
+4. Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+5. Send me a pull request. Bonus points for topic branches.
+
+## Copyright ##
+
+Copyright (c) 2010 Youth Tree. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require File.expand_path("./lib/bhm/google_maps/version", File.dirname(__FILE__))
+
+desc "Default: run unit tests."
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "bhm-google-maps"
+    gem.summary     = "Helpers for Google Maps v3 in Rails - Using html 5, the google maps api v3 and the static maps api"
+    gem.description = "A set of helpers and javascript files that makes it trivial to implement google maps unobtrusively in an application."
+    gem.email       = "darcy.laycock@youthtree.org.au"
+    gem.homepage    = "http://github.com/YouthTree/bhm-google-maps"
+    gem.authors     = ["Darcy Laycock"]
+    gem.version     = BHM::GoogleMaps::VERSION
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+desc "Compiles the javascript from Coffeescript to Javascript"
+task :compile_scripts do
+  system "coffee --no-wrap -c coffeescripts/*.coffee -o javascripts/"
+end
+
+desc "Interactively compiles coffeescripts as they're changed"
+task :watch_scripts do
+  system "coffee --no-wrap -w -c coffeescripts/*.coffee -o javascripts/"
+end
+
+desc "Compile scripts, and produce a minified version."
+task :build_scripts => [:compile_scripts] do
+  require 'closure-compiler'
+  build_prefix = "build/#{BHM::GoogleMaps::VERSION}"
+  FileUtils.mkdir_p build_prefix
+  Dir["javascripts/*.js"].each do |js|
+    new_name = js.gsub(/^javascripts\//, build_prefix + "/").gsub(/\.js$/, "-#{BHM::GoogleMaps::VERSION}.js")
+    FileUtils.cp js, new_name
+    min_name = new_name.gsub(/\.js$/, '.min.js')
+    File.open(min_name, "w+") do |f|
+      f.write Closure::Compiler.new.compile(File.read(js))
+    end
+  end
+end
+
+desc "Generate docs for the bhm-google-maps plugin"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "bhm-google-maps"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Test the bhm-google-maps plugin"
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib'
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end

data/bhm-google-maps.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bhm-google-maps}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Darcy Laycock"]
+  s.date = %q{2010-04-26}
+  s.description = %q{A set of helpers and javascript files that makes it trivial to implement google maps unobtrusively in an application.}
+  s.email = %q{darcy.laycock@youthtree.org.au}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "bhm-google-maps.gemspec",
+     "coffeescripts/gmap.coffee",
+     "javascripts/gmap.js",
+     "lib/bhm-google-maps.rb",
+     "lib/bhm/google_maps.rb",
+     "lib/bhm/google_maps/builder.rb",
+     "lib/bhm/google_maps/helper.rb",
+     "lib/bhm/google_maps/static_map.rb",
+     "lib/bhm/google_maps/tasks/bhm_google_maps.rake",
+     "lib/bhm/google_maps/version.rb",
+     "test/builder_test.rb",
+     "test/helper_test.rb",
+     "test/support/misc_helpers.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/YouthTree/bhm-google-maps}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Helpers for Google Maps v3 in Rails - Using html 5, the google maps api v3 and the static maps api}
+  s.test_files = [
+    "test/builder_test.rb",
+     "test/helper_test.rb",
+     "test/support/misc_helpers.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/coffeescripts/gmap.coffee

@@ -0,0 +1,88 @@
+# GMap is a simply, unobtrusive google map adder for jQuery + HTML5.
+# It uses data attributes to store map locations, works with a rails
+# plugin to generate static alternatives and most importantly is simple.
+GMap: (($) ->
+  
+  # The actual object we'll be exporting.
+  map:             {}
+  
+  # Map and marker options to autoextract.
+  mapOptionKeys:    ["zoom", "title"]
+  markerOptionKeys: ["title"] 
+  
+  # Exposed options / data.
+  map.count:          0
+  map.autoIDPrefix:   "gmap-"
+  map.maps:           []
+  
+  # Use a function for the roadmap value to avoid load order issues.
+  # e.g. if the google maps library is loaded after this one.
+  map.defaultOptions: {
+    zoom:        15
+    mapTypeId:   -> google.maps.MapTypeId.ROADMAP
+    scroolwheel: false
+  }
+  
+  # Very, very simple wrapper for generating a data key - tbh possibly un-needed.
+  dataKey: (key, spacer) ->
+    spacer?= ""
+    "data-$spacer$key"
+    
+  # Returns true iff the given element has the set data element, false otherwise.
+  hasData: (e, key, spacer) ->
+    e.is "[${dataKey key, spacer}]"
+    
+  # Return the value of a given data attribute.
+  getData: (e, key, spacer) ->
+    e.attr dataKey(key, spacer)
+  
+  # Merges a given object w/ values retrieved using data element.
+  # automatically namespaces keys etc.
+  mergeDataOptions: (element, options, keys, spacer) ->
+    for key in keys
+      options[key] = getData(element, key, spacer) if hasData element, key, spacer
+  
+  # Return the map options for a given element.
+  mapOptionsForElement: (element) ->
+    options: $.extend {}, map.defaultOptions
+    # Set the mapTypeId if it's a function
+    options.mapTypeId: options.mapTypeId() if $.isFunction options.mapTypeId
+    mergeDataOptions  element, options, mapOptionKeys
+    options
+  
+  # Install the google map onto each option with the .gmap key.
+  map.install: ->
+    $('.gmap').each -> map.setupElement this
+    
+  # Called with a single html dom element as an argument, will
+  # automatically set it up as a google map.
+  map.setupElement: (e) ->
+    $e: $ e
+    id: $e.attr "id"
+    $e.attr "id", "${map.autoIDPrefix}${map.count++}" unless id?
+    # Get the position of the current marker.
+    lat: Number getData($e, "latitude")
+    lng: Number getData($e, "longitude")
+    point: new google.maps.LatLng lat, lng
+    # Start setting up the map / create a map element.
+    mapOptions: mapOptionsForElement $e
+    mapOptions.center: point
+    $e.empty().addClass('dynamic-google-map').removeClass('static-google-map')
+    currentMap: new google.maps.Map e, mapOptions
+    map.maps.push currentMap
+    # Now, we need to finally add the marker to the map.
+    markerOptions: {
+      position: point
+      map:      currentMap
+    }
+    mergeDataOptions $e, markerOptions, markerOptionKeys, "marker-"
+    marker: new google.maps.Marker markerOptions
+    currentMap
+  
+  # On load, we'll install the maps.
+  $(document).ready -> map.install()
+  
+  # Return map to set it up.
+  map
+  
+)(jQuery)

data/javascripts/gmap.js

@@ -0,0 +1,105 @@
+var GMap;
+// GMap is a simply, unobtrusive google map adder for jQuery + HTML5.
+// It uses data attributes to store map locations, works with a rails
+// plugin to generate static alternatives and most importantly is simple.
+GMap = (function($) {
+  var dataKey, getData, hasData, map, mapOptionKeys, mapOptionsForElement, markerOptionKeys, mergeDataOptions;
+  // The actual object we'll be exporting.
+  map = {};
+  // Map and marker options to autoextract.
+  mapOptionKeys = ["zoom", "title"];
+  markerOptionKeys = ["title"];
+  // Exposed options / data.
+  map.count = 0;
+  map.autoIDPrefix = "gmap-";
+  map.maps = [];
+  // Use a function for the roadmap value to avoid load order issues.
+  // e.g. if the google maps library is loaded after this one.
+  map.defaultOptions = {
+    zoom: 15,
+    mapTypeId: function mapTypeId() {
+      return google.maps.MapTypeId.ROADMAP;
+    },
+    scroolwheel: false
+  };
+  // Very, very simple wrapper for generating a data key - tbh possibly un-needed.
+  dataKey = function dataKey(key, spacer) {
+    spacer = (typeof spacer !== "undefined" && spacer !== null) ? spacer : "";
+    return "data-" + spacer + key;
+  };
+  // Returns true iff the given element has the set data element, false otherwise.
+  hasData = function hasData(e, key, spacer) {
+    return e.is(("[" + (dataKey(key, spacer)) + "]"));
+  };
+  // Return the value of a given data attribute.
+  getData = function getData(e, key, spacer) {
+    return e.attr(dataKey(key, spacer));
+  };
+  // Merges a given object w/ values retrieved using data element.
+  // automatically namespaces keys etc.
+  mergeDataOptions = function mergeDataOptions(element, options, keys, spacer) {
+    var _a, _b, _c, _d, key;
+    _a = []; _c = keys;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      key = _c[_b];
+      _a.push((function() {
+        if (hasData(element, key, spacer)) {
+          options[key] = getData(element, key, spacer);
+          return options[key];
+        }
+      })());
+    }
+    return _a;
+  };
+  // Return the map options for a given element.
+  mapOptionsForElement = function mapOptionsForElement(element) {
+    var options;
+    options = $.extend({}, map.defaultOptions);
+    // Set the mapTypeId if it's a function
+    if ($.isFunction(options.mapTypeId)) {
+      options.mapTypeId = options.mapTypeId();
+    }
+    mergeDataOptions(element, options, mapOptionKeys);
+    return options;
+  };
+  // Install the google map onto each option with the .gmap key.
+  map.install = function install() {
+    return $('.gmap').each(function() {
+      return map.setupElement(this);
+    });
+  };
+  // Called with a single html dom element as an argument, will
+  // automatically set it up as a google map.
+  map.setupElement = function setupElement(e) {
+    var $e, currentMap, id, lat, lng, mapOptions, marker, markerOptions, point;
+    $e = $(e);
+    id = $e.attr("id");
+    if (!((typeof id !== "undefined" && id !== null))) {
+      $e.attr("id", ("" + (map.autoIDPrefix) + (map.count++)));
+    }
+    // Get the position of the current marker.
+    lat = Number(getData($e, "latitude"));
+    lng = Number(getData($e, "longitude"));
+    point = new google.maps.LatLng(lat, lng);
+    // Start setting up the map / create a map element.
+    mapOptions = mapOptionsForElement($e);
+    mapOptions.center = point;
+    $e.empty().addClass('dynamic-google-map').removeClass('static-google-map');
+    currentMap = new google.maps.Map(e, mapOptions);
+    map.maps.push(currentMap);
+    // Now, we need to finally add the marker to the map.
+    markerOptions = {
+      position: point,
+      map: currentMap
+    };
+    mergeDataOptions($e, markerOptions, markerOptionKeys, "marker-");
+    marker = new google.maps.Marker(markerOptions);
+    return currentMap;
+  };
+  // On load, we'll install the maps.
+  $(document).ready(function() {
+    return map.install();
+  });
+  // Return map to set it up.
+  return map;
+})(jQuery);

data/lib/bhm/google_maps/builder.rb

@@ -0,0 +1,57 @@
+module BHM
+  module GoogleMaps
+    class Builder
+      BasicMarker = Struct.new(:to_s, :lat, :lng)
+      
+      def initialize(template, address, options)
+        @template = template
+        @address  = address
+        @options  = options.symbolize_keys
+      end
+    
+      def build_static_map(marker_options)
+        ll             = self.ll_pair
+        address        = self.address_as_string
+        address_proxy  = BasicMarker.new(address, ll[0], ll[1])
+        static_map_url = StaticMap.for_address(address_proxy, marker_options.merge(@options[:static_map] || {}))
+        @template.image_tag(static_map_url, {:alt => address}.reverse_merge(@options[:static_map_html] || {}))
+      end
+    
+      def build_container
+        marker_options = @options[:marker] || {}
+        ll = self.ll_pair
+        address = self.address_as_string
+        container_options = {}
+        container_options['data-latitude'] = ll[0]
+        container_options['data-longitude'] = ll[1]
+        marker_options[:title] ||= address
+        marker_options.each_pair do |k, v|
+          container_options["data-marker-#{k.to_s.dasherize}"] = v
+        end
+        default_css_class = "#{BHM::GoogleMaps.container_class} #{BHM::GoogleMaps.static_map_class}"
+        container_options = merge_options_with_class(container_options, :class => default_css_class)
+        @template.content_tag(:div, build_static_map(marker_options), container_options)
+      end
+    
+      def to_html
+        @to_html ||= build_container
+      end
+    
+      def ll_pair
+        BHM::GoogleMaps.address_to_lat_lng_proc.call(@address)
+      end
+      
+      def address_as_string
+        BHM::GoogleMaps.address_to_s_proc.call(@address)
+      end
+    
+      protected
+    
+      def merge_options_with_class(a, b)
+        a, b = (a || {}).stringify_keys, (b || {}).stringify_keys
+        css_class = [a['class'], b['class']].join(" ").squeeze(" ")
+        a.merge(b).merge('class' => css_class)
+      end
+    end
+  end
+end

data/lib/bhm/google_maps/helper.rb

@@ -0,0 +1,37 @@
+module BHM
+  module GoogleMaps
+    module Helper
+      
+      def using_gmaps_js?
+        instance_variable_defined?(:@using_gmaps_js) && !!@using_gmaps_js
+      end
+      
+      def google_maps_url(sensor = false)
+        "http://maps.google.com/maps/api/js?sensor=#{sensor}"
+      end
+      
+      def use_gmaps_js
+        return if using_gmaps_js?
+        BHM::GoogleMaps.include_js_proc.call(self)
+        @using_gmaps_js = true
+      end
+      
+      def draw_map_of(address, options = {})
+        use_gmaps_js
+        BHM::GoogleMaps::Builder.new(self, address, options).to_html
+      end
+      
+      # Given an array of addresses, will return an image an
+      # image tag with a static google map plotting those points.
+      def static_map_of_addresses(addresses, options = {})
+        image_tag(BHM::GoogleMaps::StaticMap.for_addresses(addresses, options), :alt => "#{pluralize addresses.size, "address"} plotted on a map")
+      end
+
+      # Returns an image map with a single address plotted on a single static google map.
+      def static_map_of_address(address, options = {})
+        image_tag(BHM::GoogleMaps::StaticMap.for_address(address, options), :alt => BHM::GoogleMaps.address_to_s_proc(address))
+      end
+      
+    end
+  end
+end

data/lib/bhm/google_maps/static_map.rb

@@ -0,0 +1,60 @@
+module BHM
+  module GoogleMaps
+    class StaticMap
+      URL_TEMPLATE = "http://maps.google.com/maps/api/staticmap?%s"
+      COLOURS      = %w(red white green brown blue orange gray purple yellow black)
+      LABELS       = ('A'..'Z').to_a
+
+      def initialize(options = {})
+        @addresses = []
+        @width, @height = options.fetch(:width, 540), options.fetch(:height, 400)
+        @params = Hash.new.tap do |p|
+          p[:sensor]  = false
+          p[:size]    = "#{@width}x#{@height}"
+          p[:maptype] = options.fetch(:type, "roadmap")
+        end
+      end
+
+      def <<(address)
+        @addresses << address
+      end
+
+      def to_url
+        params = @params.to_param
+        params << "&"
+        params << build_marker_params
+        URL_TEMPLATE % params
+      end
+
+      def self.for_address(address, opts = {})
+        map = self.new(opts.reverse_merge(:zoom => 15))
+        map << address
+        map.to_url
+      end
+
+      def self.for_addresses(*addresses)
+        map = self.new(addresses.extract_options!)
+        addresses.flatten.each { |a| map << a }
+        map.to_url
+      end
+
+      protected
+
+      def build_marker_params
+        params = []
+        @addresses.each_with_index do |address, index|
+          return "markers=#{to_ll @addresses.first}" if @addresses.size == 1
+          color = COLOURS[index % COLOURS.size]
+          label = LABELS[index % LABELS.size]
+          params << "markers=color:#{color}|label:#{label}|#{to_ll(address)}"
+        end
+        params.join("&")
+      end
+
+      def to_ll(address)
+        "#{address.lat},#{address.lng}"
+      end
+
+    end
+  end
+end

data/lib/bhm/google_maps/tasks/bhm_google_maps.rake

@@ -0,0 +1,9 @@
+namespace "bhm-google-maps" do
+  
+  desc "Will copy across the newest version of the javascript files"
+  task :install => :environment do
+    puts "Installing gmap.js file into public/javascripts"
+    BHM::GoogleMaps.install_js!
+  end
+  
+end

data/lib/bhm/google_maps/version.rb

@@ -0,0 +1,5 @@
+module BHM
+  module GoogleMaps
+    VERSION = "0.1.0".freeze
+  end
+end

data/lib/bhm/google_maps.rb

@@ -0,0 +1,46 @@
+require 'active_support'
+
+module BHM
+  module GoogleMaps
+    
+    autoload :StaticMap, 'bhm/google_maps/static_map'
+    autoload :Helper,    'bhm/google_maps/helper'
+    autoload :Builder,   'bhm/google_maps/builder'
+    
+    class << self
+      attr_accessor :container_class, :static_map_class, :include_js_proc,
+                    :address_to_s_proc, :address_to_lat_lng_proc
+    end
+    
+    self.container_class         ||= "gmap"
+    self.static_map_class        ||= "static-google-map"
+    self.include_js_proc         ||= lambda { |t| t.concat(t.javascript_include_tag(t.google_maps_url(false), "gmap.js")) }
+    self.address_to_s_proc       ||= lambda { |a| a.to_s }
+    self.address_to_lat_lng_proc ||= lambda { |a| [a.lat, a.lng] }
+    
+    def self.configure
+      yield self if block_given?
+    end
+    
+    def self.install_helper!
+      ::ActionView::Base.send(:include, BHM::GoogleMaps::Helper)
+    end
+    
+    def self.install_js!
+      from = File.expand_path("../../javascripts/gmap.js", File.dirname(__FILE__))
+      if File.exist?(from) && defined?(Rails.root)
+        FileUtils.cp from, Rails.root.join("public", "javascripts", "gmap.js")
+      end
+    end
+    
+    self.install_helper! if defined?(::ActionView)
+    
+    if defined?(Rails::Railtie)
+      class Railtie < Rails::Railtie
+        rake_tasks do
+          load File.expand_path('./google_maps/tasks/bhm_google_maps.rake', File.dirname(__FILE__))
+        end
+      end
+    end
+  end
+end

data/lib/bhm-google-maps.rb

@@ -0,0 +1 @@
+require 'bhm/google_maps'

data/test/builder_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class BuilderTest < ActionView::TestCase
+end

data/test/helper_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require 'ostruct'
+
+class HelperTest < ActionView::TestCase
+  
+  def setup_default_address
+    @address = Struct.new(:lat, :lng, :to_s).new(10.0, 10.0, "Some address")
+  end
+  
+  setup :setup_default_address
+  
+  test "should return false if not using google maps js" do
+    assert !using_gmaps_js?
+  end
+  
+  test "should let you use google maps js" do
+    use_gmaps_js
+    assert using_gmaps_js?
+    assert_select 'script'
+  end
+  
+  test "should let you draw a map of an address" do
+    concat draw_map_of(@address)
+    assert_select '.gmap'
+  end
+  
+  test "should automatically use gmap js when an address is drawn" do
+    assert !using_gmaps_js?
+    concat draw_map_of(@address)
+    assert using_gmaps_js?
+  end
+  
+  test "should correctly add a container with an address" do
+    concat draw_map_of(@address)
+    assert_select ".#{BHM::GoogleMaps.container_class}"
+  end
+  
+  test "should correctly add an image with an address" do
+    concat draw_map_of(@address)
+    assert_select ".#{BHM::GoogleMaps.static_map_class}"
+  end
+  
+  test "should append a static map image" do
+    concat draw_map_of(@address)
+    assert_select ".#{BHM::GoogleMaps.static_map_class} img"
+  end
+  
+end

data/test/support/misc_helpers.rb

@@ -0,0 +1,21 @@
+module MiscHelpers
+
+  def assert_no_select(*args)
+    assert_raise Test::Unit::AssertionFailedError do
+      assert_select(*args)
+    end
+  end
+
+  def swap(object, new_values)
+    old_values = {}
+    new_values.each do |key, value|
+      old_values[key] = object.send key
+      object.send :"#{key}=", value
+    end
+    yield
+  ensure
+    old_values.each do |key, value|
+      object.send :"#{key}=", value
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'test/unit'
+require 'redgreen' if RUBY_VERSION < '1.9'
+
+require 'action_controller'
+require 'action_view'
+require 'action_view/template'
+require 'action_view/test_case'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bhm-google-maps'
+
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each { |f| require f }
+
+class ActionView::TestCase
+  include MiscHelpers
+  
+  tests BHM::GoogleMaps::Helper
+  
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: bhm-google-maps
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Darcy Laycock
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: A set of helpers and javascript files that makes it trivial to implement google maps unobtrusively in an application.
+email: darcy.laycock@youthtree.org.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- bhm-google-maps.gemspec
+- coffeescripts/gmap.coffee
+- javascripts/gmap.js
+- lib/bhm-google-maps.rb
+- lib/bhm/google_maps.rb
+- lib/bhm/google_maps/builder.rb
+- lib/bhm/google_maps/helper.rb
+- lib/bhm/google_maps/static_map.rb
+- lib/bhm/google_maps/tasks/bhm_google_maps.rake
+- lib/bhm/google_maps/version.rb
+- test/builder_test.rb
+- test/helper_test.rb
+- test/support/misc_helpers.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/YouthTree/bhm-google-maps
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Helpers for Google Maps v3 in Rails - Using html 5, the google maps api v3 and the static maps api
+test_files: 
+- test/builder_test.rb
+- test/helper_test.rb
+- test/support/misc_helpers.rb
+- test/test_helper.rb