barcode1dtools 0.9.7.0 → 0.9.8.0

data/lib/barcode1dtools.rb

@@ -17,8 +17,9 @@ module Barcode1DTools
   # library currently includes EAN-13, EAN-8, UPC-A, UPC-E, UPC
   # Supplemental 2, UPC Supplemental 5, Interleaved 2 of 5 (I 2/5),
   # 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.
+  # PostNet, Plessey, MSI (Modified Plessey), 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 => ' ')
@@ -127,3 +128,5 @@ require 'barcode1dtools/industrial2of5'
 require 'barcode1dtools/iata2of5'
 require 'barcode1dtools/matrix2of5'
 require 'barcode1dtools/postnet'
+require 'barcode1dtools/plessey'
+require 'barcode1dtools/msi'

data/lib/barcode1dtools/msi.rb

@@ -0,0 +1,262 @@
+#--
+# 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::MSI - Create and decode bar patterns for
+  # MSI.  The value encoded is a string which may contain the
+  # digits 0-9.
+  #
+  # There are four possible check digit calculations, and you
+  # may use the option :check_digit => 'x' to choose which
+  # one to use.  "x" may be one of "mod 10", "mod 11",
+  # "mod 1010", or "mod 1110".  The default is "mod 10".
+  # For a mod 11 check digit, you may use :check_style =>
+  # 'ibm' or 'ncr'.
+  #
+  # MSI is a terrible symbology in modern terms and should
+  # not be used in any new applications.
+  #
+  # val = "2898289238"
+  # bc = Barcode1DTools::MSI.new(val)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::MSI creates the patterns that you need to
+  # display MSI barcodes.  It can also decode a simple w/n
+  # string.
+  #
+  # MSI characters consist of 4 bars and 4 spaces.  The
+  # representation is simply binary where a binary "0" is
+  # represented as a narrow bar followed by a wide space and
+  # a binary "1" is a wide bar followed by a narrow space.
+  # The bits are ordered descending, so 9 is 1001 binary,
+  # "wn nw nw wn" in w/n format.
+  #
+  # 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 author is aware of no standards for display.
+
+  class MSI < 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'=>'nwnwnwnw'},
+      '1'=> {'val'=>1 ,'wn'=>'nwnwnwwn'},
+      '2'=> {'val'=>2 ,'wn'=>'nwnwwnnw'},
+      '3'=> {'val'=>3 ,'wn'=>'nwnwwnwn'},
+      '4'=> {'val'=>4 ,'wn'=>'nwwnnwnw'},
+      '5'=> {'val'=>5 ,'wn'=>'nwwnnwwn'},
+      '6'=> {'val'=>6 ,'wn'=>'nwwnwnnw'},
+      '7'=> {'val'=>7 ,'wn'=>'nwwnwnwn'},
+      '8'=> {'val'=>8 ,'wn'=>'wnnwnwnw'},
+      '9'=> {'val'=>9 ,'wn'=>'wnnwnwwn'}
+    }
+
+    GUARD_PATTERN_LEFT_WN = 'wn'
+    GUARD_PATTERN_RIGHT_WN = 'nwn'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0',
+      :w_character => 'w',
+      :n_character => 'n',
+      :wn_ratio => '2',
+      :check_digit => 'mod 10',
+      :check_style => 'ibm'
+    }
+
+    class << self
+      # MSI can encode digits
+      def can_encode?(value)
+        value.to_s =~ /\A\d+\z/
+      end
+
+      def generate_check_digit_for(value, options = {})
+        if options[:check_digit] == 'mod 10'
+          generate_mod10_check_digit_for(value).to_s
+        elsif options[:check_digit] == 'mod 11'
+          generate_mod11_check_digit_for(value, options[:check_style]).to_s
+        elsif options[:check_digit] == 'mod 1010'
+          mod10 = generate_mod10_check_digit_for(value)
+          mod10_2 = generate_mod10_check_digit_for(value + mod10.to_s)
+          "#{mod10}#{mod10_2}"
+        elsif options[:check_digit] == 'mod 1110'
+          mod11 = generate_mod11_check_digit_for(value, options[:check_style])
+          mod10_2 = generate_mod10_check_digit_for(value + mod11.to_s)
+          "#{mod11}#{mod10_2}"
+        end
+      end
+
+      def validate_check_digit_for(value, options = {})
+        payload, check_digits = split_payload_and_check_digits(value, options)
+        self.generate_check_digit_for(payload, options) == check_digits
+      end
+
+      def split_payload_and_check_digits(value, options = {})
+        if options[:check_digit] == 'mod 1010' || options[:check_digit] == 'mod 1110'
+          md = value.to_s.match(/\A(.*?)(..)\z/)
+        else
+          md = value.to_s.match(/\A(.*?)(.)\z/)
+        end
+        [md[1], md[2]]
+      end
+
+      def generate_mod10_check_digit_for(value)
+        value = value.to_s
+        valarr = value.scan(/\d\d?/)
+        if value.size.odd?
+          odd = valarr.collect { |c| c[0,1] }
+          even = valarr.collect { |c| c[1,1] }
+        else
+          odd = valarr.collect { |c| c[1,1] }
+          even = valarr.collect { |c| c[0,1] }
+        end
+        odd = (odd.join.to_i * 2).to_s.split('').inject(0) { |a,c| a + c.to_i }
+        even = even.inject(0) { |a,c| a + c.to_i }
+        (10 - ((odd + even) % 10)) % 10
+      end
+
+      def generate_mod11_check_digit_for(value, style)
+        max = (style == 'ncr' ? 9 : 7)
+        value = value.to_s
+        weight = 1
+        sum = value.split('').reverse.inject(0) { |a,c| weight = (weight == max ? 2 : weight + 1); a + weight * c.to_i }
+        (11 - (sum % 11)) % 11
+      end
+
+      # Decode a string in rle format.  This will return a MSI
+      # 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}.*?#{GUARD_PATTERN_RIGHT_WN}\z/
+          str.reverse!
+        end
+
+        unless str =~ /\A#{GUARD_PATTERN_LEFT_WN}(.*?)#{GUARD_PATTERN_RIGHT_WN}\z/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        wn_pattern = $1
+
+        # Each pattern is 4 bars and 4 spaces, with a space between.
+        unless wn_pattern.size % 8 == 0
+          raise UnencodableCharactersError, "Wrong number of bars."
+        end
+
+        decoded_string = ''
+
+        wn_pattern.scan(/.{8}/).each do |chunk|
+
+          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
+
+        MSI.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)
+
+      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, options)
+        @encoded_string = value.to_s
+        @value, @check_digit = self.class.split_payload_and_check_digits(value, options)
+      else
+        @value = value.to_s
+        @check_digit = self.class.generate_check_digit_for(@value, options)
+        @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 + @encoded_string.split('').collect { |c| PATTERNS[c]['wn'] }.join + GUARD_PATTERN_RIGHT_WN
+    end
+
+  end
+end

data/lib/barcode1dtools/plessey.rb

@@ -0,0 +1,208 @@
+#--
+# 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::Plessey - Create and decode bar patterns for
+  # Plessey.  The value encoded is a string which may contain the
+  # digits 0-9 and the letters A-F (0-15 hexadecimal).
+  #
+  # According to Wikipedia, a Plessey code should contain a two
+  # digit CRC8 checksum.  This code does not provide checksum
+  # generation or validation.
+  #
+  # Plessey is a terrible symbology in modern terms and should
+  # not be used in any new applications.
+  #
+  # val = "2898289238AF"
+  # bc = Barcode1DTools::Plessey.new(val)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::Plessey creates the patterns that you need to
+  # display Plessey barcodes.  It can also decode a simple w/n
+  # string.
+  #
+  # Plessey characters consist of 4 bars and 4 spaces.  The
+  # representation is simply binary where a binary "0" is
+  # represented as a narrow bar followed by a wide space and
+  # a binary "1" is a wide bar followed by a narrow space.
+  # The bits are ordered ascending, so 9 is 1001 binary,
+  # "wn nw nw wn" in w/n format.
+  #
+  # 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 author is aware of no standards for display.
+
+  class Plessey < Barcode1D
+
+    # Character sequence - 0-based offset in this string is character
+    # number
+    CHAR_SEQUENCE = "0123456789ABCDEF"
+
+    # Patterns for making bar codes
+    PATTERNS = {
+      '0'=> {'val'=>0 ,'wn'=>'nwnwnwnw'},
+      '1'=> {'val'=>1 ,'wn'=>'wnnwnwnw'},
+      '2'=> {'val'=>2 ,'wn'=>'nwwnnwnw'},
+      '3'=> {'val'=>3 ,'wn'=>'wnwnnwnw'},
+      '4'=> {'val'=>4 ,'wn'=>'nwnwwnnw'},
+      '5'=> {'val'=>5 ,'wn'=>'wnnwwnnw'},
+      '6'=> {'val'=>6 ,'wn'=>'nwwnwnnw'},
+      '7'=> {'val'=>7 ,'wn'=>'wnwnwnnw'},
+      '8'=> {'val'=>8 ,'wn'=>'nwnwnwwn'},
+      '9'=> {'val'=>9 ,'wn'=>'wnnwnwwn'},
+      'A'=> {'val'=>10 ,'wn'=>'nwwnnwwn'},
+      'B'=> {'val'=>11 ,'wn'=>'wnwnnwwn'},
+      'C'=> {'val'=>12 ,'wn'=>'nwnwwnwn'},
+      'D'=> {'val'=>13 ,'wn'=>'wnnwwnwn'},
+      'E'=> {'val'=>14 ,'wn'=>'nwwnwnwn'},
+      'F'=> {'val'=>15 ,'wn'=>'wnwnwnwn'}
+    }
+
+    GUARD_PATTERN_LEFT_WN = 'wnwnnwwn'
+    GUARD_PATTERN_RIGHT_WN = 'wnwnnwnw'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0',
+      :w_character => 'w',
+      :n_character => 'n',
+      :wn_ratio => '2'
+    }
+
+    class << self
+      # Plessey can encode digits and A-F.
+      def can_encode?(value)
+        value.to_s =~ /\A[0-9A-F]+\z/
+      end
+
+      def generate_check_digit_for(value)
+        raise NotImplementedError
+      end
+
+      def validate_check_digit_for(value)
+        raise NotImplementedError
+      end
+
+      # Decode a string in rle format.  This will return a Plessey
+      # 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}.*?#{GUARD_PATTERN_RIGHT_WN}\z/
+          str.reverse!
+        end
+
+        unless str =~ /\A#{GUARD_PATTERN_LEFT_WN}(.*?)#{GUARD_PATTERN_RIGHT_WN}\z/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        wn_pattern = $1
+
+        # Each pattern is 4 bars and 4 spaces, with a space between.
+        unless wn_pattern.size % 8 == 0
+          raise UnencodableCharactersError, "Wrong number of bars."
+        end
+
+        decoded_string = ''
+
+        wn_pattern.scan(/.{8}/).each do |chunk|
+
+          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
+
+        Plessey.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
+      @encoded_string = value.to_s
+      @check_digit = nil
+    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 + @encoded_string.split('').collect { |c| PATTERNS[c]['wn'] }.join + GUARD_PATTERN_RIGHT_WN
+    end
+
+  end
+end

data/test/test_barcode1dmsi.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 Barcode1DToolsMSITest < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random number from 1 to 10 digits long
+  def random_msi_value(len)
+    (1..1+rand(len)).collect { "0123456789"[rand(11),1] }.join
+  end
+
+  def test_checksum_generation
+    assert_equal '4', Barcode1DTools::MSI.generate_check_digit_for('1234567', :check_digit => 'mod 10')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::MSI.validate_check_digit_for('12345674', :check_digit => 'mod 10')
+  end
+
+  def test_attr_readers
+    msi = Barcode1DTools::MSI.new('1234567', :check_digit => 'mod 10', :checksum_included => false)
+    assert_equal '4', msi.check_digit
+    assert_equal '1234567', msi.value
+    assert_equal '12345674', msi.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is 5
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::MSI.new('12345671', :check_digit => 'mod 10', :checksum_included => true) }
+  end
+
+  def test_skip_checksum
+    msi = Barcode1DTools::MSI.new('12345', :skip_checksum => true)
+    assert_nil msi.check_digit
+    assert_equal '12345', msi.value
+    assert_equal '12345', msi.encoded_string
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::MSI.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  # Only need to test wn, as bars and rle are based on wn
+  def test_barcode_generation
+    msi = Barcode1DTools::MSI.new('12345674', :skip_checksum => true, :line_character => '#', :space_character => ' ')
+    assert_equal "## #  #  #  ## #  #  ## #  #  #  ## ## #  ## #  #  #  ## #  ## #  ## ## #  #  ## ## ## #  ## #  #  #  #", msi.bars
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::MSI.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::MSI.decode('x'*60) }
+    # proper start & stop, but crap in middle
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::MSI.decode('nnwwnnnnnnnnnnnwwn') }
+    # wrong start/stop
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::MSI.decode('nwwnwnwnwnwnwnw') }
+  end
+
+  def test_decoding
+    random_msi_num=random_msi_value(10)
+    msi = Barcode1DTools::MSI.new(random_msi_num, :skip_checksum => true)
+    msi2 = Barcode1DTools::MSI.decode(msi.wn)
+    assert_equal msi.value, msi2.value
+    # Should also work in reverse
+    msi4 = Barcode1DTools::MSI.decode(msi.wn.reverse)
+    assert_equal msi.value, msi4.value
+  end
+end

data/test/test_barcode1dplessey.rb

@@ -0,0 +1,53 @@
+#--
+# 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 Barcode1DToolsPlesseyTest < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random number from 1 to 10 digits long
+  def random_plessey_value(len)
+    (1..1+rand(len)).collect { "0123456789"[rand(11),1] }.join
+  end
+
+  def test_attr_readers
+    plessey = Barcode1DTools::Plessey.new('12345')
+    assert_nil plessey.check_digit
+    assert_equal '12345', plessey.value
+    assert_equal '12345', plessey.encoded_string
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Plessey.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Plessey.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Plessey.decode('x'*60) }
+    # proper start & stop, but crap in middle
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Plessey.decode('nnwwnnnnnnnnnnnwwn') }
+    # wrong start/stop
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Plessey.decode('nwwnwnwnwnwnwnw') }
+  end
+
+  def test_decoding
+    random_plessey_num=random_plessey_value(10)
+    plessey = Barcode1DTools::Plessey.new(random_plessey_num)
+    plessey2 = Barcode1DTools::Plessey.decode(plessey.wn)
+    assert_equal plessey.value, plessey2.value
+    # Should also work in reverse
+    plessey4 = Barcode1DTools::Plessey.decode(plessey.wn.reverse)
+    assert_equal plessey.value, plessey4.value
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: barcode1dtools
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 39
   prerelease: 
   segments: 
   - 0
   - 9
-  - 7
+  - 8
   - 0
-  version: 0.9.7.0
+  version: 0.9.8.0
 platform: ruby
 authors: 
 - Michael Chaney
@@ -23,13 +23,13 @@ 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, Code 11, Codabar, Interleaved 2 of 5, COOP 2 of 5, Matrix 2 of\n\
-  \t 5, Industrial 2 of 5, IATA 2 of 5, PostNet, 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"
+  \t 5, Industrial 2 of 5, IATA 2 of 5, PostNet, Plessey, MSI (Modified\n\
+  \t Plessey), EAN-13, EAN-8, UPC-A, UPC-E, UPC Supplemental 2, and UPC\n\
+  \t Supplemental 5.  Patterns are created in either a simple format of\n\
+  \t bars and spaces or as a run-length encoded string.  This only\n\
+  \t generates and decodes the patterns; actual display or reading from a\n\
+  \t device must be implemented by the programmer.  More symbologies will\n\
+  \t be added as time permits.\n"
 email: mdchaney@michaelchaney.com
 executables: []
 
@@ -49,6 +49,8 @@ files:
 - lib/barcode1dtools/industrial2of5.rb
 - lib/barcode1dtools/interleaved2of5.rb
 - lib/barcode1dtools/matrix2of5.rb
+- lib/barcode1dtools/msi.rb
+- lib/barcode1dtools/plessey.rb
 - lib/barcode1dtools/postnet.rb
 - lib/barcode1dtools/upc_a.rb
 - lib/barcode1dtools/upc_e.rb
@@ -68,6 +70,8 @@ files:
 - test/test_barcode1diata2of5.rb
 - test/test_barcode1dindustrial2of5.rb
 - test/test_barcode1dmatrix2of5.rb
+- test/test_barcode1dmsi.rb
+- test/test_barcode1dplessey.rb
 - test/test_barcode1dpostnet.rb
 - test/test_barcode1dupca.rb
 - test/test_barcode1dupce.rb
@@ -123,6 +127,8 @@ test_files:
 - test/test_barcode1diata2of5.rb
 - test/test_barcode1dindustrial2of5.rb
 - test/test_barcode1dmatrix2of5.rb
+- test/test_barcode1dmsi.rb
+- test/test_barcode1dplessey.rb
 - test/test_barcode1dpostnet.rb
 - test/test_barcode1dupca.rb
 - test/test_barcode1dupce.rb