validates_identity 0.3.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314621c0cd80707a6ee1f7a776307f767e167cab1e63e63c4cbe0eeeb404d92a
-  data.tar.gz: 3e7c4f2a9406ec4ade871fe38599451bb18440466c2f17829d440cff6f282cbd
+  metadata.gz: 0fdb1765f269869de8c648faa317223189f37cb567b50f6a9caf2564f4611b9c
+  data.tar.gz: 28402419c0136ab8b501b47e96bb292201212bb9f91a2c2b7534ff4d84e83bd4
 SHA512:
-  metadata.gz: f0c7bf51aaaeb802d817ad33d30881d2f8fcc46091915f0bba6938692d0356342fbd92755378713572dd6eb8dcf9439d60bb1eeedcfbb118e3d601df0194433c
-  data.tar.gz: aa22f5dd5e57e3df142c183de1f993450d7fb6e338ad46325b6c8b12d733f080561a6ffd3c8d6fd9435f0029cbd02541aabd1013e0bf9f8c3fa90bf29efdcc09
+  metadata.gz: 376739a02e1cd0673babf91821c4cf3c44f4afdb79cb087ec91d1b31ad44fd48aa1eaa075f51399b1f356aa0dbd09784be5e38d9ef915560f5d109524e2a13a2
+  data.tar.gz: f99028dfc1be6a94a2f597cf4fe451c21810b9931c6a311a85482998fa5b4fd87ea3ed1045af705c9132e41bdc16d1a6bdaabaff1e950ae8ac47c760ba201904

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [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
+
+- Shoulda Custom Matcher
+
 ## [0.3.2] - 2024-02-25
 
 ### Fixed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    validates_identity (0.3.2)
+    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,39 +38,76 @@ 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
+
+The `only` option can be used to narrow down the validators
+
+```ruby
+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
+```
+
+### Aliases
+
+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
+
+```ruby
+ValidatesIdentity.register_person_identity_type_alias('LegacyIdentity', 'CustomIdentity')
+ValidatesIdentity.register_legal_identity_type_alias('LegacyIdentity', 'CustomIdentity')
+```
+
+### Adding your own Validators
 
 New Identity Validators can be registered through the public apis of `ValidatesIdentity`
 
 ```ruby
-ValidatesIdentity.register_identity_type('CustomIdentity', CustomIdentityValidator)
+ValidatesIdentity.register_person_identity_type('CustomIdentity', CustomIdentityValidator)
+ValidatesIdentity.register_legal_identity_type('CustomIdentity', CustomIdentityValidator)
 ```
 
-Each Validator should have:
+A Validator must implement:
 
 - a constructor with 1 param: `value`
 - a `valid?` method that returns a boolean
-- a `formatted` method that returns the value formatted
+- a `formatted` method that returns the formatted value
 
-### Validators Aliases
+### 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
+
+```ruby
+ValidatesIdentity::ShouldaMatchers.register_allowed_values('CustomIdentity', ['123456789', '123.456.789'])
+ValidatesIdentity::ShouldaMatchers.register_disallowed_values('CustomIdentity', ['12345679', '12.456.789'])
+```
+
+## Testing
+
+Require matcher in your `spec_helper` or `rails_helper` file:
+
+```ruby
+require 'shoulda/matchers/active_model/require_a_valid_identity_matcher'
+```
 
-In case of a legacy system where keys were already defined and differ from the official ones, aliases can be registered as well
+Use in your tests:
 
 ```ruby
-ValidatesIdentity.register_identity_type_alias('LegacyIdentity', 'CustomIdentity')
+it { is_expected.to require_a_valid_identity } # It will test the attributes :identity and :identity_type by default
+it { is_expected.to require_a_valid_identity(:id, :my_type) }
 ```
 
 ## Development

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'shoulda-matchers'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      def require_a_valid_identity(identity = :identity, identity_type = :identity_type)
+        RequireAValidIdentityMatcher.new(identity, identity_type)
+      end
+
+      class RequireAValidIdentityMatcher < ValidationMatcher
+        def initialize(identity, identity_type)
+          super(identity)
+          @identity_type = identity_type
+          @type = :both
+        end
+
+        def description
+          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
+          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)
+          super(subject)
+
+          result = []
+
+          allowed_values.each do |identity_type, values|
+            subject.send("#{@identity_type}=", identity_type)
+
+            values.each do |value|
+              result << allows_value_of(value)
+            end
+          end
+
+          disallowed_values.each do |identity_type, values|
+            subject.send("#{@identity_type}=", identity_type)
+
+            values.each do |value|
+              result << disallows_value_of(value)
+            end
+          end
+
+          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
+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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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
+        person_allowed_values.merge(legal_allowed_values)
+      end
+
+      def 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_person_disallowed_values(identity_type_acronym, values = [])
+        person_disallowed_values[identity_type_acronym] = values
+      end
+
+      def register_legal_disallowed_values(identity_type_acronym, values = [])
+        legal_disallowed_values[identity_type_acronym] = values
+      end
+    end
+  end
+end

data/lib/validates_identity/version.rb

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

data/lib/validates_identity.rb

@@ -5,30 +5,62 @@ require 'identity_validator'
 
 class ValidatesIdentity
   autoload :Identity, 'validates_identity/identity'
+  autoload :ShouldaMatchers, 'validates_identity/shoulda_matchers'
 
   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.3.2
+  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
@@ -43,8 +43,10 @@ files:
 - README.md
 - Rakefile
 - lib/identity_validator.rb
+- lib/shoulda/matchers/active_model/require_a_valid_identity_matcher.rb
 - lib/validates_identity.rb
 - lib/validates_identity/identity.rb
+- lib/validates_identity/shoulda_matchers.rb
 - lib/validates_identity/version.rb
 - validates_identity.gemspec
 homepage: https://github.com/plribeiro3000/validates_identity