glyphic 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 738496f374c2a619ecfe954d756b61e8c9acd315f58fe987bf9ea0a8ea74780d
-  data.tar.gz: e6930b83fabcc8ece85a292d3730f1b41aa32506facd362afbd9b8bc97679e9c
+  metadata.gz: e0e68eb3afceb9ab4a9fd3f4d3ca5d4e358481b0ec4e9929366bbddb015aa74c
+  data.tar.gz: cd24a61fb5ff6a44b92a24c02bc68ff3512b4850efee64c4ab402d138e036062
 SHA512:
-  metadata.gz: 141454631eac879ceeb67733f6a690d4dbdcd1381412121bb9337d003d3a475745f7c3198781be499de3e3734291655509627d1db9d9f0b9748e0ea6d17d2f97
-  data.tar.gz: fd9853fa5bfdf46d2b5beb67758ee0eebaa90e109c7c4907cb505bcd7b1786ca35c8d43f88992207be6d2f1af27c2a54d903fee0145cbe1d3e3b78965edcd291
+  metadata.gz: 772f4464e4ecf3dd68e2a510dbec1349f8cc8c9a55c2f0e3123240540baff074182d34e61fd421987b671f8617619b108dcbe5d53aab59043dd8755dcfe12211
+  data.tar.gz: 66345c6bbf892723eefde799a1f327c75daf575c88a8ef51f10de9975040df110a6149233f1be20c60e5965c0701e1df9d438a9090e9420dce351b3faaeb4ce0

data/.yamllint

@@ -0,0 +1,16 @@
+extends: default
+ignore: |
+  build/
+  node_modules/
+  runtime/build/
+  tmp/
+  **/*.dSYM/**
+
+rules:
+  comments:
+    min-spaces-from-content: 1
+  document-start: disable
+  line-length:
+    max: 200
+  truthy:
+    check-keys: false

data/CHANGELOG.md

@@ -2,10 +2,13 @@
 
 ## [Unreleased]
 
+## [0.1.2] - 2026-09-26
+
+- Reject truncated or malformed BDF and TrueType fonts with clear errors.
+
 ## [0.1.1] - 2026-09-25
 
-- Correct the gem author and license attribution.
-- Bound the Tessel dependency to compatible major versions.
+- Prevent installation with unsupported major versions of Tessel.
 
 ## [0.1.0] - 2026-09-23
 

data/lib/glyphic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Glyphic
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/glyphic.rb

@@ -123,12 +123,17 @@ module Glyphic
           block << lines[index]
           index += 1
         end
+        raise UnsupportedError, "invalid BDF glyph terminator" unless lines[index] == "ENDCHAR"
+
         encoded = block.find { |line| line.start_with?("ENCODING") }&.split&.last
         code = encoded&.to_i
         if code && code >= 0
           code = jis_to_unicode(code) if registry.start_with?("JISX0208")
           if code
-            glyph = parse_glyph(block, advance: block.find { |line| line.start_with?("DWIDTH") }&.split&.last.to_i)
+            advance = block.find { |line| line.start_with?("DWIDTH ") }&.split&.[](1)
+            raise UnsupportedError, "invalid BDF glyph advance" unless advance&.match?(/\A-?\d+\z/)
+
+            glyph = parse_glyph(block, advance: advance.to_i)
             glyphs[code] = glyph
           else
             skipped += 1
@@ -142,10 +147,16 @@ module Glyphic
     end
 
     def parse_glyph(block, advance:)
-      bbx = block.find { |line| line.start_with?("BBX") }.split.drop(1).map(&:to_i)
+      bbx = block.find { |line| line.start_with?("BBX ") }&.split&.drop(1)&.map { |value| Integer(value, exception: false) }
+      raise UnsupportedError, "invalid BDF glyph bounds" unless bbx&.length == 4 && bbx.all? && bbx[0] >= 0 && bbx[1] >= 0
+
       width, height, offset_x, offset_y = bbx
       bitmap_start = block.index("BITMAP")
+      raise UnsupportedError, "invalid BDF glyph bitmap" unless bitmap_start
+
       rows = block[(bitmap_start + 1), height].to_a
+      raise UnsupportedError, "invalid BDF glyph bitmap" unless rows.length == height && rows.all? { |row| row.match?(/\A[0-9A-Fa-f]*\z/) && row.length * 4 >= width }
+
       alpha = rows.map do |line|
         value = line.to_i(16)
         (0...width).map { |x| (value & (1 << ([line.length * 4, width].max - x - 1))).positive? ? 255 : 0 }
@@ -172,16 +183,29 @@ module Glyphic
       def initialize(bytes)
         @bytes = bytes.b
         @tables = {}
+        raise UnsupportedError, "invalid TrueType table directory" unless @bytes.bytesize >= 12
+
         count = @bytes.byteslice(4, 2).unpack1("n")
+        raise UnsupportedError, "invalid TrueType table directory" if 12 + count * 16 > @bytes.bytesize
+
         count.times do |index|
           tag, _checksum, offset, length = @bytes.byteslice(12 + index * 16, 16).unpack("a4N3")
+          raise UnsupportedError, "invalid TrueType table data" if offset > @bytes.bytesize || length > @bytes.bytesize - offset
+
           @tables[tag] = @bytes.byteslice(offset, length)
         end
       end
 
-      def u16(data, offset) = data.byteslice(offset, 2).unpack1("n")
-      def i16(data, offset) = data.byteslice(offset, 2).unpack1("s>")
-      def u32(data, offset) = data.byteslice(offset, 4).unpack1("N")
+      def slice(data, offset, length)
+        part = data&.byteslice(offset, length) if offset >= 0 && length >= 0
+        raise UnsupportedError, "invalid TrueType table data" unless part && part.bytesize == length
+
+        part
+      end
+
+      def u16(data, offset) = slice(data, offset, 2).unpack1("n")
+      def i16(data, offset) = slice(data, offset, 2).unpack1("s>")
+      def u32(data, offset) = slice(data, offset, 4).unpack1("N")
     end
 
     class Font < Glyphic::Font
@@ -238,13 +262,14 @@ module Glyphic
 
       def build_cmap(data)
         records = @reader.u16(data, 2).times.map do |index|
-          platform, encoding, offset = data.byteslice(4 + index * 8, 8).unpack("n2N")
+          platform, encoding, offset = @reader.slice(data, 4 + index * 8, 8).unpack("n2N")
           [platform, encoding, offset]
         end
         selected = records.sort_by { |platform, encoding, _| platform == 3 && encoding == 10 ? 0 : platform == 3 && encoding == 1 ? 1 : platform.zero? ? 2 : 3 }.find { |_, _, offset| [4, 12].include?(@reader.u16(data, offset)) }
         return {} unless selected
         format = @reader.u16(data, selected[2])
-        format == 12 ? cmap12(data.byteslice(selected[2]..)) : cmap4(data.byteslice(selected[2]..))
+        subtable = @reader.slice(data, selected[2], data.bytesize - selected[2])
+        format == 12 ? cmap12(subtable) : cmap4(subtable)
       end
 
       def build_kern(data)
@@ -258,7 +283,7 @@ module Glyphic
           if coverage & 0xff == 0
             base = offset + 6
             @reader.u16(data, base).times do |index|
-              left, right, value = data.byteslice(base + 8 + index * 6, 6).unpack("n2s>")
+              left, right, value = @reader.slice(data, base + 8 + index * 6, 6).unpack("n2s>")
               pairs[[left, right]] = value
             end
           end
@@ -270,7 +295,7 @@ module Glyphic
       def cmap12(data)
         result = {}
         @reader.u32(data, 12).times do |index|
-          start_code, end_code, start_glyph = data.byteslice(16 + index * 12, 12).unpack("N3")
+          start_code, end_code, start_glyph = @reader.slice(data, 16 + index * 12, 12).unpack("N3")
           (start_code..end_code).each { |code| result[code] = start_glyph + code - start_code }
         end
         result
@@ -278,13 +303,13 @@ module Glyphic
 
       def cmap4(data)
         segments = @reader.u16(data, 6) / 2
-        end_codes = data.byteslice(14, segments * 2).unpack("n*")
+        end_codes = @reader.slice(data, 14, segments * 2).unpack("n*")
         start_offset = 16 + segments * 2
-        start_codes = data.byteslice(start_offset, segments * 2).unpack("n*")
+        start_codes = @reader.slice(data, start_offset, segments * 2).unpack("n*")
         delta_offset = start_offset + segments * 2
-        deltas = data.byteslice(delta_offset, segments * 2).unpack("s>*")
+        deltas = @reader.slice(data, delta_offset, segments * 2).unpack("s>*")
         range_offset = delta_offset + segments * 2
-        offsets = data.byteslice(range_offset, segments * 2).unpack("n*")
+        offsets = @reader.slice(data, range_offset, segments * 2).unpack("n*")
         result = {}
         end_codes.each_index do |segment|
           (start_codes[segment]..end_codes[segment]).each do |code|
@@ -324,26 +349,26 @@ module Glyphic
         finish = glyph_offset(index + 1)
         return [[], [], 0, 0, 0, 0, []] if finish <= offset
 
-        glyph = @glyf.byteslice(offset, finish - offset)
+        glyph = @reader.slice(@glyf, offset, finish - offset)
         contours = @reader.i16(glyph, 0)
         return composite_outline(index, glyph, stack) if contours.negative?
 
-        end_points = glyph.byteslice(10, contours * 2).unpack("n*")
+        end_points = @reader.slice(glyph, 10, contours * 2).unpack("n*")
         point_count = end_points.last.to_i + 1
         cursor = 10 + contours * 2
         instruction_length = @reader.u16(glyph, cursor)
         cursor += 2 + instruction_length
         flags = []
         while flags.length < point_count
-          flag = glyph.getbyte(cursor)
+          flag = @reader.slice(glyph, cursor, 1).getbyte(0)
           cursor += 1
-          repeat = flag.anybits?(8) ? glyph.getbyte(cursor).tap { cursor += 1 } : 0
+          repeat = flag.anybits?(8) ? @reader.slice(glyph, cursor, 1).getbyte(0).tap { cursor += 1 } : 0
           flags.concat([flag] * (repeat + 1))
         end
         xs = read_coordinates(glyph, flags, cursor, point_count, horizontal: true)
         ys = read_coordinates(glyph, flags, xs[1], point_count, horizontal: false)
         raw_points = xs[0].zip(ys[0]).map { |x, y| [x, y] }
-        x_min, y_min, x_max, y_max = glyph.byteslice(2, 8).unpack("s>4")
+        x_min, y_min, x_max, y_max = @reader.slice(glyph, 2, 8).unpack("s>4")
         points, flattened_end_points = flatten_contours(raw_points, flags, end_points)
         [points, flattened_end_points, x_min, y_min, x_max, y_max, raw_points]
       end
@@ -368,11 +393,11 @@ module Glyphic
           cursor += 4
           word_args = flags.anybits?(1)
           arg1, arg2 = if word_args
-            values = glyph.byteslice(cursor, 4).unpack("s>2")
+            values = @reader.slice(glyph, cursor, 4).unpack("s>2")
             cursor += 4
             values
           else
-            values = glyph.byteslice(cursor, 2).unpack("c2")
+            values = @reader.slice(glyph, cursor, 2).unpack("c2")
             cursor += 2
             values
           end
@@ -476,9 +501,9 @@ module Glyphic
 
       def component_transform(glyph, flags, cursor)
         if flags.anybits?(128)
-          glyph.byteslice(cursor, 8).unpack("s>4").map { |value| value / 16_384.0 }
+          @reader.slice(glyph, cursor, 8).unpack("s>4").map { |value| value / 16_384.0 }
         elsif flags.anybits?(64)
-          x, y = glyph.byteslice(cursor, 4).unpack("s>2").map { |value| value / 16_384.0 }
+          x, y = @reader.slice(glyph, cursor, 4).unpack("s>2").map { |value| value / 16_384.0 }
           [x, 0, 0, y]
         elsif flags.anybits?(8)
           scale = @reader.i16(glyph, cursor) / 16_384.0
@@ -502,13 +527,13 @@ module Glyphic
           short = horizontal ? flag.anybits?(2) : flag.anybits?(4)
           same = horizontal ? flag.anybits?(16) : flag.anybits?(32)
           if short
-            delta = glyph.getbyte(cursor)
+            delta = @reader.slice(glyph, cursor, 1).getbyte(0)
             cursor += 1
             delta = -delta if !same
           elsif same
             delta = 0
           else
-            delta = glyph.byteslice(cursor, 2).unpack1("s>")
+            delta = @reader.slice(glyph, cursor, 2).unpack1("s>")
             cursor += 2
           end
           previous += delta

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glyphic
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-25 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tessel
@@ -37,6 +37,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codespellignore"
+- ".yamllint"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md