geonames_api 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b04085ba81b7f7d468df252648f0b343e510a422
-  data.tar.gz: c9d634bfbdf444b769f43abd67bc2a5b2238ef56
+  metadata.gz: d605bbb8e74963f68bc1ceac9e757fa93e57803f
+  data.tar.gz: 3e1d3d10ff21f96b9e1403f57a0b75695379ace8
 SHA512:
-  metadata.gz: d083c2f06f3b1a5f4d2d624206f586e652df601caea5ec3d78b3be993bac3252fc3b7ff93782dbbc1896573f1f00112bb73843ff5e11550adc274bb1490cc11c
-  data.tar.gz: 1cdc8e7ee3166aec78f9e4c41b3023410c3e0a173e8900a5fb6e8210a2a1f7d63d9dfe1d44449660d4c8d3a7fc8d11b284199fb822da7c5d4777318aa3e2c7a0
+  metadata.gz: 70e98ad435c5e8045279998f9e098f33bfec6a02f8c31b7721d51603cd362353ae63771b773f2e29ddeff610688dfef9a0c1ed85c1d4b20186d83957779f5bd2
+  data.tar.gz: 70e213137e89e16725313b0f427ff9062da72c6828a24895027e023b1a0d601f22de94b083daf1e334a08c1811840ba7ea24334a0c1ffdaba5e7343489140267

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 2.1.2
   - 2.0.0
   - 1.9.3
 

data/lib/geonames_api/base.rb

@@ -1,4 +1,4 @@
-require 'cgi'
+require 'uri'
 
 module GeoNamesAPI
   class Base < Entity
@@ -19,9 +19,9 @@ module GeoNamesAPI
 
     def self.where(params={})
       retries_remaining = GeoNamesAPI.retries
-      url = url(params)
+      uri = uri(params)
       begin
-        response = make_request(url)
+        response = make_request(uri)
         unless response.empty?
           parse_response(response, params)
         end
@@ -38,14 +38,12 @@ module GeoNamesAPI
       end
     end
 
-    def self.make_request(url)
-      JSON.load(open(url).read)
+    def self.make_request(uri)
+      JSON.load(open(uri, "User-Agent" => "#{GeoNamesAPI.name}/#{GeoNamesAPI::VERSION}").read)
     end
 
     private_class_method :make_request
 
-    KEYS = %w(streetSegment geonames)
-
     def self.parse_response(response, request_params)
       GeoNamesAPI.logger.info "GEONAMES RESPONSE (#{Time.now}): #{response}" if GeoNamesAPI.logger
       if (status = response['status'])
@@ -56,13 +54,15 @@ module GeoNamesAPI
 
     private_class_method :parse_response
 
-    def self.url(params={})
-      endpoint = GeoNamesAPI.url + self::METHOD + params_to_url(GeoNamesAPI.params.merge(params))
+    def self.uri(params={})
+      endpoint = URI(GeoNamesAPI.url)
+      endpoint.path = "/%s" % self::METHOD # URI.path requires a leading /
+      endpoint.query = URI.encode_www_form(GeoNamesAPI.params.merge(params))
       GeoNamesAPI.logger.info "GEONAMES REQUEST (#{Time.now}): #{endpoint}" if GeoNamesAPI.logger
       endpoint
     end
 
-    private_class_method :url
+    private_class_method :uri
 
     def self.name_params(names)
       return names.first if names.first.is_a? Hash
@@ -75,19 +75,5 @@ module GeoNamesAPI
 
     private_class_method :name_params
 
-    def self.params_to_url(params={})
-      esc_params = params.map do |key, value|
-        "#{esc(key)}=#{esc(value)}"
-      end
-      "?#{esc_params.join('&')}"
-    end
-
-    private_class_method :params_to_url
-
-    def self.esc(str)
-      CGI::escape(str.to_s)
-    end
-
-    private_class_method :esc
   end
 end

data/lib/geonames_api/children.rb

@@ -2,7 +2,7 @@ module GeoNamesAPI
   class Children < ListEndpoint
 
     METHOD = "childrenJSON"
-    FIND_PARAMS = %w(geonameId)
+    FIND_PARAMS = %w(geonameId maxRows)
 
   end
 end

data/lib/geonames_api/entity.rb

@@ -9,11 +9,18 @@ module GeoNamesAPI
     attr_reader :request_params
 
     def initialize(response, request_params = nil)
-      @response = response
-      @request_params = request_params
+      marshal_load([response, request_params])
+    end
+
+    def marshal_load(x)
+      @response, @request_params = x
       parse_response
     end
 
+    def marshal_dump
+      [@response, @request_params]
+    end
+
     def parse_response
       @response.keys.each { |ea| parse_attr(ea) }
     end

data/lib/geonames_api/version.rb

@@ -1,3 +1,3 @@
 module GeoNamesAPI
-  VERSION = Gem::Version.new('0.1.4')
+  VERSION = Gem::Version.new('0.1.5')
 end

data/spec/geonames_api/country_subdivision_spec.rb

@@ -2,26 +2,26 @@ require 'spec_helper'
 
 
 describe GeoNamesAPI::CountrySubdivision do
-  def should_be_sf(result)
-    result.should be_present
-    result.admin_code1.should == 'CA'
-    result.admin_name1.should == 'California'
-    result.country_code.should == 'US'
-    result.country_name.should == 'United States'
+  def expected_sf(result)
+    expect(result).to be_present
+    expect(result.admin_code1).to eq('CA')
+    expect(result.admin_name1).to eq('California')
+    expect(result.country_code).to eq('US')
+    expect(result.country_name).to eq('United States')
   end
 
   describe '::find' do
-    it 'should find one subdivision' do
+    it 'expect to find one subdivision' do
       result = GeoNamesAPI::CountrySubdivision.find(37.8, -122.4)
-      should_be_sf(result)
+      expected_sf(result)
     end
   end
 
   describe '::all' do
-    it 'should find multiple subdivisions' do
+    it 'expect to find multiple subdivisions' do
       result = GeoNamesAPI::CountrySubdivision.all(37.8, -122.4)
-      result.size.should > 0
-      should_be_sf(result.first)
+      expect(result.size).to be > 0
+      expected_sf(result.first)
     end
   end
 end

data/spec/geonames_api/hierarchy_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
 describe GeoNamesAPI::Hierarchy do
-  def should_be_sb(h)
-    h.first.name.should == 'Earth'
-    h.map { |ea| ea.name }.should ==
-      ['Earth', 'North America', 'United States', 'California', 'Santa Barbara County', 'Santa Barbara']
+  def expect_sb(h)
+    expect(h.first.name).to eq('Earth')
+    expect(h.map(&:name)).to match_array(
+      ['Earth', 'North America', 'United States', 'California', 'Santa Barbara County', 'Santa Barbara'])
   end
 
-  def should_be_roma(h)
-    h.map { |ea| ea.name }.should ==
-      ['Terra', 'Europa', 'Italia', 'Lazio', 'Roma', 'Roma', 'Roma']
+  def expect_roma(h)
+    expect(h.map(&:name)).to match_array(
+      ['Terra', 'Europa', 'Italia', 'Lazio', 'Roma', 'Roma', 'Roma'])
   end
 
   describe '::find' do
     it 'works for Santa Barbara' do
       h = GeoNamesAPI::Hierarchy.find(5392952)
-      should_be_sb(h)
+      expect_sb(h)
     end
 
     it 'works for Roma ' do
       begin
         GeoNamesAPI.lang = :it
         h = GeoNamesAPI::Hierarchy.find(3169070)
-        should_be_roma(h)
+        expect_roma(h)
       ensure
         GeoNamesAPI.lang = :en
       end
@@ -32,7 +32,7 @@ describe GeoNamesAPI::Hierarchy do
   describe '::where' do
     it 'works for Santa Barbara' do
       h = GeoNamesAPI::Hierarchy.where(geonameId: 5392952)
-      should_be_sb(h)
+      expect_sb(h)
     end
   end
 end

data/spec/geonames_api/marshalling_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'pathname'
+
+describe GeoNamesAPI::Entity do
+  let(:filename) do
+    (Pathname.new(__FILE__).parent + "place.ser").realdirpath
+  end
+
+  class TestPlace < GeoNamesAPI::ListEndpoint
+    METHOD = "findNearbyJSON"
+    FIND_PARAMS = %w(lat lng radius maxRows)
+  end
+
+  def ensure_place_exists
+    unless filename.exist?
+      puts "Sorry, #{filename} didn't exist yet. Run this test again."
+      place = TestPlace.find(lat: 37.8018, lng: -122.3971, radius: 0.25)
+      filename.open('wb') { |io| Marshal.dump(place, io) }
+    end
+  end
+
+  # NOTE: if these fail, try deleting place.ser and re-running the spec.
+  it 'round-trips when an Entity has not been loaded yet' do
+    ensure_place_exists
+    obj = Marshal.load(filename.open('rb'))
+    expect(obj).to respond_to(:geoname_id)
+    expect(obj).to respond_to(:country_code)
+    expect(obj).to respond_to(:lat)
+    expect(obj).to respond_to(:lng)
+    expect(obj).to be_a(TestPlace)
+
+    expect(obj.geoname_id).to eq(5382567)
+    expect(obj.country_code).to eq('US')
+    expect(obj.lat).to be_within(0.001).of(37.8018)
+    expect(obj.lng).to be_within(0.001).of(-122.3971)
+  end
+end

data/spec/geonames_api/nearest_intersection_spec.rb

@@ -13,8 +13,8 @@ describe GeoNamesAPI::NearestIntersection do
       it 'returns the two street names of the nearest intersection' do
         response = described_class.find(latitude,longitude)
         
-        response.intersection["street1"].should eq('Bertrand St')
-        response.intersection["street2"].should eq('N 11th St')
+        expect(response.intersection["street1"]).to eq('Bertrand St')
+        expect(response.intersection["street2"]).to eq('N 11th St')
       end
     end
   end

data/spec/geonames_api/neighbourhood_spec.rb

@@ -2,13 +2,14 @@ require 'spec_helper'
 
 describe GeoNamesAPI::Neighbourhood do
   describe "::find" do
-    it "should find NYC" do
+    it "expect to find NYC" do
       result = GeoNamesAPI::Neighbourhood.find(lat: 40.78343, lng: -73.96625)
-      result.hierarchy.should == ["United States", "New York", "New York County", "New York City-Manhattan", "Central Park"]
+      expect(result.hierarchy).to match_array(
+        ["United States", "New York", "New York County", "New York City-Manhattan", "Central Park"])
     end
 
-    it "should not find streets outside of the US" do
-      proc { GeoNamesAPI::Neighbourhood.find(0, 0) }.should raise_error GeoNamesAPI::Error
+    it "expect to not find streets outside of the US" do
+      expect { GeoNamesAPI::Neighbourhood.find(0, 0) }.to raise_error GeoNamesAPI::Error
     end
   end
 end

data/spec/geonames_api/place_name_spec.rb

@@ -2,21 +2,21 @@ require 'spec_helper'
 
 describe GeoNamesAPI::PlaceName do
   describe "::find" do
-    it "should find one place" do
+    it "expect to find one place" do
       result = GeoNamesAPI::PlaceName.find("50.01","10.2")
-      result.should be_present
+      expect(result).to be_present
     end
 
-     it 'should find one place with a hash' do
+     it 'expect to find one place with a hash' do
       result = GeoNamesAPI::PlaceName.find(lat: 50.01, lng: 10.2)
-      result.should be_present
+      expect(result).to be_present
     end
   end
 
   describe "::all" do
-    it "should find maxRow places in 100km radius" do
+    it "expect to find maxRow places in 100km radius" do
       result = GeoNamesAPI::PlaceName.all("50.01","10.2","100", "3")
-      result.count.should == 3
+      expect(result.size).to eq(3)
     end
   end
 end

data/spec/geonames_api/place_search_spec.rb

@@ -2,61 +2,61 @@ require 'spec_helper'
 
 describe GeoNamesAPI::PlaceSearch do
   describe "::where" do
-    it "should search for places dealing with ohio" do
+    it "expect to search for places dealing with ohio" do
       search = GeoNamesAPI::PlaceSearch.where(name: 'idaho', maxRows: 10)
-      search.should be_present
-      search.size.should == 10
-      search.results.size.should == 10
+      expect(search).to be_present
+      expect(search.size).to eq(10)
+      expect(search.results.size).to eq(10)
     end
   end
 
   describe "::find_by_place_name" do
-    it "should find the place by name" do
+    it "expect to find the place by name" do
       search = GeoNamesAPI::PlaceSearch.find_by_place_name("idaho", 10)
-      search.total_results_count.should > 0
-      search.results.each{|place| place.name.should =~ /idaho/i }
+      expect(search.total_results_count).to be > 10
+      search.results.each{|place| expect(place.name).to match(/idaho/i) }
     end
   end
 
   describe "::find_by_exact_place_name" do
-    it "should find the place by the exact name" do
+    it "expect to find the place by the exact name" do
       search = GeoNamesAPI::PlaceSearch.find_by_exact_place_name('columbus', 10)
-      search.total_results_count.should > 0
-      search.results.each{|place| place.name.downcase.should == 'columbus' }
+      expect(search.total_results_count).to be > 0
+      search.results.each{|place| expect(place.name.downcase).to eq('columbus') }
     end
   end
 
   describe "#next_page" do
-    it "should grab the next page of results from the same search" do
+    it "expect to grab the next page of results from the same search" do
       page_size = 3
       big_search = GeoNamesAPI::PlaceSearch.where(name: 'goleta', maxRows: page_size * 4)
       search_pg1 = GeoNamesAPI::PlaceSearch.where(name: 'goleta', maxRows: page_size)
-      search_pg1.size.should == page_size
+      expect(search_pg1.size).to eq(page_size)
 
       search_pg2 = search_pg1.next_page
-      search_pg2.size.should == page_size
-      search_pg2.request_params[:startRow].should == page_size
+      expect(search_pg2.size).to eq(page_size)
+      expect(search_pg2.request_params[:startRow]).to eq(page_size)
 
       search_pg3 = search_pg2.next_page
-      search_pg3.request_params[:startRow].should == page_size * 2
-      search_pg3.size.should == page_size
+      expect(search_pg3.request_params[:startRow]).to eq(page_size * 2)
+      expect(search_pg3.size).to eq(page_size)
 
       # Ordering isn't always deterministic, so we're just looking for an overlap bigger than 1 page size:
       expected_ids = big_search.results.map { |ea| ea.geoname_id }
       paged_ids = (search_pg1.results + search_pg2.results + search_pg3.results).map { |ea| ea.geoname_id }
       matching_ids = paged_ids & expected_ids
       if matching_ids.size <= page_size
-        # use .should just to render a nice error message:
-        paged_ids.should =~ matching_ids
+        # use expect.to just to render a nice error message:
+        expect(paged_ids).to match(matching_ids)
       end
     end
   end
 
   describe "#to_page" do
-    it "should set startRow appropriately" do
+    it "expect to set startRow appropriately" do
       search2 = GeoNamesAPI::PlaceSearch.all("columbus", 2)
       page4 = search2.to_page(4)
-      page4.request_params[:startRow].should == 8
+      expect(page4.request_params[:startRow]).to eq(8)
     end
   end
 end

data/spec/geonames_api/place_spec.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 describe GeoNamesAPI::Place do
   describe "::find" do
-    it "should find one place" do
+    it "expect to find one place" do
       result = GeoNamesAPI::Place.find("50.01","10.2")
-      result.should be_present
+      expect(result).to be_present
     end
   end
 
   describe "::all" do
-    it "should find multiple places in 100km radius" do
+    it "expect to find multiple places in 100km radius" do
       result = GeoNamesAPI::Place.all("50.01","10.2","100")
-      result.size.should > 0
+      expect(result.size).to be > 0
     end
   end
 end

data/spec/geonames_api/retry_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe GeoNamesAPI::Base do
   describe "retries" do
     before :each do
-      GeoNamesAPI.stub(:max_sleep_time_between_retries).and_return(0)
+      allow(GeoNamesAPI).to receive(:max_sleep_time_between_retries).and_return(0)
       @timeout = JSON.load <<-JSON
         {
           "status": {
@@ -19,17 +19,17 @@ describe GeoNamesAPI::Base do
     end
 
     it "retries when geonames returns timeout errors" do
-      GeoNamesAPI::Hierarchy.stub(:make_request).and_return(@timeout, @response)
+      allow(GeoNamesAPI::Hierarchy).to receive(:make_request).and_return(@timeout, @response)
       hierarchy = GeoNamesAPI::Hierarchy.find(6295630)
       earth = hierarchy.first
-      earth.should be_present
-      earth.name.should == "Earth"
+      expect(earth).to be_present
+      expect(earth.name).to eq("Earth")
     end
 
     it "fails when geonames returns timeout errors too many times" do
-      GeoNamesAPI::Hierarchy.stub(:make_request).and_return(@timeout, @timeout, @response)
-      GeoNamesAPI.stub(:retries).and_return(1)
-      proc { GeoNamesAPI::Hierarchy.find(6295630) }.should raise_error GeoNamesAPI::Timeout
+      allow(GeoNamesAPI::Hierarchy).to receive(:make_request).and_return(@timeout, @timeout, @response)
+      allow(GeoNamesAPI).to receive(:retries).and_return(1)
+      expect { GeoNamesAPI::Hierarchy.find(6295630) }.to raise_error GeoNamesAPI::Timeout
     end
   end
 end

data/spec/geonames_api/street_spec.rb

@@ -2,21 +2,21 @@ require 'spec_helper'
 
 describe GeoNamesAPI::Street do
   describe "::find" do
-    it "should find one Street" do
+    it "expect to find one Street" do
       result = GeoNamesAPI::Street.find(37.451, -122.18)
-      result.should be_present
+      expect(result).to be_present
     end
 
-    it "should not find streets outside of the US" do
+    it "expect to not find streets outside of the US" do
       result = GeoNamesAPI::Street.find(50.01, 10.2)
-      result.should == nil
+      expect(result).to be_nil
     end
   end
 
   describe "::all" do
-    it "should find multiple Streets in 100km radius" do
+    it "expect to find multiple Streets in 100km radius" do
       result = GeoNamesAPI::Street.all(37.8, -122.4, 1, 3)
-      result.size.should == 3
+      expect(result.size).to eq(3)
     end
   end
 end

data/spec/geonames_api/weather_icao_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe GeoNamesAPI::WeatherICAO do
   describe "::find" do
-    it "should find one station" do
+    it "expect to find one station" do
       result = GeoNamesAPI::WeatherICAO.find('KHAF')
-      result.should be_present
+      expect(result).to be_present
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geonames_api
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Sean Devine
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2014-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -130,8 +130,10 @@ files:
 - spec/geonames_api/country_spec.rb
 - spec/geonames_api/country_subdivision_spec.rb
 - spec/geonames_api/hierarchy_spec.rb
+- spec/geonames_api/marshalling_spec.rb
 - spec/geonames_api/nearest_intersection_spec.rb
 - spec/geonames_api/neighbourhood_spec.rb
+- spec/geonames_api/place.ser
 - spec/geonames_api/place_name_spec.rb
 - spec/geonames_api/place_search_spec.rb
 - spec/geonames_api/place_spec.rb
@@ -170,8 +172,10 @@ test_files:
 - spec/geonames_api/country_spec.rb
 - spec/geonames_api/country_subdivision_spec.rb
 - spec/geonames_api/hierarchy_spec.rb
+- spec/geonames_api/marshalling_spec.rb
 - spec/geonames_api/nearest_intersection_spec.rb
 - spec/geonames_api/neighbourhood_spec.rb
+- spec/geonames_api/place.ser
 - spec/geonames_api/place_name_spec.rb
 - spec/geonames_api/place_search_spec.rb
 - spec/geonames_api/place_spec.rb
@@ -179,3 +183,4 @@ test_files:
 - spec/geonames_api/street_spec.rb
 - spec/geonames_api/weather_icao_spec.rb
 - spec/spec_helper.rb
+has_rdoc: