Class: SwissMunicipality

Inherits:
Object
  • Object
show all
Defined in:
lib/swiss_municipality.rb

Overview

require ‘swiss_municipality’

Defined Under Namespace

Classes: MunicipalityData

Class Method Summary collapse

Class Method Details

.all_cantons(options) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/swiss_municipality.rb', line 35

def self.all_cantons(options)
  options = sanitize_options(options)
  validate_variant(options)

  if options[:variant] == :short
    MunicipalityData.canton_hash.keys.sort
  elsif options[:variant] == :full
    MunicipalityData.canton_hash.values.map { |canton| canton[:full_name][options[:language]] }
  end
end

.all_municipalities(**options) ⇒ Object 



57
58
59
60
61
62
63
64
65
 
# File 'lib/swiss_municipality.rb', line 57

def self.all_municipalities(**options)
  options = sanitize_options(options)

  if options[:canton].nil?
    MunicipalityData.municipality_hash
  else
    MunicipalityData.canton_hash[options[:canton]][:municipalities]
  end.keys.sort.map(&:to_s)
end

.all_zip_codes(**options) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/swiss_municipality.rb', line 67

def self.all_zip_codes(**options)
  options = sanitize_options(options)

  zip_code_data = if !options[:municipality].nil?
                    MunicipalityData.municipality_hash[options[:municipality]][:zip_codes]
                  elsif !options[:canton].nil?
                    MunicipalityData.canton_hash[options[:canton]][:zip_codes]
                  else
                    MunicipalityData.zip_hash.keys
                  end

  if options[:variant] == :with_municipality
    zip_code_data.map { |zip_code| [zip_code, MunicipalityData.zip_hash[zip_code.to_sym][:municipality]].join(' ') }
  else
    zip_code_data.map(&:to_s)
  end.sort
end

.canton(**options) ⇒ Object

Raises:

  • (ArgumentError) 


10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/swiss_municipality.rb', line 10

def self.canton(**options)
  options = sanitize_options(options)
  validate_identifier(options)
  validate_variant(options)

  raise ArgumentError, 'Argument canton must not be given' unless options[:canton].nil?

  if options[:municipality].nil?
    zip_code_data = MunicipalityData.zip_hash[options[:zip_code]]

    raise ArgumentError, "No municipality found for zip code #{options[:zip_code]}" if zip_code_data.nil?

    canton_data = zip_code_data[:canton]
  else
    municipality_data = MunicipalityData.municipality_hash[options[:municipality]]
    canton_data = municipality_data[:canton]
  end

  if options[:variant] == :short
    canton_data[:short]
  elsif options[:variant] == :full
    canton_data[options[:language]]
  end
end

.municipality(**options) ⇒ Object

Raises:

  • (ArgumentError) 


46
47
48
49
50
51
52
53
54
55
 
# File 'lib/swiss_municipality.rb', line 46

def self.municipality(**options)
  options = sanitize_options(options)
  validate_identifier(options)

  raise ArgumentError, 'Argument municipality must not be given' unless options[:municipality].nil?
  raise ArgumentError, 'Argument canton must not be given' unless options[:canton].nil?

  zip_code_data = MunicipalityData.zip_hash[options[:zip_code]]
  zip_code_data[:municipality]
end

.sanitize_options(options) ⇒ Object 



85
86
87
88
89
90
91
92
93
 
# File 'lib/swiss_municipality.rb', line 85

def self.sanitize_options(options)
  options[:variant] = options[:variant]&.to_s&.downcase&.to_sym
  options[:language] = options[:language]&.to_s&.downcase&.gsub('-ch', '')&.to_s&.to_sym
  options[:zip_code] = options[:zip_code]&.to_s&.to_sym
  options[:municipality] = options[:municipality]&.to_s&.to_sym
  options[:canton] = options[:canton]&.to_s&.to_sym

  options
end

.validate_identifier(options) ⇒ Object

Raises:

  • (ArgumentError) 


106
107
108
109
110
 
# File 'lib/swiss_municipality.rb', line 106

def self.validate_identifier(options)
  return unless [options[:zip_code], options[:municipality], options[:canton]].compact.count != 1

  raise ArgumentError, 'Exactly one of the arguments zip_code, municipality or canton must be given'
end

.validate_variant(options) ⇒ Object

Raises:

  • (ArgumentError) 


95
96
97
98
99
100
101
102
103
104
 
# File 'lib/swiss_municipality.rb', line 95

def self.validate_variant(options)
  unless %i[short full].include? options[:variant]
    raise ArgumentError, "'Argument variant must be provided. The allowed values are 'short' and 'full'"
  end

  return unless options[:variant] == :full && !%i[de fr it].include?(options[:language])

  raise ArgumentError,
        "Language must be provided for variant :full. The allowed values are 'de-CH', 'de', 'fr-CH', 'fr', 'it-CH', 'it'"
end