digit_checksum 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0bce00575ccb77cd11d4b8b8e5304eefac775d7
-  data.tar.gz: fa112bced8ae776bf2eb88fe1cc00f9f5c2edb5a
+  metadata.gz: e098dcc7fc897c32eb09d70d394843796be0da2a
+  data.tar.gz: 6205b777875f7348ec6067b717b12151eb22000d
 SHA512:
-  metadata.gz: 8f6c902340c35cce05da6fabbd2e8a58993e02896afe4d36f9d432af1a2e833275de9537c6b06ea96d8784d221b2a1160f994026454fe909dcc68100594f0ee8
-  data.tar.gz: 3617c00620985d2896eb71d9d5c314e5923c1b46c5f071adca984d73ddd119def3b00ddc7f7cc12cfded433b3a2842dc6178f0cbbdddf1c1f7bcbfcc85a4847b
+  metadata.gz: d1029ae56d3961add0c57d6b9ccd4883457246bd504bf1a7c625fa1d57fb622d5dfd7f1ec2e2daaf6b3c26ded52889f8899cab89b2be82717aa70be2cce8b1ee
+  data.tar.gz: d6d87b10ab1bddc2e0bae2107123d6cc000b5a63f1f0a5c848709bb6ca9469fae3bab49592b26f41819c87a471635169f113a0e47c1a642839928433573bf4f8

data/README.md

@@ -17,7 +17,7 @@ One of the greatest abilitys of this library is allowing to check digit checksum
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'digit_checksum', '~> 0.2.2'
+gem 'digit_checksum', '~> 0.2.3'
 ```
 
 And then execute:
@@ -41,20 +41,18 @@ Don't you believe me? See for yourself an example:
 require 'digit_checksum'
 
 class CNPJ < DigitChecksum::BaseDocument
-  # weights masks that will be used to calculate each check digit
   set_verify_digits_weights first:  %w(5 4 3 2 9 8 7 6 5 4 3 2),
-                     				second: %w(6 5 4 3 2 9 8 7 6 5 4 3 2)
+                            second: %w(6 5 4 3 2 9 8 7 6 5 4 3 2)
+
+  # MOD 11
+  set_division_modulo 11
 
   # remove any non digit from document number
   set_clear_number_regexp %r{[^(\d+)]}
 
-  # use modulo 11 as algorithm (can be any value)
-  set_division_factor_modulo 11
-
   # match format such as: 99.999.999/9999-99 | 99-999-999/9999-99 | 99999999/999999 | 99999999999999
-  set_valid_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
+  set_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
 
-  # mask utilized to prettify doc number
   set_pretty_format_mask %(%s.%s.%s/%s-%s)
 
   # numbers sampled to generate new document numbers
@@ -72,7 +70,7 @@ CNPJ.generate # "79.552.921/0786-55"
 # without pretty formating
 CNPJ.generate(false)  # 85215313606778
 
-# You can calculate only random root numbers
+# You can generate only random root numbers
 root_numbers = CNPJ.generate_root_numbers
 # => [3, 8, 9, 3, 2, 5, 9, 5, 0, 2, 6, 6]
 
@@ -81,7 +79,8 @@ CNPJ.calculate_verify_digits(root_numbers) # [6,7]
 # To insert the verify digits in the CORRECT positions
 # Remember: The correct position MAY NOT be the last positions
 # So use `append_verify_digits` to handle this
-CNPJ.pretty(CNPJ.append_verify_digits(root_numbers))
+
+CNPJ.pretty(CNPJ.append_verify_digits!(root_numbers))
 => "38.932.595/0266-67"
 ```
 
@@ -94,19 +93,13 @@ CNPJ.calculate_verify_digits("123.456.78/0001") # [9,5]
 # invalid format
 CNPJ.calculate_verify_digits("123.456.78/00001") # []
 
-CNPJ.pretty(CNPJ.append_verify_digits("123.456.78/0001")) # "123.456.78/0001-95"
+CNPJ.pretty(CNPJ.append_verify_digits!("12.345.678/0001")) # "12.345.678/0001-95
 
 document = "123.456.78/0001-95"
-CNPJ.remove_verify_digits!(document)
-# [9,5]
-document
-# => 123456780001
-CNPJ.pretty(CNPJ.append_verify_digits(document))
-# => "12.345.678/0001-95"
+CNPJ.remove_verify_digits!(document) => # [9,5]
+document # => 123456780001
 
-# The last two characters position
-CNPJ.obtain_verify_digits_positions
-# => [12, 13]
+CNPJ.pretty(CNPJ.append_verify_digits!(document)) # => "12.345.678/0001-95"
 
 ```
 
@@ -115,12 +108,12 @@ CNPJ.obtain_verify_digits_positions
 # convenience methods to check if document is valid
 
 # invalid format
-CNPJ.valid?("123.456.78/0001") # false
-CNPJ.invalid?("123.456.78/0001") # true
+CNPJ.valid?("123.456.78/0001") # => false
+CNPJ.invalid?("123.456.78/0001") # => true
 
 # valid format
-CNPJ.valid?("123.456.78/0001-95") # true
-CNPJ.valid?(12345678000195) # true
+CNPJ.valid?("123.456.78/0001-95") # => true
+CNPJ.valid?(12345678000195) # => true
 
 ```
 
@@ -129,20 +122,18 @@ CNPJ.valid?(12345678000195) # true
 ```ruby
 
 # Get a array representation of document number
-CNPJ.normalize_number("123.456.78/0001-95")
+CNPJ.normalize("123.456.78/0001-95")
 # => [1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 1, 9, 5]
 
 # also aliased as CNPJ.pretty_formatted(number) or CNPJ.formatted(number)
 CNPJ.pretty("12345678000195") # "123.456.78/0001-95"
 
 # also aliased as CNPJ.clear_number(number)
-CNPJ.stripped("123.456.78/0001-95")
-# => "12345678000195"
+CNPJ.strip("123.456.78/0001-95") # => "12345678000195"
 ```
 
 See `examples/`for more detailed samples.
 
-
 ---
 
 ### Custom verify digits positions
@@ -152,48 +143,106 @@ to calculate check digits in any position in the middle of the document number,
 
 ```ruby
 class MyDocument < DigitChecksum::BaseDocument
-  set_division_factor_modulo 11
+
+  set_division_modulo 11
 
   set_clear_number_regexp %r{[^(\d+)]}
 
-  set_root_documents_digits_count 10
+  set_root_digits_count 10
 
   set_verify_digits_positions [8, 11]
 
   set_verify_digits_weights first: %w(1 3 4 5 6 7 8 10),
                             last:  %w(3 2 10 9 8 7 6 5 4 3 2)
 
-  set_valid_format_regexp %r{(\d{3})[-.]?(\d{3})[-.]?(\d{3})[-.]?(\d{3})}
+  set_format_regexp %r{(\d{3})[-.]?(\d{3})[-.]?(\d{3})[-.]?(\d{3})}
 
   set_pretty_format_mask %(%s.%s.%s.%s)
 
   set_generator_numbers (0..9).to_a
 end
 
-MyDocument.obtain_verify_digits_positions # [8, 11]
+
+MyDocument.get_verify_digits_positions # [8, 11]
+
 # document number without check digits
-MyDocument.calculate_verify_digits("110.042.49.11")
-# => [1, 3]
-document = MyDocument.append_verify_digits("110.042.49.11")
+MyDocument.calculate_verify_digits("110.042.49.11") # => [1, 3]
+
+document = MyDocument.append_verify_digits!("110.042.49.11")
 # => "110042491113"
-MyDocument.pretty(document)
-# => "110.042.491.113"
-MyDocument.remove_verify_digits!(document)
-# => [1, 3]
-document
-# => "1100424911"
-document = MyDocument.append_verify_digits(document)
+
+MyDocument.pretty(document) # => "110.042.491.113"
+
+MyDocument.remove_verify_digits!(document) # => [1, 3]
+
+document # => "1100424911"
+document = MyDocument.append_verify_digits!(document)
+
 # => "110042491113"
-MyDocument.pretty(document)
-# => "110.042.491.113"
+MyDocument.pretty(document) # => "110.042.491.113"
+
 # document number with check digits in the right positions(8, 11)
-MyDocument.valid?("110.042.491.113")
-# => true
+MyDocument.valid?("110.042.491.113") # => true
+
 # document number with wrong check digits in the right positions
-MyDocument.valid?("110.042.492.113")
-# => false
-MyDocument.pretty(MyDocument.append_verify_digits("110.042.49.11"))
+MyDocument.valid?("110.042.492.113") # => false
+
+MyDocument.pretty(MyDocument.append_verify_digits!("110.042.49.11"))
 # => "110.042.491.113"
+
+doc = MyDocument.generate # => "286.670.374.780"
+
+MyDocument.valid?(doc) # =: true
+```
+
+---
+
+## PORO - Plain Old Ruby Objects API
+
+All API demonstrated in this documentation (mostly class methods call) are **simple instance methods delegations to a Ruby object instance**, you can work directly with objects in this way:
+
+```ruby
+object = CNPJ.new("53.091.177/2847-09")
+
+object.valid? # true
+
+# Try to get verify digits without calculating
+# Just search in the right positions in number
+object.current_verify_digits # [0, 9]
+
+# Permanently remove verify digits from number
+object.remove_verify_digits! # [0, 9]
+
+# Try to get verify digits without calculating
+object.current_verify_digits # []
+
+object.number # object.to_s => "530911772847"
+
+object.valid? # false
+
+# Just calculate the verify digits, dont append to number
+object.calculate_verify_digits # [0, 9]
+
+# Use the `calculate_verify_digits` methods and append the digits in the RIGHT positions
+object.append_verify_digits! # "53091177284709"
+
+object.pretty # => "53.091.177/2847-09"
+
+object.normalize
+# => [5, 3, 0, 9, 1, 1, 7, 7, 2, 8, 4, 7, 0, 9]
+
+object.strip # "53091177284709"
+
+object.size # 14
+
+object.root_digits_count # 12
+
+object.verify_digits_count # 2
+
+# root_digits_count + verify_digits_count
+object.full_size # 14
+
+object.verify_digits_positions # [12, 13]
 ```
 
 ---

