uk_postcode 1.0.1 → 2.0.0.alpha

data/test/tree_test.rb

@@ -0,0 +1,84 @@
+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

@@ -2,277 +2,29 @@ require_relative "./test_helper"
 require "uk_postcode"
 
 describe UKPostcode do
-
-  VALID_SAMPLES  = [
-    %w[A   9 9 AA], %w[A  99 9 AA], %w[AA  9 9 AA], %w[AA 99 9 AA], %w[A  9A 9 AA],
-    %w[AA 9A 9 AA], %w[SW 1A 0 AA], %w[SW 1A 0 PW], %w[SW 1A 1 AA], %w[SW 1A 2 HQ],
-    %w[W  1A 1 AA], %w[W  1A 1 AB], %w[N  81 1 ER], %w[EH 99 1 SP], %w[CV  1 1 FL],
-    %w[EX  1 1 AE], %w[TQ  1 1 AG]
-  ]
-
-  { "full samples with spaces"    => lambda{ |(a,b,c,d)| [[a, b, " ", c, d].join, [a, b, c, d]] },
-    "full samples without spaces" => lambda{ |(a,b,c,d)| [[a, b, c, d].join, [a, b, c, d]] },
-  }.each do |desc, mapping|
-    describe desc do
-      let(:samples) {
-        VALID_SAMPLES.map(&mapping)
-      }
-
-      it "should all be valid" do
-        samples.each do |sample, _|
-          UKPostcode.new(sample).must_be :valid?
-        end
-      end
-
-      it "should all be full" do
-        samples.each do |sample, _|
-          UKPostcode.new(sample).must_be :full?
-        end
-      end
-
-      it "should extract outcodes" do
-        samples.each do |sample, parts|
-          UKPostcode.new(sample).outcode.must_equal parts[0] + parts[1]
-        end
-      end
-
-      it "should extract incodes" do
-        samples.each do |sample, parts|
-          UKPostcode.new(sample).incode.must_equal parts[2] + parts[3]
-        end
-      end
-
-      it "should extract area" do
-        samples.each do |sample, parts|
-          UKPostcode.new(sample).area.must_equal parts[0]
-        end
-      end
-
-      it "should extract district" do
-        samples.each do |sample, parts|
-          UKPostcode.new(sample).district.must_equal parts[1]
-        end
-      end
-
-      it "should extract sector" do
-        samples.each do |sample, parts|
-          UKPostcode.new(sample).sector.must_equal parts[2]
-        end
-      end
-
-      it "should extract unit" do
-        samples.each do |sample, parts|
-          UKPostcode.new(sample).unit.must_equal parts[3]
-        end
-      end
-
-      it "should be the same when normalised" do
-        samples.each do |sample, parts|
-          expected = [parts[0], parts[1], " ", parts[2], parts[3]].join
-          UKPostcode.new(sample).norm.must_equal expected
-        end
-      end
-    end
-  end
-
-  describe "outcode samples" do
-    let(:samples) {
-      VALID_SAMPLES.map{ |a,b,c,d| [a, b].join }
-    }
-
-    it "should all be valid" do
-      samples.each do |sample|
-        UKPostcode.new(sample).must_be :valid?
-      end
-    end
-
-    it "should not be full" do
-      samples.each do |sample|
-        UKPostcode.new(sample).wont_be :full?
-      end
-    end
-
-    it "should keep outcode unchanged" do
-      samples.each do |sample|
-        UKPostcode.new(sample).outcode.must_equal sample
-      end
+  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 have nil incode" do
-      samples.each do |sample|
-        UKPostcode.new(sample).incode.must_be_nil
-      end
-    end
-
-    it "should be the same when normalised" do
-      samples.each do |sample|
-        UKPostcode.new(sample).norm.must_equal sample
-      end
-    end
-  end
-
-  describe "when the postcode is supplied in lower case" do
-    let(:postcode) {
-      UKPostcode.new("w1a 1aa")
-    }
-
-    it "should extract outcode in upper case" do
-      postcode.outcode.must_equal "W1A"
-    end
-
-    it "should extract incode in upper case" do
-      postcode.incode.must_equal "1AA"
-    end
-
-    it "should be valid" do
-      postcode.must_be :valid?
-    end
-  end
-
-  { "when the postcode is blank" => "",
-    "when the incode is truncated" => "W1A 1A",
-    "when the outcode is truncated" => "W",
-    "when the postcode is invalid" => "ABC DEFG"
-  }.each do |desc, sample|
-    describe desc do
-      let(:postcode) {
-        UKPostcode.new(sample)
-      }
-
-      it "should not be valid" do
-        refute postcode.valid?
-      end
-
-      it "should not be full" do
-        refute postcode.full?
-      end
-
-      it "should return an empty string when normalised" do
-        postcode.norm.must_equal ""
-      end
-
-      it "should return nil for outcode" do
-        postcode.outcode.must_be_nil
-      end
-
-      it "should return nil for incode" do
-        postcode.incode.must_be_nil
-      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
-  end
-
-  describe "when used as a string" do
-    it "should normalise spacing when no spacing has been used in the input" do
-      UKPostcode.new("W1A1AA").norm.must_equal "W1A 1AA"
-    end
-
-    it "should normalise spacing when too much spacing has been used in the input" do
-      UKPostcode.new("W1A  1AA").norm.must_equal "W1A 1AA"
-    end
-
-    it "should convert case" do
-      UKPostcode.new("w1a 1aa").norm.must_equal "W1A 1AA"
-    end
-
-    it "should ignore a missing incode" do
-      UKPostcode.new("W1A").norm.must_equal "W1A"
-    end
-
-    it "should trim whitespace from start and end of the string" do
-      UKPostcode.new(" W1A 1AA ").norm.must_equal "W1A 1AA"
-    end
-  end
-
-  it "should return original input for to_s" do
-    ["W1A1AA", "w1a 1aa", "W1A"].each do |s|
-      UKPostcode.new(s).to_s.must_equal s
-    end
-  end
-
-  it "should return original input for to_str" do
-    ["W1A1AA", "w1a 1aa", "W1A"].each do |s|
-      UKPostcode.new(s).to_str.must_equal s
-    end
-  end
-
-  describe "when letters are used instead of digits" do
-    describe "in a full postcode" do
-      let(:postcode) {
-        UKPostcode.new("SWIA OPW")
-      }
-
-      it "should be valid" do
-        postcode.must_be :valid?
-      end
-
-      it "should be full" do
-        postcode.must_be :full?
-      end
-
-      it "should normalise to digits" do
-        postcode.norm.must_equal "SW1A 0PW"
-      end
-    end
-  end
-
-  describe "when digits are used instead of letters" do
-    describe "in a full postcode" do
-      let(:postcode) {
-        UKPostcode.new("0X1 0AB")
-      }
-
-      it "should be valid" do
-        postcode.must_be :valid?
-      end
-
-      it "should be full" do
-        postcode.must_be :full?
-      end
-
-      it "should normalise to letters" do
-        postcode.norm.must_equal "OX1 0AB"
-      end
-    end
-  end
-
-  describe "single-letter area code" do
-    %w[B E G L M N S W].each do |area|
-      describe area do
-        it "should not convert 1 to I in two-digit outcode" do
-          outcode = area + "11"
-          postcode = UKPostcode.new(outcode)
-          postcode.area.must_equal area
-          postcode.outcode.must_equal outcode
-        end
-
-        it "should not convert 1 to I in full postcode with space" do
-          outcode = area + "13"
-          postcode = UKPostcode.new(outcode + " 1AA")
-          postcode.area.must_equal area
-          postcode.outcode.must_equal outcode
-        end
-
-        it "should not convert 1 to I in full postcode without space" do
-          outcode = area + "13"
-          postcode = UKPostcode.new(outcode + "2AA")
-          postcode.area.must_equal area
-          postcode.outcode.must_equal outcode
-        end
-      end
-    end
-  end
-
-  describe "GIR 0AA" do
-    let(:norm) {
-      "GIR 0AA"
-    }
 
-    it "should stay as is if already normalised" do
-      UKPostcode.new(norm).norm.must_equal norm
+    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 be normalised" do
-      UKPostcode.new("G1ROAA").norm.must_equal norm
+    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uk_postcode
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0.alpha
 platform: ruby
 authors:
 - Paul Battley
@@ -14,29 +14,40 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description: Parse, validate, and extract sub-fields from UK postcodes
 email: pbattley@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- COPYING.txt
 - README.md
-- Rakefile
 - lib/uk_postcode.rb
+- lib/uk_postcode/country_finder.rb
+- lib/uk_postcode/country_lookup.rb
+- lib/uk_postcode/geographic_postcode.rb
+- lib/uk_postcode/giro_postcode.rb
+- lib/uk_postcode/invalid_postcode.rb
+- lib/uk_postcode/tree.rb
 - lib/uk_postcode/version.rb
-- test/samples/wikipedia.list
-- test/samples_test.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:
@@ -53,9 +64,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/Rakefile

@@ -1,8 +0,0 @@
-require "rake/testtask"
-
-Rake::TestTask.new("test") do |t|
-  t.pattern = "test/**/*_test.rb"
-  t.verbose = true
-end
-
-task :default => :test

data/test/samples/wikipedia.list

@@ -1,35 +0,0 @@
-# Special postcodes listed in http://en.wikipedia.org/wiki/UK_postcode
-
-SW1A0AA
-SW1A1AA
-SW1A2AA
-BS981TL
-BX1 1LT
-BX5 5AT
-CF991NA
-DH991NS
-E16 1XL
-E98 1NW
-E98 1SN
-E98 1ST
-E98 1TT
-EC4Y0HQ
-EH991SP
-EN8 9SL
-G58 1SB
-GIR 0AA
-L30 4GB
-LS981FD
-M2  5BE
-N81 1ER
-S2  4SU
-S6  1SW
-SE1 8UJ
-SE9 2UG
-SN381NW
-SW1A0PW
-SW1A2HQ
-SW1W0DT
-TS1 3BA
-W1A 1AA
-W1F 9DJ

data/test/samples_test.rb

@@ -1,18 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode"
-
-describe "Sample files" do
-  Dir[File.expand_path("../samples/**/*.list", __FILE__)].each do |path|
-    it "should be valid for each line in #{File.basename(path, ".list")}" do
-      open(path).each_line do |line|
-        next if line =~ /^#|^$/
-        outcode = line[0,4].strip
-        incode  = line[4,3].strip
-        postcode = UKPostcode.new(outcode + incode)
-        postcode.must_be :valid?
-        postcode.outcode.must_equal outcode
-        postcode.incode.must_equal incode
-      end
-    end
-  end
-end