Phonelib

Phonelib is a Ruby gem used for validating phone numbers. It uses Google libphonenumber as its data source for validations.

Key capabilities include:

• Basic phone number validation.
• Formatting numbers into the e164 international format.
• Formatting numbers into a national format with a prefix.

Phonelib provides a validator for ActiveRecord models.

Basic Validation

validates :attribute, phone: true

Note: Passing a blank value will fail validation.

Advanced Validation Options

validates :attribute, phone: {
  possible: true,           # Check if number is a possible phone number (less strict)
  allow_blank: true,       # Validation passes if value is blank
  types: [:voip, :mobile],  # Validate against specific patterns
  countries: [:us, :ca],   # Validate against specific countries
  country_specifier: -> phone { phone.country.try(:upcase) }, # Dynamic country detection
  extensions: false          # Check for phone extension to be blank
}

validates :attribute, phone: { possible: true, allow_blank: true, types: [:voip, :mobile], country_specifier: -> phone { phone.country.try(:upcase) } }

Add phonelib to your Gemfile to use it in a Rails application (tested on Rails >= 3.1).

gem 'phonelib'

Then run bundle install to complete the installation.

The PhoneFormatter module supports dynamic method calls using prefixes. You can call methods that start with international_, full_international_, e164_, or full_e164_ followed by a suffix to access specific variations.

Note: This is implemented via method_missing and effectively maps to the core formatting methods.

# This is handled via method_missing
# Example: calling a method with a prefix
# (Actual implementation details depend on how the suffix is parsed)

A standard Rails application follows a specific directory layout:

• app/: Contains application-specific code.
  • app/assets/: Images, stylesheets, and JavaScript.
  • app/controllers/: Controllers (e.g., weblogs_controller.rb).
  • app/models/: Models (e.g., post.rb).
  • app/views/: Template files (e.g., weblogs/index.html.erb).
  • app/views/layouts/: Layout templates (e.g., default.html.erb).
  • app/helpers/: View helpers.
• config/: Configuration for environments, routing, and databases.
• db/: Database schema (schema.rb) and migrations (db/migrate).
• lib/: Custom application libraries (included in the load path).
• log/: Application log files.
• public/: Web server accessible directory (the DOCUMENT_ROOT).
• test/: Unit, functional, and integration tests.
• vendor/: External libraries and plugins.

You can debug your application by monitoring log files or by injecting custom log messages into your code.

Monitoring Logs

Use the tail -f command to watch server.log and development.log in real-time. Rails automatically outputs debugging and runtime information to these files.

Using the Ruby Logger

You can log custom messages directly from your controllers using the Ruby logger class.

class WeblogController < ActionController::Base
    def destroy
      @weblog = Weblog.find(params[:id])
      @weblog.destroy
      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
    end
end

By default, Phonelib loads data lazily on first use. In production environments, you can call eager_load! to load all phone and extended data into memory during application startup to avoid latency on the first request.

Phonelib.eager_load!

To create and run a new Ruby on Rails application, follow these steps at your command prompt:

1. Create the application: rails new myapp (replace myapp with your desired name).
2. Navigate to the directory and start the server: cd myapp; rails server.
3. Access the application at http://localhost:3000/.

If your model stores a country code in a separate attribute, you can use the country_specifier option to tell the PhoneValidator which method to call on the record to retrieve the country context for parsing.

class Phone < ActiveRecord::Base
  # If the record has a method `user_country` that returns a country code
  validates :number, phone: { country_specifier: :user_country }

  # Or using a Proc for more complex logic
  validates :number, phone: { country_specifier: ->(record) { record.determine_country_logic } }
end