zebra-zpl 1.0.5 → 1.1.0

data/lib/zebra/zpl/version.rb

@@ -1,5 +1,5 @@
 module Zebra
   module Zpl
-    VERSION = "1.0.5"
+    VERSION = "1.1.0"
   end
 end

data/spec/spec_helper.rb

@@ -6,9 +6,13 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
 require "zebra/zpl"
+require 'byebug'
+require 'pry'
+require 'pry-nav'
+
+ENV['RUBY_ENV'] = 'test'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
@@ -16,5 +20,5 @@ RSpec.configure do |config|
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
-  config.order = 'random'
+  # config.order = 'random'
 end

data/spec/zebra/print_job_spec.rb

@@ -1,36 +1,31 @@
 require 'spec_helper'
 
 describe Zebra::PrintJob do
-  before do
-    Cups.stub(:show_destinations).and_return(["Zebra", "Foobar"])
-  end
-
   it "receives the name of a printer" do
-    described_class.new("Zebra").printer.should == "Zebra"
-  end
-
-  it "raises an error if the printer does not exists" do
-    expect {
-      described_class.new("Wrong")
-    }.to raise_error(Zebra::PrintJob::UnknownPrinter)
+    expect(described_class.new("Zebra").printer).to eq 'Zebra'
   end
 
   describe "#print" do
-    let(:label) { stub :persist => tempfile }
-    let(:cups_job) { stub :print => true }
-    let(:tempfile) { stub(:path => "/foo/bar").as_null_object }
+    let(:label) { Zebra::Zpl::Label.new(print_speed: 2) }
+    let(:zpl_string) { '^XA^FO50,50^FDHello, Zebra^FS^XZ' }
+    let(:ip) { '127.0.0.1' }
 
     subject(:print_job) { described_class.new "Zebra" }
 
-    before { print_job.stub(:` => true) }
+    before { allow(print_job).to receive(:`) { true } }
 
     it "creates a cups print job with the correct arguments" do
-      print_job.print label
+      print_job.print label, ip
     end
 
     it "prints the label" do
