thermal 0.1.1 → 0.2.0

data/lib/thermal/escpos/writer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Thermal
+module Escpos
+  class Writer < ::Thermal::WriterBase
+    extend Forwardable
+
+    DEFAULT_QR_CODE_SIZE = 400
+
+    def_delegators :buffer,
+                   :write,
+                   :write_text,
+                   :sequence
+
+    def self.format
+      'escpos'
+    end
+
+    def print(flush: true, output: nil)
+      @buffer = nil
+      super
+      feed(5)
+      cut
+      if output == :byte_array
+        flush ? buffer.flush : buffer.to_a
+      else
+        flush ? buffer.flush_base64 : buffer.to_base64
+      end
+    end
+
+    def text(str, feed: true, replace: nil, no_cjk: false, **_kwargs)
+      write_text(str, replace: replace, no_cjk: no_cjk)
+      self.feed if feed
+    end
+
+    def hr(style = nil, width: col_width)
+      write_text(hr_char(style) * width)
+      feed
+    end
+
+    def feed(lines = 1)
+      write("\n" * lines)
+    end
+
+    def cut
+      seq = supports?(:paper_partial_cut) ? ::Escpos::PAPER_PARTIAL_CUT : ::Escpos::PAPER_FULL_CUT
+      sequence(seq)
+    end
+
+    def image(path, opts = {})
+      write(::Escpos::Image.new(path, opts).to_escpos)
+    end
+
+    def qr_code(url, size = DEFAULT_QR_CODE_SIZE)
+      image(::RQRCode::QRCode.new(url).as_png(size: size))
+    end
+
+    private
+
+    def write_bold!
+      cmd = @bold ? ::Escpos::TXT_BOLD_ON : ::Escpos::TXT_BOLD_OFF
+      sequence(cmd)
+    end
+
+    def write_underline!
+      cmd = if !@underline
+              ::Escpos::TXT_UNDERL_OFF
+            elsif @underline.is_a?(Numeric) && @underline >= 2
+              ::Escpos::TXT_UNDERL2_ON
+            else
+              ::Escpos::TXT_UNDERL_ON
+            end
+      sequence(cmd)
+    end
+
+    def write_align!
+      cmd = case @align
+            when :right
+              ::Escpos::TXT_ALIGN_RT
+            when :center
+              ::Escpos::TXT_ALIGN_CT
+            else
+              ::Escpos::TXT_ALIGN_LT
+            end
+      sequence(cmd)
+    end
+
+    def buffer
+      @buffer ||= ::Thermal::Escpos::Buffer.new(@profile)
+    end
+  end
+end
+end

data/lib/thermal/escpos_star/buffer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Thermal
+module EscposStar
+  class Buffer < ::Thermal::ByteBuffer
+    def initialize
+      super
+      init_buffer!
+    end
+
+    def write_text(text, replace: nil, **_kwargs)
+      text = ::Thermal::Util.normalize_utf8(text, replace: replace)
+      write(text) if text
+    end
+
+    private
+
+    def init_buffer!
+      sequence(::Escpos::HW_INIT)
+      set_cjk_off
+      set_charset_zero
+      set_codepage_utf8
+    end
+
+    def set_cjk_off
+      sequence([0x1c, 0x2e, 0x1c, 0x43, 0])
+    end
+
+    def set_charset_zero
+      sequence([0x1b, 0x52, 0])
+    end
+
+    def set_codepage_utf8
+      sequence([0x1b, 0x1d, 0x74, 128])
+    end
+  end
+end
+end

data/lib/thermal/escpos_star/writer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Thermal
+module EscposStar
+  class Writer < ::Thermal::Escpos::Writer
+    def self.format
+      'escpos_star'
+    end
+
+    private
+
+    def buffer
+      @buffer ||= ::Thermal::EscposStar::Buffer.new
+    end
+  end
+end
+end

data/lib/thermal/printer.rb

