barby 0.1

data/README

@@ -0,0 +1,29 @@
+Barby is a Ruby barcode generator. It does not depend on other libraries
+(for the core functionality) and is easily extentable.
+
+The barcode objects are separated from the process of generating graphical
+(or other) representations. A barcode's only responsibility is to provide
+a string representation consisting of 1s and 0s representing bars and spaces.
+This string can then be used to generate (for example) an image with the
+RMagickOutputter, or an ASCII string such as the one below.
+
+See Barby::Barcode and Barby::Outputter for more information.
+
+ require 'barby'
+ require 'barby/outputter/ascii_outputter'
+
+ barcode = Barby::Code128B.new('BARBY')
+ 
+ puts barcode.to_ascii
+
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+ ## #    #  #   # ##   # #   ##   ##   # ### #   # ##   ### ## #   ## ### ### ##   ### # ##
+            B          A          R          B          Y                                  

data/lib/barby.rb

@@ -0,0 +1,11 @@
+require 'barby/version'
+
+require 'barby/barcode'
+require 'barby/barcode/code_128'
+require 'barby/barcode/gs1_128'
+require 'barby/barcode/code_39'
+require 'barby/barcode/ean_13'
+require 'barby/barcode/ean_8'
+require 'barby/barcode/bookland'
+
+require 'barby/outputter'

data/lib/barby/barcode.rb

@@ -0,0 +1,95 @@
+module Barby
+
+
+  #The base class for all barcodes. It includes some method_missing magic
+  #that is used to find registered outputters.
+  #
+  #The only interface requirement of a barcode class is that is has an encoding
+  #method that returns a string consisting of 1s and 0s representing the barcode's
+  #"black" and "white" parts. One digit is the width of the "X dimension"; that is,
+  #"101100" represents a single-width bar followed by a single-width space, then
+  #a bar and a space twice that width.
+  #
+  #Example implementation:
+  #
+  # class StaticBarcode < Barby::Barcode1D
+  #  def encoding
+  #   '101100111000111100001'
+  #  end
+  # end
+  # 
+  # require 'barby/outputter/ascii_outputter'
+  # puts StaticBarcode.new.to_ascii(:height => 3)
+  #
+  # # ##  ###   ####    #
+  # # ##  ###   ####    #
+  # # ##  ###   ####    #
+  class Barcode
+  
+    
+    #Every barcode must have an encoding method. This method returns
+    #a string containing a series of 1 and 0, representing bars and
+    #spaces. One digit is the width of one "module" or X dimension.
+    def encoding
+      raise NotImplementedError, 'Every barcode should implement this method'
+    end
+
+
+    #Is this barcode valid?
+    def valid?
+      false
+    end
+
+
+    def method_missing(name, *args, &b)#:nodoc:
+      #See if an outputter has registered this method
+      if self.class.outputters.include?(name)
+        klass, method_name = self.class.outputters[name]
+        klass.new(self).send(method_name, *args, &b)
+      else
+        super
+      end
+    end
+
+
+    #Returns an instantiated outputter for +name+ if any outputter
+    #has registered that name
+    def outputter_for(name, *a, &b)
+      outputter_class_for(name).new(self, *a, &b)
+    end
+
+    #Get the outputter class object for +name+
+    def outputter_class_for(name)
+      self.class.outputters[name].first
+    end
+
+
+    class << self
+
+      def outputters
+        @@outputters ||= {}
+      end
+
+      #Registers an outputter with +name+ so that a call to
+      #+name+ on a Barcode instance will be delegated to this outputter
+      def register_outputter(name, klass, method_name)
+        outputters[name] = [klass, method_name]
+      end
+
+    end
+
+  end
+
+
+  #Most barcodes are one-dimensional. They have bars.
+  class Barcode1D < Barcode
+  end
+
+  #There is currently only support for one-dimensional barcodes,
+  #but in the future it should also be possible to support barcodes
+  #with two dimensions.
+  class Barcode2D < Barcode
+  end
+
+
+end

data/lib/barby/barcode/bookland.rb

