gmaps-autocomplete-rails 0.1.2.1 → 0.1.4

data/vendor/assets/javascripts/gmaps-auto-complete.js

@@ -0,0 +1,297 @@
+var GmapsCompleter, GmapsCompleterDefaultAssist,
+  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+GmapsCompleter = (function() {
+  GmapsCompleter.prototype.geocoder = null;
+
+  GmapsCompleter.prototype.map = null;
+
+  GmapsCompleter.prototype.marker = null;
+
+  GmapsCompleter.prototype.inputField = null;
+
+  GmapsCompleter.prototype.errorField = null;
+
+  GmapsCompleter.prototype.positionOutputter = null;
+
+  GmapsCompleter.prototype.updateUI = null;
+
+  GmapsCompleter.prototype.updateMap = null;
+
+  GmapsCompleter.prototype.region = null;
+
+  GmapsCompleter.prototype.country = null;
+
+  GmapsCompleter.prototype.debugOn = false;
+
+  GmapsCompleter.prototype.mapElem = null;
+
+  GmapsCompleter.prototype.zoomLevel = 2;
+
+  GmapsCompleter.prototype.mapType = null;
+
+  GmapsCompleter.prototype.pos = [0, 0];
+
+  GmapsCompleter.prototype.inputField = '#gmaps-input-address';
+
+  GmapsCompleter.prototype.errorField = '#gmaps-error';
+
+  function GmapsCompleter(opts) {
+    this.keyDownHandler = __bind(this.keyDownHandler, this);
+    this.performGeocode = __bind(this.performGeocode, this);
+    this.init(opts);
+  }
+
+  GmapsCompleter.prototype.init = function(opts) {
+    var callOpts, completerAssistClass, error, lat, latlng, lng, mapElem, mapOptions, mapType, pos, self, zoomLevel;
+    opts = opts || {};
+    callOpts = $.extend(true, {}, opts);
+    this.debugOn = opts['debugOn'];
+    this.debug('init(opts)', opts);
+    completerAssistClass = opts['assist'];
+    try {
+      this.assist = new completerAssistClass;
+    } catch (_error) {
+      error = _error;
+      this.debug('assist error', error, opts['assist']);
+    }
+    this.assist || (this.assist = new GmapsCompleterDefaultAssist);
+    this.defaultOptions = opts['defaultOptions'] || this.assist.options;
+    opts = $.extend(true, {}, this.defaultOptions, opts);
+    this.positionOutputter = opts['positionOutputter'] || this.assist.positionOutputter;
+    this.updateUI = opts['updateUI'] || this.assist.updateUI;
+    this.updateMap = opts['updateMap'] || this.assist.updateMap;
+    this.geocodeErrorMsg = opts['geocodeErrorMsg'] || this.assist.geocodeErrorMsg;
+    this.geocodeErrorMsg = opts['geocodeErrorMsg'] || this.assist.geocodeErrorMsg;
+    this.noAddressFoundMsg = opts['noAddressFoundMsg'] || this.assist.noAddressFoundMsg;
+    pos = opts['pos'];
+    lat = pos[0];
+    lng = pos[1];
+    mapType = opts['mapType'];
+    mapElem = null;
+    this.mapElem = $("gmaps-canvas");
+    if (opts['mapElem']) {
+      this.mapElem = $(opts['mapElem']).get(0);
+    }
+    this.mapType = google.maps.MapTypeId.ROADMAP;
+    zoomLevel = opts['zoomLevel'];
+    this.inputField = opts['inputField'];
+    this.errorField = opts['#gmaps-error'];
+    this.debugOn = opts['debugOn'];
+    this.debug('called with opts', callOpts);
+    this.debug('final completerAssist', this.completerAssist);
+    this.debug('defaultOptions', this.defaultOptions);
+    this.debug('options after merge with defaults', opts);
+    latlng = new google.maps.LatLng(lat, lng);
+    this.debug('lat,lng', latlng);
+    mapOptions = {
+      zoom: zoomLevel,
+      center: latlng,
+      mapTypeId: mapType
+    };
+    this.debug('map options', mapOptions);
+    this.geocoder = new google.maps.Geocoder();
+    self = this;
+    if (typeof this.mapElem === 'undefined') {
+      this.showError("Map element " + opts['mapElem'] + " could not be resolved!");
+    }
+    this.debug('mapElem', this.mapElem);
+    if (!this.mapElem) {
+      return;
+    }
+    this.map = new google.maps.Map(this.mapElem, mapOptions);
+    if (!this.map) {
+      return;
+    }
+    this.marker = new google.maps.Marker({
+      map: this.map,
+      draggable: true
+    });
+    return self.addMapListeners(this.marker, this.map);
+  };
+
+  GmapsCompleter.prototype.debug = function(label, obj) {
+    if (!this.debugOn) {
+      return;
+    }
+    return console.log(label, obj);
+  };
+
+  GmapsCompleter.prototype.addMapListeners = function(marker, map) {
+    var self;
+    self = this;
+    google.maps.event.addListener(marker, 'dragend', function() {
+      return self.geocodeLookup('latLng', marker.getPosition());
+    });
+    return google.maps.event.addListener(map, 'click', function(event) {
+      marker.setPosition(event.latLng);
+      return self.geocodeLookup('latLng', event.latLng);
+    });
+  };
+
+  GmapsCompleter.prototype.geocodeLookup = function(type, value, update) {
+    var request;
+    this.update || (this.update = false);
+    request = {};
+    request[type] = value;
+    return this.geocoder.geocode(request, this.performGeocode);
+  };
+
+  GmapsCompleter.prototype.performGeocode = function(results, status) {
+    this.debug('performGeocode', status);
+    $(this.errorField).html('');
+    if (status === google.maps.GeocoderStatus.OK) {
+      return this.geocodeSuccess(results);
+    } else {
+      return this.geocodeFailure(type, value);
+    }
+  };
+
+  GmapsCompleter.prototype.geocodeSuccess = function(results) {
+    this.debug('geocodeSuccess', results);
+    if (results[0]) {
+      this.updateUI(results[0].formatted_address, results[0].geometry.location);
+      if (this.update) {
+        return this.updateMap(results[0].geometry);
+      }
+    } else {
+      return this.showError(this.geocodeErrorMsg());
+    }
+  };
+
+  GmapsCompleter.prototype.geocodeFailure = function(type, value) {
+    this.debug('geocodeFailure', type);
+    if (type === 'address') {
+      return this.showError(this.invalidAddressMsg(value));
+    } else {
+      this.showError(this.noAddressFoundMsg());
+      return this.updateUI('', value);
+    }
+  };
+
+  GmapsCompleter.prototype.showError = function(msg) {
+    $(this.errorField).html(msg);
+    $(this.errorField).show();
+    return setTimeout(function() {
+      return $(this.errorField).hide();
+    }, 1000);
+  };
+
+  GmapsCompleter.prototype.autoCompleteInit = function(opts) {
+    var autocompleteOpts, defaultAutocompleteOpts, self;
+    opts = opts || {};
+    this.region = opts['region'] || this.defaultOptions['region'];
+    this.country = opts['country'] || this.defaultOptions['country'];
+    this.debug('region', this.region);
+    self = this;
+    autocompleteOpts = opts['autocomplete'] || {};
+    defaultAutocompleteOpts = {
+      select: function(event, ui) {
+        self.updateUI(ui.item.value, ui.item.geocode.geometry.location);
+        return self.updateMap(ui.item.geocode.geometry);
+      },
+      source: function(request, response) {
+        var address, geocodeOpts, region, region_postfix;
+        region_postfix = '';
+        region = self.region;
+        if (region) {
+          region_postfix = ', ' + region;
+        }
+        address = request.term + region_postfix;
+        self.debug('geocode address', address);
+        geocodeOpts = {
+          'address': address
+        };
+        return self.geocoder.geocode(geocodeOpts, function(results, status) {
+          return response($.map(results, function(item) {
+            var uiAddress;
+            uiAddress = item.formatted_address.replace(", " + self.country, '');
+            return {
+              label: uiAddress,
+              value: uiAddress,
+              geocode: item
+            };
+          }));
+        });
+      }
+    };
+    autocompleteOpts = $.extend(true, defaultAutocompleteOpts, autocompleteOpts);
+    $(this.inputField).autocomplete(autocompleteOpts);
+    return $(this.inputField).bind('keydown', this.keyDownHandler);
+  };
+
+  GmapsCompleter.prototype.keyDownHandler = function(event) {
+    if (event.keyCode === 13) {
+      this.geocodeLookup('address', $(this.inputField).val(), true);
+      return $(this.inputField).autocomplete("disable");
+    } else {
+      return $(this.inputField).autocomplete("enable");
+    }
+  };
+
+  return GmapsCompleter;
+
+})();
+
+GmapsCompleterDefaultAssist = (function() {
+  function GmapsCompleterDefaultAssist() {}
+
+  GmapsCompleterDefaultAssist.prototype.options = {
+    mapElem: '#gmaps-canvas',
+    zoomLevel: 2,
+    mapType: google.maps.MapTypeId.ROADMAP,
+    pos: [0, 0],
+    inputField: '#gmaps-input-address',
+    errorField: '#gmaps-error',
+    debugOn: true
+  };
+
+  GmapsCompleterDefaultAssist.prototype.updateMap = function(geometry) {
+    var map, marker;
+    map = this.map;
+    marker = this.marker;
+    if (map) {
+      map.fitBounds(geometry.viewport);
+    }
+    if (marker) {
+      return marker.setPosition(geometry.location);
+    }
+  };
+
+  GmapsCompleterDefaultAssist.prototype.updateUI = function(address, latLng) {
+    var country, inputField, updateAdr;
+    inputField = this.inputField;
+    country = this.country;
+    $(inputField).autocomplete('close');
+    this.debug('country', country);
+    updateAdr = address.replace(', ' + country, '');
+    updateAdr = address;
+    this.debug('updateAdr', updateAdr);
+    $(inputField).val(updateAdr);
+    return this.positionOutputter(latLng);
+  };
+
+  GmapsCompleterDefaultAssist.prototype.positionOutputter = function(latLng) {
+    $('#gmaps-output-latitude').html(latLng.lat());
+    return $('#gmaps-output-longitude').html(latLng.lng());
+  };
+
+  GmapsCompleterDefaultAssist.prototype.geocodeErrorMsg = function() {
+    return "Sorry, something went wrong. Try again!";
+  };
+
+  GmapsCompleterDefaultAssist.prototype.invalidAddressMsg = function(value) {
+    return "Sorry! We couldn't find " + value + ". Try a different search term, or click the map.";
+  };
+
+  GmapsCompleterDefaultAssist.prototype.noAddressFoundMsg = function() {
+    return "Woah... that's pretty remote! You're going to have to manually enter a place name.";
+  };
+
+  return GmapsCompleterDefaultAssist;
+
+})();
+
+window.GmapsCompleter = GmapsCompleter;
+
+window.GmapsCompleterDefaultAssist = GmapsCompleterDefaultAssist;

metadata

@@ -1,110 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: gmaps-autocomplete-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.2.1
-  prerelease: 
+  version: 0.1.4
 platform: ruby
 authors:
 - Kristian Mandrup
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-04 00:00:00.000000000 Z
+date: 2014-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.12'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.8.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.8.4
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
 description: Easily add autocomplete geo-functionality to your Rails app :)
@@ -115,66 +102,36 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- .document
-- .rspec
-- CHANGELOG
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
-- Rakefile
-- VERSION
 - gmaps-autocomplete-rails.gemspec
 - lib/gmaps-autocomplete-rails.rb
 - lib/gmaps-autocomplete/view_helper.rb
-- spec/index.html
-- spec/init.js
-- spec/jquery-ui/images/ui-bg_flat_0_aaaaaa_40x100.png
-- spec/jquery-ui/images/ui-bg_glass_55_fbf9ee_1x400.png
-- spec/jquery-ui/images/ui-bg_glass_65_ffffff_1x400.png
-- spec/jquery-ui/images/ui-bg_glass_75_dadada_1x400.png
-- spec/jquery-ui/images/ui-bg_glass_75_e6e6e6_1x400.png
-- spec/jquery-ui/images/ui-bg_glass_75_ffffff_1x400.png
-- spec/jquery-ui/images/ui-bg_highlight-soft_75_cccccc_1x100.png
-- spec/jquery-ui/images/ui-bg_inset-soft_95_fef1ec_1x100.png
-- spec/jquery-ui/images/ui-icons_222222_256x240.png
-- spec/jquery-ui/images/ui-icons_2e83ff_256x240.png
-- spec/jquery-ui/images/ui-icons_454545_256x240.png
-- spec/jquery-ui/images/ui-icons_888888_256x240.png
-- spec/jquery-ui/images/ui-icons_cd0a0a_256x240.png
-- spec/jquery-ui/images/ui-icons_f6cf3b_256x240.png
-- spec/jquery-ui/jquery-ui-1.8.16.custom.css
-- spec/jquery-ui/jquery.ui.1.8.16.ie.css
-- spec/main.css
-- spec/spec_helper.rb
-- vendor/assets/javascripts/gmaps-autocomplete.js
+- vendor/assets/javascripts/gmaps-auto-complete.js
 homepage: http://github.com/kristianmandrup/gmaps-autocomplete-rails
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3294242176316535928
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Google Maps v3 search with jQuery UI Autocomplete, ready for use with Rails
   asset pipeline
 test_files: []