geocoder-sgonyea 1.1.6.1

data/lib/geocoder/railtie.rb

@@ -0,0 +1,26 @@
+require 'geocoder'
+require 'geocoder/models/active_record'
+
+module Geocoder
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'geocoder.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          Geocoder::Railtie.insert
+        end
+      end
+      rake_tasks do
+        load "tasks/geocoder.rake"
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      if defined?(::ActiveRecord)
+        ::ActiveRecord::Base.extend(Model::ActiveRecord)
+      end
+    end
+  end
+end

data/lib/geocoder/request.rb

@@ -0,0 +1,23 @@
+require 'geocoder'
+
+module Geocoder
+  module Request
+
+    def location
+      unless defined?(@location)
+        if env.has_key?('HTTP_X_REAL_IP')
+          @location = Geocoder.search(env['HTTP_X_REAL_IP']).first
+        elsif env.has_key?('HTTP_X_FORWARDED_FOR')
+          @location = Geocoder.search(env['HTTP_X_FORWARDED_FOR'].split(/\s*,\s*/)[0]).first
+        else
+          @location = Geocoder.search(ip).first
+        end
+      end
+      @location
+    end
+  end
+end
+
+if defined?(Rack) and defined?(Rack::Request)
+  Rack::Request.send :include, Geocoder::Request
+end

data/lib/geocoder/results/base.rb

@@ -0,0 +1,67 @@
+module Geocoder
+  module Result
+    class Base
+
+      # data (hash) fetched from geocoding service
+      attr_accessor :data
+
+      # true if result came from cache, false if from request to geocoding
+      # service; nil if cache is not configured
+      attr_accessor :cache_hit
+
+      ##
+      # Takes a hash of data from a parsed geocoding service response.
+      #
+      def initialize(data)
+        @data = data
+        @cache_hit = nil
+      end
+
+      ##
+      # A string in the given format.
+      #
+      def address(format = :full)
+        fail
+      end
+
+      ##
+      # A two-element array: [lat, lon].
+      #
+      def coordinates
+        [@data['latitude'].to_f, @data['longitude'].to_f]
+      end
+
+      def latitude
+        coordinates[0]
+      end
+
+      def longitude
+        coordinates[1]
+      end
+
+      def state
+        fail
+      end
+
+      def province
+        state
+      end
+
+      def state_code
+        fail
+      end
+
+      def province_code
+        state_code
+      end
+
+      def country
+        fail
+      end
+
+      def country_code
+        fail
+      end
+    end
+  end
+end

data/lib/geocoder/results/bing.rb

@@ -0,0 +1,48 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Bing < Base
+
+    def address(format = :full)
+      @data['address']['formattedAddress']
+    end
+
+    def city
+      @data['address']['locality']
+    end
+
+    def state_code
+      @data['address']['adminDistrict']
+    end
+
+    alias_method :state, :state_code
+
+    def country
+      @data['address']['countryRegion']
+    end
+
+    alias_method :country_code, :country
+
+    def postal_code
+      @data['address']['postalCode']
+    end
+
+    def coordinates
+      @data['point']['coordinates']
+    end
+
+    def address_data
+      @data['address']
+    end
+
+    def self.response_attributes
+      %w[bbox name confidence entityType]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/freegeoip.rb

@@ -0,0 +1,45 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Freegeoip < Base
+
+    def address(format = :full)
+      s = state_code.to_s == "" ? "" : ", #{state_code}"
+      "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region_name']
+    end
+
+    def state_code
+      @data['region_code']
+    end
+
+    def country
+      @data['country_name']
+    end
+
+    def country_code
+      @data['country_code']
+    end
+
+    def postal_code
+      @data['zipcode']
+    end
+
+    def self.response_attributes
+      %w[metrocode ip]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/geocoder_ca.rb

@@ -0,0 +1,60 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeocoderCa < Base
+
+    def coordinates
+      [@data['latt'].to_f, @data['longt'].to_f]
+    end
+
+    def address(format = :full)
+      "#{street_address}, #{city}, #{state} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def street_address
+      "#{@data['stnumber']} #{@data['staddress']}"
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['prov']
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['postal']
+    end
+
+    def country
+      country_code == 'CA' ? 'Canada' : 'United States'
+    end
+
+    def country_code
+      return nil if state.nil? || state == ""
+      canadian_province_abbreviations.include?(state) ? "CA" : "US"
+    end
+
+    def self.response_attributes
+      %w[latt longt inlatt inlongt distance stnumber staddress prov
+        NearRoad NearRoadDistance betweenRoad1 betweenRoad2
+        intersection major_intersection]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+
+
+    private # ----------------------------------------------------------------
+
+    def canadian_province_abbreviations
+      %w[ON QC NS NB MB BC PE SK AB NL]
+    end
+  end
+end

data/lib/geocoder/results/google.rb