@@ -0,0 +1,37 @@
+require 'barby/barcode/ean_13'
+
+module Barby
+
+  #Bookland barcodes are EAN-13 barcodes with number system
+  #978 (hence "Bookland"). The data they encode is an ISBN
+  #with its check digit removed. This is a convenience class
+  #that takes an ISBN no instead of "pure" EAN-13 data.
+  class Bookland < EAN13
+
+    BOOKLAND_NUMBER_SYSTEM = '978'
+
+    attr_accessor :isbn
+
+    def initialize(isbn)
+      self.isbn = isbn
+      raise ArgumentError, 'data not valid' unless valid?
+    end
+
+    def data
+      BOOKLAND_NUMBER_SYSTEM+isbn_only
+    end
+
+    #Removes any non-digit characters, number system and check digit
+    #from ISBN, so "978-82-92526-14-9" would result in "829252614"
+    def isbn_only
+      s = isbn.gsub(/[^0-9]/, '')
+      if s.size > 10#Includes number system
+        s[3,9]
+      else#No number system, may include check digit
+        s[0,9]
+      end
+    end
+
+  end
+
+end

data/lib/barby/barcode/code_128.rb

@@ -0,0 +1,361 @@
+require 'barby/barcode'
+
+module Barby
+
+
+  #Code 128 barcodes
+  class Code128 < Barcode1D
+
+    ENCODINGS = {
+      0 => "11011001100", 1 => "11001101100", 2 => "11001100110",
+      3 => "10010011000", 4 => "10010001100", 5 => "10001001100",
+      6 => "10011001000", 7 => "10011000100", 8 => "10001100100",
+      9 => "11001001000", 10 => "11001000100", 11 => "11000100100",
+      12 => "10110011100", 13 => "10011011100", 14 => "10011001110",
+      15 => "10111001100", 16 => "10011101100", 17 => "10011100110",
+      18 => "11001110010", 19 => "11001011100", 20 => "11001001110",
+      21 => "11011100100", 22 => "11001110100", 23 => "11101101110",
+      24 => "11101001100", 25 => "11100101100", 26 => "11100100110",
+      27 => "11101100100", 28 => "11100110100", 29 => "11100110010",
+      30 => "11011011000", 31 => "11011000110", 32 => "11000110110",
+      33 => "10100011000", 34 => "10001011000", 35 => "10001000110",
+      36 => "10110001000", 37 => "10001101000", 38 => "10001100010",
+      39 => "11010001000", 40 => "11000101000", 41 => "11000100010",
+      42 => "10110111000", 43 => "10110001110", 44 => "10001101110",
+      45 => "10111011000", 46 => "10111000110", 47 => "10001110110",
+      48 => "11101110110", 49 => "11010001110", 50 => "11000101110",
+      51 => "11011101000", 52 => "11011100010", 53 => "11011101110",
+      54 => "11101011000", 55 => "11101000110", 56 => "11100010110",
+      57 => "11101101000", 58 => "11101100010", 59 => "11100011010",
+      60 => "11101111010", 61 => "11001000010", 62 => "11110001010",
+      63 => "10100110000", 64 => "10100001100", 65 => "10010110000",
+      66 => "10010000110", 67 => "10000101100", 68 => "10000100110",
+      69 => "10110010000", 70 => "10110000100", 71 => "10011010000",
+      72 => "10011000010", 73 => "10000110100", 74 => "10000110010",
+      75 => "11000010010", 76 => "11001010000", 77 => "11110111010",
+      78 => "11000010100", 79 => "10001111010", 80 => "10100111100",
+      81 => "10010111100", 82 => "10010011110", 83 => "10111100100",
+      84 => "10011110100", 85 => "10011110010", 86 => "11110100100",
+      87 => "11110010100", 88 => "11110010010", 89 => "11011011110",
+      90 => "11011110110", 91 => "11110110110", 92 => "10101111000",
+      93 => "10100011110", 94 => "10001011110", 95 => "10111101000",
+      96 => "10111100010", 97 => "11110101000", 98 => "11110100010",
+      99 => "10111011110", 100 => "10111101110", 101 => "11101011110",
+      102 => "11110101110", 103 => "11010000100", 104 => "11010010000",
+      105 => "11010011100"
+    }
+
+    VALUES = {
+      'A' => {
+        0 => "SP",      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",
+        24 => "8",      25 => "9",       26 => ":",
+        27 => ";",      28 => "<",       29 => "=",
+        30 => ">",      31 => "?",       32 => "@",
+        33 => "A",      34 => "B",       35 => "C",
+        36 => "D",      37 => "E",       38 => "F",
+        39 => "G",      40 => "H",       41 => "I",
+        42 => "J",      43 => "K",       44 => "L",
+        45 => "M",      46 => "N",       47 => "O",
+        48 => "P",      49 => "Q",       50 => "R",
+        51 => "S",      52 => "T",       53 => "U",
+        54 => "V",      55 => "W",       56 => "X",
+        57 => "Y",      58 => "Z",       59 => "[",
+        60 => "\\",     61 => "]",       62 => "^",
+        63 => "_",      64 => "\000",    65 => "\001",
+        66 => "\002",   67 => "\003",    68 => "\004",
+        69 => "\005",   70 => "\006",    71 => "\a",
+        72 => "\b",     73 => "\t",      74 => "\n",
+        75 => "\v",     76 => "\f",      77 => "\r",
+        78 => "\016",   79 => "\017",    80 => "\020",
+        81 => "\021",   82 => "\022",    83 => "\023",
+        84 => "\024",   85 => "\025",    86 => "\026",
+        87 => "\027",   88 => "\030",    89 => "\031",
+        90 => "\032",   91 => "\e",      92 => "\034",
+        93 => "\035",   94 => "\036",    95 => "\037",
+        96 => "\303",   97 => "\302",    98 => "SHIFT",
+        99 => "\307",  100 => "\306",  101 => "\304",
+        102 => "\301",  103 => "STARTA", 104 => "STARTB",
+        105 => "STARTC"
+      }.invert,
+
+      'B' => {
+        0 => "SP", 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",
+        24 => "8", 25 => "9", 26 => ":", 27 => ";", 28 => "<", 29 => "=",
+        30 => ">", 31 => "?", 32 => "@", 33 => "A", 34 => "B", 35 => "C",
+        36 => "D", 37 => "E", 38 => "F", 39 => "G", 40 => "H", 41 => "I",
+        42 => "J", 43 => "K", 44 => "L", 45 => "M", 46 => "N", 47 => "O",
+        48 => "P", 49 => "Q", 50 => "R", 51 => "S", 52 => "T", 53 => "U",
+        54 => "V", 55 => "W", 56 => "X", 57 => "Y", 58 => "Z", 59 => "[",
+        60 => "\\", 61 => "]", 62 => "^", 63 => "_", 64 => "`", 65 => "a",
+        66 => "b", 67 => "c", 68 => "d", 69 => "e", 70 => "f", 71 => "g",
+        72 => "h", 73 => "i", 74 => "j", 75 => "k", 76 => "l", 77 => "m",
+        78 => "n", 79 => "o", 80 => "p", 81 => "q", 82 => "r", 83 => "s",
+        84 => "t", 85 => "u", 86 => "v", 87 => "w", 88 => "x", 89 => "y",
+        90 => "z", 91 => "{", 92 => "|", 93 => "}", 94 => "~", 95 => "\177",
+        96 => "\303", 97 => "\302", 98 => "SHIFT", 99 => "\307", 100 => "\304",
+        101 => "\305", 102 => "\301", 103 => "STARTA", 104 => "STARTB",
+        105 => "STARTC",
+      }.invert,
+
+      'C' => {
+        0 => "00", 1 => "01", 2 => "02", 3 => "03", 4 => "04", 5 => "05",
+        6 => "06", 7 => "07", 8 => "08", 9 => "09", 10 => "10", 11 => "11",
+        12 => "12", 13 => "13", 14 => "14", 15 => "15", 16 => "16", 17 => "17",
+        18 => "18", 19 => "19", 20 => "20", 21 => "21", 22 => "22", 23 => "23",
+        24 => "24", 25 => "25", 26 => "26", 27 => "27", 28 => "28", 29 => "29",
+        30 => "30", 31 => "31", 32 => "32", 33 => "33", 34 => "34", 35 => "35",
+        36 => "36", 37 => "37", 38 => "38", 39 => "39", 40 => "40", 41 => "41",
+        42 => "42", 43 => "43", 44 => "44", 45 => "45", 46 => "46", 47 => "47",
+        48 => "48", 49 => "49", 50 => "50", 51 => "51", 52 => "52", 53 => "53",
+        54 => "54", 55 => "55", 56 => "56", 57 => "57", 58 => "58", 59 => "59",
+        60 => "60", 61 => "61", 62 => "62", 63 => "63", 64 => "64", 65 => "65",
+        66 => "66", 67 => "67", 68 => "68", 69 => "69", 70 => "70", 71 => "71",
+        72 => "72", 73 => "73", 74 => "74", 75 => "75", 76 => "76", 77 => "77",
+        78 => "78", 79 => "79", 80 => "80", 81 => "81", 82 => "82", 83 => "83",
+        84 => "84", 85 => "85", 86 => "86", 87 => "87", 88 => "88", 89 => "89",
+        90 => "90", 91 => "91", 92 => "92", 93 => "93", 94 => "94", 95 => "95",
+        96 => "96", 97 => "97", 98 => "98", 99 => "99", 100 => "\306", 101 => "\305",
+        102 => "\301", 103 => "STARTA", 104 => "STARTB", 105 => "STARTC"
+      }.invert
+    }
+
+    FNC1 = "\xc1"
+    FNC2 = "\xc2"
+    FNC3 = "\xc3"
+    FNC4 = "\xc4"
+    CODEA = "\xc5"
+    CODEB = "\xc6"
+    CODEC = "\xc7"
+
+    STOP = '11000111010'
+    TERMINATE = '11'
+
+    attr_reader :type
+
+    
+    def initialize(data, type)
+      self.type = type
+      self.data = "#{data}"
+      raise ArgumentError, 'Data not valid' unless valid?
+    end
+
+
+    def type=(type)
+      type.upcase!
+      raise ArgumentError, 'type must be A, B or C' unless type =~ /^[ABC]$/
+      @type = type
+    end
+
+
+    def data
+      @data
+    end
+
+    #Set the data for this barcode. If the barcode changes
+    #character set, an extra will be created.
+    def data=(data)
+      data, *extra = data.split(/([#{CODEA+CODEB+CODEC}])/n)
+      @data = data
+      self.extra = extra.join unless extra.empty?
+    end
+
+    #An "extra" is present if the barcode changes character set. If
+    #a 128A barcode changes to C, the extra will be an instance of
+    #Code128C. Extras can themselves have an extra if the barcode
+    #changes character set again. It's like a linked list, and when
+    #there are no more extras, the barcode ends with that object.
+    #Most barcodes probably don't change charsets and don't have extras.
+    def extra
+      @extra
+    end
+
+    #Set the extra for this barcode. The argument is a string starting with the
+    #"change character set" symbol. The string may contain several character
+    #sets, in which case the extra will itself have an extra.
+    def extra=(extra)
+      raise ArgumentError, "Extra must begin with \\301, \\302 or \\303" unless extra =~ /^[#{CODEA+CODEB+CODEC}]/n
+      type = extra[/([#{CODEA+CODEB+CODEC}])/n, 1]
+      data = extra[/[#{CODEA+CODEB+CODEC}](.*)/n, 1]
+      @extra = class_for(type).new(data)
+    end
+
+    #Get an array of the individual characters for this barcode. Special
+    #characters like FNC1 will be present. Characters from extras are not
+    #present.
+    def characters
+      chars = data.split(//n)
+
+      if type == 'C'
+        result = []
+        count = 0
+        while count < chars.size
+          if chars[count] =~ /^\d$/
+            result << "#{chars[count]}#{chars[count+1]}"
+            count += 2
+          else
+            result << chars[count]
+            count += 1
+          end
+        end
+        result
+      else
+        chars
+      end
+    end
+
+    #Return the encoding of this barcode as a string of 1 and 0
+    def encoding
+      start_encoding+data_encoding+extra_encoding+checksum_encoding+stop_encoding
+    end
+
+    #Returns the encoding for the data part of this barcode, without any extras
+    def data_encoding
+      characters.map do |char|
+        encoding_for char
+      end.join
+    end
+
+    #Returns the data encoding of this barcode and extras.
+    def data_encoding_with_extra_encoding
+      data_encoding+extra_encoding
+    end
+
+    #Returns the data encoding of this barcode's extra and its
+    #extra until the barcode ends.
+    def extra_encoding
+      return '' unless extra
+      change_code_encoding_for(extra) + extra.data_encoding + extra.extra_encoding
+    end
+
+
+    #Calculate the checksum for the data in this barcode. The data includes
+    #data from extras.
+    def checksum
+      pos = 0
+      (numbers+extra_numbers).inject(start_num) do |sum,number|
+        pos += 1
+        sum + (number * pos)
+      end % 103
+    end
+
+    #Get the encoding for the checksum
+    def checksum_encoding
+      encodings[checksum]
+    end
+
+
+  #protected
+
+    #Returns the numeric values for the characters in the barcode in an array
+    def numbers
+      characters.map do |char|
+        values[char]
+      end
+    end
+
+    #Returns the numeric values for extras
+    def extra_numbers
+      return [] unless extra
+      [change_code_number_for(extra)] + extra.numbers + extra.extra_numbers
+    end
+
+    def encodings
+      ENCODINGS
+    end
+
+    #The start encoding starts the barcode
+    def stop_encoding
+      STOP+TERMINATE
+    end
+
+    #Find the encoding for the specified character for this barcode
+    def encoding_for(char)
+      encodings[values[char]]
+    end
+
+    #Find the numeric value for the character that changes the character
+    #set to the one represented in +barcode+
+    def change_code_number_for(barcode)
+      case barcode
+        when Code128A then values[CODEA]
+        when Code128B then values[CODEB]
+        when Code128C then values[CODEC]
+      end
+    end
+
+    #Find the encoding to change to the character set in +barcode+
+    def change_code_encoding_for(barcode)
+      encodings[change_code_number_for(barcode)]
+    end
+
+    def class_for(character)
+      case character
+      when 'A' then Code128A
+      when 'B' then Code128B
+      when 'C' then Code128C
+      when CODEA then Code128A
+      when CODEB then Code128B
+      when CODEC then Code128C
+      end
+    end
+
+    #Is the data in this barcode valid? Does a lookup of every character
+    #and checks if it exists in the character set.
+    def valid?
+      characters.all?{|c| values.include?(c) }
+    end
+
+    def values
+      VALUES[type]
+    end
+
+    def start_num
+      values["START#{type}"]
+    end
+
+    def start_encoding
+      encodings[start_num]
+    end
+
+
+  end
+
+
+  class Code128A < Code128
+
+    def initialize(data)
+      super(data, 'A')
+    end
+
+  end
+
+
+  class Code128B < Code128
+
+    def initialize(data)
+      super(data, 'B')
+    end
+
+  end
+
+
+  class Code128C < Code128
+
+    def initialize(data)
+      super(data, 'C')
+    end
+
+  end
+
+
+end

data/lib/barby/barcode/code_39.rb

@@ -0,0 +1,200 @@
+require 'barby/barcode'
+
+module Barby
+
+
+  class Code39 < Barcode1D
+
+    ENCODINGS = {
+      '0' => '101001101101', 'M' => '110110101001',
+      '1' => '110100101011', 'N' => '101011010011',
+      '2' => '101100101011', 'O' => '110101101001',
+      '3' => '110110010101', 'P' => '101101101001',
+      '4' => '101001101011', 'Q' => '101010110011',
+      '5' => '110100110101', 'R' => '110101011001',
+      '6' => '101100110101', 'S' => '101101011001',
+      '7' => '101001011011', 'T' => '101011011001',
+      '8' => '110100101101', 'U' => '110010101011',
+      '9' => '101100101101', 'V' => '100110101011',
+      'A' => '110101001011', 'W' => '110011010101',
+      'B' => '101101001011', 'X' => '100101101011',
+      'C' => '110110100101', 'Y' => '110010110101',
+      'D' => '101011001011', 'Z' => '100110110101',
+      'E' => '110101100101', '-' => '100101011011',
+      'F' => '101101100101', '.' => '110010101101',
+      'G' => '101010011011', ' ' => '100110101101',
+      'H' => '110101001101', '$' => '100100100101',
+      'I' => '101101001101', '/' => '100100101001',
+      'J' => '101011001101', '+' => '100101001001',
+      'K' => '110101010011', '%' => '101001001001',
+      'L' => '101101010011'#, '*' => '100101101101'
+    }
+
+    #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 = '100101101101' # *
+    STOP_ENCODING = '100101101101'  # *
+
+    attr_accessor :data, :spacing, :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| ENCODINGS[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
+      ENCODINGS[checksum_character]
+    end
+
+    #Set include_checksum to true to make +encoding+ include the checksum
+    def include_checksum?
+      include_checksum
+    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 extended?
+      extended
+    end
+
+
+    def start_encoding
+      START_ENCODING
+    end
+
+    def stop_encoding
+      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
+
+
+  end
+
+
+end

data/lib/barby/barcode/ean_13.rb

@@ -0,0 +1,173 @@
+require 'barby/barcode'
+
+module Barby
+
+  #EAN-13, aka UPC-A, barcodes are the ones you can see at your local
+  #supermarket, in your house and, well, everywhere..
+  #
+  #To use this for a UPC barcode, just add a 0 to the front
+  class EAN13 < Barcode1D
+
+    LEFT_ENCODINGS_ODD = {
+      0 => '0001101', 1 => '0011001', 2 => '0010011',
+      3 => '0111101', 4 => '0100011', 5 => '0110001',
+      6 => '0101111', 7 => '0111011', 8 => '0110111',
+      9 => '0001011'
+    }
+
+    LEFT_ENCODINGS_EVEN = {
+      0 => '0100111', 1 => '0110011', 2 => '0011011',
+      3 => '0100001', 4 => '0011101', 5 => '0111001',
+      6 => '0000101', 7 => '0010001', 8 => '0001001',
+      9 => '0010111'
+    }
+
+    RIGHT_ENCODINGS = {
+      0 => '1110010', 1 => '1100110', 2 => '1101100',
+      3 => '1000010', 4 => '1011100', 5 => '1001110',
+      6 => '1010000', 7 => '1000100', 8 => '1001000',
+      9 => '1110100'
+    }
+
+    #Describes whether the left-hand encoding should use
+    #LEFT_ENCODINGS_ODD or LEFT_ENCODINGS_EVEN, based on the
+    #first digit in the number system  (and the barcode as a whole)
+    LEFT_PARITY_MAPS = {
+      0 => [:odd, :odd, :odd, :odd, :odd, :odd],   #UPC-A
+      1 => [:odd, :odd, :even, :odd, :even, :even],
+      2 => [:odd, :odd, :even, :even, :odd, :even],
+      3 => [:odd, :odd, :even, :even, :even, :odd],
+      4 => [:odd, :even, :odd, :odd, :even, :even],
+      5 => [:odd, :even, :even, :odd, :odd, :even],
+      6 => [:odd, :even, :even, :even, :odd, :odd],
+      7 => [:odd, :even, :odd, :even, :odd, :even],
+      8 => [:odd, :even, :odd, :even, :even, :odd],
+      9 => [:odd, :even, :even, :odd, :even, :odd]
+    }
+
+    #These are the lines that "stick down" in the graphical representation
+    START = '101'
+    CENTER = '01010'
+    STOP = '101'
+
+    #EAN-13 barcodes have 12 digits + check digit
+    FORMAT = /^\d{12}$/
+
+    attr_accessor :data
+
+
+    def initialize(data)
+      self.data = data
+      raise ArgumentError, 'data not valid' unless valid?
+    end
+
+
+    def characters
+      data.split(//)
+    end
+    
+    def numbers
+      characters.map{|s| s.to_i }
+    end
+
+    def odd_and_even_numbers
+      alternater = false
+      numbers.reverse.partition{ alternater = !alternater }
+    end
+
+    #Numbers that are encoded to the left of the center
+    #The first digit is not included
+    def left_numbers
+      numbers[1,6]
+    end
+
+    #Numbers that are encoded to the right of the center
+    #The checksum is included here
+    def right_numbers
+      numbers_with_checksum[7,6]
+    end
+
+    def numbers_with_checksum
+      numbers + [checksum]
+    end
+
+
+    def data_with_checksum
+      data + checksum.to_s
+    end
+
+
+    def left_encodings
+      left_parity_map.zip(left_numbers).map do |parity,number|
+        parity == :odd ? LEFT_ENCODINGS_ODD[number] : LEFT_ENCODINGS_EVEN[number]
+      end
+    end
+
+    def right_encodings
+      right_numbers.map{|n| RIGHT_ENCODINGS[n] }
+    end
+
+    def left_encoding
+      left_encodings.join
+    end
+
+    def right_encoding
+      right_encodings.join
+    end
+
+    def encoding
+      start_encoding+left_encoding+center_encoding+right_encoding+stop_encoding
+    end
+
+
+    #The parities to use for encoding left-hand numbers
+    def left_parity_map
+      LEFT_PARITY_MAPS[numbers.first]
+    end
+
+
+    def weighted_sum
+      odds, evens = odd_and_even_numbers
+      odds.map!{|n| n * 3 }
+      sum = (odds+evens).inject(0){|s,n| s+n }
+    end
+
+    #Mod10
+    def checksum
+      mod = weighted_sum % 10
+      mod.zero? ? 0 : 10-mod
+    end
+
+    def checksum_encoding
+      RIGHT_ENCODINGS[checksum]
+    end
+
+
+    def valid?
+      data =~ FORMAT
+    end
+
+
+    #Is this a UPC-A barcode?
+    #UPC barcodes are EAN codes that start with 0
+    def upc?
+      numbers.first.zero?
+    end
+
+
+    def start_encoding
+      START
+    end
+
+    def center_encoding
+      CENTER
+    end
+
+    def stop_encoding
+      STOP
+    end
+
+
+  end
+
+end

data/lib/barby/barcode/ean_8.rb

@@ -0,0 +1,32 @@
+require 'barby/barcode/ean_13'
+
+module Barby
+
+  #EAN-8 is a sub-set of EAN-13, with only 7 (8) digits
+  class EAN8 < EAN13
+
+    FORMAT = /^\d{7}$/
+
+
+    def left_numbers
+      numbers[0,4]
+    end
+
+    def right_numbers
+      numbers_with_checksum[4,4]
+    end
+
+
+    #Left-hand digits are all encoded using odd parity
+    def left_parity_map
+      [:odd, :odd, :odd, :odd]
+    end
+
+
+    def valid?
+      data =~ FORMAT
+    end
+
+  end
+
+end

data/lib/barby/barcode/gs1_128.rb

@@ -0,0 +1,37 @@
+require 'barby/barcode/code_128'
+
+module Barby
+
+
+  #AKA EAN-128, UCC-128
+  class GS1128 < Code128
+
+    attr_accessor :application_identifier
+
+    def initialize(data, type, ai)
+      self.application_identifier = ai
+      super(data, type)
+    end
+
+    
+    def data
+      FNC1+application_identifier+super
+    end
+
+    def partial_data
+      @data
+    end
+
+    def application_identifier_number
+      values[application_identifier]
+    end
+
+    def application_identifier_encoding
+      encodings[application_identifier_number]
+    end
+
+
+  end
+
+
+end

data/lib/barby/outputter.rb

@@ -0,0 +1,73 @@
+require 'barby/barcode'
+
+module Barby
+
+
+  #An Outputter creates something from a barcode. That something can be
+  #anything, but is most likely a graphical representation of the barcode.
+  #Outputters can register methods on barcodes that will be associated with
+  #them.
+  #
+  #The basic structure of an outputter class:
+  #
+  #  class FooOutputter < Barby::Outputter
+  #    register :to_foo
+  #    def to_too
+  #      do_something_with(barcode.encoding)
+  #    end
+  #  end
+  #
+  #Barcode#to_foo will now be available to all barcodes
+  class Outputter
+
+    attr_accessor :barcode
+
+
+    #An outputter instance will have access to a Barcode
+    def initialize(barcode)
+      self.barcode = barcode
+    end
+
+  
+    #Register one or more handler methods with this outputter
+    #Barcodes will then be able to use these methods to get the output
+    #from the outputter. For example, if you have an ImageOutputter,
+    #you could do:
+    #
+    #register :to_png, :to_gif
+    #
+    #You could then do aBarcode.to_png and get the result of that method.
+    #The class which registers the method will receive the barcode as the only
+    #argument, and the default implementation of initialize puts that into
+    #the +barcode+ accessor.
+    #
+    #You can also have different method names on the barcode and the outputter
+    #by providing a hash:
+    #
+    #register :to_png => :create_png, :to_gif => :create_gif
+    def self.register(*method_names)
+      if method_names.first.is_a? Hash
+        method_names.first.each do |name, method_name|
+          Barcode.register_outputter(name, self, method_name)
+        end
+      else
+        method_names.each do |name|
+          Barcode.register_outputter(name, self, name)
+        end
+      end
+    end
+
+
+  private
+
+    #Converts the barcode's encoding (a string containing 1s and 0s)
+    #to true and false values (1 == true == "black bar")
+    def booleans#:doc:
+      barcode.encoding.split(//).map{|c| c == '1' }
+    end
+
+
+  end
+
+
+end

data/lib/barby/outputter/ascii_outputter.rb

@@ -0,0 +1,22 @@
+require 'barby/outputter'
+
+module Barby
+
+  #Outputs an ASCII representation of the barcode. This is mostly useful for printing
+  #the barcode directly to the terminal for testing.
+  class ASCIIOutputter < Outputter
+
+    register :to_ascii
+
+
+    def to_ascii(opts={})
+      opts = {:height => 10, :xdim => 1, :bar => '#', :space => ' '}.merge(opts)
+      Array.new(
+        opts[:height],
+        booleans.map{|b| (b ? opts[:bar] : opts[:space]) * opts[:xdim] }.join
+      ).join("\n")
+    end
+
+  end
+
+end

data/lib/barby/outputter/pdfwriter_outputter.rb

@@ -0,0 +1,74 @@
+require 'barby/outputter'
+
+module Barby
+
+  class PDFWriterOutputter < Outputter
+
+    register :annotate_pdf
+
+    attr_accessor :x, :y, :height, :xdim
+
+
+    def annotate_pdf(pdf, options={})
+      previous_options = options.map{|k,v| [k, send(k)] }
+      options.each{|k,v| send("#{k}=", v) if respond_to?("#{k}=") }
+
+      xpos, ypos = x, y
+
+      widths.each do |array|
+        if array.first
+          pdf.move_to(xpos, ypos).
+            line_to(xpos, ypos+height).
+            line_to(xpos+(xdim*array.size), ypos+height).
+            line_to(xpos+(xdim*array.size), ypos).
+            line_to(xpos, ypos).
+            fill
+        end
+        xpos += (xdim*array.size)
+      end
+
+      previous_options.each{|k,v| send("#{k}=", v) }
+
+      pdf
+    end
+
+
+    def x
+      @x || 10
+    end
+
+    def y
+      @y || 10
+    end
+
+    def height
+      @height || 50
+    end
+
+    def xdim
+      @xdim || 1
+    end
+
+    def widths
+      widths = []
+      count = nil
+      
+      booleans.inject nil do |last,current|
+        if current != last
+          widths << count if count
+          count = [current]
+        else
+          count << current
+        end
+        current
+      end
+
+      widths << count
+      
+      widths
+    end
+
+
+  end
+
+end

data/lib/barby/outputter/rmagick_outputter.rb

@@ -0,0 +1,87 @@
+require 'barby/outputter'
+require 'RMagick'
+
+module Barby
+
+
+  #Renders images from barcodes using RMagick
+  class RmagickOutputter < Outputter
+  
+    register :to_png, :to_gif, :to_jpg, :to_image
+
+    attr_accessor :height, :xdim, :margin
+
+
+    #Returns a string containing a PNG image
+    def to_png(*a)
+      to_image(*a).to_blob{|i| i.format ='png' }
+    end
+
+    #Returns a string containint a GIF image
+    def to_gif(*a)
+      to_image(*a).to_blob{|i| i.format ='gif' }
+    end
+
+    #Returns a string containing a JPEG image
+    def to_jpg(*a)
+      to_image(*a).to_blob{|i| i.format = 'jpg' }
+    end
+
+    #Returns an instance of Magick::Image
+    def to_image(opts={})
+      opts.each{|k,v| send("#{k}=", v) if respond_to?("#{k}=") }
+      canvas = Magick::Image.new(full_width, full_height)
+      bars = Magick::Draw.new
+
+      x = margin
+      y = margin
+      booleans.each do |bar|
+        if bar
+          bars.rectangle(x, y, x+(xdim-1), y+height)
+        end
+        x += xdim
+      end
+
+      bars.draw(canvas)
+
+      canvas
+    end
+
+
+    #The height of the barcode in px
+    def height
+      @height || 100
+    end
+
+    #X dimension. 1X == 1px
+    def xdim
+      @xdim || 1
+    end
+
+    #The margin of each edge surrounding the barcode in pixels
+    def margin
+      @margin || 10
+    end
+
+    #The width of the barcode in px
+    def width
+      barcode.encoding.length * xdim
+    end
+
+    #The full width of the image. This is the width of the
+    #barcode + the left and right margin
+    def full_width
+      width + (margin * 2)
+    end
+
+    #The height of the image. This is the height of the
+    #barcode + the top and bottom margin
+    def full_height
+      height + (margin * 2)
+    end
+
+
+  end
+
+
+end

data/lib/barby/version.rb

@@ -0,0 +1,9 @@
+module Barby #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: barby
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Tore Darell
+autorequire: barby
+bindir: bin
+cert_chain: []
+
+date: 2008-03-17 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: toredarell@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/barby.rb
+- lib/barby
+- lib/barby/barcode.rb
+- lib/barby/barcode
+- lib/barby/barcode/bookland.rb
+- lib/barby/barcode/code_128.rb
+- lib/barby/barcode/code_39.rb
+- lib/barby/barcode/ean_13.rb
+- lib/barby/barcode/ean_8.rb
+- lib/barby/barcode/gs1_128.rb
+- lib/barby/outputter.rb
+- lib/barby/outputter
+- lib/barby/outputter/ascii_outputter.rb
+- lib/barby/outputter/pdfwriter_outputter.rb
+- lib/barby/outputter/rmagick_outputter.rb
+- lib/barby/version.rb
+- README
+has_rdoc: true
+homepage: http://tore.darell.no/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A pure-Ruby barcode generator
+test_files: []
+