zebra-zpl 1.0.2 → 1.1.3

data/spec/zebra/zpl/character_set_spec.rb

@@ -3,7 +3,7 @@ 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
+    expect(character_set.number_of_data_bits).to eq 8
   end
 
   it "raises an error when receiving an invalid number of data bits" do
@@ -14,7 +14,7 @@ describe Zebra::Zpl::CharacterSet do
 
   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
+    expect(character_set.language).to eq Zebra::Zpl::Language::PORTUGUESE
   end
 
   it "raises an error with an invalid language" do
@@ -25,7 +25,7 @@ describe Zebra::Zpl::CharacterSet do
 
   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
+    expect(character_set.country_code).to eq Zebra::Zpl::CountryCode::LATIN_AMERICA
   end
 
   it "raises an error with an invalid country code" do
@@ -82,19 +82,19 @@ describe Zebra::Zpl::CharacterSet do
     end
 
     it "begins with the command 'I'" do
-      character_set.to_zpl.should =~ /\AI/
+      expect(character_set.to_zpl).to match /\AI/
     end
 
     it "contains the number of data bits" do
-      tokens[0].match(/I(\d)/)[1].should == "8"
+      expect(tokens[0].match(/I(\d)/)[1]).to eq "8"
     end
 
     it "contains the language" do
-      tokens[1].should == Zebra::Zpl::Language::PORTUGUESE
+      expect(tokens[1]).to eq Zebra::Zpl::Language::PORTUGUESE
     end
 
     it "contains the country code" do
-      tokens[2].should == Zebra::Zpl::CountryCode::LATIN_AMERICA
+      expect(tokens[2]).to eq Zebra::Zpl::CountryCode::LATIN_AMERICA
     end
   end
 end

data/spec/zebra/zpl/comment_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::Comment do
+  it "can be initialized with the data" do
+    comment = described_class.new data: "THIS IS A COMMENT"
+    expect(comment.data).to eq "THIS IS A COMMENT"
+  end
+
+  describe "#to_zpl" do
+    subject(:comment) { described_class.new attributes }
+    let(:attributes) {{
+      data:  "THIS IS A COMMENT",
+    }}
+    it "contains the comment" do
+        expect(comment.to_zpl).to eq "^FXTHIS IS A COMMENT^FS"
+    end
+  end
+end

data/spec/zebra/zpl/datamatrix_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::Datamatrix do
+    it "can be initialized with the symbol height" do
+      datamatrix = described_class.new symbol_height: 3
+      expect(datamatrix.symbol_height).to eq 3
+    end
+
+    it "can be initialized with a quality level" do
+      datamatrix = described_class.new quality: 140
+      expect(datamatrix.quality).to eq 140
+    end
+
+    it "can be initialized with a number of columns" do
+      datamatrix = described_class.new columns: 33
+      expect(datamatrix.columns).to eq 33
+    end
+
+    it "can be initialized with a number of rows" do
+      datamatrix = described_class.new rows: 42
+      expect(datamatrix.rows).to eq 42
+    end
+
+    it "can be initialized with a format" do
+      datamatrix = described_class.new format: 2
+      expect(datamatrix.format).to eq 2
+    end
+    it "can be initialized with a aspect ratio" do
+      datamatrix = described_class.new aspect_ratio: 2
+      expect(datamatrix.aspect_ratio).to eq 2
+    end
+
+    describe "#orientation" do
+      it "raises an error if the orientation not in [N I R B]" do
+        expect { described_class.new orientation: 'A' }.to raise_error(Zebra::Zpl::Datamatrix::InvalidOrientationError)
+      end
+    end
+
+    describe "#quality" do
+      it "raises an error if the quality is not one of 0, 50, 80, 100, 140, 200" do
+        expect { described_class.new quality: 20 }.to raise_error(Zebra::Zpl::Datamatrix::InvalidQualityFactorError)
+      end
+    end
+
+    describe "#columns" do
+      it "raises an error if the number of columns is out of bounds" do
+        expect { described_class.new columns: 0 }.to raise_error(Zebra::Zpl::Datamatrix::InvalidSizeError)
+      end
+    end
+
+    describe "#rows" do
+      it "raises an error if the number of rows is out of bounds" do
+        expect { described_class.new rows: 59 }.to raise_error(Zebra::Zpl::Datamatrix::InvalidSizeError)
+      end
+    end
+
+
+    describe "#to_zpl" do
+      let(:valid_attributes) { {
+        position:         [50, 50],
+        symbol_height:     5,
+        data:             "foobar"
+      }}
+      let(:datamatrix) { described_class.new valid_attributes }
+      let(:tokens) { datamatrix.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+
+      it "raises an error if the X position is not given" do
+        datamatrix = described_class.new position: [nil, 50], data: "foobar"
+        expect {
+          datamatrix.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
+        datamatrix = described_class.new position: [50, nil], data: "foobar"
+        expect {
+          datamatrix.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
+        datamatrix.data = nil
+        expect {
+          datamatrix.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 :symbol_height
+
+        expect {
+          datamatrix.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the symbol height to be used is not given")
+      end
+
+      it "contains the barcode command '^B'" do
+        expect(datamatrix.to_zpl).to match /\^B/
+      end
+
+      it "contains the X position" do
+        expect(tokens[2]).to eq "50"
+      end
+
+      it "contains the Y position" do
+        expect(tokens[3]).to eq "50"
+      end
+
+      it "contains Data Matrix code type" do
+        expect(tokens[6]).to eq "^BXN"
+      end
+
+      it "contains the symbol_height" do
+        expect(tokens[7]).to eq "5"
+      end
+
+      it "contains the quality level" do
+        expect(tokens[8]).to eq "200"
+      end
+
+      it "contains the data to be printed in the datamatrix" do
+        expect(tokens[10]).to eq "foobar"
+      end
+  end
+end

data/spec/zebra/zpl/graphics_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::Graphic do
+    it "can be initialized with graphic type" do
+      graphic = described_class.new graphic_type: Zebra::Zpl::Graphic::ELLIPSE
+      expect(graphic.graphic_type).to eq "E"
+    end
+
+    it "can be initialized with a graphic width" do
+      graphic = described_class.new graphic_width: 30
+      expect(graphic.graphic_width).to eq 30
+    end
+
+    it "can be initialized with a graphic height" do
+        graphic = described_class.new graphic_height: 30
+        expect(graphic.graphic_height).to eq 30
+    end
+
+    it "can be initialized with a line_thickness" do
+        graphic = described_class.new line_thickness: 3
+        expect(graphic.line_thickness).to eq 3
+    end
+
+    it "can be initialized with a color" do
+        graphic = described_class.new color: "W"
+        expect(graphic.color).to eq "W"
+    end
+
+    it "can be initialized with an orientation" do
+        graphic = described_class.new orientation: "R"
+        expect(graphic.orientation).to eq "R"
+    end
+
+    it "can be initialized with a rounding degree" do
+        graphic = described_class.new rounding_degree: 2
+        expect(graphic.rounding_degree).to eq 2
+    end
+
+
+
+    describe "#orientation" do
+      it "raises an error if the orientation not in [N L]" do
+        expect { described_class.new orientation: 'A' }.to raise_error(Zebra::Zpl::Graphic::InvalidOrientationError)
+      end
+    end
+
+    describe "#color" do
+      it "raises an error if the color not in [B W]" do
+        expect { described_class.new color: 'A' }.to raise_error(Zebra::Zpl::Graphic::InvalidColorError)
+      end
+    end
+
+    describe "#line_thickness" do
+      it "raises an error if line thickness is not a number" do
+        expect { described_class.new line_thickness: 'A' }.to raise_error(Zebra::Zpl::Graphic::InvalidLineThickness)
+      end
+    end
+
+    describe "#graphic_type" do
+      it "raises an error if the graphic type not in [E B D C S]" do
+        expect { described_class.new graphic_type: 'A' }.to raise_error(Zebra::Zpl::Graphic::InvalidGraphicType)
+      end
+    end
+
+    describe "#to_zpl" do
+      let(:valid_attributes) { {
+        position:         [50, 50],
+        graphic_width:    200,
+        graphic_height:   300,
+        line_thickness:   2,
+        color:            "B",
+        orientation:      "L",
+        rounding_degree:  3,
+        symbol_type:      "C"
+      }}
+      let(:graphic_ellipse) { described_class.new valid_attributes.merge({graphic_type: Zebra::Zpl::Graphic::ELLIPSE}) }
+      let(:graphic_diagonal) { described_class.new valid_attributes.merge({graphic_type: Zebra::Zpl::Graphic::DIAGONAL})}
+      let(:graphic_box) { described_class.new valid_attributes.merge({graphic_type: Zebra::Zpl::Graphic::BOX}) }
+      let(:graphic_symbol) { described_class.new valid_attributes.merge({graphic_type: Zebra::Zpl::Graphic::SYMBOL}) }
+      let(:graphic_circle) { described_class.new valid_attributes.merge({graphic_type: Zebra::Zpl::Graphic::CIRCLE}) }
+
+      let(:tokens_ellipse) { graphic_ellipse.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+      let(:tokens_diagonal) { graphic_diagonal.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+      let(:tokens_box) { graphic_box.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+      let(:tokens_symbol) { graphic_symbol.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+      let(:tokens_circle) { graphic_circle.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+
+      it "raises an error if the X position is not given" do
+        graphic = described_class.new position: [nil, 50], graphic_type: described_class::ELLIPSE
+        expect {
+          graphic.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
+        graphic = described_class.new position: [50, nil], graphic_type: described_class::ELLIPSE
+        expect {
+          graphic.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 Graphic Type is not given" do
+        graphic = described_class.new position: [50, 50]
+        expect {
+          graphic.to_zpl
+        }.to raise_error(Zebra::Zpl::Graphic::InvalidGraphicType)
+      end
+
+      it "contains the X position" do
+        expect(tokens_ellipse[2]).to eq "50"
+      end
+
+      it "contains the Y position" do
+        expect(tokens_ellipse[3]).to eq "50"
+      end
+
+      #Elipse Attributes
+
+      it "ellipse contains the ellipse graphic command '^GE'" do
+        expect(tokens_ellipse[4]).to eq "^GE"
+      end
+
+      it "ellipse contains the graphic width" do
+        expect(tokens_ellipse[5]).to eq "200"
+      end
+
+      it "ellipse contains the graphic height" do
+        expect(tokens_ellipse[6]).to eq "300"
+      end
+
+      it "ellipse contains the line thickness" do
+        expect(tokens_ellipse[7]).to eq "2"
+      end
+
+      it "ellipse contains the color" do
+        expect(tokens_ellipse[8]).to eq "B"
+      end
+
+      #Box Attributes
+
+      it "box contains the box graphic command '^GB'" do
+        expect(tokens_box[4]).to eq "^GB"
+      end
+
+      it "box contains the graphic width" do
+        expect(tokens_box[5]).to eq "200"
+      end
+
+      it "box contains the graphic height" do
+        expect(tokens_box[6]).to eq "300"
+      end
+
+      it "box contains the line thickness" do
+        expect(tokens_box[7]).to eq "2"
+      end
+
+      it "box contains the color" do
+        expect(tokens_box[8]).to eq "B"
+      end
+
+      it "box contains the rounding degree" do
+        expect(tokens_box[9]).to eq "3"
+      end
+
+      #Circle Attributes
+
+      it "circle contains the circle graphic command '^GC'" do
+        expect(tokens_circle[4]).to eq "^GC"
+      end
+
+      it "circle contains the graphic width" do
+        expect(tokens_circle[5]).to eq "200"
+      end
+
+      it "circle contains the line thickness" do
+        expect(tokens_circle[6]).to eq "2"
+      end
+
+      it "circle contains the color" do
+        expect(tokens_circle[7]).to eq "B"
+      end
+
+      #Diagonal Attributes
+
+      it "diagonal contains the diagonal graphic command '^GD'" do
+        expect(tokens_diagonal[4]).to eq "^GD"
+      end
+
+      it "diagonal contains the graphic width" do
+        expect(tokens_diagonal[5]).to eq "200"
+      end
+
+      it "diagonal contains the graphic width" do
+        expect(tokens_diagonal[6]).to eq "300"
+      end
+
+      it "diagonal contains the line thickness" do
+        expect(tokens_diagonal[7]).to eq "2"
+      end
+
+      it "diagonal contains the color" do
+        expect(tokens_diagonal[8]).to eq "B"
+      end
+
+      it "diagonal contains the orientation" do
+        expect(tokens_diagonal[9]).to eq "L"
+      end
+
+    #Symbol Attributes
+
+      it "symbol contains the symbol graphic command '^GS'" do
+        expect(tokens_symbol[4][0..2]).to eq "^GS"
+      end
+
+      it "symbol contains the graphic height" do
+        expect(tokens_symbol[5]).to eq "300"
+      end
+
+      it "symbol contains the graphic width" do
+        expect(tokens_symbol[6]).to eq "200"
+      end
+
+      it "symbol contains the symbol type" do
+        expect(tokens_symbol[7]).to eq "^FDC"
+      end
+    end
+end

data/spec/zebra/zpl/image_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Zebra::Zpl::Image do
+
+  it 'can be initialized with a path' do
+    img = described_class.new path: 'spec/fixtures/default.jpg'
+    expect(img.path).to match /^(.+)\/([^\/]+)$/
+  end
+
+  it 'can be initialized with dimensions (width & height)' do
+    img = described_class.new width: 800, height: 600
+    expect(img.width).to eq 800
+    expect(img.height).to eq 600
+  end
+
+  it 'can be initialized with a rotation amount' do
+    img = described_class.new rotation: 90
+    expect(img.rotation).to eq 90
+  end
+
+  it 'can be initialized with a black threshold' do
+    img = described_class.new black_threshold: 0.25
+    expect(img.black_threshold).to eq 0.25
+  end
+
+  it 'can be initialized with the invert flag' do
+    img = described_class.new invert: true
+    expect(img.invert).to eq true
+  end
+
+  it 'can be initialized with the compress flag' do
+    img = described_class.new compress: true
+    expect(img.compress).to eq true
+  end
+
+  describe '#width' do
+    it 'raises an error if an invalid width is given' do
+      expect { described_class.new width: -10 }.to raise_error(Zebra::Zpl::Image::InvalidSizeError)
+      expect { described_class.new width: 'abc' }.to raise_error(Zebra::Zpl::Image::InvalidSizeError)
+    end
+  end
+
+  describe '#height' do
+    it 'raises an error if an invalid height is given' do
+      expect { described_class.new height: -10 }.to raise_error(Zebra::Zpl::Image::InvalidSizeError)
+      expect { described_class.new height: 'abc' }.to raise_error(Zebra::Zpl::Image::InvalidSizeError)
+    end
+  end
+
+  describe '#rotation' do
+    it 'raises an error if an invalid rotation value is given' do
+      expect { described_class.new rotation: '90d' }.to raise_error(Zebra::Zpl::Image::InvalidRotationError)
+      expect { described_class.new rotation: 'abc' }.to raise_error(Zebra::Zpl::Image::InvalidRotationError)
+    end
+  end
+
+  describe '#black_threshold' do
+    it 'raises an error if an invalid black threshold is given' do
+      expect { described_class.new black_threshold: -5 }.to raise_error(Zebra::Zpl::Image::InvalidThresholdError)
+      expect { described_class.new black_threshold: 1.1 }.to raise_error(Zebra::Zpl::Image::InvalidThresholdError)
+    end
+  end
+
+  context "instance methods" do
+    let(:valid_attributes) { {
+      path:       'spec/fixtures/default.jpg',
+      position:   [50, 50],
+      width:      100,
+      height:     150
+    }}
+    let(:image) { described_class.new valid_attributes }
+
+    describe '#source' do
+      it 'returns an Img2Zpl::Image object' do
+        expect(image.source.class).to eq Img2Zpl::Image
+      end
+
+      it 'responds to ImageMagick (MiniMagick::Image) commands' do
+        attr = valid_attributes
+        attr.delete(:width)
+        attr.delete(:height)
+        img = described_class.new attr
+        src = img.src
+        expect(src.respond_to?(:resize)).to be true
+        expect(src.respond_to?(:trim)).to be true
+        expect(src.respond_to?(:crop)).to be true
+        expect(src.respond_to?(:flatten)).to be true
+        expect(src.respond_to?(:rotate)).to be true
+      end
+
+      it 'properly manipulates the image with ImageMagick (MiniMagick::Image) commands' do
+        attr = valid_attributes
+        attr.delete(:width)
+        attr.delete(:height)
+        img = described_class.new attr
+
+        img.source.resize '123x'
+        expect(img.width).to eq 123
+        img.source.resize 'x321'
+        expect(img.height).to eq 321
+      end
+    end
+
+    describe '#to_zpl' do
+      let(:tokens) { image.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
+
+      it 'raises an error if the X position is not given' do
+        qrcode = described_class.new position: [nil, 50]
+        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]
+        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 path is not given' do
+        valid_attributes.delete :path
+
+        expect {
+          image.to_zpl
+        }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the path is invalid or not given")
+      end
+
+      it "contains the Graphics Field command '^GF'" do
+        expect(image.to_zpl).to match /\^GF/
+      end
+
+      it 'contains the X position' do
+        expect(tokens[1]).to eq '50'
+      end
+
+      it 'contains the Y position' do
+        expect(tokens[2]).to eq '50'
+      end
+
+      it 'contains the properly encoded image' do
+        expect(tokens[3..-1].join).to eq '^GFA1079107913:::::K078Q03J07FF8P038I01JFP078I03JF8O0FCI0KFCO0FC001KFEN01FE003LFN01FE003LF8M03FF007LFCM03FF8007LFCM07FF800MFCM0IFC00MFEM0IFC00MFEL01IFE01MFEL01IFE01MFEL03JF01NFL07JF8:01NFL0KFC:01MFEK01KFE00MFEK01LF00MFEK03LF00MFEK07LF8007LFCK07LF8007LFCK0MFC003LF8K0MFC003LFK01MFE001KFEK01NFI0KFCK03NFI07JF8K07NF8I01JFL04N08J07FFCK0FC::::::N01MFE:::::::::::::::::::::::::::::::::::^FS'
+      end
+    end
+  end
+end