fontisan 0.2.0 → 0.2.2

data/lib/fontisan/pipeline/variation_resolver.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "strategies/base_strategy"
+require_relative "strategies/preserve_strategy"
+require_relative "strategies/instance_strategy"
+require_relative "strategies/named_strategy"
+
+module Fontisan
+  module Pipeline
+    # Resolves variation data using strategy pattern
+    #
+    # This class orchestrates variation resolution during font conversion by
+    # selecting and executing the appropriate strategy based on user intent.
+    # It follows the Strategy pattern to allow different approaches to handling
+    # variable font data.
+    #
+    # Three strategies are available:
+    # - PreserveStrategy: Keep variation data intact (for compatible formats)
+    # - InstanceStrategy: Generate static instance at coordinates
+    # - NamedStrategy: Use named instance from fvar table
+    #
+    # Strategy selection is explicit through the :strategy option. Each strategy
+    # has its own required and optional parameters.
+    #
+    # @example Preserve variation data
+    #   resolver = VariationResolver.new(font, strategy: :preserve)
+    #   tables = resolver.resolve
+    #
+    # @example Generate instance at coordinates
+    #   resolver = VariationResolver.new(
+    #     font,
+    #     strategy: :instance,
+    #     coordinates: { "wght" => 700.0 }
+    #   )
+    #   tables = resolver.resolve
+    #
+    # @example Use named instance
+    #   resolver = VariationResolver.new(
+    #     font,
+    #     strategy: :named,
+    #     instance_index: 0
+    #   )
+    #   tables = resolver.resolve
+    class VariationResolver
+      # @return [TrueTypeFont, OpenTypeFont] Font to process
+      attr_reader :font
+
+      # @return [Strategies::BaseStrategy] Selected strategy
+      attr_reader :strategy
+
+      # Initialize resolver with font and strategy
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to process
+      # @param options [Hash] Resolution options
+      # @option options [Symbol] :strategy Strategy to use (:preserve, :instance, :named)
+      # @option options [Hash] :coordinates Design space coordinates (for :instance)
+      # @option options [Integer] :instance_index Named instance index (for :named)
+      # @raise [ArgumentError] If strategy is missing or invalid
+      def initialize(font, options = {})
+        @font = font
+
+        strategy_type = options[:strategy]
+        raise ArgumentError, "strategy is required" unless strategy_type
+
+        @strategy = build_strategy(strategy_type, options)
+
+        # Validate strategy-specific requirements
+        validate_strategy_requirements(strategy_type, options)
+      end
+
+      # Resolve variation data
+      #
+      # Delegates to the selected strategy to process the font and return
+      # the appropriate tables.
+      #
+      # @return [Hash<String, String>] Font tables after resolution
+      def resolve
+        @strategy.resolve(@font)
+      end
+
+      # Check if resolution preserves variation data
+      #
+      # @return [Boolean] True if variation is preserved
+      def preserves_variation?
+        @strategy.preserves_variation?
+      end
+
+      # Get strategy name
+      #
+      # @return [Symbol] Strategy identifier
+      def strategy_name
+        @strategy.strategy_name
+      end
+
+      private
+
+      # Build strategy instance based on type
+      #
+      # @param type [Symbol] Strategy type (:preserve, :instance, :named)
+      # @param options [Hash] Strategy options
+      # @return [Strategies::BaseStrategy] Strategy instance
+      # @raise [ArgumentError] If strategy type is unknown
+      def build_strategy(type, options)
+        case type
+        when :preserve
+          Strategies::PreserveStrategy.new(options)
+        when :instance
+          Strategies::InstanceStrategy.new(options)
+        when :named
+          Strategies::NamedStrategy.new(options)
+        else
+          raise ArgumentError,
+                "Unknown strategy: #{type}. " \
+                "Valid strategies: :preserve, :instance, :named"
+        end
+      end
+
+      # Validate strategy-specific requirements
+      #
+      # @param type [Symbol] Strategy type
+      # @param options [Hash] Strategy options
+      # @raise [ArgumentError, InvalidCoordinatesError] If validation fails
+      def validate_strategy_requirements(type, options)
+        case type
+        when :instance
+          validate_instance_coordinates(options[:coordinates]) if options[:coordinates]
+        when :named
+          validate_named_instance_index(options[:instance_index]) if options[:instance_index]
+        end
+      end
+
+      # Validate coordinates for instance strategy
+      #
+      # @param coordinates [Hash] Coordinates to validate
+      # @raise [InvalidCoordinatesError] If coordinates invalid
+      def validate_instance_coordinates(coordinates)
+        return if coordinates.empty?
+
+        require_relative "../variation/variation_context"
+        context = Variation::VariationContext.new(@font)
+        context.validate_coordinates(coordinates)
+      end
+
+      # Validate instance index for named strategy
+      #
+      # @param instance_index [Integer] Instance index to validate
+      # @raise [ArgumentError] If index invalid
+      def validate_named_instance_index(instance_index)
+        require_relative "../variation/variation_context"
+        context = Variation::VariationContext.new(@font)
+
+        unless context.fvar
+          raise ArgumentError, "Font is not a variable font (no fvar table)"
+        end
+
+        instances = context.fvar.instances
+        if instance_index.negative? || instance_index >= instances.length
+          raise ArgumentError,
+                "Invalid instance index #{instance_index}. " \
+                "Font has #{instances.length} named instances."
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_subsetter.rb

