uk_postcode 2.0.0.beta → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fa8f457586bb74272addb1cc2680a90718688c4
-  data.tar.gz: 232794c36025c24b7d9c7051c7bb37d20daa3ba2
+  metadata.gz: 0a919ea202a84289397d9ee28a3cfeb13296c96f
+  data.tar.gz: 61ae6cb187e332087b477335996e91a5f57a6bc5
 SHA512:
-  metadata.gz: 5512f266cbb5ecd1de324af09bb07b0eb0600214a75fbc04c4467eb3887a5fc9363479dde70722161e4f6c9667940bf2baf357ef6001f46e2f97e783e83460ab
-  data.tar.gz: 5631dca91102f422254fad3672836cb92ef54834284b32346eecaf90d90f38fb88ab807b9e84e7d2125d0a58aaf037a8b21b2639a766ae3f643b84207eee179e
+  metadata.gz: aa9f41d0d1b1b9b2793cb6d5075e533f0f7364707b275ec34550ed3f401073de66158f08715ed55a5ac96bde1b12ddd0c9c7e5dd29a4054e0bec885e49f33c6f
+  data.tar.gz: 96ba39a7b24beab30c4a80cbd37ff50f95a6ed2ab6bad84049fc864c8279608140accb6b579cca1084f8e1ab13414e463a7a00389449cc692716449d7244b4ef

data/README.md

@@ -100,6 +100,38 @@ pc.to_s    # => "Not valid"
 pc.country # => :unknown
 ```
 
+## Tips for Rails
+
+You can normalise postcodes on assignment by overriding a setter method (this
+assumes that you have a `postcode` field on the model):
+
+```ruby
+def postcode=(str)
+  super UKPostcode.parse(str).to_s
+end
+```
+
+Invalid postcodes are parsed to instances of `InvalidPostcode`, whose `#to_s`
+method gives the original input, so an invalid postcode will be presented back
+to the user as originally entered.
+
+To validate, use something like this:
+
+```ruby
+class PostcodeValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    ukpc = UKPostcode.parse(value)
+    unless ukpc.valid? && ukpc.full?
+      record.errors[attribute] << "not recognised as a UK postcode"
+    end
+  end
+end
+
+class Address
+  validates :postcode, presence: true, postcode: true
+end
+```
+
 ## For users of version 1.x
 
 The interface has changed significantly, so code that worked with version 1.x

data/lib/uk_postcode/abstract_postcode.rb

@@ -22,11 +22,11 @@ module UKPostcode
     end
 
     def full?
-      false
+      raise NotImplemented
     end
 
     def valid?
-      false
+      raise NotImplemented
     end
 
     def country

data/lib/uk_postcode/invalid_postcode.rb

@@ -2,8 +2,10 @@ require "uk_postcode/abstract_postcode"
 
 module UKPostcode
 
-  # InvalidPostcode is a singleton null object returned by UKPostcode.parse
-  # when it is unable to parse the supplied postcode.
+  # An InvalidPostcode is returned by UKPostcode.parse when it is unable to
+  # parse the supplied postcode. As it returns the input verbatim via #to_s,
+  # it's possible to do UKPostcode.parse(s).to_s and get either a normalised
+  # postcode (if possible) or the original user input.
   #
   # The sub-fields of the postcode (outcode, area, etc.) are all nil.
   #
@@ -22,5 +24,14 @@ module UKPostcode
     def to_s
       @input
     end
+
+    def full?
+      false
+    end
+
+    def valid?
+      false
+    end
+
   end
 end

data/lib/uk_postcode/version.rb

@@ -1,3 +1,3 @@
 module UKPostcode
-  VERSION = "2.0.0.beta"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uk_postcode
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta
+  version: 2.0.0
 platform: ruby
 authors:
 - Paul Battley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-30 00:00:00.000000000 Z
+date: 2015-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 description: Parse, validate, and extract sub-fields from UK postcodes
 email: pbattley@gmail.com
 executables: []
@@ -42,15 +56,6 @@ files:
 - lib/uk_postcode/parser_chain.rb
 - lib/uk_postcode/tree.rb
 - lib/uk_postcode/version.rb
-- test/country_finder_test.rb
-- test/full_postcode_test.rb
-- test/geographic_postcode_test.rb
-- test/giro_postcode_test.rb
-- test/invalid_postcode_test.rb
-- test/special_postcode_test.rb
-- test/test_helper.rb
-- test/tree_test.rb
-- test/uk_postcode_test.rb
 homepage: http://github.com/threedaymonk/uk_postcode
 licenses:
 - MIT
@@ -63,12 +68,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/test/country_finder_test.rb

@@ -1,33 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode"
-
-describe UKPostcode do
-  it 'should find the country of a full postcode in England' do
-    UKPostcode.parse('W1A 1AA').country.must_equal :england
-  end
-
-  it 'should find the country of a full postcode in Scotland' do
-    UKPostcode.parse('EH8 8DX').country.must_equal :scotland
-  end
-
-  it 'should find the country of a full postcode in Wales' do
-    UKPostcode.parse('CF99 1NA').country.must_equal :wales
-  end
-
-  it 'should find the country of a full postcode in Northern Ireland' do
-    UKPostcode.parse('BT4 3XX').country.must_equal :northern_ireland
-  end
-
-  it 'should find the country of a postcode in a border region' do
-    UKPostcode.parse('CA6 5HS').country.must_equal :scotland
-    UKPostcode.parse('CA6 5HT').country.must_equal :england
-  end
-
-  it 'should find the country of an unambiguous partial postcode' do
-    UKPostcode.parse('BT4').country.must_equal :northern_ireland
-  end
-
-  it 'should return :unknown for an ambiguous partial postcode' do
-    UKPostcode.parse('DG16').country.must_equal :unknown
-  end
-end

data/test/full_postcode_test.rb

@@ -1,34 +0,0 @@
-require_relative "./test_helper"
-require "csv"
-require "uk_postcode"
-
-describe "Full set of postcodes" do
-  CSV_PATH = File.expand_path("../data/postcodes.csv", __FILE__)
-
-  COUNTRIES = {
-    'E92000001' => :england,
-    'N92000002' => :northern_ireland,
-    'S92000003' => :scotland,
-    'W92000004' => :wales,
-    'L93000001' => :channel_islands,
-    'M83000003' => :isle_of_man
-  }
-
-  it "should correctly parse and find the country of every extant postcode" do
-    skip "Skipping because SKIP_FULL_TEST was set" if ENV['SKIP_FULL_TEST']
-    skip "Skipping because #{CSV_PATH} does not exist" unless File.exist?(CSV_PATH)
-
-    CSV.foreach(CSV_PATH, headers: [:postcode, :country]) do |row|
-      outcode = row[:postcode][0, 4].strip
-      incode  = row[:postcode][4, 3].strip
-      country = COUNTRIES.fetch(row[:country])
-
-      postcode = UKPostcode.parse(outcode + incode)
-
-      postcode.wont_be_nil
-      postcode.outcode.must_equal outcode
-      postcode.incode.must_equal incode
-      postcode.country.must_equal country
-    end
-  end
-end

data/test/geographic_postcode_test.rb

@@ -1,271 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/geographic_postcode"
-
-describe UKPostcode::GeographicPostcode do
-  described_class = UKPostcode::GeographicPostcode
-
-  describe "parse" do
-    it "should parse a full postcode" do
-      pc = described_class.parse("W1A 1AA")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_equal "1A"
-      pc.sector.must_equal "1"
-      pc.unit.must_equal "AA"
-    end
-
-    it "should parse a postcode with no unit" do
-      pc = described_class.parse("W1A 1")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_equal "1A"
-      pc.sector.must_equal "1"
-      pc.unit.must_be_nil
-    end
-
-    it "should parse an outcode" do
-      pc = described_class.parse("W1A")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_equal "1A"
-      pc.sector.must_be_nil
-      pc.unit.must_be_nil
-    end
-
-    it "should parse an area" do
-      pc = described_class.parse("W")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_be_nil
-      pc.sector.must_be_nil
-      pc.unit.must_be_nil
-    end
-
-    it "should handle extra spaces" do
-      pc = described_class.parse("  W1A   1AA  ")
-      pc.must_be_instance_of described_class
-      pc.to_s.must_equal "W1A 1AA"
-    end
-
-    it "should handle no spaces" do
-      pc = described_class.parse("W1A1AA")
-      pc.must_be_instance_of described_class
-      pc.to_s.must_equal "W1A 1AA"
-    end
-
-    it "should be case-insensitive" do
-      pc = described_class.parse("w1a 1aa")
-      pc.must_be_instance_of described_class
-      pc.to_s.must_equal "W1A 1AA"
-    end
-
-    it "should return nil if unable to parse" do
-      pc = described_class.parse("Can't parse this")
-      pc.must_be_nil
-    end
-
-    describe "single-letter area" do
-      it "should extract area without trailing I from outcode" do
-        pc = described_class.parse("B11")
-        pc.area.must_equal "B"
-        pc.district.must_equal "11"
-      end
-
-      it "should extract area without trailing I from full postcode with space" do
-        pc = described_class.parse("E17 1AA")
-        pc.area.must_equal "E"
-        pc.district.must_equal "17"
-      end
-
-      it "should extract area without trailing I from full postcode without space" do
-        pc = described_class.parse("E171AA")
-        pc.area.must_equal "E"
-        pc.district.must_equal "17"
-      end
-    end
-
-    describe "trailing O in area" do
-      it "should extract area with trailing O from outcode" do
-        pc = described_class.parse("CO1")
-        pc.area.must_equal "CO"
-        pc.district.must_equal "1"
-      end
-
-      it "should extract area with trailing O from full postcode with space" do
-        pc = described_class.parse("CO1 1BT")
-        pc.area.must_equal "CO"
-        pc.district.must_equal "1"
-      end
-
-      it "should extract area with trailing O from full postcode without space" do
-        pc = described_class.parse("CO11BT")
-        pc.area.must_equal "CO"
-        pc.district.must_equal "1"
-      end
-    end
-
-    describe "tricky postcodes" do
-      it "should parse B11 1LL" do
-        pc = described_class.parse("B111LL")
-        pc.area.must_equal "B"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "LL"
-      end
-
-      it "should parse BII ILL" do
-        pc = described_class.parse("BIIILL")
-        pc.area.must_equal "B"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "LL"
-      end
-
-      it "should parse BB11 1DJ" do
-        pc = described_class.parse("BB111DJ")
-        pc.area.must_equal "BB"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "DJ"
-      end
-
-      it "should parse BBII IDJ" do
-        pc = described_class.parse("BBIIIDJ")
-        pc.area.must_equal "BB"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "DJ"
-      end
-
-      it "should parse B10 0JP" do
-        pc = described_class.parse("B100JP")
-        pc.area.must_equal "B"
-        pc.district.must_equal "10"
-        pc.sector.must_equal "0"
-        pc.unit.must_equal "JP"
-      end
-
-      it "should parse BIO OJP" do
-        pc = described_class.parse("BIOOJP")
-        pc.area.must_equal "B"
-        pc.district.must_equal "10"
-        pc.sector.must_equal "0"
-        pc.unit.must_equal "JP"
-      end
-    end
-  end
-
-  describe "area" do
-    it "should be capitalised" do
-      described_class.new("w", "1a", "1", "aa").area.must_equal "W"
-    end
-
-    it "should correct 0 to O" do
-      described_class.new("0X", "1", "0", "AB").area.must_equal "OX"
-    end
-
-    it "should correct 1 to I" do
-      described_class.new("1G", "1", "1", "AA").area.must_equal "IG"
-    end
-  end
-
-  describe "district" do
-    it "should be capitalised" do
-      described_class.new("w", "1a", "1", "aa").district.must_equal "1A"
-    end
-
-    it "should correct O to 0" do
-      described_class.new("B", "2O", "2", "XB").district.must_equal "20"
-    end
-
-    it "should correct I to 1" do
-      described_class.new("B", "I", "I", "DF").district.must_equal "1"
-    end
-  end
-
-  describe "sector" do
-    it "should correct O to 0" do
-      described_class.new("AB", "1", "O", "DN").sector.must_equal "0"
-    end
-
-    it "should correct I to 1" do
-      described_class.new("W", "1A", "I", "AA").sector.must_equal "1"
-    end
-  end
-
-  describe "unit" do
-    it "should be capitalised" do
-      described_class.new("w", "1a", "1", "aa").unit.must_equal "AA"
-    end
-
-    # Note: neither I nor O appear in units
-  end
-
-  describe "outcode" do
-    it "should be generated from area and district" do
-      described_class.new("W", "1A").outcode.must_equal "W1A"
-    end
-
-    it "should be nil if missing district" do
-      described_class.new("W").outcode.must_be_nil
-    end
-  end
-
-  describe "incode" do
-    it "should be generated from sector and unit" do
-      described_class.new("W", "1A", "1", "AA").incode.must_equal "1AA"
-    end
-
-    it "should be nil if missing sector" do
-      described_class.new("W", "1A").incode.must_be_nil
-    end
-
-    it "should be nil if missing unit" do
-      described_class.new("W", "1A", "1").incode.must_be_nil
-    end
-  end
-
-  describe "to_s" do
-    it "should generate a full postcode" do
-      described_class.new("W", "1A", "1", "AA").to_s.must_equal "W1A 1AA"
-    end
-
-    it "should generate an outcode" do
-      described_class.new("W", "1A").to_s.must_equal "W1A"
-    end
-
-    it "should generate a postcode with no unit" do
-      described_class.new("W", "1A", "1").to_s.must_equal "W1A 1"
-    end
-
-    it "should generate an area alone" do
-      described_class.new("W").to_s.must_equal "W"
-    end
-  end
-
-  describe "full?" do
-    it "should be true if outcode and incode are given" do
-      described_class.new("W", "1A", "1", "AA").must_be :full?
-    end
-
-    it "should not be true if something is missing" do
-      described_class.new("W", "1A", "1").wont_be :full?
-    end
-  end
-
-  describe "valid?" do
-    it "should be true" do
-      described_class.new("W", "1A", "1", "AA").must_be :valid?
-    end
-  end
-
-  describe "country" do
-    it "should look up the country of a full postcode" do
-      described_class.new("EH", "8", "8", "DX").country.must_equal :scotland
-    end
-
-    it "should look up the country of a partial postcode" do
-      described_class.new("W", "1A").country.must_equal :england
-    end
-  end
-end

data/test/giro_postcode_test.rb

@@ -1,100 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/giro_postcode"
-
-describe UKPostcode::GiroPostcode do
-  described_class = UKPostcode::GiroPostcode
-
-  let(:subject) { described_class.instance }
-
-  describe "parse" do
-    it "should parse the canonical form" do
-      pc = described_class.parse("GIR 0AA")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should parse transcribed 0/O and 1/I" do
-      pc = described_class.parse("G1R OAA")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should handle extra spaces" do
-      pc = described_class.parse("  GIR   0AA   ")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should handle no spaces" do
-      pc = described_class.parse("GIR0AA")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should be case-insensitive" do
-      pc = described_class.parse("gir 0aa")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should return nil if unable to parse" do
-      pc = described_class.parse("Can't parse this")
-      pc.must_be_nil
-    end
-  end
-
-  describe "area" do
-    it "should be nil" do
-      subject.area.must_be_nil
-    end
-  end
-
-  describe "district" do
-    it "should be nil" do
-      subject.district.must_be_nil
-    end
-  end
-
-  describe "sector" do
-    it "should be nil" do
-      subject.sector.must_be_nil
-    end
-  end
-
-  describe "unit" do
-    it "should be nil" do
-      subject.unit.must_be_nil
-    end
-  end
-
-  describe "outcode" do
-    it "should be GIR" do
-      subject.outcode.must_equal("GIR")
-    end
-  end
-
-  describe "incode" do
-    it "should be 0AA" do
-      subject.incode.must_equal("0AA")
-    end
-  end
-
-  describe "to_s" do
-    it "should be the canonical form" do
-      subject.to_s.must_equal "GIR 0AA"
-    end
-  end
-
-  describe "full?" do
-    it "should be true" do
-      subject.must_be :full?
-    end
-  end
-
-  describe "valid?" do
-    it "should be true" do
-      subject.must_be :valid?
-    end
-  end
-
-  describe "country" do
-    it "should be England" do
-      subject.country.must_equal :england
-    end
-  end
-end

data/test/invalid_postcode_test.rb

@@ -1,75 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/invalid_postcode"
-
-describe UKPostcode::InvalidPostcode do
-  described_class = UKPostcode::InvalidPostcode
-
-  let(:subject) { described_class.new("anything") }
-
-  describe "parse" do
-    it "should parse anything" do
-      pc = described_class.parse("Any old junk")
-      pc.must_be_instance_of described_class
-    end
-  end
-
-  describe "area" do
-    it "should be nil" do
-      subject.area.must_be_nil
-    end
-  end
-
-  describe "district" do
-    it "should be nil" do
-      subject.district.must_be_nil
-    end
-  end
-
-  describe "sector" do
-    it "should be nil" do
-      subject.sector.must_be_nil
-    end
-  end
-
-  describe "unit" do
-    it "should be nil" do
-      subject.unit.must_be_nil
-    end
-  end
-
-  describe "outcode" do
-    it "should be nil" do
-      subject.outcode.must_be_nil
-    end
-  end
-
-  describe "incode" do
-    it "should be nil" do
-      subject.incode.must_be_nil
-    end
-  end
-
-  describe "to_s" do
-    it "should return the initialisation string" do
-      subject.to_s.must_equal "anything"
-    end
-  end
-
-  describe "full?" do
-    it "should be false" do
-      subject.wont_be :full?
-    end
-  end
-
-  describe "valid?" do
-    it "should be false" do
-      subject.wont_be :valid?
-    end
-  end
-
-  describe "country" do
-    it "should be unknown" do
-      subject.country.must_equal :unknown
-    end
-  end
-end

data/test/special_postcode_test.rb

@@ -1,50 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode"
-
-describe "Special postcodes" do
-  # Special postcodes listed in http://en.wikipedia.org/wiki/UK_postcode
-  SPECIAL = %w[
-    SW1A 0AA
-    SW1A 1AA
-    SW1A 2AA
-    BS98 1TL
-    BX1  1LT
-    BX5  5AT
-    CF99 1NA
-    DH99 1NS
-    E16  1XL
-    E98  1NW
-    E98  1SN
-    E98  1ST
-    E98  1TT
-    EC4Y 0HQ
-    EH99 1SP
-    EN8  9SL
-    G58  1SB
-    GIR  0AA
-    L30  4GB
-    LS98 1FD
-    M2   5BE
-    N81  1ER
-    S2   4SU
-    S6   1SW
-    SE1  8UJ
-    SE9  2UG
-    SN38 1NW
-    SW1A 0PW
-    SW1A 2HQ
-    SW1W 0DT
-    TS1  3BA
-    W1A  1AA
-    W1F  9DJ
-  ]
-
-  SPECIAL.each_slice(2) do |outcode, incode|
-    it "should correctly handle special postcode #{outcode} #{incode}" do
-      postcode = UKPostcode.parse(outcode + incode)
-      postcode.wont_be_nil
-      postcode.outcode.must_equal outcode
-      postcode.incode.must_equal incode
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,4 +0,0 @@
-lib = File.expand_path("../../lib", __FILE__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
-require "minitest/spec"
-require "minitest/autorun"

data/test/tree_test.rb

@@ -1,84 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/tree"
-
-describe UKPostcode::Tree do
-  it "should build a nested hash via insert" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :bar
-    tree.insert %w[a b g h i], :baz
-
-    expected = {
-      "a" => {
-        "b" => {
-          "c" => { "d" => { "e" => :foo, "f" => :bar } },
-          "g" => { "h" => { "i" => :baz } }
-        }
-      }
-    }
-
-    tree.to_h.must_equal expected
-  end
-
-  it "should compress paths to identical leaves" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :foo
-    tree.insert %w[a b g h i], :baz
-
-    expected = {
-      "a" => {
-        "b" => {
-          "c" => :foo,
-          "g" => :baz
-        }
-      }
-    }
-
-    tree.compress.to_h.must_equal expected
-  end
-
-  it "should filter the tree to include only paths to specific leaf values" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :bar
-    tree.insert %w[a b g h i], :baz
-
-    expected = {
-      "a" => {
-        "b" => {
-          "c" => { "d" => { "e" => :foo } }
-        }
-      }
-    }
-
-    tree.filter(:foo).to_h.must_equal expected
-  end
-
-  it "should generate a minimal regular expression for the tree" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :foo
-    tree.insert %w[a b g h i], :foo
-    tree.insert %w[j k], :foo
-
-    expected = /^(?:ab(?:cd[ef]|ghi)|jk)/
-
-    tree.regexp.must_equal expected
-  end
-
-  it "should generate a working regular expression for the tree" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :foo
-    tree.insert %w[a b g h i], :foo
-    tree.insert %w[j k], :foo
-
-    regexp = tree.regexp
-    regexp.must_be :match, 'abcde'
-    regexp.must_be :match, 'abcdf'
-    regexp.must_be :match, 'abghi'
-    regexp.must_be :match, 'jk'
-    regexp.wont_be :match, 'abcdg'
-  end
-end

data/test/uk_postcode_test.rb

@@ -1,30 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode"
-
-describe UKPostcode do
-  describe "parse" do
-    it "should return a Giro postcode" do
-      pc = UKPostcode.parse("GIR 0AA")
-      pc.must_be_instance_of UKPostcode::GiroPostcode
-      pc.to_s.must_equal "GIR 0AA"
-    end
-
-    it "should return a geographic postcode" do
-      pc = UKPostcode.parse("EH8 8DX")
-      pc.must_be_instance_of UKPostcode::GeographicPostcode
-      pc.to_s.must_equal "EH8 8DX"
-    end
-
-    it "should return invalid instance for a blank postcode" do
-      pc = UKPostcode.parse("")
-      pc.must_be_instance_of UKPostcode::InvalidPostcode
-      pc.to_s.must_equal ""
-    end
-
-    it "should return invalid instance for an invalid postcode" do
-      pc = UKPostcode.parse("ABC DEF")
-      pc.must_be_instance_of UKPostcode::InvalidPostcode
-      pc.to_s.must_equal "ABC DEF"
-    end
-  end
-end