barby-chunky_png 0.3.3

data/lib/barby/barcode/qr_code.rb

@@ -0,0 +1,101 @@
+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],
+      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, :size
+
+
+    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
+      #@size is only used for manual override, if it's not set
+      #manually the size is always dynamic, calculated from the
+      #length of the data
+      return @size if @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
+
+
+    def to_s
+      data[0,20]
+    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/barcode.rb

@@ -0,0 +1,116 @@
+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)
+  #
+  # # ##  ###   ####    #
+  # # ##  ###   ####    #
+  # # ##  ###   ####    #
+  #
+  #2D implementation:
+  #
+  # class Static2DBarcode < Barby::Barcode2D
+  #   def encoding
+  #     ['1010101', '010101110', '0001010100']
+  #   end
+  # end
+  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.
+    #
+    #If the barcode is 2D, it returns an array of strings representing
+    #each line in the barcode
+    def encoding
+      raise NotImplementedError, 'Every barcode should implement this method'
+    end
+
+
+    #Is this barcode valid?
+    def valid?
+      false
+    end
+
+
+    def to_s
+      self.class.name.split('::').last
+    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)
+        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
+
+  #2D barcodes are 1D barcodes stacked on top of each other.
+  #Their encoding method must return an array of strings
+  class Barcode2D < Barcode
+  end
+
+
+end

data/lib/barby/outputter/ascii_outputter.rb

@@ -0,0 +1,41 @@
+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.
+  #
+  #Registers to_ascii
+  class ASCIIOutputter < Outputter
+
+    register :to_ascii
+
+
+    def to_ascii(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

@@ -0,0 +1,185 @@
+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
+    register :to_png
+
+    if Cairo.const_defined?(:PSSurface)
+      register :to_ps
+      register :to_eps if Cairo::PSSurface.method_defined?(:eps=)
+    end
+
+    register :to_pdf if Cairo.const_defined?(:PDFSurface)
+    register :to_svg if Cairo.const_defined?(:SVGSurface)
+
+    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?
+        current_x, current_y = context.current_point
+      else
+        current_x = x(options) || margin(options)
+        current_y = y(options) || margin(options)
+      end
+
+      _xdim = xdim(options)
+      _height = height(options)
+      original_current_x = current_x
+      context.save do
+        context.set_source_color(:black)
+        context.fill do
+          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
+          end
+        end
+      end
+
+      context
+    end
+
+
+    #Render the barcode to a PNG image
+    def to_png(options={})
+      output_to_string_io do |io|
+        Cairo::ImageSurface.new(options[:format],
+                                full_width(options),
+                                full_height(options)) do |surface|
+          render(surface, options)
+          surface.write_to_png(io)
+        end
+      end
+    end
+
+
+    #Render the barcode to a PS document
+    def to_ps(options={})
+      output_to_string_io do |io|
+        Cairo::PSSurface.new(io,
+                             full_width(options),
+                             full_height(options)) do |surface|
+          surface.eps = options[:eps] if surface.respond_to?(:eps=)
+          render(surface, options)
+        end
+      end
+    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,
+                              full_width(options),
+                              full_height(options)) do |surface|
+          render(surface, options)
+        end
+      end
+    end
+
+
+    #Render the barcode to an SVG document
+    def to_svg(options={})
+      output_to_string_io do |io|
+        Cairo::SVGSurface.new(io,
+                              full_width(options),
+                              full_height(options)) do |surface|
+          render(surface, options)
+        end
+      end
+    end
+
+
+    def x(options={})
+      @x || options[:x]
+    end
+
+    def y(options={})
+      @y || options[:y]
+    end
+
+    def width(options={})
+      (barcode.two_dimensional? ? encoding.first.length : encoding.length) * xdim(options)
+    end
+
+    def height(options={})
+      if barcode.two_dimensional?
+        encoding.size * xdim(options)
+      else
+        @height || options[:height] || 50
+      end
+    end
+
+    def full_width(options={})
+      width(options) + (margin(options) * 2)
+    end
+
+    def full_height(options={})
+      height(options) + (margin(options) * 2)
+    end
+
+    def xdim(options={})
+      @xdim || options[:xdim] || 1
+    end
+
+    def margin(options={})
+      @margin || options[:margin] || 10
+    end
+
+
+  private
+
+    def output_to_string_io
+      io = StringIO.new
+      yield(io)
+      io.rewind
+      io.read
+    end
+
+
+    def render(surface, options)
+      context = Cairo::Context.new(surface)
+      yield(context) if block_given?
+      context.set_source_color(options[:background] || :white)
+      context.paint
+      render_to_cairo_context(context, options)
+      context
+    end
+
+
+  end
+
+end

data/lib/barby/outputter/pdfwriter_outputter.rb

@@ -0,0 +1,83 @@
+require 'barby/outputter'
+
+module Barby
+
+  #Annotates a PDFWriter document with the barcode
+  #
+  #Registers the annotate_pdf method
+  class PDFWriterOutputter < Outputter
+
+    register :annotate_pdf
+
+    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={})
+      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
+
+      end
+
+      pdf
+    end
+
+
+    def x
+      @x || 10
+    end
+
+    def y
+      @y || 10
+    end
+
+    def height
+      @height || 50
+    end
+
+    def xdim
+      @xdim || 1
+    end
+
+
+  end
+
+end

data/lib/barby/outputter/png_outputter.rb

@@ -0,0 +1,97 @@
+require 'barby/outputter'
+require 'chunky_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, :ydim, :width, :height, :margin
+
+
+    #Creates a PNG::Canvas object and renders the barcode on it
+    def to_canvas(opts={})
+      with_options opts do
+        canvas = ChunkyPNG::Canvas.new(full_width, full_height, ChunkyPNG::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] = ChunkyPNG::Color::BLACK
+                end
+              end
+            end
+            x += xdim
+          end
+        end
+
+        canvas
+      end
+    end
+
+
+    #Renders the barcode to a PNG image
+    def to_png(*a)
+      to_canvas(*a).to_blob
+    end
+
+
+    def width
+      length * xdim
+    end
+
+    def height
+      barcode.two_dimensional? ? (ydim * encoding.length) : (@height || 100)
+    end
+
+    def full_width
+      width + (margin * 2)
+    end
+
+    def full_height
+      height + (margin * 2)
+    end
+
+    def xdim
+      @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
+
+end

data/lib/barby/outputter/prawn_outputter.rb

@@ -0,0 +1,99 @@
+require 'barby/outputter'
+require 'prawn'
+
+module Barby
+
+  class PrawnOutputter < Outputter
+
+    register :to_pdf, :annotate_pdf
+
+
+    def to_pdf(opts={})
+      opts = options(opts)
+      annotate_pdf(Prawn::Document.new(opts[:document]), opts).render
+    end
+
+
+    def annotate_pdf(pdf, opts={})
+      opts = options(opts)
+      xpos, ypos, height, xdim = opts[:x], opts[:y], opts[:height], opts[:xdim]
+      ydim = opts[:ydim] || xdim
+      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)
+              pdf.line_to(xpos, ypos+ydim)
+              pdf.line_to(xpos+(xdim*amount), ypos+ydim)
+              pdf.line_to(xpos+(xdim*amount), ypos)
+              pdf.line_to(xpos, ypos)
+              pdf.fill
+            end
+            xpos += (xdim*amount)
+          end
+          xpos = orig_xpos
+          ypos += ydim
+        end
+      else
+        boolean_groups.each do |bar,amount|
+          if bar
+            pdf.move_to(xpos, ypos)
+            pdf.line_to(xpos, ypos+height)
+            pdf.line_to(xpos+(xdim*amount), ypos+height)
+            pdf.line_to(xpos+(xdim*amount), ypos)
+            pdf.line_to(xpos, ypos)
+            pdf.fill
+          end
+          xpos += (xdim*amount)
+        end
+      end
+
+      pdf
+    end
+
+
+  private
+
+    def default_options
+      @default_options ||= {
+        :margin => 5,
+        :height => 100,
+        :xdim => 1
+      }
+    end
+
+    def options(opts={})
+      doc_opts = opts.delete(:document) || {}
+      opts = default_options.merge(opts)
+      opts[:x] ||= opts[:margin]
+      opts[:y] ||= opts[:margin]
+      opts[:document] = document_options(opts, doc_opts)
+      opts
+    end
+
+    def document_options(opts, doc_opts)
+      o = doc_opts.dup
+      #o[:page_size] ||= page_size(opts[:xdim], opts[:height], opts[:margin])
+      #%w(left right top bottom).each{|s| o[:"#{s}_margin"] ||= opts[:margin] }
+      o[:page_size] ||= 'A4' #Prawn doesn't currently support custom page sizes
+      o
+    end
+
+    def page_size(xdim, height, margin)
+      [width(xdim,margin), height(height,margin)]
+    end
+
+    def width(xdim, margin)
+      (xdim * encoding.length) + (margin * 2)
+    end
+
+    def height(height, margin)
+      height + (margin * 2)
+    end
+
+
+  end
+
+end