zebra-zpl 1.0.0

data/spec/zebra/zpl/barcode_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::Barcode do
+  it "can be initialized with the position of the text to be printed" do
+    barcode = described_class.new :position => [20, 40]
+    barcode.position.should == [20,40]
+    barcode.x.should == 20
+    barcode.y.should == 40
+  end
+
+  it "can be initialized with the barcode rotation" do
+    rotation = Zebra::Zpl::Rotation::DEGREES_90
+    barcode = described_class.new :rotation => rotation
+    barcode.rotation.should == rotation
+  end
+
+  it "can be initialized with the barcode rotation" do
+    rotation = Zebra::Zpl::Rotation::DEGREES_90
+    barcode = described_class.new :rotation => rotation
+    barcode.rotation.should == rotation
+  end
+
+  it "can be initialized with the barcode type" do
+    type = Zebra::Zpl::BarcodeType::CODE_128_C
+    barcode = described_class.new :type => type
+    barcode.type.should == type
+  end
+
+  it "can be initialized with the narrow bar width" do
+    barcode = described_class.new :narrow_bar_width => 3
+    barcode.narrow_bar_width.should == 3
+  end
+
+  it "can be initialized with the wide bar width" do
+    barcode = described_class.new :wide_bar_width => 10
+    barcode.wide_bar_width.should == 10
+  end
+
+  it "can be initialized with the barcode height" do
+    barcode = described_class.new :height => 20
+    barcode.height.should == 20
+  end
+
+  it "can be initialized informing if the human readable code should be printed" do
+    barcode = described_class.new :print_human_readable_code => true
+    barcode.print_human_readable_code.should == true
+  end
+
+  describe "#rotation=" do
+    it "raises an error if the received rotation is invalid" do
+      expect {
+        described_class.new.rotation = 4
+      }.to raise_error(Zebra::Zpl::Rotation::InvalidRotationError)
+    end
+  end
+
+  describe "#type=" do
+    it "raises an error if the received type is invalid" do
+      expect {
+        described_class.new.type = "ZZZ"
+      }.to raise_error(Zebra::Zpl::BarcodeType::InvalidBarcodeTypeError)
+    end
+  end
+
+  describe "#narrow_bar_width=" do
+    it "raises an error if the type is Code 128 and the width is invalid" do
+      expect {
+        described_class.new :type => Zebra::Zpl::BarcodeType::CODE_128_AUTO, :narrow_bar_width => 20
+      }.to raise_error(Zebra::Zpl::Barcode::InvalidNarrowBarWidthError)
+    end
+  end
+
+  describe "#wide_bar_width=" do
+    it "raises an error if the type is Code 128 and the width is invalid" do
+      expect {
+        described_class.new :type => Zebra::Zpl::BarcodeType::CODE_128_AUTO, :wide_bar_width => 40
+      }.to raise_error(Zebra::Zpl::Barcode::InvalidWideBarWidthError)
+    end
+  end
+
+  describe "#print_human_readable_code" do
+    it "defaults to false" do
+      described_class.new.print_human_readable_code.should == false
+    end
+  end
+
+  describe "#to_zpl" do
+    let(:valid_attributes) { {
+      :position         => [100, 150],
+      :type             => Zebra::Zpl::BarcodeType::CODE_128_AUTO,
+      :height           => 20,
+      :narrow_bar_width => 4,
+      :wide_bar_width   => 6,
+      :data             => "foobar"
+    } }
+    let(:barcode) { described_class.new valid_attributes }
+    let(:tokens) { barcode.to_zpl.split(",") }
+
+    it "raises an error if the X position was not informed" do
+      barcode = described_class.new :position => [nil, 100], :data => "foobar"
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the X value is not given")
+    end
+
+    it "raises an error if the Y position was not informed" do
+      barcode = described_class.new :position => [100, nil]
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the Y value is not given")
+    end
+
+    it "raises an error if the barcode type is not informed" do
+      barcode = described_class.new :position => [100, 100], :data => "foobar"
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the barcode type to be used is not given")
+    end
+
+    it "raises an error if the data to be printed was not informed" do
+      barcode.data = nil
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the data to be printed is not given")
+    end
+
+    it "raises an error if the height to be used was not informed" do
+      barcode.height = nil
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the height to be used is not given")
+    end
+
+    it "raises an error if the narrow bar width is not given" do
+      valid_attributes.delete :narrow_bar_width
+
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the narrow bar width to be used is not given")
+    end
+
+    it "raises an error if the wide bar width is not given" do
+      valid_attributes.delete :wide_bar_width
+
+      expect {
+        barcode.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the wide bar width to be used is not given")
+    end
+
+    it "begins with the command 'B'" do
+      barcode.to_zpl.should =~ /\AB/
+    end
+
+    it "contains the X position" do
+      tokens[0].match(/B(\d+)/)[1].should == "100"
+    end
+
+    it "contains the Y position" do
+      tokens[1].should == "150"
+    end
+
+    it "contains the barcode rotation" do
+      tokens[2].should == Zebra::Zpl::Rotation::NO_ROTATION.to_s
+    end
+
+    it "contains the barcode type" do
+      tokens[3].should == Zebra::Zpl::BarcodeType::CODE_128_AUTO
+    end
+
+    it "contains the barcode narrow bar width" do
+      tokens[4].should == "4"
+    end
+
+    it "contains the barcode wide bar width" do
+      tokens[5].should == "6"
+    end
+
+    it "contains the barcode height" do
+      tokens[6].should == "20"
+    end
+
+    it "contains the correct indication when the human readable code should be printed" do
+      valid_attributes.merge! :print_human_readable_code => true
+      tokens[7].should == "B"
+    end
+
+    it "contains the correct indication when the human readable code should not be printed" do
+      valid_attributes.merge! :print_human_readable_code => false
+      tokens[7].should == "N"
+    end
+
+    it "contains the data to be printed in the barcode" do
+      tokens[8].should == "\"foobar\""
+    end
+  end
+end

data/spec/zebra/zpl/box_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Zebra::Zpl::Box do
+  it "can be initialized with initial position" do
+    box = described_class.new :position => [20, 40]
+    box.position.should == [20, 40]
+    box.x.should == 20
+    box.y.should == 40
+  end
+
+  it "can be initialized with the end position" do
+    box = described_class.new :end_position => [20, 40]
+    box.end_position.should == [20, 40]
+    box.end_x.should == 20
+    box.end_y.should == 40
+  end
+
+  it "can be initialized with the line thckness " do
+    box = described_class.new :line_thickness => 3
+    box.line_thickness.should == 3
+  end
+
+  describe "#to_zpl" do
+    subject(:box)    { described_class.new attributes }
+    let(:attributes) { { :position => [20,40], :end_position => [60, 100], :line_thickness => 3 }  }
+
+    it "raises an error if the X position was not informed" do
+      box = described_class.new attributes.merge :position => [nil, 40]
+      expect {
+        box.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the X value is not given")
+    end
+
+    it "raises an error if the Y position was not informed" do
+      box = described_class.new attributes.merge :position => [20, nil]
+      expect {
+        box.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the Y value is not given")
+    end
+
+    it "raises an error if the end X position was not informed" do
+      box = described_class.new attributes.merge :end_position => [nil, 40]
+      expect {
+        box.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the horizontal end position (X) is not given")
+    end
+
+    it "raises an error if the end Y position was not informed" do
+      box = described_class.new attributes.merge :end_position => [20, nil]
+      expect {
+        box.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the vertical end position (Y) is not given")
+    end
+
+    it "raises an error if the line thickness was not informed" do
+      box = described_class.new attributes.merge :line_thickness => nil
+      expect {
+        box.to_zpl
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the line thickness is not given")
+    end
+
+    it "begins with the 'X' command" do
+      box.to_zpl.should =~ /\AX/
+    end
+
+    it "contains the attributes in correct order" do
+      box.to_zpl.should == "X20,40,3,60,100"
+    end
+  end
+end

data/spec/zebra/zpl/character_set_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::CharacterSet do
+  it "can be initialized with the number of data bits" do
+    character_set = described_class.new :number_of_data_bits => 8
+    character_set.number_of_data_bits.should == 8
+  end
+
+  it "raises an error when receiving an invalid number of data bits" do
+    expect {
+      described_class.new :number_of_data_bits => 9
+    }.to raise_error(Zebra::Zpl::CharacterSet::InvalidNumberOfDataBits)
+  end
+
+  it "can be initialized with the language" do
+    character_set = described_class.new :language => Zebra::Zpl::Language::PORTUGUESE
+    character_set.language.should == Zebra::Zpl::Language::PORTUGUESE
+  end
+
+  it "raises an error with an invalid language" do
+    expect {
+      described_class.new :language => "G"
+    }.to raise_error(Zebra::Zpl::Language::InvalidLanguageError)
+  end
+
+  it "can be initialized with the country code" do
+    character_set = described_class.new :country_code => Zebra::Zpl::CountryCode::LATIN_AMERICA
+    character_set.country_code.should == Zebra::Zpl::CountryCode::LATIN_AMERICA
+  end
+
+  it "raises an error with an invalid country code" do
+    expect {
+      described_class.new :country_code => "999"
+    }.to raise_error(Zebra::Zpl::CountryCode::InvalidCountryCodeError)
+  end
+
+  describe "#to_zpl" do
+    let(:valid_attributes) { {
+      :number_of_data_bits => 8,
+      :language            => Zebra::Zpl::Language::PORTUGUESE,
+      :country_code        => Zebra::Zpl::CountryCode::LATIN_AMERICA
+    } }
+    let(:character_set) { described_class.new valid_attributes }
+    let(:tokens) { character_set.to_zpl.split(",") }
+
+    it "raises an error if the number of data bits was not informed" do
+      character_set = described_class.new valid_attributes.merge :number_of_data_bits => nil
+      expect {
+        character_set.to_zpl
+      }.to raise_error(Zebra::Zpl::CharacterSet::MissingAttributeError, "Can't set character set if the number of data bits is not given")
+    end
+
+    it "raises an error if the language was not informed" do
+      character_set = described_class.new valid_attributes.merge :language => nil
+      expect {
+        character_set.to_zpl
+      }.to raise_error(Zebra::Zpl::CharacterSet::MissingAttributeError, "Can't set character set if the language is not given")
+    end
+
+    it "raises an error if the country code was not informed and the number of bits is 8" do
+      character_set = described_class.new valid_attributes.merge :country_code => nil
+      expect {
+        character_set.to_zpl
+      }.to raise_error(Zebra::Zpl::CharacterSet::MissingAttributeError, "Can't set character set if the country code is not given")
+    end
+
+    it "raises an error if the country code was informed and the number of bits is 7" do
+      character_set = described_class.new valid_attributes.merge :country_code => Zebra::Zpl::CountryCode::LATIN_AMERICA, :number_of_data_bits => 7
+      expect {
+        character_set.to_zpl
+      }.to raise_error(Zebra::Zpl::CharacterSet::CountryCodeNotApplicableForNumberOfDataBits)
+    end
+
+    it "does not raise an error if the country code was not informed and the number of data bits is 7" do
+      character_set = described_class.new :number_of_data_bits => 7, :language => Zebra::Zpl::Language::USA, :country_code => nil
+    end
+
+    it "raises an error if the language is not supported by the given number of data bits" do
+      expect {
+        described_class.new(:number_of_data_bits => 7, :language => Zebra::Zpl::Language::LATIN_1_WINDOWS).to_zpl
+      }.to raise_error(Zebra::Zpl::Language::InvalidLanguageForNumberOfDataBitsError)
+    end
+
+    it "begins with the command 'I'" do
+      character_set.to_zpl.should =~ /\AI/
+    end
+
+    it "contains the number of data bits" do
+      tokens[0].match(/I(\d)/)[1].should == "8"
+    end
+
+    it "contains the language" do
+      tokens[1].should == Zebra::Zpl::Language::PORTUGUESE
+    end
+
+    it "contains the country code" do
+      tokens[2].should == Zebra::Zpl::CountryCode::LATIN_AMERICA
+    end
+  end
+end

data/spec/zebra/zpl/label_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Zebra::Zpl::Label do
+  subject(:label) { described_class.new :print_speed => 2 }
+
+  describe "#new" do
+    it "sets the label width" do
+      label = described_class.new :width => 300
+      label.width.should == 300
+    end
+
+    it "sets the label length/gap" do
+      label = described_class.new :length_and_gap => [400, 24]
+      label.length.should == 400
+      label.gap.should    == 24
+    end
+
+    it "sets the printing speed" do
+      label = described_class.new :print_speed => 2
+      label.print_speed.should == 2
+    end
+
+    it "sets the number of copies" do
+      label = described_class.new :copies => 4
+      label.copies.should == 4
+    end
+
+    it "the number of copies defaults to 1" do
+      label = described_class.new
+      label.copies.should == 1
+    end
+
+    it "validates the printing speed" do
+      [-1, 8, "a"].each do |s|
+        expect {
+          described_class.new :print_speed => s
+        }.to raise_error(Zebra::Zpl::Label::InvalidPrintSpeedError)
+      end
+    end
+
+    it "sets the print density" do
+      label = described_class.new :print_density => 10
+      label.print_density.should == 10
+    end
+
+    it "validates the print density" do
+      [-1, 16, "a"].each do |d|
+        expect {
+          described_class.new :print_density => d
+        }.to raise_error(Zebra::Zpl::Label::InvalidPrintDensityError)
+      end
+    end
+  end
+
+  describe "#<<" do
+    it "adds an item to the list of label elements" do
+      expect {
+        label << stub
+      }.to change { label.elements.count }.by 1
+    end
+  end
+
+  describe "#dump_contents" do
+    let(:io) { "" }
+
+    it "dumps its contents to the received IO" do
+      label << stub(:to_zpl => "foobar")
+      label << stub(:to_zpl => "blabla")
+      label.width          = 100
+      label.length_and_gap = [200, 24]
+      label.print_speed    = 3
+      label.print_density  = 10
+      label.dump_contents(io)
+      io.should == "O\nQ200,24\nq100\nS3\nD10\n\nN\nfoobar\nblabla\nP1\n"
+    end
+
+    it "does not try to set the label width when it's not informed (falls back to autosense)" do
+      label.dump_contents(io)
+      io.should_not =~ /q/
+    end
+
+    it "does not try to set the length/gap when they were not informed (falls back to autosense)" do
+      label.dump_contents(io)
+      io.should_not =~ /Q/
+    end
+
+    it "does not try to set the print density when it's not informed (falls back to the default value)" do
+      label.dump_contents(io)
+      io.should_not =~ /D/
+    end
+
+    it "raises an error if the print speed was not informed" do
+      label = described_class.new
+      expect {
+        label.dump_contents(io)
+      }.to raise_error(Zebra::Zpl::Label::PrintSpeedNotInformedError)
+    end
+  end
+
+  describe "#persist" do
+    let(:tempfile) { stub.as_null_object }
+    let(:label)    { described_class.new :print_speed => 2 }
+
+    before do
+      Tempfile.stub :new => tempfile
+      label << stub(:to_zpl => "foobar")
+    end
+
+    it "creates a tempfile" do
+      Tempfile.should_receive(:new).with("zebra_label").and_return(tempfile)
+      label.persist
+    end
+
+    it "returns the tempfile" do
+      label.persist.should == tempfile
+    end
+
+    it "sets the `tempfile` attribute" do
+      label.persist
+      label.tempfile.should == tempfile
+    end
+  end
+
+  describe "#persisted?" do
+    it "returns false if the `tempfile` attribute is nil" do
+      label = described_class.new :print_speed => 2
+      label.should_not be_persisted
+    end
+
+    it "returns true if the `tempfile` attribute is not nil" do
+      label = described_class.new :print_speed => 2
+      label.instance_variable_set(:@tempfile, stub)
+      label.should be_persisted
+    end
+  end
+end

data/spec/zebra/zpl/qrcode_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::Qrcode do
+    it "can be initialized with the scale factor" do 
+      qrcode = described_class.new :scale_factor => 3
+      expect(qrcode.scale_factor).to eq 3
+    end 
+
+    it "can be initialized with the error correction level" do
+      qrcode = described_class.new :correction_level => "M"
+      expect(qrcode.correction_level).to eq "M"
+    end
+
+    describe "#scale_factor" do
+      it "raises an error if the scale factor is not within the range 1-99" do
+        expect{described_class.new :scale_factor=>100}.to raise_error(Zebra::Zpl::Qrcode::InvalidScaleFactorError)
+      end
+    end
+
+    describe "#correction_level" do
+      it "raises an error if the error correction_level not in [LMQH]" do
+        expect{described_class.new :correction_level=>"A"}.to raise_error(Zebra::Zpl::Qrcode::InvalidCorrectionLevelError)
+      end
+    end              
+
+    describe "#to_zpl" do
+      let(:valid_attributes) { {
+        :position         => [50, 50],
+        :scale_factor     => 3,
+        :correction_level => "M",
+        :data             => "foobar"
+      }}
+      let(:qrcode) { described_class.new valid_attributes }
+      let(:tokens) { qrcode.to_zpl.split(",") }
+
+      it "raises an error if the X position is not given" do
+        qrcode = described_class.new :position => [nil, 50], :data => "foobar"
+        expect {
+          qrcode.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the X value is not given")
+      end
+
+      it "raises an error if the Y position is not given" do
+        qrcode = described_class.new :position => [50, nil], :data => "foobar"
+        expect {
+          qrcode.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the Y value is not given")
+      end      
+
+      it "raises an error if the data to be printed was not informed" do
+        qrcode.data = nil
+        expect {
+          qrcode.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the data to be printed is not given")
+      end  
+      
+      it "raises an error if the scale factor is not given" do
+        valid_attributes.delete :scale_factor
+
+        expect {
+          qrcode.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the scale factor to be used is not given")
+      end
+
+      it "raises an error if the correction level is not given" do
+        valid_attributes.delete :correction_level
+
+        expect {
+          qrcode.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the error correction level to be used is not given")
+      end  
+
+      it "begins with the command 'b'" do
+        qrcode.to_zpl.should =~ /\Ab/
+      end 
+
+      it "contains the X position" do
+        tokens[0].match(/b(\d+)/)[1].should eq "50"
+      end
+
+      it "contains the Y position" do
+        tokens[1].should eq "50"
+      end
+
+      it "contains QR code type" do
+        tokens[2].should eq "Q"
+      end
+
+      it "contains the scale factor" do
+        tokens[3].should eq "s3"
+      end
+
+      it "contains the error correction level" do
+        tokens[4].should eq "eM"
+      end
+
+      it "contains the data to be printed in the qrcode" do
+        tokens[5].should eq "\"foobar\""
+      end
+  end
+end