harfbuzz-ruby 1.0.0

data/lib/harfbuzz/set.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_set_t — a set of Unicode codepoints or glyph IDs
+  #
+  # Includes Enumerable for Ruby-friendly iteration.
+  class Set
+    include Enumerable
+
+    HB_SET_VALUE_INVALID = C::HB_SET_VALUE_INVALID
+
+    attr_reader :ptr
+
+    def initialize
+      @ptr = C.hb_set_create
+      raise AllocationError, "Failed to create set" if @ptr.null?
+
+      HarfBuzz::Set.define_finalizer(self, @ptr)
+    end
+
+    # Returns the singleton empty set
+    # @return [Set]
+    def self.empty
+      wrap_borrowed(C.hb_set_get_empty)
+    end
+
+    # @return [Integer] Number of elements
+    def size
+      C.hb_set_get_population(@ptr)
+    end
+
+    alias length size
+
+    # @return [Boolean] true if empty
+    def empty?
+      C.from_hb_bool(C.hb_set_is_empty(@ptr))
+    end
+
+    # @param value [Integer] Codepoint to check
+    # @return [Boolean] true if value is in the set
+    def include?(value)
+      C.from_hb_bool(C.hb_set_has(@ptr, value))
+    end
+
+    alias member? include?
+
+    # Adds a value to the set
+    # @param value [Integer] Codepoint to add
+    # @return [self]
+    def add(value)
+      C.hb_set_add(@ptr, value)
+      self
+    end
+
+    alias << add
+
+    # Adds a range of values (inclusive)
+    # @param first [Integer] First codepoint
+    # @param last [Integer] Last codepoint
+    # @return [self]
+    def add_range(first, last)
+      C.hb_set_add_range(@ptr, first, last)
+      self
+    end
+
+    # Adds a sorted array of codepoints
+    # @param arr [Array<Integer>] Sorted array of codepoints
+    # @return [self]
+    def add_sorted_array(arr)
+      mem = FFI::MemoryPointer.new(:uint32, arr.size)
+      mem.put_array_of_uint32(0, arr)
+      C.hb_set_add_sorted_array(@ptr, mem, arr.size)
+      self
+    end
+
+    # Removes a value
+    # @param value [Integer] Codepoint to remove
+    # @return [self]
+    def delete(value)
+      C.hb_set_del(@ptr, value)
+      self
+    end
+
+    # Removes a range of values (inclusive)
+    # @param first [Integer] First codepoint
+    # @param last [Integer] Last codepoint
+    # @return [self]
+    def delete_range(first, last)
+      C.hb_set_del_range(@ptr, first, last)
+      self
+    end
+
+    # Clears all values
+    # @return [self]
+    def clear
+      C.hb_set_clear(@ptr)
+      self
+    end
+
+    # @param other [Set] Set to compare
+    # @return [Boolean] true if equal
+    def ==(other)
+      return false unless other.is_a?(Set)
+
+      C.from_hb_bool(C.hb_set_is_equal(@ptr, other.ptr))
+    end
+
+    # @return [Integer] Hash of this set
+    def hash
+      C.hb_set_hash(@ptr)
+    end
+
+    # @param other [Set] Potential superset
+    # @return [Boolean] true if self is a subset of other
+    def subset?(other)
+      C.from_hb_bool(C.hb_set_is_subset(@ptr, other.ptr))
+    end
+
+    # Replaces contents with another set
+    # @param other [Set] Source set
+    # @return [self]
+    def replace(other)
+      C.hb_set_set(@ptr, other.ptr)
+      self
+    end
+
+    # Adds all elements from another set (in-place union)
+    # @param other [Set] Set to union with
+    # @return [self]
+    def union(other)
+      result = dup_set
+      C.hb_set_union(result.ptr, other.ptr)
+      result
+    end
+
+    alias | union
+
+    # Removes all elements not in another set (in-place intersection)
+    # @param other [Set] Set to intersect with
+    # @return [self]
+    def intersect(other)
+      result = dup_set
+      C.hb_set_intersect(result.ptr, other.ptr)
+      result
+    end
+
+    alias & intersect
+
+    # Removes all elements that are in another set (in-place subtraction)
+    # @param other [Set] Set to subtract
+    # @return [self]
+    def subtract(other)
+      result = dup_set
+      C.hb_set_subtract(result.ptr, other.ptr)
+      result
+    end
+
+    alias - subtract
+
+    # Symmetric difference (elements in either but not both)
+    # @param other [Set] Other set
+    # @return [Set] New set
+    def symmetric_difference(other)
+      result = dup_set
+      C.hb_set_symmetric_difference(result.ptr, other.ptr)
+      result
+    end
+
+    alias ^ symmetric_difference
+
+    # Inverts the set (complements it)
+    # @return [self]
+    def invert!
+      C.hb_set_invert(@ptr)
+      self
+    end
+
+    # @return [Integer, nil] Minimum value or nil if empty
+    def min
+      val = C.hb_set_get_min(@ptr)
+      val == HB_SET_VALUE_INVALID ? nil : val
+    end
+
+    # @return [Integer, nil] Maximum value or nil if empty
+    def max
+      val = C.hb_set_get_max(@ptr)
+      val == HB_SET_VALUE_INVALID ? nil : val
+    end
+
+    # Iterates over all values in ascending order
+    # @yield [value]
+    # @return [Enumerator] if no block given
+    def each
+      return to_enum(:each) unless block_given?
+
+      cp_ptr = FFI::MemoryPointer.new(:uint32)
+      cp_ptr.write_uint32(HB_SET_VALUE_INVALID)
+      yield cp_ptr.read_uint32 while C.from_hb_bool(C.hb_set_next(@ptr, cp_ptr))
+      self
+    end
+
+    # Iterates over contiguous ranges in ascending order
+    # @yield [first, last] First and last value of each range (inclusive)
+    # @return [Enumerator] if no block given
+    def each_range
+      return to_enum(:each_range) unless block_given?
+
+      first_ptr = FFI::MemoryPointer.new(:uint32)
+      last_ptr  = FFI::MemoryPointer.new(:uint32)
+      first_ptr.write_uint32(HB_SET_VALUE_INVALID)
+      last_ptr.write_uint32(HB_SET_VALUE_INVALID)
+      while C.from_hb_bool(C.hb_set_next_range(@ptr, first_ptr, last_ptr))
+        yield first_ptr.read_uint32, last_ptr.read_uint32
+      end
+      self
+    end
+
+    # Iterates over all values in descending order
+    # @yield [value]
+    # @return [Enumerator] if no block given
+    def reverse_each
+      return to_enum(:reverse_each) unless block_given?
+
+      cp_ptr = FFI::MemoryPointer.new(:uint32)
+      cp_ptr.write_uint32(HB_SET_VALUE_INVALID)
+      yield cp_ptr.read_uint32 while C.from_hb_bool(C.hb_set_previous(@ptr, cp_ptr))
+      self
+    end
+
+    # Bulk-retrieves all values as an array
+    # @return [Array<Integer>]
+    def to_a
+      return [] if empty?
+
+      count = size
+      buf = FFI::MemoryPointer.new(:uint32, count)
+      actual = C.hb_set_next_many(@ptr, HB_SET_VALUE_INVALID, buf, count)
+      buf.read_array_of_uint32(actual)
+    end
+
+    def inspect
+      "#<HarfBuzz::Set 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_set_destroy)
+      ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+    end
+
+    private
+
+    def dup_set
+      new_set = self.class.new
+      C.hb_set_set(new_set.ptr, @ptr)
+      new_set
+    end
+  end
+end

data/lib/harfbuzz/shape_plan.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Wraps hb_shape_plan_t — a cached shaping plan for repeated shaping
+  class ShapePlan
+    attr_reader :ptr
+
+    # Creates a new ShapePlan for the given face and properties
+    # @param face [Face] Font face
+    # @param props [C::HbSegmentPropertiesT] Segment properties
+    # @param features [Array<Feature>] Features
+    # @param shapers [Array<String>, nil] Shaper list
+    # @param coords [Array<Integer>, nil] Normalized variation coordinates (nil = none)
+    # @return [ShapePlan]
+    def self.new(face, props, features = [], shapers: nil, coords: nil)
+      features_ptr = HarfBuzz.send(:build_features_ptr, features)
+      shapers_ptr = build_shapers_ptr(shapers)
+      if coords
+        coords_ptr = FFI::MemoryPointer.new(:int32, coords.size)
+        coords_ptr.put_array_of_int32(0, coords)
+        ptr = C.hb_shape_plan_create2(
+          face.ptr, props, features_ptr, features.size,
+          shapers_ptr, coords.size, coords_ptr
+        )
+      else
+        ptr = C.hb_shape_plan_create(
+          face.ptr, props, features_ptr, features.size, shapers_ptr
+        )
+      end
+      wrap_owned(ptr)
+    end
+
+    # Creates (or retrieves from cache) a ShapePlan
+    # @param face [Face] Font face
+    # @param props [C::HbSegmentPropertiesT] Segment properties
+    # @param features [Array<Feature>] Features
+    # @param shapers [Array<String>, nil] Shaper list
+    # @param coords [Array<Integer>, nil] Normalized variation coordinates (nil = none)
+    # @return [ShapePlan]
+    def self.cached(face, props, features = [], shapers: nil, coords: nil)
+      features_ptr = HarfBuzz.send(:build_features_ptr, features)
+      shapers_ptr = build_shapers_ptr(shapers)
+      if coords
+        coords_ptr = FFI::MemoryPointer.new(:int32, coords.size)
+        coords_ptr.put_array_of_int32(0, coords)
+        ptr = C.hb_shape_plan_create_cached2(
+          face.ptr, props, features_ptr, features.size,
+          shapers_ptr, coords.size, coords_ptr
+        )
+      else
+        ptr = C.hb_shape_plan_create_cached(
+          face.ptr, props, features_ptr, features.size, shapers_ptr
+        )
+      end
+      wrap_owned(ptr)
+    end
+
+    # Returns the singleton empty shape plan
+    # @return [ShapePlan]
+    def self.empty
+      wrap_borrowed(C.hb_shape_plan_get_empty)
+    end
+
+    # Executes the shape plan
+    # @param font [Font] Font to use
+    # @param buffer [Buffer] Buffer to shape
+    # @param features [Array<Feature>] Features
+    # @return [Boolean] Success
+    def execute(font, buffer, features = [])
+      features_ptr = HarfBuzz.send(:build_features_ptr, features)
+      C.from_hb_bool(
+        C.hb_shape_plan_execute(@ptr, font.ptr, buffer.ptr, features_ptr, features.size)
+      )
+    end
+
+    # @return [String] Name of the shaper used
+    def shaper
+      C.hb_shape_plan_get_shaper(@ptr)
+    end
+
+    def inspect
+      "#<HarfBuzz::ShapePlan shaper=#{shaper.inspect}>"
+    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_shape_plan_destroy)
+      ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+    end
+
+    def self.build_shapers_ptr(shapers)
+      return FFI::Pointer::NULL unless shapers
+
+      ptrs = shapers.map { |s| FFI::MemoryPointer.from_string(s) }
+      ptrs << FFI::Pointer::NULL
+      arr = FFI::MemoryPointer.new(:pointer, ptrs.size)
+      ptrs.each_with_index { |p, i| arr[i].put_pointer(0, p) }
+      arr
+    end
+    private_class_method :build_shapers_ptr
+  end
+end

data/lib/harfbuzz/shaping_result.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Value object returned by HarfBuzz.shape_text — provides convenient access
+  # to shaped glyphs, positions, and rendering helpers.
+  class ShapingResult
+    include Enumerable
+
+    attr_reader :buffer, :font
+
+    # @param buffer [Buffer] Shaped buffer
+    # @param font [Font] Font used for shaping
+    def initialize(buffer:, font:)
+      @buffer = buffer
+      @font = font
+      @glyph_infos = buffer.glyph_infos
+      @glyph_positions = buffer.glyph_positions
+    end
+
+    # @return [Array<GlyphInfo>] Glyph info array
+    def glyph_infos
+      @glyph_infos
+    end
+
+    # @return [Array<GlyphPosition>] Glyph position array
+    def glyph_positions
+      @glyph_positions
+    end
+
+    # Iterates over [GlyphInfo, GlyphPosition] pairs
+    def each
+      @glyph_infos.zip(@glyph_positions).each { |info, pos| yield info, pos }
+    end
+
+    # @return [Integer] Number of glyphs
+    def length
+      @glyph_infos.length
+    end
+
+    alias size length
+
+    # Returns the total advance as [x_advance, y_advance]
+    # @return [Array<Integer>]
+    def total_advance
+      @glyph_positions.inject([0, 0]) do |(x, y), pos|
+        [x + pos.x_advance, y + pos.y_advance]
+      end
+    end
+
+    # Generates an SVG path string for all glyphs at their shaped positions
+    # @return [String] SVG path data
+    def to_svg_path
+      paths = []
+      cx = 0
+      cy = 0
+      each do |info, pos|
+        glyph_path = extract_glyph_path(info.glyph_id)
+        ox = cx + pos.x_offset
+        oy = cy + pos.y_offset
+        paths << translate_path(glyph_path, ox, oy) unless glyph_path.empty?
+        cx += pos.x_advance
+        cy += pos.y_advance
+      end
+      paths.join(" ")
+    end
+
+    def inspect
+      "#<HarfBuzz::ShapingResult length=#{length} total_advance=#{total_advance.inspect}>"
+    end
+
+    private
+
+    def extract_glyph_path(glyph_id)
+      segments = []
+      draw = DrawFuncs.new
+      draw.on_move_to    { |x, y| segments << "M#{x},#{y}" }
+      draw.on_line_to    { |x, y| segments << "L#{x},#{y}" }
+      draw.on_quadratic_to { |cx, cy, x, y| segments << "Q#{cx},#{cy},#{x},#{y}" }
+      draw.on_cubic_to   { |c1x, c1y, c2x, c2y, x, y|
+        segments << "C#{c1x},#{c1y},#{c2x},#{c2y},#{x},#{y}"
+      }
+      draw.on_close_path { segments << "Z" }
+      draw.make_immutable!
+      @font.draw_glyph(glyph_id, draw)
+      segments.join
+    end
+
+    def translate_path(path, ox, oy)
+      return path if ox.zero? && oy.zero?
+
+      "translate(#{ox},#{oy}) #{path}"
+    end
+  end
+end

data/lib/harfbuzz/subset.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module HarfBuzz
+  # Font subsetting API (requires libharfbuzz-subset)
+  module Subset
+    # @return [Boolean] true if libharfbuzz-subset is available
+    def self.available?
+      C.available?
+    end
+
+    # Subsets a font face using the given input specification
+    # @param face [HarfBuzz::Face] Source font face
+    # @param input [Input] Subset input specification
+    # @return [HarfBuzz::Face] Subsetted face
+    # @raise [UnavailableError] If subset library is not available
+    # @raise [SubsetError] If subsetting fails
+    def self.subset(face, input)
+      raise UnavailableError, "libharfbuzz-subset is not available" unless available?
+
+      ptr = C.hb_subset_or_fail(face.ptr, input.ptr)
+      raise SubsetError, "Subsetting failed" if ptr.null?
+
+      HarfBuzz::Face.wrap_owned(ptr)
+    end
+
+    # Wraps hb_subset_input_t — specifies what to include in a subset
+    class Input
+      attr_reader :ptr
+
+      # Creates a new subset input
+      # @raise [UnavailableError] If subset library is not available
+      # @raise [AllocationError] If allocation fails
+      def initialize
+        raise UnavailableError, "libharfbuzz-subset is not available" unless C.available?
+
+        @ptr = C.hb_subset_input_create_or_fail
+        raise AllocationError, "Failed to create subset input" if @ptr.null?
+
+        HarfBuzz::Subset::Input.define_finalizer(self, @ptr)
+      end
+
+      # Returns the set of Unicode codepoints to include (borrowed reference)
+      # @return [HarfBuzz::Set] Unicode set (do not destroy separately)
+      def unicode_set
+        HarfBuzz::Set.wrap_borrowed(C.hb_subset_input_unicode_set(@ptr))
+      end
+
+      # Returns the set of glyph IDs to include (borrowed reference)
+      # @return [HarfBuzz::Set] Glyph set (do not destroy separately)
+      def glyph_set
+        HarfBuzz::Set.wrap_borrowed(C.hb_subset_input_glyph_set(@ptr))
+      end
+
+      # @return [Integer] Current flags bitmask
+      def flags
+        C.hb_subset_input_get_flags(@ptr)
+      end
+
+      # @param flags [Integer] New flags bitmask
+      def flags=(flags)
+        C.hb_subset_input_set_flags(@ptr, flags)
+      end
+
+      def inspect
+        "#<HarfBuzz::Subset::Input flags=#{flags}>"
+      end
+
+      def self.define_finalizer(obj, ptr)
+        destroy = C.method(:hb_subset_input_destroy)
+        ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+      end
+    end
+
+    # Wraps hb_subset_plan_t — a more fine-grained subsetting plan
+    class Plan
+      attr_reader :ptr
+
+      # Creates a subset plan for a face using the given input
+      # @param face [HarfBuzz::Face] Source font face
+      # @param input [Input] Subset input specification
+      # @raise [UnavailableError] If subset library is not available
+      # @raise [SubsetError] If plan creation fails
+      def initialize(face, input)
+        raise UnavailableError, "libharfbuzz-subset is not available" unless C.available?
+
+        @ptr = C.hb_subset_plan_create_or_fail(face.ptr, input.ptr)
+        raise SubsetError, "Failed to create subset plan" if @ptr.null?
+
+        HarfBuzz::Subset::Plan.define_finalizer(self, @ptr)
+      end
+
+      # Executes the plan and returns the subsetted face
+      # @return [HarfBuzz::Face] Subsetted face
+      # @raise [SubsetError] If execution fails
+      def execute
+        ptr = C.hb_subset_plan_execute_or_fail(@ptr)
+        raise SubsetError, "Subset plan execution failed" if ptr.null?
+
+        HarfBuzz::Face.wrap_owned(ptr)
+      end
+
+      # Returns the old→new glyph ID mapping (borrowed)
+      # @return [HarfBuzz::Map]
+      def old_to_new_glyph_mapping
+        HarfBuzz::Map.wrap_borrowed(C.hb_subset_plan_old_to_new_glyph_mapping(@ptr))
+      end
+
+      # Returns the new→old glyph ID mapping (borrowed)
+      # @return [HarfBuzz::Map]
+      def new_to_old_glyph_mapping
+        HarfBuzz::Map.wrap_borrowed(C.hb_subset_plan_new_to_old_glyph_mapping(@ptr))
+      end
+
+      # Returns the unicode→old glyph ID mapping (borrowed)
+      # @return [HarfBuzz::Map]
+      def unicode_to_old_glyph_mapping
+        HarfBuzz::Map.wrap_borrowed(C.hb_subset_plan_unicode_to_old_glyph_mapping(@ptr))
+      end
+
+      def inspect
+        "#<HarfBuzz::Subset::Plan>"
+      end
+
+      def self.define_finalizer(obj, ptr)
+        destroy = C.method(:hb_subset_plan_destroy)
+        ObjectSpace.define_finalizer(obj, proc { destroy.call(ptr) })
+      end
+    end
+  end
+end