arena_barby 0.3.2

data/lib/barby/barcode/code_25.rb

@@ -0,0 +1,193 @@
+require 'barby/barcode'
+
+module Barby
+
+
+  #Standard/Industrial 2 of 5, non-interleaved
+  #
+  #Checksum not included by default, to include it,
+  #set include_checksum = true
+  class Code25 < Barcode1D
+
+    WIDE   = W = true
+    NARROW = N = false
+
+    START_ENCODING = [W,W,N]
+    STOP_ENCODING  = [W,N,W]
+
+    ENCODINGS = {
+      0 => [N,N,W,W,N],
+      1 => [W,N,N,N,W],
+      2 => [N,W,N,N,W],
+      3 => [W,W,N,N,N],
+      4 => [N,N,W,N,W],
+      5 => [W,N,W,N,N],
+      6 => [N,W,W,N,N],
+      7 => [N,N,N,W,W],
+      8 => [W,N,N,W,N],
+      9 => [N,W,N,W,N]
+    }
+
+    attr_accessor :data, :narrow_width, :wide_width, :space_width, :include_checksum
+
+  
+    def initialize(data)
+      self.data = data
+    end
+
+
+    def data_encoding
+      digit_encodings.join
+    end
+
+    def data_encoding_with_checksum
+      digit_encodings_with_checksum.join
+    end
+
+    def encoding
+      start_encoding+(include_checksum? ? data_encoding_with_checksum : data_encoding)+stop_encoding
+    end
+
+
+    def characters
+      data.split(//)
+    end
+
+    def characters_with_checksum
+      characters.push(checksum.to_s)
+    end
+
+    def digits
+      characters.map{|c| c.to_i }
+    end
+
+    def digits_with_checksum
+      digits.push(checksum)
+    end
+
+    def even_and_odd_digits
+      alternater = false
+      digits.reverse.partition{ alternater = !alternater }
+    end
+
+
+    def digit_encodings
+      raise_invalid unless valid?
+      digits.map{|d| encoding_for(d) }
+    end
+    alias character_encodings digit_encodings
+
+    def digit_encodings_with_checksum
+      raise_invalid unless valid?
+      digits_with_checksum.map{|d| encoding_for(d) }
+    end
+    alias character_encodings_with_checksum digit_encodings_with_checksum
+
+
+    #Returns the encoding for a single digit
+    def encoding_for(digit)
+      encoding_for_bars(ENCODINGS[digit])
+    end
+
+    #Generate encoding for an array of W,N
+    def encoding_for_bars(*bars)
+      wide, narrow, space = wide_encoding, narrow_encoding, space_encoding
+      bars.flatten.inject '' do |enc,bar|
+        enc + (bar == WIDE ? wide : narrow) + space
+      end
+    end
+
+    def encoding_for_bars_without_end_space(*a)
+      encoding_for_bars(*a).gsub(/0+$/, '')
+    end
+
+
+    #Mod10
+    def checksum
+      evens, odds = even_and_odd_digits
+      sum = odds.inject(0){|sum,d| sum + d } + evens.inject(0){|sum,d| sum + (d*3) }
+      sum %= 10
+      sum.zero? ? 0 : 10-sum
+    end
+
+    def checksum_encoding
+      encoding_for(checksum)
+    end
+
+
+    #The width of a narrow bar in xdims
+    def narrow_width
+      @narrow_width || 1
+    end
+
+    #The width of a wide bar in xdims
+    #By default three times as wide as a narrow bar
+    def wide_width
+      @wide_width || narrow_width*3
+    end
+
+    #The width of the space between the bars in xdims
+    #By default the same width as a narrow bar
+    #
+    #A space serves only as a separator for the bars,
+    #there is no encoded meaning in them
+    def space_width
+      @space_width || narrow_width
+    end
+
+
+    #2 of 5 doesn't require a checksum, but you can include a Mod10 checksum
+    #by setting +include_checksum+ to true
+    def include_checksum?
+      include_checksum
+    end
+
+
+    def data=(data)
+      @data = "#{data}"
+    end
+
+
+    def start_encoding
+      encoding_for_bars(START_ENCODING)
+    end
+
+    def stop_encoding
+      encoding_for_bars_without_end_space(STOP_ENCODING)
+    end
+
+
+    def narrow_encoding
+      '1' * narrow_width
+    end
+
+    def wide_encoding
+      '1' * wide_width
+    end
+
+    def space_encoding
+      '0' * space_width
+    end
+
+
+    def valid?
+      data =~ /^[0-9]*$/
+    end
+
+
+    def to_s
+      (include_checksum? ? characters_with_checksum : characters).join
+    end
+
+
+  private
+
+    def raise_invalid
+      raise ArgumentError, "data not valid"
+    end
+
+
+  end
+
+
+end

data/lib/barby/barcode/code_25_iata.rb

@@ -0,0 +1,23 @@
+require 'barby/barcode/code_25'
+
+module Barby
+
+  #The IATA version of 2 of 5 is identical to its parent except for different
+  #start and stop codes. This is the one used on the tags they put on your
+  #luggage when you check it in at the airport.
+  class Code25IATA < Code25
+
+    START_ENCODING = [N,N]
+    STOP_ENCODING  = [W,N]
+
+    def start_encoding
+      encoding_for_bars(START_ENCODING)
+    end
+
+    def stop_encoding
+      encoding_for_bars_without_end_space(STOP_ENCODING)
+    end
+
+  end
+
+end

data/lib/barby/barcode/code_25_interleaved.rb

@@ -0,0 +1,73 @@
+require 'barby/barcode/code_25'
+
+module Barby
+
+  #Code 2 of 5 interleaved. Same as standard 2 of 5, but spaces are used
+  #for encoding as well as the bars. Each pair of numbers get interleaved,
+  #that is, the first is encoded in the bars and the second is encoded
+  #in the spaced. This means an interleaved 2/5 barcode must have an even
+  #number of digits.
+  class Code25Interleaved < Code25
+
+    START_ENCODING = [N,N,N,N]
+    STOP_ENCODING =  [W,N,N]
+
+
+    def digit_pairs(d=nil)
+      (d || digits).inject [] do |ary,d|
+        ary << [] if !ary.last || ary.last.size == 2
+        ary.last << d
+        ary
+      end
+    end
+
+    def digit_pairs_with_checksum
+      digit_pairs(digits_with_checksum)
+    end
+
+
+    def digit_encodings
+      raise_invalid unless valid?
+      digit_pairs.map{|p| encoding_for_pair(p) }
+    end
+
+    def digit_encodings_with_checksum
+      digit_pairs_with_checksum.map{|p| encoding_for_pair(p) }
+    end
+
+
+    def encoding_for_pair(pair)
+      bars, spaces = ENCODINGS[pair.first], ENCODINGS[pair.last]
+      encoding_for_interleaved(bars.zip(spaces))
+    end
+
+
+    #Encodes an array of interleaved W or N bars and spaces
+    #ex: [W,N,W,W,N,N] => "111011100010"
+    def encoding_for_interleaved(*bars_and_spaces)
+      bar = false#starts with bar
+      bars_and_spaces.flatten.inject '' do |enc,bar_or_space|
+        bar = !bar
+        enc << (bar ? '1' : '0') * (bar_or_space == WIDE ? wide_width : narrow_width)
+      end
+    end
+
+
+    def start_encoding
+      encoding_for_interleaved(START_ENCODING)
+    end
+
+    def stop_encoding
+      encoding_for_interleaved(STOP_ENCODING)
+    end
+
+
+    def valid?
+      #                           When checksum is included, it's included when determining "evenness"
+      super && digits.size % 2 == (include_checksum? ? 1 : 0)
+    end
+
+
+  end
+
+end

data/lib/barby/barcode/code_39.rb

@@ -0,0 +1,233 @@
+require 'barby/barcode'
+
+module Barby
+
+
+  class Code39 < Barcode1D
+
+    WIDE   = W = true
+    NARROW = N = false
+
+    ENCODINGS = {
+      ' ' => [N,W,W,N,N,N,W,N,N], '$' => [N,W,N,W,N,W,N,N,N],
+      '%' => [N,N,N,W,N,W,N,W,N], '+' => [N,W,N,N,N,W,N,W,N],
+      '-' => [N,W,N,N,N,N,W,N,W], '.' => [W,W,N,N,N,N,W,N,N],
+      '/' => [N,W,N,W,N,N,N,W,N], '0' => [N,N,N,W,W,N,W,N,N],
+      '1' => [W,N,N,W,N,N,N,N,W], '2' => [N,N,W,W,N,N,N,N,W],
+      '3' => [W,N,W,W,N,N,N,N,N], '4' => [N,N,N,W,W,N,N,N,W],
+      '5' => [W,N,N,W,W,N,N,N,N], '6' => [N,N,W,W,W,N,N,N,N],
+      '7' => [N,N,N,W,N,N,W,N,W], '8' => [W,N,N,W,N,N,W,N,N],
+      '9' => [N,N,W,W,N,N,W,N,N], 'A' => [W,N,N,N,N,W,N,N,W],
+      'B' => [N,N,W,N,N,W,N,N,W], 'C' => [W,N,W,N,N,W,N,N,N],
+      'D' => [N,N,N,N,W,W,N,N,W], 'E' => [W,N,N,N,W,W,N,N,N],
+      'F' => [N,N,W,N,W,W,N,N,N], 'G' => [N,N,N,N,N,W,W,N,W],
+      'H' => [W,N,N,N,N,W,W,N,N], 'I' => [N,N,W,N,N,W,W,N,N],
+      'J' => [N,N,N,N,W,W,W,N,N], 'K' => [W,N,N,N,N,N,N,W,W],
+      'L' => [N,N,W,N,N,N,N,W,W], 'M' => [W,N,W,N,N,N,N,W,N],
+      'N' => [N,N,N,N,W,N,N,W,W], 'O' => [W,N,N,N,W,N,N,W,N],
+      'P' => [N,N,W,N,W,N,N,W,N], 'Q' => [N,N,N,N,N,N,W,W,W],
+      'R' => [W,N,N,N,N,N,W,W,N], 'S' => [N,N,W,N,N,N,W,W,N],
+      'T' => [N,N,N,N,W,N,W,W,N], 'U' => [W,W,N,N,N,N,N,N,W],
+      'V' => [N,W,W,N,N,N,N,N,W], 'W' => [W,W,W,N,N,N,N,N,N],
+      'X' => [N,W,N,N,W,N,N,N,W], 'Y' => [W,W,N,N,W,N,N,N,N],
+      'Z' => [N,W,W,N,W,N,N,N,N]
+    }
+
+    #In extended mode, each character is replaced with two characters from the "normal" encoding
+    EXTENDED_ENCODINGS = {
+      "\000" => '%U',    " " => " ",     "@"  => "%V",    "`" =>    "%W",
+      "\001" => '$A',    "!" => "/A",    "A"  => "A",     "a" =>    "+A",
+      "\002" => '$B',    '"' => "/B",    "B"  => "B",     "b" =>    "+B",
+      "\003" => '$C',    "#" => "/C",    "C"  => "C",     "c" =>    "+C",
+      "\004" => '$D',    "$" => "/D",    "D"  => "D",     "d" =>    "+D",
+      "\005" => '$E',    "%" => "/E",    "E"  => "E",     "e" =>    "+E",
+      "\006" => '$F',    "&" => "/F",    "F"  => "F",     "f" =>    "+F",
+      "\007" => '$G',    "'" => "/G",    "G"  => "G",     "g" =>    "+G",
+      "\010" => '$H',    "(" => "/H",    "H"  => "H",     "h" =>    "+H",
+      "\011" => '$I',    ")" => "/I",    "I"  => "I",     "i" =>    "+I",
+      "\012" => '$J',    "*" => "/J",    "J"  => "J",     "j" =>    "+J",
+      "\013" => '$K',    "+" => "/K",    "K"  => "K",     "k" =>    "+K",
+      "\014" => '$L',    "," => "/L",    "L"  => "L",     "l" =>    "+L",
+      "\015" => '$M',    "-" => "-",     "M"  => "M",     "m" =>    "+M",
+      "\016" => '$N',    "." => ".",     "N"  => "N",     "n" =>    "+N",
+      "\017" => '$O',    "/" => "/O",    "O"  => "O",     "o" =>    "+O",
+      "\020" => '$P',    "0" => "0",     "P"  => "P",     "p" =>    "+P",
+      "\021" => '$Q',    "1" => "1",     "Q"  => "Q",     "q" =>    "+Q",
+      "\022" => '$R',    "2" => "2",     "R"  => "R",     "r" =>    "+R",
+      "\023" => '$S',    "3" => "3",     "S"  => "S",     "s" =>    "+S",
+      "\024" => '$T',    "4" => "4",     "T"  => "T",     "t" =>    "+T",
+      "\025" => '$U',    "5" => "5",     "U"  => "U",     "u" =>    "+U",
+      "\026" => '$V',    "6" => "6",     "V"  => "V",     "v" =>    "+V",
+      "\027" => '$W',    "7" => "7",     "W"  => "W",     "w" =>    "+W",
+      "\030" => '$X',    "8" => "8",     "X"  => "X",     "x" =>    "+X",
+      "\031" => '$Y',    "9" => "9",     "Y"  => "Y",     "y" =>    "+Y",
+      "\032" => '$Z',    ":" => "/Z",    "Z"  => "Z",     "z" =>    "+Z",
+      "\033" => '%A',    ";" => "%F",    "["  => "%K",    "{" =>    "%P",
+      "\034" => '%B',    "<" => "%G",    "\\" => "%L",    "|" =>    "%Q",
+      "\035" => '%C',    "=" => "%H",    "]"  => "%M",    "}" =>    "%R",
+      "\036" => '%D',    ">" => "%I",    "^"  => "%N",    "~" =>    "%S",
+      "\037" => '%E',    "?" => "%J",    "_"  => "%O",    "\177" => "%T"
+    }
+
+    CHECKSUM_VALUES = {
+      '0' => 0,   '1' => 1,   '2' => 2,   '3' => 3,
+      '4' => 4,   '5' => 5,   '6' => 6,   '7' => 7,
+      '8' => 8,   '9' => 9,   'A' => 10,  'B' => 11,
+      'C' => 12,  'D' => 13,  'E' => 14,  'F' => 15,
+      'G' => 16,  'H' => 17,  'I' => 18,  'J' => 19,
+      'K' => 20,  'L' => 21,  'N' => 23,  'M' => 22,
+      'O' => 24,  'P' => 25,  'Q' => 26,  'R' => 27,
+      'S' => 28,  'T' => 29,  'U' => 30,  'V' => 31,
+      'W' => 32,  'X' => 33,  'Y' => 34,  'Z' => 35,
+      '-' => 36,  '.' => 37,  ' ' => 38,  '$' => 39,
+      '/' => 40,  '+' => 41,  '%' => 42
+    }
+
+    START_ENCODING = [N,W,N,N,W,N,W,N,N] # *
+    STOP_ENCODING  = [N,W,N,N,W,N,W,N,N] # *
+
+    attr_accessor :data, :spacing, :narrow_width, :wide_width, :extended, :include_checksum
+    
+
+    def initialize(data, extended=false)
+      self.data = data
+      self.extended = extended
+      raise(ArgumentError, "data is not valid (extended=#{extended?})") unless valid?
+      yield self if block_given?
+    end
+
+
+    #Returns the characters that were passed in, no matter it they're part of
+    #the extended charset or if they're already encodable, "normal" characters
+    def raw_characters
+      data.split(//)
+    end
+
+    #Returns the encodable characters. If extended mode is enabled, each character will
+    #first be replaced by two characters from the encodable charset
+    def characters
+      chars = raw_characters
+      extended ? chars.map{|c| EXTENDED_ENCODINGS[c].split(//) }.flatten : chars
+    end
+
+    def characters_with_checksum
+      characters + [checksum_character]
+    end
+
+    def encoded_characters
+      characters.map{|c| encoding_for(c) }
+    end
+
+    def encoded_characters_with_checksum
+      encoded_characters + [checksum_encoding]
+    end
+
+
+    #The data part of the encoding (no start+stop characters)
+    def data_encoding
+      encoded_characters.join(spacing_encoding)
+    end
+
+    def data_encoding_with_checksum
+      encoded_characters_with_checksum.join(spacing_encoding)
+    end
+
+
+    def encoding
+      return encoding_with_checksum if include_checksum?
+      start_encoding+spacing_encoding+data_encoding+spacing_encoding+stop_encoding
+    end
+
+    def encoding_with_checksum
+      start_encoding+spacing_encoding+data_encoding_with_checksum+spacing_encoding+stop_encoding
+    end
+
+
+    #Checksum is optional
+    def checksum
+      characters.inject(0) do |sum,char|
+        sum + CHECKSUM_VALUES[char]
+      end % 43
+    end
+
+    def checksum_character
+      CHECKSUM_VALUES.invert[checksum]
+    end
+
+    def checksum_encoding
+      encoding_for(checksum_character)
+    end
+
+    #Set include_checksum to true to make +encoding+ include the checksum
+    def include_checksum?
+      include_checksum
+    end
+
+
+    #Takes an array of WIDE/NARROW values and returns the string representation for
+    #those bars and spaces, using wide_width and narrow_width
+    def encoding_for_bars(*bars_and_spaces)
+      bar = false
+      bars_and_spaces.flatten.map do |width|
+        bar = !bar
+        (bar ? '1' : '0') * (width == WIDE ? wide_width : narrow_width)
+      end.join
+    end
+
+    #Returns the string representation for a single character
+    def encoding_for(character)
+      encoding_for_bars(ENCODINGS[character])
+    end
+
+
+    #Spacing between the characters in xdims. Spacing will be inserted
+    #between each character in the encoding
+    def spacing
+      @spacing ||= 1
+    end
+
+    def spacing_encoding
+      '0' * spacing
+    end
+
+
+    def narrow_width
+      @narrow_width ||= 1
+    end
+
+    def wide_width
+      @wide_width ||= 2
+    end
+
+
+    def extended?
+      extended
+    end
+
+
+    def start_encoding
+      encoding_for_bars(START_ENCODING)
+    end
+
+    def stop_encoding
+      encoding_for_bars(STOP_ENCODING)
+    end
+
+    def valid?
+      if extended?
+        raw_characters.all?{|c| EXTENDED_ENCODINGS.include?(c) }
+      else
+        raw_characters.all?{|c| ENCODINGS.include?(c) }
+      end
+    end
+
+
+    def to_s
+      data
+    end
+
+
+  end
+
+
+end