phony_rails 0.14.9 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a7e279baa79785d7c0db788f230299a530f95900
-  data.tar.gz: 2b99f584e90f49369cd5114aac04e6b5c09f198b
+SHA256:
+  metadata.gz: 9f5029f29270fa190a8d6bb493268065d2abed1652c3bb63622340309018cced
+  data.tar.gz: f6f307074a3348693e6ef4bce515b81b3890ff396a35dd4ed343bcefa3476a8a
 SHA512:
-  metadata.gz: 6ae91b311ac825d4a8fe61b44d7b74ccfa515ab2702c017c5bcf32774b00fcd622ac29c1fea2da0b962643e848b69dcbef5a8871f5b3c92a1db87ff2cb8dc93b
-  data.tar.gz: d3cdc2fdc49cabb7562b4916e6b56bd8eaf1b85c2d71b93813cda6dfb025a4538bc564115f30a2bde638717f682198915e38aae38258cfab5a297363e5d5551f
+  metadata.gz: 9153aa4dfd473744cd30b227d1429b0766fd27a0b58c8003aba6677e851390adc0f1b8c237d8b77e0f386c5e3c5f05958aff5a1f1f842a495b68caba5511ffe5
+  data.tar.gz: 8cc31c41aceec40c3d0ea203a1e8cec344bc9e0e5fbc407bd78456e9a4fe16b020c5b8b4895eedc3a9e19247dd8f55e41e8349283512871a0282289ea825216a

data/.gitignore

