geo_ip 0.3.2 → 0.4.0

data/lib/geo_ip.rb

@@ -1,12 +1,12 @@
-SERVICE_URL = "http://api.ipinfodb.com/v2/"
-CITY_API    = "ip_query.php"
-COUNTRY_API = "ip_query_country.php"
-IPV4_REGEXP = /\A(?:25[0-5]|(?:2[0-4]|1\d|[1-9])?\d)(?:\.(?:25[0-5]|(?:2[0-4]|1\d|[1-9])?\d)){3}\z/
-
 require 'json'
 require 'rest-client'
 
 class GeoIp
+  SERVICE_URL = 'http://api.ipinfodb.com/v3/ip-'
+  CITY_API    = 'city'
+  COUNTRY_API = 'country'
+  IPV4_REGEXP = /\A(?:25[0-5]|(?:2[0-4]|1\d|[1-9])?\d)(?:\.(?:25[0-5]|(?:2[0-4]|1\d|[1-9])?\d)){3}\z/
+
   @@api_key = nil
   @@timeout = 1
 
@@ -38,33 +38,31 @@ class GeoIp
     def geolocation ip, options={}
       @precision = options[:precision] || :city
       @timezone  = options[:timezone]  || false
-      raise "API key must be set first: GeoIp.api_key = 'YOURKEY'" if self.api_key.nil?
-      raise "Invalid IP address" unless ip.to_s =~ IPV4_REGEXP
-      raise "Invalid precision"  unless [:country, :city].include?(@precision)
-      raise "Invalid timezone"   unless [true, false].include?(@timezone)
-      url = "#{SERVICE_URL}#{@country ? COUNTRY_API : CITY_API}?key=#{self.api_key}&ip=#{ip}&output=json&timezone=#{@timezone}"
-      reply = JSON.parse RestClient::Request.execute(:method => :get, :url => url, :timeout => self.timeout)
-      location = convert_keys reply
+      raise 'API key must be set first: GeoIp.api_key = \'YOURKEY\'' if self.api_key.nil?
+      raise 'Invalid IP address' unless ip.to_s =~ IPV4_REGEXP
+      raise 'Invalid precision'  unless [:country, :city].include?(@precision)
+      raise 'Invalid timezone'   unless [true, false].include?(@timezone)
+      url = "#{SERVICE_URL}#{@precision == :city || @timezone ? CITY_API : COUNTRY_API}?key=#{api_key}&ip=#{ip}&format=json&timezone=#{@timezone}"
+      parsed_response = JSON.parse RestClient::Request.execute(:method => :get, :url => url, :timeout => self.timeout)
+      convert_keys parsed_response
     end
 
     private
     def convert_keys hash
       location = {}
-      location[:ip]                 = hash["Ip"]
-      location[:status]             = hash["Status"]
-      location[:country_code]       = hash["CountryCode"]
-      location[:country_name]       = hash["CountryName"]
+      location[:ip]             = hash['ipAddress']
+      location[:status_code]    = hash['statusCode']
+      location[:status_message] = hash['statusMessage']
+      location[:country_code]   = hash['countryCode']
+      location[:country_name]   = hash['countryName']
       if @precision == :city
-        location[:region_code]      = hash["RegionCode"]
-        location[:region_name]      = hash["RegionName"]
-        location[:city]             = hash["City"]
-        location[:zip_postal_code]  = hash["ZipPostalCode"]
-        location[:latitude]         = hash["Latitude"]
-        location[:longitude]        = hash["Longitude"]
+        location[:region_name]  = hash['regionName']
+        location[:city]         = hash['cityName']
+        location[:zip_code]     = hash['zipCode']
+        location[:latitude]     = hash['latitude']
+        location[:longitude]    = hash['longitude']
         if @timezone
-          location[:timezone_name]  = hash["TimezoneName"]
-          location[:utc_offset]     = hash["Gmtoffset"].to_i
-          location[:dst?]           = hash["Isdst"] ? true : false
+          location[:timezone]   = hash['timeZone']
         end
       end
       location

data/spec/geo_ip_spec.rb

@@ -3,109 +3,100 @@ IP_GOOGLE_US = '209.85.227.104'
 IP_PRIVATE = '10.0.0.1'
 IP_LOCAL = '127.0.0.1'
 
-describe "GeoIp" do
-
+describe 'GeoIp' do
   before :each do
     api_config = YAML.load_file(File.dirname(__FILE__) + '/api.yml')
     GeoIp.api_key = api_config['key']
   end
 
-  context "api_key" do
-    it "should return the API key when set" do
-      GeoIp.api_key = "my_api_key"
-      GeoIp.api_key.should == "my_api_key"
+  context 'api_key' do
+    it 'should return the API key when set' do
+      GeoIp.api_key = 'my_api_key'
+      GeoIp.api_key.should == 'my_api_key'
     end
 
-    it "should throw an error when API key is not set" do
+    it 'should throw an error when API key is not set' do
       GeoIp.api_key = nil
       lambda {GeoIp.geolocation(IP_GOOGLE_US)}.should raise_error
     end
   end
 
-  context "city" do
-    it "should return the correct city for a public ip address" do
+  context 'city' do
+    it 'should return the correct city for a public ip address' do
       geolocation = GeoIp.geolocation(IP_GOOGLE_US)
       geolocation[:country_code].should == 'US'
-      geolocation[:country_name].should == 'United States'
-      geolocation[:city].should         == 'Mountain View'
+      geolocation[:country_name].should == 'UNITED STATES'
+      geolocation[:city].should         == 'MONTEREY PARK'
     end
 
-    it "should return the correct city for a private ip address" do
+    it 'should return nothing city for a private ip address' do
       geolocation = GeoIp.geolocation(IP_PRIVATE)
-      geolocation[:country_code].should == 'RD'
-      geolocation[:country_name].should == 'Reserved'
-      geolocation[:city].should         be_empty
+      geolocation[:country_code].should == '-'
+      geolocation[:country_name].should == '-'
+      geolocation[:city].should         == '-'
     end
 
-    it "should return the correct city for localhost ip address" do
+    it 'should return nothing for localhost ip address' do
       geolocation = GeoIp.geolocation(IP_LOCAL)
-      geolocation[:country_code].should == 'RD'
-      geolocation[:country_name].should == 'Reserved'
-      geolocation[:city].should         be_empty
+      geolocation[:country_code].should == '-'
+      geolocation[:country_name].should == '-'
+      geolocation[:city].should         == '-'
     end
 
-    it "should return the correct city for a public ip address when explicitly requiring it" do
-      geolocation = GeoIp.geolocation(IP_GOOGLE_US, {:precision => :city})
+    it 'should return the correct city for a public ip address when explicitly requiring it' do
+      geolocation = GeoIp.geolocation(IP_GOOGLE_US, :precision => :city)
       geolocation[:country_code].should == 'US'
-      geolocation[:country_name].should == 'United States'
-      geolocation[:city].should         == 'Mountain View'
+      geolocation[:country_name].should == 'UNITED STATES'
+      geolocation[:city].should         == 'MONTEREY PARK'
     end
   end
 
-  context "country" do
-    it "should return the correct country for a public ip address" do
-      geolocation = GeoIp.geolocation(IP_GOOGLE_US, {:precision => :country})
+  context 'country' do
+    it 'should return the correct country for a public ip address' do
+      geolocation = GeoIp.geolocation(IP_GOOGLE_US, :precision => :country)
       geolocation[:country_code].should == 'US'
-      geolocation[:country_name].should == 'United States'
+      geolocation[:country_name].should == 'UNITED STATES'
     end
 
-    it "should return the correct country for a private ip address" do
-      geolocation = GeoIp.geolocation(IP_PRIVATE, {:precision => :country})
-      geolocation[:country_code].should == 'RD'
-      geolocation[:country_name].should == 'Reserved'
+    it 'should return nothing country for a private ip address' do
+      geolocation = GeoIp.geolocation(IP_PRIVATE, :precision => :country)
+      geolocation[:country_code].should == '-'
+      geolocation[:country_name].should == '-'
     end
 
-    it "should return the correct country for localhost ip address" do
-      geolocation = GeoIp.geolocation(IP_LOCAL, {:precision => :country})
-      geolocation[:country_code].should == 'RD'
-      geolocation[:country_name].should == 'Reserved'
+    it 'should return nothing country for localhost ip address' do
+      geolocation = GeoIp.geolocation(IP_LOCAL, :precision => :country)
+      geolocation[:country_code].should == '-'
+      geolocation[:country_name].should == '-'
     end
 
-    it "should not return the city for a public ip address" do
-      geolocation = GeoIp.geolocation(IP_GOOGLE_US, {:precision => :country})
+    it 'should not return the city for a public ip address' do
+      geolocation = GeoIp.geolocation(IP_GOOGLE_US, :precision => :country)
       geolocation[:country_code].should == 'US'
-      geolocation[:country_name].should == 'United States'
+      geolocation[:country_name].should == 'UNITED STATES'
       geolocation[:city].should         be_nil
     end
   end
 
-  context "timezone" do
-    it "should return the correct timezone information for a public ip address" do
-      geolocation = GeoIp.geolocation(IP_GOOGLE_US, {:timezone => true})
-      geolocation[:timezone_name].should == 'America/Los_Angeles'
-      geolocation[:dst?].should_not      be_nil # true if dst?, false if not dst?
-      geolocation[:utc_offset].should    == (geolocation[:dst?] ? -25200 : -28800)
+  context 'timezone' do
+    it 'should return the correct timezone information for a public ip address' do
+      geolocation = GeoIp.geolocation(IP_GOOGLE_US, :timezone => true)
+      geolocation[:timezone].should == '-08:00' # This one is likely to break when dst changes.
     end
 
-    it "should not return the timezone information when explicitly not requesting it" do
-      geolocation = GeoIp.geolocation(IP_GOOGLE_US, {:timezone => false})
-      geolocation[:timezone_name].should be_nil
-      geolocation[:utc_offset].should    be_nil
-      geolocation[:dst?].should          be_nil
+    it 'should not return the timezone information when explicitly not requesting it' do
+      geolocation = GeoIp.geolocation(IP_GOOGLE_US, :timezone => false)
+      geolocation[:timezone].should be_nil
     end
 
-    it "should not return the timezone information when not requesting it" do
+    it 'should not return the timezone information when not requesting it' do
       geolocation = GeoIp.geolocation(IP_GOOGLE_US)
-      geolocation[:timezone_name].should be_nil
-      geolocation[:utc_offset].should    be_nil
-      geolocation[:dst?].should          be_nil
+      geolocation[:timezone].should be_nil
     end
 
-    it "should not return the timezone information when country precision is selected" do
-      geolocation = GeoIp.geolocation(IP_GOOGLE_US, {:precision => :country, :timezone => true})
-      geolocation[:timezone_name].should be_nil
-      geolocation[:utc_offset].should    be_nil
-      geolocation[:dst?].should          be_nil
+    it 'should not return the timezone information when country precision is selected' do
+      geolocation = GeoIp.geolocation(IP_GOOGLE_US, :precision => :country, :timezone => true)
+      geolocation[:timezone].should be_nil
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: geo_ip
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 15
   prerelease: 
   segments: 
   - 0
-  - 3
-  - 2
-  version: 0.3.2
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Jeroen Jacobs
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-20 00:00:00 +02:00
+date: 2011-05-29 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency