thermal 0.1.1 → 0.2.0

data/lib/thermal/byte_buffer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Thermal
+  class ByteBuffer
+    extend Forwardable
+
+    def buffer
+      @buffer ||= []
+    end
+
+    def <<(obj)
+      case obj
+      when String then append(*obj.bytes)
+      when Integer then append(obj)
+      when Array then append(*obj)
+      else raise "Unknown object type: #{obj.class}"
+      end
+    end
+    alias_method :write, :<<
+    alias_method :sequence, :<<
+
+    def to_base64
+      Base64.strict_encode64(to_s)
+    end
+
+    def to_s
+      buffer.pack('C*')
+    end
+
+    def to_a
+      buffer.dup
+    end
+
+    def flush
+      tmp = buffer
+      @buffer = nil
+      tmp
+    end
+
+    def flush_base64
+      tmp = to_base64
+      flush
+      tmp
+    end
+
+    def_delegators :buffer, :append
+  end
+end

data/lib/thermal/db/charset.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Thermal
+module Db
+  # The charset is different than the codepage. It controls usage of
+  # specific ASCII-range code points such as dollar-sign ($).
+  class Charset
+    CODEPOINTS = [0x23, 0x24, 0x25, 0x2A, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x60, 0x7B, 0x7C, 0x7D, 0x7E].freeze
+
+    attr_reader :key, :charmap
+
+    def initialize(key, charmap)
+      @key = key
+      @charmap = Array(charmap)&.join&.freeze
+    end
+
+    def u_codepoints
+      return @u_codepoints if defined?(@u_codepoints)
+
+      @u_codepoints = @charmap.each_codepoint.to_a
+    end
+
+    def char?(char)
+      !!charmap&.include?(char)
+    end
+
+    def codepoint?(u_codepoint)
+      !!codepoints&.include?(u_codepoint)
+    end
+
+    def codepoint(u_codepoint)
+      CODEPOINTS[u_codepoints&.index(u_codepoint)]
+    end
+  end
+end
+end

data/lib/thermal/db/cjk_encoding.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Thermal
+module Db
+  # Adds CJK character encoding lookup.
+  class CjkEncoding
+    attr_reader :key, :ruby
+
+    def initialize(key, ruby)
+      @key = key
+      @ruby = ruby
+    end
+
+    def codepoint(u_codepoint)
+      char(u_codepoint.chr('UTF-8'))
+    rescue RangeError
+      nil
+    end
+
+    def codepoint?(u_codepoint)
+      !!codepoint(u_codepoint)
+    end
+
+    def char(u_char)
+      return if u_char.ord <= 127
+
+      char = u_char.encode(@ruby)
+      char unless skip?(char)
+    rescue EncodingError
+      nil
+    end
+
+    def char?(u_char)
+      !!char(u_char)
+    end
+
+    private
+
+    def skip?(char)
+      # GB18030 has a 4-byte mapping into Unicode which should be skipped.
+      # Refer to: https://en.wikipedia.org/wiki/GB_18030#Mapping
+      @ruby == 'GB18030' && char&.bytesize == 4
+    end
+  end
+end
+end

data/lib/thermal/db/data.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Thermal
+module Db
+  module Data
+    extend self
+
+    MUTEX = Mutex.new
+    DATA_PATH = 'data/db.yml'
+
+    def data
+      MUTEX.synchronize do
+        @data ||= begin
+          data = load_data
+          normalize_data!(data)
+          ::Thermal::Util.deep_freeze!(data)
+          data
+        end
+      end
+    end
+
+    def available_devices
+      data['devices']
+    end
+
+    def available_encodings
+      data['encodings']
+    end
+
+    def available_charsets
+      data['charsets']
+    end
+
+    def device(device)
+      return unless device
+
+      data.dig('devices', device.to_s)
+    end
+
+    def encoding(encoding)
+      return unless encoding
+
+      data.dig('encodings', encoding.to_s)
+    end
+
+    def charset(charset)
+      return unless charset
+
+      data.dig('charsets', 'escpos', charset.to_i)
+    end
+
+    def reload
+      MUTEX.synchronize do
+        @data = nil
+      end
+    end
+
+    private
+
+    def data_path
+      ::Thermal.gem_root.join(DATA_PATH).to_s
+    end
+
+    def load_data
+      YAML.safe_load_file(data_path, aliases: true)
+    end
+
+    def normalize_data!(data)
+      data.dig('charsets', 'escpos').transform_keys!(&:to_i)
+      device_int_keys = %w[codepages colors fonts]
+      data['devices'].each_value do |d|
+        device_int_keys.each { |k| d[k]&.transform_keys!(&:to_i) }
+      end
+    end
+  end
+end
+end