data/examples/brazilian_cnpj.rb

@@ -3,13 +3,13 @@ class CNPJ < DigitChecksum::BaseDocument
                             second: %w(6 5 4 3 2 9 8 7 6 5 4 3 2)
 
   # MOD 11
-  set_division_factor_modulo 11
+  set_division_modulo 11
 
   # remove any non digit from document number
   set_clear_number_regexp %r{[^(\d+)]}
 
   # match format such as: 99.999.999/9999-99 | 99-999-999/9999-99 | 99999999/999999 | 99999999999999
-  set_valid_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
+  set_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
 
   set_pretty_format_mask %(%s.%s.%s/%s-%s)
 
@@ -25,5 +25,5 @@ CNPJ.valid?(69739073000104) # true
 CNPJ.valid?("38.485.271/0001-57") # true
 
 CNPJ.calculate_verify_digits("423.819.53/0001") # [9,7]
-CNPJ.pretty_formatted("69739073000104") # "69.739.073/0001-04"
-CNPJ.clear_document_number("38.485.271/0001-57") # 38485271000157
+CNPJ.pretty("69739073000104") # "69.739.073/0001-04"
+CNPJ.strip("38.485.271/0001-57") # 38485271000157

data/examples/brazilian_cpf.rb

@@ -3,13 +3,13 @@ class CPF < DigitChecksum::BaseDocument
                             second: %w(11 10 9 8 7 6 5 4 3 2)
 
   # MOD 11
-  set_division_factor_modulo 11
+  set_division_modulo 11
 
   # remove any non digit from document number
   set_clear_number_regexp %r{[^(\d+)]}
 
   # match format such as: 999.999.999-99 | 999-999-999-99 | 99999999999
-  set_valid_format_regexp %r{(\d{3})[-.]?(\d{3})[-.]?(\d{3})[-.]?(\d{2})}
+  set_format_regexp %r{(\d{3})[-.]?(\d{3})[-.]?(\d{3})[-.]?(\d{2})}
 
   set_pretty_format_mask %(%s.%s.%s-%s)
 
@@ -25,5 +25,5 @@ CPF.valid?(31777259185) # true
 CPF.valid?("315.844.227-26") # true
 
 CPF.calculate_verify_digits("315.844.227") # [2, 6]
