digit_checksum 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 175e4e3a36c8e9303127d13650327da966e13629
-  data.tar.gz: 474383c0dd57977a2038c667de810a3a1603d9fc
+  metadata.gz: a7758954adbce872ca492737d6848987a4e0c3e4
+  data.tar.gz: 656edafd10e3c9c70658cfa7ee2fae30072a3c7e
 SHA512:
-  metadata.gz: 71834735b4c85da42ff05ef937a24a039d21ce4d733ac5ddcd4ba2050446656176d5de3b3031a14296032a41db238f399e7f633e588284c33e2367aeba57ba8f
-  data.tar.gz: b53f86b1bdd6a7d06f1ef77950b6aa14e23cb4d5cae061de9cb2d0e4b0a6454d04a144576e4d0632d2a6d621fe30c44848532947b62dba9ded031de6baaf8972
+  metadata.gz: fd65ebf917f946649b808035ef6db3949114c998bca7b81e0a53f9e917bd50aec6e90aa5217179143677c721faab6f0f9094445bad8840a7a7e415c719a9ea01
+  data.tar.gz: 3125454badcd0a2773719736d3b638c4fa1e9061c270936f9af8a2baef1a8a9b90e2eb70bcdbaecf292ba992c26a64ce86f5e49691546da623eb3da2534ece1e

data/README.md

@@ -1,9 +1,12 @@
 # DigitCheckSum
 
+[![Build Status](https://travis-ci.org/fidelisrafael/digit_checksum.svg)](https://travis-ci.org/fidelisrafael/digit_checksum)
+
 Hi there, I'm glad you're looking in this gem!
 The aim of this gem is to allow **any kind** of document to be validated e generated through calculation of [**Check Digit/Digit Checksum**](https://en.wikipedia.org/wiki/Check_digit).
 
 What this mean? This mean that you can **validate** and **generate fake numbers** of any kind of documents such: **Passport numbers**, **Federal ID number**, **Books ISBN**, or even **create your own document** number, check `examples/` for more details.
+One of the greatest abilitys of this library is allowing to check digit checksum of digits in **ANY POSITION** of the document, not only for the last digits.
 
 **Tip**: Check [`examples/h4ck.rb`](examples/h4ck.rb) to see `h4ck` document specification, this is a sample document who can be manipulated using this library!
 
@@ -14,7 +17,7 @@ What this mean? This mean that you can **validate** and **generate fake numbers*
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'digit_checksum'
+gem 'digit_checksum', '~> 0.2.0'
 ```
 
 And then execute:
@@ -38,25 +41,24 @@ Don't you believe me? See for yourself an example:
 require 'digit_checksum'
 
 class CNPJ < DigitChecksum::BaseDocument
-  # masks that will be used to calculate each check digit
-  digits_verify_mask 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)
+  # 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)
 
   # remove any non digit from document number
-  # this is the default value, feel free to override
-  clear_number_regexp %r{[^(\d+)]}
+  set_clear_number_regexp %r{[^(\d+)]}
 
   # use modulo 11 as algorithm (can be any value)
-  division_factor_modulo 11
+  set_division_factor_modulo 11
 
   # match format such as: 99.999.999/9999-99 | 99-999-999/9999-99 | 99999999/999999 | 99999999999999
-  valid_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
+  set_valid_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
 
   # mask utilized to prettify doc number
-  pretty_format_mask %(%s.%s.%s/%s-%s)
+  set_pretty_format_mask %(%s.%s.%s/%s-%s)
 
   # numbers sampled to generate new document numbers
-  generator_numbers (0..9).to_a
+  set_generator_numbers (0..9).to_a
 end
 ```
 
@@ -67,8 +69,20 @@ The example below it's intent to validated brazilian `CNPJ` documents, equivalen
 ```ruby
 CNPJ.generate # "79.552.921/0786-55"
 
-CNPJ.generate(false)  # 85215313606778 -- without pretty formating
+# without pretty formating
+CNPJ.generate(false)  # 85215313606778
+
+# You can calculate only random root numbers
+root_numbers = CNPJ.generate_root_numbers
+# => [3, 8, 9, 3, 2, 5, 9, 5, 0, 2, 6, 6]
 
+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))
+=> "38.932.595/0266-67"
 ```
 
 
@@ -79,6 +93,21 @@ 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"
+
+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"
+
+# The last two characters position
+CNPJ.obtain_verify_digits_positions
+# => [12, 13]
+
 ```
 
 #### Validate documents numbers
@@ -98,33 +127,90 @@ CNPJ.valid?(12345678000195) # true
 #### Normalize and format documents number
 
 ```ruby
-# belows returns [1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 1, 9, 5]
-CNPJ.normalize_number("123.456.78/0001-95") 
 
-CNPJ.normalize_number_to_s("123.456.78/0001-95") # "12345678000195"
+# Get a array representation of document number
+CNPJ.normalize_number("123.456.78/0001-95")
+# => [1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 1, 9, 5]
 
-CNPJ.pretty_formatted("123456780001") # "123.456.78/0001-95" -- also aliased as CNPJ.pretty(number) or CNPJ.formatted(number)
+# also aliased as CNPJ.pretty_formatted(number) or CNPJ.formatted(number)
+CNPJ.pretty("12345678000195") # "123.456.78/0001-95"
 
-CNPJ.clear_number("123.456.78/0001-95") # "12345678000195" -- also aliased as CNPJ.stripped(number)
+# also aliased as CNPJ.clear_number(number)
+CNPJ.stripped("123.456.78/0001-95")
+# => "12345678000195"
 ```
 
 See `examples/`for more detailed samples.
 
 
+---
+
+### Custom verify digits positions
+
+In **most**(*but not necessarily all*) documents formats the check digits positions are the last characters, but this library also allow you
+to calculate check digits in any position in the middle of the document number, see an example:
+
+```ruby
+class MyDocument < DigitChecksum::BaseDocument
+  set_division_factor_modulo 11
+
+  set_clear_number_regexp %r{[^(\d+)]}
+
+  set_root_documents_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_pretty_format_mask %(%s.%s.%s.%s)
+
+  set_generator_numbers (0..9).to_a
+end
+
+MyDocument.obtain_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")
+# => "110042491113"
+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"
+# document number with check digits in the right positions(8, 11)
+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"))
+# => "110.042.491.113"
+```
+
+---
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`.   
+To install this gem onto your local machine, run `bundle exec rake install`.
 To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/fidelisrafael/digit_checksum.   
+Bug reports and pull requests are welcome on GitHub at https://github.com/fidelisrafael/digit_checksum.
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/examples/brazilian_cnpj.rb

@@ -1,20 +1,20 @@
 class CNPJ < DigitChecksum::BaseDocument
-  digits_verify_mask 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)
+  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)
 
   # MOD 11
-  division_factor_modulo 11
+  set_division_factor_modulo 11
 
   # remove any non digit from document number
-  clear_number_regexp %r{[^(\d+)]}
+  set_clear_number_regexp %r{[^(\d+)]}
 
   # match format such as: 99.999.999/9999-99 | 99-999-999/9999-99 | 99999999/999999 | 99999999999999
-  valid_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
+  set_valid_format_regexp %r{(\d{2})[-.]?(\d{3})[-.]?(\d{3})[\/]?(\d{4})[-.]?(\d{2})}
 
-  pretty_format_mask %(%s.%s.%s/%s-%s)
+  set_pretty_format_mask %(%s.%s.%s/%s-%s)
 
   # numbers sampled to generate new document numbers
-  generator_numbers (0..9).to_a
+  set_generator_numbers (0..9).to_a
 end
 
 CNPJ.generate

data/examples/brazilian_cpf.rb

@@ -1,20 +1,20 @@
 class CPF < DigitChecksum::BaseDocument
-  digits_verify_mask first:  %w(10 9 8 7 6 5 4 3 2),
-                     second: %w(11 10 9 8 7 6 5 4 3 2)
+  set_verify_digits_weights first:  %w(10 9 8 7 6 5 4 3 2),
+                            second: %w(11 10 9 8 7 6 5 4 3 2)
 
   # MOD 11
-  division_factor_modulo 11
+  set_division_factor_modulo 11
 
   # remove any non digit from document number
-  clear_number_regexp %r{[^(\d+)]}
+  set_clear_number_regexp %r{[^(\d+)]}
 
   # match format such as: 999.999.999-99 | 999-999-999-99 | 99999999999
-  valid_format_regexp %r{(\d{3})[-.]?(\d{3})[-.]?(\d{3})[-.]?(\d{2})}
+  set_valid_format_regexp %r{(\d{3})[-.]?(\d{3})[-.]?(\d{3})[-.]?(\d{2})}
 
-  pretty_format_mask %(%s.%s.%s-%s)
+  set_pretty_format_mask %(%s.%s.%s-%s)
 
   # numbers sampled to generate new document numbers
-  generator_numbers (0..9).to_a
+  set_generator_numbers (0..9).to_a
 end
 
 CPF.generate

data/examples/h4ck.rb

@@ -12,24 +12,24 @@ class H4ck < DigitChecksum::BaseDocument
 
   PROGRAMMINGS_LANGUAGES.default = 'Unknown'
 
-  division_factor_modulo 11
+  set_division_factor_modulo 11
 
-  digits_verify_mask 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),
-                     last:   %w(19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2)
+  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),
+                            last:   %w(19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2)
 
   # remove any non digit and 0x character from document number
-  clear_number_regexp %r{(0x)|[^\d+]}
+  set_clear_number_regexp %r{(0x)|[^\d+]}
 
   # 0101&&1111(0x01)||[16]<07>!29
   # Ex: 0101&&1111(0x01)||[16]<07>!29-110
-  valid_format_regexp %r{(\d{4})(\d{4})\(?[0x]?(\d{2})\)?\|?\|?\[?(\d{2})\]?\<?(\d{2})\>?\!?(\d{2})\-?(\d{3})}
+  set_valid_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;
-  pretty_format_mask %(%s&&%s(0x%s)||[%s]<%s>!%s-%s;)
+  set_pretty_format_mask %(%s&&%s(0x%s)||[%s]<%s>!%s-%s;)
 
   # numbers sampled to generate new document numbers
-  generator_numbers (0..9).to_a
+  set_generator_numbers (0..9).to_a
 
   def self.favorite_language(document_number)
     document_number = normalize_document_number(document_number)

data/lib/digit_checksum/base_document.rb

@@ -2,22 +2,38 @@ module DigitChecksum
   class BaseDocument
 
     CONSTANTS_MAP = [
-      :digits_verify_mask,
+      :root_documents_digits_count,
+      :verify_digits_positions,
+      :digits_ignore_positions,
       :division_factor_modulo,
-      :valid_format_regexp,
+      :verify_digits_weights,
       :clear_number_regexp,
+      :valid_format_regexp,
       :pretty_format_mask,
-      :generator_numbers
+      :generator_numbers,
+      :document_length
     ]
 
     class << self
       def generate(formatted = true)
-        doc_numbers = root_document_digits_count.times.map { get_generator_numbers.sample }
-        doc_numbers.concat(calculate_verify_digits(doc_numbers))
+        document_number = append_verify_digits(generate_root_numbers)
+
+        formatted ? pretty_formatted(document_number) : document_number
+      end
 
-        normalized_number = normalize_number_to_s(doc_numbers)
+      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)
+      end
 
-        formatted ? pretty_formatted(normalized_number) : normalized_number
+      def generate_root_numbers
+        root_document_digits_count.times.map { get_generator_numbers.sample }
       end
 
       def valid?(document_number)
@@ -28,13 +44,36 @@ module DigitChecksum
         return false if normalized_document.nil? || normalized_document.empty?
 
         # if document dont match the exact size, it's invalid
-        return false unless valid_length?(document_number)
+        return false unless valid_length?(normalized_document)
 
-        # remove last two digits to be verified
-        last_digits = normalized_document.slice!(-verify_digits_count,verify_digits_count).map(&:to_i)
+        # remove verify digits to be verified
+        verify_digits = remove_verify_digits!(normalized_document)
+
+        # calculate the new digits based on root document number
         digits = calculate_verify_digits(normalized_document)
 
-        last_digits == digits
+        verify_digits == digits
+      end
+
+      def remove_verify_digits!(document_number)
+        document_number.to_s.gsub!(get_clear_number_regexp, '')
+
+        obtain_verify_digits_positions.each_with_index.flat_map {|position, index|
+          document_number.slice!((position - index), 1)
+        }.map(&:to_i)
+      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 default_verify_digits_position
+        verify_digits_count.times.map {|i| root_document_digits_count + i  }
       end
 
       def invalid?(document_number)
@@ -44,23 +83,28 @@ module DigitChecksum
       def calculate_verify_digits(document_number)
         return [] unless correct_length_based_on_first_mask?(document_number)
 
+        document_number = normalize_number(document_number)
         division_modulo = get_division_factor_modulo
+        digits_positions = obtain_verify_digits_positions.dup
         digits = []
 
-        get_digits_verify_mask.each do |position, mask|
-          document_number = root_document_number(document_number, mask)
-
-          verify_digit = calculate_verify_digit(document_number, mask, division_modulo)
+        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)
 
           digits << verify_digit
-          document_number << verify_digit
+          digit_position = digits_positions.shift + index
+
+          # just update ref
+          document_number.insert(digit_position, verify_digit)
         end
 
         digits
       end
 
       def root_document_number(document_number, mask = nil)
-        mask ||= get_digits_verify_mask.values[0]
+        mask ||= get_verify_digits_weights.values[0]
 
         normalize_document_number(document_number, mask.size)
       end
@@ -84,9 +128,11 @@ module DigitChecksum
       end
 
       def pretty_formatted(document_number)
-        return "" if normalize_document_number(document_number).empty?
+        normalized_doc = normalize_number_to_s(document_number)
+
+        return "" if normalized_doc.empty?
 
-        numbers = document_number.to_s.scan(get_valid_format_regexp).flatten
+        numbers = normalized_doc.to_s.scan(get_valid_format_regexp).flatten
 
         # document has a value but it's not valid
         return "" if numbers.empty?
@@ -103,11 +149,16 @@ module DigitChecksum
       def calculate_digits_data(document_number, mask, division_factor)
         sum = calculate_digits_sum(document_number, mask)
         quotient = (sum / division_factor)
-        rest = (sum % division_factor)
+
+        rest = calculate_digits_sum_rest(sum, quotient, division_factor)
 
         { sum: sum, quotient: quotient, rest: rest, verify_digit: digit_verify(rest, division_factor) }
       end
 
+      def calculate_digits_sum_rest(sum, quotient, division_factor)
+        (sum % division_factor)
+      end
+
       def calculate_digits_sum(document_number, mask)
         normalized_document_number = normalize_document_number(document_number)
 
@@ -122,15 +173,19 @@ module DigitChecksum
       end
 
       def first_verify_mask
-        get_digits_verify_mask.values[0]
+        get_verify_digits_weights.values[0]
       end
 
       def verify_digits_count
-        get_digits_verify_mask.size
+        get_verify_digits_weights.size
       end
 
       def root_document_digits_count
-        first_verify_mask.size
+        begin
+          get_root_documents_digits_count
+        rescue NameError => e
+          first_verify_mask.size
+        end
       end
 
       def correct_length_based_on_first_mask?(document_number)
@@ -148,17 +203,13 @@ module DigitChecksum
       alias :formatted :pretty_formatted
       alias :pretty :pretty_formatted
 
-      CONSTANTS_MAP.each do |const_identifier|
-        define_method "get_#{const_identifier}" do
-          const_name = const_identifier.to_s.upcase
-
-          self.const_get(const_identifier.upcase)
+      CONSTANTS_MAP.each do |const_name|
+        define_method "get_#{const_name}" do
+          self.const_get(const_name.to_s.upcase)
         end
 
-        define_method const_identifier do |arg|
-          const_name = const_identifier.to_s.upcase
-
-          self.const_set(const_name, arg)
+        define_method "set_#{const_name}" do |value|
+          self.const_set(const_name.to_s.upcase, value)
         end
       end
     end

data/lib/digit_checksum/version.rb

@@ -1,3 +1,3 @@
 module DigitChecksum
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digit_checksum
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Rafael Fidelis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-13 00:00:00.000000000 Z
+date: 2016-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler