barby 0.1.2 → 0.2.0

data/lib/barby/barcode/qr_code.rb

@@ -0,0 +1,93 @@
+require 'rqrcode'
+require 'barby/barcode'
+
+module Barby
+
+
+  #QrCode is a thin wrapper around the RQRCode library
+  class QrCode < Barcode2D
+
+    #Maximum sizes for each correction level for binary data
+    #It's an array
+    SIZES = {
+            #L   M   Q   H
+      1  => [17, 14, 11, 7],          2  => [32, 26, 20, 14],
+      3  => [53, 42, 32, 24],         4  => [78, 62, 46, 34],
+      5  => [106, 84, 60, 44],        6  => [134, 106, 74, 58],
+      7  => [154, 122, 86, 64],       8  => [192, 152, 108, 84],
+      9  => [230, 180, 130, 98],      10 => [271, 213, 151, 119]#,
+
+    #I think RQRCode only supports sizes up to 10
+    #  11 => [321, 251, 177, 137],     12 => [367, 287, 203, 155],
+    #  13 => [425, 331, 241, 177],     14 => [458, 362, 258, 194],
+    #  15 => [520, 412, 292, 220],     16 => [586, 450, 322, 250],
+    #  17 => [644, 504, 364, 280],     18 => [718, 560, 394, 310],
+    #  19 => [792, 624, 442, 338],     20 => [858, 666, 482, 382],
+    #  21 => [929, 711, 509, 403],     22 => [1003, 779, 565, 439],
+    #  23 => [1091, 857, 611, 461],    24 => [1171, 911, 661, 511],
+    #  25 => [1273, 997, 715, 535],    26 => [1367, 1059, 751, 593],
+    #  27 => [1465, 1125, 805, 625],   28 => [1528, 1190, 868, 658],
+    #  29 => [1628, 1264, 908, 698],   30 => [1732, 1370, 982, 742],
+    #  31 => [1840, 1452, 1030, 790],  32 => [1952, 1538, 1112, 842],
+    #  33 => [2068, 1628, 1168, 898],  34 => [2188, 1722, 1228, 958],
+    #  35 => [2303, 1809, 1283, 983],  36 => [2431, 1911, 1351, 1051],
+    #  37 => [2563, 1989, 1423, 1093], 38 => [2699, 2099, 1499, 1139],
+    #  39 => [2809, 2213, 1579, 1219], 40 => [2953, 2331, 1663, 1273]
+    }.sort
+
+    LEVELS = { :l => 0, :m => 1, :q => 2, :h => 3 }
+
+    attr_reader :data
+    attr_writer :level
+
+
+    def initialize(data, options={})
+      self.data = data
+      options.each{|k,v| send("#{k}=", v) }
+      raise(ArgumentError, "data too large") unless size
+    end
+
+
+    def data=(data)
+      @data = data
+    end
+
+
+    def encoding
+      rqrcode.modules.map{|r| r.inject(''){|s,m| s << (m ? '1' : '0') } }
+    end
+
+
+    #Error correction level
+    #Can be one of [:l, :m, :q, :h] (7%, 15%, 25%, 30%)
+    def level
+      @level || :l
+    end
+
+
+    def size
+      level_index = LEVELS[level]
+      length = data.length
+      found_size = nil
+      SIZES.each do |size,max_values|
+        if max_values[level_index] >= length
+          found_size = size
+          break
+        end
+      end
+      found_size
+    end
+
+
+  private
+  
+    #Generate an RQRCode object with the available values
+    def rqrcode
+      RQRCode::QRCode.new(data, :level => level, :size => size)
+    end
+
+
+  end
+
+
+end

data/lib/barby/outputter.rb

@@ -62,8 +62,62 @@ module Barby
 
     #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' }
+    #
+    #If the barcode is 2D, each line will be converted to an array
+    #in the same way
+    def booleans(reload=false)#:doc:
+      if barcode.two_dimensional?
+        encoding(reload).map{|l| l.split(//).map{|c| c == '1' } }
+      else
+        encoding(reload).split(//).map{|c| c == '1' }
+      end
+    end
+
+
+    #Returns the barcode's encoding. The encoding
+    #is cached and can be reloaded by passing true
+    def encoding(reload=false)#:doc:
+      @encoding = barcode.encoding if reload
+      @encoding ||= barcode.encoding
+    end
+
+
+    #Collects continuous groups of bars and spaces (1 and 0)
+    #into arrays where the first item is true or false (1 or 0)
+    #and the second is the size of the group
+    #
+    #For example, "1100111000" becomes [[true,2],[false,2],[true,3],[false,3]]
+    def boolean_groups(reload=false)
+      if barcode.two_dimensional?
+        encoding(reload).map do |line|
+          line.scan(/1+|0+/).map do |group|
+            [group[0,1] == '1', group.size]
+          end
+        end
+      else
+        encoding(reload).scan(/1+|0+/).map do |group|
+          [group[0,1] == '1', group.size]
+        end
+      end
+    end
+
+
+    def with_options(options={})
+      original_options = options.inject({}) do |origs,pair|
+        if respond_to?(pair.first) && respond_to?("#{pair.first}=")
+          origs[pair.first] = send(pair.first)
+          send("#{pair.first}=", pair.last)
+        end
+        origs
+      end
+
+      rv = yield
+
+      original_options.each do |attribute,value|
+        send("#{attribute}=", value)
+      end
+
+      rv
     end
 
 

data/lib/barby/outputter/ascii_outputter.rb

@@ -4,19 +4,38 @@ module Barby
 
   #Outputs an ASCII representation of the barcode. This is mostly useful for printing
   #the barcode directly to the terminal for testing.
+  #
+  #Registers to_ascii
   class ASCIIOutputter < Outputter
 
     register :to_ascii
 
 
     def to_ascii(opts={})
-      opts = {:height => 10, :xdim => 1, :bar => '#', :space => ' '}.merge(opts)
+      default_opts = {:height => 10, :xdim => 1, :bar => '#', :space => ' '}
+      default_opts.update(:height => 1, :bar => ' X ', :space => '   ') if barcode.two_dimensional?
+      opts = default_opts.merge(opts)
+
+      if barcode.two_dimensional?
+        booleans.map do |bools|
+          line_to_ascii(bools, opts)
+        end.join("\n")
+      else
+        line_to_ascii(booleans, opts)
+      end
+    end
+
+
+  private
+
+    def line_to_ascii(booleans, 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/cairo_outputter.rb

@@ -1,7 +1,12 @@
+require 'barby/outputter'
 require 'cairo'
 require 'stringio'
 
 module Barby
+
+  #Uses Cairo to render a barcode to a number of formats: PNG, PS, EPS, PDF and SVG
+  #
+  #Registers methods render_to_cairo_context, to_png, to_ps, to_eps, to_pdf and to_svg
   class CairoOutputter < Outputter
 
     register :render_to_cairo_context
@@ -18,6 +23,7 @@ module Barby
     attr_writer :x, :y, :xdim, :height, :margin
 
 
+    #Render the barcode onto a Cairo context
     def render_to_cairo_context(context, options={})
       if context.respond_to?(:have_current_point?) and
           context.have_current_point?
@@ -29,15 +35,30 @@ module Barby
 
       _xdim = xdim(options)
       _height = height(options)
+      original_current_x = current_x
       context.save do
         context.set_source_color(:black)
         context.fill do
-          barcode.encoding.scan(/(?:0+|1+)/).each do |codes|
-            current_width = _xdim * codes.size
-            if codes[0] == ?1
-              context.rectangle(current_x, current_y, current_width, _height)
+          if barcode.two_dimensional?
+            boolean_groups.each do |groups|
+              groups.each do |bar,amount|
+                current_width = _xdim * amount
+                if bar
+                  context.rectangle(current_x, current_y, current_width, _xdim)
+                end
+                current_x += current_width
+              end
+              current_x = original_current_x
+              current_y += _xdim
+            end
+          else
+            boolean_groups.each do |bar,amount|
+              current_width = _xdim * amount
+              if bar
+                context.rectangle(current_x, current_y, current_width, _height)
+              end
+              current_x += current_width
             end
-            current_x += current_width
           end
         end
       end
@@ -46,6 +67,7 @@ module Barby
     end
 
 
+    #Render the barcode to a PNG image
     def to_png(options={})
       output_to_string_io do |io|
         Cairo::ImageSurface.new(options[:format],
@@ -58,6 +80,7 @@ module Barby
     end
 
 
+    #Render the barcode to a PS document
     def to_ps(options={})
       output_to_string_io do |io|
         Cairo::PSSurface.new(io,
@@ -70,11 +93,13 @@ module Barby
     end
 
 
+    #Render the barcode to an EPS document
     def to_eps(options={})
       to_ps(options.merge(:eps => true))
     end
 
 
+    #Render the barcode to a PDF document
     def to_pdf(options={})
       output_to_string_io do |io|
         Cairo::PDFSurface.new(io,
@@ -86,6 +111,7 @@ module Barby
     end
 
 
+    #Render the barcode to an SVG document
     def to_svg(options={})
       output_to_string_io do |io|
         Cairo::SVGSurface.new(io,
@@ -106,11 +132,15 @@ module Barby
     end
 
     def width(options={})
-      barcode.encoding.length * xdim(options)
+      (barcode.two_dimensional? ? encoding.first.length : encoding.length) * xdim(options)
     end
 
     def height(options={})
-      @height || options[:height] || 50
+      if barcode.two_dimensional?
+        encoding.size * xdim(options)
+      else
+        @height || options[:height] || 50
+      end
     end
 
     def full_width(options={})
@@ -151,4 +181,5 @@ module Barby
 
 
   end
+
 end

data/lib/barby/outputter/pdfwriter_outputter.rb

@@ -2,6 +2,9 @@ require 'barby/outputter'
 
 module Barby
 
+  #Annotates a PDFWriter document with the barcode
+  #
+  #Registers the annotate_pdf method
   class PDFWriterOutputter < Outputter
 
     register :annotate_pdf
@@ -9,25 +12,50 @@ module Barby
     attr_accessor :x, :y, :height, :xdim
 
 
+    #Annotate a PDFWriter document with the barcode
+    #
+    #Valid options are:
+    #
+    #x, y   - The point in the document to start rendering from
+    #height - The height of the bars in PDF units
+    #xdim   - The X dimension in PDF units
     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
+      with_options options do
+
+        xpos, ypos = x, y
+        orig_xpos = xpos
+
+        if barcode.two_dimensional?
+          boolean_groups.reverse_each do |groups|
+            groups.each do |bar,amount|
+              if bar
+                pdf.move_to(xpos, ypos).
+                  line_to(xpos, ypos+xdim).
+                  line_to(xpos+(xdim*amount), ypos+xdim).
+                  line_to(xpos+(xdim*amount), ypos).
+                  line_to(xpos, ypos).
+                  fill
+              end
+              xpos += (xdim*amount)
+            end
+            xpos = orig_xpos
+            ypos += xdim
+          end
+        else
+          boolean_groups.each do |bar,amount|
+            if bar
+              pdf.move_to(xpos, ypos).
+                line_to(xpos, ypos+height).
+                line_to(xpos+(xdim*amount), ypos+height).
+                line_to(xpos+(xdim*amount), ypos).
+                line_to(xpos, ypos).
+                fill
+            end
+            xpos += (xdim*amount)
+          end
         end
-        xpos += (xdim*array.size)
-      end
 
-      previous_options.each{|k,v| send("#{k}=", v) }
+      end
 
       pdf
     end
@@ -49,25 +77,6 @@ module Barby
       @xdim || 1
     end
 
-    def widths
-      widths = []
-      count = nil
-      
-      booleans.inject nil do |previous,current|
-        if current != previous
-          widths << count if count
-          count = [current]
-        else
-          count << current
-        end
-        current
-      end
-
-      widths << count
-      
-      widths
-    end
-
 
   end
 

data/lib/barby/outputter/png_outputter.rb

@@ -1,46 +1,70 @@
+require 'barby/outputter'
 require 'png'
 
 module Barby
 
+  #Renders the barcode to a PNG image using the "png" gem (gem install png)
+  #
+  #Registers the to_png and to_canvas methods
   class PngOutputter < Outputter
 
     register :to_png, :to_canvas
 
-    attr_accessor :xdim, :width, :height, :margin
+    attr_accessor :xdim, :ydim, :width, :height, :margin
 
 
+    #Creates a PNG::Canvas object and renders the barcode on it
     def to_canvas(opts={})
-      orig_opts = opts.inject({}){|h,p| send("#{p.first}=", p.last) if respond_to?("#{p.first}="); h.update(p.first => p.last) }
-      canvas = PNG::Canvas.new(full_width, full_height, PNG::Color::White)
-
-      x, y = margin, margin
-      booleans.each do |bar|
-        if bar
-          x.upto(x+(xdim-1)) do |xx|
-            y.upto y+(height-1) do |yy|
-              canvas[xx,yy] = PNG::Color::Black
+      with_options opts do
+        canvas = PNG::Canvas.new(full_width, full_height, PNG::Color::White)
+
+        if barcode.two_dimensional?
+          x, y = margin, margin
+          booleans.reverse_each do |line|
+            line.each do |bar|
+              if bar
+                x.upto(x+(xdim-1)) do |xx|
+                  y.upto y+(ydim-1) do |yy|
+                    canvas[xx,yy] = PNG::Color::Black
+                  end
+                end
+              end
+              x += xdim
             end
+            y += ydim
+            x = margin
+          end
+        else
+          x, y = margin, margin
+          booleans.each do |bar|
+            if bar
+              x.upto(x+(xdim-1)) do |xx|
+                y.upto y+(height-1) do |yy|
+                  canvas[xx,yy] = PNG::Color::Black
+                end
+              end
+            end
+            x += xdim
           end
         end
-        x += xdim
-      end
 
-      orig_opts.each{|k,v| send("#{k}=", v) if respond_to?("#{k}=") }
-      canvas
+        canvas
+      end
     end
 
 
+    #Renders the barcode to a PNG image
     def to_png(*a)
       PNG.new(to_canvas(*a)).to_blob
     end
 
 
     def width
-      barcode.encoding.length * xdim
+      length * xdim
     end
 
     def height
-      @height || 100
+      barcode.two_dimensional? ? (ydim * encoding.length) : (@height || 100)
     end
 
     def full_width
@@ -55,10 +79,18 @@ module Barby
       @xdim || 1
     end
 
+    def ydim
+      @ydim || xdim
+    end
+
     def margin
       @margin || 10
     end
 
+    def length
+      barcode.two_dimensional? ? encoding.first.length : encoding.length
+    end
+
 
   end