-CPF.pretty_formatted("31777259185") # "315.844.227-26"
-CPF.clear_document_number("315.844.227-26")
+CPF.pretty("31777259185") # "315.844.227-26"
+CPF.strip("315.844.227-26") # 31584422726

data/examples/h4ck.rb

@@ -12,7 +12,7 @@ class H4ck < DigitChecksum::BaseDocument
 
   PROGRAMMINGS_LANGUAGES.default = 'Unknown'
 
-  set_division_factor_modulo 11
+  set_division_modulo 11
 
   set_verify_digits_weights first:  %w(17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2),
                             second: %w(18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2),
@@ -23,7 +23,7 @@ class H4ck < DigitChecksum::BaseDocument
 
   # 0101&&1111(0x01)||[16]<07>!29
   # Ex: 0101&&1111(0x01)||[16]<07>!29-110
-  set_valid_format_regexp %r{(\d{4})(\d{4})\(?[0x]?(\d{2})\)?\|?\|?\[?(\d{2})\]?\<?(\d{2})\>?\!?(\d{2})\-?(\d{3})}
+  set_format_regexp %r{(\d{4})(\d{4})\(?[0x]?(\d{2})\)?\|?\|?\[?(\d{2})\]?\<?(\d{2})\>?\!?(\d{2})\-?(\d{3})}
 
   # XXXX&&XXXX(0xZZ)||[YY]<MM>!DD-VVV;
   set_pretty_format_mask %(%s&&%s(0x%s)||[%s]<%s>!%s-%s;)
@@ -31,9 +31,8 @@ class H4ck < DigitChecksum::BaseDocument
   # numbers sampled to generate new document numbers
   set_generator_numbers (0..9).to_a
 
-  def self.favorite_language(document_number)
-    document_number = normalize_document_number(document_number)
-    languange_identifier = document_number[8..9].join
+  def favorite_language
+    languange_identifier = normalize[8..9].join
 
     PROGRAMMINGS_LANGUAGES[languange_identifier]
   end
@@ -45,11 +44,11 @@ invalid_doc_number = "0101&&1111(0x01)||[16]<07>!29-841"
 
 H4ck.generate
 H4ck.valid?(H4ck.generate)
-H4ck.normalize_document_number_to_s(root_doc_number) # "0101111101160729"
+H4ck.strip(root_doc_number) # "0101111101160729"
 H4ck.calculate_verify_digits(root_doc_number) # [8,4,0]
 H4ck.valid?(root_doc_number) # false
 H4ck.valid?(valid_doc_number) # true
 H4ck.valid?(invalid_doc_number) # false
 
-H4ck.favorite_language(valid_doc_number) # C#
-H4ck.favorite_language("0101&&1111(0x04)||[16]<07>!29-840") # Python
+H4ck.new(valid_doc_number).favorite_language # C#
+H4ck.new("0101&&1111(0x04)||[16]<07>!29-840").favorite_language # Python

data/lib/digit_checksum.rb

@@ -1,5 +1,12 @@
 require "digit_checksum/version"
 require "digit_checksum/base_document"
+require "digit_checksum/helpers"
+require "digit_checksum/delegators"
 
 module DigitChecksum
+  class BaseDocument
+
+    extend Helpers
+
+  end
 end

data/lib/digit_checksum/base_document.rb

@@ -1,219 +1,217 @@
 module DigitChecksum
   class BaseDocument
 
