phoney 0.0.3

data/lib/phoney.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'phoney', 'version')
+require File.join(File.dirname(__FILE__), 'phoney', 'utils')
+require File.join(File.dirname(__FILE__), 'phoney', 'region')
+require File.join(File.dirname(__FILE__), 'phoney', 'parser')
+require File.join(File.dirname(__FILE__), 'phoney', 'base')

data/lib/phoney/base.rb

@@ -0,0 +1,100 @@
+class PhoneNumber
+  attr_accessor :country_code, :area_code, :number
+  
+  class << self
+    def default_region
+      @@region ||= Region[:us]
+    end
+
+    def default_region=(region)
+      if region.is_a?(Region)
+        @@region = region
+      else
+        @@region = Region[region.to_s.to_sym]
+      end
+    end
+
+    def default_country_code
+      @@country_code ||= default_region.country_code.to_s
+    end
+
+    def default_country_code=(country_code)
+      @@country_code = country_code
+    end
+
+    def default_area_code
+      @@area_code ||= nil
+    end
+
+    def default_area_code=(area_code)
+      @@area_code = area_code
+    end
+    
+    def version
+      VERSION::STRING
+    end
+  end
+
+  def initialize(params, region_code=nil)
+    region       = Region.find(region_code)
+    country_code = region.country_code.to_s if region
+    
+    if params.is_a?(String)
+      params = Parser.parse_to_parts(params, region_code)
+    end 
+
+    self.number = params[:number].to_s
+    # Can be empty, because some special numbers just don't have an area code (e.g. 911)
+    self.area_code = params[:area_code].to_s || self.class.default_area_code
+    self.country_code = params[:country_code].to_s || country_code || self.class.default_country_code
+
+    raise "Must enter number" if(self.number.nil? || self.number.empty?)
+    raise "Must enter country code or set default country code" if(self.country_code.nil? || self.country_code.empty?)
+  end
+
+  # Does this number belong to the default country code?
+  def has_default_country_code?
+    country_code.to_s == self.class.default_country_code.to_s
+  end
+
+  # Does this number belong to the default area code?
+  def has_default_area_code?
+    (!area_code.to_s.empty? && area_code.to_s == self.class.default_area_code.to_s)
+  end
+  
+  # Formats the phone number.
+  # If the method argument is a String, it is used as a format string, with the following fields being interpolated:
+  #
+  # * %c - country_code (385)
+  # * %a - area_code (91)
+  # * %n - number (5125486)
+  #
+  # If the method argument is a Symbol, we use one of the default formattings and let the parser do the rest.
+  def format(fmt)
+    if fmt.is_a?(Symbol)
+      case fmt
+      when :default
+        Parser::parse("+#{country_code} #{area_code} #{number}", country_code)
+      when :national
+        Parser::parse("#{area_code} #{number}", country_code)
+      when :local
+        STDERR.puts "Warning: Using local format without setting a default area code!?" if PhoneNumber.default_area_code.nil?
+        Parser::parse(number, country_code)
+      else
+        raise "The format #{fmt} doesn't exist'"
+      end
+    else
+      format_number(fmt)
+    end
+  end
+
+  # The default format is the canonical format: "+{country_code} {area_code} {number}"
+  def to_s
+    format(:default)
+  end
+  
+  private
+  def format_number(fmt)
+    fmt.gsub("%c", country_code || "").gsub("%a", area_code || "").gsub("%n", number || "")
+  end
+end

data/lib/phoney/parser.rb

