barcode1dtools 0.9.2

data/lib/barcode1dtools/upc_supplemental_5.rb

@@ -0,0 +1,246 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'barcode1dtools/upc_a'
+
+module Barcode1DTools
+
+  # Barcode1DTools::UPC_Supplemental_5 - Create pattern for UPC
+  # Supplemental 5 barcodes
+  #
+  # The value encoded is an 5-digit integer, and a checksum digit
+  # will be added.  You can add the option :checksum_included => true
+  # when initializing to specify that you have already included a
+  # checksum.  The bar patterns are the same as the left
+  # half of a standard UPC-A.
+  #
+  # num = '53999'  # book price is US$39.99
+  # bc = Barcode1DTools::UPC_Supplemental_5.new(num)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # bc.price   # returns the "price" part as 4 digits
+  # bc.currency  # returns the first digit currency code
+  # width = bc.width
+  # check_digit = Barcode1DTools::UPC_Supplemental_5.generate_check_digit_for(num)
+  #
+  # This type of barcode consists of 5 digits, and a check digit
+  # (a modulus 10 of the sum of the digits with weights of 3 and
+  # 9) that is encoded in the "parity" of the two barcode
+  # digits.  It is positioned to the right of a UPC-A or EAN-13
+  # to create a "Bookland" code.
+  #
+  # The two are scanned together, and typically the scanner will
+  # return the five digits of the supplemental barcode
+  # immediately following the check digit from the main barcode.
+  # You will likely need to use the Barcode::UPC_A or
+  # Barcode::EAN_13 module in addition to this one to create the
+  # full code.
+  #
+  # The 5-digit supplement is generally used on literature, and
+  # represents a type-indicator digit followed by a 4-digit
+  # MSRP.  The type is "0" for British Pound units, "5" for US
+  # Dollar units, and 9 for extra information.  A code of
+  # "90000" means "no MSRP", "99991" indicates a complimentary
+  # copy, "99990" is used to mark used books (by college
+  # bookstores), and "90001" through "98999" are used internally
+  # by some publishers.
+  #
+  #== Rendering
+  #
+  # The 5-digit supplement is positioned to the right of the
+  # main UPC code, and the human-readable digits are usually
+  # printed above the supplemental barcode.
+  #
+  # A UPC-A is generally rendered at one inch across, then
+  # there's a 1/8th inch gap, then the supplemental.  A UPC-A is
+  # 95 units wide, so the gap is 24 units wide.  The 5-digit
+  # supplemental barcode is 47 units wide, essentially half an
+  # inch at this scale.  Note that regardless of scale, the gap
+  # should be at least the smaller of 1/8th inch or 10 units.
+
+
+  class UPC_Supplemental_5 < Barcode1D
+
+    LEFT_PATTERNS = UPC_A::LEFT_PATTERNS
+    LEFT_PATTERNS_RLE = UPC_A::LEFT_PATTERNS_RLE
+
+    # parity patterns, essentially binary counting where "e" is "1"
+    # and "o" is "0"
+    PARITY_PATTERNS = {
+      '0' => 'eeooo',
+      '1' => 'eoeoo',
+      '2' => 'eooeo',
+      '3' => 'eoooe',
+      '4' => 'oeeoo',
+      '5' => 'ooeeo',
+      '6' => 'oooee',
+      '7' => 'oeoeo',
+      '8' => 'oeooe',
+      '9' => 'ooeoe'
+    };
+
+    LEFT_GUARD_PATTERN = '1011'
+    MIDDLE_GUARD_PATTERN = '01'
+    LEFT_GUARD_PATTERN_RLE = '112'
+    MIDDLE_GUARD_PATTERN_RLE = '11'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0'
+    }
+
+    attr_reader :currency_code
+    attr_reader :price
+
+    class << self
+      # Returns true or false - must be 5 or 6 digits.  This
+      # also handles the case where the leading 0 is added.
+      def can_encode?(value, options = nil)
+        if !options
+          value.to_s =~ /^\d{5,6}$/
+        elsif (options[:checksum_included])
+          value.to_s =~ /^\d{6}$/
+        else
+          value.to_s =~ /^\d{5}$/
+        end
+      end
+
+      # Generates check digit given a string to encode.  It assumes there
+      # is no check digit on the "value".
+      def generate_check_digit_for(value)
+        mult = 9  # alternates 3 and 9
+        sprintf('%05d',value.to_i).reverse.chars.inject(0) { |a,c| mult = 12 - mult; a + c.to_i * mult } % 10
+      end
+
+      # validates the check digit given a string - assumes check digit
+      # is last digit of string.
+      def validate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value, :checksum_included => true)
+        md = value.match(/^(\d{5})(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      def decode(str)
+        if str.length == 47
+          # bar pattern
+          str = bars_to_rle(str)
+        elsif str.length == 31 && str =~ /^[1-9]+$/
+          # rle
+        else
+          raise UnencodableCharactersError, "Pattern must be 47 unit bar pattern or 31 character rle."
+        end
+
+        # This string is "aaabbbb(ccdddd)" where "aaa" is the left
+        # guard pattern, "bbbb" is the first digit, "cc" is the
+        # intra-digit guard pattern, and "dddd" is the second
+        # digit.  (ccdddd) occurs 4 times.
+
+        # See if the string is reversed
+        if str[28..30] == LEFT_GUARD_PATTERN_RLE.reverse && [7,13,19,25].all? { |x| str[29-x,2] == MIDDLE_GUARD_PATTERN_RLE.reverse }
+          str.reverse!
+        end
+
+        # Check the guard patterns
+        unless (str[0..2] == LEFT_GUARD_PATTERN_RLE && [7,13,19,25].all? { |x| str[x,2] == MIDDLE_GUARD_PATTERN_RLE.reverse })
+          raise UnencodableCharactersError, "Missing or incorrect guard patterns"
+        end
+
+        parity_sequence = ''
+        digits = ''
+        left_initial_offset = LEFT_GUARD_PATTERN_RLE.length
+
+        # Decode
+        (0..4).each do |left_offset|
+          found = false
+          digit_rle = str[(left_initial_offset + left_offset*6),4]
+          ['o','e'].each do |parity|
+            ('0'..'9').each do |digit|
+              if LEFT_PATTERNS_RLE[digit][parity] == digit_rle
+                parity_sequence += parity
+                digits += digit
+                found = true
+                break
+              end
+            end
+          end
+          raise UndecodableCharactersError, "Invalid sequence: #{digit_rle}" unless found
+        end
+
+        # Now, find the parity digit
+        parity_digit = nil
+        ('0'..'9').each do |x|
+          if PARITY_PATTERNS[x] == parity_sequence
+            parity_digit = x
+            break
+          end
+        end
+
+        raise UndecodableCharactersError, "Weird parity: #{parity_sequence}" unless parity_digit
+
+        UPC_Supplemental_5.new(digits + parity_digit, :checksum_included => true)
+      end
+
+    end
+
+    # Options are :line_character, :space_character, and
+    # :checksum_included.
+    def initialize(value, options = {})
+
+      @options = DEFAULT_OPTIONS.merge(options)
+
+      # Can we encode this value?
+      raise UnencodableCharactersError unless self.class.can_encode?(value, @options)
+
+      if @options[:checksum_included]
+        @encoded_string = value.to_s
+        raise ChecksumError unless self.class.validate_check_digit_for(@encoded_string)
+        md = @encoded_string.match(/^(\d+?)(\d)$/)
+        @value, @check_digit = md[1], md[2].to_i
+      else
+        # need to add a checksum
+        @value = value.to_s
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = sprintf('%05d%1d',@value.to_i,@check_digit)
+      end
+
+      md = @value.match(/^(\d)(\d{4})/)
+      @currency_code, @price = md[1], md[2]
+    end
+
+    # not usable with EAN-style codes
+    def wn
+      raise NotImplementedError
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      if @rle
+        @rle
+      else
+        md = @encoded_string.match(/(\d{5})(\d)$/)
+        @rle = gen_rle(md[1], md[2])
+      end
+    end
+
+    # returns 1s and 0s (for "black" and "white")
+    def bars
+      @bars ||= self.class.rle_to_bars(self.rle, @options)
+    end
+
+    # returns the total unit width of the bar code
+    def width
+      @width ||= rle.split('').inject(0) { |a,c| a + c.to_i }
+    end
+
+    private
+
+    def gen_rle(payload, parity_digit)
+      LEFT_GUARD_PATTERN_RLE + (0..4).collect { |n| LEFT_PATTERNS_RLE[payload[n,1]][PARITY_PATTERNS[parity_digit][n,1]] }.join(MIDDLE_GUARD_PATTERN_RLE)
+    end
+
+  end
+end

data/test/test_barcode1d.rb

@@ -0,0 +1,56 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsTest < Test::Unit::TestCase
+  def setup
+    @options = {}
+  end
+
+  def teardown
+  end
+
+  def test_rle_to_bars
+    assert_equal '111001', Barcode1DTools::Barcode1D.rle_to_bars('321', @options)
+    assert_equal '10011100001', Barcode1DTools::Barcode1D.rle_to_bars('12341', @options)
+  end
+
+  def test_bars_to_rle
+    assert_equal '321', Barcode1DTools::Barcode1D.bars_to_rle('111001', @options)
+    assert_equal '12341', Barcode1DTools::Barcode1D.bars_to_rle('10011100001', @options)
+  end
+
+  def test_back_and_forth
+    random_rle = (0..19).collect { |x| (rand * 4 + 1).to_int.to_s }.join
+    random_bars = '1' + (0..((rand(25)+5)*2)).collect { |x| (x.odd? ? '1' : '0')*(rand(5)+1) }.join + '1'
+    random_wn = (0..19).collect { |x| rand < 0.5 ? 'w' : 'n' }.join
+    assert_equal random_rle, Barcode1DTools::Barcode1D.bars_to_rle(Barcode1DTools::Barcode1D.rle_to_bars(random_rle, @options), @options)
+    assert_equal random_bars, Barcode1DTools::Barcode1D.rle_to_bars(Barcode1DTools::Barcode1D.bars_to_rle(random_bars, @options), @options)
+    assert_equal random_wn, Barcode1DTools::Barcode1D.rle_to_wn(Barcode1DTools::Barcode1D.wn_to_rle(random_wn, @options), @options)
+  end
+
+  def test_bar_pair
+    assert_equal '01', Barcode1DTools::Barcode1D.bar_pair
+    assert_equal '56', Barcode1DTools::Barcode1D.bar_pair({ :space_character => 5, :line_character => 6 })
+  end
+
+  def test_wn_to_rle
+    assert_equal '12121211', Barcode1DTools::Barcode1D.wn_to_rle('nwnwnwnn')
+  end
+
+  def test_rle_to_wn
+    assert_equal 'wnwnwnww', Barcode1DTools::Barcode1D.rle_to_wn('21212122')
+    assert_equal 'wnwnwnww', Barcode1DTools::Barcode1D.rle_to_wn('31313133')
+  end
+
+  def test_wn_pair
+    assert_equal 'wn', Barcode1DTools::Barcode1D.wn_pair
+    assert_equal '65', Barcode1DTools::Barcode1D.wn_pair({ :n_character => '5', :w_character => '6' })
+  end
+end

data/test/test_barcode1dean13.rb

@@ -0,0 +1,102 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsEAN13Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random EAN-13 sans checksum
+  def random_12_digit_number
+    (0..11).collect { |x| ((rand * 10).to_i % 10).to_s }.join
+  end
+
+  def test_checksum_generation
+    assert_equal 7, Barcode1DTools::EAN13.generate_check_digit_for('007820601001')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::EAN13.validate_check_digit_for('0884088516338')
+  end
+
+  def test_attr_readers
+    ean = Barcode1DTools::EAN13.new('088408851633', :checksum_included => false)
+    assert_equal 8, ean.check_digit
+    assert_equal '088408851633', ean.value
+    assert_equal '0884088516338', ean.encoded_string
+    assert_equal '08', ean.number_system
+    assert_equal '84088', ean.manufacturers_code
+    assert_equal '51633', ean.product_code
+  end
+
+  def test_value_fixup
+    ean = Barcode1DTools::EAN13.new('088408851633', :checksum_included => false)
+    assert_equal 8, ean.check_digit
+    assert_equal '088408851633', ean.value
+    assert_equal '0884088516338', ean.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is 8
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::EAN13.new('0884088516331', :checksum_included => true) }
+  end
+
+  def test_value_length_errors
+    # One digit too short
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.new('01234567890', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.new('012345678901', :checksum_included => true) }
+    # One digit too long
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.new('0123456789012', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.new('01234567890123', :checksum_included => true) }
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_width
+    ean = Barcode1DTools::EAN13.new('0041343005796', :checksum_included => true)
+    assert_equal 95, ean.width
+  end
+
+  def test_barcode_generation
+    ean = Barcode1DTools::EAN13.new('0012676510226', :checksum_included => true)
+    assert_equal "10100011010011001001001101011110111011010111101010100111011001101110010110110011011001010000101", ean.bars
+    assert_equal "11132112221212211141312111411111123122213211212221221114111", ean.rle
+  end
+
+  def test_wn_raises_error
+    ean = Barcode1DTools::EAN13.new('0012676510226', :checksum_included => true)
+    assert_raise(Barcode1DTools::NotImplementedError) { ean.wn }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.decode('x'*60) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.decode('x'*96) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.decode('x'*94) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN13.decode('111000011111000011111') }
+  end
+
+  def test_decoding
+    random_ean_num=random_12_digit_number
+    ean = Barcode1DTools::EAN13.new(random_ean_num)
+    ean2 = Barcode1DTools::EAN13.decode(ean.bars)
+    assert_equal ean.value, ean2.value
+    ean3 = Barcode1DTools::EAN13.decode(ean.rle)
+    assert_equal ean.value, ean3.value
+    # Should also work in reverse
+    ean4 = Barcode1DTools::EAN13.decode(ean.bars.reverse)
+    assert_equal ean.value, ean4.value
+  end
+end

data/test/test_barcode1dean8.rb

@@ -0,0 +1,95 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsEAN8Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random EAN-8 sans checksum
+  def random_7_digit_number
+    sprintf('%07d',rand(10000000))
+  end
+
+  def test_checksum_generation
+    assert_equal 4, Barcode1DTools::EAN8.generate_check_digit_for('9638507')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::EAN8.validate_check_digit_for('96385074')
+  end
+
+  def test_attr_readers
+    ean = Barcode1DTools::EAN8.new('9638507', :checksum_included => false)
+    assert_equal 4, ean.check_digit
+    assert_equal '9638507', ean.value
+    assert_equal '96385074', ean.encoded_string
+    assert_equal '963', ean.number_system
+    assert_equal '8507', ean.product_code
+  end
+
+  def test_checksum_error
+    # proper checksum is 4
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::EAN8.new('96385070', :checksum_included => true) }
+  end
+
+  def test_value_length_errors
+    # One digit too short
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.new('123456', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.new('1234567', :checksum_included => true) }
+    # One digit too long
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.new('12345678', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.new('123456789', :checksum_included => true) }
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_width
+    ean = Barcode1DTools::EAN8.new(random_7_digit_number)
+    assert_equal 67, ean.width
+  end
+
+  def test_barcode_generation
+    ean = Barcode1DTools::EAN8.new('96385074', :checksum_included => true)
+    assert_equal "1010001011010111101111010110111010101001110111001010001001011100101", ean.bars
+
+    assert_equal "1113112111414111213111111231321113121132111", ean.rle
+  end
+
+  def test_wn_raises_error
+    ean = Barcode1DTools::EAN8.new(random_7_digit_number)
+    assert_raise(Barcode1DTools::NotImplementedError) { ean.wn }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.decode('x'*60) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.decode('x'*96) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.decode('x'*94) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::EAN8.decode('111000011111000011111') }
+  end
+
+  def test_decoding
+    random_ean_num=random_7_digit_number
+    ean = Barcode1DTools::EAN8.new(random_ean_num)
+    ean2 = Barcode1DTools::EAN8.decode(ean.bars)
+    assert_equal ean.value, ean2.value
+    ean3 = Barcode1DTools::EAN8.decode(ean.rle)
+    assert_equal ean.value, ean3.value
+    # Should also work in reverse
+    ean4 = Barcode1DTools::EAN8.decode(ean.bars.reverse)
+    assert_equal ean.value, ean4.value
+  end
+end