validator_ie 0.1.0

data/lib/validator_ie/core/state_ce.rb

@@ -0,0 +1,34 @@
+module ValidatorIE
+
+  class StateCE
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)      
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      digit = mod - sum.divmod(11).last
+      digit = digit.eql?(10) || digit.eql?(11) ? 0 : digit 
+      numberX[at + 1].eql?(digit)
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_df.rb

@@ -0,0 +1,47 @@
+module ValidatorIE
+
+  class StateDF
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 13, maximum: 13 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_mod11
+      result1 = number_should_modX(11, 10, 9)      
+      result2 = number_should_modX(11, 11, 9)      
+      return if result1 && result2
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_mod11_digit(at, weight)
+      number_mod11 = number.split(//).map(&:to_i)
+      sum = number_mod11[0..at].map.with_index { |v, k| v * WEIGHT[weight][k] }.reduce(:+)
+      digit = 11 - sum.divmod(11).last
+      digit = digit.eql?(10) || digit.eql?(11) ? 0 : digit      
+      unless number_mod11[at + 1].eql?(digit)
+        false
+      else 
+        true
+      end
+    end
+
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      digit = mod - sum.divmod(11).last
+      digit = digit.eql?(10) || digit.eql?(11) ? 0 : digit  
+      numberX[at + 1].eql?(digit)
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_es.rb

@@ -0,0 +1,38 @@
+module ValidatorIE
+
+  class StateES
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)        
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      divmod = sum.divmod(mod).last
+
+      if divmod < 2
+        digit = 0
+      else
+        digit = mod - divmod
+      end
+      numberX[at + 1].eql?(digit)
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_go.rb

@@ -0,0 +1,55 @@
+module ValidatorIE
+
+  class StateGO
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_code_state
+    validate :number_should_mod11
+
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_code_state
+      number[0..1].eql?('10') || number[0..1].eql?('11') ||  number[0..1].eql?('15')
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)        
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      divmod = sum.divmod(mod).last
+
+      if number[0..at].eql? '11094402'
+        unless numberX[at + 1].eql?(0) || numberX[at + 1].eql?(1)
+          false
+        else 
+          true
+        end
+      elsif number[0..at].to_i.between?(10103105, 10119997)
+        unless numberX[at + 1].eql?(1)
+          false
+        else 
+          true
+        end
+      else
+        digit =  mod - divmod  
+        digit = digit.eql?(1) ? 0 : digit  
+        numberX[at + 1].eql?(digit)
+      end
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_ma.rb

@@ -0,0 +1,39 @@
+module ValidatorIE
+
+  class StateMA
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_code_state
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_code_state
+      number[0..1].eql?('12')
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)      
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      divmod = sum.divmod(mod).last
+
+      digit = divmod <= 1 ? 0 : mod - divmod
+      numberX[at + 1].eql?(digit)
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_mg.rb

@@ -0,0 +1,49 @@
+require_relative 'mod_functions'
+
+module ValidatorIE
+
+  class StateMG
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 13, maximum: 13 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_mod11
+      
+      self.number = number[0..2].concat("0").concat(number[3..12])
+      matrix = number[0..number.size - 3].split(//).map.with_index {|m, k| k.next.odd? ? 1 : 2}
+      result1 = number_should_modX(11, 11, nil, matrix, true)
+      
+      self.number = number[0..2].concat(number[4..13])
+      result2 = number_should_modX(11, 11, 11, nil)
+      
+      return if result1 && result2
+      errors.add(:number, 'não é válido a inscrição estadual.')
+
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size, matrix = nil, decimal = false)
+      numberX = number.split(//).map(&:to_i)
+     
+      if decimal
+        return false if at > matrix.size - 1
+        sum = numberX[0..at].map.with_index { |v, k| v * matrix[k]}.join('').split(//).map(&:to_i).reduce(&:+)
+        digit = (sum - (sum.to_s.split(//).last.to_i - 10)) - sum
+      else
+        sum = ModFunctions.sumX(numberX, at, final, true, matrix)
+        divmod = sum.divmod(mod).last
+        digit = divmod < 2 ? 0 : mod - divmod
+      end
+      numberX[at + 1].eql?(digit)
+    end
+  end
+
+end

data/lib/validator_ie/core/state_ms.rb

@@ -0,0 +1,38 @@
+module ValidatorIE
+
+  class StateMS
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_code_state
+      number[0..1].eql?('28')
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      divmod = sum.divmod(mod).last
+      digit = divmod > 0 ? (mod - divmod > 9 ? 0 : mod - divmod) : 0
+      return numberX[at + 1].eql?(digit) 
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_mt.rb

@@ -0,0 +1,38 @@
+module ValidatorIE
+
+  class StateMT
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 11, maximum: 11 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_code_state
+      number[0..1].eql?('12')
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 9)
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      divmod = sum.divmod(mod).last
+      digit = divmod <= 1 ? 0 : mod - divmod
+      return numberX[at + 1].eql?(digit) 
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_pa.rb

@@ -0,0 +1,38 @@
+module ValidatorIE
+
+  class StatePA
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_code_state
+      number[0..1].eql?('15')
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      divmod = sum.divmod(mod).last
+      digit = divmod <= 1 ? 0 : 11 - divmod
+      return numberX[at + 1].eql?(digit) 
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_pb.rb

@@ -0,0 +1,38 @@
+module ValidatorIE
+
+  class StatePB
+    include ActiveModel::Validations
+
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_code_state
+      number[0..1].eql?('15')
+    end
+
+    def number_should_mod11
+      result = number_should_modX(11, 7)
+      return if result
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      divmod = sum.divmod(mod).last
+      digit = 11 - divmod >= 10 ? 0 : 11 - divmod
+      return numberX[at + 1].eql?(digit) 
+    end
+
+  end
+
+end

data/lib/validator_ie/core/state_pe.rb

@@ -0,0 +1,35 @@
+module ValidatorIE
+
+  class StatePE
+    include ActiveModel::Validations
+    
+    attr_accessor :number
+    validates :number, length: { minimum: 9, maximum: 9 }, numericality: true, presence: true
+    validate :number_should_mod11
+
+    def initialize(opts={})
+      opts.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+
+    def number_should_mod11
+      digit1 = number_should_modX(11, 6)
+      digit2 = number_should_modX(11, 7)
+      return if digit1 && digit2
+      errors.add(:number, 'não é válido a inscrição estadual.')
+    end
+
+    private 
+    def number_should_modX(mod, at, final = number.size)
+      numberX = number.split(//).map(&:to_i)
+      sum = ModFunctions.sumX(numberX, at, final)
+      
+      divmod = sum.divmod(mod).last
+      digit = divmod <= 1 ? 0 : 11 - divmod
+      return numberX[at + 1].eql?(digit) 
+    end
+
+  end
+  
+end