mini-safe-gem 0.0.1

data/geocoder-1.8.6/lib/geocoder/lookups/tencent.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/tencent"
+
+module Geocoder::Lookup
+  class Tencent < Base
+
+    def name
+      "Tencent"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://apis.map.qq.com/ws/geocoder/v1/?"
+    end
+
+    def content_key
+      'result'
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc[content_key]]
+      when 311
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      when 310
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request, invalid parameters.")
+      when 306
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request, check response for more info.")
+      when 110
+        raise_error(Geocoder::RequestDenied, "request denied.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request source is not authorized.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :key => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/test.rb

@@ -0,0 +1,49 @@
+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)
+        @default_stub ||= nil
+        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.delete_stub(query_text)
+        stubs.delete(query_text)
+      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/geocoder-1.8.6/lib/geocoder/lookups/twogis.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/twogis"
+
+module Geocoder::Lookup
+  class Twogis < Base
+
+    def name
+      "2gis"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def map_link_url(coordinates)
+      "https://2gis.ru/?m=#{coordinates.join(',')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://catalog.api.2gis.com/3.0/items/geocode?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc['meta'] && doc['meta']['error']
+        Geocoder.log(:warn, "2gis Geocoding API error: #{doc['meta']["code"]} (#{doc['meta']['error']["message"]}).")
+        return []
+      end
+      if doc['result'] && doc = doc['result']['items']
+        return doc.to_a
+      else
+        Geocoder.log(:warn, "2gis 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
+      params = {
+        :q => q,
+        :lang => "#{query.language || configuration.language}",
+        :key => configuration.api_key,
+        :fields => 'items.street,items.adm_div,items.full_address_name,items.point,items.geometry.centroid'
+      }
+      params.merge(super)
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/uk_ordnance_survey_names'
+
+module Geocoder::Lookup
+  class UkOrdnanceSurveyNames < Base
+
+    def name
+      'Ordance Survey Names'
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def base_query_url(query)
+      "#{protocol}://api.os.uk/search/names/v1/find?"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      base_query_url(query) + url_query_string(query)
+    end
+
+    private # -------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] if doc['header']['totalresults'].zero?
+      return doc['results'].map { |r| r['GAZETTEER_ENTRY'] }
+    end
+
+    def query_url_params(query)
+      {
+        query: query.sanitized_text,
+        key: configuration.api_key,
+        fq: filter
+      }.merge(super)
+    end
+
+    def local_types
+      %w[
+        City
+        Hamlet
+        Other_Settlement
+        Town
+        Village
+        Postcode
+      ]
+    end
+
+    def filter
+      local_types.map { |t| "local_type:#{t}" }.join(' ')
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/yandex.rb

@@ -0,0 +1,61 @@
+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 supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://geocode-maps.yandex.ru/1.x/?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if [400, 403].include? doc['statusCode']
+        if doc['statusCode'] == 403 and doc['message'] == 'Invalid key'
+          raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid API key.")
+        else
+          Geocoder.log(:warn, "Yandex Geocoding API error: #{doc['statusCode']} (#{doc['message']}).")
+        end
+        return []
+      end
+      if doc = doc['response']['GeoObjectCollection']
+        return doc['featureMember'].to_a
+      else
+        Geocoder.log(: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
+      params = {
+        :geocode => q,
+        :format => "json",
+        :lang => "#{query.language || configuration.language}", # supports ru, uk, be, default -> ru
+        :apikey => configuration.api_key
+      }
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bbox] = bounds.map{ |point| "%f,%f" % point }.join('~')
+      end
+      params.merge(super)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/models/active_record.rb

@@ -0,0 +1,51 @@
+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],
+          :params        => options[:params]
+        )
+      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],
+          :params          => options[:params]
+        )
+      end
+
+
+      private # --------------------------------------------------------------
+
+      def geocoder_file_name;   "active_record"; end
+      def geocoder_module_name; "ActiveRecord"; end
+    end
+  end
+end

data/geocoder-1.8.6/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/geocoder-1.8.6/lib/geocoder/models/mongo_base.rb

@@ -0,0 +1,62 @@
+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/geocoder-1.8.6/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

data/geocoder-1.8.6/lib/geocoder/models/mongoid.rb

@@ -0,0 +1,32 @@
+require 'geocoder/models/base'
+require 'geocoder/models/mongo_base'
+
+module Geocoder
+  module Model
+    module Mongoid
+      include Base
+      include MongoBase
+
+      def self.included(base); base.extend(self); end
+
+      private # --------------------------------------------------------------
+
+      def geocoder_file_name;   "mongoid"; end
+      def geocoder_module_name; "Mongoid"; end
+
+      def geocoder_init(options)
+        super(options)
+        if options[:skip_index] == false
+          # create 2d index
+          if defined?(::Mongoid::VERSION) && ::Mongoid::VERSION >= "3"
+            index({ geocoder_options[:coordinates].to_sym => '2d' }, 
+                  {:min => -180, :max => 180})
+          else
+            index [[ geocoder_options[:coordinates], '2d' ]],
+              :min => -180, :max => 180
+          end
+        end
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/query.rb

@@ -0,0 +1,125 @@
+module Geocoder
+  class Query
+    attr_accessor :text, :options
+
+    def initialize(text, options = {})
+      self.text = text
+      self.options = options
+    end
+
+    def execute
+      lookup.search(text, options)
+    end
+
+    def to_s
+      text
+    end
+
+    def sanitized_text
+      if coordinates?
+        if text.is_a?(Array)
+          text.join(',')
+        else
+          text.split(/\s*,\s*/).join(',')
+        end
+      else
+        text.to_s.strip
+      end
+    end
+
+    ##
+    # Get a Lookup object (which communicates with the remote geocoding API)
+    # appropriate to the Query text.
+    #
+    def lookup
+      if !options[:street_address] and (options[:ip_address] or ip_address?)
+        name = options[:ip_lookup] || Configuration.ip_lookup || Geocoder::Lookup.ip_services.first
+      else
+        name = options[:lookup] || Configuration.lookup || Geocoder::Lookup.street_services.first
+      end
+      Lookup.get(name)
+    end
+
+    def url
+      lookup.query_url(self)
+    end
+
+    ##
+    # Is the Query blank? (ie, should we not bother searching?)
+    # A query is considered blank if its text is nil or empty string AND
+    # no URL parameters are specified.
+    #
+    def blank?
+      !params_given? and (
+        (text.is_a?(Array) and text.compact.size < 2) or
+        text.to_s.match(/\A\s*\z/)
+      )
+    end
+
+    ##
+    # Does the Query text look like an IP address?
+    #
+    # Does not check for actual validity, just the appearance of four
+    # dot-delimited numbers.
+    #
+    def ip_address?
+      IpAddress.new(text).valid? rescue false
+    end
+
+    ##
+    # Is the Query text a loopback or private IP address?
+    #
+    def internal_ip_address?
+      ip_address? && IpAddress.new(text).internal?
+    end
+
+    ##
+    # Is the Query text a loopback IP address?
+    #
+    def loopback_ip_address?
+      ip_address? && IpAddress.new(text).loopback?
+    end
+
+    ##
+    # Is the Query text a private IP address?
+    #
+    def private_ip_address?
+      ip_address? && IpAddress.new(text).private?
+    end
+
+    ##
+    # Does the given string look like latitude/longitude coordinates?
+    #
+    def coordinates?
+      text.is_a?(Array) or (
+        text.is_a?(String) and
+        !!text.to_s.match(/\A-?[0-9\.]+, *-?[0-9\.]+\z/)
+      )
+    end
+
+    ##
+    # Return the latitude/longitude coordinates specified in the query,
+    # or nil if none.
+    #
+    def coordinates
+      sanitized_text.split(',') if coordinates?
+    end
+
+    ##
+    # Should reverse geocoding be performed for this query?
+    #
+    def reverse_geocode?
+      coordinates?
+    end
+
+    def language
+      options[:language]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def params_given?
+      !!(options[:params].is_a?(Hash) and options[:params].keys.size > 0)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/railtie.rb

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