telephone_number 0.0.0 → 0.1.0

data/lib/telephone_number/class_methods.rb

@@ -0,0 +1,11 @@
+module TelephoneNumber
+  module ClassMethods
+    def parse(number, country)
+      TelephoneNumber::Number.new(number, country)
+    end
+
+    def valid?(number, country, keys = [])
+      parse(number, country).valid?(keys)
+    end
+  end
+end

data/lib/telephone_number/data_importer.rb

@@ -0,0 +1,75 @@
+module TelephoneNumber
+  require 'nokogiri'
+  class DataImporter
+    attr_reader :data, :file
+
+    def initialize(file_name)
+      @data = {}
+      @file = File.open(file_name){ |f| Nokogiri::XML(f) }
+    end
+
+    def import!(override: false)
+      parse_main_data
+      save_data_file(override: override)
+    end
+
+    def parse_main_data
+      file.css("territories territory").each do |territory|
+        country_code = territory.attributes["id"].value.to_sym
+        @data[country_code] ||= {}
+
+        load_base_attributes(@data[country_code], territory)
+        load_references(@data[country_code], territory)
+        load_validations(@data[country_code], territory)
+        load_formats(@data[country_code], territory)
+      end
+    end
+
+    private
+
+    def load_formats(country_data, territory)
+      country_data[TelephoneNumber::PhoneData::FORMATS] = territory.css("availableFormats numberFormat").map do |format|
+        format_hash = {}.tap do |fhash|
+          format.attributes.values.each { |attr| fhash[attr.name.to_sym] = attr.value.delete("\n ") }
+          format.elements.each { |child| fhash[child.name.to_sym] = child.text.delete("\n ") }
+        end
+      end
+    end
+
+    def load_validations(country_data, territory)
+      country_data[TelephoneNumber::PhoneData::VALIDATIONS] = {}
+      territory.elements.each do |element|
+        next if element.name == "references" || element.name == "availableFormats"
+        country_data[TelephoneNumber::PhoneData::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
+    end
+
+    def load_base_attributes(country_data, territory)
+      territory.attributes.each do |key, value_object|
+        country_data[underscore(key).to_sym] = value_object.value
+      end
+    end
+
+    def load_references(country_data, territory)
+      country_data[:references] = territory.css("references sourceUrl").map(&:text)
+    end
+
+    def underscore(camel_cased_word)
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+      word = camel_cased_word.to_s.gsub(/::/, '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def save_data_file(override: false)
+      data_file = override ?  "telephone_number_data_override_file.dat" :  "#{File.dirname(__FILE__)}/../../data/telephone_number_data_file.dat"
+      File.open(data_file, 'wb+') { |f| Marshal.dump(@data, f) }
+    end
+  end
+end
+

data/lib/telephone_number/number.rb

@@ -0,0 +1,27 @@
+module TelephoneNumber
+  class Number
+    include TelephoneNumber::Parser
+
+    attr_reader :original_number, :country, :e164_number, :national_number
+
+    def initialize(number, country)
+      return unless number && country
+
+      @original_number = sanitize(number)
+      @country = country.upcase.to_sym
+      @national_number, @e164_number = extract_number_types(@original_number, @country)
+    end
+
+    def valid_types
+      @valid_types ||= validate(e164_number, country)
+    end
+
+    def valid?(keys = [])
+      keys.empty? ? !valid_types.empty? : !(valid_types & keys.map(&:to_sym)).empty?
+    end
+
+    def format
+      @format ||= extract_format(national_number, country)
+    end
+  end
+end

data/lib/telephone_number/parser.rb

@@ -0,0 +1,39 @@
+module TelephoneNumber
+  module Parser
+    KEYS_TO_SKIP = [TelephoneNumber::PhoneData::GENERAL,
+                    TelephoneNumber::PhoneData::AREA_CODE_OPTIONAL]
+
+    def sanitize(input_number)
+      return input_number.gsub(/[^0-9]/, "")
+    end
+
+    def extract_number_types(input_number, country)
+      country_data = TelephoneNumber::PhoneData.phone_data[country.to_sym]
+
+      return [input_number, nil] unless country_data
+      country_code = country_data[TelephoneNumber::PhoneData::COUNTRY_CODE]
+
+      reg_string  = "^(#{country_code})?"
+      reg_string += "(#{country_data[TelephoneNumber::PhoneData::NATIONAL_PREFIX]})?"
+      reg_string += "(#{country_data[TelephoneNumber::PhoneData::VALIDATIONS]\
+                        [TelephoneNumber::PhoneData::GENERAL]\
+                        [TelephoneNumber::PhoneData::VALID_PATTERN]})$"
+
+      match_result = input_number.match(Regexp.new(reg_string)) || []
+
+      prefix_results = [match_result[1], match_result[2]]
+      without_prefix = input_number.sub(prefix_results.join, "")
+      [without_prefix, "#{country_code}#{without_prefix}"]
+    end
+
+    def validate(normalized_number, country)
+      country_data = TelephoneNumber::PhoneData.phone_data[country.to_sym]
+      return [] unless country_data
+      applicable_keys = country_data[TelephoneNumber::PhoneData::VALIDATIONS].reject{ |key, _value| KEYS_TO_SKIP.include?(key) }
+      applicable_keys.map do |phone_type, validations|
+        full = "^(#{country_data[TelephoneNumber::PhoneData::COUNTRY_CODE]})(#{validations[TelephoneNumber::PhoneData::VALID_PATTERN]})$"
+        phone_type if normalized_number =~ Regexp.new(full)
+      end.compact
+    end
+  end
+end

data/lib/telephone_number/phone_data.rb

@@ -0,0 +1,37 @@
+module TelephoneNumber
+  module PhoneData
+    VALIDATIONS = :validations.freeze
+    FORMATS = :formats.freeze
+    GENERAL = :general_desc.freeze
+    PREMIUM_RATE = :premium_rate.freeze
+    TOLL_FREE = :toll_free.freeze
+    SHARED_COST = :shared_cost.freeze
+    VOIP = :voip.freeze
+    PERSONAL_NUMBER = :personal_number.freeze
+    UAN = :uan.freeze
+    VOICEMAIL = :voicemail.freeze
+    FIXED_LINE = :fixed_line.freeze
+    MOBILE = :mobile.freeze
+    NO_INTERNATIONAL_DIALING = :no_international_dialling.freeze
+    AREA_CODE_OPTIONAL = :area_code_optional.freeze
+    VALID_PATTERN = :national_number_pattern.freeze
+    POSSIBLE_PATTERN = :possible_number_pattern.freeze
+    NATIONAL_PREFIX = :national_prefix.freeze
+    COUNTRY_CODE = :country_code.freeze
+    LEADING_DIGITS = :leading_digits.freeze
+    INTERNATIONAL_PREFIX = :international_prefix.freeze
+
+    def self.phone_data
+      @@phone_data ||= load_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.merge!(override_data)
+    end
+  end
+end
+

data/lib/telephone_number/version.rb

@@ -0,0 +1,3 @@
+module TelephoneNumber
+  VERSION = "0.1.0"
+end

data/lib/telephone_number.rb

@@ -0,0 +1,28 @@
+require "telephone_number/version"
+
+module TelephoneNumber
+  autoload :DataImporter, 'telephone_number/data_importer'
+  autoload :Parser, 'telephone_number/parser'
+  autoload :Number, 'telephone_number/number'
+  autoload :PhoneData, 'telephone_number/phone_data'
+  autoload :ClassMethods, 'telephone_number/class_methods'
+
+  extend ClassMethods
+
+  # allows users to override the default data
+  @@override_file = nil
+
+  def self.override_file=(file_name)
+    @@override_file = file_name
+  end
+
+  def self.override_file
+    @@override_file
+  end
+
+  # generates binary file from xml that user gives us
+  def self.generate_override_file(file)
+    DataImporter.new(file).import!(override: true)
+  end
+
+end

data/telephone_number.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'telephone_number/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "telephone_number"
+  spec.version       = TelephoneNumber::VERSION
+  spec.author        = 'MOBI Wireless Management'
+  spec.email         = ["adam.fernung@mobiwm.com", "josh.wetzel@mobiwm.com"]
+  spec.summary       = 'Phone number validation'
+  spec.homepage      = "https://github.com/mobi/telephone_number"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  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 "minitest-focus"
+end