@@ -6,3 +6,4 @@
 coverage/*
 /.bundle
 /vendor
+Gemfile.lock

data/.rubocop.yml

@@ -1,5 +1,6 @@
 inherit_from: .rubocop_todo.yml
+require: rubocop-performance
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.4
 Metrics/BlockLength:
   ExcludedMethods: ['describe', 'context', 'define', 'shared_examples_for']

data/.rubocop_todo.yml

@@ -13,6 +13,13 @@ Lint/AssignmentInCondition:
     - 'lib/phony_rails.rb'
 
 # Offense count: 2
+# Cop supports --auto-correct.
+Lint/SendWithMixinArgument:
+  Exclude:
+    - 'lib/phony_rails.rb'
+
+# Offense count: 2
+# Configuration parameters: AllowKeywordBlockArguments.
 Lint/UnderscorePrefixedVariableName:
   Exclude:
     - 'lib/phony_rails.rb'
@@ -46,6 +53,12 @@ Performance/StartWith:
   Exclude:
     - 'lib/phony_rails.rb'
 
+# Offense count: 1
+# Cop supports --auto-correct.
+Performance/RegexpMatch:
+  Exclude:
+    - 'lib/phony_rails.rb'
+
 # Offense count: 1
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: nested, compact

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
 rvm:
-- 2.3.7
 - 2.4.4
-- 2.5.1
+- 2.5.5
+- 2.6.2
+- 3.0.0
 script:
 - bundle exec rspec spec
 - bundle exec rubocop

data/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Change Log
 
+## [v0.14.13](https://github.com/joost/phony_rails/tree/v0.14.13) (2019-07-03)
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.14.12...v0.14.13)
+
+**Closed issues:**
+
+- 0.4.11 was the latest release. However the new normalize\_when\_valid has been sitting here for a while... Release? [\#194](https://github.com/joost/phony_rails/issues/194)
+
+**Merged pull requests:**
+
+- Fixing \#195 - Original value should be cached in correct instance var [\#196](https://github.com/joost/phony_rails/pull/196) ([dlikhten](https://github.com/dlikhten))
+
+## [v0.14.12](https://github.com/joost/phony_rails/tree/v0.14.12) (2019-06-21)
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.14.11...v0.14.12)
+
+**Closed issues:**
+
+- Some German numbers not passing plausible\_numbers? without country\_code [\#193](https://github.com/joost/phony_rails/issues/193)
+
+**Merged pull requests:**
+
+- Upgrade Ruby versions and Relax dependancies [\#192](https://github.com/joost/phony_rails/pull/192) ([berkos](https://github.com/berkos))
+- Add possibility to return original phone number when is not valid [\#190](https://github.com/joost/phony_rails/pull/190) ([synion](https://github.com/synion))
+- Add UK country\_code. [\#189](https://github.com/joost/phony_rails/pull/189) ([ayghor](https://github.com/ayghor))
+
+## [v0.14.11](https://github.com/joost/phony_rails/tree/v0.14.11) (2018-10-11)
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.14.10...v0.14.11)
+
+**Closed issues:**
+
+- Problem with normalizing Estonian number [\#187](https://github.com/joost/phony_rails/issues/187)
+
+**Merged pull requests:**
+
+- Add Korean translation\(including spec\) [\#186](https://github.com/joost/phony_rails/pull/186) ([freelyageha](https://github.com/freelyageha))
+
+## [v0.14.10](https://github.com/joost/phony_rails/tree/v0.14.10) (2018-10-11)
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.14.9...v0.14.10)
+
+**Closed issues:**
+
+- PhonyRails.default\_country\_code too intrusive in plausible\_number? method [\#179](https://github.com/joost/phony_rails/issues/179)
+- default\_country\_code overrides 00-prefix country code [\#175](https://github.com/joost/phony_rails/issues/175)
+- Valid 260 area code number is reported as invalid [\#168](https://github.com/joost/phony_rails/issues/168)
+- Croatian number not validating as plausible. [\#165](https://github.com/joost/phony_rails/issues/165)
+- phony\_formatted not returning original String for non-digit only strings [\#163](https://github.com/joost/phony_rails/issues/163)
+- should all normalized numbers be valid? [\#162](https://github.com/joost/phony_rails/issues/162)
+- Extensions not working out of the box for validator [\#160](https://github.com/joost/phony_rails/issues/160)
+
+**Merged pull requests:**
+
+- Remove errant `puts` [\#188](https://github.com/joost/phony_rails/pull/188) ([stevenharman](https://github.com/stevenharman))
+- Close issues [\#185](https://github.com/joost/phony_rails/pull/185) ([joost](https://github.com/joost))
+- Better PhonyRails.plausible\_number? method. Closes \#179. [\#184](https://github.com/joost/phony_rails/pull/184) ([joost](https://github.com/joost))
+- Allow numbers starting with 00 country codes. Closes \#175. [\#183](https://github.com/joost/phony_rails/pull/183) ([joost](https://github.com/joost))
+
+## [v0.14.9](https://github.com/joost/phony_rails/tree/v0.14.9) (2018-09-05)
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.14.7...v0.14.9)
+
+**Closed issues:**
+
+- Cut new release 0.14.7 to include new extension removal logic [\#177](https://github.com/joost/phony_rails/issues/177)
+- default\_country\_code based on relation [\#174](https://github.com/joost/phony_rails/issues/174)
+
+**Merged pull requests:**
+
+- Allow brackets. Closes \#170. [\#182](https://github.com/joost/phony_rails/pull/182) ([joost](https://github.com/joost))
+- add lambda support for default country code [\#181](https://github.com/joost/phony_rails/pull/181) ([kimyu92](https://github.com/kimyu92))
+- Add Spanish translation for validation error [\#178](https://github.com/joost/phony_rails/pull/178) ([r-sierra](https://github.com/r-sierra))
+
 ## [v0.14.7](https://github.com/joost/phony_rails/tree/v0.14.7) (2018-05-25)
 [Full Changelog](https://github.com/joost/phony_rails/compare/v0.14.6...v0.14.7)
 

data/Gemfile

@@ -11,6 +11,4 @@ gem 'guard-rspec' # ,    '~> 4.2.0'
 gem 'rake'
 gem 'rspec' # ,          '~> 2.14.0'
 gem 'rubocop'
-
-# For testing
-gem 'sqlite3'
+gem 'rubocop-performance'

data/README.md

@@ -7,10 +7,10 @@ Find version information in the [CHANGELOG](CHANGELOG.md).
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's Gemfile (requires Ruby > 2.3):
 
 ```ruby
-gem 'phony_rails' # Include phony_rails after mongoid (if you use mongoid, see issue #66 on github).
+gem 'phony_rails'
 ```
 
 And then execute:
@@ -66,18 +66,10 @@ class SomeModel
 end
 ```
 
-#### Mongoid
+#### Mongoid (DEPRECATED)
 
-For **Mongoid**, in keeping with Mongoid plug-in conventions you must include the `Mongoid::Phony` module:
+WARNING: From v0.15.0 Mongoid support has been removed!
 
-```ruby
-class SomeModel
-  include Mongoid::Document
-  include Mongoid::Phony
-
-  # methods are same as ActiveRecord usage
-end
-```
 #### General info
 
 The `:default_country_code` options is used to specify a country_code when normalizing.
@@ -114,6 +106,7 @@ In your model use the Phony.plausible method to validate an attribute:
 ```ruby
 validates :phone_number, phony_plausible: true
 ```
+
 or the helper method:
 
 ```ruby
@@ -121,8 +114,9 @@ validates_plausible_phone :phone_number
 ```
 
 this method use other validators under the hood to provide:
-* presence validation using `ActiveModel::Validations::PresenceValidator`
-* format validation using `ActiveModel::Validations::FormatValidator`
+
+- presence validation using `ActiveModel::Validations::PresenceValidator`
+- format validation using `ActiveModel::Validations::FormatValidator`
 
 so we can use:
 
@@ -133,7 +127,7 @@ validates_plausible_phone :phone_number, without: /\A\+\d+/
 validates_plausible_phone :phone_number, presence: true, with: /\A\+\d+/
 ```
 
-the i18n key is `:improbable_phone`. Languages supported by default: de, en, es, fr, it, ja, kh, nl, tr, ua and ru.
+the i18n key is `:improbable_phone`. Languages supported by default: de, en, es, fr, it, ja, kh, ko, nl, tr, ua and ru.
 
 You can also validate if a number has the correct country number:
 
@@ -156,13 +150,29 @@ validates_plausible_phone :phone_number_normalized, presence: true, if: :phone_n
 
 Validation supports phone numbers with extension, such as `+18181231234 x1234` or `'+1 (818)151-5483 #4312'` out-of-the-box.
 
+Return original value after validation:
+
+The flag normalize_when_valid (disabled by default), allows to return the original phone_number when is the object is not valid. When phone validation fails, normalization is not triggered at all. It could prevent a situation where user fills in the phone number and after validation, he gets back different, already normalized phone number value, even if phone number was wrong.
+
+Example usage:
+
+```ruby
+validates_plausible_phone :phone_number
+phony_normalize :phone_number, country_code: :country_code, normalize_when_valid: true
+```
+
+Filling in the number will result with following:
+
+When the number is incorrect (e.g. phone_number: `+44 888 888 888` for country_code 'PL'), the original validation behavior is preserved, but if the number is still invalid, the original value is returned.
+When number is valid, it will save the normalized number (e.g. `+48 888 888 888` will be saved as `+48888888888`).
+
 #### Allowing records country codes to not match phone number country codes
 
-You may have a record specifying one country (via a `country_code` attribute) but using a phone number from another country.  For example, your record may be from Japan but have a phone number from the Philippines. By default, `phony_rails` will consider your record's `country_code` as part of the validation.  If that country doesn't match the country code in the phone number, validation will fail.
+You may have a record specifying one country (via a `country_code` attribute) but using a phone number from another country. For example, your record may be from Japan but have a phone number from the Philippines. By default, `phony_rails` will consider your record's `country_code` as part of the validation. If that country doesn't match the country code in the phone number, validation will fail.
 
 Additionally, `phony_normalize` will always add the records country code as the country number (eg. the user enters '+81xxx' for Japan and the records `country_code` is 'DE' then `phony_normalize` will change the number to '+4981'). You can turn this off by adding `enforce_record_country: false` to the validation options. The country_code will then only be added if no country code is specified.
 
-If you want to allow records from one country to have phone numbers from a different one, there are a couple of options you can use: `ignore_record_country_number` and `ignore_record_country_code`.  Use them like so:
+If you want to allow records from one country to have phone numbers from a different one, there are a couple of options you can use: `ignore_record_country_number` and `ignore_record_country_code`. Use them like so:
 
 ```ruby
 validates :phone_number, phony_plausible: { ignore_record_country_code: true, ignore_record_country_number: true }
@@ -216,7 +226,6 @@ Extensions are supported (identified by "ext", "ex", "x", "xt", "#", or ":") and
 "+31 (0)30 1234 123 #999".phony_normalized # => '31301234123 x999'
 ```
 
-
 ### Find by normalized number
 
 Say you want to find a record by a phone number. Best is to normalize user input and compare to an attribute stored in the db.

data/lib/data/country_codes.yaml

@@ -463,6 +463,8 @@ UA:
   country_code: '380'
 UG:
   country_code: '256'
+UK:
+  country_code: '44'
 UM:
   country_code: ''
 US:

data/lib/phony_rails.rb

@@ -46,18 +46,18 @@ module PhonyRails
   #   http://www.redguava.com.au/2011/06/rails-convert-phone-numbers-to-international-format-for-sms/
   def self.normalize_number(number, options = {}, current_instance = nil)
     return if number.nil?
+
     original_number = number
     number = number.dup # Just to be sure, we don't want to change the original.
     number, ext = extract_extension(number)
-    number.gsub!(/[^\(\)\d\+]/, '') # Strips weird stuff from the number
+    number.gsub!(/[^()\d+]/, '') # Strips weird stuff from the number
     return if number.blank?
+
     if _country_number = options[:country_number] || country_number_for(options[:country_code])
       options[:add_plus] = true if options[:add_plus].nil?
       # (Force) add country_number if missing
       # NOTE: do we need to force adding country code? Otherwise we can share logic with next block
-      if !Phony.plausible?(number) || _country_number != country_code_from_number(number)
-        number = "#{_country_number}#{number}"
-      end
+      number = "#{_country_number}#{number}" if !Phony.plausible?(number) || _country_number != country_code_from_number(number)
     elsif _default_country_number = extract_default_country_number(options, current_instance)
       options[:add_plus] = true if options[:add_plus].nil?
       number = normalize_number_default_country(number, _default_country_number)
@@ -67,8 +67,7 @@ module PhonyRails
     normalized_number = options[:add_plus] ? "+#{normalized_number}" : normalized_number
 
     options[:extension] = true if options[:extension].nil?
-    normalized_number = options[:extension] ? format_extension(normalized_number, ext) : normalized_number
-    normalized_number
+    options[:extension] ? format_extension(normalized_number, ext) : normalized_number
   rescue StandardError
     original_number # If all goes wrong .. we still return the original input.
   end
@@ -76,7 +75,7 @@ module PhonyRails
   def self.normalize_number_default_country(number, default_country_number)
     # We try to add the default country number and see if it is a
     # correct phone number. See https://github.com/joost/phony_rails/issues/87#issuecomment-89324426
-    unless number =~ /\A\(?\+/ # if we don't have a +
+    unless number =~ /\A\(?(\+|00)/ # if we don't have a + or 00
       return "#{default_country_number}#{number}" if Phony.plausible?("#{default_country_number}#{number}") || !Phony.plausible?(number) || country_code_from_number(number).nil?
       # If the number starts with ONE zero (two might indicate a country code)
       # and this is a plausible number for the default_country
@@ -97,23 +96,31 @@ module PhonyRails
     options[:default_country_number] || country_number_for(country_code) || default_country_number
   end
 
+  # Returns the country dail code (eg. '31') for a number (eg. +31612341234).
+  # Should probably be named 'country_number_from_number'.
   def self.country_code_from_number(number)
     return nil unless Phony.plausible?(number)
+
     Phony.split(Phony.normalize(number)).first
   end
 
+  # Returns the country (eg. 'NL') for a number (eg. +31612341234).
   def self.country_from_number(number)
     return nil unless Phony.plausible?(number)
+
     country_codes_hash.select { |_country, hash| hash['country_code'] == country_code_from_number(number) }.keys[0]
   end
 
   # Wrapper for Phony.plausible?.  Takes the same options as #normalize_number.
   # NB: This method calls #normalize_number and passes _options_ directly to that method.
+  # It uses the 'cc' option for Phony. This was a required param before?
   def self.plausible_number?(number, options = {})
     return false if number.blank?
+
     number = extract_extension(number).first
     number = normalize_number(number, options)
     country_number = options[:country_number] || country_number_for(options[:country_code]) ||
+                     country_code_from_number(number) ||
                      options[:default_country_number] || country_number_for(options[:default_country_code]) ||
                      default_country_number
     Phony.plausible? number, cc: country_number
@@ -121,10 +128,11 @@ module PhonyRails
     false
   end
 
-  COMMON_EXTENSIONS = /[ ]*(ext|ex|x|xt|#|:)+[^0-9]*\(?([-0-9]{1,})\)?#?$/i
+  COMMON_EXTENSIONS = / *(ext|ex|x|xt|#|:)+[^0-9]*\(?([-0-9]{1,})\)?#?$/i.freeze
 
   def self.extract_extension(number_and_ext)
     return [nil, nil] if number_and_ext.nil?
+
     subbed = number_and_ext.sub(COMMON_EXTENSIONS, '')
     [subbed, Regexp.last_match(2)]
   end
@@ -151,8 +159,10 @@ module PhonyRails
         attributes.each do |attribute|
           attribute_name = options[:as] || attribute
           raise("No attribute #{attribute_name} found on #{self.class.name} (PhonyRails)") unless self.class.attribute_method?(attribute_name)
+
+          cache_original_attribute(current_instance, attribute) if options[:normalize_when_valid]
           new_value = PhonyRails.normalize_number(send(attribute), options, current_instance)
-          send("#{attribute_name}=", new_value) if new_value || attribute_name != attribute
+          current_instance.public_send("#{attribute_name}=", new_value) if new_value || attribute_name != attribute
         end
       end
 
@@ -164,7 +174,26 @@ module PhonyRails
       end
     end
 
+    def cache_original_attribute(current_instance, attribute)
+      attribute_name = "#{attribute}_original"
+      current_instance.define_singleton_method("#{attribute_name}=") { |value| instance_variable_set("@#{attribute_name}", value) }
+      current_instance.define_singleton_method(attribute_name) { instance_variable_get("@#{attribute_name}") }
+      current_instance.public_send("#{attribute}_original=", current_instance.public_send(attribute.to_s))
+    end
+
     module ClassMethods
+      PHONY_RAILS_COLLECTION_VALID_KEYS = %i[
+        add_plus
+        as
+        country_code
+        country_number
+        default_country_code
+        default_country_number
+        enforce_record_country
+        if
+        normalize_when_valid
+        unless
+      ].freeze
       # Use this method on the class level like:
       #   phony_normalize :phone_number, :fax_number, :default_country_code => 'NL'
       #
@@ -172,10 +201,8 @@ module PhonyRails
       # you've geocoded before calling this method!
       def phony_normalize(*attributes)
         options = attributes.last.is_a?(Hash) ? attributes.pop : {}
-        options.assert_valid_keys :country_number, :default_country_number, :country_code, :default_country_code, :add_plus, :as, :enforce_record_country, :if, :unless
-        if options[:as].present?
-          raise ArgumentError, ':as option can not be used on phony_normalize with multiple attribute names! (PhonyRails)' if attributes.size > 1
-        end
+        options.assert_valid_keys(*PHONY_RAILS_COLLECTION_VALID_KEYS)
+        raise ArgumentError, ':as option can not be used on phony_normalize with multiple attribute names! (PhonyRails)' if options[:as].present? && (attributes.size > 1)
 
         options[:enforce_record_country] = true if options[:enforce_record_country].nil?
 
@@ -195,10 +222,12 @@ module PhonyRails
         main_options.assert_valid_keys :country_code, :default_country_code
         attributes.each do |attribute|
           raise(StandardError, "Instance method normalized_#{attribute} already exists on #{name} (PhonyRails)") if method_defined?(:"normalized_#{attribute}")
+
           define_method :"normalized_#{attribute}" do |*args|
             options = main_options.merge(args.first || {})
             assign_values_for_phony_symbol_options(options)
             raise(ArgumentError, "No attribute/method #{attribute} found on #{self.class.name} (PhonyRails)") unless respond_to?(attribute)
+
             options[:country_code] ||= country_code if respond_to?(:country_code)
             PhonyRails.normalize_number(send(attribute), options)
           end
@@ -246,12 +275,12 @@ end
 
 ActiveModel::Model.send :include, PhonyRails::Extension if defined?(ActiveModel::Model)
 
-if defined?(Mongoid)
-  module Mongoid::Phony
-    extend ActiveSupport::Concern
-    include PhonyRails::Extension
-  end
-end
+# if defined?(Mongoid)
+#   module Mongoid::Phony
+#     extend ActiveSupport::Concern
+#     include PhonyRails::Extension
+#   end
+# end
 
 Dir["#{File.dirname(__FILE__)}/phony_rails/locales/*.yml"].each do |file|
   I18n.load_path << file

data/lib/phony_rails/locales/ko.yml

@@ -0,0 +1,4 @@
+ko:
+  errors:
+    messages:
+      improbable_phone: "는 올바른 전화번호가 아닙니다"

data/lib/phony_rails/string_extensions.rb

@@ -7,6 +7,7 @@ class String
   #   "(0)30 1234 123".phony_normalized(country_code: 'NL') # => '301234123'
   def phony_normalized(options = {})
     raise ArgumentError, "Expected options to be a Hash, got #{options.inspect}" unless options.is_a?(Hash)
+
     options = options.dup
     PhonyRails.normalize_number(self, options)
   end
@@ -24,21 +25,25 @@ class String
   #   "somestring".phone_formatted(raise: true)
   def phony_formatted(options = {})
     raise ArgumentError, "Expected options to be a Hash, got #{options.inspect}" unless options.is_a?(Hash)
+
     options = options.dup
     normalize_country_code = options.delete(:normalize)
     s, ext = PhonyRails.extract_extension(self)
     s = (normalize_country_code ? PhonyRails.normalize_number(s, default_country_code: normalize_country_code.to_s, add_plus: false) : s.gsub(/\D/, ''))
     return if s.blank?
     return if options[:strict] && !Phony.plausible?(s)
+
     PhonyRails.format_extension(Phony.format(s, options.reverse_merge(format: :national)), ext)
   rescue StandardError
     raise if options[:raise]
+
     s
   end
 
   # The bang method
   def phony_formatted!(options = {})
     raise ArgumentError, 'The :strict options is only supported in the phony_formatted (non bang) method.' if options[:strict]
+
     replace(phony_formatted(options))
   end
 end