phony 1.9.0 → 2.19.14

data/lib/phony/country.rb

@@ -1,51 +1,208 @@
+# frozen_string_literal: true
+
 module Phony
-  
+
   #
   #
   class Country
     
     attr_accessor :codes
-    
-    # 
+
+    @@international_absolute_format = '+%s%s%s%s%s'
+    @@international_relative_format = '00%s%s%s%s%s'
+    @@national_format               = '%s%s%s%s'
+  
+    @@default_space = ' '
+    @@default_local_space = ' '
+    @@default_parentheses = false
+
+    # TODO Doc.
     #
     def initialize *codes
       @codes = codes
     end
-    
+
+    # DSL method.
+    #
     # Chain two codes together.
     #
-    def |(other)
+    def | other
       self.codes = self.codes + other.codes
       self
     end
-    
+
+    # Options.
+    #
+    # TODO Rewrite.
+    #
+    def with cc, options = {}
+      @cc           = cc
+      
+      @invalid_ndcs = options[:invalid_ndcs]
+      
+      @format       = options[:format]
+      @space        = options[:space]
+      @local_space  = options[:local_space]
+      @parentheses  = options[:parentheses]
+    end
+
     # A number is split with the code handlers as given in the initializer.
     #
     # Note: If the ndc is nil, it will not return it.
     #
+    # @return [Trunk, String (ndc), Array<String> (national pieces)]
+    #
     def split national_number
-      @codes.each do |code|
-        zero, ndc, *rest = code.split national_number
-        return [zero, ndc, *rest] if rest && !rest.empty?
+      _, trunk, ndc, *rest = internal_split national_number
+      [trunk, ndc, *rest]
+    end
+    #
+    #
+    # @return [Splitters::Local, Trunk, String (ndc), Array<String> (national pieces)]
+    #
+    def internal_split national_number
+      trunk = nil
+      @codes.each do |national_splitter|
+        new_trunk, ndc, *rest = national_splitter.split national_number
+        trunk ||= new_trunk
+        return [national_splitter.local_splitter, trunk, ndc, *rest] if rest && !rest.empty?
       end
+      
+      # Best effort.
+      [nil, trunk, national_number, []]
     end
     
+    # Format the number, given the national part of it.
+    #
+    def format national_number, options = {}
+      type         = options[:format]       || @format
+      space        = options[:spaces]       || @space       || @@default_space
+      local_space  = options[:local_spaces] || @local_space || space           || @@default_local_space
+      parentheses  = options[:parentheses]
+      parentheses  = @parentheses || @@default_parentheses if parentheses.nil?
+      use_trunk    = options[:trunk]
+      
+      trunk, ndc, *local_pieces = split national_number
+      
+      local = format_local local_pieces, local_space
+      
+      format_cc_ndc trunk, ndc, local, type, space, parentheses, use_trunk
+    end
+    def format_local local, local_space
+      if local.empty?
+        EMPTY_STRING
+      else
+        local.compact!
+        local.join local_space.to_s
+      end
+    end
+    def format_cc_ndc trunk, ndc, local, type, space, parentheses, use_trunk
+      # Note: We mark NDCs that are of type "none" with false (nil trips plausible?). This would result in false being printed.
+      #       Therefore we set NDC to nil when formatting.
+      ndc = nil if ndc == false
+      case type
+      when String
+        trunk &&= trunk.format(space, use_trunk)
+        type % { :trunk => trunk, :cc => @cc, :ndc => ndc, :local => local }
+      when nil, :international_absolute, :international, :+
+        if ndc
+          format_with_ndc(@@international_absolute_format, @cc, format_ndc(ndc, parentheses), local, space)
+        else
+          format_without_ndc(@@international_absolute_format, @cc, local, space)
+        end
+      when :international_relative
+        if ndc
+          format_with_ndc(@@international_relative_format, @cc, format_ndc(ndc, parentheses), local, space)
+        else
+          format_without_ndc(@@international_relative_format, @cc, local, space)
+        end
+      when :national
+        trunk &&= trunk.format(space, use_trunk)
+        if ndc && !ndc.empty?
+          @@national_format % [trunk, format_ndc(ndc, parentheses), space, local]
+        else
+          @@national_format % [trunk, nil, nil,   local]
+        end
+      when :local
+        local
+      end
+    end
+    def format_ndc ndc, parentheses
+      ndc = nil if ndc == false # TODO
+      parentheses ? "(#{ndc})" : ndc
+    end
+    def format_with_ndc format, cc, ndc, local, space
+      format % [cc, space, ndc, space, local]
+    end
+    def format_without_ndc format, cc, local, space
+      format % [cc, space, local, nil, nil]
+    end
+
+    # Cleans all non-numeric characters.
+    #
+    @@basic_cleaning_pattern = /\(0|\D/
+    # Clean number of all non-numeric characters and return a copy.
+    #
+    def clean number
+      clean! number && number.dup
+    end
+    # Clean number of all non-numeric characters and return it.
+    #
+    def clean! number
+      number.gsub!(@@basic_cleaning_pattern, EMPTY_STRING) || number
+    end
+
     # Removes 0s from partially normalized numbers
     # such as 410443643533.
-    # 
+    #
     # Example:
     #   410443643533 -> 41443643533
     #
     # In some cases it doesn't, like Italy.
     #
-    def normalize national_number
-      @codes.each do |code|
-        normalized = code.normalize national_number
-        return normalized if normalized && !normalized.empty?
+    # Note: Options such as CC
+    #
+    def normalize national_number, options = {}
+      clean! national_number
+      normalized = @codes.reduce national_number do |number, code|
+        result = code.normalize number, options
+        break result if result
+        number
       end
-      return nil
+      normalized
     end
-    
+
+    # Tests for plausibility of this national number.
+    #
+    def plausible? rest, hints = {}
+      local, _, ndc, *rest = internal_split rest
+      
+      # Element based checking.
+      #
+      # Note: ndc == false means the country has none.
+      #
+      return false if ndc.nil?
+      return false if ndc && ndc.empty?
+      return false if @invalid_ndcs && @invalid_ndcs === ndc
+
+      # # A valid range for the rest is 0 or 3+ total digits.
+      # #
+      # return false if (1..2) === rest_size
+
+      # National destination code plausible?
+      #
+      ndc_needed = hints[:ndc]
+      return false if ndc_needed && !(ndc_needed === ndc)
+      
+      # If there is no local part, we can assume it's not a plausible number.
+      # (Or, not defined correctly in Phony yet)
+      return false unless local
+
+      # Local code specific checks.
+      #
+      return local.plausible? rest, hints
+    end
+
     # Is this national number a vanity number?
     #
     def vanity? national_number
@@ -54,10 +211,10 @@ module Phony
     #
     #
     def vanity_to_number vanity_number
-      zero, ndc, *rest = split vanity_number
+      _, ndc, *rest = split vanity_number
       "#{ndc}#{Vanity.replace(rest.join)}"
     end
-    
+
   end
-  
-end
+
+end

data/lib/phony/country_codes.rb

@@ -1,145 +1,163 @@
 module Phony
 
-  EMPTY_STRING = ''
+  EMPTY_STRING = '' unless defined?(EMPTY_STRING)
 
   # Handles determining the correct national code handler.
   #
   class CountryCodes
 
-    attr_reader   :splitter_mapping
+    attr_reader   :countries
     attr_accessor :international_absolute_format, :international_relative_format, :national_format
 
-    def initialize
-      @international_absolute_format = '+%s%s%s'
-      @international_relative_format = '00%s%s%s'
-      @national_format               = '%s%s'
+    # Singleton instance.
+    #
+    def self.instance
+      @instance ||= new
+    end
+    
+    # Add the given country to the mapping under the
+    # given country code.
+    #
+    def add country_code, country
+      country_code = country_code.to_s
+      optimized_country_code_access = country_code.size
 
-      @normalize_format = '%s%s'
-      @default_space    = ' '
+      @countries ||= {}
+      @countries[optimized_country_code_access] ||= {}
+      @countries[optimized_country_code_access][country_code] = country
     end
 
-    def self.instance
-      @instance ||= new
+    # Get the Country object for the given CC.
+    #
+    def [] cc
+      countries[cc.size][cc]
     end
 
-    @@basic_normalizing_pattern = /^0+|\D/
+    # Clean number of all non-numeric characters, initial zeros or (0.
+    #
+    @@basic_cleaning_pattern = /\A00?|\(0|\D/
+    # Clean number of all non-numeric characters, initial zeros or (0 and return it.
+    #
     def clean number
       clean! number && number.dup
     end
+    # Clean number of all non-numeric characters, initial zeros or (0 and return a copy.
+    #
     def clean! number
-      # Remove non-digit chars.
-      #
-      number.gsub!(@@basic_normalizing_pattern, EMPTY_STRING) || number
+      number.gsub!(@@basic_cleaning_pattern, EMPTY_STRING) || number
     end
-    def normalize number
-      clean! number
-      national_handler, cc, rest = split_cc number
-      @normalize_format % [cc, national_handler.normalize(rest)]
+
+    # 00 for the standard international call prefix.
+    # http://en.wikipedia.org/wiki/List_of_international_call_prefixes
+    #
+    # We can't know from what country that person was calling, so we
+    # can't remove the intl' call prefix.
+    #
+    # We remove:
+    #  * 0 or 00 at the very beginning.
+    #  * (0) anywhere.
+    #  * Non-digits.
+    #
+    def normalize number, options = {}
+      country = if cc = options[:cc]
+        self[cc]
+      else
+        clean! number
+        country, cc, number = partial_split number
+        country
+      end
+      number = country.normalize number, cc: cc
+      countrify! number, cc
     end
 
     # Splits this number into cc, ndc and locally split number parts.
     #
     def split number
-      country_handler, cc, rest = split_cc number
-      [cc, *country_handler.split(rest)]
+      # Split the number into country, cc, and national part.
+      country, cc, national_number = partial_split number
+      
+      # Split the national number into ndc and local part.
+      _, ndc, *local = country.split national_number
+      
+      [cc, ndc, *local]
     end
 
-    def formatted number, options = {}
-      format_cc_ndc_local options[:format], options[:spaces] || @default_space, *split(number)
-    end
-    # Formats country code and national destination code.
+    # Format the number.
     #
-    def format_cc_ndc_local format, space, cc, zero, ndc, *parts
-      cc_ndc = format_cc_ndc format, space, cc, zero, ndc
-      local  = if parts.empty?
-                 cc_ndc = cc_ndc.slice 0...cc_ndc.rindex(space.to_s)
-                 EMPTY_STRING
-               else
-                 format_local(space, parts) unless parts.empty?
-               end
-      cc_ndc.empty?? local : "#{cc_ndc}#{space}#{local}"
-    end
-    #
-    # TODO This method needs an overhaul.
-    #
-    def format_cc_ndc format, space, cc, zero, ndc
-      case format
-      when nil, :international_absolute, :international, :+
-        ndc ?
-          @international_absolute_format % [cc, space, ndc] :
-          @international_absolute_format % [cc, nil, nil]
-      when :international_relative
-        ndc ?
-          @international_relative_format % [cc, space, ndc] :
-          @international_relative_format % [cc, nil, nil]
-      when :national
-        ndc && !ndc.empty? ?
-          @national_format % [zero, ndc] :
-          @national_format % [zero, nil]
-      when :local
-        EMPTY_STRING
-      end
-    end
-    def format_local space, parts_ary
-      parts_ary.compact!
-      parts_ary.join space.to_s
+    def format number, options = {}
+      country, _, national_number = partial_split number
+      country.format national_number, options
     end
+    alias formatted format
 
+    # Is this number plausible?
     #
-    #
-    def service? number
-      country_handler, cc, rest = split_cc number
-      country_handler.service? rest
-    end
-    def mobile? number
-      country_handler, cc, rest = split_cc number
-      country_handler.mobile? rest
-    end
-    def landline? number
-      country_handler, cc, rest = split_cc number
-      country_handler.landline? rest
-    end
+    def plausible? number, hints = {}
+      normalized = clean number
+
+      # False if it fails the basic check.
+      #
+      return false unless (4..16) === normalized.size # unless hints[:check_length] == false
+
+      country, cc, rest = partial_split normalized
+
+      # Country code plausible?
+      #
+      cc_needed = hints[:cc]
+      return false if cc_needed && !(cc_needed === cc)
 
+      # Country specific tests.
+      #
+      country.plausible? rest, hints
+    rescue StandardError
+      return false
+    end
+    
     # Is the given number a vanity number?
     #
     def vanity? number
-      country_handler, _, rest = split_cc number
-      country_handler.vanity? rest
+      country, _, national = partial_split number
+      country.vanity? national
     end
     # Converts a vanity number into a normalized E164 number.
     #
     def vanity_to_number vanity_number
-      country_handler, cc, rest = split_cc vanity_number
-      "#{cc}#{country_handler.vanity_to_number(rest)}"
+      country, cc, national = partial_split vanity_number
+      "#{cc}#{country.vanity_to_number(national)}"
     end
 
-    def split_cc rest
-      presumed_cc = ''
-      1.upto(3) do |i|
-        presumed_cc << rest.slice!(0..0)
-        country_handler = splitter_mapping[i][presumed_cc]
-        return [country_handler, presumed_cc, rest] if country_handler
+    private
+    
+      # Return a country for the number.
+      #
+      def country_for number
+        country, _ = partial_split number
+        country
+      end
+          
+      # Split off the country and the cc, and also return the national number part.
+      #
+      def partial_split number
+        cc = ''
+        1.upto(3) do |i|
+          cc << number.slice!(0..0)
+          country = countries[i][cc]
+          return [country, cc, number] if country
+        end
+        # This line is never reached as CCs are in prefix code.
+      end
+      
+      # Adds the country code to the front
+      # if it does not already start with it.
+      #
+      # Note: This won't be correct in some cases, but it is the best we can do.
+      #
+      def countrify number, cc
+        countrify!(number, cc) || number
+      end
+      def countrify! number, cc
+        number.sub!(/\A/, cc) # @countrify_regex, @cc
       end
-      # This line is never reached as CCs are in prefix code.
-    end
-
-    # # TODO
-    # #
-    # def self.with_cc cc
-    #   mapping[cc.size][cc.to_s]
-    # end
-
-    # Add the given country to the mapping under the
-    # given country code.
-    #
-    def add country_code, country
-      country_code = country_code.to_s
-      optimized_country_code_access = country_code.size
-
-      @splitter_mapping ||= {}
-      @splitter_mapping[optimized_country_code_access] ||= {}
-      @splitter_mapping[optimized_country_code_access][country_code] = country
-    end
 
   end