geogov 0.0.1 → 0.0.3

data/lib/geogov.rb

@@ -13,9 +13,14 @@ require 'geogov/providers/dracos_gazetteer'
 module Geogov
 
   def self.provider_for(method, instance)
+    unless instance.respond_to?(method)
+      raise ArgumentError.new("#{instance.class} doesn't respond to #{method}")
+    end
+    
     caching_instance = SimpleCache.new(instance)
     @@methods ||= {}
     @@methods[method] = caching_instance
+    
     unless self.methods().include?(method)
       dispatcher = <<-EOS
         def #{method}(*args, &block)               

data/lib/geogov/geo_stack.rb

@@ -1,140 +1,141 @@
 module Geogov
   class GeoStack
 
-   attr_accessor :postcode,:ward,:council,:nation,:country,:wmc,:lat,:lon
-   attr_accessor :fuzzy_point
-   attr_accessor :friendly_name
-
-   def initialize()
-     yield self
-   end
-
-   def calculate_fuzzy_point
-     if self.lat and self.lon
-       return FuzzyPoint.new(self.lat, self.lon, :point)
-     end
+    attr_accessor :ward, :council, :nation, :country, :wmc, :lat, :lon, :friendly_name
+    attr_reader :postcode, :fuzzy_point
+
+    def initialize(&block)
+      if block_given?
+        yield self
+      else
+        self.fuzzy_point = calculate_fuzzy_point
+      end
+    end
+
+    def calculate_fuzzy_point
+      if self.lat and self.lon
+        return FuzzyPoint.new(self.lat, self.lon, :point)
+      end
      
-     if self.postcode
-       district = postcode.split(" ")[0]
-       district_centre = Geogov.centre_of_district(district)
-       if district_centre
-         return FuzzyPoint.new(district_centre["lat"],district_centre["lon"],:postcode_district)
-       end
-     end
-
-     if self.country
-       country_centre = Geogov.centre_of_country(self.country)
-       if country_centre
-         return FuzzyPoint.new(country_centre["lat"],country_centre["lon"],:country)
-       end
-     end
-
-     FuzzyPoint.new(0,0,:planet)
-   end
-
-   def self.new_from_ip(ip_address)
-     remote_location = Geogov.remote_location(ip_address)
-     new() do |gs|
-       if remote_location
-         gs.country = remote_location['country']
-       end
-       gs.fuzzy_point = gs.calculate_fuzzy_point
-     end
-   end
-
-   def self.new_from_hash(hash)
-     new() do |gs|
-       gs.set_fields(hash)
-       unless hash['fuzzy_point']
-         raise ArgumentError, "fuzzy point required"
-       end
-     end
-   end
-
-   def to_hash
-     {
-       :fuzzy_point => self.fuzzy_point.to_hash,
-       :postcode => self.postcode,
-       :ward => self.ward,
-       :council => self.council,
-       :nation => self.nation,
-       :country => self.country,
-       :wmc => self.wmc,
-       :friendly_name => self.friendly_name
-     }.select {|k,v| !(v.nil?) }
-   end
-
-   def update(hash)
-     self.class.new() do |empty|
-       full_postcode = hash['postcode']
-       empty.set_fields(hash)
-       if has_valid_lat_lon(hash) 
-         empty.fetch_missing_fields_for_coords(hash['lat'], hash['lon'])
-       elsif full_postcode
-         empty.fetch_missing_fields_for_postcode(full_postcode)
-       end
-       empty.fuzzy_point = empty.calculate_fuzzy_point
-     end
-   end
-
-   def has_valid_lat_lon(hash)
+      if self.postcode
+        district = postcode.split(" ")[0]
+        district_centre = Geogov.centre_of_district(district)
+        if district_centre
+          return FuzzyPoint.new(district_centre["lat"],district_centre["lon"],:postcode_district)
+        end
+      end
+
+      if self.country
+        country_centre = Geogov.centre_of_country(self.country)
+        if country_centre
+          return FuzzyPoint.new(country_centre["lat"],country_centre["lon"],:country)
+        end
+      end
+
+      FuzzyPoint.new(0,0,:planet)
+    end
+
+    def self.new_from_ip(ip_address)
+      remote_location = Geogov.remote_location(ip_address)
+      new() do |gs|
+        if remote_location
+          gs.country = remote_location['country']
+        end
+        gs.fuzzy_point = gs.calculate_fuzzy_point
+      end
+    end
+
+    def self.new_from_hash(hash)
+      new() do |gs|
+        gs.set_fields(hash)
+        unless hash['fuzzy_point']
+          raise ArgumentError, "fuzzy point required"
+        end
+      end
+    end
+
+    def to_hash
+      {
+        :fuzzy_point => self.fuzzy_point.to_hash,
+        :postcode => self.postcode,
+        :ward => self.ward,
+        :council => self.council,
+        :nation => self.nation,
+        :country => self.country,
+        :wmc => self.wmc,
+        :friendly_name => self.friendly_name
+      }.select {|k,v| !(v.nil?) }
+    end
+
+    def update(hash)
+      self.class.new() do |empty|
+        full_postcode = hash['postcode']
+        empty.set_fields(hash)
+        if has_valid_lat_lon(hash)
+          empty.fetch_missing_fields_for_coords(hash['lat'], hash['lon'])
+        elsif full_postcode
+          empty.fetch_missing_fields_for_postcode(full_postcode)
+        end
+        empty.fuzzy_point = empty.calculate_fuzzy_point
+      end
+    end
+
+    def has_valid_lat_lon(hash)
       return (hash['lon'] and hash['lat'] and hash['lon'] != "" and hash['lat'] != "")
-   end
-
-   def fetch_missing_fields_for_postcode(postcode)
-     if matches = postcode.match(POSTCODE_REGEXP)
-       self.country = "UK"
-       fields = Geogov.areas_for_stack_from_postcode(postcode)
-       if fields
-         lat_lon = fields[:point]
-         if lat_lon
-           self.friendly_name = Geogov.nearest_place_name(lat_lon['lat'],lat_lon['lon'])
-         end
-         set_fields(fields.select {|k,v| k != :point})
-       end
-     end
-   end
+    end
+
+    def fetch_missing_fields_for_postcode(postcode)
+      if matches = postcode.match(POSTCODE_REGEXP)
+        self.country = "UK"
+        fields = Geogov.areas_for_stack_from_postcode(postcode)
+        if fields
+          lat_lon = fields[:point]
+          if lat_lon
+            self.friendly_name = Geogov.nearest_place_name(lat_lon['lat'],lat_lon['lon'])
+          end
+          set_fields(fields.select {|k,v| k != :point})
+        end
+      end
+    end
    
-   def fetch_missing_fields_for_coords(lat, lon)
-     self.friendly_name = Geogov.nearest_place_name(lat, lon)
-     fields = Geogov.areas_for_stack_from_coords(lat, lon)
-     if ['England', 'Scotland', 'Northern Ireland', 'Wales'].include?(fields[:nation])
-       self.country = 'UK'
-       set_fields(fields.select {|k,v| k != :point})
-     end
-   end
-
-   def set_fields(hash)
-     hash.each do |geo, value|
-       setter = (geo.to_s+"=").to_sym
-       if self.respond_to?(setter)
-         unless value == ""
-           self.send(setter,value)
-         end
-       else
-         raise ArgumentError, "geo type '#{geo}' is not a valid geo type"
-       end
-     end
-     self
-   end
-
-   def fuzzy_point=(point)
-     if point.is_a?(Hash)
-       @fuzzy_point = FuzzyPoint.new(point["lat"],point["lon"],point["accuracy"])
-     else
-       @fuzzy_point = point
-     end
-   end
-
-   POSTCODE_REGEXP = /^([A-Z]{1,2}[0-9R][0-9A-Z]?)\s*([0-9])[ABD-HJLNP-UW-Z]{2}(:?\s+)?$/i
-   SECTOR_POSTCODE_REGEXP =  /^([A-Z]{1,2}[0-9R][0-9A-Z]?)\s*([0-9])(:?\s+)?$/i
-
-   def postcode=(postcode)
-     if (matches = (postcode.match(POSTCODE_REGEXP) || postcode.match(SECTOR_POSTCODE_REGEXP)))
-       @postcode = matches[1]+" "+matches[2]
-     end
-   end
-
-
- end
-end
+    def fetch_missing_fields_for_coords(lat, lon)
+      self.friendly_name = Geogov.nearest_place_name(lat, lon)
+      fields = Geogov.areas_for_stack_from_coords(lat, lon)
+      if ['England', 'Scotland', 'Northern Ireland', 'Wales'].include?(fields[:nation])
+        self.country = 'UK'
+        set_fields(fields.select {|k,v| k != :point})
+      end
+    end
+
+    def set_fields(hash)
+      hash.each do |geo, value|
+        setter = (geo.to_s+"=").to_sym
+        if self.respond_to?(setter)
+          unless value == ""
+            self.send(setter,value)
+          end
+        else
+          raise ArgumentError, "geo type '#{geo}' is not a valid geo type"
+        end
+      end
+      self
+    end
+
+    def fuzzy_point=(point)
+      if point.is_a?(Hash)
+        @fuzzy_point = FuzzyPoint.new(point["lat"],point["lon"],point["accuracy"])
+      else
+        @fuzzy_point = point
+      end
+    end
+
+    POSTCODE_REGEXP = /^([A-Z]{1,2}[0-9R][0-9A-Z]?)\s*([0-9])[ABD-HJLNP-UW-Z]{2}(:?\s+)?$/i
+    SECTOR_POSTCODE_REGEXP =  /^([A-Z]{1,2}[0-9R][0-9A-Z]?)\s*([0-9])(:?\s+)?$/i
+
+    def postcode=(postcode)
+      if (matches = (postcode.match(POSTCODE_REGEXP) || postcode.match(SECTOR_POSTCODE_REGEXP)))
+        @postcode = matches[1]+" "+matches[2]
+      end
+    end
+  end
+end

data/lib/geogov/providers/mapit.rb

@@ -20,6 +20,7 @@ module Geogov
         }
         url_path = "#{base_url}#{url}"
         url_path += "/#{params.join("/")}" if params.length > 0
+        url_path += ".json"
         return url_path
       end
 
@@ -39,6 +40,11 @@ module Geogov
     def respond_to?(sym)
       valid_mapit_methods.include?(sym) || super(sym)
     end
+    
+    def lat_lon_from_postcode(postcode)
+      areas = areas_for_stack_from_postcode(postcode)
+      areas[:point]
+    end
    
     # Borrowed heavily from mapit's pylib/postcodes/views.py with some amendments based on
     # pylib/mapit/areas/models.py
@@ -62,7 +68,9 @@ module Geogov
         if level
           level = level.downcase.to_sym
           results[level] = [] unless results[level]
-          results[level] << area_info.select {|k,v| ["name","id","type"].include?(k) }
+          level_info = area_info.select { |k,v| ["name","id","type"].include?(k) }
+          level_info['ons'] = area_info['codes']['ons'] if area_info['codes'] && area_info['codes']['ons']
+          results[level] << level_info
           results[:nation] = area_info['country_name'] if results[:nation].nil?
         end
       end
@@ -83,7 +91,9 @@ module Geogov
             area_info =  query['areas'][id.to_s]
             level = typ.downcase.to_sym
             results[level] = [] unless results[level]
-            results[level] << area_info.select {|k,v| ["name","id","type"].include?(k) }
+            level_info = area_info.select { |k,v| ["name","id","type"].include?(k) }
+            level_info['ons'] = area_info['codes']['ons'] if area_info['codes'] && area_info['codes']['ons']
+            results[level] << level_info
             results[:nation] = area_info['country_name'] if results[:nation].nil?
           end
         end

data/test/geogov_test.rb

@@ -28,6 +28,14 @@ class GovspeakTest < Test::Unit::TestCase
       assert_equal 0, stack.fuzzy_point.lat
       assert_equal :planet, stack.fuzzy_point.accuracy
     end
+
+  test "raises an exception if provider doesn't support required method" do
+    assert_raises(ArgumentError) { 
+      Geogov.configure do |g|
+        g.provider_for :lat_lon_from_postcode, stub
+      end      
+    }
+  end
   
   test "reconstructed stack rejects unknown params" do
       assert_raises(ArgumentError) { 

data/test/test_helper.rb

@@ -1,9 +1,8 @@
 $:.unshift(File.expand_path("../lib")) unless $:.include?(File.expand_path("../lib"))
 
-require 'bundler'
-Bundler.setup :default, :development, :test
-
 require 'test/unit'
+require 'mocha'
+require 'geogov'
 
 class Test::Unit::TestCase
   class << self
@@ -16,6 +15,3 @@ class Test::Unit::TestCase
     end
   end
 end
-
-require 'mocha'
-require 'geogov'

metadata

@@ -1,81 +1,47 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: geogov
-version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Ben Griffiths
+- James Stewart
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-08 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-12-08 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70342818099700 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 63
-        segments: 
-        - 0
-        - 8
-        - 0
-        version: 0.8.0
+      - !ruby/object:Gem::Version
+        version: 0.9.0
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70342818099700
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70342818099000 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 59
-        segments: 
-        - 0
-        - 9
-        - 0
+      - !ruby/object:Gem::Version
         version: 0.9.0
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
-        version: 2.5.0
-  type: :development
-  version_requirements: *id003
-description: Geolocation and utilities for single domain
-email: 
+  version_requirements: *70342818099000
+description: Geolocation and utilities for UK Government single domain
+email:
 - ben@alphagov.co.uk
+- jystewart@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/geogov/fuzzy_point.rb
 - lib/geogov/geo_stack.rb
 - lib/geogov/providers/dracos_gazetteer.rb
@@ -90,40 +56,30 @@ files:
 - Rakefile
 - test/geogov_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: http://github.com/alphagov/geogov
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Geolocation and utilities for single domain
-test_files: 
+summary: Geolocation and utilities for UK Government single domain
+test_files:
 - test/geogov_test.rb
 - test/test_helper.rb