barby 0.1.2 → 0.2.0

data/bin/barby

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'rubygems'
+
+#$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'barby'
+
+options = {
+  :outputter => 'Png',
+  :outputter_method => 'to_png'
+}
+
+ARGV.options do |o|
+  o.banner = "  Usage: #{File.basename(__FILE__)} [OPTIONS] data"
+  o.define_head '  Generates barcodes and prints the generated output to STDOUT'
+
+  o.separator ''
+  o.separator '  EXPERIMENTAL'
+  o.separator ''
+
+  o.on('-b', '--barcode=ClassName', String, 'Barcode type'){|v| options[:barcode] = v }
+  o.on('-o', '--outputter=ClassName', String, 'Outputter'){|v| options[:outputter] = v }
+  o.on('-m', '--method=method_name', String, 'Outputter method'){|v| options[:outputter_method] = v }
+
+  o.on_tail("-h", "--help", "Show this help message.") { puts o; exit }
+    
+  o.parse!
+end
+
+#p STDIN.read
+#exit
+
+require "barby/outputter/#{options[:outputter].gsub(/[A-Z]/){|c| '_'+c.downcase }[1..-1]}_outputter"
+
+barcode_class = Barby.const_get(options[:barcode])
+barcode = barcode_class.new($*.empty? ? STDIN.read.chomp : $*)
+outputter_class = Barby.const_get("#{options[:outputter]}Outputter")
+outputter = outputter_class.new(barcode)
+
+print eval("outputter.#{options[:outputter_method]}(#{ENV['OPTIONS']})")

data/lib/barby.rb

@@ -1,11 +1,14 @@
+require 'barby/vendor'
 require 'barby/version'
 
 require 'barby/barcode'
 require 'barby/barcode/code_128'
 require 'barby/barcode/gs1_128'
 require 'barby/barcode/code_39'
+require 'barby/barcode/code_93'
 require 'barby/barcode/ean_13'
 require 'barby/barcode/ean_8'
 require 'barby/barcode/bookland'
+require 'barby/barcode/qr_code'
 
 require 'barby/outputter'

data/lib/barby/barcode.rb

@@ -41,6 +41,12 @@ module Barby
     end
 
 
+    #Is this barcode 2D?
+    def two_dimensional?
+      is_a? Barcode2D
+    end
+
+
     def method_missing(name, *args, &b)#:nodoc:
       #See if an outputter has registered this method
       if self.class.outputters.include?(name)

data/lib/barby/barcode/code_128.rb

@@ -4,6 +4,19 @@ module Barby
 
 
   #Code 128 barcodes
+  #
+  #Note that you must provide a type for each object, either by passing a string
+  #as a second parameter to Code128.new or by instantiating one of the child classes.
+  #
+  #You can switch type by using the CODEA, CODEB and CODEC characters:
+  #
+  # "\305" => A
+  # "\306" => B
+  # "\307" => C
+  #
+  #As an example, here's one that starts out as type A and then switches to B and then C:
+  #
+  #  Code128A.new("ABC123\306def\3074567")
   class Code128 < Barcode1D
 
     ENCODINGS = {
@@ -47,7 +60,7 @@ module Barby
 
     VALUES = {
       'A' => {
-        0 => "SP",      1 => "!",        2 => "\"",
+        0 => " ",      1 => "!",        2 => "\"",
         3 => "#",       4 => "$",        5 => "%",
         6 => "&",       7 => "'",        8 => "(",
         9 => ")",       10 => "*",       11 => "+",
@@ -80,13 +93,13 @@ module Barby
         90 => "\032",   91 => "\e",      92 => "\034",
         93 => "\035",   94 => "\036",    95 => "\037",
         96 => "\303",   97 => "\302",    98 => "SHIFT",
-        99 => "\307",  100 => "\306",  101 => "\304",
+        99 => "\307",   100 => "\306",   101 => "\304",
         102 => "\301",  103 => "STARTA", 104 => "STARTB",
         105 => "STARTC"
       }.invert,
 
       'B' => {
-        0 => "SP", 1 => "!", 2 => "\"", 3 => "#", 4 => "$", 5 => "%",
+        0 => " ", 1 => "!", 2 => "\"", 3 => "#", 4 => "$", 5 => "%",
         6 => "&", 7 => "'", 8 => "(", 9 => ")", 10 => "*", 11 => "+",
         12 => ",", 13 => "-", 14 => ".", 15 => "/", 16 => "0", 17 => "1",
         18 => "2", 19 => "3", 20 => "4", 21 => "5", 22 => "6", 23 => "7",

data/lib/barby/barcode/code_25.rb

@@ -0,0 +1,161 @@
+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
+      data_encoding+checksum_encoding
+    end
+
+    def encoding
+      start_encoding+(include_checksum? ? data_encoding_with_checksum : data_encoding)+stop_encoding
+    end
+
+
+    def characters
+      data.split(//)
+    end
+
+    def digits
+      characters.map{|c| c.to_i }
+    end
+
+    def even_and_odd_digits
+      alternater = false
+      digits.reverse.partition{ alternater = !alternater }
+    end
+
+
+    def digit_encodings
+      digits.map{|d| encoding_for(d) }
+    end
+    alias character_encodings digit_encodings
+
+
+    #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
+
+
+    #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
+
+
+    def include_checksum?
+      include_checksum
+    end
+
+
+    def data=(data)
+      @data = "#{data}"
+    end
+
+
+    def start_encoding
+      encoding_for_bars(START_ENCODING)
+    end
+
+    def stop_encoding
+      #Removes trailing space generated by encoding_for_bars
+      encoding_for_bars(STOP_ENCODING).gsub(/0+$/, '')
+    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
+
+
+  end
+
+
+end

data/lib/barby/barcode/code_25_interleaved.rb

@@ -0,0 +1,73 @@
+require 'barby/barcode/code_25'
+
+module Barby
+
+  class Code25Interleaved < Code25
+
+    START_ENCODING = [N,N,N,N]
+    STOP_ENCODING =  [W,N,N]
+
+
+    def data_encoding
+      digit_pair_encodings.join
+    end
+
+
+    def character_pairs
+      chars = characters
+      pairs = Array.new((chars.size/2.0).ceil){ [] }
+      chars.each_with_index{|c,i| pairs[(i/2.0).floor] << c }
+      pairs
+    end
+
+    def digit_pairs
+      d = digits
+      pairs = Array.new((d.size/2.0).ceil){ [] }
+      d.each_with_index{|dd,i| pairs[(i/2.0).floor] << dd }
+      pairs
+    end
+
+
+    def digit_pair_encodings
+      digit_pairs.map{|p| encoding_for_pair(p) }
+    end
+
+
+    def encoding_for_pair(pair)
+      bars, spaces = ENCODINGS[pair.first], ENCODINGS[pair.last]
+      bars.zip(spaces).inject '' do |enc,p|
+        bar, space = *p
+        enc + ('1' *  (bar == WIDE ? wide_width : narrow_width)) +
+        ('0' *  (space == WIDE ? wide_width : narrow_width))
+      end
+    end
+
+    #def encoding_for_bars(*bars_and_spaces)
+    #  bar = false
+    #  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
+      bar = false
+      START_ENCODING.inject '' do |enc,bar_or_space|
+        bar = !bar
+        enc << (bar ? '1' : '0') * (bar_or_space == WIDE ? wide_width : narrow_width)
+      end
+    end
+
+    def stop_encoding
+      bar = false
+      STOP_ENCODING.inject '' do |enc,bar_or_space|
+        bar = !bar
+        enc << (bar ? '1' : '0') * (bar_or_space == WIDE ? wide_width : narrow_width)
+      end
+    end
+
+
+  end
+
+end

data/lib/barby/barcode/code_93.rb

@@ -0,0 +1,225 @@
+require 'barby/barcode'
+
+module Barby
+
+  class Code93 < Barcode1D
+
+    SHIFT_DOLLAR  = "\301" # ($)
+    SHIFT_PERCENT = "\302" # (%)
+    SHIFT_SLASH   = "\303" # (/)
+    SHIFT_PLUS    = "\304" # (+)
+
+    SHIFT_CHARACTERS = [SHIFT_DOLLAR, SHIFT_PERCENT, SHIFT_SLASH, SHIFT_PLUS]
+
+    ENCODINGS = {
+      "0" => "100010100", "1" => "101001000",
+      "2" => "101000100", "3" => "101000010",
+      "4" => "100101000", "5" => "100100100",
+      "6" => "100100010", "7" => "101010000",
+      "8" => "100010010", "9" => "100001010",
+      "A" => "110101000", "B" => "110100100",
+      "C" => "110100010", "D" => "110010100",
+      "E" => "110010010", "F" => "110001010",
+      "G" => "101101000", "H" => "101100100",
+      "I" => "101100010", "J" => "100110100",
+      "K" => "100011010", "L" => "101011000",
+      "M" => "101001100", "N" => "101000110",
+      "O" => "100101100", "P" => "100010110",
+      "Q" => "110110100", "R" => "110110010",
+      "S" => "110101100", "T" => "110100110",
+      "U" => "110010110", "V" => "110011010",
+      "W" => "101101100", "X" => "101100110",
+      "Y" => "100110110", "Z" => "100111010",
+      "-" => "100101110", "." => "111010100",
+      " " => "111010010", "$" => "111001010",
+      "/" => "101101110", "+" => "101110110",
+      "%" => "110101110",
+      SHIFT_DOLLAR  => "100100110",
+      SHIFT_PERCENT => "111011010",
+      SHIFT_SLASH   => "111010110",
+      SHIFT_PLUS    => "100110010"
+    }
+
+    EXTENDED_MAPPING = {
+      "\000" => "\302U",    " "    => " ",        "@"  => "\302V", "`"    =>    "\302W",
+      "\001" => "\301A",    "!"    => "\303A",    "A"  => "A",     "a"    =>    "\304A",
+      "\002" => "\301B",    '"'    => "\303B",    "B"  => "B",     "b"    =>    "\304B",
+      "\003" => "\301C",    "#"    => "\303C",    "C"  => "C",     "c"    =>    "\304C",
+      "\004" => "\301D",    "$"    => "\303D",    "D"  => "D",     "d"    =>    "\304D",
+      "\005" => "\301E",    "%"    => "\303E",    "E"  => "E",     "e"    =>    "\304E",
+      "\006" => "\301F",    "&"    => "\303F",    "F"  => "F",     "f"    =>    "\304F",
+      "\007" => "\301G",    "'"    => "\303G",    "G"  => "G",     "g"    =>    "\304G",
+      "\010" => "\301H",    "("    => "\303H",    "H"  => "H",     "h"    =>    "\304H",
+      "\011" => "\301I",    ")"    => "\303I",    "I"  => "I",     "i"    =>    "\304I",
+      "\012" => "\301J",    "*"    => "\303J",    "J"  => "J",     "j"    =>    "\304J",
+      "\013" => "\301K",    "/"    => "\303K",    "K"  => "K",     "k"    =>    "\304K",
+      "\014" => "\301L",    ","    => "\303L",    "L"  => "L",     "l"    =>    "\304L",
+      "\015" => "\301M",    "-"    => "-",        "M"  => "M",     "m"    =>    "\304M",
+      "\016" => "\301N",    "."    => ".",        "N"  => "N",     "n"    =>    "\304N",
+      "\017" => "\301O",    "+"    => "\303O",    "O"  => "O",     "o"    =>    "\304O",
+      "\020" => "\301P",    "0"    => "0",        "P"  => "P",     "p"    =>    "\304P",
+      "\021" => "\301Q",    "1"    => "1",        "Q"  => "Q",     "q"    =>    "\304Q",
+      "\022" => "\301R",    "2"    => "2",        "R"  => "R",     "r"    =>    "\304R",
+      "\023" => "\301S",    "3"    => "3",        "S"  => "S",     "s"    =>    "\304S",
+      "\024" => "\301T",    "4"    => "4",        "T"  => "T",     "t"    =>    "\304T",
+      "\025" => "\301U",    "5"    => "5",        "U"  => "U",     "u"    =>    "\304U",
+      "\026" => "\301V",    "6"    => "6",        "V"  => "V",     "v"    =>    "\304V",
+      "\027" => "\301W",    "7"    => "7",        "W"  => "W",     "w"    =>    "\304W",
+      "\030" => "\301X",    "8"    => "8",        "X"  => "X",     "x"    =>    "\304X",
+      "\031" => "\301Y",    "9"    => "9",        "Y"  => "Y",     "y"    =>    "\304Y",
+      "\032" => "\301Z",    ":"    => "\303Z",    "Z"  => "Z",     "z"    =>    "\304Z",
+      "\033" => "\302A",    ";"    => "\302F",    "["  => "\302K", "{"    =>    "\302P",
+      "\034" => "\302B",    "<"    => "\302G",    "\\" => "\302L", "|"    =>    "\302Q",
+      "\035" => "\302C",    "="    => "\302H",    "]"  => "\302M", "}"    =>    "\302R",
+      "\036" => "\302D",    ">"    => "\302I",    "^"  => "\302N", "~"    =>    "\302S",
+      "\037" => "\302E",    "?"    => "\302J",    "_"  => "\302O", "\177" =>    "\302T"
+    }
+
+    EXTENDED_CHARACTERS = EXTENDED_MAPPING.keys - ENCODINGS.keys
+
+    CHARACTERS = {
+      0  => "0",  1 => "1", 2  => "2", 3  => "3",
+      4  => "4",  5 => "5", 6  => "6", 7  => "7",
+      8  => "8",  9 => "9", 10 => "A", 11 => "B",
+      12 => "C", 13 => "D", 14 => "E", 15 => "F",
+      16 => "G", 17 => "H", 18 => "I", 19 => "J",
+      20 => "K", 21 => "L", 22 => "M", 23 => "N",
+      24 => "O", 25 => "P", 26 => "Q", 27 => "R",
+      28 => "S", 29 => "T", 30 => "U", 31 => "V",
+      32 => "W", 33 => "X", 34 => "Y", 35 => "Z",
+      36 => "-", 37 => ".", 38 => " ", 39 => "$",
+      40 => "/", 41 => "+", 42 => "%",
+      43 => SHIFT_DOLLAR, 44 => SHIFT_PERCENT,
+      45 => SHIFT_SLASH,  46 => SHIFT_PLUS
+    }
+    
+    VALUES = CHARACTERS.invert
+
+    START_ENCODING     = '101011110' # *
+    STOP_ENCODING      = '101011110'
+    TERMINATE_ENCODING = '1'
+
+    attr_accessor :data
+
+
+    def initialize(data)
+      self.data = data
+    end
+
+
+    def extended?
+      raw_characters.any?{|c| EXTENDED_CHARACTERS.include?(c) }
+    end
+
+
+    def raw_characters
+      data.split(//)
+    end
+
+    def characters
+      raw_characters.map{|c| EXTENDED_MAPPING[c].split(//) }.flatten
+    end
+
+    def encoded_characters
+      characters.map{|c| ENCODINGS[c] }
+    end
+    alias character_encodings encoded_characters
+
+
+    def start_encoding
+      START_ENCODING
+    end
+
+    #The stop encoding includes the termination bar
+    def stop_encoding
+      STOP_ENCODING+TERMINATE_ENCODING
+    end
+
+
+    def encoding
+      start_encoding+data_encoding_with_checksums+stop_encoding
+    end
+
+    def data_encoding
+      character_encodings.join
+    end
+
+    def data_encoding_with_checksums
+      (character_encodings + checksum_encodings).join
+    end
+
+    def checksum_encodings
+      checksum_characters.map{|c| ENCODINGS[c] }
+    end
+
+    def checksum_encoding
+      checksum_encodings.join
+    end
+
+
+    def checksums
+      [c_checksum, k_checksum]
+    end
+
+    def checksum_characters
+      checksums.map{|s| CHARACTERS[s] }
+    end
+
+
+    #Returns the values used for computing the C checksum
+    #in the "right" order (i.e. reversed)
+    def checksum_values
+      characters.map{|c| VALUES[c] }.reverse
+    end
+
+    #Returns the normal checksum plus the c_checksum
+    #This is used for calculating the k_checksum
+    def checksum_values_with_c_checksum
+      [c_checksum] + checksum_values
+    end
+
+
+    #Calculates the C checksum based on checksum_values
+    def c_checksum
+      sum = 0
+      checksum_values.each_with_index do |value, index|
+        sum += ((index % 20) + 1) * value
+      end
+      sum % 47
+    end
+
+    def c_checksum_character
+      CHARACTERS[c_checksum]
+    end
+
+    def c_checksum_encoding
+      ENCODINGS[c_checksum_character]
+    end
+
+
+    #Calculates the K checksum based on checksum_values_with_c_checksum
+    def k_checksum
+      sum = 0
+      checksum_values_with_c_checksum.each_with_index do |value, index|
+        sum += ((index % 15) + 1) * value
+      end
+      sum % 47
+    end
+
+    def k_checksum_character
+      CHARACTERS[k_checksum]
+    end
+
+    def k_checksum_encoding
+      ENCODINGS[k_checksum_character]
+    end
+
+
+    def valid?
+      characters.all?{|c| ENCODINGS.include?(c) }
+    end
+
+
+  end
+
+end