validates_identity 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de2775d07796e202d6cc7ecdb166bed0233950b9b3439ae5da5e3fc7b89e3957
-  data.tar.gz: 5cf2f4410a8326c2a0f20c3471540453da92ccbc4617ad171ded389da84f145c
+  metadata.gz: 0fdb1765f269869de8c648faa317223189f37cb567b50f6a9caf2564f4611b9c
+  data.tar.gz: 28402419c0136ab8b501b47e96bb292201212bb9f91a2c2b7534ff4d84e83bd4
 SHA512:
-  metadata.gz: 1bbfa6dc9295dbd292dc37eabedc189129eeb03fa891a8e33ca8cb496213fc99b4defaa0f56b00fdac3f8c1e379f235104ca44281c91aafc84a37e0a46bfcffd
-  data.tar.gz: 4d359891c62c0c8025528c28b69685d828cb2cb3b809d6bde18cf833fba6514ad152fe3522e79d9e866f17beab939b2eb12113024b96f573c4c1067a48e3061c
+  metadata.gz: 376739a02e1cd0673babf91821c4cf3c44f4afdb79cb087ec91d1b31ad44fd48aa1eaa075f51399b1f356aa0dbd09784be5e38d9ef915560f5d109524e2a13a2
+  data.tar.gz: f99028dfc1be6a94a2f597cf4fe451c21810b9931c6a311a85482998fa5b4fd87ea3ed1045af705c9132e41bdc16d1a6bdaabaff1e950ae8ac47c760ba201904

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.5.0] - 2024-02-27
+
+### Added
+
+- `:only` option to restrict the validation to a specific entity (person or legal)
+
 ## [0.4.0] - 2024-02-25
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    validates_identity (0.4.0)
+    validates_identity (0.5.0)
       activemodel
 
 GEM

data/README.md

@@ -1,6 +1,7 @@
 # ValidatesIdentity
 
 This projects aims to validate several countries person identification documents.
+It works on top of 2 attributes, so that the identity can be determined by a second value and thus validate the first one accordingly
 
 ## Installation
 
@@ -18,6 +19,14 @@ Or install it yourself as:
 
     $ gem install validates_identity
 
+## Official Plugins
+
+Just require the plugins you want/need in your Gemfile and you will be good to go
+
+- [Brazilian CPF](https://github.com/plribeiro3000/validates_identity-br_cpf)
+- [Brazilian CNPJ](https://github.com/plribeiro3000/validates_identity-br_cnpj)
+- [Guatemala DPI](https://github.com/plribeiro3000/validates_identity-gt_dpi)
+
 ## Usage
 
 Just use as any other validator:
@@ -29,42 +38,55 @@ class User < ActiveRecord::Base
 end
 ```
 
-## Advanced Usage
-
-### Format
+### Format Option
 
 The `format` option can be used to format the final identity value.
 
 ```ruby
 class User < ActiveRecord::Base
-  # :identity_type is the attribute that will be used to determine the identity type and is required
+  # all values will be formatted after successful validation
   validates :identity, identity: { identity_type: :identity_type, format: true }
 end
 ```
 
-### Custom Validators
+### Only Option
 
-New Identity Validators can be registered through the public apis of `ValidatesIdentity`
+The `only` option can be used to narrow down the validators
 
 ```ruby
-ValidatesIdentity.register_identity_type('CustomIdentity', CustomIdentityValidator)
+class User < ActiveRecord::Base
+  # will accept only person identity types
+  validates :identity, identity: { identity_type: :identity_type, only: :person }
+  # will accept only legal identity types
+  validates :identity, identity: { identity_type: :identity_type, only: :legal }
+end
 ```
 
-Each Validator should have:
+### Aliases
 
-- a constructor with 1 param: `value`
-- a `valid?` method that returns a boolean
-- a `formatted` method that returns the value formatted
+In case of a legacy system where keys were already defined and differ from the official ones, aliases can be registered to easy the transition
 
-### Validators Aliases
+```ruby
+ValidatesIdentity.register_person_identity_type_alias('LegacyIdentity', 'CustomIdentity')
+ValidatesIdentity.register_legal_identity_type_alias('LegacyIdentity', 'CustomIdentity')
+```
 
-In case of a legacy system where keys were already defined and differ from the official ones, aliases can be registered as well
+### Adding your own Validators
+
+New Identity Validators can be registered through the public apis of `ValidatesIdentity`
 
 ```ruby
-ValidatesIdentity.register_identity_type_alias('LegacyIdentity', 'CustomIdentity')
+ValidatesIdentity.register_person_identity_type('CustomIdentity', CustomIdentityValidator)
+ValidatesIdentity.register_legal_identity_type('CustomIdentity', CustomIdentityValidator)
 ```
 
-### Custom scenarios for matching
+A Validator must implement:
+
+- a constructor with 1 param: `value`
+- a `valid?` method that returns a boolean
+- a `formatted` method that returns the formatted value
+
+### Adding scenarios to the matcher
 
 When adding a new validator, cases of success and error can be added through and API so that the `Matcher` will test against them
 

data/lib/shoulda/matchers/active_model/require_a_valid_identity_matcher.rb

@@ -13,14 +13,23 @@ module Shoulda
         def initialize(identity, identity_type)
           super(identity)
           @identity_type = identity_type
+          @type = :both
         end
 
         def description
-          'requires a valid identity'
+          case @type
+          when :person then 'require a valid person identity'
+          when :legal then 'require a valid legal identity'
+          else 'require a valid identity'
+          end
         end
 
         def failure_message
-          'does not require a valid identity'
+          case @type
+          when :person then 'does not require a valid person identity'
+          when :legal then 'does not require a valid legal identity'
+          else 'expected to require a valid identity'
+          end
         end
 
         def matches?(subject)
@@ -28,7 +37,7 @@ module Shoulda
 
           result = []
 
-          ValidatesIdentity::ShouldaMatchers.allowed_values.each do |identity_type, values|
+          allowed_values.each do |identity_type, values|
             subject.send("#{@identity_type}=", identity_type)
 
             values.each do |value|
@@ -36,7 +45,7 @@ module Shoulda
             end
           end
 
-          ValidatesIdentity::ShouldaMatchers.disallowed_values.each do |identity_type, values|
+          disallowed_values.each do |identity_type, values|
             subject.send("#{@identity_type}=", identity_type)
 
             values.each do |value|
@@ -46,6 +55,40 @@ module Shoulda
 
           result.inject(:&)
         end
+
+        private
+
+        def allowed_values
+          case @type
+          when :person then person_allowed_values
+          when :legal then legal_allowed_values
+          else ValidatesIdentity::ShouldaMatchers.allowed_values
+          end
+        end
+
+        def disallowed_values
+          case @type
+          when :person then person_disallowed_values + legal_allowed_values
+          when :legal then legal_disallowed_values + person_allowed_values
+          else ValidatesIdentity::ShouldaMatchers.disallowed_values
+          end
+        end
+
+        def person_allowed_values
+          ValidatesIdentity::ShouldaMatchers.person_allowed_values
+        end
+
+        def person_disallowed_values
+          ValidatesIdentity::ShouldaMatchers.person_disallowed_values
+        end
+
+        def legal_allowed_values
+          ValidatesIdentity::ShouldaMatchers.legal_allowed_values
+        end
+
+        def legal_disallowed_values
+          ValidatesIdentity::ShouldaMatchers.legal_disallowed_values
+        end
       end
     end
   end

data/lib/validates_identity/identity.rb

@@ -15,7 +15,7 @@ class ValidatesIdentity
       return true if value.blank?
       return false if options[:identity_type].blank?
 
-      validator_class = ValidatesIdentity.get_validator(identity_type)
+      validator_class = ValidatesIdentity.get_validator(identity_type, type: options[:only])
 
       return false if validator_class.nil?
 

data/lib/validates_identity/shoulda_matchers.rb

@@ -3,20 +3,44 @@
 class ValidatesIdentity
   class ShouldaMatchers
     class << self
+      def person_allowed_values
+        @person_allowed_values ||= {}
+      end
+
+      def legal_allowed_values
+        @legal_allowed_values ||= {}
+      end
+
+      def person_disallowed_values
+        @person_disallowed_values ||= {}
+      end
+
+      def legal_disallowed_values
+        @legal_disallowed_values ||= {}
+      end
+
       def allowed_values
-        @allowed_values ||= {}
+        person_allowed_values.merge(legal_allowed_values)
       end
 
       def disallowed_values
-        @disallowed_values ||= {}
+        person_disallowed_values.merge(legal_disallowed_values)
+      end
+
+      def register_person_allowed_values(identity_type_acronym, values = [])
+        person_allowed_values[identity_type_acronym] = values
+      end
+
+      def register_legal_allowed_values(identity_type_acronym, values = [])
+        legal_allowed_values[identity_type_acronym] = values
       end
 
-      def register_allowed_values(identity_type_acronym, values = [])
-        allowed_values[identity_type_acronym] = values
+      def register_person_disallowed_values(identity_type_acronym, values = [])
+        person_disallowed_values[identity_type_acronym] = values
       end
 
-      def register_disallowed_values(identity_type_acronym, values = [])
-        disallowed_values[identity_type_acronym] = values
+      def register_legal_disallowed_values(identity_type_acronym, values = [])
+        legal_disallowed_values[identity_type_acronym] = values
       end
     end
   end

data/lib/validates_identity/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class ValidatesIdentity
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/validates_identity.rb

@@ -10,26 +10,57 @@ class ValidatesIdentity
   class << self
     private
 
+    def person_identity_types
+      @person_identity_types ||= {}
+    end
+
+    def legal_identity_types
+      @legal_identity_types ||= {}
+    end
+
     def identity_types
-      @identity_types ||= {}
+      person_identity_types.merge(legal_identity_types)
+    end
+
+    def person_identity_type_aliases
+      @person_identity_type_aliases ||= {}
+    end
+
+    def legal_identity_type_aliases
+      @legal_identity_type_aliases ||= {}
     end
 
     def identity_type_aliases
-      @identity_type_aliases ||= {}
+      person_identity_type_aliases.merge(legal_identity_type_aliases)
     end
   end
 
-  def self.register_identity_type(identity_type_acronym, identity_type_validator)
-    identity_types[identity_type_acronym] = identity_type_validator
-    identity_type_aliases[identity_type_acronym] = identity_type_acronym
+  def self.register_person_identity_type(identity_type_acronym, identity_type_validator)
+    person_identity_types[identity_type_acronym] = identity_type_validator
+    register_person_identity_type_alias(identity_type_acronym, identity_type_acronym)
+  end
+
+  def self.register_legal_identity_type(identity_type_acronym, identity_type_validator)
+    legal_identity_types[identity_type_acronym] = identity_type_validator
+    register_legal_identity_type_alias(identity_type_acronym, identity_type_acronym)
   end
 
-  def self.register_identity_type_alias(identity_type, identity_type_alias)
-    identity_type_aliases[identity_type_alias] = identity_type
+  def self.register_person_identity_type_alias(identity_type, identity_type_alias)
+    person_identity_type_aliases[identity_type_alias] = identity_type
   end
 
-  def self.get_validator(identity_type)
-    identity_alias = identity_type_aliases[identity_type]
+  def self.register_legal_identity_type_alias(identity_type, identity_type_alias)
+    legal_identity_type_aliases[identity_type_alias] = identity_type
+  end
+
+  def self.get_validator(identity_type, type: :both)
+    identity_alias =
+      case type
+      when :person then person_identity_type_aliases[identity_type]
+      when :legal then legal_identity_type_aliases[identity_type]
+      else identity_type_aliases[identity_type]
+      end
+
     identity_types[identity_alias]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: validates_identity
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Paulo Ribeiro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-25 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel