geogov 0.0.10 → 0.0.11

data/lib/geogov/geo_stack.rb

@@ -7,28 +7,29 @@ module Geogov
     def initialize(&block)
       if block_given?
         yield self
+        raise ArgumentError, "fuzzy point required" unless fuzzy_point
       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)
+      if lat && lon
+        return FuzzyPoint.new(lat, lon, :point)
       end
 
-      if self.postcode
+      if 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)
+          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
+        country_centre = Geogov.centre_of_country(country)
         if country_centre
-          return FuzzyPoint.new(country_centre["lat"],country_centre["lon"],:country)
+          return FuzzyPoint.new(country_centre["lat"], country_centre["lon"],:country)
         end
       end
 
@@ -37,38 +38,31 @@ module Geogov
 
     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
+      new { |gs|
+        gs.country = remote_location['country'] if remote_location
         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
+      new { |gs| gs.set_fields hash }
     end
 
     def to_hash
       {
-        :fuzzy_point => self.fuzzy_point.to_hash,
-        :postcode => self.postcode,
-        :council => self.council,
-        :ward => self.ward,
-        :friendly_name => self.friendly_name,
-        :nation => self.nation
-      }#.select {|k,v| !(v.nil?) }
+        :fuzzy_point   => fuzzy_point.to_hash,
+        :postcode      => postcode,
+        :council       => council,
+        :ward          => ward,
+        :friendly_name => friendly_name,
+        :nation        => nation
+      }
     end
 
     def update(hash)
-      self.class.new() do |empty|
+      self.class.new do |empty|
         full_postcode = hash['postcode']
-        empty.set_fields(hash)
+        empty.set_fields hash
         if has_valid_lat_lon(hash)
           empty.fetch_missing_fields_for_coords(hash['lat'], hash['lon'])
         elsif full_postcode
@@ -77,55 +71,73 @@ module Geogov
         empty.fuzzy_point = empty.calculate_fuzzy_point
       end
     end
-    
+
     def friendly_name
       @friendly_name ||= build_locality
     end
 
-    def has_authority?( type )
-      get_authority(type) ? true : false
-    end
-
-    def get_authority( type )
-      return false if self.authorities[type.upcase.to_sym] == true
-      self.authorities.nil? or self.authorities[type.upcase.to_sym].nil? ? false : self.authorities[type.upcase.to_sym]
-    end
-
-    def formatted_authority_name( type ) 
-      return false unless has_authority?(type)
-      name = get_authority(type)['name'].dup
-
-      name.sub!(/ *((District Council|Borough Council|Community|County Council|City Council|Council) ?)+/,'')
-      name.sub!(/ (North|East|South|West|Central)$/,'')
-      name.sub!(/Mid /,'')
-
-      name
-    end
+    def get_authority(type)
+      authorities[type.upcase.to_sym]
+    end
+
+    def formatted_authority_name(type)
+      authority = get_authority(type) or return type
+      authority["name"].gsub(%r{
+        \s*((((District|Borough|County|City)\s|)Council|Community)\s?)+ |
+        \s(North|East|South|West|Central)$ |
+        Mid\s
+      }x, "")
+    end
+
+    # Key to the three-letter abbreviations
+    # CTY | County
+    # CED | County Electoral Division
+    # DIS | District
+    # DIW | District Ward
+    # EUR | European Region
+    # GLA | Greater London Authority
+    # LAC | Greater London Authority Assembly Constituency
+    # LBR | London Borough
+    # LBW | London Borough Ward
+    # MTD | Metropolitan District
+    # MTW | Metropolitan District Ward
+    # SPE | Scottish Parliament Electoral Region
+    # SPC | Scottish Parliament Constituency
+    # UTA | Unitary Authority
+    # UTE | Unitary Authority Electoral Division
+    # UTW | Unitary Authority Ward
+    # WAE | Welsh Assembly Electoral Region
+    # WAC | Welsh Assembly Constituency
+    # WMC | Westminster Constituency
+    # LGW | NI Ward
+    # LGD | NI Council
+    # LGE | NI Electoral Area
+    # NIE | NI Assembly Constituency
+    # NIA | NI Assembly
+
+    LOCALITY_KEYS = [
+      [:LBO],       # London (special case)
+      [:DIS, :CTY],
+      [:CPC, :UTA], # Cornwall civil parishes
+      [:UTE, :UTA],
+      [:UTW, :UTA],
+      [:MTW, :MTD],
+      [:LGW, :LGD]
+    ]
 
     def build_locality
-      return false unless self.authorities
-
-      case
-        when has_authority?('DIS') && has_authority?('CTY')
-          locality = ['DIS','CTY']
-        when has_authority?('LBO')
-          locality = ['LBO','London']
-        when has_authority?('UTA') && has_authority?('CPC') # for cornwall civil parishes
-          locality = ['CPC','UTA']
-        when has_authority?('UTA') && has_authority?('UTE')
-          locality = ['UTE','UTA']
-        when has_authority?('UTA') && has_authority?('UTW')
-          locality = ['UTW','UTA']       
-        when has_authority?('MTW') && has_authority?('MTD')
-          locality = ['MTW','MTD']
-        else
-          return false
-      end
-      locality.map {|t| formatted_authority_name(t) || t }.uniq.join(', ') 
+      return false unless authorities
+      selected_keys = LOCALITY_KEYS.find { |t|
+        (t - authorities.keys).none?
+      } or return false
+
+      parts = selected_keys.map { |a| formatted_authority_name(a) }
+      parts << "London" if selected_keys == [:LBO]
+      parts.uniq.join(", ")
     end
 
     def has_valid_lat_lon(hash)
-      return (hash['lon'] and hash['lat'] and hash['lon'] != "" and hash['lat'] != "")
+      %w[ lat lon ].none? { |k| hash[k].to_s.empty? }
     end
 
     def fetch_missing_fields_for_postcode(postcode)
@@ -134,30 +146,29 @@ module Geogov
         fields = Geogov.areas_for_stack_from_postcode(postcode)
         if fields
           lat_lon = fields[:point]
-          set_fields(fields.select {|k,v| k != :point})
+          set_fields fields.select { |k,v| k != :point }
         end
       end
     end
-   
+
+    UK_NATIONS = ['England', 'Scotland', 'Northern Ireland', 'Wales']
+
     def fetch_missing_fields_for_coords(lat, lon)
       fields = Geogov.areas_for_stack_from_coords(lat, lon)
-      if ['England', 'Scotland', 'Northern Ireland', 'Wales'].include?(fields[:nation])
+      if UK_NATIONS.include?(fields[:nation])
         self.country = 'UK'
-        set_fields(fields.select {|k,v| k != :point})
+        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
+        setter = "#{geo.to_s}=".to_sym
+        if respond_to?(setter)
+          self.send(setter, value) unless value == ""
         else
-          self.authorities ||= { }
+          self.authorities ||= {}
           self.authorities[geo] = value
-          # raise ArgumentError, "geo type '#{geo}' is not a valid geo type"
         end
       end
       self
@@ -165,7 +176,7 @@ module Geogov
 
     def fuzzy_point=(point)
       if point.is_a?(Hash)
-        @fuzzy_point = FuzzyPoint.new(point["lat"],point["lon"],point["accuracy"])
+        @fuzzy_point = FuzzyPoint.new(point["lat"], point["lon"], point["accuracy"])
       else
         @fuzzy_point = point
       end
@@ -176,7 +187,7 @@ module Geogov
 
     def postcode=(postcode)
       if (matches = (postcode.match(POSTCODE_REGEXP) || postcode.match(SECTOR_POSTCODE_REGEXP)))
-        @postcode = matches[1]+" "+matches[2]
+        @postcode = [matches[1], matches[2]].join(" ")
       end
     end
   end

data/lib/geogov/providers/dracos_gazetteer.rb

@@ -1,5 +1,5 @@
 module Geogov
-  class DracosGazetteer 
+  class DracosGazetteer
       def initialize(default_url = "http://gazetteer.dracos.vm.bytemark.co.uk")
           @base = default_url
       end
@@ -13,7 +13,7 @@ module Geogov
           return nil
         end
       end
-     
+
 
   end
 end

data/lib/geogov/providers/google.rb

@@ -1,10 +1,10 @@
 module Geogov
 
   class Google
-    
+
     def dimension(l1,l2)
       "#{l1}x#{l2}"
-    end    
+    end
 
     def location(l1,l2)
       "#{l1},#{l2}"
@@ -19,9 +19,9 @@ module Geogov
       }
       if options[:marker_lat] && options[:marker_lon]
         location = location(options[:marker_lat],options[:marker_lon])
-        g_options[:markers] = ["color:blue",location].join("|") 
+        g_options[:markers] = ["color:blue",location].join("|")
       end
-      
+
       params = Geogov.hash_to_params(g_options)
 
       "http://maps.google.com/maps/api/staticmap?#{params}"
@@ -32,11 +32,11 @@ module Geogov
       g_options = {
         :z => options[:z] || 14,
         :ie => "UTF8",
-        :q  => location(lat,lon)  
+        :q  => location(lat,lon)
       }
       if options[:marker_lat] && options[:marker_lon]
         location = location(options[:marker_lat],options[:marker_lon])
-        g_options[:sll] = location 
+        g_options[:sll] = location
       end
 
       params = Geogov.hash_to_params(g_options)

data/lib/geogov/providers/hostip.rb

@@ -8,7 +8,7 @@ module Geogov
     end
 
     def remote_location(ip_address)
-      params = {:ip => ip_address, :position => true} 
+      params = {:ip => ip_address, :position => true}
       results = Geogov.get(@url + "?" + Geogov.hash_to_params(params))
       return nil if results.nil?
       response = YAML.load(results + "\n")
@@ -21,7 +21,7 @@ module Geogov
       end
       return nil if location['city'] =~ /Unknown City/
       return nil if location['city'] =~ /Private Address/
-      
+
       # I found these very unreliable, so better they're
       # not there to tempt anyone
       location.delete("city")

data/lib/geogov/providers/mapit.rb

@@ -64,11 +64,11 @@ module Geogov
       query = self.point("4326", [lon, lat])
       results = {:point => {'lat' => lat, 'lon' => lon}}
       councils = { }
-      
+
       query.each do |id, area_info|
         type = area_info['type'].upcase.to_sym
         level = translate_area_type_to_shortcut(area_info['type'])
-        
+
         if level
           level = level.downcase.to_sym
           results[level] = [] unless results[level]
@@ -77,11 +77,11 @@ module Geogov
           results[level] << level_info
           results[:nation] = area_info['country_name'] if results[:nation].nil?
         end
-        
+
         councils[type] = { 'name' => area_info['name'], 'type' => area_info['type'], 'id' => area_info['id'] }
       end
 
-      return councils.merge results 
+      return councils.merge results
     end
 
     def areas_for_stack_from_postcode(postcode)
@@ -93,7 +93,7 @@ module Geogov
         query['areas'].each do |i, area|
           type = area['type'].to_sym
           results[type] = area
-        end 
+        end
 
         query['shortcuts'].each do |typ, i|
           if i.is_a? Hash

data/lib/geogov/providers/open_street_map.rb

@@ -16,12 +16,12 @@ module Geogov
         :lon => long,
         :show => 1
       }.merge(options)
-      
+
       if options[:marker_lat] && options[:marker_lon]
         options[:mlat0] = options.delete(:marker_lat)
         options[:mlon0] = options.delete(:marker_lon)
       end
-      
+
       params = Geogov.hash_to_params(options)
 
       "#{@url}/StaticMap?#{params}"
@@ -34,12 +34,12 @@ module Geogov
         :lon => long,
         :layers => "M"
       }.merge(options)
-      
+
       if options[:marker_lat] && options[:marker_lon]
         options[:mlat0] = options.delete(:marker_lat)
         options[:mlon0] = options.delete(:marker_lon)
       end
-      
+
       params = Geogov.hash_to_params(options)
 
       "http://www.openstreetmap.org/?#{params}"

data/lib/geogov/utils.rb

@@ -2,7 +2,7 @@ require 'json'
 require 'net/http'
 
 module Geogov
-  
+
   def get(url)
     url = URI.parse(url) unless url.is_a? URI
     response = Net::HTTP.start(url.host, url.port) { |http|
@@ -31,7 +31,7 @@ module Geogov
     class LruCache
 
       def initialize(size = 100)
-        @size = size 
+        @size = size
         @bucket1 = {}
         @bucket2 = {}
       end
@@ -67,14 +67,14 @@ module Geogov
     class SimpleCache
       def initialize(delegate)
         @delegate = delegate
-        @cache = LruCache.new(1000) 
+        @cache = LruCache.new(1000)
       end
 
       def method_missing(m, *args)
         arg_key = args.inspect
         cache_key = "#{m}--#{arg_key}"
         if @cache[cache_key]
-          return @cache[cache_key] 
+          return @cache[cache_key]
         else
           result = @delegate.send(m,*args)
           @cache[cache_key] = result
@@ -82,6 +82,6 @@ module Geogov
         end
       end
     end
-  
+
 
 end

data/test/geogov_test.rb

@@ -75,35 +75,49 @@ class GovspeakTest < Test::Unit::TestCase
 
   test "stack with postcode returns correct locality" do
     stack = Geogov::GeoStack.new
-    stack = stack.update( 'postcode' => "SW1A 1AA" )
+    stack = stack.update('postcode' => "SW1A 1AA")
 
     assert_equal "Westminster, London", stack.friendly_name
   end
-  
+
+  test "stack with Belfast postcode returns correct locality" do
+    stack = Geogov::GeoStack.new
+    stack = stack.update('postcode' => "BT2 8BP")
+
+    assert_equal "Shaftesbury, Belfast", stack.friendly_name
+  end
+
+  test "stack with non-Belfast Northern Ireland postcode returns correct locality" do
+    stack = Geogov::GeoStack.new
+    stack = stack.update('postcode' => "BT35 6AZ")
+
+    assert_equal "Ballybot, Newry and Mourne", stack.friendly_name
+  end
+
   test "stack with coordinates returns correct locality" do
     stack = Geogov::GeoStack.new
-    stack = stack.update( 'lat' => "51.501009", "lon" => "-0.1415870" )
+    stack = stack.update('lat' => "51.501009", "lon" => "-0.1415870")
 
     assert_equal "Westminster, London", stack.friendly_name
   end
 
   test "stack with postcode returns authorities" do
     stack = Geogov::GeoStack.new
-    stack = stack.update( 'postcode' => "SW1A 1AA" )
+    stack = stack.update('postcode' => "SW1A 1AA")
 
     assert stack.authorities.any?
   end
 
   test "stack with coordinates returns authorities" do
     stack = Geogov::GeoStack.new
-    stack = stack.update( 'lat' => "51.501009", "lon" => "-0.1415870" )
+    stack = stack.update('lat' => "51.501009", "lon" => "-0.1415870")
 
     assert stack.authorities.any?
   end
 
   test "stack with postcode returns correct locality, ward and council" do
     stack = Geogov::GeoStack.new
-    stack = stack.update( 'postcode' => "SW1A 1AA" )
+    stack = stack.update('postcode' => "SW1A 1AA")
 
     assert_equal "Westminster, London", stack.friendly_name
     assert stack.ward and stack.ward.any?
@@ -113,7 +127,7 @@ class GovspeakTest < Test::Unit::TestCase
 
   test "stack with coordinates returns correct locality, ward and council" do
     stack = Geogov::GeoStack.new
-    stack = stack.update( 'lat' => "51.501009", "lon" => "-0.1415870" )
+    stack = stack.update('lat' => "51.501009", "lon" => "-0.1415870")
 
     assert_equal "Westminster, London", stack.friendly_name
     assert stack.ward and stack.ward.any?
@@ -121,4 +135,4 @@ class GovspeakTest < Test::Unit::TestCase
     assert_equal "Westminster City Council", stack.council.first['name']
   end
 
-end
+end

data/test/test_helper.rb

@@ -1,4 +1,5 @@
-$:.unshift(File.expand_path("../lib")) unless $:.include?(File.expand_path("../lib"))
+lib = File.expand_path("../../lib", __FILE__)
+$:.unshift lib unless $:.include?(lib)
 
 require 'test/unit'
 require 'mocha'
@@ -10,7 +11,7 @@ class Test::Unit::TestCase
      clean_name = name.gsub(/\s+/,'_')
      method = "test_#{clean_name.gsub(/\s+/,'_')}".to_sym
      already_defined = instance_method(method) rescue false
-     raise "#{method} exists" if already_defined   
+     raise "#{method} exists" if already_defined
      define_method(method, &block)
     end
   end

metadata

@@ -1,98 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: geogov
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.11
   prerelease: 
-  version: 0.0.10
 platform: ruby
-authors: 
+authors:
 - Ben Griffiths
 - James Stewart
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-04-13 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &15045680 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.9.0
   type: :development
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: *15045680
+- !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &15045200 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.9.0
   type: :development
   prerelease: false
-  version_requirements: *id002
+  version_requirements: *15045200
 description: Geolocation and utilities for UK Government single domain
-email: 
+email:
 - ben@alphagov.co.uk
 - jystewart@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- lib/geogov.rb
+- lib/geogov/utils.rb
 - lib/geogov/fuzzy_point.rb
-- lib/geogov/geo_stack.rb
-- lib/geogov/providers/dracos_gazetteer.rb
-- lib/geogov/providers/geonames.rb
-- lib/geogov/providers/google.rb
 - lib/geogov/providers/hostip.rb
+- lib/geogov/providers/dracos_gazetteer.rb
 - lib/geogov/providers/mapit.rb
+- lib/geogov/providers/google.rb
+- lib/geogov/providers/geonames.rb
 - lib/geogov/providers/open_street_map.rb
-- lib/geogov/utils.rb
-- lib/geogov.rb
+- lib/geogov/geo_stack.rb
 - Gemfile
 - Rakefile
-- test/geogov_test.rb
 - test/test_helper.rb
+- test/geogov_test.rb
 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: 4469512638868208598
-      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: 4469512638868208598
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.12
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Geolocation and utilities for UK Government single domain
-test_files: 
-- test/geogov_test.rb
+test_files:
 - test/test_helper.rb
+- test/geogov_test.rb
+has_rdoc: