ultra-fast-mod 0.0.1

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

@@ -0,0 +1,329 @@
+# -*- coding: utf-8 -*-
+require 'geocoder/sql'
+require 'geocoder/stores/base'
+
+##
+# Add geocoding functionality to any ActiveRecord object.
+#
+module Geocoder::Store
+  module ActiveRecord
+    include Base
+
+    ##
+    # Implementation of 'included' hook method.
+    #
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+
+        # scope: geocoded objects
+        scope :geocoded, lambda {
+          where("#{table_name}.#{geocoder_options[:latitude]} IS NOT NULL " +
+            "AND #{table_name}.#{geocoder_options[:longitude]} IS NOT NULL")
+        }
+
+        # scope: not-geocoded objects
+        scope :not_geocoded, lambda {
+          where("#{table_name}.#{geocoder_options[:latitude]} IS NULL " +
+            "OR #{table_name}.#{geocoder_options[:longitude]} IS NULL")
+        }
+
+        # scope: not-reverse geocoded objects
+        scope :not_reverse_geocoded, lambda {
+          where("#{table_name}.#{geocoder_options[:fetched_address]} IS NULL")
+        }
+
+        ##
+        # Find all objects within a radius of the given location.
+        # Location may be either a string to geocode or an array of
+        # coordinates (<tt>[lat,lon]</tt>). Also takes an options hash
+        # (see Geocoder::Store::ActiveRecord::ClassMethods.near_scope_options
+        # for details).
+        #
+        scope :near, lambda{ |location, *args|
+          latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
+          if Geocoder::Calculations.coordinates_present?(latitude, longitude)
+            options = near_scope_options(latitude, longitude, *args)
+            select(options[:select]).where(options[:conditions]).
+              order(options[:order])
+          else
+            # If no lat/lon given we don't want any results, but we still
+            # need distance and bearing columns so you can add, for example:
+            # .order("distance")
+            select(select_clause(nil, null_value, null_value)).where(false_condition)
+          end
+        }
+
+        ##
+        # Find all objects within the area of a given bounding box.
+        # Bounds must be an array of locations specifying the southwest
+        # corner followed by the northeast corner of the box
+        # (<tt>[[sw_lat, sw_lon], [ne_lat, ne_lon]]</tt>).
+        #
+        scope :within_bounding_box, lambda{ |*bounds|
+          sw_lat, sw_lng, ne_lat, ne_lng = bounds.flatten if bounds
+          if sw_lat && sw_lng && ne_lat && ne_lng
+            where(Geocoder::Sql.within_bounding_box(
+              sw_lat, sw_lng, ne_lat, ne_lng,
+              full_column_name(geocoder_options[:latitude]),
+              full_column_name(geocoder_options[:longitude])
+            ))
+          else
+            select(select_clause(nil, null_value, null_value)).where(false_condition)
+          end
+        }
+      end
+    end
+
+    ##
+    # Methods which will be class methods of the including class.
+    #
+    module ClassMethods
+
+      def distance_from_sql(location, *args)
+        latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
+        if Geocoder::Calculations.coordinates_present?(latitude, longitude)
+          distance_sql(latitude, longitude, *args)
+        end
+      end
+
+      ##
+      # Get options hash suitable for passing to ActiveRecord.find to get
+      # records within a radius (in kilometers) of the given point.
+      # Options hash may include:
+      #
+      # * +:units+   - <tt>:mi</tt> or <tt>:km</tt>; to be used.
+      #   for interpreting radius as well as the +distance+ attribute which
+      #   is added to each found nearby object.
+      #   Use Geocoder.configure[:units] to configure default units.
+      # * +:bearing+ - <tt>:linear</tt> or <tt>:spherical</tt>.
+      #   the method to be used for calculating the bearing (direction)
+      #   between the given point and each found nearby point;
+      #   set to false for no bearing calculation. Use
+      #   Geocoder.configure[:distances] to configure default calculation method.
+      # * +:select+          - string with the SELECT SQL fragment (e.g. “id, name”)
+      # * +:select_distance+ - whether to include the distance alias in the
+      #                        SELECT SQL fragment (e.g. <formula> AS distance)
+      # * +:select_bearing+  - like +:select_distance+ but for bearing.
+      # * +:order+           - column(s) for ORDER BY SQL clause; default is distance;
+      #                        set to false or nil to omit the ORDER BY clause
+      # * +: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]
+          options[:units] = options[:units].to_sym
+        end
+        latitude_attribute = options[:latitude] || geocoder_options[:latitude]
+        longitude_attribute = options[:longitude] || geocoder_options[:longitude]
+        options[:units] ||= (geocoder_options[:units] || Geocoder.config.units)
+        select_distance = options.fetch(:select_distance)  { true }
+        options[:order] = "" if !select_distance && !options.include?(:order)
+        select_bearing = options.fetch(:select_bearing) { true }
+        bearing = bearing_sql(latitude, longitude, options)
+        distance = distance_sql(latitude, longitude, options)
+        distance_column = options.fetch(:distance_column) { 'distance' }
+        bearing_column = options.fetch(:bearing_column)  { 'bearing' }
+
+        # If radius is a DB column name, bounding box should include
+        # all rows within the maximum radius appearing in that column.
+        # Note: performance is dependent on variability of radii.
+        radius_is_column = radius.is_a?(Symbol) || (defined?(Arel::Nodes::SqlLiteral) && radius.is_a?(Arel::Nodes::SqlLiteral))
+        bb_radius = radius_is_column ? maximum(radius) : radius
+        b = Geocoder::Calculations.bounding_box([latitude, longitude], bb_radius, options)
+        args = b + [
+          full_column_name(latitude_attribute),
+          full_column_name(longitude_attribute)
+        ]
+        bounding_box_conditions = Geocoder::Sql.within_bounding_box(*args)
+
+        if using_unextended_sqlite?
+          conditions = bounding_box_conditions
+        else
+          min_radius = options.fetch(:min_radius, 0).to_f
+          # if radius is a DB column name,
+          # find rows between min_radius and value in column
+          if radius_is_column
+            c = "BETWEEN ? AND #{radius}"
+            a = [min_radius]
+          else
+            c = "BETWEEN ? AND ?"
+            a = [min_radius, radius]
+          end
+          conditions = [bounding_box_conditions + " AND (#{distance}) " + c] + a
+        end
+        {
+          :select => select_clause(options[:select],
+                                   select_distance ? distance : nil,
+                                   select_bearing ? bearing : nil,
+                                   distance_column,
+                                   bearing_column),
+          :conditions => add_exclude_condition(conditions, options[:exclude]),
+          :order => options.include?(:order) ? options[:order] : "#{distance_column} ASC"
+        }
+      end
+
+      ##
+      # SQL for calculating distance based on the current database's
+      # capabilities (trig functions?).
+      #
+      def distance_sql(latitude, longitude, options = {})
+        method_prefix = using_unextended_sqlite? ? "approx" : "full"
+        Geocoder::Sql.send(
+          method_prefix + "_distance",
+          latitude, longitude,
+          full_column_name(options[:latitude] || geocoder_options[:latitude]),
+          full_column_name(options[:longitude]|| geocoder_options[:longitude]),
+          options
+        )
+      end
+
+      ##
+      # SQL for calculating bearing based on the current database's
+      # capabilities (trig functions?).
+      #
+      def bearing_sql(latitude, longitude, options = {})
+        if !options.include?(:bearing)
+          options[:bearing] = Geocoder.config.distances
+        end
+        if options[:bearing]
+          method_prefix = using_unextended_sqlite? ? "approx" : "full"
+          Geocoder::Sql.send(
+            method_prefix + "_bearing",
+            latitude, longitude,
+            full_column_name(options[:latitude] || geocoder_options[:latitude]),
+            full_column_name(options[:longitude]|| geocoder_options[:longitude]),
+            options
+          )
+        end
+      end
+
+      ##
+      # Generate the SELECT clause.
+      #
+      def select_clause(columns, distance = nil, bearing = nil, distance_column = 'distance', bearing_column = 'bearing')
+        if columns == :id_only
+          return full_column_name(primary_key)
+        elsif columns == :geo_only
+          clause = ""
+        else
+          clause = (columns || full_column_name("*"))
+        end
+        if distance
+          clause += ", " unless clause.empty?
+          clause += "#{distance} AS #{distance_column}"
+        end
+        if bearing
+          clause += ", " unless clause.empty?
+          clause += "#{bearing} AS #{bearing_column}"
+        end
+        clause
+      end
+
+      ##
+      # Adds a condition to exclude a given object by ID.
+      # Expects conditions as an array or string. Returns array.
+      #
+      def add_exclude_condition(conditions, exclude)
+        conditions = [conditions] if conditions.is_a?(String)
+        if exclude
+          conditions[0] << " AND #{full_column_name(primary_key)} != ?"
+          conditions << exclude.id
+        end
+        conditions
+      end
+
+      def using_unextended_sqlite?
+        using_sqlite? && !using_sqlite_with_extensions?
+      end
+
+      def using_sqlite?
+        !!connection.adapter_name.match(/sqlite/i)
+      end
+
+      def using_sqlite_with_extensions?
+        connection.adapter_name.match(/sqlite/i) &&
+          defined?(::SqliteExt) &&
+          %W(MOD POWER SQRT PI SIN COS ASIN ATAN2).all?{ |fn_name|
+            connection.raw_connection.function_created?(fn_name)
+          }
+      end
+
+      def using_postgres?
+        connection.adapter_name.match(/postgres/i)
+      end
+
+      ##
+      # Use OID type when running in PosgreSQL
+      #
+      def null_value
+        using_postgres? ? 'NULL::text' : 'NULL'
+      end
+
+      ##
+      # Value which can be passed to where() to produce no results.
+      #
+      def false_condition
+        using_unextended_sqlite? ? 0 : "false"
+      end
+
+      ##
+      # Prepend table name if column name doesn't already contain one.
+      #
+      def full_column_name(column)
+        column = column.to_s
+        column.include?(".") ? column : [table_name, column].join(".")
+      end
+    end
+
+    ##
+    # Get nearby geocoded objects.
+    # Takes the same options hash as the near class method (scope).
+    # Returns nil if the object is not geocoded.
+    #
+    def nearbys(radius = 20, options = {})
+      return nil unless geocoded?
+      options.merge!(:exclude => self) unless send(self.class.primary_key).nil?
+      self.class.near(self, radius, options)
+    end
+
+    ##
+    # Look up coordinates and assign to +latitude+ and +longitude+ attributes
+    # (or other as specified in +geocoded_by+). Returns coordinates (array).
+    #
+    def geocode
+      do_lookup(false) do |o,rs|
+        if r = rs.first
+          unless r.latitude.nil? or r.longitude.nil?
+            o.__send__  "#{self.class.geocoder_options[:latitude]}=",  r.latitude
+            o.__send__  "#{self.class.geocoder_options[:longitude]}=", r.longitude
+          end
+          r.coordinates
+        end
+      end
+    end
+
+    alias_method :fetch_coordinates, :geocode
+
+    ##
+    # Look up address and assign to +address+ attribute (or other as specified
+    # in +reverse_geocoded_by+). Returns address (string).
+    #
+    def reverse_geocode
+      do_lookup(true) do |o,rs|
+        if r = rs.first
+          unless r.address.nil?
+            o.__send__ "#{self.class.geocoder_options[:fetched_address]}=", r.address
+          end
+          r.address
+        end
+      end
+    end
+
+    alias_method :fetch_address, :reverse_geocode
+  end
+end

data/geocoder-1.8.6/lib/geocoder/stores/base.rb

@@ -0,0 +1,115 @@
+module Geocoder
+  module Store
+    module Base
+
+      ##
+      # Is this object geocoded? (Does it have latitude and longitude?)
+      #
+      def geocoded?
+        to_coordinates.compact.size == 2
+      end
+
+      ##
+      # Coordinates [lat,lon] of the object.
+      #
+      def to_coordinates
+        [:latitude, :longitude].map{ |i| send self.class.geocoder_options[i] }
+      end
+
+      ##
+      # Calculate the distance from the object to an arbitrary point.
+      # See Geocoder::Calculations.distance_between for ways of specifying
+      # the point. Also takes a symbol specifying the units
+      # (:mi or :km; can be specified in Geocoder configuration).
+      #
+      def distance_to(point, units = nil)
+        units ||= self.class.geocoder_options[:units]
+        return nil unless geocoded?
+        Geocoder::Calculations.distance_between(
+          to_coordinates, point, :units => units)
+      end
+
+      alias_method :distance_from, :distance_to
+
+      ##
+      # Calculate the bearing from the object to another point.
+      # See Geocoder::Calculations.distance_between for
+      # ways of specifying the point.
+      #
+      def bearing_to(point, options = {})
+        options[:method] ||= self.class.geocoder_options[:method]
+        return nil unless geocoded?
+        Geocoder::Calculations.bearing_between(
+          to_coordinates, point, options)
+      end
+
+      ##
+      # Calculate the bearing from another point to the object.
+      # See Geocoder::Calculations.distance_between for
+      # ways of specifying the point.
+      #
+      def bearing_from(point, options = {})
+        options[:method] ||= self.class.geocoder_options[:method]
+        return nil unless geocoded?
+        Geocoder::Calculations.bearing_between(
+          point, to_coordinates, options)
+      end
+
+      ##
+      # Look up coordinates and assign to +latitude+ and +longitude+ attributes
+      # (or other as specified in +geocoded_by+). Returns coordinates (array).
+      #
+      def geocode
+        fail
+      end
+
+      ##
+      # Look up address and assign to +address+ attribute (or other as specified
+      # in +reverse_geocoded_by+). Returns address (string).
+      #
+      def reverse_geocode
+        fail
+      end
+
+      private # --------------------------------------------------------------
+
+      ##
+      # Look up geographic data based on object attributes (configured in
+      # geocoded_by or reverse_geocoded_by) and handle the results with the
+      # block (given to geocoded_by or reverse_geocoded_by). The block is
+      # given two-arguments: the object being geocoded and an array of
+      # Geocoder::Result objects).
+      #
+      def do_lookup(reverse = false)
+        options = self.class.geocoder_options
+        if reverse and options[:reverse_geocode]
+          query = to_coordinates
+        elsif !reverse and options[:geocode]
+          query = send(options[:user_address])
+        else
+          return
+        end
+
+        query_options = [:lookup, :ip_lookup, :language, :params].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
+        if custom_block = options[block_key]
+          custom_block.call(self, results)
+
+        # else execute block passed directly to this method,
+        # which generally performs the "auto-assigns"
+        elsif block_given?
+          yield(self, results)
+        end
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/stores/mongo_base.rb

