phonelib 0.0.1

data/lib/phonelib/core.rb

@@ -0,0 +1,86 @@
+module Phonelib
+  # main module that includes all basic data and methods
+  module Core
+    # variable will include hash with data for validation
+    @@phone_data = nil
+
+    # gem constants definition
+    # constants for phone types
+    GENERAL = :generalDesc
+    PREMIUM_RATE = :premiumRate
+    TOLL_FREE = :tollFree
+    SHARED_COST = :sharedCost
+    VOIP = :voip
+    PERSONAL_NUMBER = :personalNumber
+    PAGER = :pager
+    UAN = :uan
+    VOICEMAIL = :voicemail
+    FIXED_LINE = :fixedLine
+    MOBILE = :mobile
+    EMERGENCY = :emergency
+    SHORT_CODE = :shortCode
+    FIXED_OR_MOBILE = :fixedOrMobile
+
+    # hash of all possible types with description
+    TYPES = {
+      generalDesc: 'General Pattern',
+      premiumRate: 'Premium Rate',
+      tollFree: 'Toll Free',
+      sharedCost: 'Shared Cost',
+      voip: 'VoIP',
+      personalNumber: 'Personal Number',
+      pager: 'Pager',
+      uan: 'UAN',
+      voicemail: 'VoiceMail',
+      fixedLine: 'Fixed Line',
+      mobile: 'Mobile',
+      emergency: 'Emergency',
+      shortCode: 'Short Code',
+      fixedOrMobile: 'Fixed Line or Mobile'
+    }
+
+    # array of types not included for validation check in cycle
+    NOT_FOR_CHECK = [
+      :generalDesc, :emergency, :shortCode, :fixedLine, :mobile, :fixedOrMobile
+    ]
+
+    # method for parsing phone number
+    # on first run fills @@phone_data with data present in yaml file
+    def parse(phone)
+      require 'yaml'
+      data_file = File.dirname(__FILE__) + '/../../data/phone_data.yml'
+      @@phone_data ||= YAML.load_file(data_file)
+      Phonelib::Phone.new(phone, @@phone_data)
+    end
+
+    # method checks if passed phone number is valid
+    def valid?(phone_number)
+      parse(phone_number).valid?
+    end
+
+    # method checks if passed phone number is invalid
+    def invalid?(phone_number)
+      parse(phone_number).invalid?
+    end
+
+    # method checks if passed phone number is possible
+    def possible?(phone_number)
+      parse(phone_number).possible?
+    end
+
+    # method checks if passed phone number is impossible
+    def impossible?(phone_number)
+      parse(phone_number).impossible?
+    end
+
+    # method checks if passed phone number is valid for provided country
+    def valid_for_country?(phone_number, country)
+      parse(phone_number).valid_for_country?(country)
+    end
+
+    # method checks if passed phone number is invalid for provided country
+    def invalid_for_country?(phone_number, country)
+      parse(phone_number).invalid_for_country?(country)
+    end
+  end
+end

data/lib/phonelib/phone.rb

@@ -0,0 +1,166 @@
+module Phonelib
+  # class for parsed phone number, includes basic validation methods
+  class Phone
+    # defining reader methods for class variables
+    attr_reader :original, :sanitized, :national_number
+
+    # class initialization method
+    #
+    # ==== Attributes
+    #
+    # * +phone+ - Phone number for parsing
+    # * +country_data+ - Hash of data for parsing
+    #
+    def initialize(phone, country_data)
+      @original = phone
+      @sanitized = sanitize_phone(@original)
+      @analyzed_data = {}
+      analyze_phone(country_data) unless @sanitized.empty?
+    end
+
+    # Returns all phone types that matched valid patterns
+    def types
+      @analyzed_data.flat_map {|iso2, data| data[:valid]}.uniq
+    end
+
+    # Returns first phone type that matched
+    def type
+      types.first
+    end
+
+    # Returns all countries that matched valid patterns
+    def countries
+      @analyzed_data.map {|iso2, data| iso2}
+    end
+
+    # Returns first country that matched valid patterns
+    def country
+      countries.first
+    end
+
+    # Returns whether a current parsed phone number is valid
+    def valid?
+      @analyzed_data.select {|iso2, data| data[:valid].any? }.any?
+    end
+
+    # Returns whether a current parsed phone number is invalid
+    def invalid?
+      !valid?
+    end
+
+    # Returns whether a current parsed phone number is possible
+    def possible?
+      @analyzed_data.select {|iso2, data| data[:possible].any? }.any?
+    end
+
+    # Returns whether a current parsed phone number is impossible
+    def impossible?
+      !possible?
+    end
+
+    # Returns whether a current parsed phone number is valid for specified
+    # country
+    #
+    # ==== Attributes
+    #
+    # * +country+ - ISO code of country (2 letters) like 'US' for United States
+    #
+    def valid_for_country?(country)
+      @analyzed_data.select {|iso2, data| country == iso2 &&
+          data[:valid].any? }.any?
+    end
+
+    # Returns whether a current parsed phone number is invalid for specified
+    # country
+    #
+    # ==== Attributes
+    #
+    # * +country+ - ISO code of country (2 letters) like 'US' for United States
+    #
+    def invalid_for_country?(country)
+      @analyzed_data.select {|iso2, data| country == iso2 &&
+          data[:valid].any? }.empty?
+    end
+
+    private
+    # Analyze current phone with provided data hash
+    def analyze_phone(country_data)
+      possible_countries = country_data.select do |data|
+        @sanitized.start_with?(data[:countryCode])
+      end
+
+      possible_countries.each do |country_data|
+        next if country_data[:types].empty?
+
+        prefix_length = country_data[:countryCode].length
+        @national_number = @sanitized[prefix_length..@sanitized.length]
+        @analyzed_data[country_data[:id]] =
+            get_all_number_types(@national_number, country_data[:types])
+      end
+    end
+
+    # Returns all valid and possible phone number types for currently parsed
+    # phone for provided data hash.
+    # Forked from original Google libphonenumber library.
+    def get_all_number_types(number, data)
+      response = {valid: [], possible: []}
+
+      return response if data[Core::GENERAL].empty?
+      return response unless number_valid_and_possible?(number,
+                                                        data[Core::GENERAL])
+
+      (Core::TYPES.keys - Core::NOT_FOR_CHECK).each do |type|
+        next if data[type].nil? || data[type].empty?
+
+        response[:valid] << type if number_valid_and_possible?(number,
+                                                               data[type])
+        response[:possible] << type if number_possible?(number, data[type])
+      end
+
+      if number_valid_and_possible?(number, data[Core::FIXED_LINE])
+        if data[Core::FIXED_LINE] == data[Core::MOBILE]
+          response[:valid] << Core::FIXED_OR_MOBILE
+        else
+          response[:valid] << Core::FIXED_LINE
+        end
+      elsif number_valid_and_possible?(number, data[Core::MOBILE])
+        response[:valid] << Core::MOBILE
+      end
+
+      if number_possible?(number, data[Core::FIXED_LINE])
+        if data[Core::FIXED_LINE] == data[Core::MOBILE]
+          response[:possible] << Core::FIXED_OR_MOBILE
+        else
+          response[:possible] << Core::FIXED_LINE
+        end
+      elsif number_possible?(number, data[Core::MOBILE])
+        response[:possible] << Core::MOBILE
+      end
+
+      response
+    end
+
+    # Checks if passed number matches both valid and possible patterns
+    def number_valid_and_possible?(number, regexes)
+      national_pattern = regexes[:nationalNumberPattern]
+      possible_pattern = regexes[:possibleNumberPattern] || national_pattern
+      national_match = number.match(/^(?:#{national_pattern})$/)
+      possible_match = number.match(/^(?:#{possible_pattern})$/)
+
+      national_match && possible_match &&
+          national_match.to_s.length == number.length &&
+          possible_match.to_s.length == number.length
+    end
+
+    # Checks if passed number matches possible pattern
+    def number_possible?(number, regexes)
+      possible_match = number.match(/^(?:#{regexes[:possibleNumberPattern]})$/)
+      possible_match && possible_match.to_s.length == number.length
+    end
+
+    # Sanitizes passed phone number. Returns only digits from passed string.
+    def sanitize_phone(phone)
+      phone && phone.gsub(/[^0-9]+/, '') || ''
+    end
+  end
+end

data/lib/phonelib/validators.rb

@@ -0,0 +1,47 @@
+module Phonelib
+  # Module includes all ActiveModel validators classes
+  module Validators
+    # Validator class for phone validations
+    #
+    # ==== Examples
+    #
+    # Validates that attribute is a valid phone number.
+    # If empty value passed for attribute it fails.
+    #
+    #   class Phone < ActiveRecord::Base
+    #     attr_accessible :number
+    #     validates :number, phone: true
+    #   end
+    #
+    # Validates that attribute is a possible phone number.
+    # If empty value passed for attribute it fails.
+    #
+    #   class Phone < ActiveRecord::Base
+    #     attr_accessible :number
+    #     validates :number, phone: { possible: true }
+    #   end
+    #
+    # Validates that attribute is a valid phone number.
+    # Empty value is allowed to be passed.
+    #
+    #   class Phone < ActiveRecord::Base
+    #     attr_accessible :number
+    #     validates :number, phone: { allow_blank: true }
+    #   end
+    class PhoneValidator < ActiveModel::EachValidator
+      # Include all core methods
+      include Phonelib::Core
+
+      # Validation method
+      def validate_each(record, attribute, value)
+        phone = parse(value)
+        valid = options[:possible] ? phone.possible? : phone.valid?
+        valid = true if options[:allow_blank] && phone.original.blank?
+
+        # TODO: change to be from translations
+        error = "is not valid"
+        record.errors.add(attribute, (options[:message] || error)) unless valid
+      end
+    end
+  end
+end

data/lib/phonelib/version.rb

@@ -0,0 +1,3 @@
+module Phonelib
+  VERSION = "0.0.1"
+end

data/lib/phonelib.rb

@@ -0,0 +1,14 @@
+module Phonelib
+  # load gem classes
+  autoload :Core, 'phonelib/core'
+  autoload :Phone, 'phonelib/phone'
+  autoload :Validators, 'phonelib/validators'
+
+  extend Module.new {
+    include Core
+  }
+
+  if defined?(Rails)
+    ActiveModel::Validations.__send__(:include, Phonelib::Validators)
+  end
+end

data/lib/tasks/phonelib_tasks.rake

@@ -0,0 +1,69 @@
+namespace :phonelib do
+
+  desc "Import and reparse original data file from Google libphonenumber"
+  task :import_data do
+    require 'net/http'
+    require 'yaml'
+    require 'nokogiri'
+
+    # get metadata from google
+    url = 'http://libphonenumber.googlecode.com/svn/trunk/resources/PhoneNumberMetaData.xml'
+    xml_data = Net::HTTP.get_response(URI.parse(url)).body
+
+    # save in file for backup
+    File.open("data/PhoneNumberMetaData.xml", "w+") do |f|
+      f.write(xml_data)
+    end
+
+    # start parsing 
+    doc = Nokogiri::XML(xml_data)
+
+    main = doc.elements.first.elements.first
+    countries = []
+    main.elements.each do |el|
+      # each country
+      country = {}
+      el.attributes.each do |k, v| 
+        country[k.to_sym] = v.to_s
+      end
+
+      country[:types] = {}
+
+      el.children.each do | phone_type | 
+        if phone_type.name != 'comment' && phone_type.name != 'text'
+          phone_type_sym = phone_type.name.to_sym  
+           
+          if phone_type.name != 'availableFormats'
+            country[:types][phone_type_sym] = {}
+            phone_type.elements.each do |pattern|
+              country[:types][phone_type_sym][pattern.name.to_sym] = pattern.children.first.to_s.tr(" \n", "")
+            end
+          else
+            country[:formats] = []
+            phone_type.children.each do |format|
+              
+              if format.name != 'text' && format.name != 'comment'
+                current_format = { regex: format.first[1].to_s.tr(" \n", "") }
+
+                format.children.each do |f|
+                  if f.name != 'text'
+                    current_format[f.name.to_sym] = f.children.first.to_s.tr(" \n", "")
+                  end
+                end
+
+                country[:formats].push(current_format) 
+              end
+            end    
+          end  
+          
+        end 
+      end
+      
+      countries.push(country)   
+    end
+    target = 'data/phone_data.yml'
+    File.open(target, "w+") do |f|
+      f.write(countries.to_yaml)
+    end
+  end
+end  

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/test/dummy/app/assets/javascripts/phones.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */