piliponi 1.0.2 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e17b42c405d47c28ce0322084f2807d51bfaca6d
+  data.tar.gz: a4bd72acdc0c0c7ae91f1a05e3d7cc8f27800f02
+SHA512:
+  metadata.gz: db1d7ff2967a5fe8478e129d412e7d82635b7b5b2a80012640ca602e0b82a40dd4918ca3c4b6d4d29385747eaad930c3f8b4547089bc555182b5ada6414bf640
+  data.tar.gz: d7210b10f80175e02137bb9a500b6629e28bcae974934b237d8cf7b8ec7c7bb79148d10e1a7c8c10380cbc1c8244f0106e9a382b67266ec3c06938413932b9c4

data/README.md

@@ -19,7 +19,7 @@ Or install it yourself as:
     $ gem install piliponi
 
 ## Usage
-Include piliponi to your class to use its methods
+Include piliponi to your class to use its methods or access it directly as singleton methods.
 
     class Dummy
       include Piliponi
@@ -27,38 +27,52 @@ Include piliponi to your class to use its methods
 
     dummy = Dummy.new
 
+
 ###Plausible
 Check if the number is a probable mobile number
 
-    dummy.plausible? "091700000001"   #true
-    dummy.plausible? "NotaNumber"   #false
+    Piliponi.plausible? "09170000001"   #true
+    dummy.plausible? "091700000001"     #true
+    dummy.plausible? "NotaNumber"       #false
 
 ###Clean
 Removes Non-numeric characters
 
-    dummy.clean "+639-17-000-0001" #639170000001
+    Piliponi.clean "+639-17-000-0001" #639170000001
+    dummy.clean "+639-17-000-0001"    #639170000001
 
 ###Telco
 Returns local Telco coverage of a given number
 
+    Piliponi.telco "09170000001" #globe
     dummy.telco "09170000001" #globe
 
 ###Normalization
 Returns formatted numbers as specified
 
 ####Local
+
+    Piliponi.normalize("0917-000-0000", format: :local) #09170000000
     dummy.normalize("0917-000-0000", format: :local) #09170000000
 
 ####International
+
+    Piliponi.normalize("0917-000-0000", format: :international) #+639170000000
     dummy.normalize("0917-000-0000", format: :international) #+639170000000
 
 ####Pure
+
+    Piliponi.normalize("0917-000-0000", format: :pure) #9170000000
     dummy.normalize("0917-000-0000", format: :pure) #9170000000
 
 ####Erroneous Numbers
+
+    Piliponi.normalize("wat", format: :pure) #Piliponi::InvalidPhoneNumberException
     dummy.normalize("wat", format: :pure) #Piliponi::InvalidPhoneNumberException
 
 ####Wrong format
+
+    Piliponi.normalize("0917-000-0000", format: :none) #Piliponi::FormatNotRecognizedException
     dummy.normalize("0917-000-0000", format: :none) #Piliponi::FormatNotRecognizedException
 
 ##Needs

data/lib/piliponi/core.rb

@@ -0,0 +1,59 @@
+module Core
+  class ::FormatNotRecognizedException < Exception; end;
+  class ::InvalidPhoneNumberException < Exception; end;
+
+  def plausible? number
+    return false if number.nil?
+
+    clean_num = clean(number)
+    size = clean_num.size
+
+    ((clean_num[0] == "9" && size == 10) ||
+    (clean_num[0..1] == "63" && size == 12) ||
+    (clean_num[0..1] == "09" && size == 11)) &&
+    telco?(clean_num) != "unknown"  
+  end
+
+  def normalize(number, options={})
+    formats = [:pure, :local, :international]
+    format = options[:format].intern
+
+    raise FormatNotRecognizedException unless formats.include?(format)
+
+    return send "_nf_#{format}", clean(number) if plausible?(number)
+    raise InvalidPhoneNumberException
+  end
+
+  def clean(number=nil)
+    number.tr('^0-9','') if number
+  end
+
+  def telco? number=nil
+    PiliponiApi.new.lookup prefix(clean number)
+  end
+
+  def prefix number=nil
+    hash = { '0' => [0,3], '6' => [2,4], '9' => [0,2] }
+    start, finish = hash[number[0]].first, hash[number[0]].last
+    clean_prefix(number[start..finish])
+  end
+
+  def clean_prefix(number)
+    number = "0#{number}" if number[0] != '0'; number
+  end
+
+  private
+
+    def _nf_pure(number)
+      number[-10..-1]
+    end
+
+    def _nf_local(number)
+      '0' << _nf_pure(number)
+    end
+
+    def _nf_international(number)
+      '+63' << _nf_pure(number)
+    end
+
+end