@@ -0,0 +1,58 @@
+module Geocoder::Store
+  module MongoBase
+
+    def self.included_by_model(base)
+      base.class_eval do
+
+        scope :geocoded, lambda {
+          where(geocoder_options[:coordinates].ne => nil)
+        }
+
+        scope :not_geocoded, lambda {
+          where(geocoder_options[:coordinates] => nil)
+        }
+      end
+    end
+
+    ##
+    # Coordinates [lat,lon] of the object.
+    # This method always returns coordinates in lat,lon order,
+    # even though internally they are stored in the opposite order.
+    #
+    def to_coordinates
+      coords = send(self.class.geocoder_options[:coordinates])
+      coords.is_a?(Array) ? coords.reverse : []
+    end
+
+    ##
+    # Look up coordinates and assign to +latitude+ and +longitude+ attributes
+    # (or other as specified in +geocoded_by+). Returns coordinates (array).
+    #
+    def geocode
+      do_lookup(false) do |o,rs|
+        if r = rs.first
+          unless r.coordinates.nil?
+            o.__send__ "#{self.class.geocoder_options[:coordinates]}=", r.coordinates.reverse
+          end
+          r.coordinates
+        end
+      end
+    end
+
+    ##
+    # Look up address and assign to +address+ attribute (or other as specified
+    # in +reverse_geocoded_by+). Returns address (string).
+    #
+    def reverse_geocode
+      do_lookup(true) do |o,rs|
+        if r = rs.first
+          unless r.address.nil?
+            o.__send__ "#{self.class.geocoder_options[:fetched_address]}=", r.address
+          end
+          r.address
+        end
+      end
+    end
+  end
+end
+

