phoney 0.1.3 → 0.2.0

data/lib/phoney/region.rb

@@ -1,39 +1,30 @@
-require 'yaml'
+require 'set'
 
-class PhoneNumber
-  
+module Phoney
   class Region
-    @@regions = []
+    REGION_FILE = File.join(File.dirname(__FILE__), '..', 'data', 'regions.bin')
     
     attr_reader :country_code, :country_abbr
-    attr_reader :national_prefix, :dialout_prefixes
+    attr_reader :trunk_prefixes, :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)
+        Marshal.load(File.read(REGION_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
+        @@regions.empty? ? load : @@regions
       end
   
-      def find(param)
-        return nil unless param
-        
-        param = param.to_sym
-    
+      def find(param)    
         all.detect do |region|
-          region.country_code == param || region.country_abbr == param
+          region.country_code.to_s == param.to_s || region.country_abbr.to_s == param.to_s
         end
       end
   
@@ -42,29 +33,22 @@ class PhoneNumber
       end
     end
     
-    def initialize(hash)
-      @country_abbr = hash[:country_abbr]
-      @country_code = hash[:country_code]
+    def initialize(options={})
+      @country_abbr = options[:country_abbr]
+      @country_code = options[:country_code]
     
-      @national_prefix  = hash[:national_prefix]
-      @dialout_prefixes = hash[:dialout_prefixes]
+      @trunk_prefixes   = options[:trunk_prefixes]
+      @dialout_prefixes = options[:dialout_prefixes]
     
-      @rule_sets = hash[:rule_sets]
+      @rule_sets = SortedSet.new
       
-      if(@rule_sets)
-        for rule_set in @rule_sets do
-          if(rule_set[:rules])
-            rule_set[:rules].each_with_index do |rule,index|
-              rule.merge!(:index => index)
-            end
-          end
-        end
+      (options[:rule_sets]||[]).each do |rule_group|
+        @rule_sets.add RuleGroup.new(rule_group[:significant_digits], rule_group[:rules])
       end
     end
     
     def to_s
-      "#{@country_abbr.to_s} [+#{@country_code.to_s}]"
+      country_abbr
     end
   end
-  
 end

data/lib/phoney/rules.rb

@@ -0,0 +1,56 @@
+module Phoney
+  class RuleGroup
+    attr_reader :significant_digits, :rules
+    
+    def initialize(significant_digits, rules=[])
+      @significant_digits = significant_digits
+      @rules = []
+      
+      rules.each do |rule|
+        add_rule Rule.new(rule)
+      end
+    end
+    
+    def add_rule(rule)
+      @rules.push rule
+    end
+    
+    def delete_rule(rule)
+      @rules.delete rule
+    end
+    
+    def <=>(other)
+      other.significant_digits <=> significant_digits
+    end
+  end
+  
+  class Rule
+    attr_reader :max_digits, :min_value, :max_value, :areacode_length, :areacode_offset, :pattern
+    
+    def initialize(options={})
+      @max_digits = options[:max_digits]
+      
+      @min_value = options[:min_value]
+      @max_value = options[:max_value]
+      
+      @areacode_length = options[:areacode_length]
+      @areacode_offset = options[:areacode_offset]
+      
+      @pattern = options[:pattern]
+      @flags   = options[:flags]
+    end
+    
+    def <=>(other)
+      max_digits <=> other.max_digits
+    end
+    
+    def matches?(number)
+      value = number.to_s[0, max_value.to_s.length].to_i
+      (min_value..max_value).member?(value) && number.length <= max_digits
+    end
+    
+    def flags
+      @flags || []
+    end
+  end
+end

data/lib/phoney/vanity.rb

@@ -0,0 +1,31 @@
+module Phoney
+  # Helper module that maps vanity numbers to digit numbers.
+  module Vanity
+    VANITY_REGEXP = /\A\d{3}[a-zA-Z]{6,12}\Z/
+    VANITY_NORMALIZING_REGEXP = /^0*|[^\d\w]/
+    
+    # Returns a char to number mapping string for the String#tr method.
+    def self.mapping
+      @@mapping ||= [
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.freeze,
+        '2223334445556667777888999922233344455566677778889999'.freeze
+      ]
+    end
+    
+    # Replaces (and normalizes) vanity characters of passed number with correct digits.
+    def self.replace number
+      number.tr *mapping
+    end
+    
+    # Returns true if there is a character in the number
+    # after the first four numbers.
+    def self.vanity? number
+      !(normalized(number) =~ VANITY_REGEXP).nil?
+    end
+    
+    # Vanity-Normalized.
+    def self.normalized number
+      number.gsub VANITY_NORMALIZING_REGEXP, ''
+    end
+  end
+end

data/lib/phoney/version.rb

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

data/phoney.gemspec

@@ -1,48 +1,20 @@
-# -*- encoding: utf-8 -*-
-
-$:.push File.expand_path("../lib", __FILE__)
-
-# Maintain your gem's version:
+$:.unshift File.expand_path("../lib", __FILE__)
 require "phoney/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{phoney}
-  s.version = PhoneNumber::VERSION::STRING
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Jan Habermann"]
-  s.date = %q{2011-12-01}
-  s.description = %q{Ruby library that parses a phone number and automatically formats it correctly, depending on the country/locale you set.}
-  s.email = %q{jan@habermann24.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENCE",
-    "README.rdoc",
-    "Rakefile",
-    "lib/data/regions.yml",
-    "lib/phoney.rb",
-    "lib/phoney/base.rb",
-    "lib/phoney/parser.rb",
-    "lib/phoney/region.rb",
-    "lib/phoney/utils.rb",
-    "lib/phoney/version.rb",
-    "phoney.gemspec",
-    "spec/parser/br_spec.rb",
-    "spec/parser/de_spec.rb",
-    "spec/parser/us_spec.rb",
-    "spec/phone_number_spec.rb",
-    "spec/spec.opts",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/habermann24/phoney}
-  s.require_paths = ["lib"]
-  s.summary = %q{Ruby library that formats phone numbers.}
-
-  s.add_development_dependency(%q<rake>, [">= 0"])
-  s.add_development_dependency(%q<rspec>, ["= 2.11.0"])
+  s.name = 'phoney'
+  s.version = Phoney::VERSION
+  s.author = 'Jan Habermann'
+  s.email = 'jan@habermann24.com'
+  s.homepage = 'http://github.com/habermann24/phoney'
+  s.summary = 'Ruby library that formats phone numbers.'
+  s.description = 'Ruby library that parses a phone number and automatically formats it correctly, depending on the country/locale you set.'
+  
+  s.required_rubygems_version = '>= 1.9'
+  
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+  
+  s.files = Dir["#{File.dirname(__FILE__)}/**/*"]
 end
 

data/resources/liveinput_tester.rb

@@ -0,0 +1,32 @@
+require 'bundler/setup'
+require 'phoney'
+
+require 'io/console'
+
+Phoney.region = ARGV.first||'us'
+
+input  = ''
+prompt = "(Ctrl-C to exit) #[#{Phoney.region.country_abbr}]: "
+print prompt
+
+while ch = STDIN.getch do
+  case ch.ord
+  when 3   # Ctrl-C
+    break
+  when 127 # Backspace
+    input = input[0..-2]
+    print "\b"
+  else
+    input << ch
+  end
+  
+  output = Phoney::Parser.parse input
+  
+  print "\r#{prompt}"
+  print output
+  
+  print " "*100
+  print "\b"*100
+end
+
+puts "\n^C Exiting - Goodbye"

data/resources/phoneformat_converter.rb

@@ -0,0 +1,122 @@
+require 'yaml'
+
+module PhoneformatConverter
+  class Country
+    attr_accessor :international_prefix, :code, :offset
+    attr_accessor :desc_len, :desc_count, :disp_scheme_offset, :rules_sets_count
+    attr_accessor :trunk_prefixes
+    attr_accessor :dialout_prefixes
+  end
+  
+  def self.convert(file)
+    io = File.open(file, "rb")
+    num_countries = io.read(4).unpack("V")[0]
+    countries = []
+
+    (1..num_countries).each do
+      country = Country.new
+      country.international_prefix, country.code, country.offset = io.read(12).unpack("a4/a4/V")
+  
+      country.international_prefix = country.international_prefix.delete("\000")
+      country.code = country.code.delete("\000")
+  
+      countries << country
+    end
+
+    data = io.read
+
+    countries.each do |c|
+      c.desc_len, c.desc_count, c.disp_scheme_offset, c.rules_sets_count = data[c.offset, 12].unpack("v/v/V/V")
+  
+      local_nat_raw = data[c.offset+12, c.desc_len-12].unpack("A*")
+  
+      c.trunk_prefixes = local_nat_raw.to_s.delete('"[]').split('\0\0').first.split('\0').reject(&:empty?) rescue []
+      c.dialout_prefixes = local_nat_raw.to_s.delete('"[]').split('\0\0').last.split('\0').reject(&:empty?) rescue []
+      
+      temp_dialout_prefixes = c.dialout_prefixes
+      c.dialout_prefixes = []
+      
+      temp_dialout_prefixes.each do |p|
+        if p.start_with?('->')
+          c.dialout_prefixes.last << p
+        else
+          c.dialout_prefixes << p
+        end
+      end
+  
+      rules_offset = c.offset+c.desc_len                 # points to the rules section
+      scheme_base  = rules_offset+c.disp_scheme_offset   # points to the scheme section
+  
+      puts "#{c.code}:"
+      puts "  :country_code: #{c.international_prefix}"
+      puts "  :country_abbr: #{c.code}"
+      puts "  :trunk_prefixes: #{c.trunk_prefixes}"
+      puts "  :dialout_prefixes: #{c.dialout_prefixes}"
+      puts "  :rule_sets:"
+      
+      smallest_scheme_offset = nil
+  
+      (0..(c.rules_sets_count-1)).each do |rule_set_idx|
+        digits, rules_count = data[rules_offset, 4].unpack("v/v")
+    
+        puts "  - :significant_digits: #{digits}"
+        puts "    :rules:"
+        
+        # iterate over individual rules
+        (0..(rules_count-1)).each do |rule_idx|
+          # each rule is 16 bytes
+          prefix_min,prefix_max,unkn1,total_digits,areacode_offset,areacode_length,type,unkn2,scheme_offset = data[rules_offset+4+(rule_idx*16), 16].unpack("V/V/C/C/C/C/C/C/v")
+          
+          scheme_length = data[(scheme_base+scheme_offset)..-1].index("\x00")
+          comment_length = data[(scheme_base+scheme_offset+scheme_length+1)..-1].index("\x00")
+          
+          # now extract the rule scheme and comment
+          scheme  = data[scheme_base+scheme_offset, scheme_length]
+          comment = data[scheme_base+scheme_offset+scheme_length+1, comment_length]
+          
+          smallest_scheme_offset ||= scheme_offset
+          smallest_scheme_offset = [smallest_scheme_offset, scheme_offset].min
+      
+          flags = []
+      
+          types_bin = ("%08b" % type).split('').reverse
+          types_bin.each_with_index do |t,i|
+            if t.to_i == 1
+              case 2**i
+              when 1
+                flags << :n
+              when 2
+                flags << :c
+              when 4
+                flags << :toll_free
+              when 8
+                flags << :local
+              when 16
+                flags << :unknown_16
+              when 32
+                flags << :unknown_32
+              end
+            end
+          end
+      
+          puts "      - :min_value: #{prefix_min}"
+          puts "        :max_value: #{prefix_max}"
+          puts "        :max_digits: #{total_digits}"
+          puts "        :areacode_length: #{areacode_length}"
+          puts "        :areacode_offset: #{areacode_offset}"
+          puts "        :unknown1: #{unkn1}"
+          puts "        :unknown2: #{unkn2}"
+          puts "        :pattern: \"#{scheme}\""
+          puts "        :flags:"
+          flags.each do |flag|
+            puts "          - :#{flag}"
+          end
+        end
+    
+        rules_offset += (4 + rules_count*16) # move to next rules-set 
+      end
+      
+      pre_scheme = data[scheme_base, smallest_scheme_offset||0]
+    end
+  end
+end

data/resources/tasks/region_data.rake

@@ -0,0 +1,23 @@
+require 'yaml'
+require './resources/phoneformat_converter'
+
+namespace :phoney do
+  desc 'Generate a regions YAML file from a .phoneformat binary'
+  task :generate_regions_yml do
+    raise 'You must provide .phoneformat FILE for the task to run' unless ENV['FILE']
+    PhoneformatConverter.convert(ENV['FILE'])
+  end
+  
+  desc 'Generate a new regions data file from a .phoneformat binary'
+  task :generate_regions_bin do
+    raise 'You must provide .phoneformat FILE for the task to run' unless ENV['FILE']
+    
+    output  = StringIO.new
+    $stdout = output
+    
+    PhoneformatConverter.convert(ENV['FILE'])
+    
+    $stdout = STDOUT
+    puts Marshal.dump(YAML.load(output.string))
+  end
+end

data/test/formatter_test.rb

@@ -0,0 +1,91 @@
+require 'phoney/test_helper'
+
+class FormatterTest < MiniTest::Unit::TestCase
+  include Phoney::Formatter
+  
+  def setup
+    Phoney.region = 'us'
+  end
+  
+  def test_international_call_prefix_for_us_region
+    assert_equal "0", international_call_prefix_for("0")
+    assert_equal "01", international_call_prefix_for("01")
+    assert_equal "011", international_call_prefix_for("011")
+    assert_equal "011", international_call_prefix_for("011999")
+    assert_equal nil, international_call_prefix_for("123")
+  end
+  
+  def test_international_call_prefix_for_br_region
+    assert_equal "+00", international_call_prefix_for("+0055123", region: Phoney::Region["br"])
+    assert_equal "00 55", international_call_prefix_for("0055123", region: Phoney::Region["br"])
+    assert_equal "00 12", international_call_prefix_for("0012456", region: Phoney::Region["br"])
+    assert_equal nil, international_call_prefix_for("03001234567", region: Phoney::Region["br"])
+  end
+  
+  def test_international_call_prefix_with_plus_sign
+    assert_equal "+011", international_call_prefix_for("+011")
+    assert_equal "+", international_call_prefix_for("+123")
+    assert_equal "+", international_call_prefix_for("+")
+  end
+  
+  def test_formatting_international_call_with_non_exiting_country
+    assert_equal "+99", format("+99", "###")
+    
+    assert_equal "+99", Phoney::Parser.parse("+99")
+    assert_equal "+999999999", Phoney::Parser.parse("+999999999")
+    
+    assert_equal "011 99", Phoney::Parser.parse("01199")
+    assert_equal "011 999999999", Phoney::Parser.parse("011999999999")
+  end
+  
+  def test_international_calling_prefix_for_empty_number
+    assert_equal nil, international_call_prefix_for("")
+  end
+  
+  def test_country_code_extraction
+    assert_equal "49", extract_country_code("+49")
+    assert_equal "49", extract_country_code("01149")
+    assert_equal "49", extract_country_code("01149123456")
+    assert_equal "1", extract_country_code("0111234567")
+    assert_equal nil, extract_country_code("03001234567", region: Phoney::Region["br"])
+  end
+  
+  def test_nonexisting_country_code
+    assert_equal nil, extract_country_code("+99")
+    assert_equal nil, extract_country_code("01199")
+  end
+  
+  def test_trunk_prefix_extraction
+    assert_equal "1", extract_trunk_prefix("+117041234567")
+    assert_equal "0", extract_trunk_prefix("+49040")
+    assert_equal nil, extract_trunk_prefix("+1705")
+    assert_equal nil, extract_trunk_prefix("+1")
+    assert_equal nil, extract_trunk_prefix("+4940")
+    
+    assert_equal "1", extract_trunk_prefix("011117041234567")
+    assert_equal nil, extract_trunk_prefix("011705")
+    assert_equal "0", extract_trunk_prefix("01149040")
+  end
+  
+  def test_format_international_number_with_trunk_prefix
+    assert_equal "+1 (1) (704) 205-1234", Phoney::Parser.parse("+117042051234")
+    assert_equal "+49 (0) 40 1234567", Phoney::Parser.parse("+490401234567")
+    assert_equal "011 1 (1) (704) 205-1234", Phoney::Parser.parse("011117042051234")
+    assert_equal "011 49 (0) 40 1234567", Phoney::Parser.parse("011490401234567")
+  end
+  
+  def test_format_string_without_prefixes
+    assert_equal "123", format("123", "n ###")
+    assert_equal "123", format("123", "c ###")
+    assert_equal "123", format("123", "c n ###")
+  end
+  
+  def test_format_number_with_double_international_prefix
+    assert_equal "+011 49 40", Phoney::Parser.parse("+0114940")
+  end
+  
+  def test_international_prefix_with_plus_and_trunk_prefix_start
+    assert_equal "+0", international_call_prefix_for("+0", region: Phoney::Region["de"])
+    assert_equal "+00", international_call_prefix_for("+00", region: Phoney::Region["de"])
+  end
+end