phony 2.20.13 → 2.22.2

data/lib/phony/country.rb

@@ -1,22 +1,18 @@
 # 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.
+    # TODO: Doc.
     #
     def initialize *codes
       @codes = codes
@@ -26,8 +22,8 @@ module Phony
     #
     # Chain two codes together.
     #
-    def | other
-      self.codes = self.codes + other.codes
+    def |(other)
+      self.codes = codes + other.codes
       self
     end
 
@@ -35,11 +31,11 @@ module Phony
     #
     # TODO Rewrite.
     #
-    def with cc, options = {}
+    def with(cc, options = {})
       @cc           = cc
-      
+
       @invalid_ndcs = options[:invalid_ndcs]
-      
+
       @format       = options[:format]
       @space        = options[:space]
       @local_space  = options[:local_space]
@@ -52,43 +48,46 @@ module Phony
     #
     # @return [Trunk, String (ndc), Array<String> (national pieces)]
     #
-    def split national_number
+    def split(national_number)
       _, 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
+    def internal_split(national_number)
       trunk = nil
       @codes.each do |national_splitter|
         new_trunk, ndc, *rest = national_splitter.split national_number
         trunk ||= new_trunk
+        national_number = ndc if 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 = {}
+    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
+      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
+
+    def format_local(local, local_space)
       if local.empty?
         EMPTY_STRING
       else
@@ -96,14 +95,15 @@ module Phony
         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.
+
+    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 }
+        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)
@@ -121,20 +121,23 @@ module Phony
         if ndc && !ndc.empty?
           @@national_format % [trunk, format_ndc(ndc, parentheses), space, local]
         else
-          @@national_format % [trunk, nil, nil,   local]
+          @@national_format % [trunk, nil, nil, local]
         end
       when :local
         local
       end
     end
-    def format_ndc ndc, parentheses
+
+    def format_ndc(ndc, parentheses)
       ndc = nil if ndc == false # TODO
       parentheses ? "(#{ndc})" : ndc
     end
-    def format_with_ndc format, cc, ndc, local, space
+
+    def format_with_ndc(format, cc, ndc, local, space)
       format % [cc, space, ndc, space, local]
     end
-    def format_without_ndc format, cc, local, space
+
+    def format_without_ndc(format, cc, local, space)
       format % [cc, space, local, nil, nil]
     end
 
@@ -143,12 +146,13 @@ module Phony
     @@basic_cleaning_pattern = /\(0|\D/
     # Clean number of all non-numeric characters and return a copy.
     #
-    def clean number
+    def clean(number)
       clean! number && number.dup
     end
+
     # Clean number of all non-numeric characters and return it.
     #
-    def clean! number
+    def clean!(number)
       number.gsub!(@@basic_cleaning_pattern, EMPTY_STRING) || number
     end
 
@@ -162,21 +166,20 @@ module Phony
     #
     # Note: Options such as CC
     #
-    def normalize national_number, options = {}
+    def normalize(national_number, options = {})
+      national_number = national_number.dup
       clean! national_number
-      normalized = @codes.reduce national_number do |number, code|
+      @codes.each_with_object national_number do |code, number|
         result = code.normalize number, options
         break result if result
-        number
       end
-      normalized
     end
 
     # Tests for plausibility of this national number.
     #
-    def plausible? rest, hints = {}
+    def plausible?(rest, hints = {})
       local, _, ndc, *rest = internal_split rest
-      
+
       # Element based checking.
       #
       # Note: ndc == false means the country has none.
@@ -193,28 +196,25 @@ module Phony
       #
       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
+      local.plausible? rest, hints
     end
 
     # Is this national number a vanity number?
     #
-    def vanity? national_number
+    def vanity?(national_number)
       Vanity.vanity? national_number
     end
-    #
-    #
-    def vanity_to_number vanity_number
+
+    def vanity_to_number(vanity_number)
       _, ndc, *rest = split vanity_number
       "#{ndc}#{Vanity.replace(rest.join)}"
     end
-
   end
-
 end

data/lib/phony/country_codes.rb

@@ -1,11 +1,11 @@
-module Phony
+# frozen_string_literal: true
 
+module Phony
   EMPTY_STRING = '' unless defined?(EMPTY_STRING)
 
   # Handles determining the correct national code handler.
   #
   class CountryCodes
-
     attr_reader   :countries
     attr_accessor :international_absolute_format, :international_relative_format, :national_format
 
@@ -14,11 +14,11 @@ module Phony
     def self.instance
       @instance ||= new
     end
-    
+
     # Add the given country to the mapping under the
     # given country code.
     #
-    def add country_code, country
+    def add(country_code, country)
       country_code = country_code.to_s
       optimized_country_code_access = country_code.size
 
@@ -29,7 +29,7 @@ module Phony
 
     # Get the Country object for the given CC.
     #
-    def [] cc
+    def [](cc)
       countries[cc.size][cc]
     end
 
@@ -38,12 +38,13 @@ module Phony
     @@basic_cleaning_pattern = /\A00?|\(0|\D/
     # Clean number of all non-numeric characters, initial zeros or (0 and return it.
     #
-    def clean number
+    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
+    def clean!(number)
       number.gsub!(@@basic_cleaning_pattern, EMPTY_STRING) || number
     end
 
@@ -58,33 +59,34 @@ module Phony
     #  * (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
+    def normalize(number, options = {})
+      number = number.dup
+      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
+    def split(number)
       # 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
 
     # Format the number.
     #
-    def format number, options = {}
+    def format(number, options = {})
       country, _, national_number = partial_split number
       country.format national_number, options
     end
@@ -92,22 +94,27 @@ module Phony
 
     # Is this number plausible?
     #
-    def plausible? number, hints = {}
+    def plausible?(number, hints = {})
+      # Fail if it contains too many of certain phone specific markers:
+      #   * more than 1 +
+      #
+      return false if number.count('+') > 1
+
       normalized = clean number
 
       # False if it fails the basic check.
       #
-      return false unless (4..16) === normalized.size # unless hints[:check_length] == false
+      return false unless (4..16).include?(normalized.size) # unless hints[:check_length] == false
 
       country, cc, rest = partial_split normalized
-      
+
       # Was a country calling code given?
       #
-      if ccc = hints[:ccc]
+      if (ccc = hints[:ccc])
         cc, ndc, *local = split ccc
-        
+
         raise ArgumentError.new("The provided ccc option is too long and includes more than a cc ('#{cc}') and ndc ('#{ndc}'). It also includes '#{local.join}'.") unless local.size == 1 && local[0].empty?
-        
+
         hints[:cc] = cc
         hints[:ndc] = ndc
       end
@@ -123,55 +130,55 @@ module Phony
     rescue ArgumentError
       raise
     rescue StandardError
-      return false
+      false
     end
-    
+
     # Is the given number a vanity number?
     #
-    def vanity? number
+    def vanity?(number)
       country, _, national = partial_split number
       country.vanity? national
     end
+
     # Converts a vanity number into a normalized E164 number.
     #
-    def vanity_to_number vanity_number
+    def vanity_to_number(vanity_number)
       country, cc, national = partial_split vanity_number
       "#{cc}#{country.vanity_to_number(national)}"
     end
 
     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
+
+    # 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)
+      1.upto(3) do |i|
+        cc = number.slice(...i)
+        national_number = number.slice(i..)
+        country = countries[i][cc]
+        return [country, cc, national_number] if country
       end
+      # This line is never reached as CCs are in prefix code.
+    end
 
-  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.dup, cc) || number
+    end
 
+    def countrify!(number, cc)
+      number.sub!(/\A/, cc) # @countrify_regex, @cc
+    end
+  end
 end

data/lib/phony/dsl.rb

@@ -1,5 +1,6 @@
-module Phony
+# frozen_string_literal: true
 
+module Phony
   # For country definitions.
   #
   # There are two styles: With or without block.
@@ -27,7 +28,6 @@ module Phony
   #   Phony.define { ... }
   #
   class DSL
-
     # Define a country's rules.
     #
     # Use the other DSL methods to define the country's rules.
@@ -40,13 +40,13 @@ module Phony
     # @example Add a country with country code 27.
     #   country '27', # CC, followed by rules, for example fixed(2) >> ...
     #
-    def country country_code, definition, options = {}
+    def country(country_code, definition, options = {})
       return unless Phony.config.load?(country_code)
-      
+
       definition.with country_code, options
       Phony::CountryCodes.instance.add country_code, definition
     end
-    
+
     # Designates a country code as reserved.
     # A reserved country will result in an exception when trying to be used.
     #
@@ -57,10 +57,10 @@ module Phony
     # @example Designate country code 27 as reserved.
     #   reserved('27')
     #
-    def reserved country_code
+    def reserved(country_code)
       # Does nothing, will just fail with an exception.
     end
-    
+
     # Define a country to use default rules (and to be done at some point).
     #
     # @return Rules for a country.
@@ -71,7 +71,7 @@ module Phony
     def todo
       none >> split(10)
     end
-    
+
     # This country uses a trunk code.
     #
     # @param [String] code The trunk code.
@@ -88,7 +88,7 @@ module Phony
     # @example Most countries which use a trunk code use 0. E.g. Romania.
     #   country '40', trunk('0') | ...
     #
-    def trunk code, options = {}
+    def trunk(code, options = {})
       TrunkCode.new code, options
     end
 
@@ -107,11 +107,11 @@ module Phony
     # @example France. Uses a fixed NDC of size 1.
     #   country '33', fixed(1) >> split(2,2,2,2)
     #
-    def fixed length, options = {}
+    def fixed(length, options = {})
       options[:zero] = true if options[:zero].nil?
       NationalSplitters::Fixed.instance_for length, options
     end
-    
+
     # Marks the country as not using an NDC. This rule will always match.
     #
     # @return NationalSplitters::None A no-ndc national splitter.
@@ -121,7 +121,7 @@ module Phony
     def none
       NationalSplitters::None.instance_for
     end
-    
+
     # If you have a number of (possibly) variable length NDCs
     # that cannot be well expressed via regexp, use this.
     #
@@ -135,15 +135,15 @@ module Phony
     #     one_of('103', '105') >> split(3,3)
     #
     def one_of *ndcs
-      options = Hash === ndcs.last ? ndcs.pop : {}
+      options = ndcs.last.is_a?(Hash) ? ndcs.pop : {}
 
       # Ruby 1.8 compatibility mode.
       #
-      ndcs = ndcs.first if Array === ndcs.first
+      ndcs = ndcs.first if ndcs.first.is_a?(Array)
 
       NationalSplitters::Variable.new options[:max_length], ndcs.map(&:freeze)
     end
-    
+
     # If you have a number of (possibly) variable length NDCs
     # that can be well expressed via regexp, use this.
     #
@@ -157,11 +157,11 @@ module Phony
     #     match(/^(33|55|81)\d+$/) >> split(2,2,2,2) |
     #     match(/^(\d{3})\d+$/)    >> split(3,2,2)
     #
-    def match regex, options = {}
+    def match(regex, options = {})
       # Check if regexp has a group in it.
       #
-      raise "Regexp /#{regex.source}/ needs a group in it that defines which digits belong to the NDC." unless regex.source =~ /\(/
-      
+      raise "Regexp /#{regex.source}/ needs a group in it that defines which digits belong to the NDC." unless /\(/.match?(regex.source)
+
       NationalSplitters::Regex.instance_for regex, options[:on_fail_take], options
     end
 
@@ -183,7 +183,7 @@ module Phony
       # local << local.pop + 10 # Allow for call-through numbers with an arbitrary size.
       LocalSplitters::Fixed.instance_for local
     end
-    
+
     # Matches on the rest of the number and splits according
     # to the given value for the regexp key.
     #
@@ -199,18 +199,18 @@ module Phony
     #                           /^[489].*$/ => [3,2,3],
     #                           :fallback   => [2,2,2,2])
     #
-    def matched_split options = {}
+    def matched_split(options = {})
       LocalSplitters::Regex.instance_for options
     end
-    
+
     # Validators
     #
-    
+
     # Which NDCs are explicitly invalid?
     #
     # @param [Regexp, String] ndc A regexp or a string of invalid NDCs.
     #
-    # @return Validators::NDC An NDC validator 
+    # @return Validators::NDC An NDC validator
     #
     # @example NANP
     #   country '1',
@@ -220,8 +220,5 @@ module Phony
     def invalid_ndcs *ndc
       Validators::NDC.new invalid: ndc
     end
-
-
   end
-
 end