data/lib/piliponi/piliponi_api.rb

@@ -1,4 +1,4 @@
-module Piliponi
+module Core
   class PiliponiApi
     def lookup(prefix)
       smart = %w{0813 0918 0947 0998 0999}

data/lib/piliponi/support.rb

@@ -0,0 +1,11 @@
+module SingletonMethodSupport
+
+  module SingletonMethods
+    include Core
+  end
+  
+  def self.included(base)
+    base.extend SingletonMethods
+  end
+
+end

data/lib/piliponi/version.rb

@@ -1,3 +1,3 @@
 module Piliponi
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/lib/piliponi.rb

@@ -1,61 +1,9 @@
+require "piliponi/core"
 require "piliponi/version"
 require "piliponi/piliponi_api"
+require "piliponi/support"
 
 module Piliponi
-  class ::FormatNotRecognizedException < Exception; end;
-  class ::InvalidPhoneNumberException < Exception; end;
-
-  def plausible? number
-    return false if number.nil?
-
-    clean_num = clean(number)
-    size = clean_num.size
-
-    ((clean_num[0] == "9" && size == 10) ||
-    (clean_num[0..1] == "63" && size == 12) ||
-    (clean_num[0..1] == "09" && size == 11)) &&
-    telco?(clean_num) != "unknown"
-  end
-
-  def normalize(number, options={})
-    formats = [:pure, :local, :international]
-    format = options[:format].intern
-
-    raise FormatNotRecognizedException unless formats.include?(format)
-
-    return send "_nf_#{format}", clean(number) if plausible?(number)
-    raise InvalidPhoneNumberException
-  end
-
-  def clean(number=nil)
-    number.tr('^0-9','') if number
-  end
-
-  def telco? number=nil
-    PiliponiApi.new.lookup prefix(clean number)
-  end
-
-  def prefix number=nil
-    hash = { '0' => [0,3], '6' => [2,4], '9' => [0,2] }
-    start, finish = hash[number[0]].first, hash[number[0]].last
-    clean_prefix(number[start..finish])
-  end
-
-  def clean_prefix(number)
-    number = "0#{number}" if number[0] != '0'; number
-  end
-
-  private
-
-    def _nf_pure(number)
-      number[-10..-1]
-    end
-
-    def _nf_local(number)
-      '0' << _nf_pure(number)
-    end
-
-    def _nf_international(number)
-      '+63' << _nf_pure(number)
-    end
+  include Core
+  include SingletonMethodSupport
 end

data/spec/piliponi_spec.rb

@@ -5,111 +5,255 @@ class Dummy
 end
 
 describe Piliponi do
-  let!(:dummy) { Dummy.new }
 
-  context "#plausible?" do
-    it "works" do
-      lambda do
-        dummy.plausible?("whatevs")
-      end.should_not raise_error
-    end
+  describe "as Instance Methods" do
+    let!(:piliponi) { Dummy.new }
 
-    it "returns true given 9170000001" do
-      dummy.plausible?("9170000001").should eq(true)
-    end
+    context "#plausible?" do
 
-    it "returns true given 639170000001" do
-      dummy.plausible?("639170000001").should eq(true)
-    end
+      it "works" do
+        lambda do
+          piliponi.plausible?("whatevs")
+        end.should_not raise_error
+      end
 
-    it "returns true given +639170000001" do
-      dummy.plausible?("+639170000001").should eq(true)
-    end
+      it "returns true given 9170000001" do
+        piliponi.plausible?("9170000001").should eq(true)
+      end
 
-    it "returns false given a non-numerical string" do
-      dummy.plausible?("wawa").should eq(false)
-    end
+      it "returns true given 639170000001" do
+        piliponi.plausible?("639170000001").should eq(true)
+      end
 
-  end
+      it "returns true given +639170000001" do
+        piliponi.plausible?("+639170000001").should eq(true)
+      end
 
-  context "#clean" do
-    it "removes characters" do
-      dummy.clean("+639170000001").should eq("639170000001")
-    end
+      it "returns false given a non-numerical string" do
+        piliponi.plausible?("wawa").should eq(false)
+      end
 
-    it "returns nil if no number is placed" do
-      dummy.clean.should be_nil
     end
-  end
 
-  context "#normalize" do
-    let(:number) { '(0919) 363-2598' }
+    context "#clean" do
+
+      it "removes characters" do
+        piliponi.clean("+639170000001").should eq("639170000001")
+      end
+
+      it "returns nil if no number is placed" do
+        piliponi.clean.should be_nil
+      end
 
-    it "formats to 09XXXXXXXX" do
-      dummy.normalize(number, {format: 'local'}).should eq('09193632598')
     end
 
-    it "formats to +639XXXXXXX" do
-      dummy.normalize(number, {format: 'international'}).should eq('+639193632598')
+    context "#normalize" do
+      let(:number) { '(0919) 363-2598' }
+
+      it "formats to 09XXXXXXXX" do
+        piliponi.normalize(number, {format: 'local'}).should eq('09193632598')
+      end
+
+      it "formats to +639XXXXXXX" do
+        piliponi.normalize(number, {format: 'international'}).should eq('+639193632598')
+      end
+
+      it "formats to 9XXXXXXX" do
+        piliponi.normalize(number, {format: 'pure'}).should eq('9193632598')
+      end
+
+      context "when the format passed is not recognized" do
+
+        it "raises FormatNotRecognizedException" do
+          expect{
+            piliponi.normalize(number, format: :foo)
+          }.to raise_error(FormatNotRecognizedException)
+
+          expect{
+            piliponi.normalize(number, format: :foo)
+          }.to raise_error(FormatNotRecognizedException)
+        end
+
+      end
+
+      context "when the number is not valid" do
+
+        it "raises InvalidPhoneNumberException" do
+          expect{
+            piliponi.normalize("notanumber", format: :local)
+          }.to raise_error(InvalidPhoneNumberException)
+        end
+
+      end
     end
 
-    it "formats to 9XXXXXXX" do
-      dummy.normalize(number, {format: 'pure'}).should eq('9193632598')
+    context "#telco?" do
+
+      it "returns smart for 09XX" do
+        piliponi.telco?('09181234567').should eq('smart')
+      end
+
+      it "returns globe for 09XX" do
+        piliponi.telco?("09170000000").should eq("globe")
+      end
+
+      it "returns sun for 09XX" do
+        piliponi.telco?("09220000000").should eq("sun")
+      end
+
+      it "returns talk and text/ addict or red" do
+        piliponi.telco?("09070000000").should eq("smart_others")
+      end
+
     end
 
-    context "when the format passed is not recognized" do
-      it "raises FormatNotRecognizedException" do
-        expect{
-          dummy.normalize(number, format: :foo)
-        }.to raise_error(FormatNotRecognizedException)
+    context '#prefix' do
+      describe '09171231234' do
+
+        it 'returns 0917' do
+          expect(piliponi.prefix('09171231234')).to eq '0917'
+          expect(piliponi.prefix('639171231234')).to eq '0917'
+          expect(piliponi.prefix('9171231234')).to eq '0917'
+        end
+
       end
     end
 
-    context "when the number is not valid" do
-      it "raises InvalidPhoneNumberException" do
-        expect{
-          dummy.normalize("notanumber", format: :local)
-        }.to raise_error(InvalidPhoneNumberException)
+    context '#clean_prefix' do
+      describe '0917' do
+
+        it 'retunrs 0917' do
+          expect(piliponi.prefix('0917')).to eq '0917'
+          expect(piliponi.prefix('63917')).to eq '0917'
+          expect(piliponi.prefix('917')).to eq '0917'
+        end
+
       end
     end
   end
 
-  context "#telco?" do
-    it "returns smart for 09XX" do
-      dummy.telco?('09181234567').should eq('smart')
+  describe "as Singleton Methods" do
+
+    context "#plausible?" do
+
+      it "works" do
+        lambda do
+          Piliponi.plausible?("whatevs")
+        end.should_not raise_error
+      end
+
+      it "returns true given 9170000001" do
+        Piliponi.plausible?("9170000001").should eq(true)
+      end
+
+      it "returns true given 639170000001" do
+        Piliponi.plausible?("639170000001").should eq(true)
+      end
+
+      it "returns true given +639170000001" do
+        Piliponi.plausible?("+639170000001").should eq(true)
+      end
+
+      it "returns false given a non-numerical string" do
+        Piliponi.plausible?("wawa").should eq(false)
+      end
+
     end
 
-    it "returns globe for 09XX" do
-      dummy.telco?("09170000000").should eq("globe")
+    context "#clean" do
+
+      it "removes characters" do
+        Piliponi.clean("+639170000001").should eq("639170000001")
+      end
+
+      it "returns nil if no number is placed" do
+        Piliponi.clean.should be_nil
+      end
+
     end
 
-    it "returns sun for 09XX" do
-      dummy.telco?("09220000000").should eq("sun")
+    context "#normalize" do
+      let(:number) { '(0919) 363-2598' }
+
+      it "formats to 09XXXXXXXX" do
+        Piliponi.normalize(number, {format: 'local'}).should eq('09193632598')
+      end
+
+      it "formats to +639XXXXXXX" do
+        Piliponi.normalize(number, {format: 'international'}).should eq('+639193632598')
+      end
+
+      it "formats to 9XXXXXXX" do
+        Piliponi.normalize(number, {format: 'pure'}).should eq('9193632598')
+      end
+
+      context "when the format passed is not recognized" do
+
+        it "raises FormatNotRecognizedException" do
+          expect{
+            Piliponi.normalize(number, format: :foo)
+          }.to raise_error(FormatNotRecognizedException)
+
+          expect{
+            Piliponi.normalize(number, format: :foo)
+          }.to raise_error(FormatNotRecognizedException)
+        end
+
+      end
+
+      context "when the number is not valid" do
+
+        it "raises InvalidPhoneNumberException" do
+          expect{
+            Piliponi.normalize("notanumber", format: :local)
+          }.to raise_error(InvalidPhoneNumberException)
+        end
+
+      end
     end
 
-    it "returns talk and text/ addict or red" do
-      dummy.telco?("09070000000").should eq("smart_others")
+    context "#telco?" do
+
+      it "returns smart for 09XX" do
+        Piliponi.telco?('09181234567').should eq('smart')
+      end
+
+      it "returns globe for 09XX" do
+        Piliponi.telco?("09170000000").should eq("globe")
+      end
+
+      it "returns sun for 09XX" do
+        Piliponi.telco?("09220000000").should eq("sun")
+      end
+
+      it "returns talk and text/ addict or red" do
+        Piliponi.telco?("09070000000").should eq("smart_others")
+      end
+
     end
-  end
 
-  context '#prefix' do
-    describe '09171231234' do
-      it 'returns 0917' do
-        expect(dummy.prefix('09171231234')).to eq '0917'
-        expect(dummy.prefix('639171231234')).to eq '0917'
-        expect(dummy.prefix('9171231234')).to eq '0917'
+    context '#prefix' do
+      describe '09171231234' do
+
+        it 'returns 0917' do
+          expect(Piliponi.prefix('09171231234')).to eq '0917'
+          expect(Piliponi.prefix('639171231234')).to eq '0917'
+          expect(Piliponi.prefix('9171231234')).to eq '0917'
+        end
+
       end
     end
-  end
 
-  context '#clean_prefix' do
-    describe '0917' do
-      it 'retunrs 0917' do
-        expect(dummy.prefix('0917')).to eq '0917'
-        expect(dummy.prefix('63917')).to eq '0917'
-        expect(dummy.prefix('917')).to eq '0917'
+    context '#clean_prefix' do
+      describe '0917' do
+
+        it 'retunrs 0917' do
+          expect(Piliponi.prefix('0917')).to eq '0917'
+          expect(Piliponi.prefix('63917')).to eq '0917'
+          expect(Piliponi.prefix('917')).to eq '0917'
+        end
+
       end
     end
   end
-
 end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: piliponi
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Ace Dimasuhid
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-13 00:00:00.000000000 Z
+date: 2013-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,33 +27,29 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Philippine Mobile Phone Formatter
@@ -73,7 +66,9 @@ files:
 - README.md
 - Rakefile
 - lib/piliponi.rb
+- lib/piliponi/core.rb
 - lib/piliponi/piliponi_api.rb
+- lib/piliponi/support.rb
 - lib/piliponi/version.rb
 - piliponi.gemspec
 - spec/piliponi_spec.rb
@@ -81,27 +76,26 @@ files:
 homepage: ''
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Mobile Phone Number Formatter for the Philippines
 test_files:
 - spec/piliponi_spec.rb