-    CONSTANTS_MAP = [
-      :root_documents_digits_count,
+    CLASS_METHODS = [
       :verify_digits_positions,
       :digits_ignore_positions,
-      :division_factor_modulo,
       :verify_digits_weights,
       :clear_number_regexp,
-      :valid_format_regexp,
+      :root_digits_count,
       :pretty_format_mask,
       :generator_numbers,
-      :document_length
+      :division_modulo,
+      :document_length,
+      :format_regexp
     ]
 
-    class << self
-      def generate(formatted = true)
-        document_number = append_verify_digits(generate_root_numbers)
-
-        formatted ? pretty_formatted(document_number) : document_number
+    CLASS_METHODS.each do |const_name|
+      define_singleton_method "get_#{const_name}" do
+        self.const_get(const_name.to_s.upcase)
       end
 
-      def append_verify_digits(document_number)
-        document_number = normalize_number(document_number)
-        verify_digits = calculate_verify_digits(document_number)
-
-        obtain_verify_digits_positions.each_with_index {|position, index|
-          document_number.insert(position + index, verify_digits.shift)
-        }
-
-        normalize_number_to_s(document_number.compact)
+      define_singleton_method "set_#{const_name}" do |value|
+        self.const_set(const_name.to_s.upcase, value).freeze
       end
 
-      def generate_root_numbers
-        root_document_digits_count.times.map { get_generator_numbers.sample }
+      define_method "get_#{const_name}" do
+        self.class.const_get(const_name.to_s.upcase)
       end
+    end
 
-      def valid?(document_number)
-        # remove all non digits and return an string to be matched with mask
-        normalized_document = normalize_number_to_s(document_number)
+    attr_accessor :number
 
-        # if document is empty
-        return false if normalized_document.nil? || normalized_document.empty?
+    def initialize(number)
+      @number = stripped(number)
+    end
 
-        # if document dont match the exact size, it's invalid
-        return false unless valid_length?(normalized_document)
+    def valid?
+      # if document is empty or dont match the exact size, it's invalid
+      return false if (empty? || !valid_length?)
 
-        # remove verify digits to be verified
-        verify_digits = remove_verify_digits!(normalized_document)
+      # match current verify digits with calculate through modulo operation
+      current_verify_digits == calculate_verify_digits
+    end
 
-        # calculate the new digits based on root document number
-        digits = calculate_verify_digits(normalized_document)
+    def invalid?
+      !valid?
+    end
 
-        verify_digits == digits
-      end
+    def empty?
+      @number.nil? || @number.empty?
+    end
 
-      def remove_verify_digits!(document_number)
-        document_number.gsub!(get_clear_number_regexp, '')
+    def valid_length?
+      size == full_size
+    end
 
-        obtain_verify_digits_positions.each_with_index.flat_map {|position, index|
-          document_number.slice!((position - index), 1)
-        }.map(&:to_i)
-      end
+    def full_size
+      (root_digits_count + verify_digits_count)
+    end
 
-      def obtain_verify_digits_positions
-        begin
-          get_verify_digits_positions
-        # when value its not set
-        rescue NameError => e
-          default_verify_digits_position
-        end
-      end
+    def size
+      normalize.length
+    end
 
-      def default_verify_digits_position
-        verify_digits_count.times.map {|i| root_document_digits_count + i  }
-      end
+    alias :length :size
 
-      def invalid?(document_number)
-        !valid?(document_number)
-      end
+    def current_verify_digits
+      remove_verify_digits(@number.dup)
+    end
 
-      def calculate_verify_digits(document_number)
-        return [] unless correct_length_based_on_first_mask?(document_number)
+    def calculate_verify_digits
+      number = without_verify_digits(@number)
+      digits = []
+      digits_positions = verify_digits_positions.dup
 
-        document_number = normalize_number(document_number)
-        division_modulo = get_division_factor_modulo
-        digits_positions = obtain_verify_digits_positions.dup
-        digits = []
+      return [] unless number.size == root_digits_count
 
-        get_verify_digits_weights.each_with_index do |data, index|
-          position, mask = *data
-          current_document = root_document_number(document_number, mask)
-          verify_digit = calculate_verify_digit(current_document, mask, division_modulo)
+      get_verify_digits_weights.each_with_index do |data, index|
+        position, weights = *data
 
-          digits << verify_digit
-          digit_position = digits_positions.shift + index
+        current_number = normalized(number, weights.size)
+        verify_digit = calculate_verify_digit(current_number, weights)
 
-          # just update ref
-          document_number.insert(digit_position, verify_digit)
-        end
+        # just update ref to calculate next digit
+        number.insert((digits_positions.shift + index), verify_digit)
 
-        digits
+        digits << verify_digit
       end
 
-      def root_document_number(document_number, mask = nil)
-        mask ||= get_verify_digits_weights.values[0]
+      digits
+    end
 
-        normalize_document_number(document_number, mask.size)
-      end
+    def remove_verify_digits!
+      remove_verify_digits(@number)
+    end
 
-      def root_document_number_to_s(document_number, mask = nil)
-        root_document_number(document_number, mask).join
-      end
+    def append_verify_digits!
+      digits = calculate_verify_digits
 
-      def normalize_document_number(document_number, length = nil)
-        document_number = clear_document_number(document_number).split(//).map(&:to_i)
+      if (!valid_length? && digits != current_verify_digits)
+        @number = normalize
 
-        length.nil? ? document_number : document_number[0, length]
+        verify_digits_positions.each_with_index.flat_map {|position, index|
+          # position + index
+          @number.insert(position, digits.shift)
+        }
       end
 
-      def normalize_document_number_to_s(document_number, length = nil)
-        normalize_document_number(document_number, length).join
-      end
+      @number = stripped(@number)
+    end
 
-      def clear_document_number(document_number)
-        document_number.to_s.gsub(get_clear_number_regexp, '')
-      end
+    def normalize
+      normalized(@number)
+    end
+
+    def pretty
+      numbers = @number.to_s.scan(get_format_regexp).flatten
+      numbers.empty? ? '' : (get_pretty_format_mask % numbers)
+    end
 
-      def pretty_formatted(document_number)
-        normalized_doc = normalize_number_to_s(document_number)
+    def strip
+      stripped(@number)
+    end
 
-        return "" if normalized_doc.empty?
+    def to_s
+      @number
+    end
 
-        numbers = normalized_doc.to_s.scan(get_valid_format_regexp).flatten
+    def verify_digits_count
+      get_verify_digits_weights.size
+    end
 
-        # document has a value but it's not valid
-        return "" if numbers.empty?
+    def root_digits_count
+      self.class.root_digits_count
+    end
 
-        get_pretty_format_mask % numbers
+    def verify_digits_positions
+      begin
+        get_verify_digits_positions
+      # when value its not set
+      rescue NameError => e
+        default_verify_digits_position
       end
+    end
 
-      def calculate_verify_digit(document_number, mask, division_factor)
-        digits = calculate_digits_data(document_number, mask, division_factor)
+    alias :as_array :normalize
+    alias :clear :strip
+    alias :formatted :pretty
 
-        digits[:verify_digit].to_i
-      end
+    private
+    def stripped(number)
+      number.to_s.gsub(get_clear_number_regexp, '')
+    end
 
-      def calculate_digits_data(document_number, mask, division_factor)
-        sum = calculate_digits_sum(document_number, mask)
-        quotient = (sum / division_factor)
+    def normalized(number, length = nil)
+      number = stripped(number).split(//).map(&:to_i)
 
-        rest = calculate_digits_sum_rest(sum, quotient, division_factor)
+      length.nil? ? number : number[0, length]
+    end
 
-        { sum: sum, quotient: quotient, rest: rest, verify_digit: digit_verify(rest, division_factor) }
-      end
+    def remove_verify_digits(number)
+      return [] unless number.size == full_size
 
-      def calculate_digits_sum_rest(sum, quotient, division_factor)
-        (sum % division_factor)
-      end
+      verify_digits_positions.each_with_index.flat_map {|position, index|
+        number.slice!(position - index, 1)
+      }.map(&:to_i)
+    end
 
-      def calculate_digits_sum(document_number, mask)
-        normalized_document_number = normalize_document_number(document_number)
+    def without_verify_digits(number)
+      number = normalized(number)
 
-        normalized_document_number.each_with_index.map {|n,i| n.to_i * mask[i].to_i }.reduce(:+).to_f
-      end
+      return number unless number.size == full_size
 
-      def digit_verify(quotient_rest, division_factor)
-        rest = (division_factor - quotient_rest).to_i
+      remove_verify_digits(number) and number
+    end
 
-        # if rest has two digits(checkdigit must be a single digit), force 0
-        return 0 if rest >= 10
+    def default_verify_digits_position
+      verify_digits_count.times.map {|i| root_digits_count + i  }
+    end
 
-        rest
-      end
+    def calculate_verify_digit(number, weights)
+      data = calculate_digits_data(number, weights)
 
-      def first_verify_mask
-        get_verify_digits_weights.values[0]
-      end
+      calc_verify_digit(data[:rest])
+    end
 
-      def verify_digits_count
-        get_verify_digits_weights.size
-      end
+    def calculate_digits_data(number, weights)
+      sum = reduce_digits_weights(number, weights)
+      quotient = (sum / get_division_modulo)
+      rest = calculate_rest(sum, quotient)
 
-      def root_document_digits_count
-        begin
-          get_root_documents_digits_count
-        rescue NameError => e
-          first_verify_mask.size
-        end
-      end
+      { sum: sum, quotient: quotient, rest: rest }
+    end
 
-      def correct_length_based_on_first_mask?(document_number)
-        normalize_document_number(document_number).size == root_document_digits_count
-      end
+    def reduce_digits_weights(number, weights)
+      number = normalized(number)
 
-      def valid_length?(document_number)
-        normalize_document_number(document_number).size == root_document_digits_count + verify_digits_count
-      end
+      number.each_with_index.map {|n,i|
+        n.to_i * weights[i].to_i
+      }.reduce(:+).to_f
+    end
 
-      alias :normalize_number_to_s :normalize_document_number_to_s
-      alias :normalize_number :normalize_document_number
-      alias :clear_number :clear_document_number
-      alias :stripped :clear_document_number
-      alias :formatted :pretty_formatted
-      alias :pretty :pretty_formatted
-
-      CONSTANTS_MAP.each do |const_name|
-        define_method "get_#{const_name}" do
-          self.const_get(const_name.to_s.upcase)
-        end
-
-        define_method "set_#{const_name}" do |value|
-          self.const_set(const_name.to_s.upcase, value)
-        end
-      end
+    def calculate_rest(sum, quotient)
+      (sum % get_division_modulo)
     end
+
+    def calc_verify_digit(quotient_rest)
+      rest = (get_division_modulo - quotient_rest).to_i
+
+      # if rest has two digits(checkdigit must be a single digit), force 0
+      return 0 if rest >= 10
+
+      rest
+    end
+
   end
 end

data/lib/digit_checksum/delegators.rb

@@ -0,0 +1,25 @@
+module DigitChecksum
+  class BaseDocument
+
+    CLASS_METHODS_DELEGATES = [
+      :valid?,
+      :invalid?,
+      :pretty,
+      :strip,
+      :normalize,
+      :as_array,
+      :formatted,
+      :clear,
+      :remove_verify_digits!,
+      :append_verify_digits!,
+      :calculate_verify_digits,
+      :valid_length?
+    ]
+
+    CLASS_METHODS_DELEGATES.each do |method_name|
+      define_singleton_method method_name do |number|
+        new(number).public_send(method_name)
+      end
+    end
+  end
+end

data/lib/digit_checksum/helpers.rb

@@ -0,0 +1,33 @@
+module DigitChecksum
+  module Helpers
+    def generate(pretty = true)
+      number = new(generate_root_numbers)
+      number.append_verify_digits!
+
+      pretty ? number.pretty : number.to_s
+    end
+
+    def generate_root_numbers
+      root_digits_count.times.map { get_generator_numbers.sample }
+    end
+
+    def root_digits_count
+      begin
+        get_root_digits_count
+      rescue NameError => e
+        first_verify_mask = get_verify_digits_weights.values[0]
+        first_verify_mask.size
+      end
+    end
+
+    def root_number(number, mask = nil)
+      mask ||= get_verify_digits_weights.values[0]
+
+      new(number).normalize.slice(0, mask.size)
+    end
+
+    def root_number_to_s(number, mask = nil)
+      root_number(number, mask).join
+    end
+  end
+end

data/lib/digit_checksum/version.rb

@@ -1,3 +1,3 @@
 module DigitChecksum
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digit_checksum
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Rafael Fidelis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-08 00:00:00.000000000 Z
+date: 2016-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,6 +90,8 @@ files:
 - examples/h4ck.rb
 - lib/digit_checksum.rb
 - lib/digit_checksum/base_document.rb
+- lib/digit_checksum/delegators.rb
+- lib/digit_checksum/helpers.rb
 - lib/digit_checksum/version.rb
 homepage: https://github.com/fidelisrafael/digit_checksum
 licenses: