barby-chunky_png 0.3.3

data/lib/barby/outputter/rmagick_outputter.rb

@@ -0,0 +1,126 @@
+require 'barby/outputter'
+require 'RMagick'
+
+module Barby
+
+
+  #Renders images from barcodes using RMagick
+  #
+  #Registers the to_png, to_gif, to_jpg and to_image methods
+  class RmagickOutputter < Outputter
+  
+    register :to_png, :to_gif, :to_jpg, :to_image
+
+    attr_accessor :height, :xdim, :ydim, :margin
+
+
+    #Returns a string containing a PNG image
+    def to_png(*a)
+      to_blob('png', *a)
+    end
+
+    #Returns a string containint a GIF image
+    def to_gif(*a)
+      to_blob('gif', *a)
+    end
+
+    #Returns a string containing a JPEG image
+    def to_jpg(*a)
+      to_blob('jpg', *a)
+    end
+    
+    def to_blob(format, *a)
+      img = to_image(*a)
+      blob = img.to_blob{|i| i.format = format }
+      
+      #Release the memory used by RMagick explicitly. Ruby's GC
+      #isn't aware of it and can't clean it up automatically
+      img.destroy! if img.respond_to?(:destroy!)
+      
+      blob
+    end
+
+    #Returns an instance of Magick::Image
+    def to_image(opts={})
+      with_options opts do
+        canvas = Magick::Image.new(full_width, full_height)
+        bars = Magick::Draw.new
+
+        x = margin
+        y = margin
+
+        if barcode.two_dimensional?
+          encoding.each do |line|
+            line.split(//).map{|c| c == '1' }.each do |bar|
+              if bar
+                bars.rectangle(x, y, x+(xdim-1), y+(ydim-1))
+              end
+              x += xdim
+            end
+            x = margin
+            y += ydim
+          end
+        else
+          booleans.each do |bar|
+            if bar
+              bars.rectangle(x, y, x+(xdim-1), y+(height-1))
+            end
+            x += xdim
+          end
+        end
+
+        bars.draw(canvas)
+
+        canvas
+      end
+    end
+
+
+    #The height of the barcode in px
+    #For 2D barcodes this is the number of "lines" * ydim
+    def height
+      barcode.two_dimensional? ? (ydim * encoding.length) : (@height || 100)
+    end
+
+    #The width of the barcode in px
+    def width
+      length * xdim
+    end
+
+    #Number of modules (xdims) on the x axis
+    def length
+      barcode.two_dimensional? ? encoding.first.length : encoding.length
+    end
+
+    #X dimension. 1X == 1px
+    def xdim
+      @xdim || 1
+    end
+
+    #Y dimension. Only for 2D codes
+    def ydim
+      @ydim || xdim
+    end
+
+    #The margin of each edge surrounding the barcode in pixels
+    def margin
+      @margin || 10
+    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/outputter/svg_outputter.rb

@@ -0,0 +1,225 @@
+require 'barby/outputter'
+
+module Barby
+
+  #Renders the barcode to a simple SVG image using pure ruby
+  #
+  #Registers the to_svg, bars_to_path, and bars_to_rects method
+  #
+  #Bars can be rendered as a stroked path or as filled rectangles.  Path
+  #generally yields smaller files, but this doesn't render cleanly in Firefox
+  #3 for odd xdims.  My guess is that the renderer tries to put half a pixel
+  #on one side of the path and half on the other, leading to fuzzy dithering
+  #instead of sharp, clean b&w.
+  #
+  #Therefore, default behavior is to use a path for even xdims, and
+  #rectangles for odd.  This can be overridden by calling with explicit
+  #:use => 'rects' or :use => 'path' options.
+  class SvgOutputter < Outputter
+
+    register :to_svg, :bars_to_rects, :bars_to_path
+
+    attr_writer :title, :xdim, :ydim, :height, :rmargin, :lmargin, :tmargin, :bmargin, :xmargin, :ymargin, :margin
+
+
+    def to_svg(opts={})
+      with_options opts do
+        case opts[:use]
+          when 'rects' then bars = bars_to_rects
+          when 'path'  then bars = bars_to_path
+        else
+          xdim_odd = (xdim % 2 == 1)
+          bars = xdim_odd ? bars_to_rects : bars_to_path
+        end
+
+        <<-"EOT"
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{svg_width(opts)}px" height="#{svg_height(opts)}px" viewBox="0 0 #{svg_width(opts)} #{svg_height(opts)}" version="1.1">
+<title>#{escape title}</title>
+<g id="canvas" #{transform(opts)}>
+<rect x="0" y="0" width="#{full_width}px" height="#{full_height}px" fill="white" />
+<g id="barcode" fill="black">
+#{bars}
+</g></g>
+</svg>
+EOT
+      end
+    end
+
+
+    def bars_to_rects(opts={})
+      rects = ''
+      with_options opts do
+        x, y = lmargin, tmargin
+
+        if barcode.two_dimensional?
+          boolean_groups.each do |line|
+            line.each do |bar, amount|
+              bar_width = xdim * amount
+              if bar
+                rects << %Q|<rect x="#{x}" y="#{y}" width="#{bar_width}px" height="#{ydim}px" />\n|
+              end
+              x += bar_width
+            end
+            y += ydim
+            x = lmargin
+          end
+
+        else
+          boolean_groups.each do |bar, amount|
+            bar_width = xdim * amount
+            if bar
+              rects << %Q|<rect x="#{x}" y="#{y}" width="#{bar_width}px" height="#{height}px" />\n|
+            end
+            x += bar_width
+          end
+
+        end
+      end # with_options
+
+      rects
+    end
+
+
+    def bars_to_path(opts={})
+      with_options opts do
+        %Q|<path stroke="black" stroke-width="#{xdim}" d="#{bars_to_path_data(opts)}" />|
+      end
+    end
+
+
+    def bars_to_path_data(opts={})
+      path_data = ''
+      with_options opts do
+        x, y = lmargin+(xdim/2), tmargin
+
+        if barcode.two_dimensional?
+          booleans.each do |line|
+            line.each do |bar|
+              if bar
+                path_data << "M#{x} #{y}V #{y+ydim}"
+              end
+              x += xdim
+            end
+            y += ydim
+            x = lmargin+(xdim/2)
+          end
+
+        else
+          booleans.each do |bar|
+            if bar
+              path_data << "M#{x} #{y}V#{y+height}"
+            end
+            x += xdim
+          end
+
+        end
+      end # with_options
+
+      path_data
+    end
+
+
+    def title
+      @title || barcode.to_s
+    end
+
+
+    def width
+      length * xdim
+    end
+
+    def height
+      barcode.two_dimensional? ? (ydim * encoding.length) : (@height || 100)
+    end
+
+    def full_width
+      width + lmargin + rmargin
+    end
+
+    def full_height
+      height + tmargin + bmargin
+    end
+
+    def xdim
+      @xdim || 1
+    end
+
+    def ydim
+      @ydim || xdim
+    end
+
+    def lmargin
+      @lmargin || _xmargin
+    end
+
+    def rmargin
+      @rmargin || _xmargin
+    end
+
+    def tmargin
+      @tmargin || _ymargin
+    end
+
+    def bmargin
+      @bmargin || _ymargin
+    end
+
+    def xmargin
+      return nil if @lmargin || @rmargin
+      _margin
+    end
+
+    def ymargin
+      return nil if @tmargin || @bmargin
+      _margin
+    end
+
+    def margin
+      return nil if @ymargin || @xmargin || @tmargin || @bmargin || @lmargin || @rmargin
+      _margin
+    end
+
+    def length
+      barcode.two_dimensional? ? encoding.first.length : encoding.length
+    end
+
+
+    def svg_width(opts={})
+      opts[:rot] ? full_height : full_width
+    end
+
+    def svg_height(opts={})
+      opts[:rot] ? full_width : full_height
+    end
+
+
+    def transform(opts={})
+      opts[:rot] ? %Q|transform="rotate(-90) translate(-#{full_width}, 0)"| : nil
+    end
+
+
+  private
+
+    def _xmargin
+      @xmargin || _margin
+    end
+
+    def _ymargin
+      @ymargin || _margin
+    end
+
+    def _margin
+      @margin || 10
+    end
+
+    #Escape XML special characters <, & and >
+    def escape(str)
+      str.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+    end
+
+
+  end
+
+
+end

data/lib/barby/outputter.rb

@@ -0,0 +1,132 @@
+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
+
+    def two_dimensional?
+      barcode.respond_to?(:two_dimensional?) && barcode.two_dimensional?
+    end
+
+
+    #Converts the barcode's encoding (a string containing 1s and 0s)
+    #to true and false values (1 == true == "black bar")
+    #
+    #If the barcode is 2D, each line will be converted to an array
+    #in the same way
+    def booleans(reload=false)#:doc:
+      if 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 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
+
+
+  end
+
+
+end

data/lib/barby/vendor.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/../../vendor/*/lib"].each do |d|
+  $: << File.expand_path(d)
+end

data/lib/barby/version.rb

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

data/lib/barby.rb

@@ -0,0 +1,17 @@
+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/barcode/code_25'
+require 'barby/barcode/code_25_interleaved'
+require 'barby/barcode/code_25_iata'
+
+require 'barby/outputter'