acts_as_geocodable 2.0.3 → 2.1.0

data/lib/acts_as_geocodable.rb

@@ -1,7 +1,10 @@
-require 'graticule'
-require 'acts_as_geocodable/geocoding'
-require 'acts_as_geocodable/geocode'
-require 'acts_as_geocodable/remote_location'
+require "active_record"
+require "active_support"
+require "graticule"
+
+require "acts_as_geocodable/geocoding"
+require "acts_as_geocodable/geocode"
+require "acts_as_geocodable/remote_location"
 
 module ActiveSupport::Callbacks::ClassMethods
   def without_callback(*args, &block)
@@ -11,7 +14,7 @@ module ActiveSupport::Callbacks::ClassMethods
   end
 end
 
-module ActsAsGeocodable #:nodoc:
+module ActsAsGeocodable
   # Make a model geocodable.
   #
   #  class Event < ActiveRecord::Base
@@ -29,25 +32,24 @@ module ActsAsGeocodable #:nodoc:
   #
   def acts_as_geocodable(options = {})
     options = {
-      :address => {
-        :street => :street, :locality => :locality, :region => :region,
-        :postal_code => :postal_code, :country => :country},
-      :normalize_address => false,
-      :distance_column => 'distance',
-      :units => :miles
+      address: {
+        street: :street, locality: :locality, region: :region,
+        postal_code: :postal_code, country: :country},
+      normalize_address: false,
+      distance_column: "distance",
+      units: :miles
     }.merge(options)
 
-    if ActiveRecord::VERSION::MAJOR >= 3
-      class_attribute :acts_as_geocodable_options
-      self.acts_as_geocodable_options = options
-    else
-      write_inheritable_attribute :acts_as_geocodable_options, options
-      class_inheritable_reader :acts_as_geocodable_options
-    end
+    class_attribute :acts_as_geocodable_options
+    self.acts_as_geocodable_options = options
 
     define_callbacks :geocoding
 
-    has_one :geocoding, :as => :geocodable, :include => :geocode, :dependent => :destroy
+    if ActiveRecord::VERSION::MAJOR >= 4
+      has_one :geocoding, -> { includes :geocode }, as: :geocodable, dependent: :destroy
+    else
+      has_one :geocoding, as: :geocodable, include: :geocode, dependent: :destroy
+    end
 
     after_save :attach_geocode
 
@@ -63,7 +65,7 @@ module ActsAsGeocodable #:nodoc:
 
     # Use ActiveRecord ARel style syntax for finding records.
     #
-    #   Model.origin("Chicago, IL", :within => 10)
+    #   Model.origin("Chicago, IL", within: 10)
     #
     # a +distance+ attribute indicating the distance
     # to the origin is added to each of the results:
@@ -80,34 +82,35 @@ module ActsAsGeocodable #:nodoc:
     #   Default is <tt>:miles</tt> unless specified otherwise in the +acts_as_geocodable+
     #   declaration.
     #
