barcode1dtools 0.9.2.1 → 0.9.3.0

data/lib/barcode1dtools.rb

@@ -15,9 +15,10 @@ module Barcode1DTools
   # Barcode1DTools is a library for generating and decoding
   # 1-dimensional barcode patterns for various code types.
   # The library currently includes EAN-13, EAN-8, UPC-A,
-  # UPC-E, UPC Supplemental 2, UPC Supplemental 5, and
-  # Interleaved 2 of 5 (I 2/5), but will be expanded to
-  # include most 1D symbologies in the near future.
+  # UPC-E, UPC Supplemental 2, UPC Supplemental 5,
+  # Interleaved 2 of 5 (I 2/5), and Code 3 of 9, but will be
+  # expanded to include most 1D symbologies in the near
+  # future.
   #
   #== Example
   #  ean13 = Barcode1DTools::EAN13.new('0012676510226', :line_character => 'x', :space_character => ' ')
@@ -117,3 +118,4 @@ require 'barcode1dtools/upc_a'
 require 'barcode1dtools/upc_e'
 require 'barcode1dtools/upc_supplemental_2'
 require 'barcode1dtools/upc_supplemental_5'
+require 'barcode1dtools/code3of9'

data/lib/barcode1dtools/code3of9.rb

@@ -0,0 +1,285 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+module Barcode1DTools
+
+  # Barcode1DTools::Code3of9 - Create and decode bar patterns for
+  # Code 3 of 9 (also known as Code 39, USD-3, Alpha39, Code 3/9,
+  # Type 39, or USS Code 39) barcodes.  The value encoded is a
+  # string, and a checksum digit may be added.  You can add the
+  # option :checksum_included => true when initializing to specify
+  # that you have already included a checksum, or :skip_checksum =>
+  # true to specify that no checksum should be added or checked.  A
+  # ChecksumError will be raised if :checksum_included => true,
+  # :skip_checksum is false, and the last digit is invalid as a
+  # checksum.  Note that the default is "skip_checksum".
+  #
+  # Code 3 of 9 can encode digits, uppercase letters, and the symbols
+  # dash "-", period ".", dollar sign "$", forward slash "/", plus
+  # sign "+", percent sign "%", as well as a space " ".
+  #
+  # val = "THIS IS A TEST"
+  # bc = Barcode1DTools::Code3of9.new(val)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # wn_pattern = bc.wn
+  # width = bc.width
+  # # Note that the check digit is actually one of the characters.
+  # check_digit = Barcode1DTools::Code3of9.generate_check_digit_for(num)
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::Code3of9 creates the patterns that you need to
+  # display Code 3 of 9 barcodes.  It can also decode a simple w/n
+  # string.
+  #
+  # Code 3 of 9 barcodes consist of lines and spaces that are either
+  # "wide" or "narrow", with "wide" lines or spaces being twice the
+  # width of narrow lines or spaces.
+  #
+  # There are three formats for the returned pattern:
+  #
+  #   bars - 1s and 0s specifying black lines and white spaces.  Actual
+  #          characters can be changed from "1" and 0" with options
+  #          :line_character and :space_character.
+  #
+  #   rle -  Run-length-encoded version of the pattern.  The first
+  #          number is always a black line, with subsequent digits
+  #          alternating between spaces and lines.  The digits specify
+  #          the width of each line or space.
+  #
+  #   wn -   The native format for this barcode type.  The string
+  #          consists of a series of "w" and "n" characters.  The first
+  #          item is always a black line, with subsequent characters
+  #          alternating between spaces and lines.  A "wide" item
+  #          is twice the width of a "narrow" item.
+  #
+  # The "width" method will tell you the total end-to-end width, in
+  # units, of the entire barcode.
+  #
+  #== Miscellaneous Information
+  #
+  # Code 3 of 9 can encode text and digits.  There is also a way to do
+  # "full ascii" mode, but it's not recommended.  Full ascii mode uses
+  # some of the characters as shift characters, e.g. "a" is encoded as
+  # "+A".  There's no indication that full ascii mode is being used, so
+  # it has to be handled by the application.  This has been fixed in
+  # Code 93, by designation of four special characters which are used
+  # only for shifting.  However, if you need to use a full character
+  # set, Code 128 is probably a better choice.
+  #
+  #== Rendering
+  #
+  # Code 3 of 9 may be rendered however the programmer wishes.  Since
+  # there is a simple mapping between number of characters and length of
+  # code, a variable length code should be allowed to grow and shrink to
+  # assure the bars are neither too large or too small.  Code 3 of 9 is
+  # often implemented as a font.
+  #
+  # There is no standard for human-readable text associated with the
+  # code, and in fact some applications leave out the human-readable
+  # element altogether.  The text is typically shown below the barcode
+  # where applicable.
+
+  class Code3of9 < Barcode1D
+
+    # Character sequence - 0-based offset in this string is character
+    # number
+    CHAR_SEQUENCE = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%'
+
+    # Patterns for making bar codes
+    PATTERNS = {
+      '0' => { 'position' => 0,  'wn' => 'nnnwwnwnn' },
+      '1' => { 'position' => 1,  'wn' => 'wnnwnnnnw' },
+      '2' => { 'position' => 2,  'wn' => 'nnwwnnnnw' },
+      '3' => { 'position' => 3,  'wn' => 'wnwwnnnnn' },
+      '4' => { 'position' => 4,  'wn' => 'nnnwwnnnw' },
+      '5' => { 'position' => 5,  'wn' => 'wnnwwnnnn' },
+      '6' => { 'position' => 6,  'wn' => 'nnwwwnnnn' },
+      '7' => { 'position' => 7,  'wn' => 'nnnwnnwnw' },
+      '8' => { 'position' => 8,  'wn' => 'wnnwnnwnn' },
+      '9' => { 'position' => 9,  'wn' => 'nnwwnnwnn' },
+      'A' => { 'position' => 10, 'wn' => 'wnnnnwnnw' },
+      'B' => { 'position' => 11, 'wn' => 'nnwnnwnnw' },
+      'C' => { 'position' => 12, 'wn' => 'wnwnnwnnn' },
+      'D' => { 'position' => 13, 'wn' => 'nnnnwwnnw' },
+      'E' => { 'position' => 14, 'wn' => 'wnnnwwnnn' },
+      'F' => { 'position' => 15, 'wn' => 'nnwnwwnnn' },
+      'G' => { 'position' => 16, 'wn' => 'nnnnnwwnw' },
+      'H' => { 'position' => 17, 'wn' => 'wnnnnwwnn' },
+      'I' => { 'position' => 18, 'wn' => 'nnwnnwwnn' },
+      'J' => { 'position' => 19, 'wn' => 'nnnnwwwnn' },
+      'K' => { 'position' => 20, 'wn' => 'wnnnnnnww' },
+      'L' => { 'position' => 21, 'wn' => 'nnwnnnnww' },
+      'M' => { 'position' => 22, 'wn' => 'wnwnnnnwn' },
+      'N' => { 'position' => 23, 'wn' => 'nnnnwnnww' },
+      'O' => { 'position' => 24, 'wn' => 'wnnnwnnwn' },
+      'P' => { 'position' => 25, 'wn' => 'nnwnwnnwn' },
+      'Q' => { 'position' => 26, 'wn' => 'nnnnnnwww' },
+      'R' => { 'position' => 27, 'wn' => 'wnnnnnwwn' },
+      'S' => { 'position' => 28, 'wn' => 'nnwnnnwwn' },
+      'T' => { 'position' => 29, 'wn' => 'nnnnwnwwn' },
+      'U' => { 'position' => 30, 'wn' => 'wwnnnnnnw' },
+      'V' => { 'position' => 31, 'wn' => 'nwwnnnnnw' },
+      'W' => { 'position' => 32, 'wn' => 'wwwnnnnnn' },
+      'X' => { 'position' => 33, 'wn' => 'nwnnwnnnw' },
+      'Y' => { 'position' => 34, 'wn' => 'wwnnwnnnn' },
+      'Z' => { 'position' => 35, 'wn' => 'nwwnwnnnn' },
+      '-' => { 'position' => 36, 'wn' => 'nwnnnnwnw' },
+      '.' => { 'position' => 37, 'wn' => 'wwnnnnwnn' },
+      ' ' => { 'position' => 38, 'wn' => 'nwwnnnwnn' },
+      '$' => { 'position' => 39, 'wn' => 'nwnwnwnnn' },
+      '/' => { 'position' => 40, 'wn' => 'nwnwnnnwn' },
+      '+' => { 'position' => 41, 'wn' => 'nwnnnwnwn' },
+      '%' => { 'position' => 42, 'wn' => 'nnnwnwnwn' }
+    }
+
+    SIDE_GUARD_PATTERN = 'nwnnwnwnn'
+
+    WN_RATIO = 2
+
+    DEFAULT_OPTIONS = {
+      :w_character => 'w',
+      :n_character => 'n',
+      :line_character => '1',
+      :space_character => '0',
+      :wn_ratio => WN_RATIO,
+      :skip_checksum => true
+    }
+
+    class << self
+      # returns true or false
+      def can_encode?(value)
+        value.to_s =~ /\A[0-9A-Z\-\. \$\/\+%]*\z/
+      end
+
+      # Generates check digit given a string to encode.  It assumes there
+      # is no check digit on the "value".  The check "digit" is
+      # actually a character, and the "position" value in PATTERNS can
+      # be used to find the numeric value.
+      def generate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value)
+        mult = 1
+        sum = value.to_s.split('').inject(0) { |a,c| a + PATTERNS[c]['position'] }
+        CHAR_SEQUENCE[sum % 43,1]
+      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)
+        md = value.to_s.match(/^(.*)(.)$/)
+        self.generate_check_digit_for(md[1]) == md[2]
+      end
+
+      # Decode a string in wn format.  This will return a Code3of9
+      # object.
+      def decode(str, options = {})
+        if str =~ /[^wn]/
+          raise UnencodableCharactersError, "Pattern must contain only \"w\" and \"n\"."
+        end
+
+        if str.reverse =~ /^#{SIDE_GUARD_PATTERN}n.*?n#{SIDE_GUARD_PATTERN}$/
+          str.reverse!
+        end
+
+        unless str =~ /^#{SIDE_GUARD_PATTERN}n(.*?)#{SIDE_GUARD_PATTERN}$/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        wn_pattern = $1
+
+        unless wn_pattern.size % 10 == 0
+          raise UnencodableCharactersError, "Wrong number of bars."
+        end
+
+        decoded_string = ''
+
+        wn_pattern.scan(/(.{9})n/).each do |chunk|
+
+          chunk = chunk[0]
+
+          found = false
+
+          PATTERNS.each do |char,hsh|
+            if chunk == hsh['wn']
+              decoded_string += char
+              found = true
+              break;
+            end
+          end
+
+          raise UndecodableCharactersError, "Invalid sequence: #{chunk}" unless found
+
+        end
+
+        Code3of9.new(decoded_string, options)
+      end
+    end
+
+    # Options are :line_character, :space_character, :w_character,
+    # :n_character, :skip_checksum, 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)
+
+      value = value.to_s
+
+      if @options[:skip_checksum] && !@options[:checksum_included]
+        @encoded_string = value
+        @value = value
+        @check_digit = nil
+      elsif @options[:checksum_included]
+        @options[:skip_checksum] = nil
+        raise ChecksumError unless self.class.validate_check_digit_for(value)
+        @encoded_string = value
+        md = value.match(/\A(.*?)(.)\z/)
+        @value, @check_digit = md[1], md[2]
+      else
+        # need to add a checksum
+        @value = value
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = "#{@value}#{@check_digit}"
+      end
+    end
+
+    # Returns a string of "w" or "n" ("wide" and "narrow")
+    def wn
+      @wn ||= wn_str.tr('wn', @options[:w_character].to_s + @options[:n_character].to_s)
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      @rle ||= self.class.wn_to_rle(self.wn, @options)
+    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
+
+    # Creates the actual w/n pattern.  Note that there is a narrow space
+    # between each character.
+    def wn_str
+      @wn_str ||=
+        ([SIDE_GUARD_PATTERN] +
+        @encoded_string.split('').collect { |c| PATTERNS[c]['wn'] } +
+        [SIDE_GUARD_PATTERN]).join('n')
+    end
+
+  end
+end

data/lib/barcode1dtools/interleaved2of5.rb

@@ -146,8 +146,7 @@ module Barcode1DTools
 
         decoded_string = ''
 
-        numeric_pattern.scan(/(.{10})/).each do |chunk|
-          chunk = chunk[0]
+        numeric_pattern.scan(/.{10}/).each do |chunk|
 
           num1 = chunk[0,1] + chunk[2,1] + chunk[4,1] + chunk[6,1] + chunk[8,1]
           num2 = chunk[1,1] + chunk[3,1] + chunk[5,1] + chunk[7,1] + chunk[9,1]

data/test/test_barcode1dcode3of9.rb

@@ -0,0 +1,80 @@
+#--
+# 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 Barcode1DToolsCode3of9Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random number from 1 to 10 digits long
+  def random_x_character_string(x)
+    num_chars = Barcode1DTools::Code3of9::CHAR_SEQUENCE.size
+    (0..x-1).inject('') { |a,c| a + Barcode1DTools::Code3of9::CHAR_SEQUENCE[rand(num_chars),1] }
+  end
+
+  def test_checksum_generation
+    assert_equal 'I', Barcode1DTools::Code3of9.generate_check_digit_for('THIS IS A TEST')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::Code3of9.validate_check_digit_for('THIS IS A TESTI')
+  end
+
+  def test_attr_readers
+    c3of9 = Barcode1DTools::Code3of9.new('THIS IS A TEST', :skip_checksum => false)
+    assert_equal 'I', c3of9.check_digit
+    assert_equal 'THIS IS A TEST', c3of9.value
+    assert_equal 'THIS IS A TESTI', c3of9.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is I
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::Code3of9.new('THIS IS A TEST0', :checksum_included => true) }
+  end
+
+  def test_skip_checksum
+    c3of9 = Barcode1DTools::Code3of9.new('THIS IS A TEST', :skip_checksum => true)
+    assert_nil c3of9.check_digit
+    assert_equal 'THIS IS A TEST', c3of9.value
+    assert_equal 'THIS IS A TEST', c3of9.encoded_string
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code3of9.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  # Only need to test wn, as bars and rle are based on wn
+  def test_barcode_generation
+    c3of9 = Barcode1DTools::Code3of9.new('THIS IS A TEST')
+    assert_equal "nwnnwnwnnnnnnnwnwwnnwnnnnwwnnnnnwnnwwnnnnnwnnnwwnnnwwnnnwnnnnnwnnwwnnnnnwnnnwwnnnwwnnnwnnnwnnnnwnnwnnwwnnnwnnnnnnnwnwwnnwnnnwwnnnnnnwnnnwwnnnnnnwnwwnnnwnnwnwnn", c3of9.wn
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code3of9.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code3of9.decode('x'*60) }
+    # proper start & stop, but crap in middle
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code3of9.decode(Barcode1DTools::Code3of9::SIDE_GUARD_PATTERN + 'wwwwwww' + Barcode1DTools::Code3of9::SIDE_GUARD_PATTERN) }
+    # wrong start/stop
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code3of9.decode('nwwnwnwnwnwnwnw') }
+  end
+
+  def test_decoding
+    random_c3of9_str=random_x_character_string(rand(10)+5)
+    c3of9 = Barcode1DTools::Code3of9.new(random_c3of9_str, :skip_checksum => true)
+    c3of92 = Barcode1DTools::Code3of9.decode(c3of9.wn)
+    assert_equal c3of9.value, c3of92.value
+    # Should also work in reverse
+    c3of94 = Barcode1DTools::Code3of9.decode(c3of9.wn.reverse)
+    assert_equal c3of9.value, c3of94.value
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: barcode1dtools
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 9
-  - 2
-  - 1
-  version: 0.9.2.1
+  - 3
+  - 0
+  version: 0.9.3.0
 platform: ruby
 authors: 
 - Michael Chaney
@@ -20,8 +20,7 @@ date: 2012-08-05 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
-description: "    Barcode1D is a small library for handling many kinds of\n    1-dimensional barcodes.  Currently implemented are\n    Interleaved 2 of 5, EAN-13, EAN-8, UPC-A, UPC-E, UPC\n    Supplemental 2, and UPC Supplemental 5.  Patterns are\n    created in either a simple format of bars and spaces or\n    as a run-length encoded string.  This only generates\n    and decodes the patterns; actual display or reading\n    from a device must be implemented by the programmer.\n\
-  \t More symbologies will be added as time permits.\n"
+description: "    Barcode1D is a small library for handling many kinds of\n    1-dimensional barcodes.  Currently implemented are Code 3 of 9,\n    Interleaved 2 of 5, EAN-13, EAN-8, UPC-A, UPC-E, UPC Supplemental 2,\n    and UPC Supplemental 5.  Patterns are created in either a simple\n    format of bars and spaces or as a run-length encoded string.  This\n    only generates and decodes the patterns; actual display or reading\n    from a device must be implemented by the programmer.  More\n    symbologies will be added as time permits.\n"
 email: mdchaney@michaelchaney.com
 executables: []
 
@@ -30,6 +29,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/barcode1dtools/code3of9.rb
 - lib/barcode1dtools/ean13.rb
 - lib/barcode1dtools/ean8.rb
 - lib/barcode1dtools/interleaved2of5.rb
@@ -40,6 +40,7 @@ files:
 - lib/barcode1dtools.rb
 - MIT-LICENSE
 - test/test_barcode1d.rb
+- test/test_barcode1dcode3of9.rb
 - test/test_barcode1dean13.rb
 - test/test_barcode1dean8.rb
 - test/test_barcode1di2of5.rb
@@ -86,6 +87,7 @@ specification_version: 3
 summary: Pattern generators for 1D barcodes
 test_files: 
 - test/test_barcode1d.rb
+- test/test_barcode1dcode3of9.rb
 - test/test_barcode1dean13.rb
 - test/test_barcode1dean8.rb
 - test/test_barcode1di2of5.rb