osgb 0.2.0

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+0.2.0 (November 4, 2011)
+
+* extracted (and somewhat refactored) from radiant event_map extension

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ryan Bates
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+= OSGB
+
+Wiki[https://github.com/spanner/osgb/wiki] RDocs[http://rdoc.info/projects/spanner/osgb]
+
+Osgb is a library that converts between British (and Irish) grid references and latitude and longitude co-ordinates. It is precise to about 5m, which is to say it's good enough for WGS84 and most GPS use but not local enough for surveying to ETRS89.
+
+== Installation
+
+In <b>Rails 3</b>, add this to your Gemfile and run +bundle install+.
+
+  gem "osgb"
+
+In <b>Rails 2</b>, add this to your environment.rb file.
+
+  config.gem "osgb"
+
+Alternatively, you can install it as a plugin.
+
+  rails plugin install git://github.com/spanner/osgb.git
+
+== Usage
+
+You don't need to make any explicit reference to the gem. It adds conversion methods to the String class:
+
+    "SD12341234".is_gridref?                # -> true
+    "SD12341234".to_latlng                  # -> 
+    "SD12341234".to_WGS84                   # -> 
+    "1.056789, 55.98978607".is_latlng?      # -> true
+    "1.056789, 55.98978607".to_gridref      # -> true
+
+and provides some help for your ActiveRecord classes:
+
+    class Checkpoint < ActiveRecord::Base
+      has_gridref :lat => 'lat', 
+                  :lng => 'lng', 
+                  :gridref => 'gridref',
+                  :validation => false,
+                  :converstion => true
+
+The :lat, :lng and :gridref keys should pass in the names of the relevant columns if they don't match these defaults. 
+
+== Questions or Problems?
+
+If you have any issues with CanCan which you cannot find the solution to in the documentation[https://github.com/ryanb/cancan/wiki], please add an {issue on GitHub}[https://github.com/ryanb/cancan/issues] or fork the project and send a pull request.
+
+To get the specs running you should call +bundle+ and then +rake+. See the {spec/README}[https://github.com/ryanb/cancan/blob/master/spec/README.rdoc] for more information.
+
+
+== Special Thanks
+
+CanCan was inspired by declarative_authorization[https://github.com/stffn/declarative_authorization/] and aegis[https://github.com/makandra/aegis]. Also many thanks to the CanCan contributors[https://github.com/ryanb/cancan/contributors]. See the CHANGELOG[https://github.com/ryanb/cancan/blob/master/CHANGELOG.rdoc] for the full list.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/init.rb

@@ -0,0 +1 @@
+require 'osgb'

data/lib/osgb.rb

@@ -0,0 +1,26 @@
+require 'osgb/angle_conversions'              # converts degrees to radians and back again
+require 'osgb/ellipsoid'                      # standard approximations to the squashed-circle shape of the earth
+require 'osgb/projection'                     # the geometrical distortions required by a map projection
+require 'osgb/helmert'                        # 3d transformation algorithm for mapping between cartesian and ellipsoidal polar coordinates
+require 'osgb/gridref'                        # parse grid references and returns lat/long pairs
+require 'osgb/string_conversions'             # add conversion methods to String
+require 'osgb/railtie' if defined? Rails      # add useful methods to ActiveRecord
+
+# Define standard ellipsoids
+
+Osgb::Ellipsoid.new :osgb36, 6377563.396, 6356256.910
+Osgb::Ellipsoid.new :wgs84, 6378137.000, 6356752.3141
+Osgb::Ellipsoid.new :ie65, 6377340.189, 6356034.447
+Osgb::Ellipsoid.new :utm, 6378388.000, 6356911.946
+
+# Define standard projections
+
+Osgb::Projection.new :gb, :scale => 0.9996012717, :phi0 => 49, :lambda0 => -2, :e0 => 400000, :n0 => -100000, :ellipsoid => :osgb36
+Osgb::Projection.new :ie, :scale => 1.000035, :phi0 => 53.5, :lambda0 => -8, :e0 => 250000, :n0 => 250000, :ellipsoid => :ie65
+Osgb::Projection.new :utm29, :scale => 0.9996, :phi0 => 0, :lambda0 => -9, :e0 => 500000, :n0 => 0, :ellipsoid => :utm
+Osgb::Projection.new :utm30, :scale => 0.9996, :phi0 => 0, :lambda0 => -3, :e0 => 500000, :n0 => 0, :ellipsoid => :utm
+Osgb::Projection.new :utm31, :scale => 0.9996, :phi0 => 0, :lambda0 => 3, :e0 => 500000, :n0 => 0, :ellipsoid => :utm
+
+# the Helmert matrix used to translate to wgs84.
+
+Osgb::Helmert.new :wgs84, :tx => 446.448, :ty => -125.157, :tz => 542.060, :rx => 0.1502, :ry => 0.2470, :rz => 0.8421, :s => -20.4894

data/lib/osgb/angle_conversions.rb

@@ -0,0 +1,9 @@
+class Numeric
+  def to_radians  # presumes self is a number of degrees
+    self * Math::PI / 180 
+  end
+
+  def to_degrees  # presumes self is a number of radians
+    self / (Math::PI / 180)
+  end
+end

data/lib/osgb/ellipsoid.rb

@@ -0,0 +1,56 @@
+module Osgb
+  class Ellipsoid
+    attr_accessor :name, :a, :b
+    @@instances = {}
+
+    def initialize(name, a, b)
+      @name = name
+      @a = a
+      @b = b
+      @@instances[name] = self
+    end
+  
+    def ecc
+      (a**2 - b**2) / (a**2)
+    end
+    
+    def nu_for(phi)
+      a / (Math.sqrt(1 - ecc * Math.sin(phi)**2))
+    end
+    
+    def precision
+      4 / a
+    end
+    
+    def polar_to_cartesian(phi, lambda)
+      h = 0
+      nu = nu_for(phi)
+      x1 = (nu + h) * Math.cos(phi) * Math.cos(lambda)
+      y1 = (nu + h) * Math.cos(phi) * Math.sin(lambda)
+      z1 = ((1 - ecc) * nu + h) * Math.sin(phi)
+      [x1, y1, z1]
+    end
+    
+    def cartesian_to_polar(x,y,z)
+      p = Math.sqrt(x**2 + y**2)
+      phi = Math.atan2(z, p*(1-ecc));
+      phip = 2 * Math::PI
+
+      count = 0
+      while (phi-phip).abs > precision do
+        raise RuntimeError "Helmert transformation has not converged. Discrepancy after #{count} cycles is #{phi-phip}" if count >= Osgb::Gridref.iteration_ceiling
+        nu = a / Math.sqrt(1 - ecc * Math.sin(phi)**2)
+        phip = phi
+        phi = Math.atan2(z + ecc * nu * Math.sin(phi), p)
+        count += 1
+      end 
+
+      lambda = Math.atan2(y, x)
+      [phi, lambda]
+    end
+    
+    def self.[](name)
+      @@instances[name]
+    end
+  end
+end

data/lib/osgb/gridref.rb

@@ -0,0 +1,198 @@
+module Osgb
+  # Implementation derived from the Ordnance Survey guide to coordinate systems in the UK
+  # http://www.ordnancesurvey.co.uk/oswebsite/gps/information/coordinatesystemsinfo/guidecontents/
+  # with help from CPAN module Geography::NationalGrid by and (c) P Kent
+
+  class Gridref
+    OsTiles = {
+      :a => [0,4], :b => [1,4], :c => [2,4], :d => [3,4], :e => [4,4],
+      :f => [0,3], :g => [1,3], :h => [2,3], :j => [3,3], :k => [4,3],
+      :l => [0,2], :m => [1,2], :n => [2,2], :o => [3,2], :p => [4,2],
+      :q => [0,1], :r => [1,1], :s => [2,1], :t => [3,1], :u => [4,1],
+      :v => [0,0], :w => [1,0], :x => [2,0], :y => [3,0], :z => [4,0],
+    }
+    FalseOrigin = {:e => 2, :n => 1}
+    SquareSize = [nil, 10000, 1000, 100, 10, 1]    # shorter grid ref = larger square.
+
+    attr_accessor :gridref, :projection, :ellipsoid, :datum, :options, :precision
+
+    @@iteration_ceiling = 1000
+    @@defaults = {
+      :projection => :gb,   # mercator projection of input gridref. Can be any projection name: usually :ie or :gb
+      :precision => 6       # decimal places in the output lat/long
+    }
+    
+    class << self
+      def iteration_ceiling
+        @@iteration_ceiling
+      end
+    end
+  
+    def initialize(string, options={})
+      raise ArgumentError, "invalid grid reference string '#{string}'." unless string.is_gridref?
+      options = @@defaults.merge(options)
+      @gridref = string.upcase
+      @projection = Osgb::Projection[options[:projection]]
+      @precision = options[:precision]
+      @ellipsoid = @projection.ellipsoid
+      @datum = options[:datum]
+      self
+    end
+        
+    def tile
+      @tile ||= gridref[0,2]
+    end
+  
+    def digits
+      @digits ||= gridref[2,10]
+    end
+  
+    def resolution
+      digits.length / 2
+    end
+  
+    def offsets
+      if tile
+        major = OsTiles[tile[0,1].downcase.to_sym ]
+        minor = OsTiles[tile[1,1].downcase.to_sym]
+        @offset ||= {
+          :e => (500000 * (major[0] - FalseOrigin[:e])) + (100000 * minor[0]),
+          :n => (500000 * (major[1] - FalseOrigin[:n])) + (100000 * minor[1])
+        }
+      else
+        { :e => 0, :n => 0 }
+      end
+    end
+  
+    def easting
+      @east ||= offsets[:e] + digits[0, resolution].to_i * SquareSize[resolution]
+    end
+  
+    def northing
+      @north ||= offsets[:n] + digits[resolution, resolution].to_i * SquareSize[resolution]
+    end
+  
+    def lat
+      round(coordinates[:lat].to_degrees)
+    end
+  
+    def lng
+      round(coordinates[:lng].to_degrees)
+    end
+    
+    def round(value)
+      if value.method(:round).arity == 0
+        multiplier = 10**precision
+        (value * multiplier).round.to_f / multiplier
+      else
+        value.round(precision)
+      end
+    end
+  
+    def to_s
+      gridref.to_s
+    end
+  
+    def to_latlng
+      [lat, lng]
+    end
+
+    def coordinates
+      unless @coordinates
+        # variable names correspond roughly to symbols in the OS algorithm, lowercased:
+        # n0 = northing of true origin 
+        # e0 = easting of true origin 
+        # f0 = scale factor on central meridian
+        # phi0 = latitude of true origin 
+        # lambda0 = longitude of true origin and central meridian.
+        # e2 = eccentricity squared
+        # a = length of polar axis of ellipsoid
+        # b = length of equatorial axis of ellipsoid
+        # ning & eing are the northings and eastings of the supplied gridref
+        # phi and lambda are the discovered latitude and longitude
+      
+        ning = northing
+        eing = easting
+
+        n0 = projection.n0
+        e0 = projection.e0
+        phi0 = projection.phi0
+        l0 = projection.lambda0
+        f0 = projection.scale
+      
+        a = ellipsoid.a
+        b = ellipsoid.b
+        e2 = ellipsoid.ecc
+      
+        # the rest is juste a transliteration of the OS equations
+
+        n = (a - b) / (a + b)
+        m = 0
+        phi = phi0
+    
+        # iterate to within acceptable distance of solution
+      
+        count = 0
+        while ((ning - n0 - m) >= 0.001) do
+          raise RuntimeError "Demercatorising equation has not converged. Discrepancy after #{count} cycles is #{ning - n0 - m}" if count >= @@iteration_ceiling
+
+          phi = ((ning - n0 - m) / (a * f0)) + phi
+          ma = (1 + n + (1.25 * n**2) + (1.25 * n**3)) * (phi - phi0)
+          mb = ((3 * n) + (3 * n**2) + (2.625 * n**3)) * Math.sin(phi - phi0) * Math.cos(phi + phi0)
+          mc = ((1.875 * n**2) + (1.875 * n**3)) * Math.sin(2 * (phi - phi0)) * Math.cos(2 * (phi + phi0))
+          md = (35/24) * (n**3) * Math.sin(3 * (phi - phi0)) * Math.cos(3 * (phi + phi0))
+          m = b * f0 * (ma - mb + mc - md)
+          count += 1
+        end
+      
+        # engage alphabet soup
+      
+        nu = a * f0 * ((1-(e2) * ((Math.sin(phi)**2))) ** -0.5)
+        rho = a * f0 * (1-(e2)) * ((1-(e2)*((Math.sin(phi)**2))) ** -1.5)
+        eta2 = (nu/rho - 1)
+      
+        # fire
+      
+        vii = Math.tan(phi) / (2 * rho * nu)
+        viii = (Math.tan(phi) / (24 * rho * (nu ** 3))) * (5 + (3 * (Math.tan(phi) ** 2)) + eta2 - 9 * eta2 * (Math.tan(phi) ** 2) )
+        ix = (Math.tan(phi) / (720 * rho * (nu ** 5))) * (61 + (90 * (Math.tan(phi) ** 2)) + (45 * (Math.tan(phi) ** 4)) )
+        x = sec(phi) / nu
+        xi = (sec(phi) / (6 * nu ** 3)) * ((nu/rho) + 2 * (Math.tan(phi) ** 2))
+        xii = (sec(phi) / (120 * nu ** 5)) * (5 + (28 * (Math.tan(phi) ** 2)) + (24 * (Math.tan(phi) ** 4)))
+        xiia = (sec(phi) / (5040 * nu ** 7)) * (61 + (662 * (Math.tan(phi) ** 2)) + (1320 * (Math.tan(phi) ** 4)) + (720 * (Math.tan(phi) ** 6)))
+
+        d = eing-e0
+
+        # all of which was just to populate these last two equations:
+      
+        phi = phi - vii*(d**2) + viii*(d**4) - ix*(d**6)
+        lambda = l0 + x*d - xi*(d**3) + xii*(d**5) - xiia*(d**7)
+
+        # phi and lambda are lat and long but note that here we are still in radians and osgb36
+        # if a different output datum is required, the helmert transformation remaps the coordinates onto a new globe
+
+        if datum && datum != :osgb36
+          target_ellipsoid = Osgb::Ellipsoid[datum]
+          
+          if helmert = Osgb::Helmert[datum]
+            cartesian_coordinates = ellipsoid.polar_to_cartesian(phi, lambda)
+            transformed = helmert.transform(*cartesian_coordinates)
+            phi, lambda = target_ellipsoid.cartesian_to_polar(*transformed)
+          else
+            raise RuntimeError, "Missing ellipsoid or helmert transformation for #{datum}"
+          end
+        end
+
+        @coordinates = {:lat => phi, :lng => lambda}
+      end
+      @coordinates
+    end
+    
+  private
+
+    def sec(radians)
+      1 / Math.cos(radians)
+    end
+  
+  end
+end

data/lib/osgb/has_gridref.rb

@@ -0,0 +1,45 @@
+module Osgb
+  module HasGridref
+    def self.included base #:nodoc:
+      base.class_eval {
+        cattr_accessor :osgb_options
+        @@osgb = {}
+        extend Osgb::ClassMethods
+      }
+    end
+  end
+
+  module ClassMethods
+    def has_gridref name, options = {}
+      include Osgb::InstanceMethods
+      osgb_options = {
+        :lat => 'lat',
+        :lng => 'lng',
+        :gridref => 'gridref',
+        :validation => false,
+        :conversion => true
+      }.merge(options)
+      before_validation :convert_between_gridref_and_latlng if osgb_options[:conversion]
+      validates :must_have_location if osgb_options[:validation]
+    end
+  end
+  
+  module InstanceMethods
+    def must_have_location
+      send(cols[:gridref]).is_gridref? || (send("#{cols[:lat]}?") && send("#{cols[:lng]}?"))
+    end
+    
+    def convert_between_gridref_and_latlng
+      cols = self.class.osgb_options
+      if columns.include?(cols[:lat], cols[:lng], cols[:gridref])
+        if send("#{cols[:gridref]}_changed?") || !send("#{cols[:lat]}?") || !send("#{cols[:lng]}?")
+          latlng = gridref.coordinates
+          send("#{cols[:lat]}=", latlng[0])
+          send("#{cols[:lng]}=", latlng[1])
+        elsif send("#{cols[:lat]}_changed?") || send("#{cols[:lng]}_changed?") || !send("#{cols[:gridref]}?")
+          send("#{cols[:gridref]}=", Osgb::Gridref.from(send(cols[:lat]), send(cols[:lng])))
+        end
+      end
+    end
+  end
+end

data/lib/osgb/helmert.rb

@@ -0,0 +1,33 @@
+module Osgb
+  class Helmert
+    attr_accessor :name, :tx, :ty, :tz, :rx, :ry, :rz, :s
+    @@instances = {}
+
+    def initialize(name, attributes)
+      @name = name
+      @tx = attributes[:tx]
+      @ty = attributes[:ty]
+      @tz = attributes[:tz]
+      @rx = (attributes[:rx]/3600).to_radians
+      @ry = (attributes[:ry]/3600).to_radians
+      @rz = (attributes[:rz]/3600).to_radians
+      @s = attributes[:s]
+      @@instances[name] = self
+    end
+    
+    def s1
+      s/1e6 + 1
+    end
+  
+    def transform(x,y,z)
+      xp = tx + x*s1 - y*rz + z*ry
+      yp = ty + x*rz + y*s1 - z*rx
+      zp = tz - x*ry + y*rx + z*s1
+      [xp, yp, zp]
+    end
+  
+    def self.[](name)
+      @@instances[name]
+    end
+  end
+end

data/lib/osgb/projection.rb

@@ -0,0 +1,21 @@
+module Osgb
+  class Projection
+    attr_accessor :name, :scale, :phi0, :lambda0, :e0, :n0, :ellipsoid
+    @@instances = {}
+    
+    def initialize(name, attributes)
+      @name = name
+      @scale = attributes[:scale]
+      @phi0 = attributes[:phi0].to_radians
+      @lambda0 = attributes[:lambda0].to_radians
+      @e0 = attributes[:e0]
+      @n0 = attributes[:n0]
+      @ellipsoid = Osgb::Ellipsoid[attributes[:ellipsoid]]
+      @@instances[name] = self
+    end
+    
+    def self.[](name)
+      @@instances[name]
+    end
+  end
+end

data/lib/osgb/railtie.rb

@@ -0,0 +1,23 @@
+require 'osgb'
+
+module Osgb
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'osgb.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          Osgb::Railtie.insert
+        end
+      end
+      rake_tasks do
+        load "tasks/osgb.rake"
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      ActiveRecord::Base.send(:include, Osgb::HasGridref)
+    end
+  end
+end

data/lib/osgb/string_conversions.rb

@@ -0,0 +1,41 @@
+class String
+  def is_gridref?
+    !!(self.upcase =~ /^(H(P|T|U|Y|Z)|N(A|B|C|D|F|G|H|J|K|L|M|N|O|R|S|T|U|W|X|Y|Z)|OV|S(C|D|E|G|H|J|K|M|N|O|P|R|S|T|U|W|X|Y|Z)|T(A|F|G|L|M|Q|R|V)){1}\d{4}(NE|NW|SE|SW)?$|((H(P|T|U|Y|Z)|N(A|B|C|D|F|G|H|J|K|L|M|N|O|R|S|T|U|W|X|Y|Z)|OV|S(C|D|E|G|H|J|K|M|N|O|P|R|S|T|U|W|X|Y|Z)|T(A|F|G|L|M|Q|R|V)){1}(\d{4}|\d{6}|\d{8}|\d{10}))$/)
+  end
+
+  def is_latlng?
+    !!coordinates
+  end
+
+  def coordinates
+    if matches = self.match(/(-?\d+\.\d+)[,\s]+(-?\d+\.\d+)/)
+      matches[1,2]
+    else
+      nil
+    end
+  end
+  
+  def to_latlng(options={})
+    if is_gridref?
+      Osgb::Gridref.new(self, options).to_latlng
+    else
+      self.coordinates
+    end
+  end
+  
+  def to_wgs84(options={})
+    if is_gridref?
+      Osgb::Gridref.new(self, options.merge(:datum => :wgs84)).to_latlng
+    else
+      self.coordinates
+    end
+  end
+  
+  def lat(options={})
+    to_latlng({:datum => :wgs84}.merge(options))[0]
+  end
+  
+  def lng(options={})
+    to_latlng({:datum => :wgs84}.merge(options))[1]
+  end  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'osgb'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/string_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe String do
+  it "should know whether or not it looks like a grid reference" do
+    "SD13241324".is_gridref?.should be_true
+    "catapult".is_gridref?.should be_false
+    "54.196915 -3.094684".is_gridref?.should be_false
+  end
+
+  it "should know whether or not it looks like a lat/lng pair" do
+    "SD13241324".is_latlng?.should be_false
+    "catapult".is_latlng?.should be_false
+    "54.196915 -3.094684".is_latlng?.should be_true
+    "54.196915, -3.094684".is_latlng?.should be_true
+    "54.196915|-3.094684".is_latlng?.should be_true
+  end
+
+  it "should turn be able to turn itself into an osgb lat/lng pair" do
+    "SD28687846".to_latlng(:precision => 6).should == [54.196763, -3.093320]
+    "SD28687846".to_latlng(:precision => 2).should == [54.2, -3.09]
+  end
+
+  it "should turn be able to turn itself into a wgs84 lat/lng pair for gps use" do
+    "SD28687846".to_wgs84(:precision => 6).should == [54.196915, -3.094684]
+    "SD28687846".to_wgs84(:precision => 2).should == [54.2, -3.09]
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: osgb
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- William Ross
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-24 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 3
+        - 0
+        - 9
+        version: 3.0.9
+  type: :development
+  version_requirements: *id002
+description: Supports the use of Ordnance Survey Grid References in place of lat/lng pairs. Includes activerecord plugin.
+email: will@spanner.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/osgb/angle_conversions.rb
+- lib/osgb/ellipsoid.rb
+- lib/osgb/gridref.rb
+- lib/osgb/has_gridref.rb
+- lib/osgb/helmert.rb
+- lib/osgb/projection.rb
+- lib/osgb/railtie.rb
+- lib/osgb/string_conversions.rb
+- lib/osgb.rb
+- spec/spec_helper.rb
+- spec/string_spec.rb
+- CHANGELOG.rdoc
+- Gemfile
+- LICENSE
+- Rakefile
+- README.md
+- init.rb
+homepage: http://github.com/spanner/osgb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 19
+      segments: 
+      - 1
+      - 3
+      - 4
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Grid reference translation to and from lat/long.
+test_files: []
+