barby 0.6.7 → 0.6.8

data/test/outputter/html_outputter_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+require 'barby/barcode/code_128'
+#require 'barby/outputter/html_outputter'
+
+class HtmlOutputterTest < Barby::TestCase
+
+  class MockCode
+    attr_reader :encoding
+    def initialize(e)
+      @encoding = e
+    end
+    def two_dimensional?
+      encoding.is_a? Array
+    end
+  end
+
+  before do
+    load_outputter('html')
+    @barcode = Barby::Code128B.new('BARBY')
+    @outputter = HtmlOutputter.new(@barcode)
+  end
+
+  it "should register to_html" do
+    Barcode.outputters.must_include(:to_html)
+  end
+
+  it 'should have the expected start HTML' do
+    assert_equal '<table class="barby-barcode"><tbody>', @outputter.start
+  end
+
+  it 'should be able to set additional class name' do
+    @outputter.class_name = 'humbaba'
+    assert_equal '<table class="barby-barcode humbaba"><tbody>', @outputter.start
+  end
+
+  it 'should have the expected stop HTML' do
+    assert_equal '</tbody></table>', @outputter.stop
+  end
+
+  it 'should build the expected cells' do
+    assert_equal ['<td class="barby-cell on"></td>', '<td class="barby-cell off"></td>', '<td class="barby-cell off"></td>', '<td class="barby-cell on"></td>'],
+      @outputter.cells_for([true, false, false, true])
+  end
+
+  it 'should build the expected rows' do
+    assert_equal(
+      [
+        "<tr class=\"barby-row\">#{@outputter.cells_for([true, false]).join}</tr>",
+        "<tr class=\"barby-row\">#{@outputter.cells_for([false, true]).join}</tr>",
+      ],
+      @outputter.rows_for([[true, false],[false, true]])
+    )
+  end
+
+  it 'should have the expected rows' do
+    barcode = MockCode.new('101100')
+    outputter = HtmlOutputter.new(barcode)
+    assert_equal outputter.rows_for([[true, false, true, true, false, false]]), outputter.rows
+    barcode = MockCode.new(['101', '010'])
+    outputter = HtmlOutputter.new(barcode)
+    assert_equal outputter.rows_for([[true, false, true], [false, true, false]]), outputter.rows
+  end
+
+  it 'should have the expected html' do
+    assert_equal @outputter.start + @outputter.rows.join + @outputter.stop, @outputter.to_html
+  end
+
+end

data/test/outputter/pdfwriter_outputter_test.rb

@@ -0,0 +1,37 @@
+unless RUBY_VERSION >= '1.9'
+
+  require 'test_helper'
+  require 'pdf/writer'
+
+  class PDFWriterOutputterTest < Barby::TestCase
+
+    before do
+      load_outputter('pdfwriter')
+      @barcode = Barcode.new
+      def @barcode.encoding; '101100111000'; end
+      @outputter = PDFWriterOutputter.new(@barcode)
+      @pdf = PDF::Writer.new
+    end
+
+    it "should have registered annotate_pdf" do
+      Barcode.outputters.must_include(:annotate_pdf)
+    end
+
+    it "should have defined the annotate_pdf method" do
+      @outputter.must_respond_to(:annotate_pdf)
+    end
+
+    it "should return the pdf object it was given in annotate_pdf" do
+      @barcode.annotate_pdf(@pdf).object_id.must_equal @pdf.object_id
+    end
+
+    it "should have x, y, height and xdim attributes" do
+      @outputter.must_respond_to(:x)
+      @outputter.must_respond_to(:y)
+      @outputter.must_respond_to(:height)
+      @outputter.must_respond_to(:xdim)
+    end
+
+  end
+
+end

data/test/outputter/png_outputter_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class PngTestBarcode < Barby::Barcode
+  def initialize(data)
+    @data = data
+  end
+  def encoding
+    @data
+  end
+end
+
+class PngOutputterTest < Barby::TestCase
+
+  before do
+    load_outputter('png')
+    @barcode = PngTestBarcode.new('10110011100011110000')
+    @outputter = PngOutputter.new(@barcode)
+  end
+  
+  it "should register to_png and to_image" do
+    Barcode.outputters.must_include(:to_png)
+    Barcode.outputters.must_include(:to_image)
+  end
+
+  it "should return a ChunkyPNG::Datastream on to_datastream" do
+    @barcode.to_datastream.must_be_instance_of(ChunkyPNG::Datastream)
+  end
+
+  it "should return a string on to_png" do
+    @barcode.to_png.must_be_instance_of(String)
+  end
+
+  it "should return a ChunkyPNG::Image on to_canvas" do
+    @barcode.to_image.must_be_instance_of(ChunkyPNG::Image)
+  end
+
+  it "should have a width equal to Xdim * barcode_string.length" do
+    @outputter.width.must_equal @outputter.barcode.encoding.length * @outputter.xdim
+  end
+
+  it "should have a full_width which is the sum of width + (margin*2)" do
+    @outputter.full_width.must_equal @outputter.width + (@outputter.margin*2)
+  end
+
+  it "should have a full_height which is the sum of height + (margin*2)" do
+    @outputter.full_height.must_equal @outputter.height + (@outputter.margin*2)
+  end
+
+end

data/test/outputter/prawn_outputter_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class PrawnOutputterTest < Barby::TestCase
+
+  before do
+    load_outputter('prawn')
+    @barcode = Barcode.new
+    def @barcode.encoding;  '10110011100011110000'; end
+    @outputter = PrawnOutputter.new(@barcode)
+  end
+
+  it "should register to_pdf and annotate_pdf" do
+    Barcode.outputters.must_include(:to_pdf)
+    Barcode.outputters.must_include(:annotate_pdf)
+  end
+
+  it "should have a to_pdf method" do
+    @outputter.must_respond_to(:to_pdf)
+  end
+
+  it "should return a PDF document in a string on to_pdf" do
+    @barcode.to_pdf.must_be_instance_of(String)
+  end
+
+  it "should return the same Prawn::Document on annotate_pdf" do
+    doc = Prawn::Document.new
+    @barcode.annotate_pdf(doc).object_id.must_equal doc.object_id
+  end
+
+  it "should default x and y to margin value" do
+    @outputter.margin = 123
+    @outputter.x.must_equal 123
+    @outputter.y.must_equal 123
+  end
+
+  it "should default ydim to xdim value" do
+    @outputter.xdim = 321
+    @outputter.ydim.must_equal 321
+  end
+
+  it "should be able to calculate width required" do
+    @outputter.width.must_equal @barcode.encoding.length
+    @outputter.xdim = 2
+    @outputter.width.must_equal @barcode.encoding.length * 2
+    @outputter.full_width.must_equal @barcode.encoding.length * 2
+    @outputter.margin = 5
+    @outputter.full_width.must_equal((@barcode.encoding.length * 2) + 10)
+
+    #2D
+    barcode = Barcode2D.new
+    def barcode.encoding; ['111', '000', '111'] end
+    outputter = PrawnOutputter.new(barcode)
+    outputter.width.must_equal 3
+    outputter.xdim = 2
+    outputter.margin = 5
+    outputter.width.must_equal 6
+    outputter.full_width.must_equal 16
+  end
+
+  it "should be able to calculate height required" do
+    @outputter.full_height.must_equal @outputter.height
+    @outputter.margin = 5
+    @outputter.full_height.must_equal @outputter.height + 10
+
+    #2D
+    barcode = Barcode2D.new
+    def barcode.encoding; ['111', '000', '111'] end
+    outputter = PrawnOutputter.new(barcode)
+    outputter.height.must_equal 3
+    outputter.xdim = 2 #ydim defaults to xdim
+    outputter.margin = 5
+    outputter.height.must_equal 6
+    outputter.full_height.must_equal 16
+    outputter.ydim = 3 #ydim overrides xdim when set
+    outputter.height.must_equal 9
+    outputter.full_height.must_equal 19
+  end
+
+end

data/test/outputter/rmagick_outputter_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+class RmagickTestBarcode < Barby::Barcode
+  def initialize(data)
+    @data = data
+  end
+  def encoding
+    @data
+  end
+end
+
+class RmagickOutputterTest < Barby::TestCase
+
+  before do
+    load_outputter('rmagick')
+    @barcode = RmagickTestBarcode.new('10110011100011110000')
+    @outputter = RmagickOutputter.new(@barcode)
+  end
+
+  it "should register to_png, to_gif, to_jpg, to_image" do
+    Barcode.outputters.must_include(:to_png)
+    Barcode.outputters.must_include(:to_gif)
+    Barcode.outputters.must_include(:to_jpg)
+    Barcode.outputters.must_include(:to_image)
+  end
+
+  it "should have defined to_png, to_gif, to_jpg, to_image" do
+    @outputter.must_respond_to(:to_png)
+    @outputter.must_respond_to(:to_gif)
+    @outputter.must_respond_to(:to_jpg)
+    @outputter.must_respond_to(:to_image)
+  end
+
+  it "should return a string on to_png and to_gif" do
+    @outputter.to_png.must_be_instance_of(String)
+    @outputter.to_gif.must_be_instance_of(String)
+  end
+
+  it "should return a Magick::Image instance on to_image" do
+    @outputter.to_image.must_be_instance_of(Magick::Image)
+  end
+
+  it "should have a width equal to the length of the barcode encoding string * x dimension" do
+    @outputter.xdim.must_equal 1#Default
+    @outputter.width.must_equal @outputter.barcode.encoding.length
+    @outputter.xdim = 2
+    @outputter.width.must_equal @outputter.barcode.encoding.length * 2
+  end
+
+  it "should have a full_width equal to the width + left and right margins" do
+    @outputter.xdim.must_equal 1
+    @outputter.margin.must_equal 10
+    @outputter.full_width.must_equal (@outputter.width + 10 + 10)
+  end
+
+  it "should have a default height of 100" do
+    @outputter.height.must_equal 100
+    @outputter.height = 200
+    @outputter.height.must_equal 200
+  end
+
+  it "should have a full_height equal to the height + top and bottom margins" do
+    @outputter.full_height.must_equal @outputter.height + (@outputter.margin * 2)
+  end
+
+  describe "#to_image" do
+
+    before do
+      @barcode = RmagickTestBarcode.new('10110011100011110000')
+      @outputter = RmagickOutputter.new(@barcode)
+      @image = @outputter.to_image
+    end
+
+    it "should have a width and height equal to the outputter's full_width and full_height" do
+      @image.columns.must_equal @outputter.full_width
+      @image.rows.must_equal @outputter.full_height
+    end
+
+  end
+
+end
+
+

data/test/outputter/svg_outputter_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class SvgBarcode < Barby::Barcode
+  attr_accessor :data, :two_d
+  def initialize(data, two_d=false)
+    self.data, self.two_d = data, two_d
+  end
+  def encoding
+    data
+  end
+  def two_dimensional?
+    two_d
+  end
+  def to_s
+    data
+  end
+end
+
+class SvgOutputterTest < Barby::TestCase
+  
+  before do
+    load_outputter('svg')
+    @barcode = SvgBarcode.new('10110011100011110000')
+    @outputter = SvgOutputter.new(@barcode)
+  end
+
+  it 'should register to_svg, bars_to_rects, and bars_to_path' do
+    Barcode.outputters.must_include :to_svg
+    Barcode.outputters.must_include :bars_to_rects
+    Barcode.outputters.must_include :bars_to_path
+  end
+
+  it 'should return a string on to_svg' do
+    @barcode.to_svg.must_be_instance_of String
+  end
+  
+  it 'should return a string on bars_to_rects' do
+    @barcode.bars_to_rects.must_be_instance_of String
+  end
+  
+  it 'should return a string on bars_to_path' do
+    @barcode.bars_to_path.must_be_instance_of String
+  end
+  
+  it 'should produce one rect for each bar' do
+    @barcode.bars_to_rects.scan(/<rect/).size.must_equal @outputter.send(:boolean_groups).select{|bg|bg[0]}.size
+  end
+  
+  it 'should produce one path stroke for each bar module' do
+    @barcode.bars_to_path.scan(/(M\d+\s+\d+)\s*(V\d+)/).size.must_equal @outputter.send(:booleans).select{|bg|bg}.size
+  end
+  
+  it 'should return default values for attributes' do
+    @outputter.margin.must_be_instance_of Fixnum
+  end
+  
+  it 'should use defaults to populate higher level attributes' do
+    @outputter.xmargin.must_equal @outputter.margin
+  end
+  
+  it 'should return nil for overridden attributes' do
+    @outputter.xmargin = 1
+    @outputter.margin.must_equal nil
+  end
+  
+  it 'should still use defaults for unspecified attributes' do
+    @outputter.xmargin = 1
+    @outputter.ymargin.must_equal @outputter.send(:_margin)
+  end
+  
+  it 'should have a width equal to Xdim * barcode_string.length' do
+    @outputter.width.must_equal @outputter.barcode.encoding.length * @outputter.xdim
+  end
+  
+  it 'should have a full_width which is by default the sum of width + (margin*2)' do
+    @outputter.full_width.must_equal @outputter.width + (@outputter.margin*2)
+  end
+  
+  it 'should have a full_width which is the sum of width + xmargin + ymargin' do
+    @outputter.full_width.must_equal @outputter.width + @outputter.xmargin + @outputter.ymargin
+  end
+  
+  it 'should use Barcode#to_s for title' do
+    @outputter.title.must_equal @barcode.data
+    def @barcode.to_s; "the eastern star"; end
+    @outputter.title.must_equal "the eastern star"
+  end
+  
+end

data/test/outputter_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+
+class OutputterTest < Barby::TestCase
+
+  before do
+    @outputter = Class.new(Outputter)
+  end
+
+  it "should be able to register an output method for barcodes" do
+    @outputter.register :foo
+    Barcode.outputters.must_include(:foo)
+    @outputter.register :bar, :baz
+    Barcode.outputters.must_include(:bar)
+    Barcode.outputters.must_include(:baz)
+    @outputter.register :quux => :my_quux
+    Barcode.outputters.must_include(:quux)
+  end
+  
+  describe "Outputter instances" do
+
+    before do
+      @barcode = Barcode.new
+      class << @barcode; attr_accessor :encoding; end
+      @barcode.encoding = '101100111000'
+      @outputter = Outputter.new(@barcode)
+    end
+
+    it "should have a method 'booleans' which converts the barcode encoding to an array of true,false values" do
+      @outputter.send(:booleans).length.must_equal @barcode.encoding.length
+      t, f = true, false
+      @outputter.send(:booleans).must_equal [t,f,t,t,f,f,t,t,t,f,f,f]
+    end
+
+    it "should convert 2D encodings with 'booleans'" do
+      barcode = Barcode2D.new
+      def barcode.encoding; ['101100','110010']; end
+      outputter = Outputter.new(barcode)
+      outputter.send(:booleans).length.must_equal barcode.encoding.length
+      t, f = true, false
+      outputter.send(:booleans).must_equal [[t,f,t,t,f,f], [t,t,f,f,t,f]]
+    end
+
+    it "should have an 'encoding' attribute" do
+      @outputter.send(:encoding).must_equal @barcode.encoding
+    end
+
+    it "should cache encoding" do
+      @outputter.send(:encoding).must_equal @barcode.encoding
+      previous_encoding = @barcode.encoding
+      @barcode.encoding = '101010'
+      @outputter.send(:encoding).must_equal previous_encoding
+      @outputter.send(:encoding, true).must_equal @barcode.encoding
+    end
+
+    it "should have a boolean_groups attribute which collects continuous bars and spaces" do
+      t, f = true, false
+                                                  # 1     0     11    00    111   000
+      @outputter.send(:boolean_groups).must_equal [[t,1],[f,1],[t,2],[f,2],[t,3],[f,3]]
+
+      barcode = Barcode2D.new
+      def barcode.encoding; ['1100', '111000']; end
+      outputter = Outputter.new(barcode)
+      outputter.send(:boolean_groups).must_equal [[[t,2],[f,2]],[[t,3],[f,3]]]
+    end
+
+    it "should have a with_options method which sets the instance's attributes temporarily while the block gets yielded" do
+      class << @outputter; attr_accessor :foo, :bar; end
+      @outputter.foo, @outputter.bar = 'humbaba', 'scorpion man'
+      @outputter.send(:with_options, :foo => 'horse', :bar => 'donkey') do
+        @outputter.foo.must_equal 'horse'
+        @outputter.bar.must_equal 'donkey'
+      end
+      @outputter.foo.must_equal 'humbaba'
+      @outputter.bar.must_equal 'scorpion man'
+    end
+
+    it "should return the block value on with_options" do
+      @outputter.send(:with_options, {}){ 'donkey' }.must_equal 'donkey'
+    end
+
+    it "should have a two_dimensional? method which returns true if the barcode is 2d" do
+      refute Outputter.new(Barcode1D.new).send(:two_dimensional?)
+      assert Outputter.new(Barcode2D.new).send(:two_dimensional?)
+    end
+
+    it "should not require the barcode object to respond to two_dimensional?" do
+      barcode = Object.new
+      def barcode.encoding; "101100111000"; end
+      outputter = Outputter.new(barcode)
+      assert outputter.send(:booleans)
+      assert outputter.send(:boolean_groups)
+    end
+
+  end
+
+  describe "Barcode instances" do
+  
+    before do
+      @outputter = Class.new(Outputter)
+      @outputter.register :foo
+      @outputter.register :bar => :my_bar
+      @outputter.class_eval{ def foo; 'foo'; end; def my_bar; 'bar'; end }
+      @barcode = Barcode.new
+    end
+  
+    it "should respond to registered output methods" do
+      @barcode.foo.must_equal 'foo'
+      @barcode.bar.must_equal 'bar'
+    end
+  
+    it "should send arguments to registered method on outputter class" do
+      @outputter.class_eval{ def foo(*a); a; end; def my_bar(*a); a; end }
+      @barcode.foo(1,2,3).must_equal [1,2,3]
+      @barcode.bar('humbaba').must_equal ['humbaba']
+    end
+  
+    it "should pass block to registered methods" do
+      @outputter.class_eval{ def foo(*a, &b); b.call(*a); end }
+      @barcode.foo(1,2,3){|*a| a }.must_equal [1,2,3]
+    end
+  
+    it "should be able to get an instance of a specific outputter" do
+      @barcode.outputter_for(:foo).must_be_instance_of(@outputter)
+    end
+  
+    it "should be able to get a specific outputter class" do
+      @barcode.outputter_class_for(:foo).must_equal @outputter
+    end
+  
+  end
+
+end
+
+