barcode1dtools 0.9.5.1 → 0.9.6.0

data/lib/barcode1dtools.rb

@@ -16,8 +16,8 @@ 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, and Codabar, but will be expanded to
-  # include most 1D symbologies in the near future.
+  # 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 => ' ')
@@ -120,3 +120,4 @@ require 'barcode1dtools/upc_supplemental_5'
 require 'barcode1dtools/code3of9'
 require 'barcode1dtools/code93'
 require 'barcode1dtools/codabar'
+require 'barcode1dtools/code11'

data/lib/barcode1dtools/code11.rb

@@ -0,0 +1,239 @@
+#--
+# 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::Code11 - Create and decode bar patterns for
+  # Code11.  The value encoded is a string which may contain the
+  # digits 0-9 and the dash symbol "-".  The standard specifies
+  # one or two check digits may be added depending on the length
+  # of the payload.  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.
+  #
+  # Code 11 is used in the telecom industry for equipment
+  # labeling.  It should not be used in any new applications.
+  #
+  # val = "29382-38"
+  # bc = Barcode1DTools::Code11.new(val)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::Code11 creates the patterns that you need to
+  # display Code11 barcodes.  It can also decode a simple w/n
+  # string.
+  #
+  # Code11 characters consist of 3 bars and 2 spaces, with a narrow
+  # space between them.  Three of the characters- 0, 9, and "-" -
+  # are 6 units wide.  The rest are 7 units 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.  Note that the w/n format is
+  # unavailable for this symbology.
+  #
+  #== Rendering
+  #
+  # The standard w/n ratio seems to be 2:1.  There seem to be no real
+  # standards for display.
+
+  class Code11 < Barcode1D
+
+    # Character sequence - 0-based offset in this string is character
+    # number
+    CHAR_SEQUENCE = "0123456789-"
+
+    # Patterns for making bar codes
+    PATTERNS = {
+      '0'=> {'val'=>0 ,'wn'=>'nnnnw'},
+      '1'=> {'val'=>1 ,'wn'=>'wnnnw'},
+      '2'=> {'val'=>2 ,'wn'=>'nwnnw'},
+      '3'=> {'val'=>3 ,'wn'=>'wwnnn'},
+      '4'=> {'val'=>4 ,'wn'=>'nnwnw'},
+      '5'=> {'val'=>5 ,'wn'=>'wnwnn'},
+      '6'=> {'val'=>6 ,'wn'=>'nwwnn'},
+      '7'=> {'val'=>7 ,'wn'=>'nnnww'},
+      '8'=> {'val'=>8 ,'wn'=>'wnnwn'},
+      '9'=> {'val'=>9 ,'wn'=>'wnnnn'},
+      '-'=> {'val'=>10 ,'wn'=>'nnwnn'}
+    }
+
+    GUARD_PATTERN_WN = 'nnwwn'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0',
+      :w_character => 'w',
+      :n_character => 'n',
+      :wn_ratio => '2'
+    }
+
+    attr_reader :start_character, :stop_character, :payload
+
+    class << self
+      # Code11 can encode digits and dashes.
+      def can_encode?(value)
+        value.to_s =~ /\A[0-9\-]+\z/
+      end
+
+      def generate_check_digit_for(value)
+        mult = 0
+        sum_c = value.to_s.reverse.split('').inject(0) { |a,c| mult = (mult == 11 ? 1 : mult + 1); a + mult * PATTERNS[c]['val'] }
+        check_c = CHAR_SEQUENCE[sum_c % 11,1]
+        if value.to_s.size > 9
+          mult = 0
+          sum_k = (value.to_s + check_c).reverse.split('').inject(0) { |a,c| mult = (mult == 10 ? 1 : mult + 1); a + mult * PATTERNS[c]['val'] }
+          check_k = CHAR_SEQUENCE[sum_k % 9,1]
+        else
+          check_k = ''
+        end
+        "#{check_c}#{check_k}"
+      end
+
+      def validate_check_digit_for(value)
+        payload, check_digits = split_payload_and_check_digits(value)
+        self.generate_check_digit_for(payload) == check_digits
+      end
+
+      def split_payload_and_check_digits(value)
+        if value.to_s.size > 11
+          # two check digits
+          md = value.to_s.match(/\A(.*)(..)\z/)
+        else
+          md = value.to_s.match(/\A(.*)(.)\z/)
+        end
+        [md[1], md[2]]
+      end
+
+      # Decode a string in rle format.  This will return a Code11
+      # 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_WN}n.*?#{GUARD_PATTERN_WN}\z/
+          str.reverse!
+        end
+
+        unless str =~ /\A#{GUARD_PATTERN_WN}n(.*?)#{GUARD_PATTERN_WN}\z/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        # Adding an "n" to make it easier to scan
+        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
+
+        Code11.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]
+        raise ChecksumError unless self.class.validate_check_digit_for(value)
+        @encoded_string = value.to_s
+        @value, @check_digit = self.class.split_payload_and_check_digits(value)
+      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_WN + 'n' + @encoded_string.split('').collect { |c| PATTERNS[c]['wn'] }.join('n') + 'n' + GUARD_PATTERN_WN
+    end
+
+  end
+end

data/test/test_barcode1dcode11.rb

@@ -0,0 +1,79 @@
+#--
+# 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 Barcode1DToolsCode11Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random number from 1 to 10 digits long
+  def random_code11_value(len)
+    (1..1+rand(len)).collect { "0123456789-"[rand(11),1] }.join
+  end
+
+  def test_checksum_generation
+    assert_equal '5', Barcode1DTools::Code11.generate_check_digit_for('123-45')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::Code11.validate_check_digit_for('123-455')
+  end
+
+  def test_attr_readers
+    code11 = Barcode1DTools::Code11.new('123-45', :checksum_included => false)
+    assert_equal '5', code11.check_digit
+    assert_equal '123-45', code11.value
+    assert_equal '123-455', code11.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is 5
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::Code11.new('123-451', :checksum_included => true) }
+  end
+
+  def test_skip_checksum
+    code11 = Barcode1DTools::Code11.new('123-45', :skip_checksum => true)
+    assert_nil code11.check_digit
+    assert_equal '123-45', code11.value
+    assert_equal '123-45', code11.encoded_string
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code11.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  # Only need to test wn, as bars and rle are based on wn
+  def test_barcode_generation
+    code11 = Barcode1DTools::Code11.new('123-455', :skip_checksum => true)
+    assert_equal "nnwwnnwnnnwnnwnnwnwwnnnnnnwnnnnnwnwnwnwnnnwnwnnnnnwwn", code11.wn
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code11.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code11.decode('x'*60) }
+    # proper start & stop, but crap in middle
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code11.decode('nnwwnnnnnnnnnnnwwn') }
+    # wrong start/stop
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Code11.decode('nwwnwnwnwnwnwnw') }
+  end
+
+  def test_decoding
+    random_code11_num=random_code11_value(10)
+    code11 = Barcode1DTools::Code11.new(random_code11_num, :skip_checksum => true)
+    code112 = Barcode1DTools::Code11.decode(code11.wn)
+    assert_equal code11.value, code112.value
+    # Should also work in reverse
+    code114 = Barcode1DTools::Code11.decode(code11.wn.reverse)
+    assert_equal code11.value, code114.value
+  end
+end

metadata

@@ -1,29 +1,44 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: barcode1dtools
-version: !ruby/object:Gem::Version
-  version: 0.9.5.1
+version: !ruby/object:Gem::Version 
+  hash: 31
   prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 6
+  - 0
+  version: 0.9.6.0
 platform: ruby
-authors:
+authors: 
 - Michael Chaney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-14 00:00:00.000000000Z
+
+date: 2012-09-16 00:00:00 -05:00
+default_executable: 
 dependencies: []
-description: ! "\t Barcode1D is a small library for handling many kinds of\n\t 1-dimensional
-  barcodes.  Currently implemented are Code 3 of 9, Code\n\t 93, Codabar, Interleaved
-  2 of 5, EAN-13, EAN-8, UPC-A, UPC-E, UPC\n\t Supplemental 2, and UPC Supplemental
-  5.  Patterns are created in\n\t either a simple format of bars and spaces or as
-  a run-length encoded\n\t string.  This only generates and decodes the patterns;
-  actual\n\t display or reading from a device must be implemented by the\n\t programmer.
-  \ More symbologies will be added as time permits.\n"
+
+description: "\t Barcode1D is a small library for handling many kinds of\n\
+  \t 1-dimensional barcodes.  Currently implemented are Code 3 of 9, Code\n\
+  \t 93, Code 11, Codabar, Interleaved 2 of 5, EAN-13, EAN-8, UPC-A,\n\
+  \t UPC-E, UPC Supplemental 2, and UPC Supplemental 5.  Patterns are\n\
+  \t created in either a simple format of bars and spaces or as a\n\
+  \t run-length encoded string.  This only generates and decodes the\n\
+  \t patterns; actual display or reading from a device must be\n\
+  \t implemented by the programmer.  More symbologies will be added as\n\
+  \t time permits.\n"
 email: mdchaney@michaelchaney.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/barcode1dtools/codabar.rb
+- lib/barcode1dtools/code11.rb
 - lib/barcode1dtools/code3of9.rb
 - lib/barcode1dtools/code93.rb
 - lib/barcode1dtools/ean13.rb
@@ -37,6 +52,7 @@ files:
 - MIT-LICENSE
 - test/test_barcode1d.rb
 - test/test_barcode1dcodabar.rb
+- test/test_barcode1dcode11.rb
 - test/test_barcode1dcode3of9.rb
 - test/test_barcode1dcode93.rb
 - test/test_barcode1dean13.rb
@@ -46,35 +62,47 @@ files:
 - test/test_barcode1dupce.rb
 - test/test_barcode1dupcsupp2.rb
 - test/test_barcode1dupcsupp5.rb
+has_rdoc: true
 homepage: http://rubygems.org/gems/barcode1dtools
-licenses:
+licenses: 
 - MIT
 - GPL-2
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
       version: 1.8.6
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
 summary: Pattern generators for 1D barcodes
-test_files:
+test_files: 
 - test/test_barcode1d.rb
 - test/test_barcode1dcodabar.rb
+- test/test_barcode1dcode11.rb
 - test/test_barcode1dcode3of9.rb
 - test/test_barcode1dcode93.rb
 - test/test_barcode1dean13.rb