barcode1dtools 0.9.6.0 → 0.9.7.0

data/lib/barcode1dtools.rb

@@ -16,8 +16,9 @@ module Barcode1DTools
   # 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, Interleaved 2 of 5 (I 2/5),
-  # Code 3 of 9, Code 93, Code 11, and Codabar, but will be
-  # expanded to include most 1D symbologies in the near future.
+  # COOP 2 of 5, Matrix 2 of 5, Industrial 2 of 5, IATA 2 of 5,
+  # PostNet, Code 3 of 9, Code 93, Code 11, and Codabar, but will
+  # be expanded to include most 1D symbologies in the near future.
   #
   #== Example
   #  ean13 = Barcode1DTools::EAN13.new('0012676510226', :line_character => 'x', :space_character => ' ')
@@ -121,3 +122,8 @@ require 'barcode1dtools/code3of9'
 require 'barcode1dtools/code93'
 require 'barcode1dtools/codabar'
 require 'barcode1dtools/code11'
+require 'barcode1dtools/coop2of5'
+require 'barcode1dtools/industrial2of5'
+require 'barcode1dtools/iata2of5'
+require 'barcode1dtools/matrix2of5'
+require 'barcode1dtools/postnet'

data/lib/barcode1dtools/codabar.rb

@@ -62,8 +62,7 @@ module Barcode1DTools
   #          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.  Note that the w/n format is
-  # unavailable for this symbology.
+  # units, of the entire barcode.
   #
   #== Rendering
   #

data/lib/barcode1dtools/code11.rb

@@ -53,8 +53,7 @@ module Barcode1DTools
   #          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.  Note that the w/n format is
-  # unavailable for this symbology.
+  # units, of the entire barcode.
   #
   #== Rendering
   #

data/lib/barcode1dtools/coop2of5.rb

@@ -0,0 +1,222 @@
+#--
+# 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::Coop2of5 - Create and decode bar patterns for
+  # COOP 2 of 5.  The value encoded is a number with digits 0-9.
+  # Internally, the value is treated as a string to preserve
+  # leading zeroes.
+  #
+  # Use :checksum_included => true if you have already added a
+  # checksum and wish to have it validated, or :skip_checksum =>
+  # true if you don't wish to add one or have it validated.
+  #
+  # COOP 2 of 5 is low-density and limited.  It should not be
+  # used in any new applications.
+  #
+  # val = "3423"
+  # bc = Barcode1DTools::Coop2of5.new(val)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::Coop2of5 creates the patterns that you need to
+  # display COOP 2 of 5 barcodes.  It can also decode a simple w/n
+  # string.
+  #
+  # Coop2of5 characters consist of 3 bars and 2 spaces, with a narrow
+  # space between them.  2 of the bars/spaces in each symbol are wide.
+  #
+  # 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.
+  #
+  #== Rendering
+  #
+  # The standard w/n ratio seems to be 2:1.  There seem to be no real
+  # standards for display.
+
+  class Coop2of5 < Barcode1D
+
+    # Character sequence - 0-based offset in this string is character
+    # number
+    CHAR_SEQUENCE = "0123456789"
+
+    # Patterns for making bar codes.  Note that the position
+    # weights are 7, 4, 2, 1 and the last bit is parity.
+    # Each letter is an alternating bar then space, and there
+    # is a narrow space between each character.
+    PATTERNS = {
+      '0'=> {'val'=>0 ,'wn'=>'wwnnn'},
+      '1'=> {'val'=>1 ,'wn'=>'nnnww'},
+      '2'=> {'val'=>2 ,'wn'=>'nnwnw'},
+      '3'=> {'val'=>3 ,'wn'=>'nnwwn'},
+      '4'=> {'val'=>4 ,'wn'=>'nwnnw'},
+      '5'=> {'val'=>5 ,'wn'=>'nwnwn'},
+      '6'=> {'val'=>6 ,'wn'=>'nwwnn'},
+      '7'=> {'val'=>7 ,'wn'=>'wnnnw'},
+      '8'=> {'val'=>8 ,'wn'=>'wnnwn'},
+      '9'=> {'val'=>9 ,'wn'=>'wnwnn'}
+    }
+
+    GUARD_PATTERN_LEFT_WN = 'wnw'
+    GUARD_PATTERN_RIGHT_WN = 'nww'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0',
+      :w_character => 'w',
+      :n_character => 'n',
+      :wn_ratio => '2'
+    }
+
+    class << self
+      # Coop2of5 can encode digits
+      def can_encode?(value)
+        value.to_s =~ /\A[0-9]+\z/
+      end
+
+      def generate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value)
+        mult = 3
+        value = value.reverse.split('').inject(0) { |a,c| mult = 4 - mult ; a + c.to_i * mult }
+        (10 - (value % 10)) % 10
+      end
+
+      def validate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value)
+        md = value.match(/^(\d+?)(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      # Decode a string in rle format.  This will return a Coop2of5
+      # object.
+      def decode(str, options = {})
+        if str =~ /[^1-3]/ && str =~ /[^wn]/
+          raise UnencodableCharactersError, "Pattern must be rle or wn"
+        end
+
+        # ensure a wn string
+        if str =~ /[1-3]/
+          str = str.tr('123','nww')
+        end
+
+        if str.reverse =~ /\A#{GUARD_PATTERN_LEFT_WN}n.*?#{GUARD_PATTERN_RIGHT_WN}\z/
+          str.reverse!
+        end
+
+        unless str =~ /\A#{GUARD_PATTERN_LEFT_WN}n(.*?)#{GUARD_PATTERN_RIGHT_WN}\z/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        wn_pattern = $1
+
+        # Each pattern is 3 bars and 2 spaces, with a space between.
+        unless wn_pattern.size % 6 == 0
+          raise UnencodableCharactersError, "Wrong number of bars."
+        end
+
+        decoded_string = ''
+
+        wn_pattern.scan(/(.{5})n/).each do |chunk|
+
+          chunk = chunk.first
+          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
+
+        Coop2of5.new(decoded_string, options)
+      end
+
+    end
+
+    # Options are :line_character, :space_character, :w_character,
+    # :n_character, :checksum_included, and :skip_checksum.
+    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]
+        @encoded_string = value.to_s
+        @value = value.to_s
+        @check_digit = nil
+      elsif @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
+        @value = value.to_s
+        @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 ||= GUARD_PATTERN_LEFT_WN + 'n' + @encoded_string.split('').collect { |c| PATTERNS[c]['wn'] }.join('n') + 'n' + GUARD_PATTERN_RIGHT_WN
+    end
+
+  end
+end

data/lib/barcode1dtools/iata2of5.rb

@@ -0,0 +1,223 @@
+#--
+# 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::IATA2of5 - Create and decode bar patterns for
+  # IATA 2 of 5.  The value encoded is a number with digits 0-9.
+  # Internally, the value is treated as a string to preserve
+  # leading zeroes.  This is identical to Industrial 2 of 5 but
+  # with different guard patterns.
+  #
+  # Use :checksum_included => true if you have already added a
+  # checksum and wish to have it validated, or :skip_checksum =>
+  # true if you don't want to add it or wish to skip checking.
+  #
+  # IATA 2 of 5 is low-density and limited.  It should not be
+  # used in any new applications.
+  #
+  # val = "3423"
+  # bc = Barcode1DTools::IATA2of5.new(val)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::IATA2of5 creates the patterns that you need to
+  # display IATA 2 of 5 barcodes.  It can also decode a simple w/n
+  # string.
+  #
+  # IATA2of5 characters consist of 3 bars and 2 spaces, with a narrow
+  # space between them.  2 of the bars/spaces in each symbol are wide.
+  #
+  # 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.
+  #
+  #== Rendering
+  #
+  # The standard w/n ratio seems to be 2:1.  There seem to be no real
+  # standards for display.
+
+  class IATA2of5 < Barcode1D
+
+    # Character sequence - 0-based offset in this string is character
+    # number
+    CHAR_SEQUENCE = "0123456789"
+
+    # Patterns for making bar codes.  Note that the position
+    # weights are 1, 2, 4, and 7 and the last bit is parity.
+    # The patterns are for the bars, all spaces are narrow.
+    PATTERNS = {
+      '0'=> {'val'=>0 ,'wn'=>'nnnnwnwnn'},
+      '1'=> {'val'=>1 ,'wn'=>'wnnnnnnnw'},
+      '2'=> {'val'=>2 ,'wn'=>'nnwnnnnnw'},
+      '3'=> {'val'=>3 ,'wn'=>'wnwnnnnnn'},
+      '4'=> {'val'=>4 ,'wn'=>'nnnnwnnnw'},
+      '5'=> {'val'=>5 ,'wn'=>'wnnnwnnnn'},
+      '6'=> {'val'=>6 ,'wn'=>'nnwnwnnnn'},
+      '7'=> {'val'=>7 ,'wn'=>'nnnnnnwnw'},
+      '8'=> {'val'=>8 ,'wn'=>'wnnnnnwnn'},
+      '9'=> {'val'=>9 ,'wn'=>'nnwnnnwnn'}
+    }
+
+    GUARD_PATTERN_LEFT_WN = 'nnn'
+    GUARD_PATTERN_RIGHT_WN = 'wnn'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0',
+      :w_character => 'w',
+      :n_character => 'n',
+      :wn_ratio => '2'
+    }
+
+    class << self
+      # IATA2of5 can encode digits
+      def can_encode?(value)
+        value.to_s =~ /\A[0-9]+\z/
+      end
+
+      def generate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value)
+        mult = 3
+        value = value.reverse.split('').inject(0) { |a,c| mult = 4 - mult ; a + c.to_i * mult }
+        (10 - (value % 10)) % 10
+      end
+
+      def validate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value)
+        md = value.match(/^(\d+?)(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      # Decode a string in rle format.  This will return a IATA2of5
+      # object.
+      def decode(str, options = {})
+        if str =~ /[^1-3]/ && str =~ /[^wn]/
+          raise UnencodableCharactersError, "Pattern must be rle or wn"
+        end
+
+        # ensure a wn string
+        if str =~ /[1-3]/
+          str = str.tr('123','nww')
+        end
+
+        if str.reverse =~ /\A#{GUARD_PATTERN_LEFT_WN}n.*?#{GUARD_PATTERN_RIGHT_WN}\z/
+          str.reverse!
+        end
+
+        # Note that every other character is an "n"
+        unless str =~ /\A([wn]n)+[wn]\z/ && str =~ /\A#{GUARD_PATTERN_LEFT_WN}n(.*?)#{GUARD_PATTERN_RIGHT_WN}\z/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        wn_pattern = $1
+
+        # Each pattern is 5 bars and 4 spaces, with a space between.
+        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.first
+          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
+
+        IATA2of5.new(decoded_string, options)
+      end
+
+    end
+
+    # Options are :line_character, :space_character, :w_character,
+    # :n_character, :checksum_included, and :skip_checksum.
+    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]
+        @encoded_string = value.to_s
+        @value = value.to_s
+        @check_digit = nil
+      elsif @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
+        @value = value.to_s
+        @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 every single bar.
+    def wn_str
+      @wn_str ||= GUARD_PATTERN_LEFT_WN + 'n' + @encoded_string.split('').collect { |c| PATTERNS[c]['wn'] }.join('n') + 'n' + GUARD_PATTERN_RIGHT_WN
+    end
+
+  end
+end