really-broken-geocoder 1.5.1

data/lib/geocoder/results/smarty_streets.rb

@@ -0,0 +1,142 @@
+require 'geocoder/lookups/base'
+
+module Geocoder::Result
+  class SmartyStreets < Base
+    def coordinates
+      result = %w(latitude longitude).map do |i|
+        zipcode_endpoint? ? zipcodes.first[i] : metadata[i]
+      end
+
+      if result.compact.empty?
+        nil
+      else
+        result
+      end
+    end
+
+    def address
+      parts =
+        if international_endpoint?
+          (1..12).map { |i| @data["address#{i}"] }
+        else
+          [
+            delivery_line_1,
+            delivery_line_2,
+            last_line
+          ]
+        end
+      parts.select{ |i| i.to_s != "" }.join(" ")
+    end
+
+    def state
+      if international_endpoint?
+        components['administrative_area']
+      elsif zipcode_endpoint?
+        city_states.first['state']
+      else
+        components['state_abbreviation']
+      end
+    end
+
+    def state_code
+      if international_endpoint?
+        components['administrative_area']
+      elsif zipcode_endpoint?
+        city_states.first['state_abbreviation']
+      else
+        components['state_abbreviation']
+      end
+    end
+
+    def country
+      international_endpoint? ?
+        components['country_iso_3'] :
+        "United States"
+    end
+
+    def country_code
+      international_endpoint? ?
+        components['country_iso_3'] :
+        "US"
+    end
+
+    ## Extra methods not in base.rb ------------------------
+
+    def street
+      international_endpoint? ?
+        components['thoroughfare_name'] :
+        components['street_name']
+    end
+
+    def city
+      if international_endpoint?
+        components['locality']
+      elsif zipcode_endpoint?
+        city_states.first['city']
+      else
+        components['city_name']
+      end
+    end
+
+    def zipcode
+      if international_endpoint?
+        components['postal_code']
+      elsif zipcode_endpoint?
+        zipcodes.first['zipcode']
+      else
+        components['zipcode']
+      end
+    end
+    alias_method :postal_code, :zipcode
+
+    def zip4
+      components['plus4_code']
+    end
+    alias_method :postal_code_extended, :zip4
+
+    def fips
+      zipcode_endpoint? ?
+        zipcodes.first['county_fips'] :
+        metadata['county_fips']
+    end
+
+    def zipcode_endpoint?
+      zipcodes.any?
+    end
+
+    def international_endpoint?
+      !@data['address1'].nil?
+    end
+
+    [
+      :delivery_line_1,
+      :delivery_line_2,
+      :last_line,
+      :delivery_point_barcode,
+      :addressee
+    ].each do |m|
+      define_method(m) do
+        @data[m.to_s] || ''
+      end
+    end
+
+    [
+      :components,
+      :metadata,
+      :analysis
+    ].each do |m|
+      define_method(m) do
+        @data[m.to_s] || {}
+      end
+    end
+
+    [
+      :city_states,
+      :zipcodes
+    ].each do |m|
+      define_method(m) do
+        @data[m.to_s] || []
+      end
+    end
+  end
+end

data/lib/geocoder/results/telize.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Telize < Base
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region']
+    end
+
+    def state_code
+      @data['region_code']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def country_code
+      @data['country_code']
+    end
+
+    def postal_code
+      @data['postal_code']
+    end
+
+    def self.response_attributes
+      %w[timezone isp dma_code area_code ip asn continent_code country_code3]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/tencent.rb

@@ -0,0 +1,72 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Tencent < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| @data['location'][i] }
+    end
+
+    def address
+      "#{province}#{city}#{district}#{street}#{street_number}"
+
+      #@data['title'] or @data['address']
+    end
+
+    # NOTE: The Tencent reverse geocoding API has the field named
+    # 'address_component' compared to 'address_components' in the 
+    # regular geocoding API.
+    def province
+      @data['address_components'] and (@data['address_components']['province']) or 
+      (@data['address_component'] and @data['address_component']['province']) or
+      ""
+    end
+
+    alias_method :state, :province
+
+    def city
+      @data['address_components'] and (@data['address_components']['city']) or 
+      (@data['address_component'] and @data['address_component']['city']) or
+      ""
+    end
+
+    def district
+      @data['address_components'] and (@data['address_components']['district']) or 
+      (@data['address_component'] and @data['address_component']['district']) or
+      ""
+    end
+
+    def street
+      @data['address_components'] and (@data['address_components']['street']) or 
+      (@data['address_component'] and @data['address_component']['street']) or
+      ""
+    end
+
+    def street_number
+      @data['address_components'] and (@data['address_components']['street_number']) or 
+      (@data['address_component'] and @data['address_component']['street_number']) or
+      ""
+    end
+
+    def address_components
+      @data['address_components'] or @data['address_component']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+  end
+end

