telephone_number 1.1.1 → 1.2.0.rc1

data/lib/active_model/telephone_number_validator.rb

@@ -0,0 +1,9 @@
+class TelephoneNumberValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    country = options[:country].call(record) if options.key?(:country)
+    valid_types = options.fetch(:types, [])
+    args = [value, country, valid_types]
+
+    record.errors.add(attribute, :invalid) if TelephoneNumber.invalid?(*args)
+  end
+end

data/lib/telephone_number/class_methods.rb

@@ -1,10 +1,17 @@
 module TelephoneNumber
   module ClassMethods
-    def parse(number, country = Parser.detect_country(number))
-      TelephoneNumber::Number.new(number, country)
+    attr_accessor :override_file, :default_format_string
+    attr_reader :default_format_pattern
+
+    def default_format_pattern=(format_string)
+      @default_format_pattern = Regexp.new(format_string)
+    end
+
+    def parse(number, country = detect_country(number))
+      TelephoneNumber::Number.new(sanitize(number), country)
     end
 
-    def valid?(number, country = Parser.detect_country(number), keys = [])
+    def valid?(number, country = detect_country(number), keys = [])
       parse(number, country).valid?(keys)
     end
 
@@ -12,6 +19,19 @@ module TelephoneNumber
       !valid?(*args)
     end
 
+    def sanitize(input_number)
+      input_number.to_s.gsub(/\D/, '')
+    end
+
+    def detect_country(number)
+      sanitized_number = sanitize(number)
+      detected_country = Country.all_countries.detect do |country|
+        sanitized_number.start_with?(country.country_code) && valid?(sanitized_number, country.country_id)
+      end
+
+      detected_country.country_id.to_sym if detected_country
+    end
+
     # generates binary file from xml that user gives us
     def generate_override_file(file)
       DataImporter.new(file, override: true).import!

data/lib/telephone_number/country.rb

@@ -0,0 +1,67 @@
+module TelephoneNumber
+  class Country
+    attr_reader :country_code, :national_prefix, :national_prefix_formatting_rule,
+                :national_prefix_for_parsing, :national_prefix_transform_rule, :international_prefix,
+                :formats, :validations, :mobile_token, :country_id, :general_validation, :main_country_for_code
+
+    MOBILE_TOKEN_COUNTRIES = { AR: '9' }
+
+    def initialize(data_hash)
+      @country_code = data_hash[:country_code]
+      @country_id = data_hash[:id]
+      @formats = data_hash.fetch(:formats, []).map { |format| NumberFormat.new(format) }
+      @general_validation = NumberValidation.new(:general_desc, data_hash[:validations][:general_desc]) if data_hash.fetch(:validations, {})[:general_desc]
+      @international_prefix = Regexp.new(data_hash[:international_prefix]) if data_hash[:international_prefix]
+      @main_country_for_code = data_hash[:main_country_for_code] == 'true'
+      @mobile_token = MOBILE_TOKEN_COUNTRIES[@country_id.to_sym]
+      @national_prefix = data_hash[:national_prefix]
+      @national_prefix_formatting_rule = data_hash[:national_prefix_formatting_rule]
+      @national_prefix_for_parsing = Regexp.new(data_hash[:national_prefix_for_parsing]) if data_hash[:national_prefix_for_parsing]
+      @national_prefix_transform_rule = data_hash[:national_prefix_transform_rule]
+      @validations = data_hash.fetch(:validations, {})
+                              .except(:general_desc, :area_code_optional)
+                              .map { |name, data| NumberValidation.new(name, data) }
+    end
+
+    def detect_format(number)
+      native_format = formats.detect do |format|
+        number =~ Regexp.new("^(#{format.leading_digits})") && number =~ Regexp.new("^(#{format.pattern})$")
+      end
+
+      return native_format if native_format || main_country_for_code
+      parent_country.detect_format(number) if parent_country
+    end
+
+    def parent_country
+      return if main_country_for_code
+      Country.all_countries.detect do |country|
+        country.country_code == self.country_code && country.main_country_for_code
+      end
+    end
+
+    def full_general_pattern
+      %r{^(#{country_code})?(#{national_prefix})?(?<national_num>#{general_validation.pattern})$}
+    end
+
+    def self.phone_data
+      @phone_data ||= load_data
+    end
+
+    def self.find(country_id)
+      data = phone_data[country_id.to_s.upcase.to_sym]
+      new(data) if data
+    end
+
+    def self.load_data
+      data_file = "#{File.dirname(__FILE__)}/../../data/telephone_number_data_file.dat"
+      main_data = Marshal.load(File.binread(data_file))
+      override_data = {}
+      override_data = Marshal.load(File.binread(TelephoneNumber.override_file)) if TelephoneNumber.override_file
+      return main_data.deep_deep_merge!(override_data)
+    end
+
+    def self.all_countries
+      @all_countries ||= phone_data.values.map {|data| new(data)}
+    end
+  end
+end

data/lib/telephone_number/data_importer.rb

@@ -33,7 +33,7 @@ module TelephoneNumber
         {}.tap do |fhash|
           format.attributes.values.each do |attr|
             key = underscore(attr.name).to_sym
-            fhash[key] = if key == PhoneData::NATIONAL_PREFIX_FORMATTING_RULE
+            fhash[key] = if key == :national_prefix_formatting_rule
                            attr.value
                          else
                            attr.value.delete("\n ")
@@ -41,30 +41,30 @@ module TelephoneNumber
           end
           format.elements.each do |child|
             key = underscore(child.name).to_sym
-            fhash[key] = [PhoneData::FORMAT, PhoneData::INTL_FORMAT].include?(key) ? child.text : child.text.delete("\n ")
+            fhash[key] = [:format, :intl_format].include?(key) ? child.text : child.text.delete("\n ")
           end
         end
       end
 
       return if override && formats_arr.empty?
-      country_data[PhoneData::FORMATS] = formats_arr
+      country_data[:formats] = formats_arr
     end
 
     def load_validations(country_data, territory)
-      country_data[PhoneData::VALIDATIONS] = {}
+      country_data[:validations] = {}
       territory.elements.each do |element|
         next if element.name == 'references' || element.name == 'availableFormats'
-        country_data[PhoneData::VALIDATIONS][underscore(element.name).to_sym] = {}.tap do |validation_hash|
+        country_data[:validations][underscore(element.name).to_sym] = {}.tap do |validation_hash|
           element.elements.each { |child| validation_hash[underscore(child.name).to_sym] = child.text.delete("\n ") }
         end
       end
-      country_data.delete(PhoneData::VALIDATIONS) if country_data[PhoneData::VALIDATIONS].empty? && override
+      country_data.delete(:validations) if country_data[:validations].empty? && override
     end
 
     def load_base_attributes(country_data, territory)
       territory.attributes.each do |key, value_object|
         underscored_key = underscore(key).to_sym
-        country_data[underscored_key] = if underscored_key == PhoneData::NATIONAL_PREFIX_FOR_PARSING
+        country_data[underscored_key] = if underscored_key == :national_prefix_for_parsing
                                           value_object.value.delete("\n ")
                                         else
                                           value_object.value
@@ -94,4 +94,3 @@ module TelephoneNumber
     end
   end
 end
-

data/lib/telephone_number/formatter.rb

@@ -1,39 +1,28 @@
 module TelephoneNumber
   class Formatter
-    extend Forwardable
 
-    attr_reader :normalized_number, :phone_data, :valid
+    attr_reader :normalized_number, :country, :valid, :original_number
 
-    delegate [:country_data, :country] => :phone_data
-
-    def initialize(number_obj, phone_data)
+    def initialize(number_obj)
       @normalized_number = number_obj.normalized_number
-      @phone_data = phone_data
+      @country = number_obj.country
       @valid = number_obj.valid?
+      @original_number = number_obj.original_number
     end
 
     def national_number(formatted: true)
-      if formatted
-        @formatted_national_number ||= build_national_number
-      else
-        @national_number ||= build_national_number(formatted: false)
-      end
+      return original_or_default if !valid? || !number_format
+      build_national_number(formatted: formatted)
     end
 
     def e164_number(formatted: true)
-      if formatted
-        @formatted_e164_number ||= build_e164_number
-      else
-        @e164_number ||= build_e164_number(formatted: false)
-      end
+      return original_or_default if !valid?
+      build_e164_number(formatted: formatted)
     end
 
     def international_number(formatted: true)
-      if formatted
-        @formatted_international_number ||= build_international_number
-      else
-        @international_number ||= build_international_number(formatted: false)
-      end
+      return original_or_default if !valid? || !number_format
+      build_international_number(formatted: formatted)
     end
 
     alias_method :valid?, :valid
@@ -41,73 +30,47 @@ module TelephoneNumber
     private
 
     def number_format
-      @number_format ||= extract_number_format
+      @number_format ||= country.detect_format(normalized_number)
     end
 
     def build_national_number(formatted: true)
-      return normalized_or_default if !valid? || number_format.nil?
-      captures = normalized_number.match(Regexp.new(number_format[PhoneData::PATTERN])).captures
-      national_prefix_formatting_rule = number_format[PhoneData::NATIONAL_PREFIX_FORMATTING_RULE] \
-                                         || country_data[PhoneData::NATIONAL_PREFIX_FORMATTING_RULE]
+      captures = normalized_number.match(number_format.pattern).captures
+      national_prefix_formatting_rule = number_format.national_prefix_formatting_rule || country.national_prefix_formatting_rule
 
-      formatted_string = format(ruby_format_string(number_format[PhoneData::FORMAT]), *captures)
-      captures.delete(PhoneData::MOBILE_TOKEN_COUNTRIES[country])
+      formatted_string = format(ruby_format_string(number_format.format), *captures)
+      captures.delete(country.mobile_token)
 
       if national_prefix_formatting_rule
         national_prefix_string = national_prefix_formatting_rule.dup
-        national_prefix_string.gsub!(/\$NP/, country_data[PhoneData::NATIONAL_PREFIX])
+        national_prefix_string.gsub!(/\$NP/, country.national_prefix)
         national_prefix_string.gsub!(/\$FG/, captures[0])
         formatted_string.sub!(captures[0], national_prefix_string)
       end
 
-      formatted ? formatted_string : Parser.sanitize(formatted_string)
+      formatted ? formatted_string : TelephoneNumber.sanitize(formatted_string)
     end
 
     def build_e164_number(formatted: true)
-      return normalized_or_default if !country_data || normalized_number.empty?
-      formatted_string = "+#{country_data[PhoneData::COUNTRY_CODE]}#{normalized_number}"
-      formatted ? formatted_string : Parser.sanitize(formatted_string)
+      formatted_string = "+#{country.country_code}#{normalized_number}"
+      formatted ? formatted_string : TelephoneNumber.sanitize(formatted_string)
     end
 
     def build_international_number(formatted: true)
-      return normalized_or_default if !valid? || number_format.nil?
-      captures = normalized_number.match(Regexp.new(number_format[PhoneData::PATTERN])).captures
-      key = number_format.fetch(PhoneData::INTL_FORMAT, 'NA') != 'NA' ? PhoneData::INTL_FORMAT : PhoneData::FORMAT
-      formatted_string = "+#{country_data[PhoneData::COUNTRY_CODE]} #{format(ruby_format_string(number_format[key]), *captures)}"
-      formatted ? formatted_string : Parser.sanitize(formatted_string)
+      return original_or_default if !valid? || number_format.nil?
+      captures = normalized_number.match(number_format.pattern).captures
+      key = number_format.intl_format || number_format.format
+      formatted_string = "+#{country.country_code} #{format(ruby_format_string(key), *captures)}"
+      formatted ? formatted_string : TelephoneNumber.sanitize(formatted_string)
     end
 
     def ruby_format_string(format_string)
       format_string.gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
     end
 
-    def normalized_or_default
-      return normalized_number unless TelephoneNumber.default_format_string && TelephoneNumber.default_format_pattern
-      captures = normalized_number.match(TelephoneNumber.default_format_pattern).captures
+    def original_or_default
+      return original_number unless TelephoneNumber.default_format_string && TelephoneNumber.default_format_pattern
+      captures = original_number.match(TelephoneNumber.default_format_pattern).captures
       format(ruby_format_string(TelephoneNumber.default_format_string), *captures)
     end
-
-    def extract_number_format
-      native_country_format = detect_format(country.to_sym)
-      return native_country_format if native_country_format
-
-      # This means we couldn't find an applicable format so we now need to scan through the hierarchy
-      parent_country_code = PhoneData.phone_data.detect do |_country_code, country_data|
-        country_data[PhoneData::COUNTRY_CODE] == PhoneData.phone_data[self.country.to_sym][PhoneData::COUNTRY_CODE] \
-          && country_data[PhoneData::MAIN_COUNTRY_FOR_CODE] == 'true'
-      end
-
-      detect_format(parent_country_code[0]) if parent_country_code
-    end
-
-    def detect_format(country_code)
-      PhoneData.phone_data[country_code.to_sym][PhoneData::FORMATS].detect do |format|
-        (format[PhoneData::LEADING_DIGITS].nil? \
-          || normalized_number =~ Regexp.new("^(#{format[PhoneData::LEADING_DIGITS]})")) \
-          && normalized_number =~ Regexp.new("^(#{format[PhoneData::PATTERN]})$")
-      end
-    end
   end
 end
-
-

data/lib/telephone_number/number.rb

@@ -2,15 +2,16 @@ module TelephoneNumber
   class Number
     extend Forwardable
 
-    attr_reader :phone_data, :parser, :formatter
+    attr_reader :country, :parser, :formatter, :original_number
 
     delegate [:valid?, :valid_types, :normalized_number] => :parser
     delegate [:national_number, :e164_number, :international_number] => :formatter
 
     def initialize(number, country)
-      @phone_data = PhoneData.new(country)
-      @parser = Parser.new(number, @phone_data)
-      @formatter = Formatter.new(self, @phone_data)
+      @original_number = number
+      @country = Country.find(country)
+      @parser = Parser.new(self)
+      @formatter = Formatter.new(self)
     end
   end
 end

data/lib/telephone_number/number_format.rb

@@ -0,0 +1,14 @@
+module TelephoneNumber
+  class NumberFormat
+
+    attr_reader :pattern, :leading_digits, :format, :national_prefix_formatting_rule, :intl_format
+
+    def initialize(data_hash)
+      @pattern = Regexp.new(data_hash[:pattern]) if data_hash[:pattern]
+      @leading_digits = Regexp.new(data_hash[:leading_digits]) if data_hash[:leading_digits]
+      @format = data_hash[:format]
+      @intl_format = data_hash[:intl_format]
+      @national_prefix_formatting_rule = data_hash[:national_prefix_formatting_rule]
+    end
+  end
+end

data/lib/telephone_number/number_validation.rb

@@ -0,0 +1,10 @@
+module TelephoneNumber
+  class NumberValidation
+    attr_reader :name, :pattern
+
+    def initialize(name, data_hash)
+      @name = name
+      @pattern = data_hash[:national_number_pattern]
+    end
+  end
+end

data/lib/telephone_number/parser.rb

@@ -1,16 +1,11 @@
 module TelephoneNumber
   class Parser
-    KEYS_TO_SKIP = [PhoneData::GENERAL, PhoneData::AREA_CODE_OPTIONAL]
-    extend Forwardable
+    attr_reader :original_number, :normalized_number, :country
 
-    delegate [:country_data, :country] => :phone_data
-    attr_reader :sanitized_number, :original_number, :normalized_number, :phone_data
-
-    def initialize(original_number, phone_data)
-      @sanitized_number = self.class.sanitize(original_number)
-      @phone_data = phone_data
-      @original_number = original_number
-      @normalized_number = build_normalized_number
+    def initialize(number_obj)
+      @original_number = number_obj.original_number
+      @country = number_obj.country
+      @normalized_number = build_normalized_number if @country
     end
 
     def valid_types
@@ -21,59 +16,35 @@ module TelephoneNumber
       keys.empty? ? !valid_types.empty? : !(valid_types & keys.map(&:to_sym)).empty?
     end
 
-    def self.detect_country(number)
-      sanitized_number = sanitize(number)
-      detected_country = PhoneData.phone_data.detect(->{[]}) do |two_letter, value|
-        sanitized_number =~ Regexp.new("^#{value[:country_code]}") && new(sanitized_number, PhoneData.new(two_letter)).valid?
-      end.first
-    end
-
-    def self.sanitize(input_number)
-      return input_number.to_s.gsub(/\D/, '')
-    end
-
     private
 
-    # returns an array of valid types for the normalized number
-    # if array is empty, we can assume that the number is invalid
-    def validate
-      return [] unless country_data
-      applicable_keys = country_data[PhoneData::VALIDATIONS].reject { |key, _value| KEYS_TO_SKIP.include?(key) }
-      applicable_keys.map do |phone_type, validations|
-        full = "^(#{validations[PhoneData::VALID_PATTERN]})$"
-        phone_type.to_sym if normalized_number =~ Regexp.new(full)
-      end.compact
-    end
-
     # normalized_number is basically a "best effort" at national number without
     # any formatting. This is what we will use to derive formats, validations and
     # basically anything else that uses google data
     def build_normalized_number
-      return sanitized_number unless country_data
-      country_code = country_data[PhoneData::COUNTRY_CODE]
-
-      number_with_correct_prefix = parse_prefix
-
-      reg_string = "^(#{country_code})?"
-      reg_string << "(#{country_data[PhoneData::NATIONAL_PREFIX]})?"
-      reg_string << "(#{country_data[PhoneData::VALIDATIONS][PhoneData::GENERAL][PhoneData::VALID_PATTERN]})$"
+      match_result = parse_prefix.match(country.full_general_pattern)
+      match_result ? match_result[:national_num] : original_number
+    end
 
-      match_result = number_with_correct_prefix.match(Regexp.new(reg_string))
-      return sanitized_number unless match_result
-      prefix_results = [match_result[1], match_result[2]]
-      number_with_correct_prefix.sub(prefix_results.join, '')
+    # returns an array of valid types for the normalized number
+    # if array is empty, we can assume that the number is invalid
+    def validate
+      return [] unless country
+      country.validations.select do |validation|
+        normalized_number =~ Regexp.new("^(#{validation.pattern})$")
+      end.map(&:name)
     end
 
     def parse_prefix
-      return sanitized_number unless country_data[:national_prefix_for_parsing]
-      duped = sanitized_number.dup
-      match_object = duped.match(Regexp.new(country_data[:national_prefix_for_parsing]))
+      return original_number unless country.national_prefix_for_parsing
+      duped = original_number.dup
+      match_object = duped.match(country.national_prefix_for_parsing)
 
       # we need to do the "start_with?" here because we need to make sure it's not finding
       # something in the middle of the number. However, we can't modify the regex to do this
       # for us because it will offset the match groups that are referenced in the transform rules
-      return sanitized_number unless match_object && duped.start_with?(match_object[0])
-      if country_data[:national_prefix_transform_rule]
+      return original_number unless match_object && duped.start_with?(match_object[0])
+      if country.national_prefix_transform_rule
         transform_national_prefix(duped, match_object)
       else
         duped.sub!(match_object[0], '')
@@ -81,7 +52,7 @@ module TelephoneNumber
     end
 
     def transform_national_prefix(duped, match_object)
-      if PhoneData::MOBILE_TOKEN_COUNTRIES.include?(country) && match_object.captures.any?
+      if country.mobile_token && match_object.captures.any?
         format(build_format_string, duped.sub!(match_object[0], match_object[1]))
       elsif match_object.captures.none?
         duped.sub!(match_object[0], '')
@@ -91,7 +62,7 @@ module TelephoneNumber
     end
 
     def build_format_string
-      country_data[:national_prefix_transform_rule].gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
+      country.national_prefix_transform_rule.gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
     end
   end
 end

data/lib/telephone_number/test_data_generator.rb

@@ -6,23 +6,31 @@ module TelephoneNumber
   class TestDataGenerator
     URL =  "https://libphonenumber.appspot.com/phonenumberparser?number=%s&country=%s".freeze
     COUNTRIES = {
+                  AE: %w(971529933171 971553006144 971551000291),
                   AR: %w(111512345678 380151234567 299154104587 01112345678),
                   AU: %w(0467703037),
+                  BE: %w(32498485960 32477702206 32474095692),
+                  BO: %w(59178500348 59178006138 59178006139),
                   BR: %w(011992339376 1123456789 11961234567),
                   BY: %w(80152450911 294911911 152450911),
                   CA: %w(16135550119 16135550171 16135550112 16135550194
                          16135550122 16135550131 15146708700 14169158200),
+                  CH: %w(41794173875 41795061129 41795820985),
                   CL: %w(961234567 221234567),
                   CN: %w(15694876068 13910503766 15845989469 05523245954 04717158875 03748086894),
                   CO: %w(3211234567 12345678),
                   CR: %w(22123456 83123456),
                   DE: %w(15222503070),
+                  DK: %w(4524453744 4551622172 4542428484),
+                  EC: %w(593992441504 593984657155 593984015053),
+                  EE: %w(37253629280 37253682997 37254004517),
+                  ES: %w(34606217800 34667751353 34646570628),
                   FR: %w(0607114556),
                   GB: %w(448444156790 442079308181 442076139800 442076361000
                          07780991912 442076299400 442072227888),
                   HK: %w(64636251),
+                  HU: %w(36709311285 36709311279 36709311206),
                   IE: %w(0863634875),
-                  MX: %w(4423593227 14423593227),
                   IN: %w(915622231515 912942433300 912912510101 911126779191
                          912224818000 917462223999 912266653366 912266325757
                          914066298585 911242451234 911166566162 911123890606
@@ -30,14 +38,31 @@ module TelephoneNumber
                          1126779191 2224818000 7462223999 2266653366
                          2266325757 4066298585 1242451234 1166566162
                          1123890606 1123583754 09176642499),
+                  IT: %w(393478258998 393440161350),
                   JP: %w(312345678 9012345678),
+                  KR: %w(821036424812 821053812833 821085894820),
+                  MX: %w(4423593227 14423593227),
+                  NL: %w(31610958780 31610000852 31611427604),
+                  NO: %w(4792272668 4797065876 4792466013),
+                  NZ: %w(64212715077 6421577017 64212862111),
+                  PE: %w(51994156035 51987527881 51972737259),
+                  PH: %w(639285588185 639285588262 639285548190),
+                  PL: %w(48665666003 48885882321 48885889958),
+                  QA: %w(97470482288 97474798678),
+                  RO: %w(40724242563 40727798526 40727735377),
+                  SA: %w(966503891468 966501543349 966500939012),
+                  SE: %w(46708922920 46723985268 46761001966),
                   SG: %w(96924755),
+                  TR: %w(905497728782 905497728780 905497728781),
+                  TT: %w(18687804765 18687804843 18687804752),
+                  TW: %w(886905627933 886905627901 886905627925),
                   US: %w(16502530000 14044879000 15123435283 13032450086 16175751300
                          3175083345 13128404100 12485934000 19497941600 14257395600 13103106000
                          16086699600 12125650000 14123456700 14157360000 12068761800
-                         12023461100 3175082333)
+                         12023461100 3175082333),
+                  VE: %w(584149993108 584248407260 584248271518),
+                  ZA: %w(27826187617 27823014578 27828840632)
                 }.freeze
-
     def self.import!
       output_hash = {}
       fetch_data(output_hash)

data/lib/telephone_number/version.rb

@@ -1,3 +1,3 @@
 module TelephoneNumber
-  VERSION = "1.1.1"
+  VERSION = "1.2.0.rc1"
 end

data/lib/telephone_number.rb

@@ -1,48 +1,17 @@
 require 'telephone_number/version'
 require 'utilities/hash'
-require 'forwardable'
+require 'active_model/telephone_number_validator' if defined?(ActiveModel)
 
 module TelephoneNumber
-  autoload :DataImporter, 'telephone_number/data_importer'
+  autoload :DataImporter,      'telephone_number/data_importer'
   autoload :TestDataGenerator, 'telephone_number/test_data_generator'
-  autoload :Parser, 'telephone_number/parser'
-  autoload :Number, 'telephone_number/number'
-  autoload :Formatter, 'telephone_number/formatter'
-  autoload :PhoneData, 'telephone_number/phone_data'
-  autoload :ClassMethods, 'telephone_number/class_methods'
+  autoload :Parser,            'telephone_number/parser'
+  autoload :Number,            'telephone_number/number'
+  autoload :Formatter,         'telephone_number/formatter'
+  autoload :Country,           'telephone_number/country'
+  autoload :NumberFormat,      'telephone_number/number_format'
+  autoload :NumberValidation,  'telephone_number/number_validation'
+  autoload :ClassMethods,      'telephone_number/class_methods'
 
   extend ClassMethods
-
-  # allows users to override the default data
-  @override_file = nil
-
-  # allows users to provide a default format pattern
-  @default_format_pattern = nil
-
-  # allows users to provide a default format string
-  @default_format_string = nil
-
-  def self.override_file=(file_name)
-    @override_file = file_name
-  end
-
-  def self.override_file
-    @override_file
-  end
-
-  def self.default_format_string=(format_string)
-    @default_format_string = format_string
-  end
-
-  def self.default_format_string
-    @default_format_string
-  end
-
-  def self.default_format_pattern=(format_string)
-    @default_format_pattern = Regexp.new(format_string)
-  end
-
-  def self.default_format_pattern
-    @default_format_pattern
-  end
 end

data/lib/utilities/hash.rb

@@ -35,4 +35,13 @@ class Hash
 
     self
   end
+
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
 end

data/telephone_number.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'nokogiri'
   spec.add_development_dependency 'httparty'
+  spec.add_development_dependency 'activemodel', '>= 4.0'
   spec.add_development_dependency 'minitest-focus'
   spec.add_development_dependency 'coveralls'
 end