-      print_job.should_receive(:`).with("lpr -P Zebra -o raw /foo/bar")
-      print_job.print label
+      expect(print_job).to receive(:system).with(/r?lpr? -(h|H) 127.0.0.1 -(d|P) Zebra.*/).at_least(:once)
+      print_job.print label, ip
+    end
+
+    it "can print from a ZPL string" do
+      expect(print_job).to receive(:system).with(/r?lpr? -(h|H) 127.0.0.1 -(d|P) Zebra.*/).at_least(:once)
+      print_job.print zpl_string, ip
     end
   end
 end

data/spec/zebra/zpl/barcode_spec.rb

@@ -2,48 +2,58 @@ 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
+    barcode = described_class.new position: [20, 40]
+    expect(barcode.position).to eq [20,40]
+    expect(barcode.x).to eq 20
+    expect(barcode.y).to eq 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
+    barcode = described_class.new rotation: rotation
+    expect(barcode.rotation).to eq 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
+    barcode = described_class.new rotation: rotation
+    expect(barcode.rotation).to eq 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
+    type = Zebra::Zpl::BarcodeType::CODE_128_AUTO
+    barcode = described_class.new type: type
+    expect(barcode.type).to eq 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
+  it "can be initialized with the barcode width" do
+    barcode = described_class.new width: 5
+    expect(barcode.width).to eq 5
   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
+  it "can be initialized with the barcode height" do
+    barcode = described_class.new height: 20
+    expect(barcode.height).to eq 20
   end
 
-  it "can be initialized with the barcode height" do
-    barcode = described_class.new :height => 20
-    barcode.height.should == 20
+  it "can be initialized with the ratio" do
+    barcode = described_class.new ratio: 3.0
+    expect(barcode.ratio).to eq 3.0
+  end
+
+  it "can be initialized with the narrow bar width" do
+    barcode = described_class.new narrow_bar_width: 3
+    expect(barcode.narrow_bar_width).to eq 3
+  end
+
+  it "can be initialized with the wide bar width" do
+    barcode = described_class.new wide_bar_width: 10
+    expect(barcode.wide_bar_width).to eq 10
   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
+    barcode = described_class.new print_human_readable_code: true
+    expect(barcode.print_human_readable_code).to eq true
   end
 
   describe "#rotation=" do
@@ -65,7 +75,7 @@ describe Zebra::Zpl::Barcode do
   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
+        described_class.new type: Zebra::Zpl::BarcodeType::CODE_128_AUTO, narrow_bar_width: 20
       }.to raise_error(Zebra::Zpl::Barcode::InvalidNarrowBarWidthError)
     end
   end
@@ -73,45 +83,46 @@ describe Zebra::Zpl::Barcode do
   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
+        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
+      expect(described_class.new.print_human_readable_code).to eq 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"
+      position:         [100, 150],
+      type:             Zebra::Zpl::BarcodeType::CODE_128_AUTO,
+      height:           20,
+      width:            5,
+      narrow_bar_width: 3,
+      wide_bar_width:   6,
+      data:             "foobar"
     } }
     let(:barcode) { described_class.new valid_attributes }
-    let(:tokens) { barcode.to_zpl.split(",") }
+    let(:tokens) { barcode.to_zpl.split(/(\^[A-Z]+|\,)/).reject{ |e| ['', ',', nil].include?(e) } }
 
     it "raises an error if the X position was not informed" do
-      barcode = described_class.new :position => [nil, 100], :data => "foobar"
+      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]
+      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"
+      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")
@@ -131,66 +142,62 @@ describe Zebra::Zpl::Barcode do
       }.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
+    it "raises an error if the neither of with, narrow_bar_width, or wide_bar_width are not given" do
+      valid_attributes.delete :width
       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")
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the width to be used is not given")
     end
 
     it "begins with the command 'B'" do
-      barcode.to_zpl.should =~ /\AB/
+      expect(tokens[4]).to eq '^BY'
     end
 
     it "contains the X position" do
-      tokens[0].match(/B(\d+)/)[1].should == "100"
+      expect(tokens[2]).to eq '100'
     end
 
     it "contains the Y position" do
-      tokens[1].should == "150"
+      expect(tokens[3]).to eq '150'
     end
 
-    it "contains the barcode rotation" do
-      tokens[2].should == Zebra::Zpl::Rotation::NO_ROTATION.to_s
+    it "contains the width" do
+      expect(tokens[5]).to eq '5'
     end
 
-    it "contains the barcode type" do
-      tokens[3].should == Zebra::Zpl::BarcodeType::CODE_128_AUTO
+    it "contains the ratio" do
+      expect(tokens[6]).to eq '2.0'
     end
 
-    it "contains the barcode narrow bar width" do
-      tokens[4].should == "4"
+    it "contains the barcode height" do
+      expect(tokens[7]).to eq '20'
     end
 
-    it "contains the barcode wide bar width" do
-      tokens[5].should == "6"
+    it "contains the barcode type" do
+      expect(tokens[8]).to start_with "^B#{Zebra::Zpl::BarcodeType::CODE_128_AUTO}"
     end
 
-    it "contains the barcode height" do
-      tokens[6].should == "20"
+    it "contains the barcode rotation" do
+      expect(tokens[0]).to start_with '^FW'
+      expect(tokens[0]).to end_with Zebra::Zpl::Rotation::NO_ROTATION.to_s
+      expect(tokens[8]).to start_with '^B'
+      expect(tokens[8]).to end_with Zebra::Zpl::Rotation::NO_ROTATION.to_s
     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"
+      valid_attributes.merge! print_human_readable_code: true
+      expect(tokens[9]).to eq 'Y'
     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"
+      valid_attributes.merge! print_human_readable_code: false
+      expect(tokens[9]).to eq 'N'
     end
 
     it "contains the data to be printed in the barcode" do
-      tokens[8].should == "\"foobar\""
+      expect(tokens[11]).to eq 'foobar'
     end
   end
 end

data/spec/zebra/zpl/box_spec.rb

@@ -3,69 +3,65 @@ 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
+    box = described_class.new position: [20, 40]
+    expect(box.position).to eq [20, 40]
+    expect(box.x).to eq 20
+    expect(box.y).to eq 40
   end
 
   it "can be initialized with the line thckness " do
-    box = described_class.new :line_thickness => 3
-    box.line_thickness.should == 3
+    box = described_class.new line_thickness: 3
+    expect(box.line_thickness).to eq 3
   end
 
   describe "#to_zpl" do
-    subject(:box)    { described_class.new attributes }
-    let(:attributes) { { :position => [20,40], :end_position => [60, 100], :line_thickness => 3 }  }
+    subject(:box) { described_class.new attributes }
+    let(:attributes) {{
+      position: [20,40],
+      line_thickness: 3,
+      box_width: 5,
+      box_height: 4,
+      color: 'B',
+      rounding_degree: 6
+    }}
 
     it "raises an error if the X position was not informed" do
-      box = described_class.new attributes.merge :position => [nil, 40]
+      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]
+      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]
+    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 horizontal end position (X) is not given")
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the line thickness 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]
+    it "raises an error if the box width was not informed" do
+      box = described_class.new attributes.merge box_width: nil
       expect {
         box.to_zpl
-      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the vertical end position (Y) is not given")
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the box_width 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
+    it "raises an error if the box height was not informed" do
+      box = described_class.new attributes.merge box_height: 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/
+      }.to raise_error(Zebra::Zpl::Printable::MissingAttributeError, "Can't print if the box_height is not given")
     end
 
     it "contains the attributes in correct order" do
-      box.to_zpl.should == "X20,40,3,60,100"
+      expect(box.to_zpl).to eq '^FO20,40^GB5,4,3,B,6^FS'
     end
   end
 end

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