swissmatch-rails 0.0.1

data/LICENSE.txt

@@ -0,0 +1,8 @@
+Copyright (c) 2012, Stefan Rusterholz <stefan.rusterholz@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.markdown

@@ -0,0 +1,79 @@
+README
+======
+
+
+Summary
+-------
+Adds ActiveRecord models and javascript assets for rails to swissmatch.
+
+
+Installation
+------------
+Install the gem: `gem install swissmatch-rails`  
+Depending on how you installed rubygems, you have to use `sudo`:
+`sudo gem install swissmatch-rails`  
+In Ruby: `require 'swissmatch/rails'`
+
+
+Usage
+-----
+### Gemfile
+To use swissmatch-rails, the best way is to put the following line into your Gemfile:
+
+    gem 'swissmatch', :require => 'swissmatch/rails'
+
+
+### SwissMatch and Databases
+If you want to load the data into your database, you can use:
+
+    swissmatch_db create
+    swissmatch_db seed
+
+This needs active\_record 3.2+ to be installed, and you should either be in a rails project, or
+use the -c option to specify a database configuration file.
+The models used for that can be loaded by `require 'swissmatch/active_record'`.
+See SwissMatch::ActiveRecord::Canton, SwissMatch::ActiveRecord::Community and
+SwissMatch::ActiveRecord::ZipCode
+
+### Configuration
+The swissmatch-rails gem loads the configuration from PROJECT_ROOT/config/swissmatch.yml.
+The file should have the following structure:
+
+    global:
+      telsearch_key:    "your telsearch API key"
+      data_directory:   "A path to where you want your data files stored, relative paths are relative to PROJECT_ROOT"
+      cache_directory:  "A path to where swissmatch should store its cache"
+    development:
+      # same keys as for global, you can have environment specific settings here
+
+The key 'global' will be used as the base for every environment.
+
+
+Relevant Classes and Modules
+----------------------------
+* __{SwissMatch::ActiveRecord}__
+  Container for all ActiveRecord models
+
+
+Links
+-----
+
+* [Main Project](https://github.com/apeiros/swissmatch)
+* [Online API Documentation](http://rdoc.info/github/apeiros/swissmatch-directories/)
+* [Public Repository](https://github.com/apeiros/swissmatch-directories)
+* [Bug Reporting](https://github.com/apeiros/swissmatch-directories/issues)
+* [RubyGems Site](https://rubygems.org/gems/swissmatch-directories)
+* [Swiss Posts MAT[CH]](http://www.post.ch/match)
+
+
+License
+-------
+
+You can use this code under the {file:LICENSE.txt BSD-2-Clause License}, free of charge.
+If you need a different license, please ask the author.
+
+
+Credits
+-------
+
+* [AWD Switzerland](http://www.awd.ch/) for donating time to work on this gem.

data/Rakefile

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.expand_path('../rake/lib', __FILE__))
+Dir.glob(File.expand_path('../rake/tasks/**/*.{rake,task,rb}', __FILE__)) do |task_file|
+  begin
+    import task_file
+  rescue LoadError => e
+    warn "Failed to load task file #{task_file}"
+    warn "  #{e.class} #{e.message}"
+    warn "  #{e.backtrace.first}"
+  end
+end

data/bin/swissmatch_db

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+lib_dir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH << lib_dir if File.directory?(lib_dir)
+
+require 'active_record'
+require 'swissmatch/autoload'
+require 'swissmatch/activerecord'
+require 'optparse'
+require 'logger'
+
+environment = ENV["RAILS_ENV"] || 'development'
+log_file    = ENV["LOG"]
+config_file = ENV["SWISSMATCH_DB_CONFIG"] || 'config/database.yml'
+
+parser      = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] command"
+
+  opts.on("-h", "--help", "Print help and exit") do
+    help
+    exit
+  end
+
+  opts.on("-e", "--environment NAME", "Set the environment, used to determine the configuration (uses RAILS_ENV env variable, defaults to 'development')") do |name|
+    environment = name
+  end
+
+  opts.on("-c", "--configuration PATH", "Path to the configuration file  (uses SWISSMATCH_DB_CONFIG env variable, defaults to 'config/database.yml')") do |path|
+    config_file = path
+  end
+
+  opts.on("-l", "--log PATH", "Path to the log file. Use - for stdout and _ to suppress. (uses LOG env variable, defaults to 'log/ENVIRONMENT.log')") do |path|
+    log_file = path
+  end
+end
+parser.parse!
+
+# determine log-file
+log_file ||= "log/#{environment}.log" if File.writable?("log")
+log_file = nil if log_file == '_'
+log_file = $stdout if log_file == '-'
+
+# establish connection and setup logging
+abort("Configuration file not found, use -c switch to specify one. Tried '#{config_file}'") unless File.readable?(config_file)
+SwissMatch::ActiveRecord.connect_from_config(config_file, environment)
+ActiveRecord::Base.logger = Logger.new(log_file) if log_file
+
+# handle commands
+case ARGV.first
+  when "create"
+    SwissMatch::ActiveRecord::Migration.migrate(:up)
+  when "destroy"
+    SwissMatch::ActiveRecord::Migration.migrate(:down)
+  when "seed"
+    SwissMatch::ActiveRecord.seed
+  when "help"
+    help
+  when nil
+    puts "No command given"
+    help
+    abort "Aborting"
+  else
+    puts "Unknown command: #{ARGV.first}"
+    help
+    abort "Aborting"
+end
+
+BEGIN {
+  def help
+    puts "Available commands are:", "  create", "  seed", "  destroy"
+  end
+}

data/lib/swissmatch/activerecord.rb

@@ -0,0 +1,300 @@
+# encoding: utf-8
+
+
+
+require 'swissmatch'
+require 'active_record'
+
+
+
+module SwissMatch
+
+  # ActiveRecord models for swissmatch
+  module ActiveRecord
+    LanguageToCode = {
+      :de => 1,
+      :fr => 2,
+      :it => 3,
+      :rt => 4,
+    }
+    CodeToLanguage = LanguageToCode.invert
+
+    def self.connect_from_config(config_file, environment=nil)
+      config = YAML.load_file(config_file)
+      config = config[environment] if config[environment]
+      config = Hash[config.map { |k,v| [k.to_sym, v] }]
+      ::ActiveRecord::Base.establish_connection(config)
+    end
+
+    def self.delete_all
+      SwissMatch::ActiveRecord::ZipCodeName.delete_all
+      SwissMatch::ActiveRecord::ZipCode.delete_all
+      SwissMatch::ActiveRecord::Community.delete_all
+      SwissMatch::ActiveRecord::Canton.delete_all
+    end
+
+    def self.cursor_hidden(io=$stdout)
+      io.printf "\e[?25l"
+      io.flush
+      yield
+    ensure
+      io.printf "\e[?25h"
+      io.flush
+    end
+
+    def self.print_progress(progress, total, width=80, io=$stdout)
+      bar_width = width-8
+      percent   = progress.fdiv(total)
+      filled    = (percent*bar_width).round
+      empty     = bar_width - filled
+      io.printf "\r\e[1m %5.1f%%\e[0m \e[44m%*s\e[46m%*s\e[0m", percent*100, filled, '', empty, ''
+      io.flush
+    end
+
+    def self.seed(data_source=SwissMatch.data)
+      canton2id     = {}
+      total         = data_source.cantons.size +
+                      data_source.communities.size +
+                      data_source.zip_codes.size*2 +
+                      10
+      progress      = 0
+
+      cursor_hidden do
+        print_progress(progress, total)
+
+        ::ActiveRecord::Base.transaction do
+          delete_all
+          print_progress(progress+=10, total)
+
+          data_source.cantons.each do |canton|
+            canton2id[canton.license_tag] = SwissMatch::ActiveRecord::Canton.create!(canton.to_hash, :without_protection => true).id
+            print_progress(progress+=1, total)
+          end
+          data_source.communities.partition do |community|
+            hash                    = community.to_hash
+            hash[:canton_id]        = canton2id[hash.delete(:canton)]
+            hash[:agglomeration_id] = hash.delete(:agglomeration)
+            SwissMatch::ActiveRecord::Community.create!(hash, :without_protection => true)
+            print_progress(progress+=1, total)
+          end
+          self_delivered, others = data_source.zip_codes.partition { |code| code.delivery_by.nil? || code.delivery_by == code }
+          process_code = proc do |zip_code|
+            hash                        = zip_code.to_hash
+            hash[:id]                   = hash.delete(:ordering_number)
+            hash[:delivery_by_id]       = hash.delete(:delivery_by)
+            hash[:canton_id]            = canton2id[hash.delete(:canton)]
+            hash[:language]             = LanguageToCode[hash.delete(:language)]
+            hash[:language_alternative] = LanguageToCode[hash.delete(:language_alternative)]
+            hash[:community_id]         = hash.delete(:community)
+            hash.update(
+              :suggested_name_de => zip_code.suggested_name(:de),
+              :suggested_name_fr => zip_code.suggested_name(:fr),
+              :suggested_name_it => zip_code.suggested_name(:it),
+              :suggested_name_rt => zip_code.suggested_name(:rt)
+            )
+            hash.delete(:name_short) # not used
+
+            # FIXME: work around, should be replaced by a proper mechanism
+            hash.delete(:valid_from)
+            hash.delete(:valid_until)
+            hash[:active]               = true
+
+            SwissMatch::ActiveRecord::ZipCode.create!(hash, :without_protection => true)
+            zip_code.names.each do |name|
+              hash                = name.to_hash
+              hash[:language]     = LanguageToCode[hash.delete(:language)]
+              hash[:zip_code_id]  = zip_code.ordering_number
+              hash[:designation]  = 2 # designation of type 3 is not currently in the system
+              SwissMatch::ActiveRecord::ZipCodeName.create!(hash, :without_protection => true)
+            end
+            print_progress(progress+=2, total)
+          end
+
+          self_delivered.each(&process_code)
+          others.each(&process_code)
+        end
+      end
+      puts "","Done"
+    end
+
+    def self.update(data_source=SwissMatch.data)
+    end
+
+    class Migration < ::ActiveRecord::Migration
+      def down
+        try_drop_table :swissmatch_zip_code_names
+        try_drop_table :swissmatch_zip_codes
+        try_drop_table :swissmatch_communities
+        try_drop_table :swissmatch_cantons
+        try_execute "No view support, did not drop view swissmatch_named_zip_codes", "DROP VIEW swissmatch_named_zip_codes"
+      end
+
+      def try_drop_table(name)
+        drop_table name
+      rescue => e
+        warn "Could not drop #{name}: #{e}"
+      end
+
+      def try_execute(failure_message, *sqls)
+        sqls.each do |sql_statements|
+          sql_statements.split(/;\n/).each do |sql_statement|
+            execute(sql_statement.chomp(';'))
+          end
+        end
+      rescue => e
+        warn "#{failure_message} (#{e})"
+      end
+
+      def up
+        create_table :swissmatch_cantons, :comment => 'All swiss cantons as needed by swiss posts MAT[CH], includes the non-cantons DE and IT.' do |t|
+          t.integer :id,          :null => false, :limit => 6,  :comment => 'A unique ID, unrelated to the swiss postal service data.'
+          t.string  :license_tag, :null => false, :limit => 2,  :comment => 'The two letter abbreviation of the cantons name as used on license plates.'
+          t.string  :name,        :null => false, :limit => 32, :comment => 'The canonical name of the canton.'
+          t.string  :name_de,     :null => false, :limit => 32, :comment => 'The name of the canton in german.'
+          t.string  :name_fr,     :null => false, :limit => 32, :comment => 'The name of the canton in french.'
+          t.string  :name_it,     :null => false, :limit => 32, :comment => 'The name of the canton in italian.'
+          t.string  :name_rt,     :null => false, :limit => 32, :comment => 'The name of the canton in rheto-romanic.'
+
+          t.timestamps
+        end
+
+        create_table :swissmatch_communities, :comment => 'The swiss communities as per plz_c file from the swiss posts MAT[CH].' do |t|
+          t.integer  :id,                :null => false, :limit => 6,  :comment => 'A unique, never recycled identification number. Also known as BFSNR.'
+          t.string   :name,              :null => false, :limit => 32, :comment => 'The canonical name of the community.'
+          t.integer  :canton_id,         :null => false, :limit => 6,  :comment => 'The canton this community belongs to.'
+          t.integer  :agglomeration_id,  :null => true,  :limit => 6,  :comment => 'The community this community is considered to be an agglomeration of. Note that a main community will reference itself.'
+
+          t.timestamps
+        end
+
+        create_table :swissmatch_zip_codes, :comment => 'The swiss zip codes as per plz_p1 and plz_p2 files from the swiss posts MAT[CH].' do |t|
+          t.integer :id,                    :null => false, :limit => 6,  :comment => 'The postal ordering number, also known as ONRP. Unique and never recycled.'
+          t.integer :type,                  :null => false, :limit => 16, :comment => 'The type of the entry. One of 10 (Domizil- und Fachadressen), 20 (Nur Domiziladressen), 30 (Nur Fach-PLZ), 40 (Firmen-PLZ) or 80 (Postinterne PLZ).'
+          t.integer :code,                  :null => false, :limit => 16, :comment => 'The 4 digit numeric zip code. Note that the 4 digit code alone does not uniquely identify a zip code record.'
+          t.integer :add_on,                :null => false, :limit => 16, :comment => 'The 2 digit numeric code addition, to distinguish zip codes with the same 4 digit code.'
+          t.integer :canton_id,             :null => false, :limit => 6,  :comment => 'The canton this zip code belongs to.'
+          t.string  :name,                  :null => false, :limit => 27, :comment => 'The canonical name (city) that belongs to this zip code.'
+          t.string  :suggested_name_de,     :null => false, :limit => 27, :comment => 'The suggested name of the zip code (city) for german.'
+          t.string  :suggested_name_fr,     :null => false, :limit => 27, :comment => 'The suggested name of the zip code (city) for french.'
+          t.string  :suggested_name_it,     :null => false, :limit => 27, :comment => 'The suggested name of the zip code (city) for italian.'
+          t.string  :suggested_name_rt,     :null => false, :limit => 27, :comment => 'The suggested name of the zip code (city) for rheto-romanic.'
+          t.integer :language,              :null => false, :limit => 2,  :comment => 'The main language in the area of this zip code. 1 = de, 2 = fr, 3 = it, 4 = rt.'
+          t.integer :language_alternative,  :null => true,  :limit => 2,  :comment => 'The second most used language in the area of this zip code. 1 = de, 2 = fr, 3 = it, 4 = rt.'
+          t.boolean :sortfile_member,       :null => true,                :comment => 'Whether this ZipCode instance is included in the MAT[CH]sort sortfile.'
+          t.integer :delivery_by_id,        :null => true,  :limit => 6,  :comment => 'By which postal office delivery of letters is usually taken care of.'
+          t.integer :community_id,          :null => false, :limit => 6,  :comment => 'The community this zip code belongs to.'
+          t.boolean :active,                :null => false,               :comment => 'Whether this record is currently active.'
+#           t.date    :valid_from,                          :comment => 'The date from which on this zip code starts to be in use.'
+#           t.date    :valid_until,                         :comment => '[CURRENTLY NOT USED] The date until which this zip code is in use.'
+
+          t.timestamps
+        end
+        add_index :swissmatch_zip_codes, [:code]
+
+        create_table :swissmatch_zip_code_names, :comment => 'Contains all primary and alternative names of zip codes.' do |t|
+          t.integer :id,              :null => false, :limit => 6,  :comment => 'An internal ID.'
+          t.integer :zip_code_id,     :null => false, :limit => 6,  :comment => 'The postal ordering number to which this name belongs.'
+          t.string  :name,            :null => false, :limit => 27, :comment => 'The name (city) that belongs to this zip code. At a maximum 27 characters long.'
+          t.integer :language,        :null => false, :limit => 2,  :comment => 'The main language in the area of this zip code. 1 = de, 2 = fr, 3 = it, 4 = rt.'
+          t.integer :sequence_number, :null => false, :limit => 3,  :comment => 'The sequence number of names unique for a single ONRP, a deleted sequence number is never reused.'
+          t.integer :designation,     :null => false, :limit => 2,  :comment => 'The way this name is to be used. Valid values are 2 or 3, 2 2 means this name can be used instead of the zip_code name, 3 means this can be used in addition to the zip_code name.'
+
+          t.timestamps
+        end
+        add_index :swissmatch_zip_code_names, [:name]
+
+        # not every db supports views
+        try_execute "No view support, did not create view swissmatch_named_zip_codes", <<-SQL
+          CREATE VIEW swissmatch_named_zip_codes AS
+            SELECT
+              z.id                    zip_code_id,
+              z.type                  type,
+              n.name                  name,
+              n.language              name_language,
+              n.sequence_number       sequence_number,
+              z.code                  code,
+              z.add_on                add_on,
+              z.canton_id             canton_id,
+              z.language              language,
+              z.language_alternative  language_alternative,
+              z.sortfile_member       sortfile_member,
+              z.delivery_by_id        delivery_by_id,
+              z.community_id          community_id,
+              z.active                active
+            FROM swissmatch_zip_codes z
+            JOIN swissmatch_zip_code_names n ON n.zip_code_id = z.id
+            WHERE n.designation = 2
+        SQL
+
+        # not every db supports comments
+        try_execute "No comment support, did comment on swissmatch_named_zip_codes", <<-SQL
+          COMMENT ON TABLE swissmatch_named_zip_codes IS 'Lists all zip-code/name combinations, an ONRP can occur multiple times.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.zip_code_id IS           'The ONRP of the zip code (swissmatch_zip_codes.id)';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.type IS                  'The type of the entry. One of 10 (Domizil- und Fachadressen), 20 (Nur Domiziladressen), 30 (Nur Fach-PLZ), 40 (Firmen-PLZ) or 80 (Postinterne PLZ).';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.zip_code_id IS           'The postal ordering number to which this name belongs.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.name IS                  'The name (city) that belongs to this zip code. At a maximum 27 characters long.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.name_language IS         'The main language in the area of this zip code. 1 = de, 2 = fr, 3 = it, 4 = rt.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.sequence_number IS       'The sequence number of names unique for a single ONRP, a deleted sequence number is never reused.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.code IS                  'The 4 digit numeric zip code. Note that the 4 digit code alone does not uniquely identify a zip code record.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.add_on IS                'The 2 digit numeric code addition, to distinguish zip codes with the same 4 digit code.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.canton_id IS             'The canton this zip code belongs to.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.name IS                  'The name (city) that belongs to this zip code. At a maximum 27 characters long.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.language IS              'The main language in the area of this zip code. 1 = de, 2 = fr, 3 = it, 4 = rt.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.language_alternative IS  'The second most used language in the area of this zip code. 1 = de, 2 = fr, 3 = it, 4 = rt.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.sortfile_member IS       'Whether this ZipCode instance is included in the MAT[CH]sort sortfile.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.delivery_by_id IS        'By which postal office delivery of letters is usually taken care of.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.community_id IS          'The community this zip code belongs to.';
+          COMMENT ON COLUMN swissmatch_named_zip_codes.active IS                'Whether this record is currently active.';
+        SQL
+
+        # not every db supports foreign key constraints, and maybe there are also syntax differences,
+        try_execute "No foreign key support, did not create foreign key constraints", <<-SQL1, <<-SQL2, <<-SQL3
+          ALTER TABLE swissmatch_communities
+            ADD CONSTRAINT fk_sm_com_0001 FOREIGN KEY (canton_id) REFERENCES swissmatch_cantons(id)
+            ADD CONSTRAINT fk_sm_com_0002 FOREIGN KEY (agglomeration_id) REFERENCES swissmatch_communities(id)
+        SQL1
+          ALTER TABLE swissmatch_zip_codes
+            ADD CONSTRAINT fk_sm_zip_0001 FOREIGN KEY (canton_id) REFERENCES swissmatch_cantons(id)
+            ADD CONSTRAINT fk_sm_zip_0002 FOREIGN KEY (community_id) REFERENCES swissmatch_communities(id)
+            ADD CONSTRAINT fk_sm_zip_0003 FOREIGN KEY (delivery_by_id) REFERENCES swissmatch_zip_codes(id)
+        SQL2
+          ALTER TABLE swissmatch_zip_code_names
+            ADD CONSTRAINT fk_sm_nam_0001 FOREIGN KEY (zip_code_id) REFERENCES swissmatch_zip_codes(id)
+        SQL3
+      end
+    end
+
+    class ZipCode < ::ActiveRecord::Base
+      self.table_name         = "swissmatch_zip_codes"
+      self.inheritance_column = "no_sti_in_this_model" # set it to something unused, so 'type' can be used as column name
+
+      alias_attribute :ordering_number, :id
+
+      belongs_to :canton,      :class_name => 'SwissMatch::ActiveRecord::Canton'
+      belongs_to :community,   :class_name => 'SwissMatch::ActiveRecord::Community'
+      belongs_to :delivery_by, :class_name => 'SwissMatch::ActiveRecord::ZipCode'
+      has_many   :delivers,    :class_name => 'SwissMatch::ActiveRecord::ZipCode', :foreign_key => 'delivery_by_id'
+      has_many   :names,       :class_name => 'SwissMatch::ActiveRecord::ZipCodeName'
+    end
+    class ZipCodeName < ::ActiveRecord::Base
+      self.table_name         = "swissmatch_zip_code_names"
+
+      belongs_to :zip_code,    :class_name => 'SwissMatch::ActiveRecord::ZipCode'
+    end
+    class Community < ::ActiveRecord::Base
+      self.table_name = "swissmatch_communities"
+
+      alias_attribute :community_number, :id
+
+      belongs_to :canton,         :class_name => 'SwissMatch::ActiveRecord::Canton'
+      belongs_to :agglomeration,  :class_name => 'SwissMatch::ActiveRecord::Community'
+      has_many   :zip_codes,      :class_name => 'SwissMatch::ActiveRecord::ZipCode'
+    end
+    class Canton < ::ActiveRecord::Base
+      self.table_name = "swissmatch_cantons"
+
+      has_many :zip_codes,    :class_name => 'SwissMatch::ActiveRecord::ZipCode'
+      has_many :communities,  :class_name => 'SwissMatch::ActiveRecord::Community'
+    end
+  end
+end

data/lib/swissmatch/rails.rb

@@ -0,0 +1,29 @@
+# To use SwissMatch in rails, best use this line in your Gemfile:
+#     gem 'swissmatch', :require => 'swissmatch/rails'
+
+
+
+raise "This file should be required after rails has been loaded" unless defined?(ActiveSupport)
+
+ActiveSupport.on_load(:before_initialize) do
+  require 'swissmatch'
+
+  # Load environment specific configuration
+  config_path       = Rails.root.join('config/swissmatch.yml')
+  configuration_all = File.exist?(config_path) ? YAML.load_file(config_path) : {}
+  configuration     = configuration_all['global'] || {}
+  configuration.merge!(configuration_all[Rails.env] || {})
+
+  # Load zip-code data
+  if configuration['data_directory'] then
+    SwissMatch.load(SwissMatch::DataFiles.new(configuration['data_directory']))
+  else
+    SwissMatch.load
+  end
+
+  # Load directory services
+  if configuration['telsearch_key'] then
+    require 'swissmatch/telsearch'
+    SwissMatch.directory_service = SwissMatch::TelSearch.new(configuration['telsearch_key'])
+  end
+end

data/lib/swissmatch.rb

@@ -0,0 +1,216 @@
+# encoding: utf-8
+
+
+
+require 'date'
+require 'swissmatch/ruby'
+require 'swissmatch/canton'
+require 'swissmatch/cantons'
+require 'swissmatch/community'
+require 'swissmatch/communities'
+require 'swissmatch/datafiles'
+require 'swissmatch/version'
+require 'swissmatch/zipcode'
+require 'swissmatch/zipcodes'
+
+
+
+# SwissMatch
+# Deal with swiss zip codes, cities, communities and cantons.
+#
+# Notice that all strings passed to SwissMatch are expected to be utf-8. All strings
+# returned by SwissMatch are also in utf-8.
+#
+# @example Load the data
+#     require 'swissmatch'
+#     SwissMatch.load
+#     # alternatively, just require 'swissmatch/autoload'
+#
+# @example Get the ONRP for a given zip-code + city
+#     require 'swissmatch/autoload'
+#     SwissMatch.zip_code(8000, 'Zürich').ordering_number # => 
+module SwissMatch
+  @data               = nil
+  @directory_service  = nil
+
+  class <<self
+    # @return [SwissMatch::DataFiles, nil] The data source used
+    attr_reader :data
+
+    # @return [SwissMatch::DirectoryService, nil]
+    # The directory service used to search for addresses
+    attr_accessor :directory_service
+  end
+
+  def self.canton(name_or_plate)
+    @data.cantons[name_or_plate]
+  end
+
+  def self.cantons
+    @data.cantons
+  end
+
+  def self.community(key)
+    @data.communities.by_community_number(key)
+  end
+
+  def self.communities(name=nil)
+    name ? @data.communities.by_name(name) : @data.communities
+  end
+
+  # @param [String, Integer] code_or_name
+  #   Either the 4 digit zip code as Integer or String, or the city name as a String in
+  #   utf-8.
+  #
+  # @return [Array<SwissMatch::ZipCode>]
+  #   A list of zip codes with the given code or name.
+  def self.zip_codes(code_or_name=nil)
+    case code_or_name
+      when Integer, /\A\d{4}\z/
+        @data.zip_codes.by_code(code_or_name.to_i)
+      when String
+        @data.zip_codes.by_name(code_or_name)
+      when nil
+        @data.zip_codes
+      else
+        raise ArgumentError, "Invalid argument, must be a ZipCode#code (Integer or String) or ZipCode#name (String)"
+    end
+  end
+
+  # Returns a single zip code. A zip code can be uniquely identified by any of:
+  # * Its ordering_number (ONRP, a 4 digit Integer)
+  # * Its zip code (4 digit Integer) and add-on (2 digit Integer)
+  # * Its zip code (4 digit Integer) and any official name (String)
+  # The data can be passed in different ways, e.g. all numbers can be passed either
+  # as a String or as an Integer. The identification by zip code and add-on can be done
+  # by either using a combined 6 digit number (e.g. 800000 for "8000 Zürich"), or by
+  # passing 2 arguments, passing the zip code and the add-on separately.
+  #
+  # === IMPORTANT
+  # You must be aware, that passing a single 4-digit code to SwissMatch::zip_code uses
+  # the ONRP, and NOT the zip-code. The 4 digit zip code alone does NOT uniquely identify
+  # a zip code.
+  #
+  #
+  # @example Get a zip code by ONRP
+  #   SwissMatch.zip_code(4384)           # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #
+  # @example Get a zip code by 4-digit code and add-on
+  #   SwissMatch.zip_code(8000, 0)        # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #   SwissMatch.zip_code("8000", "00")   # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #   SwissMatch.zip_code(800000)         # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #   SwissMatch.zip_code("800000")       # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #
+  # @example Get a zip code by 4-digit code and name
+  #   SwissMatch.zip_code(8000, "Zürich") # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #   SwissMatch.zip_code(8000, "Zurigo") # => #<SwissMatch::ZipCode:003ff996cf8d3c 8000 Zürich>
+  #
+  #
+  # @param [String, Integer] code
+  #   The 4 digit zip code as Integer or String
+  # @param [String, Integer] city_or_add_on
+  #   Either the 2 digit zip-code add-on as string or integer, or the city name as a
+  #   String in utf-8.
+  #
+  # @return [SwissMatch::ZipCode]
+  #   The zip codes with the given code and the given add-on or name.
+  def self.zip_code(code, city_or_add_on=nil)
+    case city_or_add_on
+      when nil
+        @data.zip_codes.by_ordering_number(code.to_i)
+      when Integer, /\A\d\d\z/
+        @data.zip_codes.by_code_and_add_on(code.to_i, city_or_add_on.to_i)
+      when String
+        @data.zip_codes.by_code_and_name(code.to_i, city_or_add_on)
+      else
+        raise ArgumentError, "Invalid second argument, must be nil, ZipCode#add_on or ZipCode#name"
+    end
+  end
+
+  # @param [String] name
+  #   The name for which to return matching zip codes
+  #
+  # @return [Array<SwissMatch::ZipCode>]
+  #   Zip codes whose name equals the given name
+  def self.city(name)
+    @data.zip_codes.by_name(name)
+  end
+
+  # @param [String, Integer] code
+  #   The 4 digit zip code
+  # @param [nil, Array<Integer>] only_types
+  #   An array of zip code types (see ZipCode#type) which the returned zip codes must match.
+  # @param [nil, Symbol] locale
+  #   Return the names in the given locale, defaults to nil/:native (nil and :native are
+  #   treated the same and will return the native names)
+  #
+  # @return [Array<String>]
+  #   A list of unique names matching the parameters (4 digit code, type, locale).
+  def self.cities_for_zip_code(code, only_types=nil, locale=nil)
+    codes = @data.zip_codes.by_code(code.to_i)
+    return [] unless codes
+    codes = codes.select { |code| only_types.include?(code.type) } if only_types
+    names = case locale
+      when :native,nil then codes.map(&:name)
+      when :de then codes.map(&:name_de)
+      when :fr then codes.map(&:name_fr)
+      when :it then codes.map(&:name_it)
+      when :rt then codes.map(&:name_rt)
+      else raise ArgumentError, "Invalid locale #{locale}"
+    end
+
+    names.uniq
+  end
+
+  def self.load(data_source=nil)
+    @data = data_source || DataFiles.new
+    @data.load!
+  end
+
+  # @private
+  # Used to transliterate city names
+  Transliteration1 = {
+    "à" => "a",
+    "â" => "a",
+    "ä" => "a",
+    "è" => "e",
+    "é" => "e",
+    "ê" => "e",
+    "ë" => "e",
+    "ì" => "i",
+    "î" => "i",
+    "ï" => "i",
+    "ô" => "o",
+    "ö" => "o",
+    "ù" => "u",
+    "ü" => "u",
+  }
+
+  # @private
+  # Used to transliterate city names
+  Transliteration2 = Transliteration1.merge({
+    "ä" => "ae",
+    "ö" => "oe",
+    "ü" => "ue",
+  })
+
+  # @private
+  # Used to transliterate city names
+  TransMatch1 = /#{Transliteration1.keys.map { |k| Regexp.escape(k) }.join("|")}/
+
+  # @private
+  # Used to transliterate city names
+  TransMatch2 = /#{Transliteration2.keys.map { |k| Regexp.escape(k) }.join("|")}/
+
+  # @private
+  # Used to transliterate city names
+  def self.transliterate1(word)
+    word.gsub(TransMatch1, Transliteration1).delete("^ A-Za-z").downcase
+  end
+
+  # @private
+  # Used to transliterate city names
+  def self.transliterate2(word)
+    word.gsub(TransMatch2, Transliteration2).delete("^ A-Za-z").downcase
+  end
+end

data/swissmatch-rails.gemspec

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name                      = "swissmatch-rails"
+  s.version                   = "0.0.1"
+  s.authors                   = "Stefan Rusterholz"
+  s.email                     = "stefan.rusterholz@gmail.com"
+  s.homepage                  = "http://github.com/apeiros/swissmatch-rails"
+
+  s.description               = <<-DESCRIPTION.gsub(/^    /, '').chomp
+    Adds ActiveRecord models and javascript assets for rails to swissmatch.
+  DESCRIPTION
+
+  s.summary                   = <<-SUMMARY.gsub(/^    /, '').chomp
+    Adds ActiveRecord models and javascript assets for rails to swissmatch.
+  SUMMARY
+
+  s.files                     =
+    Dir['bin/**/*'] +
+    Dir['data/**/*'] +
+    Dir['lib/**/*'] +
+    Dir['rake/**/*'] +
+    Dir['test/**/*'] +
+    Dir['*.gemspec'] +
+    %w[
+      LICENSE.txt
+      Rakefile
+      README.markdown
+    ]
+
+  if File.directory?('bin') then
+    executables = Dir.chdir('bin') { Dir.glob('**/*').select { |f| File.executable?(f) } }
+    s.executables = executables unless executables.empty?
+  end
+
+  s.add_dependency "swissmatch"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1")
+  s.rubygems_version          = "1.3.1"
+  s.specification_version     = 3
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: swissmatch-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Stefan Rusterholz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: swissmatch
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds ActiveRecord models and javascript assets for rails to swissmatch.
+email: stefan.rusterholz@gmail.com
+executables:
+- swissmatch_db
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/swissmatch_db
+- lib/swissmatch/activerecord.rb
+- lib/swissmatch/rails.rb
+- lib/swissmatch.rb
+- swissmatch-rails.gemspec
+- LICENSE.txt
+- Rakefile
+- README.markdown
+homepage: http://github.com/apeiros/swissmatch-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Adds ActiveRecord models and javascript assets for rails to swissmatch.
+test_files: []
+has_rdoc: