brazil-validator 0.1.0

data/lib/br_validator/ie/rj.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # RJ: verified against the official SEFAZ-RJ "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_RJ.html) for the
+    # check-digit rule, and cross-checked against a worked example
+    # (99.999.99-3) for the weights, which the Sintegra page itself does
+    # not enumerate.
+    module Rj
+      module_function
+
+      ALLOWED_CHARS = /\A[\d.\-\s]+\z/.freeze
+      WEIGHTS = [2, 7, 6, 5, 4, 3, 2].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def calculate_check_digit(v)
+        sum = Mod11.weighted_sum(v, WEIGHTS)
+        remainder = sum % 11
+
+        return 0 if remainder <= 1
+
+        11 - remainder
+      end
+      private_class_method :calculate_check_digit
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 8
+
+        calculate_check_digit(v) == v[7].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 8
+
+        "#{v[0...2]}.#{v[2...5]}.#{v[5...7]}-#{v[7...8]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/rn.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # RN: verified against the official SEFAZ-RN "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_RN.html),
+    # including both of its worked examples (20.040.040-1 and
+    # 20.0.040.040-0). Format: always starts with "20", followed by either
+    # 7 or 8 more digits, plus 1 check digit (9 or 10 digits total, both
+    # still valid today per the official page).
+    module Rn
+      module_function
+
+      ALLOWED_CHARS = /\A[\d.\-\s]+\z/.freeze
+      private_constant :ALLOWED_CHARS
+
+      def normalize(value)
+        Shared.remove_non_digits(value)
+      end
+
+      def weights_for(base_length)
+        (0...base_length).map { |i| base_length + 1 - i }
+      end
+      private_class_method :weights_for
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless [9, 10].include?(v.length) && v.start_with?("20")
+
+        base = v[0...-1]
+        check_digit = Mod11.mod11_times_ten_check_digit(
+          Mod11.weighted_sum(base, weights_for(base.length))
+        )
+
+        check_digit == v[-1].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        case v.length
+        when 9
+          "#{v[0...2]}.#{v[2...5]}.#{v[5...8]}-#{v[8...9]}"
+        when 10
+          "#{v[0...2]}.#{v[2...3]}.#{v[3...6]}.#{v[6...9]}-#{v[9...10]}"
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/br_validator/ie/ro.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # RO: verified against the official SEFAZ-RO "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_RO.html),
+    # including its worked example (0000000062521-3). Since 01/08/2000 the
+    # format is 13 digits + 1 check digit (the old "município + empresa"
+    # layout is superseded, with old registrations re-expressed by
+    # zero-padding into the new 13-digit field).
+    #
+    # The weights cycle 2-9 applied right to left over the 13 digits, i.e.
+    # [6,5,4,3,2,9,8,7,6,5,4,3,2] read left to right. Unlike most other
+    # states, a zero remainder maps to check digit 1, not 0 (the source
+    # explicitly says "subtract 10" from the 11-or-10 result, rather than
+    # mapping straight to 0).
+    module Ro
+      module_function
+
+      ALLOWED_CHARS = /\A[\d.\-\s]+\z/.freeze
+      WEIGHTS = [6, 5, 4, 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 calculate_check_digit(base)
+        remainder = Mod11.weighted_sum(base, WEIGHTS) % 11
+        diff = 11 - remainder
+
+        diff > 9 ? diff - 10 : diff
+      end
+      private_class_method :calculate_check_digit
+
+      def is_valid?(value)
+        return false unless value.match?(ALLOWED_CHARS)
+
+        v = normalize(value)
+
+        return false unless v.length == 14
+
+        calculate_check_digit(v[0...13]) == v[13].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 14
+
+        "#{v[0...13]}-#{v[13...14]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/rr.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # RR: verified against the official SEFAZ-RR "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_RR.html),
+    # including its worked example (24006153-6) and the ten additional
+    # valid numbers it lists. Format: "24" (fixed) + 6 sequence digits + 1
+    # check digit = 9 digits total. Unlike every other state, the check
+    # digit uses módulo 9, and the weights are the digit's own 1-based
+    # position (ascending, not descending).
+    module Rr
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\-\s]+\z/.freeze
+      WEIGHTS = [1, 2, 3, 4, 5, 6, 7, 8].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?("24")
+
+        check_digit = Mod11.weighted_sum(v, WEIGHTS) % 9
+
+        check_digit == 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/rs.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # RS: verified against the official SEFAZ-RS "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_RS.html),
+    # including its worked example (224/3658792). Format: 3 digits
+    # (município) + 6 digits (empresa) + 1 check digit = 10 digits total.
+    module Rs
+      module_function
+
+      ALLOWED_CHARS = %r{\A[\d/\s]+\z}.freeze
+      WEIGHTS = [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 == 10
+
+        Mod11.mod11_check_digit(Mod11.weighted_sum(v, WEIGHTS)) == v[9].to_i
+      end
+
+      def format(value)
+        v = normalize(value)
+
+        return value unless v.length == 10
+
+        "#{v[0...3]}/#{v[3...10]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/sc.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # SC: verified against the official SEFAZ-SC "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_SC.html),
+    # including its worked example (251.040.852). Format: 8 digits + 1
+    # check digit.
+    module Sc
+      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...3]}.#{v[3...6]}.#{v[6...9]}"
+      end
+    end
+  end
+end

data/lib/br_validator/ie/se.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # SE: verified against the official SEFAZ-SE "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_SE.html),
+    # including its worked example (27123456-3). Format: 8 digits + 1
+    # check digit.
+    module Se
+      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/sp.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # SP: verified against the official SEFAZ-SP "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_SP.html),
+    # including both of its worked examples: the standard
+    # industrial/commercial format (110.042.490.114) and the "Produtor
+    # Rural" format (P-01100424.3/002).
+    #
+    # Note: the source restates the Produtor Rural example at the very end
+    # as "P-011000424.3/002" (14 characters) -- this contradicts both the
+    # document's own "13 caracteres" rule and its worked calculation
+    # (which sums exactly 8 digits to 91, matching the 13-character form).
+    # Treated as a typo in the source; the 13-character form is what this
+    # module expects.
+    module Sp
+      module_function
+
+      STANDARD_ALLOWED_CHARS = /\A[\d.\s]+\z/.freeze
+      PRODUTOR_RURAL_ALLOWED = %r{\A[Pp\d.\-/\s]+\z}.freeze
+      FORMATTING_CHARS = %r{[.\-/\s]}.freeze
+      PRODUTOR_RURAL_PREFIX = /\A\s*[Pp]/.freeze
+
+      STANDARD_FIRST_DIGIT_WEIGHTS = [1, 3, 4, 5, 6, 7, 8, 10].freeze
+      STANDARD_SECOND_DIGIT_WEIGHTS = [3, 2, 10, 9, 8, 7, 6, 5, 4, 3, 2].freeze
+      PRODUTOR_RURAL_WEIGHTS = [1, 3, 4, 5, 6, 7, 8, 10].freeze
+      private_constant :STANDARD_ALLOWED_CHARS, :PRODUTOR_RURAL_ALLOWED, :FORMATTING_CHARS,
+                        :PRODUTOR_RURAL_PREFIX, :STANDARD_FIRST_DIGIT_WEIGHTS,
+                        :STANDARD_SECOND_DIGIT_WEIGHTS, :PRODUTOR_RURAL_WEIGHTS
+
+      def calculate_check_digit(digits, weights)
+        sum = Mod11.weighted_sum(digits, weights)
+
+        sum % 11 == 10 ? 0 : sum % 11
+      end
+      private_class_method :calculate_check_digit
+
+      def produtor_rural?(value)
+        value.match?(PRODUTOR_RURAL_PREFIX)
+      end
+      private_class_method :produtor_rural?
+
+      def normalize_standard(value)
+        Shared.remove_non_digits(value)
+      end
+      private_class_method :normalize_standard
+
+      def valid_standard?(value)
+        return false unless value.match?(STANDARD_ALLOWED_CHARS)
+
+        v = normalize_standard(value)
+
+        return false unless v.length == 12
+
+        first_digit = calculate_check_digit(v, STANDARD_FIRST_DIGIT_WEIGHTS)
+        return false unless first_digit == v[8].to_i
+
+        second_digit = calculate_check_digit(v, STANDARD_SECOND_DIGIT_WEIGHTS)
+
+        second_digit == v[11].to_i
+      end
+      private_class_method :valid_standard?
+
+      def format_standard(value)
+        v = normalize_standard(value)
+
+        return value unless v.length == 12
+
+        "#{v[0...3]}.#{v[3...6]}.#{v[6...9]}.#{v[9...12]}"
+      end
+      private_class_method :format_standard
+
+      # Format: P0MMMSSSSD000 (13 characters) -- "P" (fixed) + "0" (fixed)
+      # + 3 município digits + 4 sequence digits + 1 check digit + 3
+      # unused digits.
+      def normalize_produtor_rural(value)
+        value.gsub(FORMATTING_CHARS, "").upcase
+      end
+      private_class_method :normalize_produtor_rural
+
+      def valid_produtor_rural?(value)
+        return false unless value.match?(PRODUTOR_RURAL_ALLOWED)
+
+        v = normalize_produtor_rural(value)
+
+        return false unless v.length == 13 && v[0] == "P" && v[1] == "0"
+
+        base = v[1...9]
+        check_digit = calculate_check_digit(base, PRODUTOR_RURAL_WEIGHTS)
+
+        check_digit == v[9].to_i
+      end
+      private_class_method :valid_produtor_rural?
+
+      def format_produtor_rural(value)
+        v = normalize_produtor_rural(value)
+
+        return value unless v.length == 13
+
+        "P-#{v[1...9]}.#{v[9...10]}/#{v[10...13]}"
+      end
+      private_class_method :format_produtor_rural
+
+      def is_valid?(value)
+        produtor_rural?(value) ? valid_produtor_rural?(value) : valid_standard?(value)
+      end
+
+      def normalize(value)
+        produtor_rural?(value) ? normalize_produtor_rural(value) : normalize_standard(value)
+      end
+
+      def format(value)
+        produtor_rural?(value) ? format_produtor_rural(value) : format_standard(value)
+      end
+    end
+  end
+end

data/lib/br_validator/ie/to.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../shared"
+require_relative "mod11"
+
+module BrValidator
+  module Ie
+    # TO: verified against the official SEFAZ-TO "Roteiro de Crítica da
+    # Inscrição Estadual" (sintegra.gov.br/Cad_Estados/cad_TO.html),
+    # including its worked example (29010227836). Format: 11 digits, where
+    # positions 3-4 hold a fixed "tipo" code (01 Produtor Rural, 02
+    # Indústria e Comércio, 03 Empresas Rudimentares, 99 Cadastro Antigo)
+    # that is excluded from the check-digit calculation, and position 11
+    # is the check digit.
+    module To
+      module_function
+
+      ALLOWED_CHARS = /\A[\d\s]+\z/.freeze
+      WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2].freeze
+      VALID_TYPE_CODES = %w[01 02 03 99].freeze
+      # 1-based positions used in the check-digit calculation (positions
+      # 3-4 are skipped).
+      DIGIT_POSITIONS = [1, 2, 5, 6, 7, 8, 9, 10].freeze
+      private_constant :ALLOWED_CHARS, :WEIGHTS, :VALID_TYPE_CODES, :DIGIT_POSITIONS
+
+      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 && VALID_TYPE_CODES.include?(v[2...4])
+
+        sum = DIGIT_POSITIONS.each_with_index.sum do |pos, i|
+          v[pos - 1].to_i * WEIGHTS[i]
+        end
+
+        Mod11.mod11_check_digit(sum) == v[10].to_i
+      end
+
+      def format(value)
+        normalize(value)
+      end
+    end
+  end
+end

data/lib/br_validator/ie.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "ie/ac"
+require_relative "ie/al"
+require_relative "ie/am"
+require_relative "ie/ap"
+require_relative "ie/ba"
+require_relative "ie/ce"
+require_relative "ie/df"
+require_relative "ie/es"
+require_relative "ie/go"
+require_relative "ie/ma"
+require_relative "ie/mg"
+require_relative "ie/ms"
+require_relative "ie/mt"
+require_relative "ie/pa"
+require_relative "ie/pb"
+require_relative "ie/pe"
+require_relative "ie/pi"
+require_relative "ie/pr"
+require_relative "ie/rj"
+require_relative "ie/rn"
+require_relative "ie/ro"
+require_relative "ie/rr"
+require_relative "ie/rs"
+require_relative "ie/sc"
+require_relative "ie/se"
+require_relative "ie/sp"
+require_relative "ie/to"
+
+module BrValidator
+  # Validates, normalizes, and formats Brazilian Inscrição Estadual
+  # numbers.
+  #
+  # Inscrição Estadual has no single national rule: each state (SEFAZ)
+  # defines its own digit count and check-digit algorithm, so every UF is
+  # modeled as its own module under BrValidator::Ie and registered in the
+  # STATES map below. A UF absent from that map is simply not supported
+  # yet.
+  module Ie
+    module_function
+
+    STATES = {
+      "AC" => Ac,
+      "AL" => Al,
+      "AM" => Am,
+      "AP" => Ap,
+      "BA" => Ba,
+      "CE" => Ce,
+      "DF" => Df,
+      "ES" => Es,
+      "GO" => Go,
+      "MA" => Ma,
+      "MG" => Mg,
+      "MS" => Ms,
+      "MT" => Mt,
+      "PA" => Pa,
+      "PB" => Pb,
+      "PE" => Pe,
+      "PI" => Pi,
+      "PR" => Pr,
+      "RJ" => Rj,
+      "RN" => Rn,
+      "RO" => Ro,
+      "RR" => Rr,
+      "RS" => Rs,
+      "SC" => Sc,
+      "SE" => Se,
+      "SP" => Sp,
+      "TO" => To
+    }.freeze
+    private_constant :STATES
+
+    def resolve_state(uf)
+      STATES[uf.strip.upcase]
+    end
+    private_class_method :resolve_state
+
+    # Returns true if value is a valid Inscrição Estadual for uf.
+    def is_valid?(value, uf)
+      state = resolve_state(uf)
+
+      return false if state.nil?
+
+      state.is_valid?(value)
+    end
+
+    # Strips formatting and returns the canonical representation of value
+    # for uf.
+    #
+    # If uf is not supported, value is returned unchanged.
+    def normalize(value, uf)
+      state = resolve_state(uf)
+
+      return value if state.nil?
+
+      state.normalize(value)
+    end
+
+    # Returns value in uf's standard human-readable representation.
+    #
+    # If uf is not supported or the normalized value has an invalid
+    # length, value is returned unchanged.
+    def format(value, uf)
+      state = resolve_state(uf)
+
+      return value if state.nil?
+
+      state.format(value)
+    end
+  end
+end

data/lib/br_validator/phone.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "shared"
+
+module BrValidator
+  # Validates, normalizes, and formats Brazilian national phone numbers
+  # (mobile and landline, no +55 country code).
+  module Phone
+    module_function
+
+    ALLOWED_CHARS = /\A[\d\s()-]+\z/.freeze
+    private_constant :ALLOWED_CHARS
+
+    # Strips formatting and returns the canonical (digits-only)
+    # representation of value.
+    def normalize(value)
+      Shared.remove_non_digits(value)
+    end
+
+    # Returns true if value is a structurally valid Brazilian phone number.
+    #
+    # Enforces Anatel's numbering plan: the DDD must be one of the 67 codes
+    # actually assigned, mobile numbers (11 digits) must carry the "ninth
+    # digit" 9 (Resolução nº 553/2010), and landline numbers (10 digits)
+    # must start with 2-5.
+    def is_valid?(value)
+      return false unless value.match?(ALLOWED_CHARS)
+
+      phone = normalize(value)
+
+      return false unless [10, 11].include?(phone.length)
+      return false unless Shared::VALID_DDDS.include?(phone[0...2])
+
+      subscriber_first_digit = phone[2]
+
+      return subscriber_first_digit == "9" if phone.length == 11
+
+      "2345".include?(subscriber_first_digit)
+    end
+
+    # Returns value as (XX) XXXXX-XXXX (mobile) or (XX) XXXX-XXXX
+    # (landline).
+    #
+    # If the normalized value has an invalid length, value is returned
+    # unchanged.
+    def format(value)
+      phone = normalize(value)
+
+      case phone.length
+      when 11
+        "(#{phone[0...2]}) #{phone[2...7]}-#{phone[7...11]}"
+      when 10
+        "(#{phone[0...2]}) #{phone[2...6]}-#{phone[6...10]}"
+      else
+        value
+      end
+    end
+  end
+end