zpl-transformer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aacd8a6370c188d59d840059ab0640844b1ce490
+  data.tar.gz: ba144f793ed25e8620f769ab9bf1d80e6f8bec78
+SHA512:
+  metadata.gz: 753c6b8a358b0224d36ad0e53a6c8aa3b8771e5aba7898c4d7d5189206e32f8b0b2876176573c47ef6d64c5c583121ed2bba4fdaf5cbd4be8cb8825699417e81
+  data.tar.gz: 33b9326769e0b0f182333661ead968e1b058695c494a5f88c5cedd413eb202768fb265c4c8880ad97b757412a0f336d6f8e7f7d71a1aca78654e9ce6fd8f93c8

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.17.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in zpl-transformer.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    zpl-transformer (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  zpl-transformer!
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Benoit de Chezelles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# ZplTransformer
+
+## Why
+
+Our Zebra printer has a 300dpi resolution, and can only handle ZPL that is to be printed by a 300dpi printer.
+
+Some shipping API are not configurable enough, and can return ZPL code that is to be printed by a 203dpi printer.
+
+We needed a way to scale a ZPL code from 203dpi to 300dpi.
+
+
+## How it works
+
+It works by parsing the ZPL commands and transform them through one or more transformers.
+
+The ZPL command parser reads commands one by one, ignoring newlines and comments between each command.
+NOTE: the parser assumes the control char to be `^`, it doesn't support the command `^CC` to change the control char.
+
+A transformer is a class inheriting from `Zpl::Transformer::Base` and implementing the method `map_cmd(cmd)`
+
+TODO explain how a transformer is applied? & how to implem' a Transformer (takes a Zpl::Command, and should return a Zpl::Command, can return nil to delete a cmd)
+
+
+## Available transformers
+
+### `Zpl::Transformer::GenericScaler`
+
+This transformer can scale to a given ratio, specific arguments of a set of commands.
+
+Example:
+
+```rb
+code = '^XA^GB12,30,2,B^XZ',
+scaler = Zpl::Transformer::GenericScaler.new(1.2) # ratio: 1.2
+puts scaler.apply(code) # => "^XA^GB14,36,2,B^XZ"
+```
+
+List of commands that can be scaled currently:
+
+- `^MN` - Media Tracking
+- `^BY` - Bar Code Field Default
+- `^FO` - Field Origin
+- `^B2` - Interleaved 2 of 5 Bar Code
+- `^GB` - Graphic Box
+- `^BC` - Code 128 Bar Code (Subsets A, B, and C)
+
+These commands have at least one argument that is a coordinate (in dots) and need to be recalculated (scaled).
+The non-coordinate arguments and all other commands not listed above are not touched and left as is.
+
+This transformer only scales a few ZPL commands we needed, feel free to send a PR to add support for a ZPL command you need to be scaled.
+
+Note: images that are embedded in the ZPL code are not supported.
+
+
+### `Zpl::Transformer::FontScaler`
+
+This transformer can scale font commands (`^A` and `^CF`) to a given ratio.
+
+The ZPL2 specification has two kind of fonts available: scalable and bitmap.
+- The scalable fonts don't have a fixed size, they can be easily scaled.
+- The bitmap fonts have a fixed base size (e.g: font `A` base `height`/`width` is `9`/`5` dots). They can only be scaled to a multiple of their font's base height/width.
+  This transformer implements a special algorithm to try to scale bitmap fonts more precisely, but keep in mind that it is inaccurate compared to a scalable font.
+
+#### What's so special about bitmap fonts
+
+Given the font command `^ACR,9,9`, this will set the font `C` only for the next `^FD` field, with a field orientation `R` (rotated 90°) and a size of `9x9` dots for height and width.
+However the resulting font size will not be `9x9` dots as the base size of font `C` is `18x10`. The resulting size will be `18x10` since it must be a multiple of the base size of the font.
+Similarly, if the input size is `20x15` the resulting size would be `36x20`.
+
+#### Scaling algorithm for bitmap fonts
+
+1. Normalize the given font height to the font's base height (e.g: size `20` becomes `36`).
+2. Find smallest font that can be the same size as the given font (e.g: font `A`'s base size is half of font `C`'s base size: `9x5` vs `18x10`). A smaller font means more result granularity when scaling.
+3. Scale the normalized given height to the given ratio.
+4. Compute the scaled width from the scaled height based on proportion of new font's base size.
+5. Normalize again the scaled sizes to the new font's base sizes.
+
+
+### `Zpl::Transformer::Pipeline`
+
+This transformer allows composition of other transformers. It doesn't do anything on its own and allows you to apply multiple transformers in a row. Each transformer's output cmd is given as the input cmd of the next transformer unless the output is `nil`, in which case the cmd is skipped and following transformers are not called.
+
+Example: This will double the scale of `code`, by first applying the **generic scaler** then the **font scaler**.
+```rb
+code = '^XA^GB12,30,2,B^AA,9,5^XZ',
+pipeline = Zpl::Transformer::Pipeline.new([
+  Zpl::Transformer::GenericScaler.new(2.0),
+  Zpl::Transformer::FontScaler.new(2.0),
+])
+pipeline.apply(code) # => "^XA^GB24,60,2,B^AA,18,10^XZ"
+```
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zpl-transformer'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install zpl-transformer
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cheerz/zpl-transformer.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zpl/scaler"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/zpl-transformer/command.rb

@@ -0,0 +1,19 @@
+module Zpl
+
+  # Data class that holds the name & params of a ZPL command.
+  class Command
+    attr_accessor :name
+    attr_accessor :params
+
+    def initialize(name, params = [])
+      @name = name
+      @params = params
+    end
+
+    # Converts the command to a ZPL string.
+    def to_zpl_string
+      "^#{ @name }#{ @params.join(',') }"
+    end
+  end
+
+end

data/lib/zpl-transformer/font.rb

@@ -0,0 +1,98 @@
+module Zpl
+
+  class Font
+
+    attr_accessor :name, :base_height, :base_width, :type
+
+    def initialize(name:, base_height:, base_width:, type:, scalable: false)
+      @name = name
+      @base_height = base_height
+      @base_width = base_width
+      @type = type
+      @scalable = scalable
+    end
+
+    def base_size
+      [@base_height, @base_width]
+    end
+
+    def scalable?
+      @scalable
+    end
+
+    # Font matrix
+    #
+    # FONT    HxW (dots)         TYPE
+    #
+    ## Bitmap fonts
+    # A       9 X 5              U-L-D
+    # B       11 X 7             U
+    # C, D    18 X 10            U-L-D
+    # E       42 x 20            OCR-B
+    # F       26 x 13            U-L-D
+    # G       60 x 40            U-L-D
+    # H       34 x 22            OCR-A
+    # P       20 x 18            U-L-D
+    # Q       28 x 24            U-L-D
+    # R       35 x 31            U-L-D
+    # S       40 x 35            U-L-D
+    # T       48 x 42            U-L-D
+    # U       59 x 53            U-L-D
+    # V       80 x 71            U-L-D
+    #
+    ## Scalable font
+    # 0       Default: 15 x 12   U-L-D
+
+    AVAILABLE_FONTS = {
+      "A" => Font.new(name: "A", base_height: 9, base_width: 5, type: :u_l_d),
+      "B" => Font.new(name: "B", base_height: 11, base_width: 7, type: :u),
+      "C" => Font.new(name: "C", base_height: 18, base_width: 10, type: :u_l_d),
+      "D" => Font.new(name: "D", base_height: 18, base_width: 10, type: :u_l_d),
+      "E" => Font.new(name: "E", base_height: 42, base_width: 20, type: :ocr_b),
+      "F" => Font.new(name: "F", base_height: 26, base_width: 13, type: :u_l_d),
+      "G" => Font.new(name: "G", base_height: 60, base_width: 40, type: :u_l_d),
+      "H" => Font.new(name: "H", base_height: 34, base_width: 22, type: :ocr_a),
+      "P" => Font.new(name: "P", base_height: 20, base_width: 18, type: :u_l_d),
+      "Q" => Font.new(name: "Q", base_height: 28, base_width: 24, type: :u_l_d),
+      "R" => Font.new(name: "R", base_height: 35, base_width: 31, type: :u_l_d),
+      "S" => Font.new(name: "S", base_height: 40, base_width: 35, type: :u_l_d),
+      "T" => Font.new(name: "T", base_height: 48, base_width: 42, type: :u_l_d),
+      "U" => Font.new(name: "U", base_height: 59, base_width: 53, type: :u_l_d),
+      "V" => Font.new(name: "V", base_height: 80, base_width: 71, type: :u_l_d),
+      "0" => Font.new(name: "0", base_height: 15, base_width: 12, type: :u_l_d, scalable: true),
+    }
+
+    def self.all
+      AVAILABLE_FONTS.values
+    end
+
+    def self.from_name?(font_name)
+      AVAILABLE_FONTS[font_name]
+    end
+
+    # Normalize *height* and *width* to the font's height and width.
+    def normalize_size(height:, width:)
+      [
+        normalize_single_size(height, ref_size: base_height),
+        normalize_single_size(width, ref_size: base_width),
+      ]
+    end
+
+    # Normalize *input_size* to be a multiple of *ref_size*.
+    #
+    # Example: (with ref_size = 10)
+    #    input_size   normalized
+    #        0           10
+    #        7           10
+    #       10           10
+    #       11           20
+    def normalize_single_size(input_size, ref_size:)
+      if input_size % ref_size == 0
+        input_size
+      else
+        ((input_size / ref_size) + 1) * ref_size
+      end
+    end
+  end
+
+end

data/lib/zpl-transformer/reader.rb

@@ -0,0 +1,87 @@
+require 'strscan'
+require 'set'
+require_relative './command'
+
+module Zpl
+  # NOTE: doesn't handle ZPL that changes the control char (default is assumed: '^')
+  class Reader
+
+    # Creates a new reader that will read ZPL commands from *content* string.
+    def initialize(content, strip_spaces: true)
+      @scanner = StringScanner.new content
+      @strip_spaces = strip_spaces
+    end
+
+    # Returns the next zpl command or ignored string if any, or nil.
+    #
+    # The ignored string can be a newlines, ignored chars, spaces.
+    def next_token
+      return if @scanner.eos?
+
+      if chars_to_ignore = parse_ignore_chars
+        return chars_to_ignore
+      end
+
+      parse_zpl_cmd
+    end
+
+    # Returns the next zpl command if any, or nil.
+    def next_command
+      while token = next_token
+        if token.is_a?(Command)
+          return token
+        end
+      end
+
+      nil
+    end
+
+    # Yields each ZPL command to the block. Stops when there are no more commands to read.
+    def each_command
+      while cmd = next_command
+        yield cmd
+      end
+    end
+
+    protected
+
+    def parse_zpl_cmd
+      # Example format: ^XXparam1,param2,,param4
+      # Command name: XX (the command is read as 2 chars, no more no less)
+      # 4 (5) params (param 3 & 5 are not given)
+      #
+      # The command stops at the next `^` or newline.
+      @scanner.scan(/\^([A-Z0-9@]{2})([^\^\n]*)/)
+
+      cmd_name = @scanner[1]
+      raw_params = @scanner[2]
+      if @strip_spaces
+        raw_params = raw_params&.strip
+      end
+
+      params = raw_params&.split(',', -1) || []
+      if @strip_spaces
+        params.each { |param| param.strip! }
+      end
+      Command.new(cmd_name, params)
+    end
+
+    def parse_ignore_chars
+      # scan until next command (just before the `^`)
+      chars_skipped = @scanner.scan_until(/(?=\^)/)
+
+      if chars_skipped.nil?
+        # No more commands, return the rest
+        rest = @scanner.rest
+        @scanner.terminate
+        return rest
+      end
+
+      if chars_skipped.empty?
+        nil
+      else
+        chars_skipped
+      end
+    end
+  end
+end

data/lib/zpl-transformer/transformer/base.rb

@@ -0,0 +1,50 @@
+require_relative '../reader'
+
+module Zpl
+  module Transformer
+  end
+
+  # TODO: doc - explain how to make a transformer
+  class Transformer::Base
+
+    # TODO: doc
+    def apply(zpl_code, strip_spaces: true)
+      reader = Reader.new(zpl_code, strip_spaces: strip_spaces)
+      transformed_zpl = StringIO.new
+
+      while token = reader.next_token
+        if token.is_a?(Command)
+          # It's a command, transform it
+          if new_cmd = self.map_cmd(token)
+            transformed_zpl << new_cmd.to_zpl_string
+          end
+        else
+          # Not a command, just append it
+          transformed_zpl << token
+        end
+      end
+
+      transformed_zpl.string
+    end
+
+    # TODO: doc
+    def map_cmd(cmd)
+      cmd
+    end
+
+    protected
+
+    # Returns an integer converted from the string *param*, or nil if it cannot be
+    # converted or when the string is empty.
+    def param_to_i?(param)
+      begin
+        Integer(param)
+      rescue ArgumentError # raised when *param* string cannot be converted to Integer
+        nil
+      rescue TypeError # raised when *param* is nil
+        nil
+      end
+    end
+  end
+
+end

data/lib/zpl-transformer/transformer/base_scaler.rb

@@ -0,0 +1,20 @@
+require_relative './base'
+
+module Zpl
+
+  class Transformer::BaseScaler < Transformer::Base
+
+    def initialize(ratio)
+      @scale_ratio = ratio.to_f
+    end
+
+    protected
+
+    # Scale the given *number* by the configured ratio.
+    def scale_single_number(number)
+      (number * @scale_ratio).to_i
+    end
+
+  end
+
+end

data/lib/zpl-transformer/transformer/font_scaler.rb

@@ -0,0 +1,148 @@
+require_relative '../font'
+require_relative '../reader'
+require_relative './base_scaler'
+
+module Zpl::Transformer
+
+  # TODO: doc - Explain the algorithm used to scale bitmap font
+  #
+  # NOTE: will ONLY scale font commands
+  # NOTE: doesn't support partial font cmd (yet?)
+  #       e.g: font with height but not width
+  class FontScaler < BaseScaler
+    # Supported font commands
+    #
+    # ^A - Scalable/Bitmapped Font
+    #
+    # Param -1: font name (value: [A-Z0-9])
+    #    Note: This is part of the command name (second char), it will not appear in
+    #    the command's params
+    # Param  0: field orientation (enum)
+    # Param  1: character height in dots
+    # Param  2: character width in dots
+    #
+    #
+    # ^CF - Change default Font
+    #
+    # Param 0: font name (value: [A-Z0-9])
+    # Param 1: character height in dots
+    # Param 2: character width in dots
+
+    def initialize(ratio, allow_font_change: true)
+      super(ratio)
+      @allow_font_change = allow_font_change
+    end
+
+    def map_cmd(raw_cmd)
+      font, cmd_kind = font_and_kind_from_cmd?(raw_cmd)
+      unless font
+        # Unable to extract the font from the command, it is probably not
+        # a font command, we don't touch it.
+        return raw_cmd
+      end
+
+      given_height, given_width = extract_given_sizes(raw_cmd, cmd_kind)
+
+      unless given_height && given_width
+        # Either param *height* or *width* is not given, this is not supported.
+        # Returning the same command.
+        return raw_cmd
+      end
+
+      font_cmd = FontCommand.new(raw_cmd, cmd_kind, font, given_height, given_width)
+
+      if font.scalable?
+        scale_scalable_font(font_cmd)
+      else
+        scale_bitmap_font(font_cmd)
+      end
+    end
+
+    protected
+
+    # Helper data class with all the important data easily accessible for the conversion
+    FontCommand = Struct.new(:raw_cmd, :kind, :font, :height, :width)
+
+    def scale_scalable_font(font_cmd)
+      scaled_height = scale_single_number(font_cmd.height)
+      scaled_width = scale_single_number(font_cmd.width)
+
+      make_cmd(font_cmd.raw_cmd, font_cmd.kind, font_cmd.font, scaled_height, scaled_width)
+    end
+
+    def scale_bitmap_font(font_cmd)
+      given_font = font_cmd.font
+      if @allow_font_change
+        new_font = find_smallest_font_matching_size(given_font)
+      end
+      new_font ||= given_font
+
+      # Normalize
+      norm_height, _ = given_font.normalize_size(
+        height: font_cmd.height,
+        width: font_cmd.width,
+      )
+
+      scaled_height = scale_single_number(norm_height)
+      # Proportionnal computation of scaled_width from scaled_height
+      # based on proportion of new_font's base size
+      scaled_width = (new_font.base_width.to_f * scaled_height.to_f / new_font.base_height.to_f).to_i
+
+      # Normalize again
+      norm_scaled_height, norm_scaled_width = new_font.normalize_size(
+        height: scaled_height,
+        width: scaled_width,
+      )
+
+      make_cmd(font_cmd.raw_cmd, font_cmd.kind, new_font, norm_scaled_height, norm_scaled_width)
+    end
+
+    private
+
+    def extract_given_sizes(cmd, cmd_kind)
+      # Format for ^CF: ^CFfont,height,width
+      #    With `font`: the short font name [A-Z0-9]
+      # Format for ^A: ^A#orient,height,width
+      #    With #: the short font name [A-Z0-9]
+      [param_to_i?(cmd.params[1]), param_to_i?(cmd.params[2])]
+    end
+
+    def find_smallest_font_matching_size(current_font)
+      Zpl::Font.all.each do |font|
+        next if current_font.base_size == font.base_size
+        next unless current_font.type == font.type
+
+        if (current_font.base_height % font.base_height) == 0 &&
+            (current_font.base_width % font.base_width) == 0
+          return font
+        end
+      end
+
+      nil
+    end
+
+    def font_and_kind_from_cmd?(raw_cmd)
+      if raw_cmd.name.start_with?('A')
+        font_name = raw_cmd.name[1]
+        cmd_kind = :set_font
+      elsif raw_cmd.name == "CF"
+        # Format: ^CFfont,height,width
+        font_name = raw_cmd.params[0]
+        cmd_kind = :change_default_font
+      else
+        return
+      end
+      [Zpl::Font.from_name?(font_name), cmd_kind]
+    end
+
+    def make_cmd(old_cmd, cmd_kind, new_font, height, width)
+      case cmd_kind
+      when :set_font
+        Zpl::Command.new "A#{ new_font.name }", [old_cmd.params[0], height, width]
+      when :change_default_font
+        Zpl::Command.new "CF", [new_font.name, height, width]
+      end
+    end
+
+  end
+end

data/lib/zpl-transformer/transformer/generic_scaler.rb

@@ -0,0 +1,81 @@
+require_relative './base_scaler'
+
+module Zpl::Transformer
+  # TODO: doc
+  # It works by parsing ZPL commands, then edit the parameters of specific commands
+  # to scale the coordinates to the new dpi
+  class GenericScaler < BaseScaler
+
+    # TODO: doc - what is this hash for? format?
+    # TODO: rewrite?
+    COMMANDS_PARAM_INDEXES_TO_SCALE = {
+      # ^MN - Media Tracking
+      #
+      # Param 0: media being used
+      # Param 1: black mark offset in dots (optional)
+      "MN" => [1],
+
+      # ^BY - Bar Code Field Default
+      #
+      # Param 0: module width in dots
+      # Param 1: wide bar to narrow bar width ratio (float)
+      # Param 2: bar code height in dots
+      "BY" => [0, 2],
+
+      # ^FO - Field Origin
+      #
+      # Param 0: x-axis location in dots
+      # Param 1: y-axis location in dots
+      # Param 2: justification (enum)
+      "FO" => [0, 1],
+
+      # ^B2 - Interleaved 2 of 5 Bar Code
+      #
+      # Param 0: orientation (enum)
+      # Param 1: bar code height in dots
+      # Param 2: print interpretation line above code (bool)
+      "B2" => [1],
+
+      # ^GB - Graphic Box
+      #
+      # Param 0: box width in dots
+      # Param 1: box height in dots
+      # Param 2: border thickness
+      # Param 3: line color (enum)
+      # Param 4: degree of corner rounding (enum)
+      "GB" => [0, 1, 2],
+
+      # ^BC - Code 128 Bar Code (Subsets A, B, and C)
+      #
+      # Param 0: orientation (enum)
+      # Param 1: bar code height in dots
+      # Param 2: print interpretation line (bool)
+      # Param 3: print interpretation line above code (bool)
+      # Param 4: UCC check digit (bool)
+      # Param 5: mode (enum)
+      "BC" => [1],
+    }
+
+    def map_cmd(cmd)
+      return cmd unless cmd_need_scale? cmd
+
+      cmd_params = cmd.params
+
+      param_indexes_to_scale = COMMANDS_PARAM_INDEXES_TO_SCALE[cmd.name]
+      param_indexes_to_scale.each do |param_index|
+        if param_i = param_to_i?(cmd_params[param_index])
+          cmd_params[param_index] = scale_single_number(param_i)
+        end
+      end
+
+      cmd
+    end
+
+    protected
+
+    def cmd_need_scale?(cmd)
+      !!COMMANDS_PARAM_INDEXES_TO_SCALE[cmd.name]
+    end
+
+  end
+end

data/lib/zpl-transformer/transformer/pipeline.rb

@@ -0,0 +1,20 @@
+require_relative './base'
+
+module Zpl
+  class Transformer::Pipeline < Transformer::Base
+
+    def initialize(transformers)
+      @transformers = transformers
+    end
+
+    def map_cmd(cmd)
+      @transformers.each do |tr|
+        new_cmd = tr.map_cmd(cmd)
+        return unless new_cmd
+        cmd = new_cmd
+      end
+      cmd
+    end
+
+  end
+end

data/lib/zpl-transformer/transformers.rb

@@ -0,0 +1,3 @@
+require_relative './transformer/generic_scaler'
+require_relative './transformer/font_scaler'
+require_relative './transformer/pipeline'

data/lib/zpl-transformer/version.rb

@@ -0,0 +1,3 @@
+module Zpl
+  VERSION = "0.1.0"
+end

data/lib/zpl-transformer.rb

@@ -0,0 +1,16 @@
+require_relative './zpl-transformer/version'
+require_relative './zpl-transformer/reader'
+require_relative './zpl-transformer/transformers'
+
+module Zpl
+
+  # Returns the list of unique commands used in the given ZPL.
+  def self.uniq_commands(zpl_content)
+    uniq_cmds = Set.new
+    Reader.new(zpl_content).each_command do |cmd|
+      uniq_cmds << cmd.name
+    end
+    uniq_cmds.to_a
+  end
+
+end

data/zpl-transformer.gemspec

@@ -0,0 +1,26 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "zpl-transformer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "zpl-transformer"
+  spec.version       = Zpl::VERSION
+  spec.authors       = ["Benoit de Chezelles"]
+  spec.email         = ["benoit.dechezelles@gmail.com"]
+
+  spec.summary       = %q{Simple gem to scale ZPL label}
+  spec.homepage      = "https://github.com/cheerz/zpl-transformer.rb"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: zpl-transformer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Benoit de Chezelles
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- benoit.dechezelles@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/zpl-transformer.rb
+- lib/zpl-transformer/command.rb
+- lib/zpl-transformer/font.rb
+- lib/zpl-transformer/reader.rb
+- lib/zpl-transformer/transformer/base.rb
+- lib/zpl-transformer/transformer/base_scaler.rb
+- lib/zpl-transformer/transformer/font_scaler.rb
+- lib/zpl-transformer/transformer/generic_scaler.rb
+- lib/zpl-transformer/transformer/pipeline.rb
+- lib/zpl-transformer/transformers.rb
+- lib/zpl-transformer/version.rb
+- zpl-transformer.gemspec
+homepage: https://github.com/cheerz/zpl-transformer.rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Simple gem to scale ZPL label
+test_files: []