swissmatch-location 0.0.1

data/lib/swissmatch/canton.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+
+
+module SwissMatch
+
+  # Represents a swiss canton.
+  class Canton
+
+    # @return [String]
+    #   The two letter abbreviation of the cantons name as used on license plates.
+    attr_reader :license_tag
+
+    # @param [String] license_tag
+    #   The two letter abbreviation of the cantons name as used on license plates.
+    # @param [String] name
+    #   The official name of the canton in the local language.
+    # @param [String] name_de
+    #   The official name of the canton in german.
+    # @param [String] name_fr
+    #   The official name of the canton in french.
+    # @param [String] name_it
+    #   The official name of the canton in italian.
+    # @param [String] name_rt
+    #   The official name of the canton in rhaeto-romanic.
+    def initialize(license_tag, name, name_de, name_fr, name_it, name_rt)
+      @license_tag  = license_tag
+      @name         = name
+      @names        = {
+        :de => name_de,
+        :fr => name_fr,
+        :it => name_it,
+        :rt => name_rt,
+      }
+    end
+
+    # The name of the canton. If no language is passed, the local language is used.
+    #
+    # @param [Symbol, nil] language
+    #   One of nil, :de, :fr, :it or :rt
+    def name(language=nil)
+      language ? @names[language] : @name
+    end
+
+    # @return [Array<String>]
+    #   The name of this zip code in all languages (only unique names)
+    def names
+      @names.values.uniq
+    end
+
+    # @return [Hash]
+    #   All properties of the canton as a hash.
+    def to_hash
+      {
+        :name         => @name,
+        :name_de      => @names[:de],
+        :name_fr      => @names[:fr],
+        :name_it      => @names[:it],
+        :name_rt      => @names[:rt],
+        :license_tag  => @license_tag
+      }
+    end
+
+    alias to_s name
+
+    # @private
+    # @see Object#hash
+    def hash
+      [self.class, @license_tag].hash
+    end
+
+    # @private
+    # @see Object#eql?
+    def eql?(other)
+      self.class == other.class && @license_tag == other.license_tag
+    end
+
+    # @return [String]
+    # @see Object#inspect
+    def inspect
+      sprintf "\#<%s:%014x %s>", self.class, object_id, self
+    end
+  end
+end

data/lib/swissmatch/cantons.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+
+
+require 'swissmatch/canton'
+
+
+
+module SwissMatch
+
+  # Represents a collection of swiss cantons and provides a query interface.
+  class Cantons
+    include Enumerable
+
+    # @param [Array<SwissMatch::Canton>] cantons
+    #   The SwissMatch::Canton objects this SwissMatch::Cantons should contain
+    def initialize(cantons)
+      @cantons        = cantons
+      @by_license_tag = {}
+      @by_name        = {}
+
+      cantons.each do |canton|
+        @by_license_tag[canton.license_tag] = canton
+        canton.names.each do |name|
+          @by_name[name] = canton
+        end
+      end
+    end
+
+    # Calls the block once for every SwissMatch::Canton in this SwissMatch::Cantons
+    # instance, passing that canton as a parameter.
+    # The order is the same as the instance was constructed.
+    #
+    # @yield [canton]
+    # @yieldparam [SwissMatch::Canton] canton
+    #
+    # @return [self] Returns self
+    def each(&block)
+      @cantons.each(&block)
+      self
+    end
+
+    # Calls the block once for every SwissMatch::Canton in this SwissMatch::Cantons
+    # instance, passing that canton as a parameter.
+    # The order is the reverse of what the instance was constructed.
+    #
+    # @yield [canton]
+    # @yieldparam [SwissMatch::Canton] canton
+    #
+    # @return [self] Returns self
+    def reverse_each(&block)
+      @cantons.reverse_each(&block)
+      self
+    end
+
+    # @return [SwissMatch::Cantons]
+    #   A SwissMatch::Cantons collection with all SwissMatch::Canton objects for which the block
+    #   returned true (or a trueish value)
+    def select(*args, &block)
+      Cantons.new(@cantons.select(*args, &block))
+    end
+
+    # @return [SwissMatch::Cantons]
+    #   A SwissMatch::Cantons collection with all SwissMatch::Canton objects for which the block
+    #   returned false (or a falseish value)
+    def reject(*args, &block)
+      Cantons.new(@cantons.reject(*args, &block))
+    end
+
+    # @see Enumerable#sort
+    #
+    # @return [SwissMatch::Cantons]
+    #   A SwissMatch::Cantons collection sorted by the block
+    def sort(*args, &block)
+      Cantons.new(@cantons.sort(*args, &block))
+    end
+
+    # @see Enumerable#sort_by
+    #
+    # @return [SwissMatch::Cantons]
+    #   A SwissMatch::Cantons collection sorted by the block
+    def sort_by(*args, &block)
+      Cantons.new(@cantons.sort_by(*args, &block))
+    end
+
+    # @return [SwissMatch::Canton]
+    #   The canton with the given license tag or name (in any language)
+    def [](key)
+      @by_license_tag[key] || @by_name[key]
+    end
+
+    # @return [SwissMatch::Canton]
+    #   The canton with the given license tag.
+    def by_license_tag(tag)
+      @by_license_tag[tag]
+    end
+
+    # @return [SwissMatch::Canton]
+    #   The canton with the given name (any language)
+    def by_name(name)
+      @by_name[name]
+    end
+
+    # @return [Integer] The number of SwissMatch::Canton objects in this collection.
+    def size
+      @cantons.size
+    end
+
+    # @return [Array<SwissMatch::Canton>]
+    #   An Array with all SwissMatch::Canton objects in this SwissMatch::Cantons.
+    def to_a
+      @cantons.dup
+    end
+
+    # @private
+    # @see Object#inspect
+    def inspect
+      sprintf "\#<%s:%x size: %d>", self.class, object_id>>1, size
+    end
+  end
+end

data/lib/swissmatch/communities.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+
+
+module SwissMatch
+
+  # Represents a collection of SwissMatch::Community objects and provides a query
+  # interface.
+  class Communities
+    include Enumerable
+
+    # @param [Array<SwissMatch::Community>] communities
+    #   The SwissMatch::Community objects this SwissMatch::Communities should contain
+    def initialize(communities)
+      @communities          = communities
+      reset!
+    end
+
+    # @private
+    # Reinitialize all caching instance variables
+    def reset!
+      @by_community_number  = Hash[@communities.map { |c| [c.community_number, c] }]
+      @by_name              = {}
+      @communities.each do |community|
+        @by_name[community.name.to_s] = community
+      end
+
+      unless @communities.size == @by_name.size
+        raise "ImplementationError: The author assumed communities to have a unique name, which doesn't seem to be the case anymore"
+      end
+
+      self
+    end
+
+    # Calls the block once for every SwissMatch::Community in this SwissMatch::Communities
+    # instance, passing that community as a parameter.
+    # The order is the same as the instance was constructed.
+    #
+    # @yield [community]
+    # @yieldparam [SwissMatch::Community] community
+    #
+    # @return [self] Returns self
+    def each(&block)
+      @communities.each(&block)
+      self
+    end
+
+    # Calls the block once for every SwissMatch::Community in this SwissMatch::Communities
+    # instance, passing that community as a parameter.
+    # The order is the reverse of what the instance was constructed.
+    #
+    # @yield [community]
+    # @yieldparam [SwissMatch::Community] community
+    #
+    # @return [self] Returns self
+    def reverse_each(&block)
+      @communities.reverse_each(&block)
+      self
+    end
+
+    # @return [SwissMatch::Communities]
+    #   A SwissMatch::Communities collection with all SwissMatch::Community objects for which the block
+    #   returned true (or a trueish value)
+    def select(*args, &block)
+      Communities.new(@communities.select(*args, &block))
+    end
+
+    # @return [SwissMatch::Communities]
+    #   A SwissMatch::Communities collection with all SwissMatch::Community objects for which the block
+    #   returned false (or a falseish value)
+    def reject(*args, &block)
+      Communities.new(@communities.reject(*args, &block))
+    end
+
+    # @see Enumerable#sort
+    #
+    # @return [SwissMatch::Communities]
+    #   A SwissMatch::Communities collection sorted by the block
+    def sort(*args, &block)
+      Communities.new(@communities.sort(*args, &block))
+    end
+
+    # @see Enumerable#sort_by
+    #
+    # @return [SwissMatch::Communities]
+    #   A SwissMatch::Communities collection sorted by the block
+    def sort_by(*args, &block)
+      Communities.new(@communities.sort_by(*args, &block))
+    end
+
+    # @return [SwissMatch::Community]
+    #   The community with the given name or community number.
+    def [](key)
+      @by_name[key] || @by_community_number[key.to_i]
+    end
+
+    # @return [SwissMatch::Community]
+    #   The community with the given community number (also known as BFSNR).
+    def by_community_number(number)
+      @by_community_number[number]
+    end
+
+    # @return [SwissMatch::Community]
+    #   The community with the given name.
+    def by_name(name)
+      @by_name[name]
+    end
+
+    # @return [Integer] The number of SwissMatch::Community objects in this collection.
+    def size
+      @communities.size
+    end
+
+    # @return [Array<SwissMatch::Community>]
+    #   An Array with all SwissMatch::Community objects in this SwissMatch::Communities.
+    def to_a
+      @communities.dup
+    end
+
+    # @private
+    # @see Object#inspect
+    def inspect
+      sprintf "\#<%s:%x size: %d>", self.class, object_id>>1, size
+    end
+  end
+end

