geocoder 1.1.9 → 1.2.0

data/lib/geocoder/results/geocodio.rb

@@ -0,0 +1,66 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Geocodio < Base
+    def number
+      address_components["number"]
+    end
+
+    def street
+      address_components["street"]
+    end
+
+    def suffix
+      address_components["suffix"]
+    end
+
+    def state
+      address_components["state"]
+    end
+    alias_method :state_code, :state
+
+    def zip
+      address_components["zip"]
+    end
+    alias_method :postal_code, :zip
+
+    def country
+      "United States" # Geocodio only supports the US
+    end
+
+    def country_code
+      "US" # Geocodio only supports the US
+    end
+
+    def city
+      address_components["city"]
+    end
+
+    def postdirectional
+      address_components["postdirectional"]
+    end
+
+    def location
+      @data['location']
+    end
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| location[i] } if location
+    end
+
+    def accuracy
+      @data['accuracy'].to_f if @data.key?('accuracy')
+    end
+
+    def formatted_address(format = :full)
+      @data['formatted_address']
+    end
+    alias_method :address, :formatted_address
+
+    private
+
+    def address_components
+      @data['address_components'] || {}
+    end
+  end
+end

data/lib/geocoder/results/here.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Here < Base
+
+    ##
+    # A string in the given format.
+    #
+    def address(format = :full)
+      address_data['Label']
+    end
+
+    ##
+    # A two-element array: [lat, lon].
+    #
+    def coordinates
+      fail unless d = @data['Location']['DisplayPosition']
+      [d['Latitude'].to_f, d['Longitude'].to_f]
+    end
+
+    def state
+      address_data['County']
+    end
+
+    def province
+      address_data['County']
+    end
+
+    def postal_code
+      address_data['PostalCode']
+    end
+
+    def city
+      address_data['City']
+    end
+
+    def state_code
+      address_data['State']
+    end
+
+    def province_code
+      address_data['State']
+    end
+
+    def country
+      fail unless d = address_data['AdditionalData']
+      if v = d.find{|ad| ad['key']=='CountryName'}
+        return v['value']
+      end
+    end
+
+    def country_code
+      address_data['Country']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def address_data
+      @data['Location']['Address'] || fail
+    end
+  end
+end

data/lib/geocoder/results/maxmind_local.rb

@@ -0,0 +1,49 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class MaxmindLocal < Base
+
+    def address(format = :full)
+      s = state.to_s == "" ? "" : ", #{state}"
+      "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def coordinates
+      [@data[:latitude], @data[:longitude]]
+    end
+
+    def city
+      @data[:city_name]
+    end
+
+    def state
+      @data[:region_name]
+    end
+
+    def state_code
+      "" # Not available in Maxmind's database
+    end
+
+    def country
+      @data[:country_name]
+    end
+
+    def country_code
+      @data[:country_code2]
+    end
+
+    def postal_code
+      @data[:postal_code]
+    end
+
+    def self.response_attributes
+      %w[ip]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/smarty_streets.rb