@@ -0,0 +1,216 @@
+require 'strscan'
+
+class PhoneNumber
+
+  module Parser
+    class << self
+      include Utils
+      
+      def parse(phone_number, region_code=nil)
+        parse_to_parts(phone_number, region_code)[:formatted_number]
+      end
+      
+      def parse_to_parts(phone_number, region_code=nil)
+        phone_number = normalize(phone_number.to_s)
+
+        # we don't really need to do anything unless we get more input
+        unless phone_number.length > 1
+          return { :formatted_number => phone_number, :number => normalize(phone_number) }
+        end
+
+        region          = Region.find(region_code) || PhoneNumber.default_region
+        country_code    = region.country_code.to_s
+        area_code       = nil
+
+        dialout_prefix  = get_dialout_prefix(phone_number, region)
+        national_prefix = get_national_prefix(phone_number, region)
+        dialout_region  = get_dialout_region(phone_number, region)
+        dialout_country = ''
+        rule_sets       = get_rule_sets_for_region(phone_number, dialout_region || region)
+        
+        # build our total prefix
+        if dialout_region
+          prefix       = dialout_prefix.delete(' ') + dialout_region.country_code.to_s
+          country_code = dialout_region.country_code.to_s
+          dialout_country = country_code
+        else
+          prefix  = national_prefix
+          prefix += dialout_prefix unless(dialout_prefix.empty?)
+        end
+        
+        # strip the total prefix from the beginning of the number
+        phone_number = phone_number[prefix.length..-1]
+        number       = phone_number
+        
+        prefered_type = 0 # for sorting the priority
+        
+        # if we're dialing out or using the national prefix
+        if(dialout_region || !national_prefix.empty?)
+          # we need to sort the rules slightly different
+          prefered_type = dialout_region.nil? ? 1 : 2
+        end
+        
+        # sorting for rule priorities
+        rule_sets.each do |rule_set|
+          rule_set[:rules] = rule_set[:rules].sort_by do |rule|
+            # [ prefered rule type ASC, total_digits ASC ]
+            [ (rule[:type]==prefered_type) ? -1 : rule[:type], rule[:total_digits] ]
+          end
+        end
+        
+        # finally...find our matching rule
+        matching_rule = find_matching_rule(phone_number, rule_sets)
+        
+        # now that know how to format the number, do the formatting work...
+        if(matching_rule)
+          area_code     = phone_number[matching_rule[:areacode_offset], matching_rule[:areacode_length]]
+          number        = phone_number[matching_rule[:areacode_offset]+matching_rule[:areacode_length]..-1]
+          phone_number  = format(phone_number, matching_rule[:format].to_s)
+        
+          # replace 'n' with our national_prefix if it exists
+          if(phone_number[/n/])
+            phone_number.gsub!(/n{1}/, national_prefix)
+
+            # reset the national_prefix so we don't add it twice
+            national_prefix = ''
+          end
+        end
+          
+        # strip possible whitespace from the left
+        phone_number.lstrip!
+        
+        if(matching_rule && phone_number[/c/])  
+          # format the country code
+          if(dialout_prefix == '+')
+            phone_number.gsub!(/c{1}/, "+#{dialout_country}")
+          else
+            phone_number.gsub!(/c{1}/, dialout_country)
+            phone_number = "#{dialout_prefix} #{phone_number}" unless dialout_prefix.empty?
+          end
+        else
+          # default formatting
+          if(dialout_prefix == '+')
+            if(dialout_country.empty?)
+              phone_number = "+#{phone_number}"
+            else
+              phone_number = "+#{dialout_country} #{phone_number}"
+            end
+          else
+            phone_number = "#{dialout_country} #{phone_number}" unless dialout_country.empty?
+            phone_number = "#{dialout_prefix} #{phone_number}" unless dialout_prefix.empty?
+            phone_number = national_prefix + phone_number unless national_prefix.empty?
+          end
+        end
+        
+        # strip possible whitespace
+        phone_number.rstrip!
+        phone_number.lstrip!
+        
+        # Finally...we can output our parts as a hash
+        { :formatted_number => phone_number, :area_code => area_code, :country_code => country_code, :number => normalize(number) }
+      end
+      
+      private
+      def get_rule_sets_for_region(string, region)
+        rule_sets      = []
+        
+        if(region && region.rule_sets)
+          rule_sets = region.rule_sets.select do |rule_set|
+            rule_set[:digits] <= string.length
+          end
+        end
+        
+        rule_sets
+      end
+      
+      def find_matching_rule(string, rule_sets)
+        match = nil
+        
+        # go through all our given rules
+        for rule_set in rule_sets do
+          digits = rule_set[:digits]
+          prefix = string[0,digits].to_i
+          rules  = rule_set[:rules].select { |rule| rule[:total_digits] >= string.length }
+
+          rules.each do |rule|
+            if(prefix >= rule[:min] && prefix <= rule[:max])
+              match = rule
+              break
+            end
+          end
+          
+          break if match
+        end
+        
+        match
+      end
+      
+      def dialing_out?(string, region=nil)
+        region ||= PhoneNumber.default_region
+        !get_dialout_prefix(string, region).empty?
+      end
+            
+      def get_dialout_prefix(string, region=nil)
+        region ||= PhoneNumber.default_region
+        prefixes = region.dialout_prefixes
+        dialout_prefix = ''
+        
+        # check if we're dialing outside our region
+        if string[0].chr == '+'
+          dialout_prefix = '+'
+        end
+
+        for prefix in prefixes do
+          regexp = Regexp.escape(prefix)
+          match_str = string
+          
+          # we have matching wild cards
+          if(prefix[/X/] && string =~ Regexp.new("^#{Regexp.escape(prefix.delete('X '))}"))
+            regexp.gsub!(/X/, "[0-9]{0,1}")
+            match_str = format(string[prefix.scan(/[0-9]/).size, prefix.count('X')], prefix)
+            prefix    = match_str
+          end
+          
+          if(match_str =~ Regexp.new("^#{regexp}"))
+            dialout_prefix = prefix
+            break
+          end
+        end
+        
+        dialout_prefix
+      end
+      
+      def get_national_prefix(string, region=nil)
+        region ||= PhoneNumber.default_region
+        prefix = region.national_prefix
+        national_prefix = ''
+
+        # in case we're not dialing out and the number starts with the national_prefix
+        if(!dialing_out?(string, region) && string =~ Regexp.new("^#{Regexp.escape(prefix)}"))
+          national_prefix = prefix
+        end
+
+        national_prefix
+      end
+      
+      def get_dialout_region(string, region)
+        region ||= PhoneNumber.default_region
+        dialout_prefix = get_dialout_prefix(string, region)
+        dialout_region = nil
+        
+        unless dialout_prefix.empty?
+          # region codes are 1 to 3 digits
+          range_end = [string.length-dialout_prefix.delete(' ').length, 3].min
+
+          (1..range_end).each do |i|
+            dialout_region = Region.find(string[dialout_prefix.delete(' ').length, i])
+            break if dialout_region
+          end
+        end
+        
+        dialout_region
+      end
+    end
+  end
+
+end

data/lib/phoney/region.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+
+class PhoneNumber
+  
+  class Region
+    @@regions = []
+    
+    attr_reader :country_code, :country_abbr
+    attr_reader :national_prefix, :dialout_prefixes
+    attr_reader :rule_sets
+    
+    class << self
+      def load
+        data_file = File.join(File.dirname(__FILE__), '..', 'data', 'regions.yml')
+    
+        @@regions = []
+        YAML.load(File.read(data_file)).each_pair do |key, region_hash|
+          new_region = Region.new(region_hash)
+          @@regions.push(new_region)
+        end
+        @@regions
+      end
+  
+      def all
+        return @@regions unless @@regions.empty?
+    
+        load
+      end
+  
+      def find(param)
+        return nil unless param
+        
+        param = param.to_sym
+    
+        all.detect do |region|
+          region.country_code == param || region.country_abbr == param
+        end
+      end
+  
+      def [](param)
+        find(param)
+      end
+    end
+    
+    def initialize(hash)
+      @country_abbr = hash[:country_abbr]
+      @country_code = hash[:country_code]
+    
+      @national_prefix  = hash[:national_prefix]
+      @dialout_prefixes = hash[:dialout_prefixes]
+    
+      @rule_sets = hash[:rule_sets]
+    end
+    
+    def to_s
+      "#{@country_abbr.to_s} [+#{@country_code.to_s}]"
+    end
+  end
+  
+end

data/lib/phoney/utils.rb

@@ -0,0 +1,52 @@
+class PhoneNumber
+  
+  module Utils
+    
+    # Returns the string formatted according to a pattern.
+    #
+    # Examples:
+    # format('123456789', 'XXX-XX-XXXX')
+    #    => "123-45-6789"
+    # format('12345', 'XXX-XX-XXXX')
+    #    => "123-45"
+    #
+    # Parameters:
+    # string  -- The string to be formatted.
+    # pattern -- The format string, see above examples.
+    # fixchar -- The single-character placeholder. Default is 'X'.
+    def format(string, pattern, fixchar='X')
+      raise ArgumentError.new("First parameter 'string' must be a String") unless string.is_a?(String)
+      raise ArgumentError.new("#{fixchar} too long") if fixchar.length > 1
+
+      slots = pattern.count(fixchar)
+
+      # Return the string if it doesn't fit and we shouldn't even try,
+      return string if string.length > slots
+
+      # Make the result.
+      scanner = ::StringScanner.new(pattern)
+      regexp  = Regexp.new(Regexp.escape(fixchar))
+      index   = 0
+      result  = ''
+
+      while(!scanner.eos? && index < string.length)
+        if scanner.scan(regexp) then
+          result += string[index].chr
+          index  += 1
+        else
+          result += scanner.getch
+        end
+      end
+
+      result
+    end
+
+    # Strips all non-numberpad characters from a string
+    # => For example: "+45 (123) 023 1.1.1" -> "+45123023111"
+    def normalize(string_with_number)
+      string_with_number.scan(/[0-9+*#]/).to_s unless string_with_number.nil?
+    end
+    
+  end
+  
+end

data/lib/phoney/version.rb

@@ -0,0 +1,11 @@
+class PhoneNumber
+  
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 3
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+end