osgb 0.2.0 → 0.3.0

data/README.markdown

@@ -0,0 +1,51 @@
+# OSGB
+
+Osgb is a library that converts between British (and Irish) grid references and latitude and longitude co-ordinates. It is theoretically precise to about 1m, which is to say it's good for WGS84 and most GPS use but not up to surveying with ITRS or ETRS89. So don't do that.
+
+## 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
+
+## Status
+
+Early days: activerecord interface hasn't settled down, some refactoring likely, bugs entirely possible. The basic algorithms are ancient and sound, though.
+
+## Usage
+
+You don't need to make any explicit reference to the gem. It adds conversion methods to the String class:
+
+    "SD28687846".is_gridref?                # -> true
+    "SD28687846".to_latlng                  # -> [54.196763, -3.093320]
+    "SD28687846".to_wgs84                   # -> [54.196915, -3.094684]
+    "1.056789, 55.98978607".is_latlng?      # -> true
+
+and provides some (tentative) 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. 
+
+## Bugs and features
+
+[Github issues](http://github.com/spanner/osgb/issues) please, or for little things an email or github message is fine.
+
+## Author & Copyright
+
+Copyright 2008-2011 Will at spanner.org.
+
+Released under the same terms as Ruby

data/lib/osgb.rb

@@ -2,6 +2,7 @@ require 'osgb/angle_conversions'              # converts degrees to radians and
 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/point'                          # versatile coordinate pair
 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
@@ -21,6 +22,14 @@ Osgb::Projection.new :utm29, :scale => 0.9996, :phi0 => 0, :lambda0 => -9, :e0 =
 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.
+# the Helmert matrices used to translate from osgb36 to wgs84 and vice versa
 
-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
+Osgb::Helmert.new :osgb36_to_wgs84, :tx => 446.448, :ty => -125.157, :tz => 542.060, :rx => 0.1502, :ry => 0.2470, :rz => 0.8421, :s => -20.4894
+Osgb::Helmert.new :wgs84_to_osgb36, :tx => -446.448, :ty => 125.157, :tz => -542.060, :rx => -0.1502, :ry => -0.2470, :rz => -0.8421, :s => 20.4894
+
+# Housekeeping
+
+module Osgb
+  class TransformationError < StandardError; end
+  class ConfigurationError < StandardError; end
+end

data/lib/osgb/gridref.rb

@@ -4,22 +4,29 @@ module Osgb
   # with help from CPAN module Geography::NationalGrid by and (c) P Kent
 
   class Gridref
-    OsTiles = {
+    
+    # maps OS letter codes onto their coordinates in the master grid
+    OS_TILES = {
       :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.
+    
+    # the offset makes all coordinates positive and <1000km
+    FALSE_ORIGIN = {:e => 2, :n => 1}
+    
+    # a shorter grid ref denotes a larger square
+    SQUARE_SIZE = [nil, 10000, 1000, 100, 10, 1]    
 
-    attr_accessor :gridref, :projection, :ellipsoid, :datum, :options, :precision
+    attr_accessor :gridref, :projection, :ellipsoid, :options, :precision
 
+    @@default_datum = :osgb36
     @@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
+      :precision => 6,      # decimal places in the output lat/long
     }
     
     class << self
@@ -27,7 +34,7 @@ module Osgb
         @@iteration_ceiling
       end
     end
-  
+
     def initialize(string, options={})
       raise ArgumentError, "invalid grid reference string '#{string}'." unless string.is_gridref?
       options = @@defaults.merge(options)
@@ -48,16 +55,16 @@ module Osgb
     end
   
     def resolution
-      digits.length / 2
+      @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]
+        major = OS_TILES[tile[0,1].downcase.to_sym ]
+        minor = OS_TILES[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])
+          :e => (500000 * (major[0] - FALSE_ORIGIN[:e])) + (100000 * minor[0]),
+          :n => (500000 * (major[1] - FALSE_ORIGIN[:n])) + (100000 * minor[1])
         }
       else
         { :e => 0, :n => 0 }
@@ -65,40 +72,40 @@ module Osgb
     end
   
     def easting
-      @east ||= offsets[:e] + digits[0, resolution].to_i * SquareSize[resolution]
+      @east ||= offsets[:e] + digits[0, resolution].to_i * SQUARE_SIZE[resolution]
     end
   
     def northing
-      @north ||= offsets[:n] + digits[resolution, resolution].to_i * SquareSize[resolution]
+      @north ||= offsets[:n] + digits[resolution, resolution].to_i * SQUARE_SIZE[resolution]
     end
   
-    def lat
-      round(coordinates[:lat].to_degrees)
+    def lat(datum=nil)
+      to_latlng(datum).lat
     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
+    def lng(datum=nil)
+      to_latlng(datum).lng
     end
   
     def to_s
       gridref.to_s
     end
   
-    def to_latlng
-      [lat, lng]
+    # Returns an Osgb::Point corresponding to this grid reference and lying on the specified datum.
+    # We default to WGS84 since that is the representation most likely to be useful.
+    #
+    def to_latlng(datum=nil)
+      datum ||= :wgs84
+      point.transform_to(datum)
     end
 
-    def coordinates
-      unless @coordinates
+  private
+
+    # Returns an Osgb::Point corresponding to this grid reference. Since it is not yet transformed,
+    # the point will lie on the native OSGB36 datum. 
+    #
+    def point
+      unless @point
         # variable names correspond roughly to symbols in the OS algorithm, lowercased:
         # n0 = northing of true origin 
         # e0 = easting of true origin 
@@ -168,27 +175,10 @@ module Osgb
         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}
+        @point = Osgb::Point.new(phi.to_degrees, lambda.to_degrees, :osgb36, precision)
       end
-      @coordinates
+      @point
     end
-    
-  private
 
     def sec(radians)
       1 / Math.cos(radians)

data/lib/osgb/helmert.rb

@@ -25,7 +25,7 @@ module Osgb
       zp = tz - x*ry + y*rx + z*s1
       [xp, yp, zp]
     end
-  
+    
     def self.[](name)
       @@instances[name]
     end

data/lib/osgb/point.rb

@@ -0,0 +1,114 @@
+module Osgb
+  class Point
+    # A coordinate pair on a specified ellipsoid, 
+    # easy to use either in string or array context
+    # and able to perform basic distance and equivalence. 
+    # calculations.
+    
+    attr_writer :lat, :lng
+    attr_accessor :datum, :precision
+    
+    # Usage: 
+    #     Osgb::Point.new(lat[float], lng[float], datum[symbol], precision[integer])
+    #
+    # Default datum is :osgb36. For most web use you will be using WGS84 points, since
+    # that's the standard for most GPS applications and used by google maps:
+    #
+    #    Osgb::Point.new(54.196915, -3.094684, :wgs84)
+    #    Osgb::Point.new(54.196763, -3.093320).transform_to(:wgs84)
+    #
+    def initialize(lat, lng, datum=nil, precision=nil)
+      @lat = lat.to_f
+      @lng = lng.to_f
+      @datum = datum || :osgb36
+      @precision = precision || 6
+    end
+    
+    # Returns the latitude of the point, rounded to the specified precision
+    #
+    def lat
+      round(@lat)
+    end
+    
+    # Returns the longitude of the point, rounded to the specified precision
+    #
+    def lng
+      round(@lng)
+    end
+    
+    # Returns true if the coordinates are both specified and within the acceptable range.
+    #
+    def valid?
+      lat && lng && lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180
+    end
+    
+    # Returns the point as a "lat,lng" string.
+    def to_s
+      "#{lat},#{lng}"
+    end
+    
+    # Returns the point as a [lat,lng] array.
+    def to_a
+      [lat, lng]
+    end
+    
+    # Remaps the point onto another datum. If you're turning OS grid references into GPS coordinates you 
+    # have to remap from OSGB36 to WGS84:
+    #
+    #    point = "SD28687846".to_latlng.transform_to(:wgs84)
+    #
+    # or more concisely:
+    #
+    #    point = "SD28687846".to_wgs84
+    #
+    def transform_to(target_datum)
+      return self if datum == target_datum
+      if helmert = Osgb::Helmert[:"#{self.datum}_to_#{target_datum}"]
+        cartesian_coordinates = Osgb::Ellipsoid[self.datum].polar_to_cartesian(@lat.to_radians,@lng.to_radians)
+        transformed = helmert.transform(*cartesian_coordinates)
+        phi, lambda = Osgb::Ellipsoid[target_datum].cartesian_to_polar(*transformed)
+        self.class.new(phi.to_degrees, lambda.to_degrees, target_datum, precision)
+      else
+        raise Osgb::TransformationError, "Missing helmert transformation for #{self.datum} to #{target_datum}"
+      end
+    end
+
+    # Tests the equivalence of two points, however they are specified. 
+    # If given two Point objects, they can lie on different datums:
+    #
+    #    Osgb::Point.new(54.196763, -3.093320, :osgb36) == Osgb::Point.new(54.196915, -3.094684, :wgs84)  # -> true
+    #
+    # When comparing a point with a string or array representation they are assumed 
+    # to lie on the same datum:
+    #
+    #    Osgb::Point.new(54.196763, -3.093320) == "54.196763, -3.093320"   # -> true
+    #    Osgb::Point.new(54.196763, -3.093320) == [54.196763, -3.093320]   # -> true
+    #    Osgb::Point.new(54.196763, -3.093320) == "SD28687846"             # -> true
+    #
+    # Two points with different precisions will not be considered equivalent.
+    #
+    def ==(other)
+      case other
+      when Osgb::Point
+        other = other.transform_to(self.datum) unless other.datum == self.datum
+        self.lat == other.lat && self.lng == other.lng && self.datum == other.datum
+      when Array
+        self.to_a == other
+      when String
+        self == other.to_latlng(:datum => self.datum) # serves to normalise string representation
+      end
+    end
+
+  private
+  
+    def round(value) #:nodoc:
+      if value.method(:round).arity == 0
+        multiplier = 10**precision
+        (value * multiplier).round.to_f / multiplier
+      else
+        value.round(precision)
+      end
+    end
+  
+  end
+end

data/lib/osgb/string_conversions.rb

@@ -1,41 +1,135 @@
 class String
+  # Defines a few methods to make the grid reference machinery easily 
+  # accessible from string objects.
+
+  # Returns true if the string is a valid grid reference: that is, it consits 
+  # of two valid square-designation  letters then 4, 6, 8 or 10 digits. 
+  # Invalid, malformed and just plain not a grid reference will all return
+  # false.
+  #
   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
 
+  # Returns true if the string looks like a grid reference, whether or
+  # not it is well-formed or valid on the ground. In validation this may allow 
+  # you to distinguish between mistaken and irrelevant input.
+  #
+  # "HD123456".resembles_gridref?       # -> true
+  # "HD123456".is_gridref?              # -> false
+  # "SD12345".resembles_gridref?        # -> true
+  # "SD12345".is_gridref?               # -> false
+  # "WC1 1AA".resembles_gridref?        # -> false
+  #
+  def resembles_gridref?
+    !!(self.upcase =~ /^\w\w\d{2,}/)
+  end
+
+  # Returns true if the string can be decomposed into a valid lat/long 
+  # co-ordinate pair.
+  #
   def is_latlng?
+    coordinates && coordinates.valid?
+  end
+
+  # Returns true if the string can be decomposed into a co-ordinate pair,
+  # regardless of whether the coordinates are valid.
+  #
+  def resembles_latlng?
     !!coordinates
   end
 
-  def coordinates
-    if matches = self.match(/(-?\d+\.\d+)[,\s]+(-?\d+\.\d+)/)
-      matches[1,2]
+  # Treats the string as a coordinate pair, if that can be done. Any two
+  # decimal numbers, positive or negative, separated by any non-digit (and 
+  # non -) characters are acceptable.
+  #
+  #     "54.196763, -3.093320".coordinates      # -> [54.196763, -3.093320]
+  #
+  def coordinates(datum=:osgb36, options={})
+    if matches = self.match(/(-?\d+\.\d+)[^\d\-]+(-?\d+\.\d+)/)
+      lat,lng = matches[1,2]
+      Osgb::Point.new(lat, lng, datum, options[:precision])
     else
       nil
     end
   end
-  
+
+  # If the string is a valid grid reference, this returns the lat/long point 
+  # using the specified or default datum. Default is WGS84 for GPS compatibility.
+  #
   def to_latlng(options={})
     if is_gridref?
-      Osgb::Gridref.new(self, options).to_latlng
+      Osgb::Gridref.new(self, options).to_latlng(options[:datum])
     else
-      self.coordinates
+      self.coordinates(options[:datum])
     end
   end
   
+  # Returns the grid reference as a lat/long pair on the specified or default datum, 
+  # raising an exception if it is not valid.
+  #
+  def to_latlng!(options={})
+    with_validity_check { to_latlng(options) }
+  end
+  
+  # If the string is a valid grid reference, this returns the coordinate pair 
+  # using the OSGB36 datum, which is the native representation for grid references.
+  #
+  def to_osgb36(options={})
+    if is_gridref?
+      Osgb::Gridref.new(self, options).to_latlng(:osgb36)
+    else
+      self.coordinates(:osgb36, options)
+    end
+  end
+
+  # Returns the grid reference as a lat/long pair on OSGB36, raising an exception
+  # if it is not valid.
+  #
+  def to_osgb36!(options={})
+    with_validity_check { to_osgb36(options) }
+  end
+
+  # If the string is a valid grid reference, this returns the coordinate pair 
+  # using the WGS84 datum, which is the most suitable representation for work
+  # with GPS or google maps.
+  #
   def to_wgs84(options={})
     if is_gridref?
-      Osgb::Gridref.new(self, options.merge(:datum => :wgs84)).to_latlng
+      Osgb::Gridref.new(self, options).to_latlng(:wgs84)
     else
-      self.coordinates
+      self.coordinates(:wgs84, options)
     end
   end
   
+  # Returns the grid reference as a lat/long pair on WGS84, raising an exception
+  # if it is not valid.
+  #
+  def to_wgs84!(options={})
+    with_validity_check { to_wgs84(options) }
+  end
+
+  # Returns the latitude component of the string, however it can be found. Works 
+  # for both coordinate pairs and grid references. Defaults to WGS84 if coming from 
+  # a grid reference.
+  #
   def lat(options={})
-    to_latlng({:datum => :wgs84}.merge(options))[0]
+    to_latlng(options).lat
   end
   
+  # Returns the longitude component of the string, however it can be found. Works 
+  # for both coordinate pairs and grid references. Defaults to WGS84 if coming from 
+  # a grid reference.
+  #
   def lng(options={})
-    to_latlng({:datum => :wgs84}.merge(options))[1]
-  end  
+    to_latlng(options).lng
+  end 
+  
+protected
+
+  def with_validity_check(&block)
+    raise Osgb::TransformationError unless is_gridref?
+    block.call
+  end
+
 end

data/spec/point_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Osgb::Point do
+  
+  let(:osgb) { Osgb::Point.new(54.196763, -3.093320, :osgb36) }
+  let(:wgs) { Osgb::Point.new(54.196915, -3.094684, :wgs84) }
+  
+  it "should have lat and long" do
+    wgs.lat.should == 54.196915
+    wgs.lng.should == -3.094684
+  end
+  
+  it "should be good at equality" do
+    (wgs == [54.196915, -3.094684]).should be_true
+    (wgs == "54.196915,-3.094684").should be_true
+    (wgs == "54.196915,  -3.094684").should be_true
+    (wgs == "SD28687846").should be_true
+    (wgs == "SD13241324").should be_false
+    (wgs == osgb).should be_true
+    (wgs == Osgb::Point.new(54.196914, -3.094684)).should be_false
+  end
+  
+  it "should be good at helmert transformations" do
+    osgb.transform_to(:wgs84).should == wgs
+  end
+end

data/spec/string_spec.rb

@@ -2,26 +2,54 @@ 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
+    "SD28687846".resembles_gridref?.should be_true
+    "SD1324132".resembles_gridref?.should be_true
+    "catapult".resembles_gridref?.should be_false
+  end
+
+  it "should know whether or not it is a grid reference" do
+    "SD28687846".is_gridref?.should be_true
+    "SD1324132".is_gridref?.should be_false
     "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
+    "SD28687846".resembles_latlng?.should be_false
+    "catapult".resembles_latlng?.should be_false
+    "54.196915 -3.094684".resembles_latlng?.should be_true
+    "54.196915, -3.094684".resembles_latlng?.should be_true
+  end
+
+  it "should know whether or not it is a lat/lng pair" do
+    "SD28687846".is_latlng?.should be_false
     "catapult".is_latlng?.should be_false
     "54.196915 -3.094684".is_latlng?.should be_true
+    "104.196915 -3.094684".is_latlng?.should be_false
+    "54.196915 -183.094684".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
+    "54.196915x-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]
+    "SD28687846".to_osgb36(:precision => 6).to_a.should == [54.196763, -3.093320]
+    "SD28687846".to_osgb36(:precision => 6).to_s.should == "54.196763,-3.09332"
+    "SD28687846".to_osgb36(:precision => 2).to_a.should == [54.2, -3.09]
+  end
+
+  it "should turn be able to turn itself into a wgs84 lat/lng pair" do
+    "SD28687846".to_wgs84(:precision => 6).to_a.should == [54.196915, -3.094684]
+    "SD28687846".to_wgs84(:precision => 2).to_a.should == [54.2, -3.09]
+  end
+
+  it "should default to WGS84 representation" do
+    "SD28687846".to_latlng(:precision => 6).to_a.should == [54.196915, -3.094684]
   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]
+  it "should blow up if banged" do
+    lambda { "SD28687846".to_latlng!(:precision => 6) }.should_not raise_error
+    lambda { "SD2868784".to_latlng!(:precision => 6) }.should raise_error(Osgb::TransformationError)
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: osgb
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - William Ross
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-24 00:00:00 Z
+date: 2011-11-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -63,17 +63,19 @@ files:
 - lib/osgb/gridref.rb
 - lib/osgb/has_gridref.rb
 - lib/osgb/helmert.rb
+- lib/osgb/point.rb
 - lib/osgb/projection.rb
 - lib/osgb/railtie.rb
 - lib/osgb/string_conversions.rb
 - lib/osgb.rb
+- spec/point_spec.rb
 - spec/spec_helper.rb
 - spec/string_spec.rb
 - CHANGELOG.rdoc
 - Gemfile
 - LICENSE
 - Rakefile
-- README.md
+- README.markdown
 - init.rb
 homepage: http://github.com/spanner/osgb
 licenses: []

data/README.md

@@ -1,51 +0,0 @@
-= 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.