bw-geocoder 1.2.5

data/lib/geocoder/lookups/okf.rb

@@ -0,0 +1,43 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/okf"
+
+module Geocoder::Lookup
+  class Okf < Base
+
+    def name
+      "Okf"
+    end
+
+    def query_url(query)
+      "#{protocol}://data.okf.fi/gis/1/geocode/json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def valid_response?(response)
+      status = parse_json(response.body)["status"]
+      super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      case doc['status']; when "OK" # OK status implies >0 results
+        return doc['results']
+      end
+      return []
+    end
+
+    def query_url_okf_params(query)
+      params = {
+        (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
+        :sensor => "false",
+        :language => (query.language || configuration.language)
+      }
+      params
+    end
+
+    def query_url_params(query)
+      query_url_okf_params(query).merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/opencagedata.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/opencagedata'
+
+module Geocoder::Lookup
+  class Opencagedata < Base
+
+    def name
+      "OpenCageData"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.opencagedata.com/geocode/v1/json?key=#{configuration.api_key}&#{url_query_string(query)}"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    private
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      # return doc["results"]
+
+      messages = doc['status']['message']
+      case doc['status']['code']
+      when 400 # Error with input
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      when 403 # Key related error
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      when 402 # Quata Exceeded
+          raise_error(Geocoder::OverQueryLimitError, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      when 500 # Unknown error
+        raise_error(Geocoder::Error, messages) ||
+          warn("Opencagedata Geocoding API error: #{messages}")
+      end
+
+      return doc["results"]
+    end
+
+    def query_url_params(query)
+      params = {
+        :q => query.sanitized_text,
+        :language => (query.language || configuration.language)
+      }.merge(super)
+
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join(',')
+      end
+
+      params
+    end
+
+  end
+end

data/lib/geocoder/lookups/ovi.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ovi'
+
+module Geocoder::Lookup
+  class Ovi < Base
+
+    def name
+      "Ovi"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    def query_url(query)
+      "#{protocol}://lbs.ovi.com/search/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] unless doc['Response'] && doc['Response']['View']
+      if r=doc['Response']['View']
+        return [] if r.nil? || !r.is_a?(Array) || r.empty?
+        return r.first['Result']
+      end
+      []
+    end
+
+    def query_url_params(query)
+      options = {
+        :gen=>1,
+        :app_id=>api_key,
+        :app_code=>api_code
+      }
+
+      if query.reverse_geocode?
+        super.merge(options).merge(
+          :prox=>query.sanitized_text,
+          :mode=>:retrieveAddresses
+        )
+      else
+        super.merge(options).merge(
+          :searchtext=>query.sanitized_text
+        )
+      end
+    end
+
+    def api_key
+      if a=configuration.api_key
+        return a.first if a.is_a?(Array)
+      end
+    end
+
+    def api_code
+      if a=configuration.api_key
+        return a.last if a.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/pointpin.rb

@@ -0,0 +1,68 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/pointpin'
+
+module Geocoder::Lookup
+  class Pointpin < Base
+
+    def name
+      "Pointpin"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "#{ protocol }://geo.pointp.in/#{ api_key }/json/#{ query.sanitized_text }"
+    end
+
+  private
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Hash)
+        if !data_contains_error?(doc)
+          return [doc]
+        elsif doc['error']
+          case doc['error']
+          when "Invalid IP address"
+            raise_error(Geocoder::InvalidRequest) || warn("Invalid Pointpin request.")
+          when "Invalid API key"
+            raise_error(Geocoder::InvalidApiKey) || warn("Invalid Pointpin API key.")
+          when "Address not found"
+            warn("Address not found.")
+          end
+        else
+          raise_error(Geocoder::Error) || warn("Pointpin server error")
+        end
+      end
+      
+      return []
+    end
+
+    def data_contains_error?(parsed_data)
+      parsed_data.keys.include?('error')
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def api_key
+      configuration.api_key
+    end
+  end
+end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -0,0 +1,45 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/smarty_streets'
+
+module Geocoder::Lookup
+  class SmartyStreets < Base
+    def name
+      "SmartyStreets"
+    end
+
+    def required_api_key_parts
+      %w(auti-id auth-token)
+    end
+
+    def query_url(query)
+      path = zipcode_only?(query) ? "zipcode" : "street-address"
+      "#{protocol}://api.smartystreets.com/#{path}?#{url_query_string(query)}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def zipcode_only?(query)
+      !query.text.is_a?(Array) and query.to_s.strip =~ /\A\d{5}(-\d{4})?\Z/
+    end
+
+    def query_url_params(query)
+      params = {}
+      if zipcode_only?(query)
+        params[:zipcode] = query.sanitized_text
+      else
+        params[:street] = query.sanitized_text
+      end
+      if configuration.api_key.is_a?(Array)
+        params[:"auth-id"] = configuration.api_key[0]
+        params[:"auth-token"] = configuration.api_key[1]
+      else
+        params[:"auth-token"] = configuration.api_key
+      end
+      params.merge(super)
+    end
+
+    def results(query)
+      fetch_data(query) || []
+    end
+  end
+end

data/lib/geocoder/lookups/telize.rb

@@ -0,0 +1,40 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/telize'
+
+module Geocoder::Lookup
+  class Telize < Base
+
+    def name
+      "Telize"
+    end
+
+    def query_url(query)
+      #currently doesn't support HTTPS
+      "http://www.telize.com/geoip/#{query.sanitized_text}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def use_ssl?
+      false
+    end
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [reserved_result(query.text)] if query.loopback_ip_address?
+      if (doc = fetch_data(query)).nil? or doc['code'] == 401 or empty_result?(doc)
+        []
+      else
+        [doc]
+      end
+    end
+
+    def empty_result?(doc)
+      !doc.is_a?(Hash) or doc.keys == ["ip"]
+    end
+
+    def reserved_result(ip)
+      {"message" => "Input string is not a valid IP address", "code" => 401}
+    end
+  end
+end

data/lib/geocoder/lookups/test.rb

@@ -0,0 +1,44 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/test'
+
+module Geocoder
+  module Lookup
+    class Test < Base
+
+      def name
+        "Test"
+      end
+
+      def self.add_stub(query_text, results)
+        stubs[query_text] = results
+      end
+
+      def self.set_default_stub(results)
+        @default_stub = results
+      end
+
+      def self.read_stub(query_text)
+        stubs.fetch(query_text) {
+          return @default_stub unless @default_stub.nil?
+          raise ArgumentError, "unknown stub request #{query_text}"
+        }
+      end
+
+      def self.stubs
+        @stubs ||= {}
+      end
+
+      def self.reset
+        @stubs = {}
+        @default_stub = nil
+      end
+
+      private
+
+      def results(query)
+        Geocoder::Lookup::Test.read_stub(query.text)
+      end
+
+    end
+  end
+end

data/lib/geocoder/lookups/yahoo.rb

@@ -0,0 +1,88 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/yahoo"
+require 'oauth_util'
+
+module Geocoder::Lookup
+  class Yahoo < Base
+
+    def name
+      "Yahoo BOSS"
+    end
+
+    def map_link_url(coordinates)
+      "http://maps.yahoo.com/#lat=#{coordinates[0]}&lon=#{coordinates[1]}"
+    end
+
+    def required_api_key_parts
+      ["consumer key", "consumer secret"]
+    end
+
+    def query_url(query)
+      parsed_url = URI.parse(raw_url(query))
+      o = OauthUtil.new
+      o.consumer_key = configuration.api_key[0]
+      o.consumer_secret = configuration.api_key[1]
+      base_url + o.sign(parsed_url).query_string
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      doc = doc['bossresponse']
+      if doc['responsecode'].to_i == 200
+        if doc['placefinder']['count'].to_i > 0
+          return doc['placefinder']['results']
+        else
+          return []
+        end
+      else
+        warn "Yahoo Geocoding API error: #{doc['responsecode']} (#{doc['reason']})."
+        return []
+      end
+    end
+
+    ##
+    # Yahoo returns errors as XML even when JSON format is specified.
+    # Handle that here, without parsing the XML
+    # (which would add unnecessary complexity).
+    # Yahoo auth errors can also be cryptic, so add raw error desc
+    # to warning message.
+    #
+    def parse_raw_data(raw_data)
+      if raw_data.match(/^<\?xml/)
+        if raw_data.include?("Rate Limit Exceeded")
+          raise_error(Geocoder::OverQueryLimitError) || warn("Over API query limit.")
+        elsif raw_data =~ /<yahoo:description>(Please provide valid credentials.*)<\/yahoo:description>/i
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid API key. Error response: #{$1}")
+        end
+      else
+        super(raw_data)
+      end
+    end
+
+    def query_url_params(query)
+      lang = (query.language || configuration.language).to_s
+      lang += '_US' if lang == 'en'
+      {
+        :location => query.sanitized_text,
+        :flags => "JXTSR",
+        :gflags => "AC#{'R' if query.reverse_geocode?}",
+        :locale => lang,
+        :appid => configuration.api_key
+      }.merge(super)
+    end
+
+    def cache_key(query)
+      raw_url(query)
+    end
+
+    def base_url
+      "#{protocol}://yboss.yahooapis.com/geo/placefinder?"
+    end
+
+    def raw_url(query)
+      base_url + url_query_string(query)
+    end
+  end
+end

data/lib/geocoder/lookups/yandex.rb

@@ -0,0 +1,54 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/yandex"
+
+module Geocoder::Lookup
+  class Yandex < Base
+
+    def name
+      "Yandex"
+    end
+
+    def map_link_url(coordinates)
+      "http://maps.yandex.ru/?ll=#{coordinates.reverse.join(',')}"
+    end
+
+    def query_url(query)
+      "#{protocol}://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if err = doc['error']
+        if err["status"] == 401 and err["message"] == "invalid key"
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid API key.")
+        else
+          warn "Yandex Geocoding API error: #{err['status']} (#{err['message']})."
+        end
+        return []
+      end
+      if doc = doc['response']['GeoObjectCollection']
+        meta = doc['metaDataProperty']['GeocoderResponseMetaData']
+        return meta['found'].to_i > 0 ? doc['featureMember'] : []
+      else
+        warn "Yandex Geocoding API error: unexpected response format."
+        return []
+      end
+    end
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        q = query.coordinates.reverse.join(",")
+      else
+        q = query.sanitized_text
+      end
+      {
+        :geocode => q,
+        :format => "json",
+        :plng => "#{query.language || configuration.language}", # supports ru, uk, be
+        :key => configuration.api_key
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/models/active_record.rb

@@ -0,0 +1,50 @@
+require 'geocoder/models/base'
+
+module Geocoder
+  module Model
+    module ActiveRecord
+      include Base
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def geocoded_by(address_attr, options = {}, &block)
+        geocoder_init(
+          :geocode       => true,
+          :user_address  => address_attr,
+          :latitude      => options[:latitude]  || :latitude,
+          :longitude     => options[:longitude] || :longitude,
+          :geocode_block => block,
+          :units         => options[:units],
+          :method        => options[:method],
+          :lookup        => options[:lookup],
+          :language      => options[:language]
+        )
+      end
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def reverse_geocoded_by(latitude_attr, longitude_attr, options = {}, &block)
+        geocoder_init(
+          :reverse_geocode => true,
+          :fetched_address => options[:address] || :address,
+          :latitude        => latitude_attr,
+          :longitude       => longitude_attr,
+          :reverse_block   => block,
+          :units           => options[:units],
+          :method          => options[:method],
+          :lookup          => options[:lookup],
+          :language        => options[:language]
+        )
+      end
+
+
+      private # --------------------------------------------------------------
+
+      def geocoder_file_name;   "active_record"; end
+      def geocoder_module_name; "ActiveRecord"; end
+    end
+  end
+end
+

data/lib/geocoder/models/base.rb

@@ -0,0 +1,39 @@
+module Geocoder
+
+  ##
+  # Methods for invoking Geocoder in a model.
+  #
+  module Model
+    module Base
+
+      def geocoder_options
+        if defined?(@geocoder_options)
+          @geocoder_options
+        elsif superclass.respond_to?(:geocoder_options)
+          superclass.geocoder_options || { }
+        else
+          { }
+        end
+      end
+
+      def geocoded_by
+        fail
+      end
+
+      def reverse_geocoded_by
+        fail
+      end
+
+      private # ----------------------------------------------------------------
+
+      def geocoder_init(options)
+        unless defined?(@geocoder_options)
+          @geocoder_options = {}
+          require "geocoder/stores/#{geocoder_file_name}"
+          include Geocoder::Store.const_get(geocoder_module_name)
+        end
+        @geocoder_options.merge! options
+      end
+    end
+  end
+end

data/lib/geocoder/models/mongo_base.rb

@@ -0,0 +1,64 @@
+require 'geocoder'
+
+module Geocoder
+
+  ##
+  # Methods for invoking Geocoder in a model.
+  #
+  module Model
+    module MongoBase
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def geocoded_by(address_attr, options = {}, &block)
+        geocoder_init(
+          :geocode       => true,
+          :user_address  => address_attr,
+          :coordinates   => options[:coordinates] || :coordinates,
+          :geocode_block => block,
+          :units         => options[:units],
+          :method        => options[:method],
+          :skip_index    => options[:skip_index] || false,
+          :lookup        => options[:lookup],
+          :language      => options[:language]
+        )
+      end
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def reverse_geocoded_by(coordinates_attr, options = {}, &block)
+        geocoder_init(
+          :reverse_geocode => true,
+          :fetched_address => options[:address] || :address,
+          :coordinates     => coordinates_attr,
+          :reverse_block   => block,
+          :units           => options[:units],
+          :method          => options[:method],
+          :skip_index      => options[:skip_index] || false,
+          :lookup          => options[:lookup],
+          :language        => options[:language]
+        )
+      end
+
+      private # ----------------------------------------------------------------
+
+      def geocoder_init(options)
+        unless geocoder_initialized?
+          @geocoder_options = { }
+          require "geocoder/stores/#{geocoder_file_name}"
+          include Geocoder::Store.const_get(geocoder_module_name)
+        end
+        @geocoder_options.merge! options
+      end
+
+      def geocoder_initialized?
+        included_modules.include? Geocoder::Store.const_get(geocoder_module_name)
+      rescue NameError
+        false
+      end
+    end
+  end
+end
+

data/lib/geocoder/models/mongo_mapper.rb

@@ -0,0 +1,26 @@
+require 'geocoder/models/base'
+require 'geocoder/models/mongo_base'
+
+module Geocoder
+  module Model
+    module MongoMapper
+      include Base
+      include MongoBase
+
+      def self.included(base); base.extend(self); end
+
+      private # --------------------------------------------------------------
+
+      def geocoder_file_name;   "mongo_mapper"; end
+      def geocoder_module_name; "MongoMapper"; end
+
+      def geocoder_init(options)
+        super(options)
+        if options[:skip_index] == false
+          ensure_index [[ geocoder_options[:coordinates], Mongo::GEO2D ]],
+            :min => -180, :max => 180 # create 2d index
+        end
+      end
+    end
+  end
+end