activerecord-postgres-earthdistance 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa10e1e01f4e26d80e188024f16177899ef524b7
-  data.tar.gz: 2b86f09f526262b9d4e5e69bee619714c7bbb4b4
+  metadata.gz: 837c44a62054d3207412a8426a108d91c3ee565a
+  data.tar.gz: 51eb68df69f6259f9ed85cfa01a8b699bdfdc59d
 SHA512:
-  metadata.gz: a2eb157285ff752f9b9e53dc98afa332d584da45e962174bff85adfcb5b5cb4e8aa5c8ee2548f401408b2a4620578bdd9dba25b7add3ca24327977b930515314
-  data.tar.gz: c706f3332b474f697b7b8abd09d66f44491927ede254554f774816c111e0f6b93ddfbb4d1c05c944daf84cdce2b319d3591ba4040080caaef423feb8a54d7dbf
+  metadata.gz: bc1e1bb9e5ee4f5abf5d282cc0580ddde5994a7011e0948413b1191549fe78850835eb9aee996fa4a5faa12534124848371c327e82a0b36e24f07d934881f86d
+  data.tar.gz: b0a529f93d2adcba785c74c7440ac7ef45eae07175b7ac7a670e388046dc589c6082c9dc63b0d698c7070d97d91cfb3da8ae61afab4a1531151090341f3711ee

data/.rubocop.yml

@@ -0,0 +1,20 @@
+Metrics/LineLength:
+  Max: 100
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/VariableNumber:
+  EnforcedStyle: normalcase

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    activerecord-postgres-earthdistance (0.4.4)
+    activerecord-postgres-earthdistance (0.5.0)
       activerecord (>= 3.1)
       pg
       rake
@@ -9,25 +9,31 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (5.0.0)
-      activesupport (= 5.0.0)
-    activerecord (5.0.0)
-      activemodel (= 5.0.0)
-      activesupport (= 5.0.0)
+    activemodel (5.0.0.1)
+      activesupport (= 5.0.0.1)
+    activerecord (5.0.0.1)
+      activemodel (= 5.0.0.1)
+      activesupport (= 5.0.0.1)
       arel (~> 7.0)
-    activesupport (5.0.0)
+    activesupport (5.0.0.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (7.1.1)
+    arel (7.1.4)
+    coderay (1.1.1)
     concurrent-ruby (1.0.2)
     diff-lcs (1.2.5)
     i18n (0.7.0)
     json (1.8.3)
-    minitest (5.9.0)
-    pg (0.18.4)
-    rake (11.2.2)
+    method_source (0.8.2)
+    minitest (5.9.1)
+    pg (0.19.0)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (11.3.0)
     rdoc (4.2.1)
       json (~> 1.4)
     rspec (2.99.0)
@@ -38,6 +44,7 @@ GEM
     rspec-expectations (2.99.2)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.99.4)
+    slop (3.6.0)
     thread_safe (0.3.5)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
@@ -48,8 +55,9 @@ PLATFORMS
 DEPENDENCIES
   activerecord-postgres-earthdistance!
   bundler
+  pry
   rdoc
   rspec (~> 2.11)
 
 BUNDLED WITH
-   1.12.5
+   1.13.1

data/README.md

@@ -1,9 +1,9 @@
-#ActiveRecord + PostgreSQL Earthdistance [![Build Status](https://travis-ci.org/diogob/activerecord-postgres-earthdistance.svg?branch=master)](https://travis-ci.org/diogob/activerecord-postgres-earthdistance)
+# ActiveRecord + PostgreSQL Earthdistance [![Build Status](https://travis-ci.org/diogob/activerecord-postgres-earthdistance.svg?branch=master)](https://travis-ci.org/diogob/activerecord-postgres-earthdistance) [![Code Climate](https://codeclimate.com/github/diogob/activerecord-postgres-earthdistance/badges/gpa.svg)](https://codeclimate.com/github/diogob/activerecord-postgres-earthdistance)
 
 Check distances with latitude and longitude using PostgreSQL special indexes.
 This gem enables your model to query the database using the earthdistance extension. This should be much faster than using trigonometry functions over standard indexes.
 
-##Requirements
+## Requirements
 
 Postgresql 9.1+ with contrib and Rails 3.1+
 On Ubuntu, this is easy: `sudo apt-get install postgresql-contrib-9.1`
@@ -14,7 +14,7 @@ On Mac you have a couple of options:
 * [Homebrew’s](https://github.com/mxcl/homebrew) Postgres installation also includes the contrib packages: `brew install postgres`
 * [Postgres.app](http://postgresapp.com/)
 
-##Install
+## Install
 
 
 Earthdistance is a PostgreSQL contrib module, [check it out first](http://www.postgresql.org/docs/9.2/static/earthdistance.html).
@@ -60,7 +60,7 @@ This will create the index with a SQL like this:
 CREATE INDEX places_earthdistance_ix ON places USING GIST (ll_to_earth(lat, lng));
 ```
 
-##Usage
+## Usage
 
 This gem only provides a custom serialization coder.
 If you want to use it just put in your Gemfile:
@@ -86,7 +86,15 @@ class Place < ActiveRecord::Base
 end
 ```
 
-###Querying the database
+You can also locale other entities through an geolocated association as in:
+```ruby
+class Job < ActiveRecord::Base
+  belongs_to :job
+  acts_as_geolocated through: :job
+end
+```
+
+### Querying the database
 
 To query for all places within a given radius of 100 meters from the origin -22.951916,-43.210487 just use:
 ```ruby
@@ -98,6 +106,11 @@ You can also order the records based on the distance from a point
 Place.within_radius(100, -22.951916,-43.210487).order_by_distance(-22.951916,-43.210487)
 ```
 
+To query on associated models (the joins will be included for you):
+```ruby
+Job.within_radius(100, -22.951916,-43.210487)
+```
+
 The `within_radius` query performs two checks: first against the *bounding box*, followed by computing the exact distance for
 all contained elements. The latter might be computationally expensive for big ranges.
 So if precision is not an issue but query speed is, you might want to query against the bounding box only:
@@ -112,7 +125,7 @@ closest = Place.within_radius(100, *point).order_by_distance(*point).selecting_d
 closest.distance
 ```
 
-##Test Database
+## Test Database
 
 To have earthdistance enabled when you load your database schema (as happens in rake db:test:prepare), you
 have two options.
@@ -128,12 +141,12 @@ This will change your schema dumps from Ruby to SQL. If you're
 unsure about the implications of this change, we suggest reading this
 [Rails Guide](http://guides.rubyonrails.org/migrations.html#schema-dumping-and-you).
 
-##Help
+## Help
 
 You can use issues in github for that. Or else you can reach us at
 twitter: [@dbiazus](https://twitter.com/#!/dbiazus)
 
-##Note on Patches/Pull Requests
+## Note on Patches/Pull Requests
 
 
 * Fork the project.
@@ -142,6 +155,6 @@ twitter: [@dbiazus](https://twitter.com/#!/dbiazus)
 * Commit, do not mess with rakefile, version, or history.  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-##Copyright
+## Copyright
 
 Copyright © 2010 Diogo Biazus. See LICENSE for details.

data/Rakefile

@@ -1,11 +1,11 @@
 # -*- encoding: utf-8 -*-
-$:.unshift File.expand_path("../lib", __FILE__)
-require 'bundler/gem_tasks'
-require 'rubygems'
-require 'rspec/core/rake_task'
-require 'rdoc/task'
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "bundler/gem_tasks"
+require "rubygems"
+require "rspec/core/rake_task"
+require "rdoc/task"
 
-task :default => :spec
+task default: :spec
 
 begin
   Bundler.setup(:default, :development)
@@ -18,10 +18,9 @@ end
 RSpec::Core::RakeTask.new(:spec)
 
 RDoc::Task.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-  rdoc.rdoc_dir = 'rdoc'
+  version = File.exist?("VERSION") ? File.read("VERSION") : ""
+  rdoc.rdoc_dir = "rdoc"
   rdoc.title = "activerecord-postgres-hstore #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
-

data/activerecord-postgres-earthdistance.gemspec

@@ -1,10 +1,10 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
+lib = File.expand_path("../lib/", __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name = "activerecord-postgres-earthdistance"
-  s.version = "0.4.4"
+  s.version = "0.5.0"
 
   s.platform    = Gem::Platform::RUBY
   s.license     = "MIT"
@@ -12,7 +12,9 @@ Gem::Specification.new do |s|
   s.email       = "diogo@biazus.me"
   s.homepage    = "http://github.com/diogob/activerecord-postgres-earthdistance"
   s.summary     = "Check distances with latitude and longitude using PostgreSQL special indexes"
-  s.description = "This gem enables your model to query the database using the earthdistance extension. This should be much faster than using trigonometry functions over standart indexs."
+  s.description = "This gem enables your model to query the database using the earthdistance \
+                  extension. This should be much faster than using trigonometry functions over\
+                  standart indexs."
   s.required_ruby_version     = ">= 1.8.7"
   s.required_rubygems_version = ">= 1.3.6"
 
@@ -22,8 +24,13 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler"
   s.add_development_dependency "rdoc"
   s.add_development_dependency "rspec", "~> 2.11"
+  s.add_development_dependency "pry"
 
-  git_files            = `git ls-files`.split("\n") rescue ''
+  git_files            = begin
+                           `git ls-files`.split("\n")
+                         rescue
+                           ""
+                         end
   s.files              = git_files
   s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables        = []

data/lib/activerecord-postgres-earthdistance.rb

@@ -1,4 +1,4 @@
-require 'active_support'
+require "active_support"
 
 ActiveSupport.on_load :active_record do
   require "activerecord-postgres-earthdistance/activerecord"

data/lib/activerecord-postgres-earthdistance/activerecord.rb

@@ -3,14 +3,13 @@ require "activerecord-postgres-earthdistance/acts_as_geolocated"
 module ActiveRecord
   module ConnectionAdapters
     module SchemaStatements
-
-      def add_earthdistance_index table_name, options = {}
-        execute "CREATE INDEX %s_earthdistance_ix ON %s USING gist (ll_to_earth(%s, %s));" %
-          [table_name, table_name, (options[:lat] || 'lat'), (options[:lng] || 'lng')]
+      def add_earthdistance_index(table_name, options = {})
+        execute("CREATE INDEX %s_earthdistance_ix ON %s USING gist (ll_to_earth(%s, %s));")
+          .format([table_name, table_name, (options[:lat] || "lat"), (options[:lng] || "lng")])
       end
 
-      def remove_earthdistance_index table_name
-        execute "DROP INDEX %s_earthdistance_ix;" % [table_name]
+      def remove_earthdistance_index(table_name)
+        execute("DROP INDEX %s_earthdistance_ix;").format([table_name])
       end
     end
   end

data/lib/activerecord-postgres-earthdistance/acts_as_geolocated.rb

@@ -4,57 +4,96 @@ module ActiveRecordPostgresEarthdistance
 
     module ClassMethods
       def acts_as_geolocated(options = {})
-        cattr_accessor :latitude_column, :longitude_column
+        cattr_accessor :latitude_column, :longitude_column, :through_table
         self.latitude_column = options[:lat] || (column_names.include?("lat") ? "lat" : "latitude")
-        self.longitude_column = options[:lng] || (column_names.include?("lng") ? "lng" : "longitude")
+        self.longitude_column = options[:lng] ||
+                                (column_names.include?("lng") ? "lng" : "longitude")
+        self.through_table = options[:through]
       end
 
       def within_box(radius, lat, lng)
-        earth_box = Arel::Nodes::NamedFunction.new('earth_box', [Utils.ll_to_earth_coords(lat, lng), Utils.quote_value(radius)])
-        where Arel::Nodes::InfixOperation.new('<@', Utils.ll_to_earth_columns(self), earth_box)
+        earth_box = Arel::Nodes::NamedFunction.new(
+          "earth_box",
+          [Utils.ll_to_earth_coords(lat, lng), Utils.quote_value(radius)]
+        )
+        joins(through_table)
+          .where(
+            Arel::Nodes::InfixOperation.new(
+              "<@",
+              Utils.ll_to_earth_columns(through_table_klass),
+              earth_box
+            )
+          )
       end
 
       def within_radius(radius, lat, lng)
-        earth_distance = Arel::Nodes::NamedFunction.new('earth_distance', [Utils.ll_to_earth_columns(self), Utils.ll_to_earth_coords(lat, lng)])
-        within_box(radius, lat, lng).where(Arel::Nodes::InfixOperation.new('<=', earth_distance, Utils.quote_value(radius)))
+        earth_distance = Utils.earth_distance(through_table_klass, lat, lng)
+        within_box(radius, lat, lng)
+          .where(Arel::Nodes::InfixOperation.new("<=", earth_distance, Utils.quote_value(radius)))
       end
 
       def order_by_distance(lat, lng, order = "ASC")
-        earth_distance = Arel::Nodes::NamedFunction.new('earth_distance', [Utils.ll_to_earth_columns(self), Utils.ll_to_earth_coords(lat, lng)])
-        order("#{earth_distance.to_sql} #{order.to_s}")
+        earth_distance = Utils.earth_distance(through_table_klass, lat, lng)
+        joins(through_table).order("#{earth_distance.to_sql} #{order}")
       end
-    end
 
-    module Utils
-      def self.ll_to_earth_columns(klass)
-        Arel::Nodes::NamedFunction.new('ll_to_earth', [klass.arel_table[klass.latitude_column], klass.arel_table[klass.longitude_column]])
-      end
+      private
 
-      def self.ll_to_earth_coords lat, lng
-        Arel::Nodes::NamedFunction.new('ll_to_earth', [quote_value(lat), quote_value(lng)])
-      end
-
-      def self.quote_value value
-        if Arel::Nodes.respond_to?(:build_quoted) # for arel >= 6.0.0
-          Arel::Nodes.build_quoted(value)
+      def through_table_klass
+        if through_table.present?
+          reflections[through_table.to_s].klass
         else
-          value
+          self
         end
       end
     end
   end
 
+  module Utils
+    def self.earth_distance(through_table_klass, lat, lng, aliaz = nil)
+      Arel::Nodes::NamedFunction.new(
+        "earth_distance",
+        [
+          ll_to_earth_columns(through_table_klass),
+          ll_to_earth_coords(lat, lng)
+        ],
+        aliaz
+      )
+    end
+
+    def self.ll_to_earth_columns(klass)
+      Arel::Nodes::NamedFunction.new(
+        "ll_to_earth",
+        [klass.arel_table[klass.latitude_column], klass.arel_table[klass.longitude_column]]
+      )
+    end
+
+    def self.ll_to_earth_coords(lat, lng)
+      Arel::Nodes::NamedFunction.new("ll_to_earth", [quote_value(lat), quote_value(lng)])
+    end
+
+    def self.quote_value(value)
+      if Arel::Nodes.respond_to?(:build_quoted) # for arel >= 6.0.0
+        Arel::Nodes.build_quoted(value)
+      else
+        value
+      end
+    end
+  end
+
   module QueryMethods
-    def selecting_distance_from lat, lng, name="distance", include_default_columns=true
+    def selecting_distance_from(lat, lng, name = "distance", include_default_columns = true)
       clone.tap do |relation|
         values = []
-        values << relation.arel_table[Arel.star] if relation.select_values.empty? && include_default_columns
-        values << "earth_distance(ll_to_earth(#{self.latitude_column}, #{self.longitude_column}), ll_to_earth(#{lat}, #{lng})) as #{name}"
+        if relation.select_values.empty? && include_default_columns
+          values << relation.arel_table[Arel.star]
+        end
+        values << Utils.earth_distance(self, lat, lng, name)
+
         relation.select_values = values
       end
     end
   end
-
 end
 
 ActiveRecord::Base.send :include, ActiveRecordPostgresEarthdistance::ActsAsGeolocated

data/lib/activerecord-postgres-earthdistance/railties.rb

@@ -1,13 +1,13 @@
-require 'rails'
-require 'rails/generators'
-require 'rails/generators/migration'
-require 'active_record'
+require "rails"
+require "rails/generators"
+require "rails/generators/migration"
+require "active_record"
 # = Earth Distance Railtie
 #
 # Creates a new railtie for 2 reasons:
 #
 # * Initialize ActiveRecord properly
-# * Add earthdistance:setup generator 
+# * Add earthdistance:setup generator
 class EarthDistance < Rails::Railtie
   # Creates the earthdistance:setup generator. This generator creates a migration that
   # adds earthdistance support for your database. If fact, it's just the sql from the
@@ -20,21 +20,19 @@ class EarthDistance < Rails::Railtie
     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
 
     def self.next_migration_number(dirname)
       if ActiveRecord::Base.timestamped_migrations
         Time.now.utc.strftime("%Y%m%d%H%M%S")
       else
-        "%.3d" % (current_migration_number(dirname) + 1)
+        "%.3d".format(current_migration_number(dirname) + 1)
       end
     end
 
     def create_migration_file
-      migration_template 'setup_earthdistance.rb', 'db/migrate/setup_earthdistance.rb'
+      migration_template "setup_earthdistance.rb", "db/migrate/setup_earthdistance.rb"
     end
-
   end
 end
-

data/spec/act_as_geolocated_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "ActiveRecord::Base.act_as_geolocated" do
-  describe 'ActiveRecord::Base' do
+  describe "ActiveRecord::Base" do
     context "when using .where with a model instance as a placeholder" do
       let(:place) { Place.create! }
-      subject { Place.where('id = ?', place).first }
+      subject { Place.where("id = ?", place).first }
       after { place.destroy! }
 
       it { should == place }
@@ -16,7 +16,7 @@ describe "ActiveRecord::Base.act_as_geolocated" do
 
     subject { Place.within_box(test_data[:radius], test_data[:lat], test_data[:lng]) }
 
-    before(:all) { @place = Place.create!(:lat => -30.0277041, :lng => -51.2287346) }
+    before(:all) { @place = Place.create!(lat: -30.0277041, lng: -51.2287346) }
     after(:all) { @place.destroy }
 
     context "when query with null data" do
@@ -24,19 +24,19 @@ describe "ActiveRecord::Base.act_as_geolocated" do
     end
 
     context "when query for the exact same point with radius 0" do
-      let(:test_data) { { lat: -30.0277041, lng: -51.2287346 , radius: 0 } }
+      let(:test_data) { { lat: -30.0277041, lng: -51.2287346, radius: 0 } }
 
       it { should == [@place] }
     end
 
     context "when query for place within the box" do
-      let(:test_data) { { radius: 4000000, lat: -27.5969039, lng: -48.5494544 } }
+      let(:test_data) { { radius: 4_000_000, lat: -27.5969039, lng: -48.5494544 } }
 
       it { should == [@place] }
     end
 
     context "when query for place within the box, but outside the radius" do
-      let(:test_data) { { radius: 300000, lat: -27.5969039, lng: -48.5494544 } }
+      let(:test_data) { { radius: 300_000, lat: -27.5969039, lng: -48.5494544 } }
 
       it "the place shouldn't be within the radius" do
         Place.within_radius(test_data[:radius], test_data[:lat], test_data[:lng]).should be_empty
@@ -56,21 +56,28 @@ describe "ActiveRecord::Base.act_as_geolocated" do
       subject { Place.within_box(test_data[:radius], test_data[:lat], test_data[:lng]) }
 
       it "should work with objects having columns with the same name" do
-        expect { Place.joins(:events).within_radius(test_data[:radius], test_data[:lat], test_data[:lng]).to_a }.to_not raise_error
-
+        expect do
+          Place
+            .joins(:events)
+            .within_radius(test_data[:radius], test_data[:lat], test_data[:lng]).to_a
+        end.to_not raise_error
       end
 
       it "should work with nested associations" do
-        expect { Event.joins(:events).within_radius(test_data[:radius], test_data[:lat], test_data[:lng]).to_a }.to_not raise_error
+        expect do
+          Event
+            .joins(:events)
+            .within_radius(test_data[:radius], test_data[:lat], test_data[:lng]).to_a
+        end.to_not raise_error
       end
     end
   end
 
   describe "#within_radius" do
-    let(:test_data){ {lat: nil, lng: nil, radius: nil} }
-    subject{ Place.within_radius(test_data[:radius], test_data[:lat], test_data[:lng]) }
+    let(:test_data) { { lat: nil, lng: nil, radius: nil } }
+    subject { Place.within_radius(test_data[:radius], test_data[:lat], test_data[:lng]) }
     before(:all) do
-      @place = Place.create!(:lat => -30.0277041, :lng => -51.2287346)
+      @place = Place.create!(lat: -30.0277041, lng: -51.2287346)
     end
 
     after(:all) do
@@ -78,66 +85,121 @@ describe "ActiveRecord::Base.act_as_geolocated" do
     end
 
     context "when query with null data" do
-      it{ should == [] }
+      it { should == [] }
     end
 
     context "when query for the exact same point with radius 0" do
-      let(:test_data){{lat: -30.0277041, lng: -51.2287346 , radius: 0}}
-      it{ should == [@place] }
+      let(:test_data) { { lat: -30.0277041, lng: -51.2287346, radius: 0 } }
+      it { should == [@place] }
     end
 
     context "when query for place within radius" do
-      let(:test_data){ {radius: 4000000, lat: -27.5969039, lng: -48.5494544} }
-      it{ should == [@place] }
+      let(:test_data) { { radius: 4_000_000, lat: -27.5969039, lng: -48.5494544 } }
+      it { should == [@place] }
     end
 
     context "when query for place outside the radius" do
-      let(:test_data){ {radius: 1000, lat: -27.5969039, lng: -48.5494544} }
-      it{ should == [] }
+      let(:test_data) { { radius: 1000, lat: -27.5969039, lng: -48.5494544 } }
+      it { should == [] }
+    end
+
+    context "uses lat and long of through table" do
+      subject do
+        Job.within_radius(test_data[:radius], test_data[:lat], test_data[:lng])
+      end
+
+      before(:all) do
+        @event = Event.create!(lat: -30.0277041, lng: -51.2287346)
+        @job = Job.create!(event: @event)
+      end
+
+      after(:all) do
+        @event.destroy
+        @job.destroy
+      end
+
+      context "when query with null data" do
+        it { should == [] }
+      end
+
+      context "when query for the exact same point with radius 0" do
+        let(:test_data) { { lat: -30.0277041, lng: -51.2287346, radius: 0 } }
+        it { should == [@job] }
+      end
+
+      context "when query for place within radius" do
+        let(:test_data) { { radius: 4_000_000, lat: -27.5969039, lng: -48.5494544 } }
+        it { should == [@job] }
+      end
+
+      context "when query for place outside the radius" do
+        let(:test_data) { { radius: 1000, lat: -27.5969039, lng: -48.5494544 } }
+        it { should == [] }
+      end
     end
   end
 
   describe "#order_by_distance" do
-    let(:current_location){ {lat: nil, lng: nil, radius: nil} }
-    subject{ Place.order_by_distance(current_location[:lat], current_location[:lng]) }
+    let(:current_location) { { lat: nil, lng: nil, radius: nil } }
+
+    subject { Place.order_by_distance(current_location[:lat], current_location[:lng]) }
+
     before(:all) do
-      @place_1 = Place.create!(:lat => 52.370216, :lng => 4.895168) #Amsterdam
-      @place_2 = Place.create!(:lat => 52.520007, :lng => 13.404954) #Berlin
+      @amsterdam = Place.create!(lat: 52.370216, lng: 4.895168)
+      @berlin = Place.create!(lat: 52.520007, lng: 13.404954) # Berlin
+      @event_in_amsterdam = Event.create!(lat: 52.370216, lng: 4.895168)
+      @event_in_berlin = Event.create!(lat: 52.520007, lng: 13.404954)
+      @amsterdam_job = Job.create!(event: @event_in_amsterdam)
+      @berlin_job = Job.create!(event: @event_in_berlin)
     end
+
     after(:all) do
-      @place_1.destroy
-      @place_2.destroy
+      @amsterdam.destroy
+      @berlin.destroy
+      @event_in_amsterdam.destroy
+      @event_in_berlin.destroy
+      @amsterdam_job.destroy
+      @berlin_job.destroy
+    end
+
+    context "uses lat and long of through table" do
+      subject do
+        Job.order_by_distance(current_location[:lat], current_location[:lng])
+      end
+
+      let(:current_location) { { lat: 51.511214, lng: 0.119824 } } # London
+      it { should == [@amsterdam_job, @berlin_job] }
     end
 
     context "when sorting on distance" do
-      let(:current_location){{lat: 51.511214, lng: 0.119824}} #London
-      it{ should == [@place_1, @place_2] }
+      let(:current_location) { { lat: 51.511214, lng: 0.119824 } } # London
+      it { should == [@amsterdam, @berlin] }
     end
 
     context "when sorting on distance from another location" do
-      let(:current_location){{lat: 52.229676, lng: 21.012229}} #Warsaw
-      it{ should == [@place_2, @place_1] }
+      let(:current_location) { { lat: 52.229676, lng: 21.012229 } } # Warsaw
+      it { should == [@berlin, @amsterdam] }
     end
   end
 
   describe "#selecting_distance_from" do
-    let(:current_location){ {lat: nil, lng: nil, radius: nil} }
+    let(:current_location) { { lat: nil, lng: nil, radius: nil } }
     subject do
-      Place.
-        order_by_distance(current_location[:lat], current_location[:lng]).
-        selecting_distance_from(current_location[:lat], current_location[:lng]).
-        first.
-        try{|p| [p.data, p.distance.to_f] }
+      Place
+        .order_by_distance(current_location[:lat], current_location[:lng])
+        .selecting_distance_from(current_location[:lat], current_location[:lng])
+        .first
+        .try { |p| [p.data, p.distance.to_f] }
     end
     before(:all) do
-      @place = Place.create!(:data => 'Amsterdam', :lat => 52.370216, :lng => 4.895168) #Amsterdam
+      @place = Place.create!(data: "Amsterdam", lat: 52.370216, lng: 4.895168) # Amsterdam
     end
     after(:all) do
       @place.destroy
     end
     context "when selecting distance" do
-      let(:current_location){{lat: 52.229676, lng: 21.012229}} #Warsaw
-      it{ should == ["Amsterdam", 1095013.87438311] }
+      let(:current_location) { { lat: 52.229676, lng: 21.012229 } } # Warsaw
+      it { should == ["Amsterdam", 1_095_013.87438311] }
     end
   end
 end

data/spec/fixtures/job.rb

@@ -0,0 +1,4 @@
+class Job < ActiveRecord::Base
+  acts_as_geolocated through: :event
+  belongs_to :event
+end

data/spec/spec_helper.rb

@@ -1,9 +1,9 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'rspec'
-require 'rspec/autorun'
-require 'activerecord-postgres-earthdistance'
-require 'active_record'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "rspec"
+require "rspec/autorun"
+require "activerecord-postgres-earthdistance"
+require "active_record"
 
 RSpec.configure do |config|
   config.before(:suite) do
@@ -11,12 +11,12 @@ RSpec.configure do |config|
     # I do not use database users or password for the tests, using ident authentication instead
     begin
       ActiveRecord::Base.establish_connection(
-        :adapter  => "postgresql",
-        :host     => "localhost",
-        :username => "postgres",
-        :password => "postgres",
-        :port     => 5432,
-        :database => "ar_pg_earthdistance_test"
+        adapter: "postgresql",
+        host: "localhost",
+        username: "postgres",
+        password: "postgres",
+        port: 5432,
+        database: "ar_pg_earthdistance_test"
       )
       ActiveRecord::Base.connection.execute %{
         SET client_min_messages TO warning;
@@ -24,26 +24,35 @@ RSpec.configure do |config|
         CREATE EXTENSION IF NOT EXISTS earthdistance;
         DROP TABLE IF EXISTS places;
         DROP TABLE IF EXISTS events;
+        DROP TABLE IF EXISTS jobs;
         CREATE TABLE places (id serial PRIMARY KEY, data text, lat float8, lng float8);
-        CREATE TABLE events (id serial PRIMARY KEY, event_id integer, place_id integer, data text, lat float8, lng float8);
+        CREATE TABLE events (
+          id serial PRIMARY KEY,
+          event_id integer,
+          place_id integer,
+          data text,
+          lat float8,
+          lng float8
+        );
+        CREATE TABLE jobs (id serial PRIMARY KEY, event_id integer);
 }
-    rescue Exception => e
+    rescue StandardError => e
       puts "Exception: #{e}"
       ActiveRecord::Base.establish_connection(
-        :adapter  => "postgresql",
-        :host     => "localhost",
-        :username => "postgres",
-        :password => "postgres",
-        :port     => 5432,
-        :database => "postgres"
+        adapter: "postgresql",
+        host: "localhost",
+        username: "postgres",
+        password: "postgres",
+        port: 5432,
+        database: "postgres"
       )
       ActiveRecord::Base.connection.execute "CREATE DATABASE ar_pg_earthdistance_test"
       retry
     end
 
     # Load models used in spec
-    require 'fixtures/place'
-    require 'fixtures/event'
+    require "fixtures/place"
+    require "fixtures/event"
+    require "fixtures/job"
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgres-earthdistance
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Diogo Biazus
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-31 00:00:00.000000000 Z
+date: 2016-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -94,8 +94,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
-description: This gem enables your model to query the database using the earthdistance
-  extension. This should be much faster than using trigonometry functions over standart
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem enables your model to query the database using the earthdistance                   extension.
+  This should be much faster than using trigonometry functions over                  standart
   indexs.
 email: diogo@biazus.me
 executables: []
@@ -105,6 +119,7 @@ files:
 - ".document"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - Gemfile.lock
@@ -121,6 +136,7 @@ files:
 - lib/templates/setup_earthdistance.rb
 - spec/act_as_geolocated_spec.rb
 - spec/fixtures/event.rb
+- spec/fixtures/job.rb
 - spec/fixtures/place.rb
 - spec/spec_helper.rb
 homepage: http://github.com/diogob/activerecord-postgres-earthdistance
@@ -150,5 +166,6 @@ summary: Check distances with latitude and longitude using PostgreSQL special in
 test_files:
 - spec/act_as_geolocated_spec.rb
 - spec/fixtures/event.rb
+- spec/fixtures/job.rb
 - spec/fixtures/place.rb
 - spec/spec_helper.rb