harfbuzz-ruby 1.0.0

data/lib/harfbuzz/glyph_info.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_glyph_info_t, providing access to glyph ID and cluster index
+  class GlyphInfo
+    def initialize(struct_ptr)
+      @struct = C::HbGlyphInfoT.new(struct_ptr)
+    end
+
+    # @return [Integer] Glyph ID (after shaping) or Unicode codepoint (before shaping)
+    def codepoint
+      @struct[:codepoint]
+    end
+
+    alias glyph_id codepoint
+
+    # @return [Integer] Cluster index in source text
+    def cluster
+      @struct[:cluster]
+    end
+
+    # @return [Integer] Glyph flags bitmask
+    def mask
+      @struct[:mask]
+    end
+
+    def to_h
+      { codepoint: codepoint, cluster: cluster, mask: mask }
+    end
+
+    def inspect
+      "#<HarfBuzz::GlyphInfo glyph_id=#{codepoint} cluster=#{cluster}>"
+    end
+  end
+end

data/lib/harfbuzz/glyph_position.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_glyph_position_t, providing access to advance and offset values
+  class GlyphPosition
+    def initialize(struct_ptr)
+      @struct = C::HbGlyphPositionT.new(struct_ptr)
+    end
+
+    # @return [Integer] Horizontal advance (in font units)
+    def x_advance
+      @struct[:x_advance]
+    end
+
+    # @return [Integer] Vertical advance (in font units)
+    def y_advance
+      @struct[:y_advance]
+    end
+
+    # @return [Integer] Horizontal offset (in font units)
+    def x_offset
+      @struct[:x_offset]
+    end
+
+    # @return [Integer] Vertical offset (in font units)
+    def y_offset
+      @struct[:y_offset]
+    end
+
+    def to_h
+      {
+        x_advance: x_advance, y_advance: y_advance,
+        x_offset: x_offset, y_offset: y_offset
+      }
+    end
+
+    def inspect
+      "#<HarfBuzz::GlyphPosition adv=(#{x_advance},#{y_advance}) off=(#{x_offset},#{y_offset})>"
+    end
+  end
+end

data/lib/harfbuzz/library.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module HarfBuzz
+  # Returns the path to the HarfBuzz shared library
+  # @return [String, Array<String>] Library path or array of library names for FFI to search
+  def self.library_path
+    @library_path ||= detect_library
+  end
+
+  # Sets the library path explicitly
+  # @param path [String] Path to the HarfBuzz shared library
+  def self.library_path=(path)
+    @library_path = path
+  end
+
+  # Detects the HarfBuzz shared library location
+  # @return [String, Array<String>] Library path or array of library names
+  # @raise [LibraryNotFoundError] If library cannot be found
+  private_class_method def self.detect_library
+    # 1. Environment variable override
+    if (env_path = ENV.fetch("HARFBUZZ_LIB_PATH", nil))
+      return env_path if File.exist?(env_path)
+
+      warn "HARFBUZZ_LIB_PATH=#{env_path} does not exist, falling back to auto-detection"
+    end
+
+    # 2. pkg-config (most reliable)
+    pkg_config_path = try_pkg_config
+    return pkg_config_path if pkg_config_path
+
+    # 3. Platform-specific default paths
+    platform_path = try_platform_paths
+    return platform_path if platform_path
+
+    # 4. Let FFI search via ldconfig / dyld (return array of library names)
+    ["harfbuzz", "libharfbuzz", "libharfbuzz-0"]
+  end
+
+  # Tries to find library path using pkg-config
+  # @return [String, nil] Library path if found
+  private_class_method def self.try_pkg_config
+    # Suppress mkmf output
+    libs = `pkg-config --libs harfbuzz 2>/dev/null`.strip
+    return nil if libs.empty?
+
+    lib_dir = libs[/-L(\S+)/, 1]
+    return nil unless lib_dir
+
+    ext = lib_extension
+    path = File.join(lib_dir, "libharfbuzz.#{ext}")
+    File.exist?(path) ? path : nil
+  rescue StandardError
+    nil
+  end
+
+  # Tries platform-specific library paths
+  # @return [String, nil] Library path if found
+  private_class_method def self.try_platform_paths
+    candidates = case RbConfig::CONFIG["host_os"]
+                 when /darwin/i
+                   %w[
+                     /opt/homebrew/lib/libharfbuzz.dylib
+                     /usr/local/lib/libharfbuzz.dylib
+                     /opt/local/lib/libharfbuzz.dylib
+                   ]
+                 when /linux/i
+                   %w[
+                     /usr/lib/x86_64-linux-gnu/libharfbuzz.so
+                     /usr/lib/aarch64-linux-gnu/libharfbuzz.so
+                     /usr/lib64/libharfbuzz.so
+                     /usr/lib/libharfbuzz.so
+                     /usr/local/lib/libharfbuzz.so
+                   ]
+                 when /mingw|mswin|cygwin/i
+                   %w[
+                     C:/msys64/mingw64/bin/libharfbuzz-0.dll
+                     C:/msys64/ucrt64/bin/libharfbuzz-0.dll
+                     C:/msys64/clang64/bin/libharfbuzz-0.dll
+                   ]
+                 else
+                   []
+                 end
+
+    candidates.find { |p| File.exist?(p) }
+  end
+
+  # Returns the library extension for the current platform
+  # @return [String] Library extension (.dylib, .so, or .dll)
+  private_class_method def self.lib_extension
+    case RbConfig::CONFIG["host_os"]
+    when /darwin/i then "dylib"
+    when /mingw|mswin|cygwin/i then "dll"
+    else "so"
+    end
+  end
+end