@@ -0,0 +1,106 @@
+require 'geocoder/lookups/base'
+
+module Geocoder::Result
+  class SmartyStreets < Base
+    def coordinates
+      %w(latitude longitude).map do |i|
+        zipcode_endpoint? ? zipcodes.first[i] : metadata[i]
+      end
+    end
+
+    def address
+      [
+        delivery_line_1,
+        delivery_line_2,
+        last_line
+      ].select{ |i| i.to_s != "" }.join(" ")
+    end
+
+    def state
+      zipcode_endpoint? ?
+        city_states.first['state'] :
+        components['state_abbreviation']
+    end
+
+    def state_code
+      zipcode_endpoint? ?
+        city_states.first['state_abbreviation'] :
+        components['state_abbreviation']
+    end
+
+    def country
+      # SmartyStreets returns results for USA only
+      "United States"
+    end
+
+    def country_code
+      # SmartyStreets returns results for USA only
+      "US"
+    end
+
+    ## Extra methods not in base.rb ------------------------
+
+    def street
+      components['street_name']
+    end
+
+    def city
+      zipcode_endpoint? ?
+        city_states.first['city'] :
+        components['city_name']
+    end
+
+    def zipcode
+      zipcode_endpoint? ?
+        zipcodes.first['zipcode'] :
+        components['zipcode']
+    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
+
+    [
+      :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/test.rb

@@ -4,13 +4,30 @@ module Geocoder
   module Result
     class Test < Base
 
-      %w[latitude longitude city state state_code province
-      province_code postal_code country country_code address
-      street_address street_number route].each do |attr|
+      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[latitude longitude 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.keys.each do |attr|
+          Test.add_result_attribute(attr)
+        end
+
+        super
+      end
     end
   end
 end

data/lib/geocoder/results/yandex.rb

@@ -14,7 +14,7 @@ module Geocoder::Result
     def city
       if state.empty? and address_details.has_key? 'Locality'
         address_details['Locality']['LocalityName']
-      elsif sub_state.empty?
+      elsif sub_state.empty? and address_details['AdministrativeArea'].has_key? 'Locality'
         address_details['AdministrativeArea']['Locality']['LocalityName']
       elsif not sub_state_city.empty?
         sub_state_city
@@ -59,6 +59,10 @@ module Geocoder::Result
       address_details['Locality']['Premise']['PremiseName']
     end
 
+    def kind
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['kind']
+    end
+
     def precision
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['precision']
     end
@@ -70,8 +74,8 @@ module Geocoder::Result
     end
 
     def sub_state_city
-      if sub_state && sub_state["Locality"]
-        sub_state['Locality']['LocalityName']          
+      if !sub_state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
       else
         ""
       end

data/lib/geocoder/sql.rb

@@ -63,26 +63,27 @@ module Geocoder
     # 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
-        "CAST(" +
-          "DEGREES(ATAN2( " +
-            "RADIANS(#{lon_attr} - #{longitude.to_f}), " +
-            "RADIANS(#{lat_attr} - #{latitude.to_f})" +
-          ")) + 360 " +
-        "AS decimal) % 360"
+        "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
-        "CAST(" +
-          "DEGREES(ATAN2( " +
-            "SIN(RADIANS(#{lon_attr} - #{longitude.to_f})) * " +
-            "COS(RADIANS(#{lat_attr})), (" +
-              "COS(RADIANS(#{latitude.to_f})) * SIN(RADIANS(#{lat_attr}))" +
+        "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(RADIANS(#{latitude.to_f})) * COS(RADIANS(#{lat_attr})) * " +
-              "COS(RADIANS(#{lon_attr} - #{longitude.to_f}))" +
+              "SIN( (#{latitude.to_f}) / #{degrees_per_radian}) * COS((#{lat_attr}) / #{degrees_per_radian}) * " +
+              "COS( (#{lon_attr} - #{longitude.to_f}) / #{degrees_per_radian})" +
             ")" +
-          ")) + 360 " +
-        "AS decimal) % 360"
+          ") * #{degrees_per_radian}) + 360 " +
+        "AS decimal), 360)"
       end
     end
 

data/lib/geocoder/stores/active_record.rb

@@ -107,6 +107,9 @@ module Geocoder::Store
       # * +:exclude+         - an object to exclude (used by the +nearbys+ method)
       # * +:distance_column+ - used to set the column name of the calculated distance.
       # * +:bearing_column+  - used to set the column name of the calculated bearing.
+      # * +:min_radius+      - the value to use as the minimum radius. 
+      #                        ignored if database is sqlite.
+      #                        default is 0.0
       #
       def near_scope_options(latitude, longitude, radius = 20, options = {})
         if options[:units]
@@ -131,7 +134,8 @@ module Geocoder::Store
         if using_sqlite?
           conditions = bounding_box_conditions
         else
-          conditions = [bounding_box_conditions + " AND #{distance} <= ?", radius]
+          min_radius = options.fetch(:min_radius, 0).to_f
+          conditions = [bounding_box_conditions + " AND (#{distance}) BETWEEN ? AND ?", min_radius, radius]
         end
         {
           :select => select_clause(options[:select],
@@ -215,7 +219,7 @@ module Geocoder::Store
       end
 
       def using_sqlite?
-        connection.adapter_name.match /sqlite/i
+        connection.adapter_name.match(/sqlite/i)
       end
 
       ##

data/lib/geocoder/stores/base.rb

@@ -101,7 +101,14 @@ module Geocoder
           return
         end
 
-        results = Geocoder.search(query)
+        query_options = [:lookup, :ip_lookup].inject({}) do |hash, key|
+          if options.has_key?(key)
+            val = options[key]
+            hash[key] = val.respond_to?(:call) ? val.call(self) : val
+          end
+          hash
+        end
+        results = Geocoder.search(query, query_options)
 
         # execute custom block, if specified in configuration
         block_key = reverse ? :reverse_block : :geocode_block

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.1.9"
+  VERSION = "1.2.0"
 end

data/lib/maxmind_database.rb

@@ -0,0 +1,109 @@
+require 'csv'
+require 'net/http'
+
+module Geocoder
+  module MaxmindDatabase
+    extend self
+
+    def download(package, dir = "tmp")
+      filepath = File.expand_path(File.join(dir, archive_filename(package)))
+      open(filepath, 'wb') do |file|
+        uri = URI.parse(archive_url(package))
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request_get(uri.path) do |resp|
+            # TODO: show progress
+            resp.read_body do |segment|
+              file.write(segment)
+            end
+          end
+        end
+      end
+    end
+
+    def insert(package, dir = "tmp")
+      data_files(package).each do |filepath,table|
+        print "Resetting table #{table}..."
+        ActiveRecord::Base.connection.execute("DELETE FROM #{table}")
+        puts "done"
+        insert_into_table(table, filepath)
+      end
+    end
+
+    def archive_filename(package)
+      p = archive_url_path(package)
+      s = !(pos = p.rindex('/')).nil? && pos + 1 || 0
+      p[s..-1]
+    end
+
+    private # -------------------------------------------------------------
+
+    def table_columns(table_name)
+      {
+        maxmind_geolite_city_blocks: %w[start_ip_num end_ip_num loc_id],
+        maxmind_geolite_city_location: %w[loc_id country region city postal_code latitude longitude metro_code area_code],
+        maxmind_geolite_country: %w[start_ip end_ip start_ip_num end_ip_num country_code country]
+      }[table_name.to_sym]
+    end
+
+    def insert_into_table(table, filepath)
+      start_time = Time.now
+      print "Loading data for table #{table}"
+      rows = []
+      columns = table_columns(table)
+      CSV.foreach(filepath, encoding: "ISO-8859-1") do |line|
+        # Some files have header rows.
+        # skip if starts with "Copyright" or "locId" or "startIpNum"
+        next if line.first.match(/[A-z]/)
+        rows << line.to_a
+        if rows.size == 10000
+          insert_rows(table, columns, rows)
+          rows = []
+          print "."
+        end
+      end
+      insert_rows(table, columns, rows) if rows.size > 0
+      puts "done (#{Time.now - start_time} seconds)"
+    end
+
+    def insert_rows(table, headers, rows)
+      value_strings = rows.map do |row|
+        "(" + row.map{ |col| sql_escaped_value(col) }.join(',') + ")"
+      end
+      q = "INSERT INTO #{table} (#{headers.join(',')}) " +
+        "VALUES #{value_strings.join(',')}"
+      ActiveRecord::Base.connection.execute(q)
+    end
+
+    def sql_escaped_value(value)
+      value.to_i.to_s == value ? value :
+        ActiveRecord::Base.connection.quote(value)
+    end
+
+    def data_files(package, dir = "tmp")
+      case package
+      when :geolite_city_csv
+        # use the last two in case multiple versions exist
+        files = Dir.glob(File.join(dir, "GeoLiteCity_*/*.csv"))[-2..-1]
+        Hash[*files.zip(["maxmind_geolite_city_blocks", "maxmind_geolite_city_location"]).flatten]
+      when :geolite_country_csv
+        {File.join(dir, "GeoIPCountryWhois.csv") => "maxmind_geolite_country"}
+      end
+    end
+
+    def archive_url(package)
+      base_url + archive_url_path(package)
+    end
+
+    def archive_url_path(package)
+      {
+        geolite_country_csv: "GeoIPCountryCSV.zip",
+        geolite_city_csv: "GeoLiteCity_CSV/GeoLiteCity-latest.zip",
+        geolite_asn_csv: "asnum/GeoIPASNum2.zip"
+      }[package]
+    end
+
+    def base_url
+      "http://geolite.maxmind.com/download/geoip/database/"
+    end
+  end
+end