@@ -1,21 +1,56 @@
-module Thermal
-  class Printer
-
-    def self.translate
-      {}
-    end
-
-    def self.getCode(tag)
-      self.translate[tag.to_sym] || ['', '']
-    end
-
-    def self.startCode(tag)
-      self.getCode(tag)[0]
-    end
-
-    def self.endCode(tag)
-      self.getCode(tag)[1]
-    end
-
-  end
-end
+# frozen_string_literal: true
+
+module Thermal
+  class Printer
+    extend Forwardable
+
+    # TODO: align(:symbol)
+    PRINT_METHODS = %i[ text
+                        hr
+                        bold
+                        underline
+                        align
+                        feed
+                        cut
+                        image
+                        qr_code ].freeze
+
+    WRITERS = [
+      ::Thermal::Escpos::Writer,
+      ::Thermal::EscposStar::Writer,
+      ::Thermal::Stargraphic::Writer,
+      ::Thermal::Starprnt::Writer
+    ].freeze
+
+    WRITER_MAP = ::Thermal::Util.index_by(WRITERS, &:format).freeze
+
+    attr_reader :device
+
+    # opts includes :cjk_encoding
+    def initialize(device, **opts)
+      @device = device
+      @opts = opts
+    end
+
+    def profile
+      @profile ||= ::Thermal::Profile.new(device, **@opts)
+    end
+
+    def writer
+      @writer ||= WRITER_MAP[format].new(profile)
+    end
+
+    def_delegators :profile,
+                   :format,
+                   :device_name,
+                   :codepages,
+                   :charsets,
+                   :cjk_encoding,
+                   :supports?,
+                   :col_width
+
+    def_delegators :writer,
+                   :print,
+                   *PRINT_METHODS
+  end
+end

data/lib/thermal/profile.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Thermal
+  class Profile
+    extend Forwardable
+
+    # TODO: some of these methods can be moved to an Escpos::Encoder class.
+
+    # These characters should always use codepage, even if present
+    # in CJK. HR chars have issues with double-printing in CJK encodings
+    # on Epson printers. This has been observed on Japanese (Shift-JIS)
+    # with \u2500 and Simplified Chinese (GB18030) with \u2584.
+    CODEPOINTS_CJK_SKIP = [
+      "\u2500".."\u259F", # box drawing + block elements
+      "\u2660".."\u2667"  # card suits
+    ].map(&:to_a).flatten.join.each_codepoint.to_a.freeze
+
+    # These characters exist in the Katakana codepage,
+    # but should use CJK encoding if available.
+    CODEPOINTS_CJK_FORCE = '円年月日時分秒〒市区町村人'.each_codepoint.to_a.freeze
+
+    # Wraps a Device object with CJK encoding support.
+    def initialize(device, **opts)
+      @device_key = device.to_s
+      @cjk = ::Thermal::Db.find_cjk_encoding(opts[:cjk_encoding]) || opts[:cjk_encoding]
+    end
+
+    def device_name
+      device.name
+    end
+
+    def cjk_encoding
+      return @cjk_encoding if defined?(@cjk_encoding)
+
+      @cjk_encoding = ::Thermal::Db.cjk_encoding(@cjk)
+    end
+
+    def_delegators :device,
+                   :format,
+                   :codepages,
+                   :charsets,
+                   :supports?,
+                   :col_width
+
+    def find_encoding(u_codepoint, no_cjk: false)
+      device_encoding = device.find_encoding(u_codepoint)
+      if device_encoding && !codepoint_cjk_force?(u_codepoint)
+        device_encoding
+      elsif !no_cjk && cjk_encoding&.codepoint?(u_codepoint)
+        [:cjk, true].freeze
+      else # rubocop:disable Lint/DuplicateBranch
+        # codepoint_cjk_force failed
+        device_encoding
+      end
+    end
+
+    def codepoint_cjk_skip?(u_codepoint)
+      CODEPOINTS_CJK_SKIP.include?(u_codepoint)
+    end
+
+    def codepoint_cjk_force?(u_codepoint)
+      CODEPOINTS_CJK_FORCE.include?(u_codepoint)
+    end
+
+    private
+
+    def device
+      @device ||= ::Thermal::Db.device(@device_key)
+    end
+  end
+end

data/lib/thermal/stargraphic/capped_byte_buffer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thermal
+module Stargraphic
+  class CappedByteBuffer < ByteBuffer
+    def initialize(max_bytes)
+      super()
+      @max_bytes = max_bytes
+      @byte_counter = 0
+    end
+
+    protected
+
+    def append(*bytes)
+      @byte_counter += bytes.size
+      super unless @byte_counter >= @max_bytes
+    end
+  end
+end
+end

data/lib/thermal/stargraphic/chunked_byte_buffer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Thermal
+module Stargraphic
+  # TODO: This is not used yet.
+  # It should be refactored as it doesn't transparently extend ByteBuffer
+  class ChunkedByteBuffer
+    def initialize(max_chunk_bytes)
+      @max_chunk_bytes = max_chunk_bytes
+      @byte_counter = 0
+    end
+
+    def <<(obj)
+      check_length(obj)
+      append(obj)
+    end
+
+    def chunks
+      @chunks ||= [::Thermal::ByteBuffer.new]
+    end
+
+    def to_base64
+      chunks.map(&:to_base64)
+    end
+
+    def to_a
+      chunks.map(&:to_a)
+    end
+
+    def flush
+      tmp = chunks
+      @chunks = nil
+      @byte_counter = 0
+      tmp
+    end
+
+    def flush_base64
+      tmp = to_base64
+      flush
+      tmp
+    end
+
+    protected
+
+    # This method approximates base64 byte counting. The base64 encoded size
+    # will be greater than or equal to the raw bytes, so this is safe.
+    # Note that `obj` can be either a String or Array; both respond to size.
+    def check_length(obj)
+      @byte_counter += obj.size
+      add_chunk if @byte_counter > @max_chunk_bytes
+    end
+
+    def add_chunk
+      chunks << ::Thermal::ByteBuffer.new
+    end
+
+    def append(obj)
+      chunks.last << obj
+    end
+  end
+end
+end

