zebra-zpl 1.0.0

data/lib/zebra/zpl/label.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module Zebra
+  module Zpl
+    class Label
+      class InvalidPrintSpeedError     < StandardError; end
+      class InvalidPrintDensityError   < StandardError; end
+      class PrintSpeedNotInformedError < StandardError; end
+
+      attr_writer :copies
+      attr_reader :elements, :tempfile
+      attr_accessor :width, :length, :gap, :print_speed, :print_density
+
+      def initialize(options = {})
+        options.each_pair { |key, value| self.__send__("#{key}=", value) if self.respond_to?("#{key}=") }
+        @elements = []
+      end
+
+      def length_and_gap=(length_and_gap)
+        self.length = length_and_gap[0]
+        self.gap    = length_and_gap[1]
+      end
+
+      def print_speed=(s)
+        raise InvalidPrintSpeedError unless (0..6).include?(s)
+        @print_speed = s
+      end
+
+      def print_density=(d)
+        raise InvalidPrintDensityError unless (0..6).include?(d)
+        @print_density = d
+      end
+
+      def copies
+        @copies || 1
+      end
+
+      def <<(element)
+        element.width = self.width
+        elements << element
+      end
+
+      def dump_contents(io = STDOUT)
+        check_required_configurations
+        # Start format
+        io << "^XA"
+        # ^LL<label height in dots>,<space between labels in dots>
+        # io << "^LL#{length},#{gap}\n" if length && gap
+        io << "^LL#{length}" if length
+        # ^LH<label home - x,y coordinates of top left label>
+        io << "^LH0,0"
+        # ^LS<shift the label to the left(or right)>
+        io << "^LS10"
+        # ^PW<label width in dots>
+        io << "^PW#{width}" if width
+        # Print Rate(speed) (^PR command)
+        io << "^PR#{print_speed}"
+        # Density (D command) "Carried over from EPL, does this exist in ZPL ????"
+        # io << "D#{print_density}\n" if print_density
+
+        # TEST ZPL (comment everything else out)...
+        # io << "^XA^WD*:*.FNT*^XZ"
+        # TEST ZPL SEGMENT
+        # io << "^WD*:*.FNT*"
+        # TEST AND GET CONFIGS
+        # io << "^HH"
+
+        elements.each do |element|
+          io << element.to_zpl
+        end
+        # Specify how many copies to print
+        io << "^PQ#{copies}"
+        # End format
+        io << "^XZ"
+      end
+
+      def persist
+        # debugger
+        tempfile = Tempfile.new "zebra_label"
+        dump_contents tempfile
+        tempfile.close
+        @tempfile = tempfile
+        tempfile
+      end
+
+      def persisted?
+        !!self.tempfile
+      end
+
+      private
+
+      def check_required_configurations
+        raise PrintSpeedNotInformedError unless print_speed
+      end
+    end
+  end
+end

data/lib/zebra/zpl/language.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+module Zebra
+  module Zpl
+    class Language
+      class InvalidLanguageError                    < StandardError; end
+      class InvalidLanguageForNumberOfDataBitsError < StandardError; end
+
+      # 8 bits languages
+      ENGLISH_US       = "0"
+      LATIN_1          = "1"
+      LATIN_2          = "2"
+      PORTUGUESE       = "3"
+      FRENCH_CANADIAN  = "4"
+      NORDIC           = "5"
+      TURKISH          = "6"
+      ICELANDIC        = "7"
+      HEBREW           = "8"
+      CYRILLIC         = "9"
+      CYRILLIC_CIS_1   = "10"
+      GREEK            = "11"
+      GREEK_1          = "12"
+      GREEK_2          = "13"
+      LATIN_1_WINDOWS  = "A"
+      LATIN_2_WINDOWS  = "B"
+      CYRILLIC_WINDOWS = "C"
+      GREEK_WINDOWS    = "D"
+      TURKISH_WINDOWS  = "E"
+      HEBREW_WINDOWS   = "F"
+
+      # 7 bits languages
+      USA              = "0"
+      BRITISH          = "1"
+      GERMAN           = "2"
+      FRENCH           = "3"
+      DANISH           = "4"
+      ITALIAN          = "5"
+      SPANISH          = "6"
+      SWEDISH          = "7"
+      SWISS            = "8"
+
+      def self.valid_language?(language)
+        ("0".."13").include?(language) || ("A".."F").include?(language)
+      end
+
+      def self.validate_language(language)
+        raise InvalidLanguageError unless valid_language?(language)
+      end
+
+      def self.validate_language_for_number_of_data_bits(language, number_of_data_bits)
+        if number_of_data_bits == 8
+          validate_8_data_bits_language language
+        elsif number_of_data_bits == 7
+          validate_7_data_bits_language language
+        else
+          raise ArgumentError.new("Unknown number of data bits")
+        end
+      end
+
+      private
+
+      def self.validate_8_data_bits_language(language)
+        raise InvalidLanguageForNumberOfDataBitsError unless [ENGLISH_US,
+        LATIN_1, LATIN_2, PORTUGUESE, FRENCH_CANADIAN, NORDIC,
+        TURKISH, ICELANDIC, HEBREW, CYRILLIC, CYRILLIC_CIS_1, GREEK,
+        GREEK_1, GREEK_2, LATIN_1_WINDOWS, LATIN_2_WINDOWS, CYRILLIC_WINDOWS,
+        GREEK_WINDOWS, TURKISH_WINDOWS, HEBREW_WINDOWS].include?(language)
+      end
+
+      def self.validate_7_data_bits_language(language)
+        raise InvalidLanguageForNumberOfDataBitsError unless [USA, BRITISH,
+        GERMAN, FRENCH, DANISH, ITALIAN, SPANISH, SWEDISH, SWISS].include?(language)
+      end
+    end
+  end
+end
+

data/lib/zebra/zpl/multipliers.rb

@@ -0,0 +1,42 @@
+module Zebra
+  module Zpl
+    module BaseMultiplier
+      class InvalidMultiplierError < StandardError; end
+
+      VALUE_1 = 1
+      VALUE_2 = 2
+      VALUE_3 = 3
+      VALUE_4 = 4
+      VALUE_5 = 5
+      VALUE_6 = 6
+      VALUE_7 = 7
+      VALUE_8 = 8
+
+      def self.included(base_module)
+        base_module.instance_eval do
+          def validate_multiplier(multiplier)
+            raise InvalidMultiplierError unless valid_multiplier?(multiplier)
+          end
+        end
+      end
+    end
+
+    module HorizontalMultiplier
+      include BaseMultiplier
+
+      def self.valid_multiplier?(multiplier)
+        (1..8).include? multiplier
+      end
+    end
+
+    module VerticalMultiplier
+      include BaseMultiplier
+
+      VALUE_9 = 9
+
+      def self.valid_multiplier?(multiplier)
+        (1..9).include? multiplier
+      end
+    end
+  end
+end

data/lib/zebra/zpl/print_mode.rb

@@ -0,0 +1,18 @@
+module Zebra
+  module Zpl
+    module PrintMode
+      class InvalidPrintModeError < StandardError; end
+
+      NORMAL  = "N"
+      REVERSE = "R"
+
+      def self.valid_mode?(mode)
+        %w(N R).include? mode
+      end
+
+      def self.validate_mode(mode)
+        raise InvalidPrintModeError unless valid_mode?(mode)
+      end
+    end
+  end
+end

data/lib/zebra/zpl/printable.rb

@@ -0,0 +1,58 @@
+module Zebra
+  module Zpl
+    module Printable
+      class MissingAttributeError < StandardError
+        def initialize(message)
+          super("Can't print if #{message}")
+        end
+      end
+
+      attr_reader :position, :x, :y, :margin
+      attr_accessor :data
+
+      def initialize(options = {})
+        options.each_pair { |attribute, value| self.__send__ "#{attribute}=", value }
+      end
+
+      def position=(coords)
+        @position = coords
+        @x = (@margin.nil? || @margin == 0) ? coords[0] : (@margin + coords[0])
+        @y = coords[1]
+      end
+
+      def justification=(just)
+        Justification.validate_justification just
+        @justification = just
+      end
+
+      def justification
+        @justification || Justification::LEFT
+      end
+
+      def margin=(margin)
+        @margin = margin || 0
+      end
+
+      def rotation=(rot)
+        Rotation.validate_rotation rot
+        @rotation = rot
+      end
+
+      def rotation
+        @rotation || Rotation::NO_ROTATION
+      end
+
+      private
+
+      def has_data?
+        true
+      end
+
+      def check_attributes
+        raise MissingAttributeError.new("the X value is not given") unless @x
+        raise MissingAttributeError.new("the Y value is not given") unless @y
+        raise MissingAttributeError.new("the data to be printed is not given") unless @data || !has_data?
+      end
+    end
+  end
+end

data/lib/zebra/zpl/qrcode.rb

@@ -0,0 +1,37 @@
+require "zebra/zpl/printable"
+
+module Zebra
+  module Zpl
+    class Qrcode
+      include Printable
+
+      class InvalidScaleFactorError < StandardError; end
+      class InvalidCorrectionLevelError < StandardError; end
+
+      attr_reader :scale_factor, :correction_level
+
+      def scale_factor=(value)
+        raise InvalidScaleFactorError unless (1..99).include?(value.to_i)
+        @scale_factor = value
+      end
+
+      def correction_level=(value)
+        raise InvalidCorrectionLevelError unless %w[L M Q H].include?(value.to_s)
+        @correction_level = value
+      end
+
+      def to_zpl
+        check_attributes
+        ["b#{x}", y, "Q", "s#{scale_factor}", "e#{correction_level}", "\"#{data}\""].join(",")
+      end
+
+      private
+
+      def check_attributes
+        super
+        raise MissingAttributeError.new("the scale factor to be used is not given") unless @scale_factor
+        raise MissingAttributeError.new("the error correction level to be used is not given") unless @correction_level
+      end
+    end
+  end
+end

data/lib/zebra/zpl/rotation.rb

@@ -0,0 +1,20 @@
+module Zebra
+  module Zpl
+    module Rotation
+      class InvalidRotationError < StandardError; end
+
+      NO_ROTATION = 'N'
+      DEGREES_90  = 'R'
+      DEGREES_180 = 'I'
+      DEGREES_270 = 'B'
+
+      def self.valid_rotation?(rotation)
+        [NO_ROTATION, DEGREES_90, DEGREES_180, DEGREES_270].include? rotation
+      end
+
+      def self.validate_rotation(rotation)
+        raise InvalidRotationError unless valid_rotation?(rotation)
+      end
+    end
+  end
+end

data/lib/zebra/zpl/text.rb

@@ -0,0 +1,80 @@
+require "zebra/zpl/printable"
+
+module Zebra
+  module Zpl
+    class Text
+      include Printable
+
+      attr_reader   :font_size, :font_type, :width
+
+      def font_size=(f)
+        FontSize.validate_font_size f
+        @font_size = f
+      end
+
+      def width=(width)
+        unless (margin.nil? || margin < 1)
+          @width = (width - (margin*2))
+        else
+          @width = width || 0
+        end
+      end
+
+      def font_type=(type)
+        FontType.validate_font_type type
+        @font_type = type
+      end
+
+      def font_type
+        @font_type || FontType::TYPE_0
+      end
+
+      def print_mode=(mode)
+        PrintMode.validate_mode mode
+        @print_mode = mode
+      end
+
+      def print_mode
+        @print_mode || PrintMode::NORMAL
+      end
+
+      def h_multiplier
+        @h_multiplier || HorizontalMultiplier::VALUE_1
+      end
+
+      def v_multiplier
+        @v_multiplier || VerticalMultiplier::VALUE_1
+      end
+
+      def print_mode
+        @print_mode || PrintMode::NORMAL
+      end
+
+      def h_multiplier=(multiplier)
+        HorizontalMultiplier.validate_multiplier multiplier
+        @h_multiplier = multiplier
+      end
+
+      def v_multiplier=(multiplier)
+        VerticalMultiplier.validate_multiplier multiplier
+        @v_multiplier = multiplier
+      end
+
+      def to_zpl
+        check_attributes
+        # ["A#{x}", y, rotation, font_size, h_multiplier, v_multiplier, print_mode, "\"#{data}\""].join(",")
+        # "^FO25,25^FB600,100,0,C,0^FDFoo^FS"
+
+        # "^CF#{font_type},#{font_size}^FO#{x},#{y}^FB609,4,0,#{justification},0^FD#{data}^FS"
+        "^FW#{rotation}^CF#{font_type},#{font_size}^CI28^FO#{x},#{y}^FB#{width},4,0,#{justification},0^FD#{data}^FS"
+      end
+
+      private
+
+      def check_attributes
+        super
+        raise MissingAttributeError.new("the font_size to be used is not given") unless @font_size
+      end
+    end
+  end
+end

data/lib/zebra/zpl/version.rb

@@ -0,0 +1,5 @@
+module Zebra
+  module Zpl
+    VERSION = "1.0.0"
+  end
+end

data/lib/zebra/zpl.rb

@@ -0,0 +1,18 @@
+require "cups"
+require "tempfile"
+require "zebra/zpl/version"
+require "zebra/zpl/language"
+require "zebra/zpl/country_code"
+require "zebra/zpl/character_set"
+require "zebra/zpl/rotation"
+require "zebra/zpl/multipliers"
+require "zebra/zpl/print_mode"
+require "zebra/zpl/font"
+require "zebra/zpl/box"
+require "zebra/zpl/label"
+require "zebra/zpl/text"
+require "zebra/zpl/barcode"
+require "zebra/zpl/barcode_type"
+require "zebra/print_job"
+require "zebra/zpl/qrcode"
+require "zebra/zpl/justification"

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require "zebra/zpl"
+
+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
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # 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'
+end

data/spec/zebra/print_job_spec.rb

@@ -0,0 +1,36 @@
+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)
+  end
+
+  describe "#print" do
+    let(:label) { stub :persist => tempfile }
+    let(:cups_job) { stub :print => true }
+    let(:tempfile) { stub(:path => "/foo/bar").as_null_object }
+
+    subject(:print_job) { described_class.new "Zebra" }
+
+    before { print_job.stub(:` => true) }
+
+    it "creates a cups print job with the correct arguments" do
+      print_job.print label
+    end
+
+    it "prints the label" do
+      print_job.should_receive(:`).with("lpr -P Zebra -o raw /foo/bar")
+      print_job.print label
+    end
+  end
+end