data/lib/thermal/db/device.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Thermal
+module Db
+  class Device
+    DEFAULT_COL_WIDTH = 42
+
+    attr_reader :key
+
+    def initialize(key, data)
+      @key = key
+      @data = data
+
+      # eager load cache
+      codepage_index
+      charset_index
+    end
+
+    def name
+      @data['name']&.to_s
+    end
+
+    def format
+      @data['format']&.to_s
+    end
+
+    def supports?(feature)
+      !!@data.dig('features', feature)
+    end
+
+    # TODO: this needs to be dynamic in the printer
+    def col_width
+      @col_width ||= @data.dig('fonts', 0, 'columns') || DEFAULT_COL_WIDTH
+    end
+
+    def find_encoding(u_codepoint)
+      if (codepage = codepage_index[u_codepoint])
+        [:codepage, codepage].freeze
+      elsif (charset = charset_index[u_codepoint]) && charset > 0
+        [:charset, charset].freeze
+      end
+    end
+
+    # def find_codepage(encoding)
+    #   encoding = encoding&.to_s
+    #   device.codepages&.invert&.[](encoding) || 0
+    # end
+
+    def codepages
+      @codepages ||= begin
+        codepages = @data['codepages'] || ::Thermal::Db::DEFAULT_CODEPAGES
+        codepages.each_with_object({}) do |(k, v), h|
+          encoding = ::Thermal::Db.encoding(v)
+          h[k] = encoding if encoding
+        end.freeze
+      end
+    end
+
+    def charsets
+      @charsets ||= begin
+        charsets = @data['charsets'] || ::Thermal::Db::DEFAULT_CHARSETS
+        ::Thermal::Util.index_with(charsets) { |i| ::Thermal::Db.charset(i) }.freeze
+      end
+    end
+
+    private
+
+    def codepage_index
+      @codepage_index ||= codepages.map { |k, v| ::Thermal::Util.index_with(v.u_codepoints, k) }
+                                   .reverse.inject(&:merge).freeze
+    end
+
+    def charset_index
+      @charset_index ||= charsets.values.map! { |c| ::Thermal::Util.index_with(c.u_codepoints, c.key) }
+                                 .reverse.inject(&:merge).freeze
+    end
+  end
+end
+end

data/lib/thermal/db/encoding.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Thermal
+module Db
+  class Encoding
+    RANGE = (128..255)
+
+    attr_reader :key, :charmap
+
+    def initialize(key, charmap)
+      @key = key
+      @charmap = Array(charmap)&.join&.freeze
+      raise 'Invalid charmap' unless @charmap.size == 128
+    end
+
+    def u_codepoints
+      return @u_codepoints if defined?(@u_codepoints)
+
+      @u_codepoints = charmap.each_codepoint.to_a
+    end
+
+    def char?(char)
+      !!charmap&.include?(char)
+    end
+
+    def codepoint?(u_codepoint)
+      !!u_codepoints&.include?(u_codepoint)
+    end
+
+    def codepoint(u_codepoint)
+      u_codepoints&.index(u_codepoint)&.+(128)
+    end
+  end
+end
+end

data/lib/thermal/db/loader.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Thermal
+module Db
+  module Loader
+    extend self
+
+    MUTEX = Mutex.new
+
+    def device(device)
+      device = device&.to_s
+      cached(:devices, device) do
+        cfg = data.device(device)
+        ::Thermal::Db::Device.new(device, cfg) if cfg
+      end
+    end
+
+    def encoding(encoding)
+      encoding = encoding&.to_s
+      cached(:encodings, encoding) do
+        charmap = data.encoding(encoding)&.[]('charmap')
+        ::Thermal::Db::Encoding.new(encoding, charmap) if charmap
+      end
+    end
+
+    def charset(charset)
+      charset = charset&.to_i
+      cached(:charsets, charset) do
+        charmap = data.charset(charset)&.[]('charmap')
+        ::Thermal::Db::Charset.new(charset, charmap) if charmap
+      end
+    end
+
+    def cjk_encoding(cjk)
+      cjk = cjk&.to_s
+      cached(:cjk_encodings, cjk) do
+        ruby = data.encoding(cjk)&.[]('ruby')
+        ::Thermal::Db::CjkEncoding.new(cjk, ruby) if ruby
+      end
+    end
+
+    def reload
+      MUTEX.synchronize do
+        @cache = nil
+      end
+    end
+
+    private
+
+    def cached(key, value)
+      cache[key.to_s][value] ||= yield
+    end
+
+    def cache
+      MUTEX.synchronize do
+        @cache ||= Hash.new { |h, k| h[k] = {} }
+      end
+    end
+
+    def data
+      ::Thermal::Db::Data
+    end
+  end
+end
+end

data/lib/thermal/db.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Thermal
+  module Db
+    extend self
+    extend Forwardable
+
+    DEFAULT_DEVICE = 'escpos_generic'
+    DEFAULT_CODEPAGES = { 0 => 'cp437' }.freeze
+    DEFAULT_CHARSETS = [0].freeze
+
+    def_delegators ::Thermal::Db::Data,
+                   :data,
+                   :available_devices,
+                   :available_encodings,
+                   :available_charsets
+
+    def_delegators ::Thermal::Db::Loader,
+                   :encoding,
+                   :charset,
+                   :cjk_encoding
+
+    def device(device)
+      loader = ::Thermal::Db::Loader
+      loader.device(device) || loader.device(DEFAULT_DEVICE)
+    end
+
+    def find_cjk_encoding(locale)
+      return unless locale
+
+      case locale.to_s.downcase.tr('_', '-')
+      when /\Aja(-.+)?\z/, 'jp'
+        'shift_jis'
+      when /\Ako(-.+)?\z/, 'kr'
+        'ksc5601'
+      when /\A(zh)?-?(hant(-.+)?|tw|hk|mo)\z/
+        'big5'
+      when /\Azh(-.+)?\z/, 'zhhans', 'cn', 'sg', 'my'
+        'gb18030'
+      end
+    end
+  end
+end

data/lib/thermal/dsl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Thermal
+  module Dsl
+    def self.included(base)
+      base.class_eval do
+        def thermal_print(...)
+          printer.print(...)
+        end
+
+        private
+
+        ::Thermal::Printer::PRINT_METHODS.each do |meth|
+          define_method(meth) do |*args, **kwargs, &block|
+            raise 'Must define #printer method or set @printer variable' unless printer
+
+            printer.send(meth, *args, **kwargs, &block)
+          end
+          private(meth)
+        end
+
+        def printer
+          @printer
+        end
+      end
+    end
+  end
+end

data/lib/thermal/escpos/buffer.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Thermal
+module Escpos
+  # Inspired by mike42/escpos-php
+  # https://github.com/mike42/escpos-php/blob/development/src/Mike42/Escpos/PrintBuffers/EscposPrintBuffer.php
+  class Buffer < ::Thermal::ByteBuffer
+    extend Forwardable
+
+    def initialize(profile)
+      super()
+      @profile = profile
+      @codepage = 0
+      @charset = 0
+      @cjk = false
+      init_buffer!
+    end
+
+    def_delegators :@profile,
+                   :find_encoding,
+                   :cjk_encoding,
+                   :codepages,
+                   :charsets,
+                   :codepoint_cjk_skip?,
+                   :codepoint_cjk_force?
+
+    def current_encoding
+      @cjk ? cjk_encoding : codepages[@codepage]
+    end
+
+    def current_charset
+      charsets[@charset]
+    end
+
+    def write_text(text, replace: nil, no_cjk: false)
+      text = ::Thermal::Util.normalize_utf8(text, replace: replace)
+      text&.each_codepoint do |u_codepoint|
+        write_u_codepoint(u_codepoint, replace: replace, no_cjk: no_cjk)
+      end
+    end
+
+    private
+
+    def write_u_codepoint(u_codepoint, replace: nil, no_cjk: false, fallback: false)
+      replace ||= ::Thermal.replace_char
+
+      if ascii?(u_codepoint)
+        reset_charset!(u_codepoint)
+        write(u_codepoint)
+      elsif current_encoding &&
+            (!@cjk || (!no_cjk && !codepoint_cjk_skip?(u_codepoint))) &&
+            (@cjk || !codepoint_cjk_force?(u_codepoint)) &&
+            (codepoint = current_encoding.codepoint(u_codepoint))
+        write(codepoint)
+      else
+        location, value = find_encoding(u_codepoint, no_cjk: no_cjk)
+        case location
+        when :codepage
+          set_codepage(value)
+          codepoint = current_encoding.codepoint(u_codepoint)
+          # TODO: move this to encoding class
+          raise_missing_codepoint!(u_codepoint, current_encoding) unless codepoint
+          write(codepoint)
+        when :charset
+          set_charset(value)
+          codepoint = current_charset.codepoint(u_codepoint)
+          # TODO: move this to encoding class
+          raise_missing_codepoint!(u_codepoint, current_encoding) unless codepoint
+          write(codepoint)
+        when :cjk
+          set_cjk(true)
+          char = current_encoding.codepoint(u_codepoint)
+          # TODO: move this to encoding class
+          raise_missing_codepoint!(u_codepoint, current_encoding) unless char
+          write(char)
+        else
+          write_u_codepoint(replace.ord, replace: ' ', fallback: true) unless fallback || replace.empty?
+        end
+      end
+    end
+
+    def init_buffer!
+      sequence(::Escpos::HW_INIT)
+
+      # CJK is on after HW_INIT for Chinese models.
+      # To ensure consistency, we explicitly set it off.
+      # https://reference.epson-biz.com/modules/ref_escpos/index.php?content_id=175
+      sequence(Cmd::SET_CJK_OFF) if cjk_supported?
+    end
+
+    def ascii?(codepoint, extended: false)
+      (codepoint == 10) ||
+        (codepoint >= 32 && codepoint <= 126) ||
+        (extended && codepoint >= 128 && codepoint <= 255)
+    end
+
+    def set_charset(charset) # rubocop:disable Naming/AccessorMethodName
+      return if @charset == charset
+
+      sequence([0x1b, 0x52] + [charset])
+      @charset = charset
+    end
+
+    def reset_charset!(u_codepoint)
+      return unless ::Thermal::Db::Charset::CODEPOINTS.include?(u_codepoint)
+
+      set_charset(0)
+    end
+
+    def set_codepage(codepage) # rubocop:disable Naming/AccessorMethodName
+      set_cjk(false)
+      return if @codepage == codepage
+
+      sequence(::Escpos::CP_SET + [codepage])
+      @codepage = codepage
+    end
+
+    def set_cjk(enabled) # rubocop:disable Naming/AccessorMethodName
+      enabled ? set_cjk_on : set_cjk_off
+    end
+
+    def set_cjk_on
+      return if !cjk_supported? || @cjk
+
+      sequence(cjk_on_command)
+      @cjk = true
+    end
+
+    def set_cjk_off
+      return if !cjk_supported? || !@cjk
+
+      sequence(cjk_off_command)
+      @cjk = false
+    end
+
+    def cjk_supported?
+      !!cjk_encoding
+    end
+
+    def shift_jis?
+      cjk_encoding&.ruby == 'Shift_JIS'
+    end
+
+    def cjk_on_command
+      if shift_jis?
+        Cmd::SET_JIS_MODE + [1]
+      else
+        Cmd::SET_CJK_ON
+      end
+    end
+
+    def cjk_off_command
+      if shift_jis?
+        Cmd::SET_JIS_MODE + [0]
+      else
+        Cmd::SET_CJK_OFF
+      end
+    end
+
+    # TODO: move this to encoding
+    def raise_missing_codepoint!(u_codepoint, encoding)
+      klass = encoding.class.name.split('::').last
+      raise "Codepoint U#{u_codepoint.to_s(16)} not found in #{klass} #{encoding.name}"
+    end
+  end
+end
+end

data/lib/thermal/escpos/cmd.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Thermal
+module Escpos
+  module Cmd
+    SET_JIS_MODE = [0x1C, 0x43].freeze
+    SET_CJK_ON   = [0x1C, 0x26].freeze
+    SET_CJK_OFF  = [0x1C, 0x2E].freeze
+  end
+end
+end