data/lib/swissmatch/community.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+
+
+module SwissMatch
+
+  # Represents a swiss community.
+  # Swiss communities are identified by their community number (BFSNR).
+  class Community
+
+    # @return [Integer]
+    #   A unique, never recycled identification number.
+    #   Also known as BFSNR.
+    attr_reader :community_number
+
+    # @return [String]
+    #   The official name of the community.
+    attr_reader :name
+
+    # @return [SwissMatch::Canton]
+    #   The canton this community belongs to.
+    attr_reader :canton
+
+    # @return [SwissMatch::Community]
+    #   The community this community is considered to be an agglomeration of.
+    #   Note that a main community will reference itself.
+    attr_reader :agglomeration
+
+    # @param [Integer] community_number
+    #   The identification number of the community, also known as BFSNR.
+    # @param [String] name
+    #   The official name of the community
+    # @param [SwissMatch::Canton] canton
+    #   The canton this community belongs to
+    # @param [SwissMatch::Community] agglomeration
+    #   The community this community is considered to be an agglomeration of.
+    #   Note that a main community will reference itself.
+    def initialize(community_number, name, canton, agglomeration)
+      @community_number = community_number
+      @name             = name
+      @canton           = canton
+      @agglomeration    = agglomeration == :self ? self : agglomeration
+    end
+
+    alias to_s name
+
+    # @param [Boolean] retain_references
+    #   If set to false, :agglomeration will be set to the community_number and
+    #   :canton to the canton's license_tag.
+    #
+    # @return [Hash]
+    #   All properties of the community as a hash.
+    def to_hash(retain_references=false)
+      if retain_references then
+        canton        = @canton
+        agglomeration = @agglomeration
+      else
+        canton        = @canton && @canton.license_tag
+        agglomeration = @agglomeration && @agglomeration.community_number
+      end
+
+      {
+        :community_number => @community_number,
+        :name             => @name,
+        :canton           => canton,
+        :agglomeration    => agglomeration,
+      }
+    end
+
+    # @private
+    # @see Object#hash
+    def hash
+      [self.class, @community_number].hash
+    end
+
+    # @private
+    # @see Object#eql?
+    def eql?(other)
+      self.class == other.class && @community_number == other.community_number
+    end
+
+    # @return [String]
+    # @see Object#inspect
+    def inspect
+      sprintf "\#<%s:%014x %s, BFSNR %d>", self.class, object_id, self, @community_number
+    end
+  end
+end

data/lib/swissmatch/datafiles.rb

@@ -0,0 +1,333 @@
+# encoding: utf-8
+
+
+
+require 'swissmatch/loaderror'
+
+
+
+module SwissMatch
+
+  # Deals with retrieving and updating the files provided by the swiss postal service,
+  # and loading the data from them.
+  #
+  # @todo
+  #   The current handling of the urls is not clean. I don't know yet how the urls will
+  #   change over iterations.
+  class DataFiles
+
+    # Used to generate the regular expressions used to parse the data files.
+    # Generates a regular expression, that matches +size+ tab separated fields,
+    # delimited by \r\n.
+    # @private
+    def self.generate_expression(size)
+      /^#{Array.new(size) { '([^\t]*)' }.join('\t')}\r\n/
+    end
+
+    # Regular expressions used to parse the different files.
+    # @private
+    Expressions = {
+      :community  => generate_expression(4),
+      :zip_2      => generate_expression(6),
+      :zip_1      => generate_expression(13),
+    }
+
+    # @private
+    # The URL of the plz_p1 file
+    URLZip1         = "https://match.post.ch/download?file=10001&tid=11&rol=0"
+
+    # @private
+    # The URL of the plz_p2 file
+    URLZip2         = "https://match.post.ch/download?file=10002&tid=14&rol=0"
+
+    # @private
+    # The URL of the plz_c file
+    URLCommunity    = "https://match.post.ch/download?file=10003&tid=13&rol=0"
+
+    # @private
+    # An array of all urls
+    URLAll          = [URLZip1, URLZip2, URLCommunity]
+
+    # The data of all cantons
+    # @private
+    CantonData = [
+      ["AG", "Aargau",                    "Aargau",                   "Argovie",                      "Argovia",                  "Argovia"],
+      ["AI", "Appenzell Innerrhoden",     "Appenzell Innerrhoden",    "Appenzell Rhodes-Intérieures", "Appenzello Interno",       "Appenzell Dadens"],
+      ["AR", "Appenzell Ausserrhoden",    "Appenzell Ausserrhoden",   "Appenzell Rhodes-Extérieures", "Appenzello Esterno",       "Appenzell Dadora"],
+      ["BE", "Bern",                      "Bern",                     "Berne",                        "Berna",                    "Berna"],
+      ["BL", "Basel-Landschaft",          "Basel-Landschaft",         "Bâle-Campagne",                "Basilea Campagna",         "Basilea-Champagna"],
+      ["BS", "Basel-Stadt",               "Basel-Stadt",              "Bâle-Ville",                   "Basilea Città",            "Basilea-Citad"],
+      ["FR", "Freiburg",                  "Fribourg",                 "Fribourg",                     "Friburgo",                 "Friburg"],
+      ["GE", "Genève",                    "Genf",                     "Genève",                       "Ginevra",                  "Genevra"],
+      ["GL", "Glarus",                    "Glarus",                   "Glaris",                       "Glarona",                  "Glaruna"],
+      ["GR", "Graubünden",                "Graubünden",               "Grisons",                      "Grigioni",                 "Grischun"],
+      ["JU", "Jura",                      "Jura",                     "Jura",                         "Giura",                    "Giura"],
+      ["LU", "Luzern",                    "Luzern",                   "Lucerne",                      "Lucerna",                  "Lucerna"],
+      ["NE", "Neuchâtel",                 "Neuenburg",                "Neuchâtel",                    "Neuchâtel",                "Neuchâtel"],
+      ["NW", "Nidwalden",                 "Nidwalden",                "Nidwald",                      "Nidvaldo",                 "Sutsilvania"],
+      ["OW", "Obwalden",                  "Obwalden",                 "Obwald",                       "Obvaldo",                  "Sursilvania"],
+      ["SG", "St. Gallen",                "St. Gallen",               "Saint-Gall",                   "San Gallo",                "Son Gagl"],
+      ["SH", "Schaffhausen",              "Schaffhausen",             "Schaffhouse",                  "Sciaffusa",                "Schaffusa"],
+      ["SO", "Solothurn",                 "Solothurn",                "Soleure",                      "Soletta",                  "Soloturn"],
+      ["SZ", "Schwyz",                    "Schwyz",                   "Schwytz",                      "Svitto",                   "Sviz"],
+      ["TG", "Thurgau",                   "Thurgau",                  "Thurgovie",                    "Turgovia",                 "Turgovia"],
+      ["TI", "Ticino",                    "Tessin",                   "Tessin",                       "Ticino",                   "Tessin"],
+      ["UR", "Uri",                       "Uri",                      "Uri",                          "Uri",                      "Uri"],
+      ["VD", "Vaud",                      "Waadt",                    "Vaud",                         "Vaud",                     "Vad"],
+      ["VS", "Valais",                    "Wallis",                   "Valais",                       "Vallese",                  "Vallais"],
+      ["ZG", "Zug",                       "Zug",                      "Zoug",                         "Zugo",                     "Zug"],
+      ["ZH", "Zürich",                    "Zürich",                   "Zurich",                       "Zurigo",                   "Turitg"],
+      ["FL", "Fürstentum Liechtenstein",  "Fürstentum Liechtenstein", "Liechtenstein",                "Liechtenstein",            "Liechtenstein"],
+      ["DE", "Deutschland",               "Deutschland",              "Allemagne",                    "Germania",                 "Germania"],
+      ["IT", "Italien",                   "Italien",                  "Italie",                       "Italia",                   "Italia"],
+    ]
+
+    # The directory in which the post mat[ch] files reside
+    attr_accessor :data_directory
+
+    # @return [SwissMatch::Cantons] The loaded swiss cantons
+    attr_reader :cantons
+
+    # @return [SwissMatch::Communities] The loaded swiss communities
+    attr_reader :communities
+
+    # @return [SwissMatch::ZipCodes] The loaded swiss zip codes
+    attr_reader :zip_codes
+
+    # @return [Array<LoadError>] Errors that occurred while loading the data
+    attr_reader :errors
+
+    # @param [nil, String] data_directory
+    #   The directory in which the post mat[ch] files reside
+    def initialize(data_directory=nil)
+      reset_errors!
+      if data_directory then
+        @data_directory = data_directory
+      elsif ENV['SWISSMATCH_DATA'] then
+        @data_directory = ENV['SWISSMATCH_DATA']
+      else
+        data_directory  = File.expand_path('../../../data/swissmatch', __FILE__)
+        data_directory  = Gem.datadir 'swissmatch' if defined?(Gem) && !File.directory?(data_directory)
+        @data_directory = data_directory
+      end
+    end
+
+    # Resets the list of errors that were encountered during load
+    # @return [self]
+    def reset_errors!
+      @errors = []
+      self
+    end
+
+    # Load new files
+    #
+    # @return [Array<String>]
+    #   An array with the absolute file paths of the extracted files.
+    def load_updates
+      URLAll.flat_map { |url|
+        http_get_zip_file(url, @data_directory)
+      }
+    end
+
+    # Performs an HTTP-GET for the given url, extracts it as a zipped file into the
+    # destination directory.
+    #
+    # @return [Array<String>]
+    #   An array with the absolute file paths of the extracted files.
+    def http_get_zip_file(url, destination)
+      require 'open-uri'
+      require 'swissmatch/zip' # patched zip/zip
+      require 'fileutils'
+
+      files = []
+
+      open(url) do |zip_buffer|
+        Zip::ZipFile.open(zip_buffer) do |zip_file|
+          zip_file.each do |f|
+            target_path = File.join(destination, f.name)
+            FileUtils.mkdir_p(File.dirname(target_path))
+            zip_file.extract(f, target_path) unless File.exist?(target_path)
+            files << target_path
+          end
+        end
+      end
+
+      files
+    end
+
+    # Unzips it as a zipped file into the destination directory.
+    def unzip_file(file, destination)
+      require 'swissmatch/zip'
+      Zip::ZipFile.open(file) do |zip_file|
+        zip_file.each do |f|
+          target_path = File.join(destination, f.name)
+          FileUtils.mkdir_p(File.dirname(target_path))
+          zip_file.extract(f, target_path) unless File.exist?(target_path)
+        end
+      end
+    end
+
+    # Used to convert numerical language codes to symbols
+    LanguageCodes = [nil, :de, :fr, :it, :rt]
+
+    # Loads the data into this DataFiles instance
+    #
+    # @return [self]
+    #   Returns self.
+    def load!
+      @cantons, @communities, @zip_codes = *load
+      self
+    end
+
+    # @return [Array]
+    #   Returns an array of the form [SwissMatch::Cantons, SwissMatch::Communities,
+    #   SwissMatch::ZipCodes].
+    def load
+      reset_errors!
+
+      cantons     = load_cantons
+      communities = load_communities(cantons)
+      zip_codes   = load_zipcodes(cantons, communities)
+
+      [cantons, communities, zip_codes]
+    end
+
+    # @return [SwissMatch::Cantons]
+    #   A SwissMatch::Cantons containing all cantons used by the swiss postal service.
+    def load_cantons
+      Cantons.new(
+        CantonData.map { |tag, name, name_de, name_fr, name_it, name_rt|
+          Canton.new(tag, name, name_de, name_fr, name_it, name_rt)
+        }
+      )
+    end
+
+    # @return [SwissMatch::Communities]
+    #   An instance of SwissMatch::Communities containing all communities defined by the
+    #   files known to this DataFiles instance.
+    def load_communities(cantons)
+      raise "Must load cantons first" unless cantons
+
+      file      = Dir.enum_for(:glob, "#{@data_directory}/plz_c_*.txt").last
+      temporary = []
+      complete  = {}
+      load_table(file, :community).each do |bfsnr, name, canton, agglomeration|
+        bfsnr         = bfsnr.to_i
+        agglomeration = agglomeration.to_i
+        canton        = cantons.by_license_tag(canton)
+        if agglomeration == bfsnr then
+          complete[bfsnr] = Community.new(bfsnr, name, canton, :self)
+        elsif agglomeration.nil? then
+          complete[bfsnr] = Community.new(bfsnr, name, canton, nil)
+        else
+          temporary << [bfsnr, name, canton, agglomeration]
+        end
+      end
+      temporary.each do |bfsnr, name, canton, agglomeration|
+        community = complete[agglomeration]
+        raise "Incomplete community referenced by #{bfsnr}: #{agglomeration}" unless agglomeration
+        complete[bfsnr] = Community.new(bfsnr, name, canton, community)
+      end
+
+      Communities.new(complete.values)
+    end
+
+    # TODO: load all files, not just the most recent
+    # TODO: calculate valid_until dates
+    #
+    # @return [SwissMatch::ZipCodes]
+    #   An instance of SwissMatch::ZipCodes containing all zip codes defined by the
+    #   files known to this DataFiles instance.
+    def load_zipcodes(cantons, communities)
+      raise "Must load cantons first" unless cantons
+      raise "Must load communities first" unless communities
+
+      temporary       = {}
+      self_delivered  = []
+      others          = []
+      zip1_file       = Dir.enum_for(:glob, "#{@data_directory}/plz_p1_*.txt").last
+      zip2_file       = Dir.enum_for(:glob, "#{@data_directory}/plz_p2_*.txt").last
+      load_table(zip1_file, :zip_1).each do |row|
+        onrp                  = row.at(0).to_i
+        delivery_by           = row.at(10).to_i
+        delivery_by           = case delivery_by when 0 then nil; when onrp then :self; else delivery_by; end
+        language              = LanguageCodes[row.at(7).to_i]
+        language_alternative  = LanguageCodes[row.at(8).to_i]
+        name_short            = Name.new(row.at(4), language)
+        name                  = Name.new(row.at(5), language)
+        data                  = [
+          onrp,                              # ordering_number
+          row.at(1).to_i,                    # type
+          row.at(2).to_i,                    # code
+          row.at(3).to_i,                    # add_on
+          name,                              # name (official)
+          [name],                            # names (official + alternative)
+          name_short,                        # name_short (official)
+          [name_short],                      # names_short (official + alternative)
+          [],                                # PLZ2 type 3 short names (additional region names)
+          [],                                # PLZ2 type 3 names (additional region names)
+          cantons.by_license_tag(row.at(6)), # canton
+          language,
+          language_alternative,
+          row.at(9) == "1",                  # sortfile_member
+          delivery_by,                       # delivery_by
+          communities.by_community_number(row.at(11).to_i),  # community_number
+          Date.civil(*row.at(12).match(/^(\d{4})(\d\d)(\d\d)$/).captures.map(&:to_i)) # valid_from
+        ]
+        temporary[onrp] = data
+        if :self == delivery_by then
+          self_delivered << data
+        else
+          others << data
+        end
+      end
+
+      load_table(zip2_file, :zip_2).each do |onrp, rn, type, lang, short, name|
+        onrp      = onrp.to_i
+        lang_code = lang.to_i
+        language  = LanguageCodes[lang_code]
+        entry     = temporary[onrp]
+        if type == "2"
+          entry[5] << Name.new(name, language, rn.to_i)
+          entry[7] << Name.new(short, language, rn.to_i)
+        elsif type == "3"
+          entry[8] << Name.new(name, language, rn.to_i)
+          entry[9] << Name.new(short, language, rn.to_i)
+        end
+      end
+
+      self_delivered.each do |row|
+        temporary[row.at(0)] = ZipCode.new(*row)
+      end
+      others.each do |row|
+        if row.at(14) then
+          raise "Delivery not found:\n#{row.inspect}" unless tmp = temporary[row.at(14)]
+          if tmp.kind_of?(Array) then
+            @errors << LoadError.new("Invalid reference: onrp #{row.at(0)} delivery by #{row.at(14)}", row)
+            row[14] = nil
+          else
+            row[14] = tmp
+          end
+        end
+        temporary[row.at(0)] = ZipCode.new(*row)
+      end
+
+      ZipCodes.new(temporary.values)
+    end
+
+    # Reads a file and parses using the pattern of the given name.
+    #
+    # @param [String] path
+    #   The path of the file to parse
+    # @param [Symbol] pattern
+    #   The pattern-name used to parse the file (see Expressions)
+    #
+    # @return [Array<Array<String>>]
+    #   A 2 dimensional array representing the tabular data contained in the given file.
+    def load_table(path, pattern)
+      File.read(path, :encoding => Encoding::Windows_1252.to_s). # to_s because sadly, ruby 1.9.2 can't handle an Encoding instance as argument
+        encode(Encoding::UTF_8).
+        scan(Expressions[pattern])
+    end
+  end
+end