data/geocoder-1.8.6/lib/geocoder/stores/mongo_mapper.rb

@@ -0,0 +1,13 @@
+require 'geocoder/stores/base'
+require 'geocoder/stores/mongo_base'
+
+module Geocoder::Store
+  module MongoMapper
+    include Base
+    include MongoBase
+
+    def self.included(base)
+      MongoBase.included_by_model(base)
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'geocoder/stores/base'
+require 'geocoder/stores/mongo_base'
+
+module Geocoder::Store
+  module Mongoid
+    include Base
+    include MongoBase
+
+    def self.included(base)
+      MongoBase.included_by_model(base)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Geocoder
+  module Util
+    #
+    # Recursive version of Hash#merge!
+    #
+    # Adds the contents of +h2+ to +h1+,
+    # merging entries in +h1+ with duplicate keys with those from +h2+.
+    #
+    # Compared with Hash#merge!, this method supports nested hashes.
+    # When both +h1+ and +h2+ contains an entry with the same key,
+    # it merges and returns the values from both hashes.
+    #
+    #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+    #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+    #    recursive_hash_merge(h1, h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+    #
+    # Simply using Hash#merge! would return
+    #
+    #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+    #
+    def self.recursive_hash_merge(h1, h2)
+      h1.merge!(h2) do |_key, oldval, newval|
+        oldval.class == h1.class ? self.recursive_hash_merge(oldval, newval) : newval
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module Geocoder
+  VERSION = "1.8.6"
+end

data/geocoder-1.8.6/lib/geocoder.rb

@@ -0,0 +1,48 @@
+require "geocoder/configuration"
+require "geocoder/logger"
+require "geocoder/kernel_logger"
+require "geocoder/query"
+require "geocoder/calculations"
+require "geocoder/exceptions"
+require "geocoder/cache"
+require "geocoder/request"
+require "geocoder/lookup"
+require "geocoder/ip_address"
+require "geocoder/models/active_record" if defined?(::ActiveRecord)
+require "geocoder/models/mongoid" if defined?(::Mongoid)
+require "geocoder/models/mongo_mapper" if defined?(::MongoMapper)
+
+module Geocoder
+
+  ##
+  # Search for information about an address or a set of coordinates.
+  #
+  def self.search(query, options = {})
+    query = Geocoder::Query.new(query, options) unless query.is_a?(Geocoder::Query)
+    query.blank? ? [] : query.execute
+  end
+
+  ##
+  # Look up the coordinates of the given street or IP address.
+  #
+  def self.coordinates(address, options = {})
+    if (results = search(address, options)).size > 0
+      results.first.coordinates
+    end
+  end
+
+  ##
+  # Look up the address of the given coordinates ([lat,lon])
+  # or IP address (string).
+  #
+  def self.address(query, options = {})
+    if (results = search(query, options)).size > 0
+      results.first.address
+    end
+  end
+end
+
+# load Railtie if Rails exists
+if defined?(Rails)
+  require "geocoder/railtie"
+end