geocomplete_rails 1.4.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Guy Israeli
+
+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,37 @@
+# GeocompleteRails
+
+jQuery Geocoding and Places Autocomplete Plugin
+
+for Rails 3.1+ and Rails 4 
+
+see demo - http://ubilabs.github.io/geocomplete/
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'geocomplete_rails'
+
+Add this to application.js
+
+    //= require geocomplete
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geocomplete_rails
+
+## Usage
+
+see demo - http://ubilabs.github.io/geocomplete/
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/assets/javascripts/geocomplete.js

@@ -0,0 +1,451 @@
+/*!
+ * jQuery Geocoding and Places Autocomplete Plugin - V 1.4.1
+ *
+ * @author Martin Kleppe <kleppe@ubilabs.net>, 2012
+ * @author Ubilabs http://ubilabs.net, 2012
+ * @license MIT License <http://www.opensource.org/licenses/mit-license.php>
+ */
+
+
+;(function($, window, document, undefined){
+
+  // ## Options
+  // The default options for this plugin.
+  //
+  // * `map` - Might be a selector, an jQuery object or a DOM element. Default is `false` which shows no map.
+  // * `details` - The container that should be populated with data. Defaults to `false` which ignores the setting.
+  // * `location` - Location to initialize the map on. Might be an address `string` or an `array` with [latitude, longitude] or a `google.maps.LatLng`object. Default is `false` which shows a blank map.
+  // * `bounds` - Whether to snap geocode search to map bounds. Default: `true` if false search globally. Alternatively pass a custom `LatLngBounds object.
+  // * `detailsAttribute` - The attribute's name to use as an indicator. Default: `"name"`
+  // * `mapOptions` - Options to pass to the `google.maps.Map` constructor. See the full list [here](http://code.google.com/apis/maps/documentation/javascript/reference.html#MapOptions).
+  // * `mapOptions.zoom` - The inital zoom level. Default: `14`
+  // * `mapOptions.scrollwheel` - Whether to enable the scrollwheel to zoom the map. Default: `false`
+  // * `mapOptions.mapTypeId` - The map type. Default: `"roadmap"`
+  // * `markerOptions` - The options to pass to the `google.maps.Marker` constructor. See the full list [here](http://code.google.com/apis/maps/documentation/javascript/reference.html#MarkerOptions).
+  // * `markerOptions.draggable` - If the marker is draggable. Default: `false`. Set to true to enable dragging.
+  // * `markerOptions.disabled` - Do not show marker. Default: `false`. Set to true to disable marker.
+  // * `maxZoom` - The maximum zoom level too zoom in after a geocoding response. Default: `16`
+  // * `types` - An array containing one or more of the supported types for the places request. Default: `['geocode']` See the full list [here](http://code.google.com/apis/maps/documentation/javascript/places.html#place_search_requests).
+
+  var defaults = {
+    bounds: true,
+    country: null,
+    map: false,
+    details: false,
+    detailsAttribute: "name",
+    location: false,
+
+    mapOptions: {
+      zoom: 14,
+      scrollwheel: false,
+      mapTypeId: "roadmap"
+    },
+
+    markerOptions: {
+      draggable: false
+    },
+
+    maxZoom: 16,
+    types: ['geocode'],
+    blur: false
+  };
+
+  // See: [Geocoding Types](https://developers.google.com/maps/documentation/geocoding/#Types)
+  // on Google Developers.
+  var componentTypes = ("street_address route intersection political " +
+    "country administrative_area_level_1 administrative_area_level_2 " +
+    "administrative_area_level_3 colloquial_area locality sublocality " +
+    "neighborhood premise subpremise postal_code natural_feature airport " +
+    "park point_of_interest post_box street_number floor room " +
+    "lat lng viewport location " +
+    "formatted_address location_type bounds").split(" ");
+
+  // See: [Places Details Responses](https://developers.google.com/maps/documentation/javascript/places#place_details_responses)
+  // on Google Developers.
+  var placesDetails = ("id url website vicinity reference name rating " +
+    "international_phone_number icon formatted_phone_number").split(" ");
+
+  // The actual plugin constructor.
+  function GeoComplete(input, options) {
+
+    this.options = $.extend(true, {}, defaults, options);
+
+    this.input = input;
+    this.$input = $(input);
+
+    this._defaults = defaults;
+    this._name = 'geocomplete';
+
+    this.init();
+  }
+
+  // Initialize all parts of the plugin.
+  $.extend(GeoComplete.prototype, {
+    init: function(){
+      this.initMap();
+      this.initMarker();
+      this.initGeocoder();
+      this.initDetails();
+      this.initLocation();
+    },
+
+    // Initialize the map but only if the option `map` was set.
+    // This will create a `map` within the given container
+    // using the provided `mapOptions` or link to the existing map instance.
+    initMap: function(){
+      if (!this.options.map){ return; }
+
+      if (typeof this.options.map.setCenter == "function"){
+        this.map = this.options.map;
+        return;
+      }
+
+      this.map = new google.maps.Map(
+        $(this.options.map)[0],
+        this.options.mapOptions
+      );
+
+      // add click event listener on the map
+      google.maps.event.addListener(
+        this.map,
+        'click',
+        $.proxy(this.mapClicked, this)
+      );
+    },
+
+    // Add a marker with the provided `markerOptions` but only
+    // if the option was set. Additionally it listens for the `dragend` event
+    // to notify the plugin about changes.
+    initMarker: function(){
+      if (!this.map){ return; }
+      var options = $.extend(this.options.markerOptions, { map: this.map });
+
+      if (options.disabled){ return; }
+
+      this.marker = new google.maps.Marker(options);
+
+      google.maps.event.addListener(
+        this.marker,
+        'dragend',
+        $.proxy(this.markerDragged, this)
+      );
+    },
+
+    // Associate the input with the autocompleter and create a geocoder
+    // to fall back when the autocompleter does not return a value.
+    initGeocoder: function(){
+
+      var options = {
+        types: this.options.types,
+        bounds: this.options.bounds === true ? null : this.options.bounds,
+        componentRestrictions: this.options.componentRestrictions
+      };
+
+      if (this.options.country){
+        options.componentRestrictions = {country: this.options.country}
+      }
+
+      this.autocomplete = new google.maps.places.Autocomplete(
+        this.input, options
+      );
+
+      this.geocoder = new google.maps.Geocoder();
+
+      // Bind autocomplete to map bounds but only if there is a map
+      // and `options.bindToMap` is set to true.
+      if (this.map && this.options.bounds === true){
+        this.autocomplete.bindTo('bounds', this.map);
+      }
+
+      // Watch `place_changed` events on the autocomplete input field.
+      google.maps.event.addListener(
+        this.autocomplete,
+        'place_changed',
+        $.proxy(this.placeChanged, this)
+      );
+
+      // Prevent parent form from being submitted if user hit enter.
+      this.$input.keypress(function(event){
+        if (event.keyCode === 13){ return false; }
+      });
+
+      // Listen for "geocode" events and trigger find action.
+      this.$input.bind("geocode", $.proxy(function(){
+        this.find();
+      }, this));
+
+      // Trigger find action when input element is blured out.
+      // (Usefull for typing partial location and tabing to the next field
+      // or clicking somewhere else.)
+      if (this.options.blur === true){
+        this.$input.blur($.proxy(function(){
+          this.find();
+        }, this));
+      }
+    },
+
+    // Prepare a given DOM structure to be populated when we got some data.
+    // This will cycle through the list of component types and map the
+    // corresponding elements.
+    initDetails: function(){
+      if (!this.options.details){ return; }
+
+      var $details = $(this.options.details),
+        attribute = this.options.detailsAttribute,
+        details = {};
+
+      function setDetail(value){
+        details[value] = $details.find("[" +  attribute + "=" + value + "]");
+      }
+
+      $.each(componentTypes, function(index, key){
+        setDetail(key);
+        setDetail(key + "_short");
+      });
+
+      $.each(placesDetails, function(index, key){
+        setDetail(key);
+      });
+
+      this.$details = $details;
+      this.details = details;
+    },
+
+    // Set the initial location of the plugin if the `location` options was set.
+    // This method will care about converting the value into the right format.
+    initLocation: function() {
+
+      var location = this.options.location, latLng;
+
+      if (!location) { return; }
+
+      if (typeof location == 'string') {
+        this.find(location);
+        return;
+      }
+
+      if (location instanceof Array) {
+        latLng = new google.maps.LatLng(location[0], location[1]);
+      }
+
+      if (location instanceof google.maps.LatLng){
+        latLng = location;
+      }
+
+      if (latLng){
+        if (this.map){ this.map.setCenter(latLng); }
+        if (this.marker){ this.marker.setPosition(latLng); }
+      }
+    },
+
+    // Look up a given address. If no `address` was specified it uses
+    // the current value of the input.
+    find: function(address){
+      this.geocode({
+        address: address || this.$input.val()
+      });
+    },
+
+    // Requests details about a given location.
+    // Additionally it will bias the requests to the provided bounds.
+    geocode: function(request){
+      if (this.options.bounds && !request.bounds){
+        if (this.options.bounds === true){
+          request.bounds = this.map && this.map.getBounds();
+        } else {
+          request.bounds = this.options.bounds;
+        }
+      }
+
+      if (this.options.country){
+        request.region = this.options.country;
+      }
+
+      this.geocoder.geocode(request, $.proxy(this.handleGeocode, this));
+    },
+
+    // Handles the geocode response. If more than one results was found
+    // it triggers the "geocode:multiple" events. If there was an error
+    // the "geocode:error" event is fired.
+    handleGeocode: function(results, status){
+      if (status === google.maps.GeocoderStatus.OK) {
+        var result = results[0];
+        this.$input.val(result.formatted_address);
+        this.update(result);
+
+        if (results.length > 1){
+          this.trigger("geocode:multiple", results);
+        }
+
+      } else {
+        this.trigger("geocode:error", status);
+      }
+    },
+
+    // Triggers a given `event` with optional `arguments` on the input.
+    trigger: function(event, argument){
+      this.$input.trigger(event, [argument]);
+    },
+
+    // Set the map to a new center by passing a `geometry`.
+    // If the geometry has a viewport, the map zooms out to fit the bounds.
+    // Additionally it updates the marker position.
+    center: function(geometry){
+
+      if (geometry.viewport){
+        this.map.fitBounds(geometry.viewport);
+        if (this.map.getZoom() > this.options.maxZoom){
+          this.map.setZoom(this.options.maxZoom);
+        }
+      } else {
+        this.map.setZoom(this.options.maxZoom);
+        this.map.setCenter(geometry.location);
+      }
+
+      if (this.marker){
+        this.marker.setPosition(geometry.location);
+        this.marker.setAnimation(this.options.markerOptions.animation);
+      }
+    },
+
+    // Update the elements based on a single places or geoocoding response
+    // and trigger the "geocode:result" event on the input.
+    update: function(result){
+
+      if (this.map){
+        this.center(result.geometry);
+      }
+
+      if (this.$details){
+        this.fillDetails(result);
+      }
+
+      this.trigger("geocode:result", result);
+    },
+
+    // Populate the provided elements with new `result` data.
+    // This will lookup all elements that has an attribute with the given
+    // component type.
+    fillDetails: function(result){
+
+      var data = {},
+        geometry = result.geometry,
+        viewport = geometry.viewport,
+        bounds = geometry.bounds;
+
+      // Create a simplified version of the address components.
+      $.each(result.address_components, function(index, object){
+        var name = object.types[0];
+        data[name] = object.long_name;
+        data[name + "_short"] = object.short_name;
+      });
+
+      // Add properties of the places details.
+      $.each(placesDetails, function(index, key){
+        data[key] = result[key];
+      });
+
+      // Add infos about the address and geometry.
+      $.extend(data, {
+        formatted_address: result.formatted_address,
+        location_type: geometry.location_type || "PLACES",
+        viewport: viewport,
+        bounds: bounds,
+        location: geometry.location,
+        lat: geometry.location.lat(),
+        lng: geometry.location.lng()
+      });
+
+      // Set the values for all details.
+      $.each(this.details, $.proxy(function(key, $detail){
+        var value = data[key];
+        this.setDetail($detail, value);
+      }, this));
+
+      this.data = data;
+    },
+
+    // Assign a given `value` to a single `$element`.
+    // If the element is an input, the value is set, otherwise it updates
+    // the text content.
+    setDetail: function($element, value){
+
+      if (value === undefined){
+        value = "";
+      } else if (typeof value.toUrlValue == "function"){
+        value = value.toUrlValue();
+      }
+
+      if ($element.is(":input")){
+        $element.val(value);
+      } else {
+        $element.text(value);
+      }
+    },
+
+    // Fire the "geocode:dragged" event and pass the new position.
+    markerDragged: function(event){
+      this.trigger("geocode:dragged", event.latLng);
+    },
+
+    mapClicked: function(event) {
+        this.trigger("geocode:click", event.latLng);
+    },
+
+    // Restore the old position of the marker to the last now location.
+    resetMarker: function(){
+      this.marker.setPosition(this.data.location);
+      this.setDetail(this.details.lat, this.data.location.lat());
+      this.setDetail(this.details.lng, this.data.location.lng());
+    },
+
+    // Update the plugin after the user has selected an autocomplete entry.
+    // If the place has no geometry it passes it to the geocoder.
+    placeChanged: function(){
+      var place = this.autocomplete.getPlace();
+
+      if (!place.geometry){
+        this.find(place.name);
+      } else {
+        this.update(place);
+      }
+    }
+  });
+
+  // A plugin wrapper around the constructor.
+  // Pass `options` with all settings that are different from the default.
+  // The attribute is used to prevent multiple instantiations of the plugin.
+  $.fn.geocomplete = function(options) {
+
+    var attribute = 'plugin_geocomplete';
+
+    // If you call `.geocomplete()` with a string as the first parameter
+    // it returns the corresponding property or calls the method with the
+    // following arguments.
+    if (typeof options == "string"){
+
+      var instance = $(this).data(attribute) || $(this).geocomplete().data(attribute),
+        prop = instance[options];
+
+      if (typeof prop == "function"){
+        prop.apply(instance, Array.prototype.slice.call(arguments, 1));
+        return $(this);
+      } else {
+        if (arguments.length == 2){
+          prop = arguments[1];
+        }
+        return prop;
+      }
+    } else {
+      return this.each(function() {
+        // Prevent against multiple instantiations.
+        var instance = $.data(this, attribute);
+        if (!instance) {
+          instance = new GeoComplete( this, options )
+          $.data(this, attribute, instance);
+        }
+      });
+    }
+  };
+
+})( jQuery, window, document );

data/geocomplete_rails.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geocomplete_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "geocomplete_rails"
+  spec.version       = GeocompleteRails::VERSION
+  spec.authors       = ["Guy Israeli"]
+  spec.description   = %q{Wrapper for geocomplete.js - a jQuery Geocoding and Places Autocomplete Plugin}
+  spec.summary       = %q{jQuery Geocoding and Places Autocomplete Plugin}
+  spec.homepage      = "https://github.com/guyisra/geocomplete_rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "railties", ">=3.1"
+
+end

data/lib/geocomplete_rails.rb

@@ -0,0 +1,8 @@
+require "geocomplete_rails/version"
+
+module GeocompleteRails
+ module Rails
+  class Engine < ::Rails::Engine
+  end
+ end
+end

data/lib/geocomplete_rails/version.rb

@@ -0,0 +1,3 @@
+module GeocompleteRails
+  VERSION = "1.4.1"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: geocomplete_rails
+version: !ruby/object:Gem::Version
+  version: 1.4.1
+  prerelease: 
+platform: ruby
+authors:
+- Guy Israeli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Wrapper for geocomplete.js - a jQuery Geocoding and Places Autocomplete
+  Plugin
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/geocomplete.js
+- geocomplete_rails.gemspec
+- lib/geocomplete_rails.rb
+- lib/geocomplete_rails/version.rb
+homepage: https://github.com/guyisra/geocomplete_rails
+licenses:
+- MIT
+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.24
+signing_key: 
+specification_version: 3
+summary: jQuery Geocoding and Places Autocomplete Plugin
+test_files: []