ultra-fast-mod 0.0.1

data/geocoder-1.8.6/lib/geocoder/results/photon.rb

@@ -0,0 +1,119 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Photon < Base
+    def name
+      properties['name']
+    end
+
+    def address(_format = :full)
+      parts = []
+      parts << name if name
+      parts << street_address if street_address
+      parts << city
+      parts << state if state
+      parts << postal_code
+      parts << country
+
+      parts.join(', ')
+    end
+
+    def street_address
+      return unless street
+      return street unless house_number
+
+      "#{house_number} #{street}"
+    end
+
+    def house_number
+      properties['housenumber']
+    end
+
+    def street
+      properties['street']
+    end
+
+    def postal_code
+      properties['postcode']
+    end
+
+    def city
+      properties['city']
+    end
+
+    def state
+      properties['state']
+    end
+
+    def state_code
+      ''
+    end
+
+    def country
+      properties['country']
+    end
+
+    def country_code
+      ''
+    end
+
+    def coordinates
+      return unless geometry
+      return unless geometry[:coordinates]
+
+      geometry[:coordinates].reverse
+    end
+
+    def geometry
+      return unless data['geometry']
+
+      symbol_hash data['geometry']
+    end
+
+    def bounds
+      properties['extent']
+    end
+
+    # Type of the result (OSM object type), one of:
+    #
+    #   :node
+    #   :way
+    #   :relation
+    #
+    def type
+      {
+        'N' => :node,
+        'W' => :way,
+        'R' => :relation
+      }[properties['osm_type']]
+    end
+
+    def osm_id
+      properties['osm_id']
+    end
+
+    # See: https://wiki.openstreetmap.org/wiki/Tags
+    def osm_tag
+      return unless properties['osm_key']
+      return properties['osm_key'] unless properties['osm_value']
+
+      "#{properties['osm_key']}=#{properties['osm_value']}"
+    end
+
+    private
+
+    def properties
+      @properties ||= data['properties'] || {}
+    end
+
+    def symbol_hash(orig_hash)
+      {}.tap do |result|
+        orig_hash.each_key do |key|
+          next unless orig_hash[key]
+
+          result[key.to_sym] = orig_hash[key]
+        end
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/pickpoint.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/nominatim'
+
+module Geocoder::Result
+  class Pickpoint < Nominatim
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/pointpin.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Pointpin < Base
+
+    def address
+      [ city_name, state, postal_code, country ].select{ |i| i.to_s != "" }.join(", ")
+    end
+
+    def city
+      @data['city_name']
+    end
+
+    def state
+      @data['region_name']
+    end
+
+    def state_code
+      @data['region_code']
+    end
+
+    def country
+      @data['country_name']
+    end
+
+    def postal_code
+      @data['postcode']
+    end
+
+    def self.response_attributes
+      %w[continent_code ip country_code country_name region_name city_name postcode latitude longitude time_zone languages]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/postcode_anywhere_uk.rb

@@ -0,0 +1,42 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class PostcodeAnywhereUk < Base
+
+    def coordinates
+      [@data['Latitude'].to_f, @data['Longitude'].to_f]
+    end
+
+    def blank_result
+      ''
+    end
+    alias_method :state, :blank_result
+    alias_method :state_code, :blank_result
+    alias_method :postal_code, :blank_result
+
+    def address
+      @data['Location']
+    end
+
+    def city
+      # is this too big a jump to assume that the API always
+      # returns a City, County as the last elements?
+      city = @data['Location'].split(',')[-2] || blank_result
+      city.strip
+    end
+
+    def os_grid
+      @data['OsGrid']
+    end
+
+    # This is a UK only API; all results are UK specific and
+    # so ommitted from API response.
+    def country
+      'United Kingdom'
+    end
+
+    def country_code
+      'UK'
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/postcodes_io.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class PostcodesIo < Base
+
+    def coordinates
+      [@data['latitude'].to_f, @data['longitude'].to_f]
+    end
+
+    def quality
+      @data['quality']
+    end
+
+    def postal_code
+      @data['postcode']
+    end
+    alias address postal_code
+
+    def city
+      @data['admin_ward']
+    end
+
+    def county
+      @data['admin_county']
+    end
+    alias state county
+
+    def state_code
+      @data['codes']['admin_county']
+    end
+
+    def country
+      'United Kingdom'
+    end
+
+    def country_code
+      'UK'
+    end
+  end
+end

data/geocoder-1.8.6/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/geocoder-1.8.6/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/geocoder-1.8.6/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/geocoder-1.8.6/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/geocoder-1.8.6/lib/geocoder/results/twogis.rb

@@ -0,0 +1,76 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Twogis < Base
+    def coordinates
+      ['lat', 'lon'].map{ |i| @data['point'][i] } if @data['point']
+    end
+
+    def address(_format = :full)
+      @data['full_address_name'] || ''
+    end
+
+    def city
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "city"}.first.try(:[], 'name') || ''
+    end
+
+    def region
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "region"}.first.try(:[], 'name') || ''
+    end
+
+    def country
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "country"}.first.try(:[], 'name') || ''
+    end
+
+    def district
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "district"}.first.try(:[], 'name') || ''
+    end
+
+    def district_area
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "district_area"}.first.try(:[], 'name') || ''
+    end
+
+    def street_address
+      @data['address_name'] || ''
+    end
+
+    def street
+      return '' unless @data['address_name']
+      @data['address_name'].split(', ').first
+    end
+
+    def street_number
+      return '' unless @data['address_name']
+      @data['address_name'].split(', ')[1] || ''
+    end
+
+    def type
+      @data['type'] || ''
+    end
+
+    def purpose_name
+      @data['purpose_name'] || ''
+    end
+
+    def building_name
+      @data['building_name'] || ''
+    end
+
+    def subtype
+      @data['subtype'] || ''
+    end
+
+    def subtype_specification
+      @data['subtype_specification'] || ''
+    end
+
+    def name
+      @data['name'] || ''
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/uk_ordnance_survey_names.rb

@@ -0,0 +1,59 @@
+require 'geocoder/results/base'
+require 'easting_northing'
+
+module Geocoder::Result
+  class UkOrdnanceSurveyNames < Base
+
+    def coordinates
+      @coordinates ||= Geocoder::EastingNorthing.new(
+        easting: data['GEOMETRY_X'],
+        northing: data['GEOMETRY_Y'],
+      ).lat_lng
+    end
+
+    def city
+      is_postcode? ? data['DISTRICT_BOROUGH'] : data['NAME1']
+    end
+
+    def county
+      data['COUNTY_UNITARY']
+    end
+    alias state county
+
+    def county_code
+      code_from_uri data['COUNTY_UNITARY_URI']
+    end
+    alias state_code county_code
+
+    def province
+      data['REGION']
+    end
+
+    def province_code
+      code_from_uri data['REGION_URI']
+    end
+
+    def postal_code
+      is_postcode? ? data['NAME1'] : ''
+    end
+
+    def country
+      'United Kingdom'
+    end
+
+    def country_code
+      'UK'
+    end
+
+    private
+
+    def is_postcode?
+      data['LOCAL_TYPE'] == 'Postcode'
+    end
+
+    def code_from_uri(uri)
+      return '' if uri.nil?
+      uri.split('/').last
+    end
+  end
+end