@@ -122,11 +122,11 @@ module Fontisan
         data = table.to_binary_s.dup
 
         # Calculate new numberOfHMetrics
-        new_num_h_metrics = if hmtx && hmtx.h_metrics
-                             hmtx.h_metrics.size
-                           else
-                             calculate_number_of_h_metrics
-                           end
+        new_num_h_metrics = if hmtx&.h_metrics
+                              hmtx.h_metrics.size
+                            else
+                              calculate_number_of_h_metrics
+                            end
 
         # Update numberOfHMetrics field (at offset 34, uint16)
         data[34, 2] = [new_num_h_metrics].pack("n")

data/lib/fontisan/tables/cff/charstring.rb

@@ -239,6 +239,11 @@ module Fontisan
             # 3-byte signed integer (16-bit)
             b1 = io.getbyte
             b2 = io.getbyte
+            if b1.nil? || b2.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading shortint"
+            end
+
             value = (b1 << 8) | b2
             value > 0x7FFF ? value - 0x10000 : value
           when 32..246
@@ -247,14 +252,29 @@ module Fontisan
           when 247..250
             # Positive 2-byte integer: +108 to +1131
             b2 = io.getbyte
+            if b2.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading positive integer"
+            end
+
             (byte - 247) * 256 + b2 + 108
           when 251..254
             # Negative 2-byte integer: -108 to -1131
             b2 = io.getbyte
+            if b2.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading negative integer"
+            end
+
             -(byte - 251) * 256 - b2 - 108
           when 255
             # 5-byte signed integer (32-bit) as fixed-point 16.16
             bytes = io.read(4)
+            if bytes.nil? || bytes.length < 4
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading fixed-point"
+            end
+
             value = bytes.unpack1("l>") # Signed 32-bit big-endian
             value / 65536.0 # Convert to float
           else
@@ -360,6 +380,8 @@ module Fontisan
           # rmoveto takes 2 operands, so if stack has 3 and width not parsed,
           # first is width
           parse_width_for_operator(width_parsed, 2)
+          return if @stack.size < 2 # Need at least 2 values
+
           dy = @stack.pop
           dx = @stack.pop
           @x += dx
@@ -374,6 +396,8 @@ module Fontisan
           # hmoveto takes 1 operand, so if stack has 2 and width not parsed,
           # first is width
           parse_width_for_operator(width_parsed, 1)
+          return if @stack.empty? # Need at least 1 value
+
           dx = @stack.pop || 0
           @x += dx
           @path << { type: :move_to, x: @x, y: @y }
@@ -386,6 +410,8 @@ module Fontisan
           # vmoveto takes 1 operand, so if stack has 2 and width not parsed,
           # first is width
           parse_width_for_operator(width_parsed, 1)
+          return if @stack.empty? # Need at least 1 value
+
           dy = @stack.pop || 0
           @y += dy
           @path << { type: :move_to, x: @x, y: @y }
@@ -773,7 +799,12 @@ module Fontisan
 
         # Call local subroutine
         def callsubr
-          subr_index = @stack.pop + @subroutine_bias
+          return if @stack.empty?
+
+          subr_num = @stack.pop
+          return unless subr_num # Guard against empty stack
+
+          subr_index = subr_num + @subroutine_bias
           if @local_subrs && subr_index >= 0 && subr_index < @local_subrs.count
             subr_data = @local_subrs[subr_index]
             execute_subroutine(subr_data)
@@ -782,7 +813,12 @@ module Fontisan
 
         # Call global subroutine
         def callgsubr
-          subr_index = @stack.pop + @global_subroutine_bias
+          return if @stack.empty?
+
+          subr_num = @stack.pop
+          return unless subr_num # Guard against empty stack
+
+          subr_index = subr_num + @global_subroutine_bias
           if subr_index >= 0 && subr_index < @global_subrs.count
             subr_data = @global_subrs[subr_index]
             execute_subroutine(subr_data)
@@ -818,39 +854,58 @@ module Fontisan
 
         # Arithmetic operators
         def arithmetic_add
+          return if @stack.size < 2
+
           b = @stack.pop
           a = @stack.pop
           @stack << (a + b)
         end
 
         def arithmetic_sub
+          return if @stack.size < 2
+
           b = @stack.pop
           a = @stack.pop
           @stack << (a - b)
         end
 
         def arithmetic_mul
+          return if @stack.size < 2
+
           b = @stack.pop
           a = @stack.pop
           @stack << (a * b)
         end
 
         def arithmetic_div
+          return if @stack.size < 2
+
           b = @stack.pop
           a = @stack.pop
+          return if b.zero?
+
           @stack << (a / b.to_f)
         end
 
         def arithmetic_neg
+          return if @stack.empty?
+
           @stack << -@stack.pop
         end
 
         def arithmetic_abs
+          return if @stack.empty?
+
           @stack << @stack.pop.abs
         end
 
         def arithmetic_sqrt
-          @stack << Math.sqrt(@stack.pop)
+          return if @stack.empty?
+
+          val = @stack.pop
+          return if val.negative?
+
+          @stack << Math.sqrt(val)
         end
 
         # Parse width for a specific operator

data/lib/fontisan/tables/cff/charstring_builder.rb

@@ -118,6 +118,40 @@ module Fontisan
           @output.string
         end
 
+        # Build a CharString from operation list
+        #
+        # This method takes operations from CharStringParser and encodes them
+        # back to binary CharString format. Useful for CharString modification.
+        #
+        # @param operations [Array<Hash>] Array of operation hashes from parser
+        # @return [String] Binary CharString data
+        def self.build_from_operations(operations)
+          new.build_from_operations(operations)
+        end
+
+        # Instance method for building from operations
+        #
+        # @param operations [Array<Hash>] Array of operation hashes
+        # @return [String] Binary CharString data
+        def build_from_operations(operations)
+          @output = StringIO.new("".b)
+
+          operations.each do |op|
+            # Write operands
+            op[:operands].each { |operand| write_number(operand) }
+
+            # Write operator
+            write_operator(op[:name])
+
+            # Write hint data if present (for hintmask/cntrmask)
+            if op[:hint_data]
+              @output.write(op[:hint_data])
+            end
+          end
+
+          @output.string
+        end
+
         # Build an empty CharString (for .notdef or empty glyphs)
         #
         # @param width [Integer, nil] Glyph width

data/lib/fontisan/tables/cff/charstring_parser.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff
+      # CharString parser that converts binary CharString data to operation list
+      #
+      # Unlike [`CharString`](lib/fontisan/tables/cff/charstring.rb) which
+      # interprets and executes CharStrings for rendering, CharStringParser
+      # parses CharStrings into a list of operations that can be modified and
+      # rebuilt. This enables CharString manipulation for hint injection,
+      # subroutine optimization, and other transformations.
+      #
+      # Operation Format:
+      # ```ruby
+      # {
+      #   type: :operator,
+      #   name: :rmoveto,
+      #   operands: [100, 200]
+      # }
+      # ```
+      #
+      # Reference: Adobe Type 2 CharString Format
+      # https://adobe-type-tools.github.io/font-tech-notes/pdfs/5177.Type2.pdf
+      #
+      # @example Parse a CharString
+      #   parser = CharStringParser.new(charstring_data)
+      #   operations = parser.parse
+      #   operations.each { |op| puts "#{op[:name]} #{op[:operands]}" }
+      class CharStringParser
+        # Type 2 CharString operators (from CharString class)
+        OPERATORS = {
+          # Path construction operators
+          1 => :hstem,
+          3 => :vstem,
+          4 => :vmoveto,
+          5 => :rlineto,
+          6 => :hlineto,
+          7 => :vlineto,
+          8 => :rrcurveto,
+          10 => :callsubr,
+          11 => :return,
+          14 => :endchar,
+          18 => :hstemhm,
+          19 => :hintmask,
+          20 => :cntrmask,
+          21 => :rmoveto,
+          22 => :hmoveto,
+          23 => :vstemhm,
+          24 => :rcurveline,
+          25 => :rlinecurve,
+          26 => :vvcurveto,
+          27 => :hhcurveto,
+          28 => :shortint,
+          29 => :callgsubr,
+          30 => :vhcurveto,
+          31 => :hvcurveto,
+          # 12 prefix for two-byte operators
+          [12, 3] => :and,
+          [12, 4] => :or,
+          [12, 5] => :not,
+          [12, 9] => :abs,
+          [12, 10] => :add,
+          [12, 11] => :sub,
+          [12, 12] => :div,
+          [12, 14] => :neg,
+          [12, 15] => :eq,
+          [12, 18] => :drop,
+          [12, 20] => :put,
+          [12, 21] => :get,
+          [12, 22] => :ifelse,
+          [12, 23] => :random,
+          [12, 24] => :mul,
+          [12, 26] => :sqrt,
+          [12, 27] => :dup,
+          [12, 28] => :exch,
+          [12, 29] => :index,
+          [12, 30] => :roll,
+          [12, 34] => :hflex,
+          [12, 35] => :flex,
+          [12, 36] => :hflex1,
+          [12, 37] => :flex1,
+        }.freeze
+
+        # Operators that require hint mask bytes
+        HINTMASK_OPERATORS = %i[hintmask cntrmask].freeze
+
+        # @return [String] Binary CharString data
+        attr_reader :data
+
+        # @return [Array<Hash>] Parsed operations
+        attr_reader :operations
+
+        # Initialize parser with CharString data
+        #
+        # @param data [String] Binary CharString data
+        # @param stem_count [Integer] Number of stem hints (for hintmask)
+        def initialize(data, stem_count: 0)
+          @data = data
+          @stem_count = stem_count
+          @operations = []
+        end
+
+        # Parse CharString to operation list
+        #
+        # @return [Array<Hash>] Array of operation hashes
+        def parse
+          @operations = []
+          io = StringIO.new(@data)
+          operand_stack = []
+
+          until io.eof?
+            byte = io.getbyte
+
+            if operator_byte?(byte)
+              # Operator byte - read operator and create operation
+              operator = read_operator(io, byte)
+
+              # Read hint mask data if needed
+              hint_data = nil
+              if HINTMASK_OPERATORS.include?(operator)
+                hint_bytes = (@stem_count + 7) / 8
+                hint_data = io.read(hint_bytes) if hint_bytes.positive?
+              end
+
+              # Create operation
+              @operations << {
+                type: :operator,
+                name: operator,
+                operands: operand_stack.dup,
+                hint_data: hint_data,
+              }
+
+              # Clear operand stack
+              operand_stack.clear
+            else
+              # Operand byte - read number and push to stack
+              io.pos -= 1
+              number = read_number(io)
+              operand_stack << number
+            end
+          end
+
+          @operations
+        rescue StandardError => e
+          raise CorruptedTableError,
+                "Failed to parse CharString: #{e.message}"
+        end
+
+        # Update stem count (needed for hintmask operations)
+        #
+        # @param count [Integer] Number of stem hints
+        def stem_count=(count)
+          @stem_count = count
+        end
+
+        private
+
+        # Check if byte is an operator
+        #
+        # @param byte [Integer] Byte value
+        # @return [Boolean] True if operator byte
+        def operator_byte?(byte)
+          byte <= 31 && byte != 28 # Operators are 0-31 except 28 (shortint)
+        end
+
+        # Read operator from CharString
+        #
+        # @param io [StringIO] Input stream
+        # @param first_byte [Integer] First operator byte
+        # @return [Symbol] Operator name
+        def read_operator(io, first_byte)
+          if first_byte == 12
+            # Two-byte operator
+            second_byte = io.getbyte
+            raise CorruptedTableError, "Unexpected end of CharString" if
+              second_byte.nil?
+
+            operator_key = [first_byte, second_byte]
+            OPERATORS[operator_key] || :unknown
+          else
+            # Single-byte operator
+            OPERATORS[first_byte] || :unknown
+          end
+        end
+
+        # Read a number (integer or real) from CharString
+        #
+        # @param io [StringIO] Input stream
+        # @return [Integer, Float] The number value
+        def read_number(io)
+          byte = io.getbyte
+          raise CorruptedTableError, "Unexpected end of CharString" if
+            byte.nil?
+
+          case byte
+          when 28
+            # 3-byte signed integer (16-bit)
+            b1 = io.getbyte
+            b2 = io.getbyte
+            if b1.nil? || b2.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading shortint"
+            end
+
+            value = (b1 << 8) | b2
+            value > 0x7FFF ? value - 0x10000 : value
+          when 32..246
+            # Small integer: -107 to +107
+            byte - 139
+          when 247..250
+            # Positive 2-byte integer: +108 to +1131
+            b2 = io.getbyte
+            if b2.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading positive integer"
+            end
+
+            (byte - 247) * 256 + b2 + 108
+          when 251..254
+            # Negative 2-byte integer: -108 to -1131
+            b2 = io.getbyte
+            if b2.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading negative integer"
+            end
+
+            -(byte - 251) * 256 - b2 - 108
+          when 255
+            # 5-byte signed integer (32-bit) as fixed-point 16.16
+            bytes = io.read(4)
+            if bytes.nil? || bytes.length < 4
+              raise CorruptedTableError,
+                    "Unexpected end of CharString reading fixed-point"
+            end
+
+            value = bytes.unpack1("l>") # Signed 32-bit big-endian
+            value / 65536.0 # Convert to float
+          else
+            raise CorruptedTableError,
+                  "Invalid CharString number byte: #{byte}"
+          end
+        end
+      end
+    end
+  end
+end