data/lib/harfbuzz/map.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_map_t — an integer-to-integer mapping
+  #
+  # Behaves similarly to Ruby's Hash with Integer keys and values.
+  # Includes Enumerable.
+  class Map
+    include Enumerable
+
+    HB_MAP_VALUE_INVALID = 0xFFFFFFFF
+
+    attr_reader :ptr
+
+    def initialize
+      @ptr = C.hb_map_create
+      raise AllocationError, "Failed to create map" if @ptr.null?
+
+      HarfBuzz::Map.define_finalizer(self, @ptr)
+    end
+
+    # Returns the singleton empty map
+    # @return [Map]
+    def self.empty
+      wrap_borrowed(C.hb_map_get_empty)
+    end
+
+    # @return [Integer] Number of entries
+    def size
+      C.hb_map_get_population(@ptr)
+    end
+
+    alias length size
+
+    # @return [Boolean] true if empty
+    def empty?
+      C.from_hb_bool(C.hb_map_is_empty(@ptr))
+    end
+
+    # @param key [Integer] Key
+    # @return [Boolean] true if key exists
+    def has_key?(key)
+      C.from_hb_bool(C.hb_map_has(@ptr, key))
+    end
+
+    alias include? has_key?
+    alias key? has_key?
+
+    # @param key [Integer] Key
+    # @return [Integer] Value (HB_MAP_VALUE_INVALID if not found)
+    def [](key)
+      val = C.hb_map_get(@ptr, key)
+      val == HB_MAP_VALUE_INVALID ? nil : val
+    end
+
+    # @param key [Integer] Key
+    # @param value [Integer] Value
+    def []=(key, value)
+      C.hb_map_set(@ptr, key, value)
+    end
+
+    # Deletes a key
+    # @param key [Integer] Key to delete
+    def delete(key)
+      C.hb_map_del(@ptr, key)
+    end
+
+    # Clears all entries
+    # @return [self]
+    def clear
+      C.hb_map_clear(@ptr)
+      self
+    end
+
+    # @param other [Map] Map to compare
+    # @return [Boolean] true if equal
+    def ==(other)
+      return false unless other.is_a?(Map)
+
+      C.from_hb_bool(C.hb_map_is_equal(@ptr, other.ptr))
+    end
+
+    # @return [Integer] Hash of this map
+    def hash
+      C.hb_map_hash(@ptr)
+    end
+
+    # Copies entries from another map into this one
+    # @param other [Map] Source map
+    # @return [self]
+    def update(other)
+      C.hb_map_update(@ptr, other.ptr)
+      self
+    end
+
+    alias merge! update
+
+    # @return [Boolean] true if the last allocation was successful
+    def allocation_successful?
+      C.from_hb_bool(C.hb_map_allocation_successful(@ptr))
+    end
+
+    # @return [Set] Set of all keys
+    def keys
+      set = Set.new
+      C.hb_map_keys(@ptr, set.ptr)
+      set
+    end
+
+    # @return [Set] Set of all values
+    def values
+      set = Set.new
+      C.hb_map_values(@ptr, set.ptr)
+      set
+    end
+
+    # Iterates over key-value pairs
+    # @yield [key, value]
+    # @return [Enumerator] if no block given
+    def each
+      return to_enum(:each) unless block_given?
+
+      idx_ptr = FFI::MemoryPointer.new(:int)
+      idx_ptr.write_int(-1)
+      key_ptr = FFI::MemoryPointer.new(:uint32)
+      val_ptr = FFI::MemoryPointer.new(:uint32)
+
+      while C.from_hb_bool(C.hb_map_next(@ptr, idx_ptr, key_ptr, val_ptr))
+        yield key_ptr.read_uint32, val_ptr.read_uint32
+      end
+      self
+    end
+
+    def inspect
+      "#<HarfBuzz::Map size=#{size}>"
+    end
+
+    def self.wrap_owned(ptr)
+      obj = allocate
+      obj.instance_variable_set(:@ptr, ptr)
+      define_finalizer(obj, ptr)
+      obj
+    end
+
+    def self.wrap_borrowed(ptr)
+      obj = allocate
+      obj.instance_variable_set(:@ptr, ptr)
+      obj.instance_variable_set(:@borrowed, true)
+      obj
+    end
+
+    def self.define_finalizer(obj, ptr)
+      destroy = C.method(:hb_map_destroy)
+      ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+    end
+  end
+end

data/lib/harfbuzz/ot/color.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Color Fonts API (CPAL, COLR, SVG, CBDT/CBLC)
+    module Color
+      module_function
+
+      # @param face [Face] Font face
+      # @return [Boolean] true if the face has CPAL color palettes
+      def has_palettes?(face)
+        C.from_hb_bool(C.hb_ot_color_has_palettes(face.ptr))
+      end
+
+      # @param face [Face] Font face
+      # @return [Integer] Number of palettes
+      def palette_count(face)
+        C.hb_ot_color_palette_get_count(face.ptr)
+      end
+
+      # @param face [Face] Font face
+      # @param idx [Integer] Palette index
+      # @return [Integer] Name ID
+      def palette_name_id(face, idx)
+        C.hb_ot_color_palette_get_name_id(face.ptr, idx)
+      end
+
+      # @param face [Face] Font face
+      # @param idx [Integer] Color index within palette
+      # @return [Integer] Name ID
+      def palette_color_name_id(face, idx)
+        C.hb_ot_color_palette_color_get_name_id(face.ptr, idx)
+      end
+
+      # @param face [Face] Font face
+      # @param idx [Integer] Palette index
+      # @return [Integer] Palette flags bitmask
+      def palette_flags(face, idx)
+        C.hb_ot_color_palette_get_flags(face.ptr, idx)
+      end
+
+      # Returns colors in a palette
+      # @param face [Face] Font face
+      # @param idx [Integer] Palette index
+      # @return [Array<Integer>] Array of RGBA color values
+      def palette_colors(face, idx)
+        count_ptr = FFI::MemoryPointer.new(:uint)
+        count_ptr.write_uint(0)
+        C.hb_ot_color_palette_get_colors(face.ptr, idx, 0, count_ptr, nil)
+        count = count_ptr.read_uint
+        return [] if count.zero?
+
+        colors_ptr = FFI::MemoryPointer.new(:uint32, count)
+        count_ptr.write_uint(count)
+        C.hb_ot_color_palette_get_colors(face.ptr, idx, 0, count_ptr, colors_ptr)
+        colors_ptr.read_array_of_uint32(count_ptr.read_uint)
+      end
+
+      # @param face [Face] Font face
+      # @return [Boolean] true if face has COLR layers
+      def has_layers?(face)
+        C.from_hb_bool(C.hb_ot_color_has_layers(face.ptr))
+      end
+
+      # Returns COLR layers for a glyph
+      # @param face [Face] Font face
+      # @param glyph [Integer] Glyph ID
+      # @return [Array<C::HbOtColorLayerT>] Layer array
+      def glyph_layers(face, glyph)
+        count_ptr = FFI::MemoryPointer.new(:uint)
+        count_ptr.write_uint(0)
+        C.hb_ot_color_glyph_get_layers(face.ptr, glyph, 0, count_ptr, nil)
+        count = count_ptr.read_uint
+        return [] if count.zero?
+
+        layers_ptr = FFI::MemoryPointer.new(C::HbOtColorLayerT, count)
+        count_ptr.write_uint(count)
+        C.hb_ot_color_glyph_get_layers(face.ptr, glyph, 0, count_ptr, layers_ptr)
+        actual = count_ptr.read_uint
+        actual.times.map { |i| C::HbOtColorLayerT.new(layers_ptr + i * C::HbOtColorLayerT.size) }
+      end
+
+      # @param face [Face] Font face
+      # @return [Boolean] true if face has SVG glyphs
+      def has_svg?(face)
+        C.from_hb_bool(C.hb_ot_color_has_svg(face.ptr))
+      end
+
+      # Returns the SVG blob for a glyph
+      # @param face [Face] Font face
+      # @param glyph [Integer] Glyph ID
+      # @return [Blob] SVG data blob
+      def glyph_svg(face, glyph)
+        Blob.wrap_owned(C.hb_ot_color_glyph_reference_svg(face.ptr, glyph))
+      end
+
+      # @param face [Face] Font face
+      # @return [Boolean] true if face has PNG glyphs
+      def has_png?(face)
+        C.from_hb_bool(C.hb_ot_color_has_png(face.ptr))
+      end
+
+      # Returns the PNG blob for a glyph at a given size
+      # @param font [Font] Sized font
+      # @param glyph [Integer] Glyph ID
+      # @return [Blob] PNG data blob
+      def glyph_png(font, glyph)
+        Blob.wrap_owned(C.hb_ot_color_glyph_reference_png(font.ptr, glyph))
+      end
+
+      # @param face [Face] Font face
+      # @return [Boolean] true if face has COLRv1 paint data
+      def has_paint?(face)
+        C.from_hb_bool(C.hb_ot_color_has_paint(face.ptr))
+      end
+
+      # @param face [Face] Font face
+      # @param glyph [Integer] Glyph ID
+      # @return [Boolean] true if glyph has COLRv1 paint data
+      def glyph_has_paint?(face, glyph)
+        C.from_hb_bool(C.hb_ot_color_glyph_has_paint(face.ptr, glyph))
+      end
+    end
+  end
+end

data/lib/harfbuzz/ot/font.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  module OT
+    # OpenType Font functions
+    module Font
+      module_function
+
+      # Sets OpenType font functions on a font
+      # @param font [HarfBuzz::Font] Font to configure
+      def set_funcs(font)
+        C.hb_ot_font_set_funcs(font.ptr)
+      end
+    end
+  end
+end