-    scope :origin, lambda {|*args|
+    scope :origin, lambda { |*args|
       origin = location_to_geocode(args[0])
       options = {
-        :units => acts_as_geocodable_options[:units],
+        units: acts_as_geocodable_options[:units],
       }.merge(args[1] || {})
       distance_sql = sql_for_distance(origin, options[:units])
 
       scope = with_geocode_fields.select("#{table_name}.*, #{distance_sql} AS
            #{acts_as_geocodable_options[:distance_column]}")
 
-      scope = scope.where("#{distance_sql} >  #{options[:beyond]}") if options[:beyond]
+      scope = scope.where("#{distance_sql} > #{options[:beyond]}") if options[:beyond]
       if options[:within]
-        scope = scope.where("(geocodes.latitude = :lat AND geocodes.longitude = :long) OR (#{distance_sql} <= #{options[:within]})", {:lat => origin.latitude, :long => origin.longitude})
+        scope = scope.where("(geocodes.latitude = :lat AND geocodes.longitude = :long) OR (#{distance_sql} <= #{options[:within]})", { lat: origin.latitude, long: origin.longitude })
       end
       scope
     }
 
-    scope :near, order("#{acts_as_geocodable_options[:distance_column]} ASC")
-    scope :far, order("#{acts_as_geocodable_options[:distance_column]} DESC")
+    scope :near, -> { order("#{acts_as_geocodable_options[:distance_column]} ASC") }
+    scope :far, -> { order("#{acts_as_geocodable_options[:distance_column]} DESC") }
 
     include ActsAsGeocodable::Model
   end
 
   module Model
-    extend ActiveSupport::Concern
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
     module ClassMethods
-
       # Find the nearest location to the given origin
       #
       #   Model.origin("Grand Rapids, MI").nearest
@@ -128,7 +131,7 @@ module ActsAsGeocodable #:nodoc:
       def location_to_geocode(location)
         case location
         when Geocode then location
-        when InstanceMethods then location.geocode
+        when ActsAsGeocodable::Model then location.geocode
         when String, Fixnum then Geocode.find_or_create_by_query(location.to_s)
         end
       end
@@ -149,120 +152,116 @@ module ActsAsGeocodable #:nodoc:
       #   end
       #
       def validates_as_geocodable(options = {})
-        options = options.reverse_merge :message => "Address could not be geocoded.", :allow_nil => false
+        options = options.reverse_merge message: "Address could not be geocoded.", allow_nil: false
         validate do |model|
           is_blank = model.to_location.attributes.except(:precision).all?(&:blank?)
           unless options[:allow_nil] && is_blank
-            geocode = model.send :attach_geocode
+            geocode = model.send(:attach_geocode)
             if !geocode ||
                 (options[:precision] && geocode.precision < options[:precision]) ||
                 (block_given? && yield(geocode) == false)
-              model.errors.add :base, options[:message]
+              model.errors.add(:base, options[:message])
             end
           end
         end
       end
 
-    private
+      private
 
       def sql_for_distance(origin, units = acts_as_geocodable_options[:units])
         Graticule::Distance::Spherical.to_sql(
-          :latitude => origin.latitude,
-          :longitude => origin.longitude,
-          :latitude_column => "geocodes.latitude",
-          :longitude_column => "geocodes.longitude",
-          :units => units
+          latitude: origin.latitude,
+          longitude: origin.longitude,
+          latitude_column: "geocodes.latitude",
+          longitude_column: "geocodes.longitude",
+          units: units
         )
       end
     end
 
-    module InstanceMethods
-
-      # Get the geocode for this model
-      def geocode
-        geocoding.geocode if geocoding
-      end
+    # Get the geocode for this model
+    def geocode
+      geocoding.geocode if geocoding
+    end
 
-      # Create a Graticule::Location
-      def to_location
-        Graticule::Location.new.tap do |location|
-          [:street, :locality, :region, :postal_code, :country].each do |attr|
-            location.send "#{attr}=", geo_attribute(attr)
-          end
+    # Create a Graticule::Location
+    def to_location
+      Graticule::Location.new.tap do |location|
+        [:street, :locality, :region, :postal_code, :country].each do |attr|
+          location.send("#{attr}=", geo_attribute(attr))
         end
       end
+    end
 
-      # Get the distance to the given destination. The destination can be an
-      # acts_as_geocodable model, a Geocode, or a string
-      #
-      #   myhome.distance_to "Chicago, IL"
-      #   myhome.distance_to "49423"
-      #   myhome.distance_to other_model
-      #
-      # == Options
-      # * <tt>:units</tt>: <tt>:miles</tt> or <tt>:kilometers</tt>
-      # * <tt>:formula</tt>: The formula to use to calculate the distance. This can
-      #   be any formula supported by Graticule. The default is <tt>:haversine</tt>.
-      #
-      def distance_to(destination, options = {})
-        units = options[:units] || acts_as_geocodable_options[:units]
-        formula = options[:formula] || :haversine
+    # Get the distance to the given destination. The destination can be an
+    # acts_as_geocodable model, a Geocode, or a string
+    #
+    #   myhome.distance_to "Chicago, IL"
+    #   myhome.distance_to "49423"
+    #   myhome.distance_to other_model
+    #
+    # == Options
+    # * <tt>:units</tt>: <tt>:miles</tt> or <tt>:kilometers</tt>
+    # * <tt>:formula</tt>: The formula to use to calculate the distance. This can
+    #   be any formula supported by Graticule. The default is <tt>:haversine</tt>.
+    #
+    def distance_to(destination, options = {})
+      units = options[:units] || acts_as_geocodable_options[:units]
+      formula = options[:formula] || :haversine
 
-        geocode = self.class.location_to_geocode(destination)
-        self.geocode.distance_to(geocode, units, formula)
-      end
+      geocode = self.class.location_to_geocode(destination)
+      self.geocode.distance_to(geocode, units, formula)
+    end
 
     protected
 
-      # Perform the geocoding
-      def attach_geocode
-        new_geocode = Geocode.find_or_create_by_location self.to_location unless self.to_location.blank?
-        if new_geocode && self.geocode != new_geocode
-          run_callbacks :geocoding do
-            self.geocoding = Geocoding.new :geocode => new_geocode
-            self.update_address self.acts_as_geocodable_options[:normalize_address]
-          end
-        elsif !new_geocode && self.geocoding
-          self.geocoding.destroy
+    # Perform the geocoding
+    def attach_geocode
+      new_geocode = Geocode.find_or_create_by_location(self.to_location) unless self.to_location.blank?
+      if new_geocode && self.geocode != new_geocode
+        run_callbacks :geocoding do
+          self.geocoding = Geocoding.new(geocode: new_geocode)
+          self.update_address self.acts_as_geocodable_options[:normalize_address]
         end
-        new_geocode
-      rescue Graticule::Error => e
-        logger.warn e.message
+      elsif !new_geocode && self.geocoding
+        self.geocoding.destroy
       end
+      new_geocode
+    rescue Graticule::Error => error
+      logger.warn error.message
+    end
 
-
-      def update_address(force = false) #:nodoc:
-        unless self.geocode.blank?
-          if self.acts_as_geocodable_options[:address].is_a? Symbol
-            method = self.acts_as_geocodable_options[:address]
+    def update_address(force = false)
+      unless self.geocode.blank?
+        if self.acts_as_geocodable_options[:address].is_a? Symbol
+          method = self.acts_as_geocodable_options[:address]
+          if self.respond_to?("#{method}=") && (self.send(method).blank? || force)
+            self.send("#{method}=", self.geocode.to_location.to_s)
+          end
+        else
+          self.acts_as_geocodable_options[:address].each do |attribute,method|
             if self.respond_to?("#{method}=") && (self.send(method).blank? || force)
-              self.send "#{method}=", self.geocode.to_location.to_s
-            end
-          else
-            self.acts_as_geocodable_options[:address].each do |attribute,method|
-              if self.respond_to?("#{method}=") && (self.send(method).blank? || force)
-                self.send "#{method}=", self.geocode.send(attribute)
-              end
+              self.send("#{method}=", self.geocode.send(attribute))
             end
           end
+        end
 
-          self.class.without_callback(:save, :after, :attach_geocode) do
-            save
-          end
+        self.class.without_callback(:save, :after, :attach_geocode) do
+          save
         end
       end
+    end
 
-      def geo_attribute(attr_key) #:nodoc:
-        if self.acts_as_geocodable_options[:address].is_a? Symbol
-          attr_name = self.acts_as_geocodable_options[:address]
-          attr_key == :street ? self.send(attr_name) : nil
-        else
-          attr_name = self.acts_as_geocodable_options[:address][attr_key]
-          attr_name && self.respond_to?(attr_name) ? self.send(attr_name) : nil
-        end
+    def geo_attribute(attr_key)
+      if self.acts_as_geocodable_options[:address].is_a? Symbol
+        attr_name = self.acts_as_geocodable_options[:address]
+        attr_key == :street ? self.send(attr_name) : nil
+      else
+        attr_name = self.acts_as_geocodable_options[:address][attr_key]
+        attr_name && self.respond_to?(attr_name) ? self.send(attr_name) : nil
       end
     end
   end
 end
 
-ActiveRecord::Base.send :extend, ActsAsGeocodable
+ActiveRecord::Base.send(:extend, ActsAsGeocodable)

data/lib/acts_as_geocodable/geocode.rb

@@ -1,5 +1,5 @@
 class Geocode < ActiveRecord::Base
-  has_many :geocodings, :dependent => :destroy
+  has_many :geocodings, dependent: :destroy
 
   validates_uniqueness_of :query
 
@@ -20,7 +20,7 @@ class Geocode < ActiveRecord::Base
   end
 
   def self.create_by_query(query)
-    create geocoder.locate(query).attributes.merge(:query => query)
+    create geocoder.locate(query).attributes.merge(query: query)
   end
 
   def self.find_or_create_by_location(location)
@@ -28,9 +28,9 @@ class Geocode < ActiveRecord::Base
   end
 
   def self.create_from_location(location)
-    create geocoder.locate(location).attributes.merge(:query => location.to_s)
-  rescue Graticule::Error => e
-    logger.warn e.message
+    create geocoder.locate(location).attributes.merge(query: location.to_s)
+  rescue Graticule::Error => error
+    logger.warn error.message
     nil
   end
 
@@ -47,7 +47,7 @@ class Geocode < ActiveRecord::Base
   end
 
   def on(geocodable)
-    geocodings.create :geocodable => geocodable
+    geocodings.create(geocodable: geocodable)
   end
 
   def coordinates
@@ -60,6 +60,6 @@ class Geocode < ActiveRecord::Base
 
   # Create a Graticule::Location
   def to_location
-    Graticule::Location.new(attributes.except('id', 'query'))
+    Graticule::Location.new(attributes.except("id", "query"))
   end
-end
+end

data/lib/acts_as_geocodable/geocoding.rb

@@ -1,12 +1,12 @@
 class Geocoding < ActiveRecord::Base
   belongs_to :geocode
-  belongs_to :geocodable, :polymorphic => true
+  belongs_to :geocodable, polymorphic: true
 
   def self.geocoded_class(geocodable)
     ActiveRecord::Base.send(:class_name_of_active_record_descendant, geocodable.class).to_s
   end
-  
+
   def self.find_geocodable(geocoded_class, geocoded_id)
     geocoded_class.constantize.find(geocoded_id)
   end
-end
+end

data/lib/acts_as_geocodable/remote_location.rb

@@ -1,20 +1,20 @@
-module ActsAsGeocodable #:nodoc:
-  module RemoteLocation #:nodoc:
+require "action_controller"
 
+module ActsAsGeocodable
+  module RemoteLocation
     # Get the remote location of the request IP using http://hostip.info
     def remote_location
-      if request.remote_ip == '127.0.0.1'
+      if request.remote_ip == "127.0.0.1"
         # otherwise people would complain that it doesn't work
-        Graticule::Location.new(:locality => 'localhost')
+        Graticule::Location.new(locality: "localhost")
       else
         Graticule.service(:host_ip).new.locate(request.remote_ip)
       end
-    rescue Graticule::Error => e
-      logger.warn "An error occurred while looking up the location of '#{request.remote_ip}': #{e.message}"
+    rescue Graticule::Error => error
+      logger.warn "An error occurred while looking up the location of '#{request.remote_ip}': #{error.message}"
       nil
     end
-
   end
 end
 
-ActionController::Base.send :include, ActsAsGeocodable::RemoteLocation
+ActionController::Base.send(:include, ActsAsGeocodable::RemoteLocation)

data/lib/acts_as_geocodable/version.rb

@@ -1,3 +1,3 @@
 module ActsAsGeocodable
-  VERSION = '2.0.3' unless defined?(::ActsAsGeocodable::VERSION)
+  VERSION = "2.1.0" unless defined?(::ActsAsGeocodable::VERSION)
 end

data/lib/generators/acts_as_geocodable/USAGE

@@ -9,4 +9,4 @@ Example:
     rails generate acts_as_geocodable
 
     With 4 existing migrations, this will create an AddGeocodableTables migration in the
-    file db/migrate/5_add_geocodable_tables.rb
+    file db/migrate/5_add_geocodable_tables.rb

data/lib/generators/acts_as_geocodable/acts_as_geocodable_generator.rb

@@ -1,16 +1,16 @@
-require 'rails/generators'
-require 'rails/generators/migration'
+require "rails/generators"
+require "rails/generators/migration"
 
 class ActsAsGeocodableGenerator < Rails::Generators::Base
   include Rails::Generators::Migration
 
   def self.source_root
-     @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+     @source_root ||= File.join(File.dirname(__FILE__), "templates")
   end
 
   # Implement the required interface for Rails::Generators::Migration.
   #
-  def self.next_migration_number(dirname) #:nodoc:
+  def self.next_migration_number(dirname)
     next_migration_number = current_migration_number(dirname) + 1
     if ActiveRecord::Base.timestamped_migrations
       [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
@@ -21,8 +21,7 @@ class ActsAsGeocodableGenerator < Rails::Generators::Base
 
   def create_migration_file
     if defined?(ActiveRecord)
-      migration_template 'migration.rb', 'db/migrate/add_geocodable_tables.rb'
+      migration_template "migration.rb", "db/migrate/add_geocodable_tables.rb"
     end
   end
-
 end