data/lib/thermal/stargraphic/writer.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Thermal
+module Stargraphic
+  # TODO: image buffer
+  # TODO: page limit
+  class Writer < ::Thermal::WriterBase
+    DOT_WIDTH = 576
+    LINE_HEIGHT = 34
+    PAGE_LENGTH = 32_000
+    MAX_BYTES = 500_000 # Star API allows 500KB max
+
+    def initialize(profile)
+      @width = DOT_WIDTH
+      @align = :left
+      super
+    end
+
+    def self.format
+      'stargraphic'
+    end
+
+    def print(flush: true)
+      seq_init_raster_mode
+      seq_enter_raster_mode
+      seq_set_page_length
+      super
+      feed(5)
+      cut
+      finalize(flush: flush)
+    end
+
+    def text(str, feed: true, replace: nil, **_kwargs)
+      str = ::Thermal::Util.normalize_utf8(str, replace: replace)
+      str = "#{str}\n" if feed
+      append_text(str) if str
+    end
+
+    def hr(style = nil, width: col_width) # rubocop:disable Lint/UnusedMethodArgument
+      append_image(hr_image(style))
+      # append_raw(hr_seq(style))
+    end
+
+    def bold
+      @bold = true
+      yield
+      @bold = false
+    end
+
+    def underline(weight: nil) # rubocop:disable Lint/UnusedMethodArgument
+      @underline = true
+      yield
+      @underline = false
+    end
+
+    def feed(lines = 1)
+      feed_rows(lines * LINE_HEIGHT)
+    end
+
+    def image(path)
+      width, height = ::MiniMagick::Image.open(path).dimensions
+      output, = Open3.capture3("convert #{path} -depth 1 R:-", binmode: true)
+      output = output.chomp
+      append_image([width, height, output])
+    end
+
+    def qr_code(url)
+      append_image(qr_code_image(url))
+    end
+
+    def cut
+      seq_set_em_mode
+      seq_exec_em
+    end
+
+    protected
+
+    def commands
+      @commands ||= []
+    end
+
+    def buffer
+      @buffer ||= ::Thermal::Stargraphic::CappedByteBuffer.new(MAX_BYTES)
+    end
+
+    def finalize(flush: true, output: nil)
+      rasterize_text
+      write_commands_to_buffer
+      @commands = []
+      if output == :byte_array
+        [flush ? buffer.flush : buffer.to_a]
+      else
+        [flush ? buffer.flush_base64 : buffer.to_base64]
+      end
+    end
+
+    def rasterize_text
+      commands.each_index do |i|
+        if commands[i][0] == :text
+          data = commands[i][1]
+          @commands[i] = [:image, text_image(data[0], align: data[1])]
+        end
+      end
+    end
+
+    def write_commands_to_buffer
+      commands.each do |type, obj|
+        case type
+        when :raw   then write(obj)
+        when :image then write_image(obj)
+        else raise "Cannot write type #{type.inspect}"
+        end
+      end
+    end
+
+    def write(obj)
+      buffer << obj
+    end
+
+    def write_image(obj)
+      width, _, data = obj
+      raise "Width #{width}px must be a multiple of 8" unless width % 8 == 0
+      raise "Width #{width}px cannot be greater than #{@width}px" if width > @width
+
+      byte_width = width / 8
+      row_cmd = [98, byte_width, 0]
+      data.each_chunk(byte_width) do |row|
+        buffer << row_cmd
+        buffer << row
+      end
+    end
+
+    # control chars:
+    # \e{ - converts to <
+    # \e} - converts to >
+    def append_text(str, font_size: 21, spacing: -2)
+      str = str
+            .gsub('&', '&amp;')
+            .gsub('\\', '&#92;')
+            .gsub('<', '&lt;')
+            .gsub('>', '&gt;')
+            .gsub('&', '&amp;') # do a second-pass on & char
+            .gsub("\e{", '<')
+            .gsub("\e}", '>')
+
+      str = "<i>#{str}</i>" if @italic
+      str = "<b>#{str}</b>" if @bold
+      str = "<u>#{str}</u>" if @underline
+      str = "<span size='#{(font_size * 1024).to_i}' letter_spacing='#{(spacing * 1024).to_i}'>#{str}</span>"
+      str = str.encode_utf8('')
+
+      if commands[-1] && commands[-1][0] == :text && commands[-1][1][1] == @align # align match
+        commands[-1][1][0] << str
+      else
+        commands << [:text, [str, @align]]
+      end
+    end
+
+    def append_image(obj)
+      obj[2] = (+obj[2]).force_encoding('UTF-8')
+      if commands[-1] && commands[-1][0] == :image && commands[-1][1][0] == obj[0] # width match
+        commands[-1][1][1] += obj[1] # add height
+        commands[-1][1][2] << obj[2] # append data
+      else
+        commands << [:image, obj]
+      end
+    end
+
+    def append_raw(obj)
+      commands << [:raw, obj]
+    end
+
+    def seq_set_page_length(length = 32_000)
+      append_raw([27, 42, 114, 80] + length.to_s.each_char.map(&:ord) + [0])
+    end
+
+    def seq_init_raster_mode
+      append_raw [27, 42, 114, 82]
+    end
+
+    def seq_enter_raster_mode
+      append_raw [27, 42, 114, 65]
+    end
+
+    def seq_set_em_mode(cut = true) # rubocop:disable Style/OptionalBooleanParameter
+      append_raw [27, 42, 114, 101, cut ? 13 : 0, 0]
+    end
+
+    def seq_exec_em
+      append_raw [27, 12, 25]
+    end
+
+    def font
+      self.class.font
+    end
+
+    class << self
+      # Persists font as singleton
+      def font
+        @font ||= if OS.windows?
+                    'Sans'
+                  else
+                    font_list = begin
+                      `fc-list`
+                    rescue StandardError
+                      ''
+                    end
+                    case font_list
+                    when /NotoSans/ then 'NotoSans'
+                    else 'Sans'
+                    end
+                  end
+      end
+    end
+
+    def text_image(markup, width: @width, align: :left, font: 'Sans', delete: true)
+      tmp_path = ::Thermal.tmp_path("#{SecureRandom.uuid}.png")
+
+      begin
+        ::MiniMagick::Tool::Convert.new do |i|
+          i << '+antialias'
+          i << '+dither'
+          i.size width
+          i.font font
+          # replace next line with align when released
+          i.gravity :center if align == :center
+          # after this is released https://github.com/ImageMagick/ImageMagick6/commit/b82aa924
+          # i.define "pango:align=#{align}"
+          i.pango markup
+          i.threshold '30%'
+          i.depth 1
+          i.negate
+          i << tmp_path
+        end
+      rescue StandardError => e
+        Bugsnag.notify(e) do |r|
+          r.add_metadata('data',
+                         text: markup,
+                         width: width,
+                         align: align,
+                         font: font)
+        end
+        raise e
+      end
+
+      output, = Open3.capture3("convert #{tmp_path} -depth 1 R:-", binmode: true)
+      File.delete(tmp_path) if delete
+      output = output.chomp
+      height = (8 * output.size / width.to_f).ceil
+      [width, height, output]
+    end
+
+    # TODO: assumes 8px width
+    # TODO: centering is off
+    def qr_code_image(url, width: @width)
+      cols = width / 8
+      qr_lines = ::RQRCode::QRCode.new(url).to_s(dark: 'x', light: ' ').split("\n")
+      height = qr_lines.size * 8
+      qr_lines = qr_lines.map { |line| line.each_char.map { |d| d == 'x' ? 255 : 0 } }
+      qr_cols = qr_lines.first.size
+      margin = (cols - qr_cols) / 2.0
+      zero = [0]
+      output = qr_lines.map { |line| ((zero * margin.floor) + line + (zero * margin.ceil)) * 8 }.flatten.pack('C*')
+      [width, height, output]
+    end
+
+    def feed_rows(rows)
+      append_raw(feed_rows_seq(rows))
+    end
+
+    def feed_rows_seq(rows)
+      [27, 42, 114, 89] + rows.to_s.each_char.map(&:ord) + [0]
+    end
+
+    def hr_image(style = nil, width: @width)
+      byte_width = width / 8
+      pixels = hr_pixels(style)
+      output = +''
+      (0...LINE_HEIGHT).each do |row|
+        output << ((row.in?(pixels) ? "\xFF" : "\x00") * byte_width)
+      end
+      output.freeze
+      [width, LINE_HEIGHT, output]
+    end
+
+    # More efficient
+    # def hr_seq(style = nil, width: @width)
+    #   byte_width = width / 8
+    #   pixels = hr_pixels(style)
+    #   output = []
+    #   i = 0
+    #   (0...LINE_HEIGHT).each do |row|
+    #     if row.in?(pixels)
+    #       output += feed_rows_seq(i) if i > 0
+    #       output += [98, byte_width, 0] + [255] * byte_width
+    #       i = 0
+    #     else
+    #       i += 1
+    #     end
+    #   end
+    #   output += feed_rows_seq(i) if i > 0
+    #   output
+    # end
+
+    def hr_pixels(style)
+      case style
+      when :bold then 11..14
+      when :double then [9, 10, 15, 16]
+      when :underline then 25..26
+      when :half_upper then 0..12
+      when :half_lower then 13..29
+      when :full then 0..29
+      else 12..13
+      end.to_a
+    end
+  end
+end
+end