brazil-validator 0.1.0

data/lib/br_validator/ie/df.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # DF: SEFAZ-DF's own Sintegra "Roteiro de Crítica" page
+    # (sintegra.gov.br/Cad_Estados/cad_DF.html) is empty, so this was
+    # instead cross-verified against two independent secondary sources
+    # that agree with each other (cadcobol.com.br's fully worked example,
+    # arithmetic re-checked by hand, and mestredocalculo.com.br
+    # independently citing the same valid example "07.300.001.001-09").
+    # The algorithm is structurally identical to AC's officially-confirmed
+    # one (same weight sequences), differing only in the fixed "07" prefix
+    # -- strong evidence both derive from the same original SEFAZ
+    # documentation.
+    #
+    # Format: "07" (fixed) + 6 sequence digits + 3 "ordem do
+    # estabelecimento" digits (001 = matriz) + 2 check digits = 13 digits
+    # total.
+    module Df
+      module_function
+
+      ALLOWED_CHARS = %r{\A[\d./\-\s]+\z}.freeze
+      FIRST_DIGIT_WEIGHTS = [4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2].freeze
+      SECOND_DIGIT_WEIGHTS = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :FIRST_DIGIT_WEIGHTS, :SECOND_DIGIT_WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 13 && v.start_with?("07")
+
+        first_digit = Mod11.mod11_check_digit(Mod11.weighted_sum(v, FIRST_DIGIT_WEIGHTS))
+        return false unless first_digit == v[11].to_i
+
+        second_digit = Mod11.mod11_check_digit(Mod11.weighted_sum(v, SECOND_DIGIT_WEIGHTS))
+
+        second_digit == v[12].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 13
+
+        "#{v[0...2]}.#{v[2...5]}.#{v[5...8]}.#{v[8...11]}-#{v[11...13]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/es.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # ES: verified against the official SEFAZ-ES "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_ES.html),
+    # including its worked example (all-9s base -> sum 396). Format: 8
+    # digits + 1 check digit. No official punctuation mask is published,
+    # so format returns plain digits.
+    module Es
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        normalize(value)
+      end
+    end
+  end
+end

data/lib/br_validator/ie/go.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # GO: verified against the official SEFAZ-GO "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_GO.html),
+    # including its worked example (10.987.654-7). Format: AB.CDE.FGH-I,
+    # where AB must be 10, 11, or 20-29.
+    module Go
+      module_function
+
+      ALLOWED_CHARS = /\A[\d.\-\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def valid_prefix?(v)
+        prefix = v[0...2].to_i
+
+        prefix == 10 || prefix == 11 || (20..29).cover?(prefix)
+      end
+      private_class_method :valid_prefix?
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9 && valid_prefix?(v)
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 9
+
+        "#{v[0...2]}.#{v[2...5]}.#{v[5...8]}-#{v[8...9]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/ma.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # MA: verified against the official SEFAZ-MA "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_MA.html),
+    # including its worked example (120000385).
+    #
+    # Format: "12" (fixed) + 6 sequence digits + 1 check digit = 9 digits
+    # total. No official punctuation mask is published, so format returns
+    # plain digits.
+    module Ma
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9 && v.start_with?("12")
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        normalize(value)
+      end
+    end
+  end
+end

data/lib/br_validator/ie/mg.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # MG: verified against the official SEFAZ-MG "Roteiro de Crítica da
+    # Inscrição Estadual" (mirrored at
+    # sintegra.gov.br/Cad_Estados/cad_MG.html), including its fully worked
+    # example (062.307.904/0081).
+    #
+    # Format: A1A2A3 B1B2B3B4B5B6 C1C2 D1D2 (13 digits), where A =
+    # município code, B = registration number, C = establishment order, D
+    # = check digits.
+    module Mg
+      module_function
+
+      ALLOWED_CHARS = %r{\A[\d./\s]+\z}.freeze
+      FIRST_DIGIT_WEIGHTS = [1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2].freeze
+      SECOND_DIGIT_WEIGHTS = [3, 2, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :FIRST_DIGIT_WEIGHTS, :SECOND_DIGIT_WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def sum_of_digits(value)
+        value.digits.sum
+      end
+      private_class_method :sum_of_digits
+
+      # D1 equalizes the field widths by inserting a "0" right after the
+      # município code, then sums the *digits* of each weighted product
+      # (not the products themselves) before completing to the next
+      # multiple of ten.
+      def calculate_first_digit(base)
+        with_inserted_zero = "#{base[0...3]}0#{base[3..]}"
+
+        digit_sum = FIRST_DIGIT_WEIGHTS.each_with_index.sum do |weight, i|
+          sum_of_digits(with_inserted_zero[i].to_i * weight)
+        end
+
+        remainder = digit_sum % 10
+
+        return 0 if remainder.zero?
+
+        10 - remainder
+      end
+      private_class_method :calculate_first_digit
+
+      # D2 uses the original (un-padded) base plus D1, and sums the
+      # weighted products directly, following the general módulo 11
+      # remainder rule.
+      def calculate_second_digit(base, first_digit)
+        with_first_digit = "#{base}#{first_digit}"
+
+        sum = Mod11.weighted_sum(with_first_digit, SECOND_DIGIT_WEIGHTS)
+        remainder = sum % 11
+
+        return 0 if remainder <= 1
+
+        11 - remainder
+      end
+      private_class_method :calculate_second_digit
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 13
+
+        base = v[0...11]
+        first_digit = calculate_first_digit(base)
+
+        return false unless first_digit == v[11].to_i
+
+        second_digit = calculate_second_digit(base, first_digit)
+
+        second_digit == v[12].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 13
+
+        "#{v[0...3]}.#{v[3...6]}.#{v[6...9]}/#{v[9...13]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/mod11.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BrValidator
+  module Ie
+    # Shared by most Inscrição Estadual algorithms (SEFAZ "Roteiro de
+    # Crítica" documents): weight each digit, sum the products, then
+    # reduce modulo 11.
+    #
+    # Not part of the public API of brazil-validator.
+    module Mod11
+      module_function
+
+      def weighted_sum(digits, weights)
+        weights.each_with_index.sum { |weight, i| digits[i].to_i * weight }
+      end
+
+      # The most common check-digit rule across states: remainder 0 or 1
+      # maps to digit 0, otherwise the digit is 11 minus the remainder.
+      def mod11_check_digit(sum)
+        remainder = sum % 11
+
+        return 0 if remainder <= 1
+
+        11 - remainder
+      end
+
+      # Used by Bahia's módulo-10 branch: remainder 0 maps to digit 0,
+      # otherwise the digit is 10 minus the remainder.
+      def mod10_check_digit(sum)
+        remainder = sum % 10
+
+        return 0 if remainder.zero?
+
+        10 - remainder
+      end
+
+      # Used by Alagoas and Rio Grande do Norte: the sum is multiplied by
+      # 10 before reducing modulo 11, and the remainder *is* the digit
+      # directly (a remainder of 10 wraps to 0). Mirrors CPF's check-digit
+      # formula.
+      def mod11_times_ten_check_digit(sum)
+        remainder = (sum * 10) % 11
+
+        remainder == 10 ? 0 : remainder
+      end
+    end
+  end
+end

data/lib/br_validator/ie/ms.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # MS: verified against the official SEFAZ-MS "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_MS.html) for the
+    # algorithm (which the page does not accompany with a worked numeric
+    # example), plus an independently hand-computed regression vector
+    # (281234566). Format: 8 digits (always starting with "28" or "50") +
+    # 1 check digit.
+    module Ms
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def valid_prefix?(v)
+        %w[28 50].include?(v[0...2])
+      end
+      private_class_method :valid_prefix?
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9 && valid_prefix?(v)
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        normalize(value)
+      end
+    end
+  end
+end

data/lib/br_validator/ie/mt.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # MT: verified against the official SEFAZ-MT "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_MT.html),
+    # including its worked example (0013000001-9). Format: 10 digits + 1
+    # check digit.
+    module Mt
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\-\s]+\z/.freeze
+      WEIGHTS = [3, 2, 9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 11
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[10].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 11
+
+        "#{v[0...10]}-#{v[10...11]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/pa.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # PA: verified against the official SEFAZ-PA "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_PA.html),
+    # including its two worked examples (15999999-5, 75000002-3). Format:
+    # 8 digits (always starting with 15, 75, 76, 77, 78 or 79) + 1 check
+    # digit.
+    module Pa
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\-\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      VALID_PREFIXES = %w[15 75 76 77 78 79].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS, :VALID_PREFIXES
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9 && VALID_PREFIXES.include?(v[0...2])
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 9
+
+        "#{v[0...8]}-#{v[8...9]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/pb.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # PB: verified against the official SEFAZ-PB "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_PB.html),
+    # including its worked example (06000001-5). Format: 8 digits + 1
+    # check digit.
+    module Pb
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\-\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 9
+
+        "#{v[0...8]}-#{v[8...9]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/pe.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # PE: verified against the official SEFAZ-PE "Roteiro de Crítica da
+    # Inscrição Estadual" for the e-Fisco system
+    # (sintegra.gov.br/Cad_Estados/cad_PE.html), including its fully
+    # worked example (0321418-40). Format: 7 digits + 2 check digits.
+    module Pe
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\-\s]+\z/.freeze
+      FIRST_DIGIT_WEIGHTS = [8, 7, 6, 5, 4, 3, 2].freeze
+      SECOND_DIGIT_WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :FIRST_DIGIT_WEIGHTS, :SECOND_DIGIT_WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9
+
+        base = v[0...7]
+        first_digit = Mod11.mod11_check_digit(Mod11.weighted_sum(base, FIRST_DIGIT_WEIGHTS))
+
+        return false unless first_digit == v[7].to_i
+
+        second_digit = Mod11.mod11_check_digit(
+          Mod11.weighted_sum(base + first_digit.to_s, SECOND_DIGIT_WEIGHTS)
+        )
+
+        second_digit == v[8].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 9
+
+        "#{v[0...7]}-#{v[7...9]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/pi.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # PI: verified against the official SEFAZ-PI "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_PI.html),
+    # including its worked example (012345679). Format: 8 digits + 1 check
+    # digit.
+    module Pi
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 9
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[8].to_i
+      end
+
+      def format(value)
+        normalize(value)
+      end
+    end
+  end
+end

data/lib/br_validator/ie/pr.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # PR: verified against the official SEFAZ-PR "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_PR.html),
+    # including its fully worked example (123.45678-50), and cross-checked
+    # against the reference Visual Basic routine published on the same
+    # page. Format: 8 digits + 2 check digits.
+    module Pr
+      module_function
+
+      ALLOWED_CHARS = /\A[\d.\-\s]+\z/.freeze
+      FIRST_DIGIT_WEIGHTS = [3, 2, 7, 6, 5, 4, 3, 2].freeze
+      SECOND_DIGIT_WEIGHTS = [4, 3, 2, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :FIRST_DIGIT_WEIGHTS, :SECOND_DIGIT_WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 10
+
+        base = v[0...8]
+        first_digit = Mod11.mod11_check_digit(Mod11.weighted_sum(base, FIRST_DIGIT_WEIGHTS))
+
+        return false unless first_digit == v[8].to_i
+
+        second_digit = Mod11.mod11_check_digit(
+          Mod11.weighted_sum(base + first_digit.to_s, SECOND_DIGIT_WEIGHTS)
+        )
+
+        second_digit == v[9].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 10
+
+        "#{v[0...3]}.#{v[3...8]}-#{v[8...10]}"
+      end
+    end
+  end
+end