fontisan 0.2.1 → 0.2.2

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

@@ -99,7 +99,11 @@ module Fontisan
           # Check array limits
           if HINT_LIMITS[key]
             raise ArgumentError, "#{key} invalid" unless value.is_a?(Array)
-            raise ArgumentError, "#{key} too long" if value.length > HINT_LIMITS[key][:max]
+
+            if value.length > HINT_LIMITS[key][:max]
+              raise ArgumentError,
+                    "#{key} too long"
+            end
             if HINT_LIMITS[key][:pairs] && value.length.odd?
               raise ArgumentError, "#{key} must be pairs"
             end
@@ -114,12 +118,14 @@ module Fontisan
           when :blue_shift, :blue_fuzz
             raise ArgumentError, "#{key} invalid" unless value.is_a?(Numeric)
           when :force_bold
-            raise ArgumentError, "#{key} must be 0 or 1" unless [0, 1].include?(value)
+            raise ArgumentError, "#{key} must be 0 or 1" unless [0,
+                                                                 1].include?(value)
           when :language_group
-            raise ArgumentError, "#{key} must be 0 or 1" unless [0, 1].include?(value)
+            raise ArgumentError, "#{key} must be 0 or 1" unless [0,
+                                                                 1].include?(value)
           end
         end
       end
     end
   end
-end
+end

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

@@ -218,4 +218,4 @@ module Fontisan
       end
     end
   end
-end
+end

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

@@ -68,7 +68,8 @@ module Fontisan
         # @param global_subrs [Cff::Index, nil] Global subroutines INDEX
         # @param local_subrs [Cff::Index, nil] Local subroutines INDEX
         # @param vsindex [Integer] Variation store index (default 0)
-        def initialize(data, num_axes = 0, global_subrs = nil, local_subrs = nil, vsindex = 0)
+        def initialize(data, num_axes = 0, global_subrs = nil,
+local_subrs = nil, vsindex = 0)
           @data = data
           @num_axes = num_axes
           @global_subrs = global_subrs
@@ -123,7 +124,8 @@ module Fontisan
             when :line_to
               [:line_to, cmd[:x], cmd[:y]]
             when :curve_to
-              [:curve_to, cmd[:x1], cmd[:y1], cmd[:x2], cmd[:y2], cmd[:x], cmd[:y]]
+              [:curve_to, cmd[:x1], cmd[:y1], cmd[:x2], cmd[:y2], cmd[:x],
+               cmd[:y]]
             end
           end
         end
@@ -146,7 +148,8 @@ module Fontisan
             end
           end
         rescue StandardError => e
-          raise CorruptedTableError, "Failed to parse CFF2 CharString: #{e.message}"
+          raise CorruptedTableError,
+                "Failed to parse CFF2 CharString: #{e.message}"
         end
 
         # Check if byte is an operator
@@ -165,7 +168,10 @@ module Fontisan
           if first_byte == 12
             # Two-byte operator
             second_byte = @io.getbyte
-            raise CorruptedTableError, "Unexpected end of CharString" if second_byte.nil?
+            if second_byte.nil?
+              raise CorruptedTableError,
+                    "Unexpected end of CharString"
+            end
 
             [12, second_byte]
           else
@@ -305,7 +311,7 @@ module Fontisan
         # @param blend_op [Hash] Blend operation data
         # @param coordinates [Hash<String, Float>] Axis coordinates
         # @return [Array<Float>] Blended values
-        def apply_blend(blend_op, coordinates)
+        def apply_blend(blend_op, _coordinates)
           blend_op[:blends].map do |blend|
             base = blend[:base]
             deltas = blend[:deltas]
@@ -313,7 +319,7 @@ module Fontisan
             # Apply deltas based on coordinates
             # This will be enhanced when we have proper coordinate interpolation
             blended_value = base
-            deltas.each_with_index do |delta, axis_index|
+            deltas.each_with_index do |delta, _axis_index|
               # Placeholder: use normalized coordinate (will be replaced with proper interpolation)
               scalar = 0.0 # Will be calculated by interpolator
               blended_value += delta * scalar
@@ -573,7 +579,7 @@ module Fontisan
         def callsubr
           return if @local_subrs.nil? || @stack.empty?
 
-          subr_index = @stack.pop
+          @stack.pop
           # Implement subroutine call (placeholder)
           @stack.clear
         end
@@ -581,7 +587,7 @@ module Fontisan
         def callgsubr
           return if @global_subrs.nil? || @stack.empty?
 
-          subr_index = @stack.pop
+          @stack.pop
           # Implement global subroutine call (placeholder)
           @stack.clear
         end

