feat!: allow empty or partial data argument in ItaxCode.valid? (#26)

Author: matteoredz

lib/itax_code.rb

@@ -40,7 +40,7 @@ def decode(tax_code)
     # encoded from user informations.
     #
     # @param [String] tax_code The user tax code
-    # @param [Hash]   data     The user attributes
+    # @param [Hash]   data     The optional user attributes
     #
     # @option data [String]       :surname
     # @option data [String]       :name
@@ -49,8 +49,8 @@ def decode(tax_code)
     # @option data [String]       :birthplace
     #
     # @return [Boolean]
-    def valid?(tax_code, data)
-      Validator.new(data).valid?(tax_code)
+    def valid?(tax_code, data = {})
+      Validator.new(tax_code, data).valid?
     end
   end
 end

lib/itax_code/parser.rb

@@ -13,9 +13,10 @@ module ItaxCode
   #
   # @return [Hash]
   class Parser
-    NoTaxCodeError                    = Class.new(StandardError)
-    InvalidControlInternalNumberError = Class.new(StandardError)
-    InvalidTaxCodeError               = Class.new(StandardError)
+    Error                             = Class.new(StandardError)
+    NoTaxCodeError                    = Class.new(Error)
+    InvalidControlInternalNumberError = Class.new(Error)
+    InvalidTaxCodeError               = Class.new(Error)
 
     def initialize(tax_code, utils = Utils.new)
       @tax_code = tax_code.upcase

lib/itax_code/validator.rb

@@ -5,35 +5,76 @@ module ItaxCode
   #
   # @param [Hash] data The user input data
   class Validator
-    LENGTH = 16
+    LENGTH        = 16
+    REQUIRED_KEYS = %i[surname name gender birthdate birthplace].freeze
 
-    def initialize(data = {})
-      @encoded = Encoder.new(data).encode
+    # @param [String] tax_code The pre-computed tax code
+    # @param [Hash]   data     The optional user attributes
+    #
+    def initialize(tax_code, data = {})
+      @tax_code = tax_code
+      @data     = data
     end
 
     class << self
       # Checks the tax code standard length against user
       # and business fiscal code standards.
       #
-      # @param [String] code The tax code
+      # @param [String] tax_code The tax code
       #
       # @return [true, false]
-      def standard_length?(code)
-        code.length == LENGTH
+      def standard_length?(tax_code)
+        tax_code.length == LENGTH
       end
     end
 
-    # Checks pre computed tax code validity against newly encoded tax code.
-    #
-    # @param [String] tax_code The pre-computed tax code
+    # Checks pre-computed tax code validity against newly encoded tax code.
     #
     # @return [true, false]
-    def valid?(tax_code)
-      encoded[0..10] == tax_code[0..10]
+    def valid?
+      encoded_tax_code == tax_code
     end
 
     private
 
-      attr_accessor :encoded
+      attr_reader :tax_code, :data
+
+      # Encodes the tax code from the given 'data' hash, also backfilling missing information
+      # by decoding the pre-computed tax code.
+      #
+      # @return [String, nil] The encoded tax code or nil if decoding the tax code fails
+      def encoded_tax_code
+        if partial_data?
+          decoded_tax_code ? backfill_data! : return
+        end
+
+        Encoder.new(data).encode
+      end
+
+      # Decodes the given tax code to backfill possibly missing data in the 'data' hash.
+      # If the decode fails, it means that the provided tax code is not valid.
+      #
+      # @return [Hash, nil] The decoded hash or nil if the tax code is not valid
+      def decoded_tax_code
+        @decoded_tax_code ||= begin
+          Parser.new(tax_code).decode
+        rescue Parser::Error
+          nil
+        end
+      end
+
+      def partial_data?
+        REQUIRED_KEYS.any? { |required_key| data[required_key].blank? }
+      end
+
+      def backfill_data!
+        data.tap do |hash|
+          hash[:surname]    ||= decoded_tax_code[:raw][:surname]
+          hash[:name]       ||= decoded_tax_code[:raw][:name]
+          hash[:gender]     ||= decoded_tax_code[:gender]
+          hash[:birthdate]  ||= decoded_tax_code[:birthdate]
+          hash[:birthplace] ||= decoded_tax_code[:birthplace][:code]
+        end
+      end
   end
 end

test/itax_code/validator_test.rb

@@ -12,19 +12,39 @@ class ValidatorTest < ActiveSupport::TestCase
       assert_equal %i[standard_length?], class_methods
     end
 
-    test "#valid?" do
-      assert Validator.new(user_data).valid?("RSSMRA80A01F205X")
-      assert_not Validator.new(user_data).valid?("RSSMRA11A01F205F")
+    test "#valid? is truthy when data matches with the provided tax code" do
+      assert_predicate Validator.new("RSSMRA80A01F205X", data), :valid?
     end
 
-    test "#standard_length?" do
+    test "#valid? is truthy with matching partial and backfilled data" do
+      data_combos.each do |data_combo|
+        assert_predicate Validator.new("RSSMRA80A01F205X", data_combo), :valid?
+      end
+    end
+
+    test "#valid? is truthy when the tax code is valid and no data is provided" do
+      assert_predicate Validator.new("RSSMRA80A01F205X"), :valid?
+    end
+
+    test "#valid? is falsy when data don't matches with the provided tax code" do
+      assert_not Validator.new("RSSMRA11A01F205F", data).valid?
+    end
+
+    test "#valid? is falsy when the parser cannot decode the given tax code" do
+      assert_not Validator.new("WRONG").valid?
+    end
+
+    test "#standard_length? is truthy when the tax code length is 16" do
       assert Validator.standard_length?("RSSMRA00A01F205F")
+    end
+
+    test "#standard_length? is falsy when the tax code hasn't 16 chars" do
       assert_not Validator.standard_length?("WRONG")
     end
 
     private
 
-      def user_data
+      def data
         {
           surname: "Rossi",
           name: "Mario",
@@ -33,5 +53,14 @@ def user_data
           birthplace: "Milano"
         }
       end
+
+      # Creates all the possible combinations from the 'data' hash.
+      def data_combos
+        (1..data.keys.size).flat_map do |size|
+          data.keys.combination(size).map do |keys|
+            keys.map { |key| [key, data[key]] }.to_h
+          end
+        end
+      end
   end
 end