data/lib/geocoder/results/test.rb

@@ -0,0 +1,33 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class Test < Base
+
+      def self.add_result_attribute(attr)
+        begin
+          remove_method(attr) if method_defined?(attr)
+        rescue NameError # method defined on superclass
+        end
+
+        define_method(attr) do
+          @data[attr.to_s] || @data[attr.to_sym]
+        end
+      end
+
+      %w[coordinates neighborhood city state state_code sub_state
+      sub_state_code province province_code postal_code country
+      country_code address street_address street_number route geometry].each do |attr|
+        add_result_attribute(attr)
+      end
+
+      def initialize(data)
+        data.each_key do |attr|
+          Test.add_result_attribute(attr)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/geocoder/results/yandex.rb

@@ -0,0 +1,134 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Yandex < Base
+
+    def coordinates
+      @data['GeoObject']['Point']['pos'].split(' ').reverse.map(&:to_f)
+    end
+
+    def address(format = :full)
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['text']
+    end
+
+    def city
+      if state.empty? and address_details and address_details.has_key? 'Locality'
+        address_details['Locality']['LocalityName']
+      elsif sub_state.empty? and address_details and address_details.has_key? 'AdministrativeArea' and
+          address_details['AdministrativeArea'].has_key? 'Locality'
+        address_details['AdministrativeArea']['Locality']['LocalityName']
+      elsif not sub_state_city.empty?
+        sub_state_city
+      else
+        ""
+      end
+    end
+
+    def country
+      if address_details
+        address_details['CountryName']
+      else
+        ""
+      end
+    end
+
+    def country_code
+      if address_details
+        address_details['CountryNameCode']
+      else
+        ""
+      end
+    end
+
+    def state
+      if address_details and address_details['AdministrativeArea']
+        address_details['AdministrativeArea']['AdministrativeAreaName']
+      else
+        ""
+      end
+    end
+
+    def sub_state
+      if !state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea']
+        address_details['AdministrativeArea']['SubAdministrativeArea']['SubAdministrativeAreaName']
+      else
+        ""
+      end
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def premise_name
+      address_details['Locality']['Premise']['PremiseName']
+    end
+
+    def street
+      thoroughfare_data && thoroughfare_data['ThoroughfareName']
+    end
+
+    def street_number
+      thoroughfare_data && thoroughfare_data['Premise'] && thoroughfare_data['Premise']['PremiseNumber']
+    end
+
+    def kind
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['kind']
+    end
+
+    def precision
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['precision']
+    end
+
+    def viewport
+      envelope = @data['GeoObject']['boundedBy']['Envelope'] || fail
+      east, north = envelope['upperCorner'].split(' ').map(&:to_f)
+      west, south = envelope['lowerCorner'].split(' ').map(&:to_f)
+      [south, west, north, east]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def thoroughfare_data
+      locality_data && locality_data['Thoroughfare']
+    end
+
+    def locality_data
+      dependent_locality && subadmin_locality && admin_locality
+    end
+
+    def admin_locality
+      address_details && address_details['AdministrativeArea'] &&
+        address_details['AdministrativeArea']['Locality']
+    end
+
+    def subadmin_locality
+      address_details && address_details['AdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']
+    end
+
+    def dependent_locality
+      address_details && address_details['AdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality'] &&
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['DependentLocality']
+    end
+
+    def address_details
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
+    end
+
+    def sub_state_city
+      if !sub_state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/geocoder/sql.rb

@@ -0,0 +1,110 @@
+module Geocoder
+  module Sql
+    extend self
+
+    ##
+    # Distance calculation for use with a database that supports POWER(),
+    # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(), 
+    # ATAN2().
+    #
+    # Based on the excellent tutorial at:
+    # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
+    #
+    def full_distance(latitude, longitude, lat_attr, lon_attr, options = {})
+      units = options[:units] || Geocoder.config.units
+      earth = Geocoder::Calculations.earth_radius(units)
+
+      "#{earth} * 2 * ASIN(SQRT(" +
+        "POWER(SIN((#{latitude.to_f} - #{lat_attr}) * PI() / 180 / 2), 2) + " +
+        "COS(#{latitude.to_f} * PI() / 180) * COS(#{lat_attr} * PI() / 180) * " +
+        "POWER(SIN((#{longitude.to_f} - #{lon_attr}) * PI() / 180 / 2), 2)" +
+      "))"
+    end
+
+    ##
+    # Distance calculation for use with a database without trigonometric
+    # functions, like SQLite. Approach is to find objects within a square
+    # rather than a circle, so results are very approximate (will include
+    # objects outside the given radius).
+    #
+    # Distance and bearing calculations are *extremely inaccurate*. To be
+    # clear: this only exists to provide interface consistency. Results
+    # are not intended for use in production!
+    #
+    def approx_distance(latitude, longitude, lat_attr, lon_attr, options = {})
+      units = options[:units] || Geocoder.config.units
+      dx = Geocoder::Calculations.longitude_degree_distance(30, units)
+      dy = Geocoder::Calculations.latitude_degree_distance(units)
+
+      # sin of 45 degrees = average x or y component of vector
+      factor = Math.sin(Math::PI / 4)
+
+      "(#{dy} * ABS(#{lat_attr} - #{latitude.to_f}) * #{factor}) + " +
+        "(#{dx} * ABS(#{lon_attr} - #{longitude.to_f}) * #{factor})"
+    end
+
+    def within_bounding_box(sw_lat, sw_lng, ne_lat, ne_lng, lat_attr, lon_attr)
+      spans = "#{lat_attr} BETWEEN #{sw_lat} AND #{ne_lat} AND "
+      # handle box that spans 180 longitude
+      if sw_lng.to_f > ne_lng.to_f
+        spans + "(#{lon_attr} BETWEEN #{sw_lng} AND 180 OR " +
+        "#{lon_attr} BETWEEN -180 AND #{ne_lng})"
+      else
+        spans + "#{lon_attr} BETWEEN #{sw_lng} AND #{ne_lng}"
+      end
+    end
+
+    ##
+    # Fairly accurate bearing calculation. Takes a latitude, longitude,
+    # and an options hash which must include a :bearing value
+    # (:linear or :spherical).
+    #
+    # For use with a database that supports MOD() and trigonometric functions
+    # SIN(), COS(), ASIN(), ATAN2().
+    #
+    # Based on:
+    # http://www.beginningspatial.com/calculating_bearing_one_point_another
+    #
+    def full_bearing(latitude, longitude, lat_attr, lon_attr, options = {})
+      degrees_per_radian = Geocoder::Calculations::DEGREES_PER_RADIAN
+      case options[:bearing] || Geocoder.config.distances
+      when :linear
+        "MOD(CAST(" +
+          "(ATAN2( " +
+            "((#{lon_attr} - #{longitude.to_f}) / #{degrees_per_radian}), " +
+            "((#{lat_attr} - #{latitude.to_f}) / #{degrees_per_radian})" +
+          ") * #{degrees_per_radian}) + 360 " +
+        "AS decimal), 360)"
+      when :spherical
+        "MOD(CAST(" +
+          "(ATAN2( " +
+            "SIN( (#{lon_attr} - #{longitude.to_f}) / #{degrees_per_radian} ) * " +
+            "COS( (#{lat_attr}) / #{degrees_per_radian} ), (" +
+              "COS( (#{latitude.to_f}) / #{degrees_per_radian} ) * SIN( (#{lat_attr}) / #{degrees_per_radian})" +
+            ") - (" +
+              "SIN( (#{latitude.to_f}) / #{degrees_per_radian}) * COS((#{lat_attr}) / #{degrees_per_radian}) * " +
+              "COS( (#{lon_attr} - #{longitude.to_f}) / #{degrees_per_radian})" +
+            ")" +
+          ") * #{degrees_per_radian}) + 360 " +
+        "AS decimal), 360)"
+      end
+    end
+
+    ##
+    # Totally lame bearing calculation. Basically useless except that it
+    # returns *something* in databases without trig functions.
+    #
+    def approx_bearing(latitude, longitude, lat_attr, lon_attr, options = {})
+      "CASE " +
+        "WHEN (#{lat_attr} >= #{latitude.to_f} AND " +
+          "#{lon_attr} >= #{longitude.to_f}) THEN  45.0 " +
+        "WHEN (#{lat_attr} <  #{latitude.to_f} AND " +
+          "#{lon_attr} >= #{longitude.to_f}) THEN 135.0 " +
+        "WHEN (#{lat_attr} <  #{latitude.to_f} AND " +
+          "#{lon_attr} <  #{longitude.to_f}) THEN 225.0 " +
+        "WHEN (#{lat_attr} >= #{latitude.to_f} AND " +
+          "#{lon_attr} <  #{longitude.to_f}) THEN 315.0 " +
+      "END"
+    end
+  end
+end