@@ -0,0 +1,106 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Google < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| geometry['location'][i] }
+    end
+
+    def address(format = :full)
+      formatted_address
+    end
+
+    def city
+      fields = [:locality, :sublocality,
+        :administrative_area_level_3,
+        :administrative_area_level_2]
+      fields.each do |f|
+        if entity = address_components_of_type(f).first
+          return entity['long_name']
+        end
+      end
+      return nil # no appropriate components found
+    end
+
+    def state
+      if state = address_components_of_type(:administrative_area_level_1).first
+        state['long_name']
+      end
+    end
+
+    def state_code
+      if state = address_components_of_type(:administrative_area_level_1).first
+        state['short_name']
+      end
+    end
+
+    def country
+      if country = address_components_of_type(:country).first
+        country['long_name']
+      end
+    end
+
+    def country_code
+      if country = address_components_of_type(:country).first
+        country['short_name']
+      end
+    end
+
+    def postal_code
+      if postal = address_components_of_type(:postal_code).first
+        postal['long_name']
+      end
+    end
+
+    def route
+      if route = address_components_of_type(:route).first
+        route['long_name']
+      end
+    end
+
+    def street_number
+      if street_number = address_components_of_type(:street_number).first
+        street_number['long_name']
+      end
+    end
+
+    def street_address
+      [street_number, route].compact.join(' ')
+    end
+
+    def types
+      @data['types']
+    end
+
+    def formatted_address
+      @data['formatted_address']
+    end
+
+    def address_components
+      @data['address_components']
+    end
+
+    ##
+    # Get address components of a given type. Valid types are defined in
+    # Google's Geocoding API documentation and include (among others):
+    #
+    #   :street_number
+    #   :locality
+    #   :neighborhood
+    #   :route
+    #   :postal_code
+    #
+    def address_components_of_type(type)
+      address_components.select{ |c| c['types'].include?(type.to_s) }
+    end
+
+    def geometry
+      @data['geometry']
+    end
+
+    def precision
+      geometry['location_type'] if geometry
+    end
+  end
+end

data/lib/geocoder/results/google_premier.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/google'
+
+module Geocoder::Result
+  class GooglePremier < Google
+  end
+end

data/lib/geocoder/results/mapquest.rb

@@ -0,0 +1,51 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Mapquest < Base
+    def latitude
+      @data["latLng"]["lat"]
+    end
+
+    def longitude
+      @data["latLng"]["lng"]
+    end
+
+    def coordinates
+      [latitude, longitude]
+    end
+
+    def city
+      @data['adminArea5']
+    end
+
+    def street
+      @data['street']
+    end
+
+    def state
+      @data['adminArea3']
+    end
+
+    alias_method :state_code, :state
+
+    #FIXME: these might not be right, unclear with MQ documentation
+    alias_method :province, :state
+    alias_method :province_code, :state
+
+    def postal_code
+      @data['postalCode'].to_s
+    end
+
+    def country
+      @data['adminArea1']
+    end
+
+    def country_code
+      country
+    end
+
+    def address
+      [street, city, state, postal_code, country].reject{|s| s.length == 0 }.join(", ")
+    end
+  end
+end

data/lib/geocoder/results/maxmind.rb

@@ -0,0 +1,136 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Maxmind < Base
+
+    ##
+    # Hash mapping service names to names of returned fields.
+    #
+    def self.field_names
+      {
+        :country => [
+          :country_code,
+          :error
+        ],
+
+        :city => [
+          :country_code,
+          :region_code,
+          :city_name,
+          :latitude,
+          :longitude,
+          :error
+        ],
+
+        :city_isp_org => [
+          :country_code,
+          :region_code,
+          :city_name,
+          :postal_code,
+          :latitude,
+          :longitude,
+          :metro_code,
+          :area_code,
+          :isp_name,
+          :organization_name,
+          :error
+        ],
+
+        :omni => [
+          :country_code,
+          :country_name,
+          :region_code,
+          :region_name,
+          :city_name,
+          :latitude,
+          :longitude,
+          :metro_code,
+          :area_code,
+          :time_zone,
+          :continent_code,
+          :postal_code,
+          :isp_name,
+          :organization_name,
+          :domain,
+          :as_number,
+          :netspeed,
+          :user_type,
+          :accuracy_radius,
+          :country_confidence_factor,
+          :city_confidence_factor,
+          :region_confidence_factor,
+          :postal_confidence_factor,
+          :error
+        ]
+      }
+    end
+
+    ##
+    # Name of the MaxMind service being used.
+    # Inferred from format of @data.
+    #
+    def service_name
+      self.class.field_names.to_a.each do |n,f|
+        return n if (@data.size..@data.size+1).include?(f.size)
+      end
+      nil
+    end
+
+    def field_names
+      self.class.field_names[service_name]
+    end
+
+    def data_hash
+      @data_hash ||= Hash[*field_names.zip(@data).flatten]
+    end
+
+    def coordinates
+      [data_hash[:latitude].to_f, data_hash[:longitude].to_f]
+    end
+
+    def address(format = :full)
+      s = state_code.to_s == "" ? "" : ", #{state_code}"
+      "#{city}#{s} #{postal_code}, #{country_code}".sub(/^[ ,]*/, "")
+    end
+
+    def city
+      data_hash[:city_name]
+    end
+
+    def state # not given by MaxMind
+      data_hash[:region_name] || data_hash[:region_code]
+    end
+
+    def state_code
+      data_hash[:region_code]
+    end
+
+    def country #not given by MaxMind
+      data_hash[:country_name] || data_hash[:country_code]
+    end
+
+    def country_code
+      data_hash[:country_code]
+    end
+
+    def postal_code
+      data_hash[:postal_code]
+    end
+
+    def method_missing(method, *args, &block)
+      if field_names.include?(method)
+        data_hash[method]
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      if field_names.include?(method)
+        true
+      else
+        super
+      end
+    end
+  end
+end