dialable 0.6.3 → 1.0.0

data/dialable.gemspec

@@ -3,24 +3,35 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'dialable/version'
 
-spec = Gem::Specification.new do |gem|
-  gem.licenses      = ['MIT', 'LGPL-2']
-  gem.required_ruby_version = '>= 1.9.0'
-  gem.name          = "dialable"
-  gem.version       = Dialable::VERSION
-  gem.authors       = ["chorn"]
-  gem.email         = ["chorn@chorn.com"]
-  gem.description   = %q{A gem that provides parsing and output of phone numbers according to NANPA (North American Numbering Plan Administration) standards.  If possible, time zones are populated by abbreviation as well as offset relative to the local timezone.}
-  gem.summary       = %q{Provides parsing and output of phone numbers according to NANPA standards.}
-  gem.homepage      = "http://github.com/chorn/dialable"
+Gem::Specification.new do |spec|
+  spec.name          = 'dialable'
+  spec.version       = Dialable::VERSION
+  spec.authors       = ['Chris Horn']
+  spec.email         = ['chorn@chorn.com']
+  spec.summary       = 'Provides parsing and output of phone numbers according to NANPA standards.'
+  spec.description   = 'A gem that provides parsing and output of phone numbers according to NANPA (North American Numbering Plan Administration) standards.  If possible, time zones are populated by abbreviation as well as offset relative to the local timezone.'
+  spec.homepage      = 'http://github.com/chorn/dialable'
+  spec.licenses      = ['MIT', 'LGPL-2']
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
-  gem.add_dependency "tzinfo"
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
-  gem.add_development_dependency "tzinfo"
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{!^bin/}).map { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  signing_key = File.expand_path("~/.certs/chorn@chorn.com-rubygems.key")
+  if File.file?(signing_key)
+    spec.signing_key = signing_key
+    spec.cert_chain = ['certs/chorn.pem']
+  end
+
+  spec.required_ruby_version = '>= 1.9.0'
+  spec.add_runtime_dependency 'tzinfo', '~> 1.0'
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.4'
+  spec.add_development_dependency 'guard', '~> 2.12'
+  spec.add_development_dependency 'guard-bundler', '~> 2.1'
+  spec.add_development_dependency 'guard-rspec', '~> 4.5'
+  spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'rspec', '~> 3.3'
 end
 

data/lib/dialable.rb

@@ -1,141 +1,48 @@
-# Copyright (c) 2008-2011 Chris Horn http://chorn.com/
-# See MIT-LICENSE.txt
-
-require "dialable/version"
-require "yaml"
-require "tzinfo"
+require 'dialable/version'
 require 'rubygems'
+require 'tzinfo'
+require 'dialable/area_codes'
+require 'dialable/service_codes'
+require 'dialable/patterns'
+require 'dialable/parsers'
 
 module Dialable
   class NANP
+    class InvalidNANPError < StandardError; end
 
-    ##
-    # Raised if something other than a valid NANP is supplied
-    class InvalidNANPError < StandardError
-    end
-
-    ##
-    # ERC, Easily Recognizable Codes
-    module ServiceCodes
-      ERC = {
-        211 => "Community Information and Referral Services",
-        311 => "Non-Emergency Police and Other Governmental Services",
-        411 => "Local Directory Assistance",
-        511 => "Traffic and Transportation Information (US); Provision of Weather and Traveller Information Services (Canada)",
-        611 => "Repair Service",
-        711 => "Telecommunications Relay Service (TRS)",
-        811 => "Access to One Call Services to Protect Pipeline and Utilities from Excavation Damage (US); Non-Urgent Health Teletriage Services (Canada)",
-        911 => "Emergency"
-      }
-    end
-
-    ##
-    # Regexs to match valid phone numbers
-    module Patterns
-      VALID = [
-        /^\D*1?\D*([2-9]\d\d)\D*(\d{3})\D*(\d{4})\D*[ex]+\D*(\d{1,5})\D*$/i,
-        /^\D*1?\D*([2-9]\d\d)[ $\\\.-]*(\d{3})[ $\\\.-]*(\d{4})[ $\\\.\*-]*(\d{1,5})\D*$/i,
-        /^\D*1?\D*([2-9]\d\d)\D*(\d{3})\D*(\d{4})\D*$/,
-        /^(\D*)(\d{3})\D*(\d{4})\D*$/,
-        /^\D*([2-9]11)\D*$/,
-        /^\D*1?\D*([2-9]\d\d)\D*(\d{3})\D*(\d{4})\D.*/  # Last ditch, just find a number
-        ]
-    end
-
-    ##
-    # Valid area codes per nanpa.com
-    module AreaCodes
-      data_path = Gem::datadir('dialable')
-      data_path ||= File.join(File.dirname(__FILE__), '..', 'data', 'dialable')
-      NANP = YAML.load_file(File.join(data_path, "nanpa.yaml"))
-    end
-
-    attr_accessor :areacode, :prefix, :line, :extension, :location, :country, :timezones, :relative_timezones, :raw_timezone
+    attr_accessor :areacode, :prefix, :line, :extension, :location, :country, :timezones, :relative_timezones
+    attr_reader :service_codes, :pattern
 
-    def initialize(parts={})
-      self.areacode  = parts[:areacode]  ? parts[:areacode]  : nil
-      self.prefix    = parts[:prefix]    ? parts[:prefix]    : nil
-      self.line      = parts[:line]      ? parts[:line]      : nil
-      self.extension = parts[:extension] ? parts[:extension] : nil
-    end
+    def self.parse(string, parser = Dialable::Parsers::NANP)
+      parsed = parser.call(string)
 
-    def areacode=(raw_code)
-      code = raw_code.to_i
-      if AreaCodes::NANP[code]
-        @areacode = raw_code
-        self.location = AreaCodes::NANP[code][:location] if AreaCodes::NANP[code][:location]
-        self.country = AreaCodes::NANP[code][:country] if AreaCodes::NANP[code][:country]
-        self.raw_timezone = AreaCodes::NANP[code][:timezone] if AreaCodes::NANP[code][:timezone]
-
-        if AreaCodes::NANP[code][:timezone]
-          self.timezones = []
-          self.relative_timezones = []
-          tz = AreaCodes::NANP[code][:timezone]
-          now = Time.now
-          local_utc_offset = now.utc_offset/3600
-
-          if tz =~ /UTC(-\d+)/
-            self.timezones << tz
-            utc_offset = $1.to_i
-            self.relative_timezones << (utc_offset) - local_utc_offset
-          else
-            tz.split(//).each do |zone|  # http://www.timeanddate.com/library/abbreviations/timezones/na/
-              zone = "HA" if zone == "H"
-              zone = "AK" if zone == "K"
-              tz = zone + (now.dst? ? "D" : "S") + "T"  # This is cludgey
-              self.timezones << tz
-              delta = nil
-              if Time.zone_offset(tz)
-                delta = Time.zone_offset(tz)/3600 - local_utc_offset
-              else
-                case zone
-                when /N[SD]T/
-                  delta = -3.5 - local_utc_offset
-                when /A[SD]T/
-                  delta = -4 - local_utc_offset
-                when /A?K[SD]T/
-                  delta = -9 - local_utc_offset
-                when /HA?[SD]T/
-                  delta = -10 - local_utc_offset
-                end
-                delta = delta - 1 if delta and now.dst?
-              end
-              # puts "#{delta} // #{Time.zone_offset(tz)} // #{tz} // #{local_utc_offset}"
-              self.relative_timezones << delta if delta
-            end
-          end
-        end
+      if parsed
+        return Dialable::NANP.new(parsed)
       else
-        raise InvalidNANPError, "#{code} is not a valid NANP Area Code."
+        fail InvalidNANPError, "Not a valid NANP Phone Number."
       end
     end
 
-    def timezone
-      @timezones.first if @timezones
-    end
-
-    def timezone=(tz)
-      @timezones = [tz] if tz
+    def initialize(parts = {}, options = {})
+      self.areacode  = parts.fetch(:areacode)
+      self.prefix    = parts.fetch(:prefix)
+      self.line      = parts.fetch(:line)
+      self.extension = parts.fetch(:extension)
+      @service_codes = options.fetch(:service_codes) { Dialable::ServiceCodes::NANP }
+      @patterns      = options.fetch(:patterns)      { Dialable::Patterns::NANP }
     end
 
-    # def relative_timezones
-    #   rt = []
-    #   @timezones.each do |tz|
-    #     rt <<
-    #   end
-    #   rt
-    # end
-
-    def self.parse(number)
-      Patterns::VALID.each do |pattern|
-        return Dialable::NANP.new(:areacode => $1, :prefix => $2, :line => $3, :extension => $4) if number =~ pattern
-      end
-
-      raise InvalidNANPError, "Not a valid NANP Phone Number."
+    def areacode=(raw_code)
+      code = AreaCodes::NANP.fetch(raw_code.to_i) { fail InvalidNANPError, "#{code} is not a valid NANP Area Code." }
+      @areacode = raw_code
+      @location = code.fetch(:location) { nil }
+      @country = code.fetch(:country) { nil }
+      @timezones = code.fetch(:timezones) { [] }
+      @relative_timezones = @timezones.map { |timezone| timezone_offset(timezone) }
     end
 
     def erc?
-      return ServiceCodes::ERC[@areacode].nil?
+      @service_codes.key?(@areacode)
     end
 
     def to_s
@@ -159,12 +66,34 @@ module Dialable
     end
 
     def to_hash
-      return {
+      {
         :areacode => @areacode,
         :prefix => @prefix,
         :line => @line,
         :extension => @extension
       }
     end
+
+    def timezone
+      @timezones.first if @timezones
+    end
+
+    def timezone=(tz)
+      @timezones = [tz] if tz
+    end
+
+    def raw_timezone
+      @raw_timezones.first if @raw_timezones
+    end
+
+    def relative_timezone
+      @relative_timezones.first if @relative_timezones
+    end
+
+    private
+
+    def timezone_offset(raw)
+      TZInfo::Timezone.get(raw).offsets_up_to(0).first.utc_total_offset / 3600
+    end
   end
 end

data/lib/dialable/area_codes.rb

@@ -0,0 +1,13 @@
+require 'yaml'
+
+module Dialable
+  module AreaCodes
+
+    # Valid area codes per nanpa.com
+    data_path = Gem.datadir('dialable')
+    data_path ||= File.join(File.dirname(__FILE__), '..', 'data', 'dialable')
+
+    NANP = YAML.load_file(File.join(data_path, 'nanpa.yaml'))
+
+  end
+end

data/lib/dialable/parsers.rb

@@ -0,0 +1,19 @@
+require 'dialable/patterns'
+
+module Dialable
+  module Parsers
+
+    NANP = lambda do |string, patterns = Dialable::Patterns::NANP|
+      patterns.each do |pattern|
+        pattern.match(string) do |m|
+          return { areacode: m[1],
+                   prefix: m[2],
+                   line: m[3],
+                   extension: m[4],
+                }
+        end
+      end
+    end
+
+  end
+end

data/lib/dialable/patterns.rb

@@ -0,0 +1,15 @@
+module Dialable
+  module Patterns
+
+    # Regexs to match valid phone numbers
+    NANP = [
+      Regexp.new('^\D*1?\D*([2-9]\d\d)\D*(\d{3})\D*(\d{4})\D*[ex]+\D*(\d{1,5})\D*$', Regexp::IGNORECASE),
+      Regexp.new('^\D*1?\D*([2-9]\d\d)[ $\\\.-]*(\d{3})[ $\\\.-]*(\d{4})[ $\\\.\*-]*(\d{1,5})\D*$', Regexp::IGNORECASE),
+      Regexp.new('^\D*1?\D*([2-9]\d\d)\D*(\d{3})\D*(\d{4})\D*$'),
+      Regexp.new('^(\D*)(\d{3})\D*(\d{4})\D*$'),
+      Regexp.new('^\D*([2-9]11)\D*$'),
+      Regexp.new('^\D*1?\D*([2-9]\d\d)\D*(\d{3})\D*(\d{4})\D.*') # Last ditch, just find a number
+    ]
+
+  end
+end

data/lib/dialable/service_codes.rb

@@ -0,0 +1,17 @@
+module Dialable
+  module ServiceCodes
+
+    # Easily Recognizable Codes
+    NANP = {
+      211 => 'Community Information and Referral Services',
+      311 => 'Non-Emergency Police and Other Governmental Services',
+      411 => 'Local Directory Assistance',
+      511 => 'Traffic and Transportation Information (US); Provision of Weather and Traveller Information Services (Canada)',
+      611 => 'Repair Service',
+      711 => 'Telecommunications Relay Service (TRS)',
+      811 => 'Access to One Call Services to Protect Pipeline and Utilities from Excavation Damage (US); Non-Urgent Health Teletriage Services (Canada)',
+      911 => 'Emergency'
+    }
+
+  end
+end

data/lib/dialable/version.rb

@@ -1,3 +1,3 @@
 module Dialable
-    VERSION = "0.6.3"
+  VERSION = "1.0.0"
 end

data/spec/dialable_spec.rb

@@ -1,48 +1,87 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 describe Dialable do
-  describe "with a full NANP number with extension" do
-    subject { Dialable::NANP.parse("+1(307)555-1212 ext 1234") }
+  context 'with a full NANP number with extension' do
+    subject { Dialable::NANP.parse('+1(307)555-1212 ext 1234') }
 
-    it("should extract the area code") { subject.areacode.should == "307" }
-    it("should extract the prefix") { subject.prefix.should == "555" }
-    it("should extract the line number") { subject.line.should == "1212" }
-    it("should extract the extension") { subject.extension.should == "1234" }
+    it 'will not raise an exception' do
+    end
+
+    it 'will parse the area code' do
+      expect(subject.areacode).to eq '307'
+    end
+
+    it 'will parse the prefix' do
+      expect(subject.prefix).to eq '555'
+    end
+
+    it 'will parse the line number' do
+      expect(subject.line).to eq '1212'
+    end
 
+    it 'will parse the extension' do
+      expect(subject.extension).to eq '1234'
+    end
   end
 
-  describe "with a full NANP number with extension and appropriate daylight/standard time" do
-    subject { Dialable::NANP.parse("+1(307)555-1212 ext 1234") }
-    it("should determine the time zone during daylight savings or standard time") {
-      target_zone = Time.new.dst? ? "MDT" : "MST"
-      subject.timezones.should == [target_zone]
-    }
+  context 'with a full NANP number with extension and appropriate daylight/standard time' do
+    let(:target_zone) { 'US/Mountain' }
+    subject { Dialable::NANP.parse('+1(307)555-1212 ext 1234') }
+
+    it 'will determine the time zone during daylight savings or standard time' do
+      expect(subject.timezones).to eq [target_zone]
+    end
   end
 
-  NANP = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'data') + "/nanpa.yaml")
+  NANP = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'data', 'dialable') + '/nanpa.yaml')
   NANP.delete(:created)
   NANP.each do |nanp|
     areacode = nanp[0]
-    describe "recognize the area code #{areacode} in ()'s" do
-      subject { Dialable::NANP.parse("(#{areacode})5551212") }
-      it("should extract the area code") { subject.areacode.should == areacode.to_s }
-    end
-    describe "recognize the area code #{areacode} with garbage" do
-      subject { Dialable::NANP.parse("noise #{areacode}noise5551212") }
-      it("should extract the area code") { subject.areacode.should == areacode.to_s }
-    end
-    describe "with a sloppy areacode of #{areacode} and number" do
-      subject { Dialable::NANP.parse("+1-#{areacode}555  1212") }
-      it("should match the location") { subject.location.should == nanp[1][:location] }
-    end
-    describe "with areacode of #{areacode} and a sloppy extension" do
-      subject { Dialable::NANP.parse("1 #{areacode} 867 5309 xAAA0001") }
-      it("should match the country") { subject.country.should == nanp[1][:country] }
-    end
-    describe "with areacode of #{areacode} and lots of garbage" do
-      subject { Dialable::NANP.parse("1 #{areacode}yadayada867BLAH5309....derp") }
-      it("should match the timezone") { subject.raw_timezone.should == nanp[1][:timezone] }
+    country = nanp[1].fetch(:country) { nil }
+    location = nanp[1].fetch(:location) { nil }
+    timezones = nanp[1].fetch(:timezones) { nil }
+    timezone = timezones.first if timezones
+
+    context "with area code #{areacode}" do
+      describe "when the areacode is in ()" do
+        subject { Dialable::NANP.parse("(#{areacode})5551212") }
+
+        it 'will parse the area code' do
+          expect(subject.areacode).to eq areacode.to_s
+        end
+      end
+
+      describe 'when there is text noise in the number' do
+        subject { Dialable::NANP.parse("noise #{areacode}noise5551212") }
+
+        it 'will parse area code' do
+          expect(subject.areacode).to eq areacode.to_s
+        end
+      end
+
+      describe 'when the areacode has extra noise' do
+        subject { Dialable::NANP.parse("+1-#{areacode}555  1212") }
+
+        it 'will find the location' do
+          expect(subject.location).to eq location
+        end
+      end
+
+      describe 'when the extension has extra noise' do
+        subject { Dialable::NANP.parse("1 #{areacode} 867 5309 xAAA0001") }
+
+        it 'will find the country' do
+          expect(subject.country).to eq country
+        end
+      end
+
+      describe 'when there is lots of garbage in the string' do
+        subject { Dialable::NANP.parse("1 #{areacode}yadayada867BLAH5309....derp") }
+
+        it 'will find the timezone' do
+          expect(subject.timezone).to eq timezone
+        end
+      end
     end
   end
-
-end
+end