Module: PostalCoder::Formats

Defined in:
lib/postalcoder/formats.rb

Defined Under Namespace

Classes: AbstractFormat, CAPostalCode, USZipCode

Constant Summary collapse

SYMBOLS_TO_NAMES_MAP = 
{
:ca_postal_code => 'CAPostalCode',
:us_zip_code => 'USZipCode' }

Class Method Summary collapse

Class Method Details

.auto_instantiate(postal_code, accepted_formats = Config[:accepted_formats]) ⇒ Object

Raises:



42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/postalcoder/formats.rb', line 42

def self.auto_instantiate(postal_code, accepted_formats = Config[:accepted_formats])
  results = symbols_to_classes(accepted_formats).map do |format|
    begin
      format.new(postal_code)
    rescue Errors::MalformedPostalCodeError
      nil
    end
  end.compact
  return results[0] if results.any?
  raise Errors::MalformedPostalCodeError, "The postal code: #{postal_code}" \
  ' did not properly map to any of the accepted formats.'
end

.instantiate(postal_code, format_symbol = nil) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/postalcoder/formats.rb', line 30

def self.instantiate(postal_code, format_symbol = nil)
  unless postal_code.is_a?(String)
    raise Errors::MalformedPostalCodeError, 'postal_code must be a ' \
    "String, not: #{postal_code.class}"
  end
  if format_symbol
    symbol_to_class(format_symbol).new(postal_code)
  else
    auto_instantiate(postal_code)
  end
end

.symbol_to_class(symbol) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/postalcoder/formats.rb', line 8

def self.symbol_to_class(symbol)
  unless symbol.is_a?(Symbol)
    raise ArgumentError, "expected Symbol, not: #{symbol.class}"
  end
  class_name = SYMBOLS_TO_NAMES_MAP.fetch(symbol) do |sym|
    raise Errors::UnknownFormatSymbolError, 'The format symbol ' \
    "#{sym.inspect} is not one of the reconized symbols, which are: " \
    "#{SYMBOLS_TO_NAMES_MAP.keys.inspect}"
  end
  eval class_name
end

.symbols_to_classes(symbols) ⇒ Object 



20
21
22
23
24
25
26
27
28
 
# File 'lib/postalcoder/formats.rb', line 20

def self.symbols_to_classes(symbols)
  unless symbols.is_a?(Array)
    raise ArgumentError, "symbols must be Array, not: #{symbols.class}"
  end
  if symbols.empty?
    raise ArgumentError, 'symbols must contain format symbols, it is empty.'
  end
  symbols.map { |f| symbol_to_class(f) }
end