data/lib/fontisan/tables/cff2/private_dict_blend_handler.rb

@@ -63,14 +63,14 @@ module Fontisan
 
             blends << {
               base: base,
-              deltas: deltas
+              deltas: deltas,
             }
           end
 
           {
             num_values: num_values,
             num_axes: num_axes,
-            blends: blends
+            blends: blends,
           }
         end
 
@@ -90,7 +90,7 @@ module Fontisan
           {
             base: value[0],
             deltas: value[1..num_axes],
-            num_axes: num_axes
+            num_axes: num_axes,
           }
         end
 
@@ -149,7 +149,8 @@ module Fontisan
               else
                 # Try as single blend value
                 blend_data = parse_blend_value(key, num_axes: num_axes)
-                result[key] = blend_data ? apply_blend(blend_data, scalars) : value
+                result[key] =
+                  blend_data ? apply_blend(blend_data, scalars) : value
               end
             else
               # Non-blend value, copy as-is
@@ -186,7 +187,7 @@ module Fontisan
               # Hint with blend data - normalize and flatten for DICT storage
               normalized_value = {
                 base: value[:base] || value["base"],
-                deltas: value[:deltas] || value["deltas"]
+                deltas: value[:deltas] || value["deltas"],
               }
               result[key] = flatten_blend(normalized_value, num_axes: num_axes)
             else
@@ -243,4 +244,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2/region_matcher.rb

@@ -121,7 +121,7 @@ module Fontisan
         def active_regions(coordinates)
           scalars = calculate_scalars(coordinates)
           scalars.each_with_index.select { |scalar, _| scalar.positive? }
-                 .map(&:last)
+            .map(&:last)
         end
 
         # Get scalar for specific region index
@@ -197,4 +197,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2/table_builder.rb

@@ -31,6 +31,9 @@ module Fontisan
       #   builder = CFF2TableBuilder.new(reader, hint_set)
       #   new_cff2 = builder.build
       class TableBuilder < Tables::Cff::TableBuilder
+        # CFF2-specific operators not supported by CFF DictBuilder
+        INVALID_CFF_KEYS = [24].freeze # operator 24 = vstore (CFF2 only)
+
         # @return [CFF2TableReader] CFF2 table reader
         attr_reader :reader
 
@@ -79,7 +82,7 @@ module Fontisan
             top_dict: top_dict_hash,
             charstrings: charstrings_data,
             private_dict: private_dict_data,
-            vstore: vstore_data
+            vstore: vstore_data,
           )
         end
 
@@ -134,7 +137,8 @@ module Fontisan
 
           # Create rebuilder with stem count
           stem_count = calculate_stem_count
-          rebuilder = Cff::CharStringRebuilder.new(charstrings_index, stem_count: stem_count)
+          rebuilder = Cff::CharStringRebuilder.new(charstrings_index,
+                                                   stem_count: stem_count)
 
           # Modify each glyph with hints
           hinted_glyph_ids.each do |glyph_id|
@@ -179,14 +183,14 @@ module Fontisan
           # Count stems from blue zones (hstem)
           hstem_count = 0
           blue_values = font_hints["blue_values"] || font_hints[:blue_values]
-          if blue_values && blue_values.is_a?(Array)
+          if blue_values.is_a?(Array)
             hstem_count = blue_values.size / 2
           end
 
           # Count stems from stem snap (vstem)
           vstem_count = 0
           stem_snap_h = font_hints["stem_snap_h"] || font_hints[:stem_snap_h]
-          if stem_snap_h && stem_snap_h.is_a?(Array)
+          if stem_snap_h.is_a?(Array)
             vstem_count = stem_snap_h.size
           end
 
@@ -365,7 +369,7 @@ module Fontisan
           # Extract Variable Store bytes unchanged
           # For simplicity, extract from vstore_offset to end of table
           # In production, we'd parse structure to get exact size
-          @reader.data[vstore_offset..-1]
+          @reader.data[vstore_offset..]
         end
 
         # Rebuild complete CFF2 table
@@ -376,7 +380,8 @@ module Fontisan
         # @param private_dict [String, nil] Private DICT
         # @param vstore [String, nil] Variable Store
         # @return [String] Complete CFF2 table binary
-        def rebuild_cff2_table(header:, top_dict:, charstrings:, private_dict:, vstore:)
+        def rebuild_cff2_table(header:, top_dict:, charstrings:, private_dict:,
+vstore:)
           output = StringIO.new("".b)
 
           # 1. Write Header
@@ -387,7 +392,7 @@ module Fontisan
             header_size: header.size,
             charstrings: charstrings,
             private_dict: private_dict,
-            vstore: vstore
+            vstore: vstore,
           )
 
           # 3. Build Top DICT with updated offsets
@@ -416,7 +421,8 @@ module Fontisan
         # @param private_dict [String, nil] Private DICT data
         # @param vstore [String, nil] Variable Store data
         # @return [Hash] Section offsets
-        def calculate_cff2_offsets(header_size:, charstrings:, private_dict:, vstore:)
+        def calculate_cff2_offsets(header_size:, charstrings:, private_dict:,
+vstore:)
           # Start after header
           offset = header_size
 
@@ -446,7 +452,7 @@ module Fontisan
             charstrings: charstrings_offset,
             private_dict: private_dict_offset,
             private_dict_size: private_dict_size,
-            vstore: vstore_offset
+            vstore: vstore_offset,
           }
         end
 
@@ -531,23 +537,23 @@ module Fontisan
             18 => :private,
             19 => :subrs,
             20 => :default_width_x,
-            21 => :nominal_width_x
-          # Note: operator 24 (vstore) is CFF2-specific and handled separately
+            21 => :nominal_width_x,
+            # Note: operator 24 (vstore) is CFF2-specific and handled separately
           }
 
           result = {}
           dict.each do |key, value|
             # Skip vstore (operator 24) - CFF2 specific, not in CFF DictBuilder
-            next if key == 24 || key == :vstore
+            next if INVALID_CFF_KEYS.include?(key)
 
             # Convert string keys to symbols for DictBuilder
-            if key.is_a?(String)
-              symbol_key = key.to_sym
-            elsif key.is_a?(Integer)
-              symbol_key = operator_map[key] || key
-            else
-              symbol_key = key
-            end
+            symbol_key = if key.is_a?(String)
+                           key.to_sym
+                         elsif key.is_a?(Integer)
+                           operator_map[key] || key
+                         else
+                           key
+                         end
 
             result[symbol_key] = value
           end
@@ -571,4 +577,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2/table_reader.rb

@@ -61,7 +61,7 @@ module Fontisan
             major_version: read_uint8,
             minor_version: read_uint8,
             header_size: read_uint8,
-            top_dict_length: read_uint16
+            top_dict_length: read_uint16,
           }
 
           # Validate CFF2 version
@@ -105,7 +105,7 @@ module Fontisan
           # Parse Variable Store structure
           @variable_store = {
             regions: read_region_list,
-            item_variation_data: read_item_variation_data
+            item_variation_data: read_item_variation_data,
           }
 
           @variable_store
@@ -140,7 +140,7 @@ module Fontisan
             axes << {
               start_coord: read_f2dot14,
               peak_coord: read_f2dot14,
-              end_coord: read_f2dot14
+              end_coord: read_f2dot14,
             }
           end
 
@@ -158,13 +158,11 @@ module Fontisan
 
           item_variation_data = []
 
-          data_count.times do |idx|
-            begin
-              item_data = read_single_item_variation_data
-              item_variation_data << item_data
-            rescue EOFError => e
-              # break
-            end
+          data_count.times do |_idx|
+            item_data = read_single_item_variation_data
+            item_variation_data << item_data
+          rescue EOFError
+            # break
           end
 
           item_variation_data
@@ -186,32 +184,32 @@ module Fontisan
 
           # Read delta sets
           delta_sets = []
-          item_count.times do |item_idx|
-            begin
-              deltas = []
-
-              # Short deltas (16-bit)
-              short_delta_count.times do
-                break if @io.eof?
-                deltas << read_int16
-              end
-
-              # Long deltas (8-bit) for remaining regions
-              (region_index_count - short_delta_count).times do
-                break if @io.eof?
-                deltas << read_int8
-              end
-
-              delta_sets << deltas
-            rescue EOFError => e
-              # break
+          item_count.times do |_item_idx|
+            deltas = []
+
+            # Short deltas (16-bit)
+            short_delta_count.times do
+              break if @io.eof?
+
+              deltas << read_int16
+            end
+
+            # Long deltas (8-bit) for remaining regions
+            (region_index_count - short_delta_count).times do
+              break if @io.eof?
+
+              deltas << read_int8
             end
+
+            delta_sets << deltas
+          rescue EOFError
+            # break
           end
 
           {
             item_count: item_count,
             region_indices: region_indices,
-            delta_sets: delta_sets
+            delta_sets: delta_sets,
           }
         end
 
@@ -249,7 +247,10 @@ module Fontisan
         # @raise [EOFError] If not enough bytes available
         def read_safely(bytes, description)
           data = @io.read(bytes)
-          raise EOFError, "Unexpected EOF while reading #{description}" if data.nil? || data.bytesize < bytes
+          if data.nil? || data.bytesize < bytes
+            raise EOFError,
+                  "Unexpected EOF while reading #{description}"
+          end
 
           data
         end
@@ -269,7 +270,8 @@ module Fontisan
 
             if operator_byte?(byte)
               operator = read_dict_operator(io, byte)
-              dict[operator] = operands.size == 1 ? operands.first : operands.dup
+              dict[operator] =
+                operands.size == 1 ? operands.first : operands.dup
               operands.clear
             else
               # Operand (number)
@@ -416,4 +418,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2/variation_data_extractor.rb

@@ -148,7 +148,7 @@ module Fontisan
               {
                 start: axis[:start_coord],
                 peak: axis[:peak_coord],
-                end: axis[:end_coord]
+                end: axis[:end_coord],
               }
             end
           end
@@ -209,4 +209,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2.rb

@@ -111,7 +111,7 @@ module Fontisan
           @num_axes,
           @global_subr_index,
           nil, # local subrs (CFF2 may not have them)
-          0    # vsindex
+          0, # vsindex
         ).parse
       end
 

data/lib/fontisan/tables/glyf/compound_glyph_resolver.rb

@@ -118,7 +118,8 @@ module Fontisan
                                 resolve(component_glyph, visited, depth + 1)
                               else
                                 # Convert simple glyph to outline
-                                Models::Outline.from_truetype(component_glyph, component.glyph_index)
+                                Models::Outline.from_truetype(component_glyph,
+                                                              component.glyph_index)
                               end
 
           # Apply transformation matrix

data/lib/fontisan/tables/glyf/curve_converter.rb

@@ -119,7 +119,10 @@ module Fontisan
       # @raise [ArgumentError] If parameters are invalid
       def self.calculate_error(cubic, quadratics)
         validate_cubic_curve!(cubic)
-        raise ArgumentError, "quadratics must be Array" unless quadratics.is_a?(Array)
+        unless quadratics.is_a?(Array)
+          raise ArgumentError,
+                "quadratics must be Array"
+        end
         raise ArgumentError, "quadratics cannot be empty" if quadratics.empty?
 
         max_error = 0.0
@@ -305,7 +308,8 @@ module Fontisan
         required.each do |key|
           value = quad[key]
           unless value.is_a?(Numeric)
-            raise ArgumentError, "quad[:#{key}] must be Numeric, got: #{value.class}"
+            raise ArgumentError,
+                  "quad[:#{key}] must be Numeric, got: #{value.class}"
           end
         end
       end
@@ -324,14 +328,16 @@ module Fontisan
         required.each do |key|
           value = cubic[key]
           unless value.is_a?(Numeric)
-            raise ArgumentError, "cubic[:#{key}] must be Numeric, got: #{value.class}"
+            raise ArgumentError,
+                  "cubic[:#{key}] must be Numeric, got: #{value.class}"
           end
         end
       end
 
       private_class_method def self.validate_max_error!(max_error)
         unless max_error.is_a?(Numeric)
-          raise ArgumentError, "max_error must be Numeric, got: #{max_error.class}"
+          raise ArgumentError,
+                "max_error must be Numeric, got: #{max_error.class}"
         end
 
         if max_error <= 0

data/lib/fontisan/tables/glyf/glyph_builder.rb

@@ -106,7 +106,11 @@ module Fontisan
       # @raise [ArgumentError] If parameters are invalid
       def self.build_compound_glyph(components, bbox, instructions: "".b)
         raise ArgumentError, "components cannot be nil" if components.nil?
-        raise ArgumentError, "components must be Array" unless components.is_a?(Array)
+
+        unless components.is_a?(Array)
+          raise ArgumentError,
+                "components must be Array"
+        end
         raise ArgumentError, "components cannot be empty" if components.empty?
 
         validate_bbox!(bbox)
@@ -114,7 +118,8 @@ module Fontisan
         build_compound_glyph_data(components, bbox, instructions)
       end
 
-      private_class_method def self.build_simple_glyph_data(contours, bbox, instructions)
+      private_class_method def self.build_simple_glyph_data(contours, bbox,
+instructions)
         num_contours = contours.length
 
         # Build endPtsOfContours array
@@ -136,7 +141,8 @@ module Fontisan
 
         # Header (10 bytes)
         data << [num_contours].pack("n") # numberOfContours
-        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max], bbox[:y_max]].pack("n4")
+        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max],
+                 bbox[:y_max]].pack("n4")
 
         # endPtsOfContours
         data << end_pts_of_contours.pack("n*")
@@ -155,18 +161,21 @@ module Fontisan
         data
       end
 
-      private_class_method def self.build_compound_glyph_data(components, bbox, instructions)
+      private_class_method def self.build_compound_glyph_data(components, bbox,
+instructions)
         data = (+"").force_encoding(Encoding::BINARY)
 
         # Header (10 bytes) - numberOfContours = -1 for compound
         data << [-1].pack("n") # Use signed pack, will convert to 0xFFFF
-        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max], bbox[:y_max]].pack("n4")
+        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max],
+                 bbox[:y_max]].pack("n4")
 
         # Encode components
         has_instructions = instructions.bytesize.positive?
         components.each_with_index do |component, index|
           is_last = (index == components.length - 1)
-          component_data = encode_component(component, is_last, has_instructions)
+          component_data = encode_component(component, is_last,
+                                            has_instructions)
           data << component_data
         end
 
@@ -179,7 +188,8 @@ module Fontisan
         data
       end
 
-      private_class_method def self.encode_component(component, is_last, has_instructions)
+      private_class_method def self.encode_component(component, is_last,
+has_instructions)
         validate_component!(component)
 
         glyph_index = component[:glyph_index]
@@ -344,7 +354,8 @@ module Fontisan
         data
       end
 
-      private_class_method def self.encode_coordinate_values(flags, deltas, axis)
+      private_class_method def self.encode_coordinate_values(flags, deltas,
+axis)
         data = (+"").force_encoding(Encoding::BINARY)
         short_flag = axis == :x ? X_SHORT_VECTOR : Y_SHORT_VECTOR
         same_flag = axis == :x ? X_IS_SAME_OR_POSITIVE_X_SHORT : Y_IS_SAME_OR_POSITIVE_Y_SHORT
@@ -400,7 +411,10 @@ module Fontisan
         # Convert float to F2DOT14 fixed-point format
         # F2DOT14: 2 bits integer, 14 bits fractional
         # Range: -2.0 to ~1.99993896484375
-        raise ArgumentError, "value out of F2DOT14 range" if value < -2.0 || value > 2.0
+        if value < -2.0 || value > 2.0
+          raise ArgumentError,
+                "value out of F2DOT14 range"
+        end
 
         fixed = (value * 16_384.0).round
         # Convert to unsigned 16-bit
@@ -434,7 +448,10 @@ module Fontisan
       end
 
       private_class_method def self.validate_component!(component)
-        raise ArgumentError, "component must be Hash" unless component.is_a?(Hash)
+        unless component.is_a?(Hash)
+          raise ArgumentError,
+                "component must be Hash"
+        end
         unless component[:glyph_index]
           raise ArgumentError, "component must have :glyph_index"
         end

data/lib/fontisan/tables/name.rb

@@ -173,13 +173,13 @@ module Fontisan
         record = find_name_record(
           name_id,
           platform: PLATFORM_WINDOWS,
-          language: WINDOWS_LANGUAGE_EN_US
+          language: WINDOWS_LANGUAGE_EN_US,
         )
 
         record ||= find_name_record(
           name_id,
           platform: PLATFORM_MACINTOSH,
-          language: MAC_LANGUAGE_ENGLISH
+          language: MAC_LANGUAGE_ENGLISH,
         )
 
         return nil unless record
@@ -236,10 +236,10 @@ module Fontisan
         decoded = case record.platform_id
                   when PLATFORM_WINDOWS, PLATFORM_UNICODE
                     string_data.dup.force_encoding("UTF-16BE")
-                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                      .encode("UTF-8", invalid: :replace, undef: :replace)
                   when PLATFORM_MACINTOSH
                     string_data.dup.force_encoding("ASCII-8BIT")
-                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                      .encode("UTF-8", invalid: :replace, undef: :replace)
                   else
                     string_data.dup.force_encoding("UTF-8")
                   end

data/lib/fontisan/true_type_font.rb

@@ -233,7 +233,8 @@ module Fontisan
           batch_entries.each do |entry|
             relative_offset = entry.offset - batch_offset
             tag_key = entry.tag.dup.force_encoding("UTF-8")
-            @table_data[tag_key] = batch_data[relative_offset, entry.table_length]
+            @table_data[tag_key] =
+              batch_data[relative_offset, entry.table_length]
           end
         end
 
@@ -307,6 +308,7 @@ module Fontisan
     # @return [Boolean] true if table is available in current mode
     def table_available?(tag)
       return false unless has_table?(tag)
+
       LoadingModes.table_allowed?(@loading_mode, tag)
     end