geocoder-sgonyea 1.1.6.1

data/lib/geocoder/stores/base.rb

@@ -0,0 +1,120 @@
+module Geocoder
+  module Store
+    module Base
+
+      ##
+      # Is this object geocoded? (Does it have latitude and longitude?)
+      #
+      def geocoded?
+        to_coordinates.compact.size > 0
+      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
+
+      ##
+      # 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
+        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
+
+        results = Geocoder.search(query)
+
+        # 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/lib/geocoder/stores/mongo_base.rb

@@ -0,0 +1,85 @@
+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)
+        }
+
+        scope :near, lambda{ |location, *args|
+          coords  = Geocoder::Calculations.extract_coordinates(location)
+
+          # no results if no lat/lon given
+          return where(:id => false) unless coords.is_a?(Array)
+
+          radius  = args.size > 0 ? args.shift : 20
+          options = args.size > 0 ? args.shift : {}
+          options[:units] ||= geocoder_options[:units]
+
+          # Use BSON::OrderedHash if Ruby's hashes are unordered.
+          # Conditions must be in order required by indexes (see mongo gem).
+          empty = RUBY_VERSION.split('.')[1].to_i < 9 ? BSON::OrderedHash.new : {}
+
+          conds = empty.clone
+          field = geocoder_options[:coordinates]
+          conds[field] = empty.clone
+          conds[field]["$nearSphere"]  = coords.reverse
+          conds[field]["$maxDistance"] = \
+            Geocoder::Calculations.distance_to_radians(radius, options[:units])
+
+          if obj = options[:exclude]
+            conds[:_id.ne] = obj.id
+          end
+          where(conds)
+        }
+      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/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/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/lib/geocoder/version.rb

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

data/lib/hash_recursive_merge.rb

@@ -0,0 +1,74 @@
+# 
+# = Hash Recursive Merge
+# 
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+# 
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      http://gist.github.com/gists/6391/
+#
+module HashRecursiveMerge
+
+  #
+  # Recursive version of Hash#merge!
+  # 
+  # Adds the contents of +other_hash+ to +hsh+, 
+  # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge!(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 rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+      oldval.class == self.class ? oldval.rmerge!(newval) : newval
+    end
+  end
+
+  #
+  # Recursive version of Hash#merge
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  # Compared with Hash#merge, this method provides a different approch
+  # for merging nasted hashes.
+  # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+  # includes the same key, the value is merged instead replaced with
+  # +other_hash+ value.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge(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 rmerge(other_hash)
+    r = {}
+    merge(other_hash) do |key, oldval, newval|
+      r[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
+  end
+
+end
+
+
+class Hash
+  include HashRecursiveMerge
+end

data/lib/oauth_util.rb

@@ -0,0 +1,112 @@
+# A utility for signing an url using OAuth in a way that's convenient for debugging
+# Note: the standard Ruby OAuth lib is here http://github.com/mojodna/oauth
+# Source: http://gist.github.com/383159
+# License: http://gist.github.com/375593
+# Usage: see example.rb below
+#
+# NOTE: This file has been modified from the original Gist:
+#
+# 1. Fix to prevent param-array conversion, as mentioned in Gist comment.
+# 2. Query string escaping has been changed. See:
+#   https://github.com/alexreisner/geocoder/pull/360
+#
+
+require 'uri'
+require 'cgi'
+require 'openssl'
+require 'base64'
+
+class OauthUtil
+
+  attr_accessor :consumer_key, :consumer_secret, :token, :token_secret, :req_method, 
+                :sig_method, :oauth_version, :callback_url, :params, :req_url, :base_str
+
+  def initialize
+    @consumer_key = ''
+    @consumer_secret = ''
+    @token = ''
+    @token_secret = ''
+    @req_method = 'GET'
+    @sig_method = 'HMAC-SHA1'
+    @oauth_version = '1.0'
+    @callback_url = ''
+  end
+
+  # openssl::random_bytes returns non-word chars, which need to be removed. using alt method to get length
+  # ref http://snippets.dzone.com/posts/show/491
+  def nonce
+    Array.new( 5 ) { rand(256) }.pack('C*').unpack('H*').first
+  end
+
+  def percent_encode( string )
+
+    # ref http://snippets.dzone.com/posts/show/1260
+    return URI.escape( string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]") ).gsub('*', '%2A')
+  end
+
+  # @ref http://oauth.net/core/1.0/#rfc.section.9.2
+  def signature
+    key = percent_encode( @consumer_secret ) + '&' + percent_encode( @token_secret )
+
+    # ref: http://blog.nathanielbibler.com/post/63031273/openssl-hmac-vs-ruby-hmac-benchmarks
+    digest = OpenSSL::Digest::Digest.new( 'sha1' )
+    hmac = OpenSSL::HMAC.digest( digest, key, @base_str )
+
+    # ref http://groups.google.com/group/oauth-ruby/browse_thread/thread/9110ed8c8f3cae81
+    Base64.encode64( hmac ).chomp.gsub( /\n/, '' )
+  end
+
+  # sort (very important as it affects the signature), concat, and percent encode
+  # @ref http://oauth.net/core/1.0/#rfc.section.9.1.1
+  # @ref http://oauth.net/core/1.0/#9.2.1
+  # @ref http://oauth.net/core/1.0/#rfc.section.A.5.1
+  def query_string
+    pairs = []
+    @params.sort.each { | key, val | 
+      pairs.push( "#{ CGI.escape(key.to_s).gsub(/%(5B|5D)/n) { [$1].pack('H*') } }=#{ CGI.escape(val.to_s) }" )
+    }
+    pairs.join '&'
+  end
+
+  # organize params & create signature
+  def sign( parsed_url )
+
+    @params = {
+      'oauth_consumer_key' => @consumer_key,
+      'oauth_nonce' => nonce,
+      'oauth_signature_method' => @sig_method,
+      'oauth_timestamp' => Time.now.to_i.to_s,
+      'oauth_version' => @oauth_version
+    }
+
+    # if url has query, merge key/values into params obj overwriting defaults
+    if parsed_url.query
+      CGI.parse( parsed_url.query ).each do |k,v|
+        if v.is_a?(Array) && v.count == 1
+          @params[k] = v.first
+        else
+          @params[k] = v
+        end
+      end
+    end
+
+    # @ref http://oauth.net/core/1.0/#rfc.section.9.1.2
+    @req_url = parsed_url.scheme + '://' + parsed_url.host + parsed_url.path
+
+    # create base str. make it an object attr for ez debugging
+    # ref http://oauth.net/core/1.0/#anchor14
+    @base_str = [ 
+      @req_method, 
+      percent_encode( req_url ), 
+
+      # normalization is just x-www-form-urlencoded
+      percent_encode( query_string ) 
+
+    ].join( '&' )
+
+    # add signature
+    @params[ 'oauth_signature' ] = signature
+
+    return self
+  end
+end

data/lib/tasks/geocoder.rake

@@ -0,0 +1,25 @@
+namespace :geocode do
+  desc "Geocode all objects without coordinates."
+  task :all => :environment do
+    class_name = ENV['CLASS'] || ENV['class']
+    raise "Please specify a CLASS (model)" unless class_name
+    klass = class_from_string(class_name)
+
+    klass.not_geocoded.each do |obj|
+      obj.geocode; obj.save
+    end
+  end
+end
+
+##
+# Get a class object from the string given in the shell environment.
+# Similar to ActiveSupport's +constantize+ method.
+#
+def class_from_string(class_name)
+  parts = class_name.split("::")
+  constant = Object
+  parts.each do |part|
+    constant = constant.const_get(part)
+  end
+  constant
+end