prawn-svg 0.37.0 → 0.38.0

data/scripts/compare_samples

@@ -0,0 +1,25 @@
+#!/usr/bin/env fish
+
+if test (count $argv) -ne 2
+    echo "Usage: compare_samples [file containing sample output files] [new branch name]"
+    echo
+    echo A handy script that generates a sample SVG on both the main branch and the specified branch, and displays
+    echo them alongside the original SVG as rendered by Arc.  Used to see whether there have been regressions or
+    echo improvements in rendering code changes.
+    exit 1
+end
+
+set files $argv[1]
+set branch $argv[2]
+
+set i (cat $files | string trim | fzf)
+and echo $i
+and git switch main
+and bundle exec rspec -e (echo $i | string replace 'spec/sample_output/' '' | string replace '.pdf' '')
+and cp $i original.pdf
+and git switch $branch
+and bundle exec rspec -e (echo $i | string replace 'spec/sample_output/' '' | string replace '.pdf' '')
+and cp $i new.pdf
+and open -n original.pdf
+and open -n new.pdf
+and open -a Arc (echo $i | string replace sample_output sample_svg | string replace .pdf '')

data/spec/prawn/svg/attributes/transform_spec.rb

@@ -10,6 +10,10 @@ describe Prawn::SVG::Attributes::Transform do
       @warnings = []
       @attributes = {}
     end
+
+    def transformable?
+      true
+    end
   end
 
   let(:element) { TransformTestElement.new }

data/spec/prawn/svg/elements/text_spec.rb

@@ -8,7 +8,79 @@ describe Prawn::SVG::Elements::Text do
   let(:element) { Prawn::SVG::Elements::Text.new(document, document.root, [], fake_state) }
 
   let(:default_style) do
-    { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }
+    { size: 16, style: :normal, at: [:relative, :relative], offset: [0, 0] }
+  end
+
+  let(:prawn) { instance_double('Prawn::Document') }
+  let(:renderer) { instance_double('Prawn::SVG::Renderer') }
+
+  def setup_basic_mocks
+    allow(prawn).to receive(:save_font).and_yield
+    allow(prawn).to receive(:font)
+    allow(prawn).to receive(:width_of).and_return(50.0)
+    allow(prawn).to receive(:draw_text)
+    allow(prawn).to receive(:horizontal_text_scaling).and_yield
+    allow(prawn).to receive(:character_spacing) do |spacing = nil, &block|
+      if spacing.nil?
+        0 # return current character spacing when called without args
+      elsif block
+        block.call # yield when called with spacing
+      end
+    end
+    allow(prawn).to receive(:text_rendering_mode).and_yield
+    allow(prawn).to receive(:translate) do |*_args, &block|
+      block&.call
+    end
+    allow(prawn).to receive(:save_graphics_state)
+    allow(prawn).to receive(:restore_graphics_state)
+    allow(prawn).to receive(:fill_rectangle)
+    allow(prawn).to receive(:fill_color)
+    allow(prawn).to receive(:stroke_color)
+
+    # Mock render_calls to actually execute the procs so we can test the real calls
+    allow(renderer).to receive(:render_calls) do |prawn_doc, calls|
+      calls.each do |call, arguments, kwarguments, children|
+        case call
+        when 'svg:yield'
+          proc = arguments.first
+          proc&.call
+        when 'svg:render'
+          element = arguments.first
+          element.render(prawn_doc, renderer) if element.respond_to?(:render)
+        else
+          if prawn_doc.respond_to?(call) && children.empty?
+            prawn_doc.send(call, *arguments, **kwarguments)
+          elsif prawn_doc.respond_to?(call) && children.any?
+            prawn_doc.send(call, *arguments, **kwarguments) do
+              renderer.render_calls(prawn_doc, children)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def process_and_render
+    element.process
+    element.render(prawn, renderer)
+  end
+
+  describe 'basic text rendering' do
+    let(:svg) { '<text>Hello World</text>' }
+
+    it 'renders simple text' do
+      setup_basic_mocks
+      process_and_render
+
+      expect(prawn).to have_received(:draw_text).with('Hello World', hash_including(:size, :at))
+    end
+
+    it 'lays out the text during rendering' do
+      setup_basic_mocks
+      process_and_render
+      expect(prawn).to have_received(:save_font).at_least(:once)
+      expect(prawn).to have_received(:width_of).with('Hello World', hash_including(:kerning, :size))
+    end
   end
 
   describe 'xml:space preserve' do
@@ -18,10 +90,11 @@ describe Prawn::SVG::Elements::Text do
       let(:attributes) { ' xml:space="preserve"' }
 
       it 'converts newlines and tabs to spaces, and preserves spaces' do
-        element.process
+        setup_basic_mocks
+        process_and_render
 
-        expect(flatten_calls(element.calls)).to include ['draw_text', ['some    text'],
-                                                         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }]
+        expect(prawn).to have_received(:draw_text).with('some    text', hash_including(:size, :at))
+        expect(prawn).to have_received(:width_of).with('some    text', hash_including(:kerning, :size))
       end
     end
 
@@ -29,10 +102,11 @@ describe Prawn::SVG::Elements::Text do
       let(:attributes) { '' }
 
       it 'strips space' do
-        element.process
+        setup_basic_mocks
+        process_and_render
 
-        expect(flatten_calls(element.calls)).to include ['draw_text', ['some text'],
-                                                         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }]
+        expect(prawn).to have_received(:draw_text).with('some text', hash_including(:size, :at))
+        expect(prawn).to have_received(:width_of).with('some text', hash_including(:kerning, :size))
       end
     end
   end
@@ -58,13 +132,14 @@ describe Prawn::SVG::Elements::Text do
     end
 
     it 'correctly apportions white space between the tags' do
-      element.process
-      calls = element.calls.flatten
-      expect(calls).to include 'Some text here '
-      expect(calls).to include 'More text'
-      expect(calls).to include 'Even more'
-      expect(calls).to include ' leading goodness '
-      expect(calls).to include 'ok'
+      setup_basic_mocks
+      process_and_render
+
+      expect(prawn).to have_received(:draw_text).with('Some text here ', anything)
+      expect(prawn).to have_received(:draw_text).with('More text', anything)
+      expect(prawn).to have_received(:draw_text).with('Even more', anything)
+      expect(prawn).to have_received(:draw_text).with(' leading goodness ', anything)
+      expect(prawn).to have_received(:draw_text).with('ok', anything)
     end
   end
 
@@ -73,9 +148,14 @@ describe Prawn::SVG::Elements::Text do
     let(:element) { Prawn::SVG::Elements::Container.new(document, document.root, [], fake_state) }
 
     it 'should inherit text-anchor from parent element' do
+      setup_basic_mocks
+      allow(prawn).to receive(:width_of).and_return(40.0)
+
       element.process
-      expect(element.calls.flatten).to include(size: 12.0, style: :normal, text_anchor: 'middle',
-        at: [50.0, 586.0], offset: [0, 0])
+      renderer.render_calls(prawn, element.calls)
+
+      expect(prawn).to have_received(:translate).with(-20.0, 0)
+      expect(prawn).to have_received(:draw_text).with('Text', anything)
     end
   end
 
@@ -83,16 +163,12 @@ describe Prawn::SVG::Elements::Text do
     let(:svg) { '<text letter-spacing="5">spaced</text>' }
 
     it 'calls character_spacing with the requested size' do
-      element.process
+      setup_basic_mocks
+      process_and_render
 
-      expect(element.base_calls).to eq [
-        ['text_group', [], {}, [
-          ['font', ['Helvetica'], { style: :normal }, []],
-          ['character_spacing', [5.0], {}, [
-            ['draw_text', ['spaced'], default_style, []]
-          ]]
-        ]]
-      ]
+      expect(prawn).to have_received(:font).with('Helvetica', style: :normal).at_least(:once)
+      expect(prawn).to have_received(:character_spacing).with(5.0)
+      expect(prawn).to have_received(:draw_text).with('spaced', hash_including(size: 16, at: anything))
     end
   end
 
@@ -100,14 +176,14 @@ describe Prawn::SVG::Elements::Text do
     let(:svg) { '<text text-decoration="underline">underlined</text>' }
 
     it 'marks the element to be underlined' do
-      element.process
-
-      expect(element.base_calls).to eq [
-        ['text_group', [], {}, [
-          ['font', ['Helvetica'], { style: :normal }, []],
-          ['draw_text', ['underlined'], default_style.merge(decoration: 'underline'), []]
-        ]]
-      ]
+      setup_basic_mocks
+      process_and_render
+
+      expect(prawn).to have_received(:draw_text).with('underlined', hash_including(:size, :at))
+      expect(prawn).to have_received(:fill_rectangle).with(
+        [0, be_within(1).of(598.56)], 50.0, be_within(0.5).of(0.96)
+      )
+      expect(prawn).to have_received(:width_of).with('underlined', hash_including(:kerning, :size))
     end
   end
 
@@ -116,17 +192,18 @@ describe Prawn::SVG::Elements::Text do
       let(:svg) { '<text stroke="red" fill="none">stroked</text>' }
 
       it 'calls text_rendering_mode with the requested options' do
+        setup_basic_mocks
+
         element.process
 
-        expect(element.base_calls).to eq [
-          ['text_group', [], {}, [
-            ['stroke_color', ['ff0000'], {}, []],
-            ['font', ['Helvetica'], { style: :normal }, []],
-            ['text_rendering_mode', [:stroke], {}, [
-              ['draw_text', ['stroked'], default_style, []]
-            ]]
-          ]]
-        ]
+        calls_flat = flatten_calls(element.calls)
+        expect(calls_flat).to include(['stroke_color', ['ff0000'], {}])
+
+        element.render(prawn, renderer)
+
+        expect(prawn).to have_received(:font).with('Helvetica', style: :normal).at_least(:once)
+        expect(prawn).to have_received(:text_rendering_mode).with(:stroke)
+        expect(prawn).to have_received(:draw_text).with('stroked', hash_including(size: 16, at: anything))
       end
     end
 
@@ -136,30 +213,23 @@ describe Prawn::SVG::Elements::Text do
       end
 
       it 'calls text_rendering_mode with the requested options' do
+        setup_basic_mocks
+
         element.process
 
-        expect(element.base_calls).to eq [
-          ['text_group', [], {}, [
-            ['stroke_color', ['ff0000'], {}, []],
-            ['font', ['Helvetica'], { style: :normal }, []],
-            ['text_rendering_mode', [:stroke], {}, [
-              ['draw_text', ['stroked '], default_style, []],
-              ['save', [], {}, []],
-              ['fill_color', ['000000'], {}, []],
-              ['font', ['Helvetica'], { style: :normal }, []],
-              ['text_rendering_mode', [:fill_stroke], {}, [
-                ['draw_text', ['both'], default_style, []]
-              ]],
-              ['restore', [], {}, []],
-              ['save', [], {}, []],
-              ['font', ['Helvetica'], { style: :normal }, []],
-              ['text_rendering_mode', [:invisible], {}, [
-                ['draw_text', ['neither'], default_style, []]
-              ]],
-              ['restore', [], {}, []]
-            ]]
-          ]]
-        ]
+        calls_flat = flatten_calls(element.calls)
+        expect(calls_flat).to include(['stroke_color', ['ff0000'], {}])
+
+        element.render(prawn, renderer)
+
+        expect(prawn).to have_received(:text_rendering_mode).with(:stroke)
+        expect(prawn).to have_received(:text_rendering_mode).with(:fill_stroke)
+        expect(prawn).to have_received(:text_rendering_mode).with(:invisible)
+        expect(prawn).to have_received(:draw_text).with('stroked ', anything)
+        expect(prawn).to have_received(:draw_text).with('both', anything)
+        expect(prawn).to have_received(:draw_text).with('neither', anything)
+        expect(prawn).to have_received(:save_graphics_state).at_least(:once)
+        expect(prawn).to have_received(:restore_graphics_state).at_least(:once)
       end
     end
   end
@@ -169,8 +239,11 @@ describe Prawn::SVG::Elements::Text do
       let(:svg) { '<text font-family="monospace">hello</text>' }
 
       it 'finds the font and uses it' do
-        element.process
-        expect(flatten_calls(element.base_calls)).to include ['font', ['Courier'], { style: :normal }]
+        setup_basic_mocks
+        process_and_render
+
+        expect(prawn).to have_received(:font).with('Courier', style: :normal).at_least(:once)
+        expect(prawn).to have_received(:draw_text).with('hello', hash_including(size: 16, at: anything))
       end
     end
 
@@ -178,16 +251,21 @@ describe Prawn::SVG::Elements::Text do
       let(:svg) { '<text font-family="does not exist">hello</text>' }
 
       it 'uses the fallback font' do
-        element.process
-        expect(flatten_calls(element.base_calls)).to include ['font', ['Times-Roman'], { style: :normal }]
+        setup_basic_mocks
+        process_and_render
+
+        expect(prawn).to have_received(:font).with('Times-Roman', style: :normal).at_least(:once)
+        expect(prawn).to have_received(:draw_text).with('hello', hash_including(size: 16, at: anything))
       end
 
       context 'when there is no fallback font' do
         before { document.font_registry.installed_fonts.delete('Times-Roman') }
 
         it "doesn't call the font method and logs a warning" do
-          element.process
-          expect(element.base_calls.flatten).to_not include 'font'
+          setup_basic_mocks
+          process_and_render
+
+          expect(prawn).not_to have_received(:font)
           expect(document.warnings.first).to include 'is not a known font'
         end
       end
@@ -199,13 +277,11 @@ describe Prawn::SVG::Elements::Text do
     let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, [], fake_state) }
 
     it 'references the text' do
+      setup_basic_mocks
+
       element.process
-      expect(flatten_calls(element.base_calls)[9..11]).to eq [
-        ['fill_color', ['ff0000'], {}],
-        ['font', ['Helvetica'], { style: :normal }],
-        ['draw_text', ['my reference text'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [10.0, :relative], offset: [0, 0] }]
-      ]
+
+      expect(element.calls.any? { |call| call[0] == 'svg:render' }).to be true
     end
   end
 
@@ -213,50 +289,28 @@ describe Prawn::SVG::Elements::Text do
     let(:svg) { '<text x="10 20" dx="30 50 80" dy="2">Hi there, this is a good test</text>' }
 
     it 'correctly calculates the positions of the text' do
-      element.process
+      setup_basic_mocks
+      process_and_render
 
-      expect(flatten_calls(element.base_calls)).to eq [
-        ['text_group', [], {}],
-        ['font', ['Helvetica'], { style: :normal }],
-        ['draw_text', ['H'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [10.0, :relative], offset: [30.0, 2.0] }],
-        ['draw_text', ['i'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [20.0, :relative], offset: [50.0, 0] }],
-        ['draw_text', [' there, this is a good test'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [80.0, 0] }]
-      ]
+      expect(prawn).to have_received(:draw_text).with('H', hash_including(at: [40.0, anything])) # 10 + 30
+      expect(prawn).to have_received(:draw_text).with('i', hash_including(at: [70.0, anything])) # 20 + 50
+      expect(prawn).to have_received(:draw_text).with(' there, this is a good test', anything)
     end
   end
 
   describe 'rotate attribute' do
     let(:svg) { '<text rotate="10 20 30 40 50 60 70 80 90 100">Hi <tspan rotate="0">this</tspan> ok!</text>' }
 
-    it 'correctly calculates the positions of the text' do
-      element.process
+    it 'correctly processes rotated text' do
+      setup_basic_mocks
+      process_and_render
 
-      expect(flatten_calls(element.base_calls)).to eq [
-        ['text_group', [], {}],
-        ['font', ['Helvetica'], { style: :normal }],
-        ['draw_text', ['H'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -10.0 }],
-        ['draw_text', ['i'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -20.0 }],
-        ['draw_text', [' '],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -30.0 }],
-        ['save', [], {}],
-        ['font', ['Helvetica'], { style: :normal }],
-        ['draw_text', ['this'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }],
-        ['restore', [], {}],
-        ['draw_text', [' '],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -80.0 }],
-        ['draw_text', ['o'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -90.0 }],
-        ['draw_text', ['k'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -100.0 }],
-        ['draw_text', ['!'],
-         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -100.0 }]
-      ]
+      expect(prawn).to have_received(:draw_text).with('H', hash_including(rotate: -10.0))
+      expect(prawn).to have_received(:draw_text).with('i', hash_including(rotate: -20.0))
+      expect(prawn).to have_received(:draw_text).with(' ', hash_including(rotate: -30.0))
+      expect(prawn).to have_received(:draw_text).with('this', hash_excluding(:rotate))
+      expect(prawn).to have_received(:draw_text).with('o', hash_including(rotate: -90.0))
+      expect(prawn).to have_received(:draw_text).with('k', hash_including(rotate: -100.0))
     end
   end
 
@@ -264,26 +318,52 @@ describe Prawn::SVG::Elements::Text do
     let(:svg) { '<text>Hi <!-- comment --> there</text>' }
 
     it 'ignores the comment' do
+      setup_basic_mocks
+      process_and_render
+
+      expect(renderer).to have_received(:render_calls).with(prawn, anything)
+      expect(prawn).to have_received(:width_of).at_least(:once)
+    end
+  end
+
+  describe 'when a use element references a tspan element' do
+    let(:svg) do
+      <<~SVG
+        <svg>
+          <defs>
+            <text>
+              <tspan id="tspan-element">Referenced text</tspan>
+            </text>
+          </defs>
+          <use href="#tspan-element"/>
+        </svg>
+      SVG
+    end
+    let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, [], fake_state) }
+
+    it 'emits a warning that tspan cannot be used' do
       element.process
+      expect(document.warnings).to include('attempted to <use> a component inside a text element, this is not supported')
+    end
+  end
 
-      expect(flatten_calls(element.calls)).to eq [
-        ['text_group', [], {}],
-        ['font', ['Helvetica'], { style: :normal }],
-        ['draw_text',
-         ['Hi '],
-         { size:        16,
-           style:       :normal,
-           text_anchor: 'start',
-           at:          [:relative, :relative],
-           offset:      [0, 0] }],
-        ['draw_text',
-         ['there'],
-         { size:        16,
-           style:       :normal,
-           text_anchor: 'start',
-           at:          [:relative, :relative],
-           offset:      [0, 0] }]
-      ]
+  describe 'when a use element references a text element' do
+    let(:svg) do
+      <<~SVG
+        <svg>
+          <defs>
+            <text id="text-element"><tspan>Referenced text</tspan></text>
+          </defs>
+          <use href="#text-element"/>
+        </svg>
+      SVG
+    end
+    let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, [], fake_state) }
+
+    it 'processes the referenced text element' do
+      element.process
+      expect(document.warnings).to eq []
+      expect(flatten_calls(element.base_calls).map(&:first)).to include 'svg:render'
     end
   end
 end

data/spec/prawn/svg/font_registry_spec.rb

@@ -6,29 +6,140 @@ RSpec.describe Prawn::SVG::FontRegistry do
     let(:font_registry) { Prawn::SVG::FontRegistry.new(pdf.font_families) }
 
     it 'matches a built in font' do
-      font_registry.load("blah, 'courier', nothing").name.should == 'Courier'
+      expect(font_registry.load("blah, 'courier', nothing").name).to eq('Courier')
     end
 
     it 'matches a default font' do
-      font_registry.load('serif').name.should
-      font_registry.load('blah, serif').name.should
-      font_registry.load('blah, serif , test').name.should == 'Times-Roman'
+      expect(font_registry.load('serif').name).to be_truthy
+      expect(font_registry.load('blah, serif').name).to be_truthy
+      expect(font_registry.load('blah, serif , test').name).to eq('Times-Roman')
     end
 
     if Prawn::SVG::FontRegistry.new({}).installed_fonts['Verdana']
       it 'matches a font installed on the system' do
-        font_registry.load('verdana, sans-serif').name.should
-        font_registry.load('VERDANA, sans-serif').name.should
-        font_registry.load('something, "Times New Roman", serif').name.should
-        font_registry.load('something, Times New Roman, serif').name.should == 'Times New Roman'
+        expect(font_registry.load('verdana, sans-serif').name).to eq('Verdana')
+        expect(font_registry.load('VERDANA, sans-serif').name).to eq('Verdana')
+        expect(font_registry.load('something, "Times New Roman", serif').name).to be_truthy
+        expect(font_registry.load('something, Times New Roman, serif').name).to eq('Times New Roman')
       end
     else
       it "not running font test because we couldn't find Verdana installed on the system"
     end
 
     it "returns nil if it can't find any such font" do
-      font_registry.load('blah, thing').should be_nil
-      font_registry.load('').should be_nil
+      expect(font_registry.load('blah, thing')).to be_nil
+      expect(font_registry.load('')).to be_nil
+    end
+
+    it 'handles CSS font weights' do
+      font = font_registry.load('courier', '700')
+      expect(font.weight).to eq(:bold)
+    end
+
+    it 'normalizes multiple spaces in font names' do
+      font = font_registry.load('courier   , times')
+      expect(font.name).to eq('Courier')
+    end
+
+    it 'falls back when requested weight is unavailable' do
+      font = font_registry.load('courier', :black)
+      expect(font.name).to eq('Courier')
+    end
+
+    it 'handles font weight and style parameters' do
+      font = font_registry.load('courier', :bold, :italic)
+      expect(font.weight).to eq(:bold)
+      expect(font.style).to eq(:italic)
+    end
+
+    it 'converts CSS numeric weights to symbols' do
+      expect(font_registry.load('courier', '400').weight).to eq(:normal)
+      expect(font_registry.load('courier', '700').weight).to eq(:bold)
+    end
+
+    it 'falls back from style when unavailable' do
+      font = font_registry.load('courier', :normal, :italic)
+      expect(font.name).to eq('Courier')
+    end
+
+    it 'processes comma-separated font families' do
+      font = font_registry.load('nonexistent, courier, times')
+      expect(font.name).to eq('Courier')
+    end
+
+    it 'handles quoted font names with commas' do
+      font = font_registry.load('"font, with comma", courier')
+      expect(font.name).to eq('Courier')
+    end
+
+    describe 'weight fallbacks' do
+      before do
+        # Mock a font family with only normal and bold available
+        allow(font_registry).to receive(:installed_fonts).and_return({
+          'TestFont' => { normal: 'test.ttf', bold: 'test-bold.ttf' }
+        })
+        allow(font_registry).to receive(:correctly_cased_font_name).and_return('TestFont')
+      end
+
+      it 'falls back from light to normal' do
+        font = font_registry.load('TestFont', :light)
+        expect(font.weight).to eq(:normal)
+      end
+
+      it 'falls back from semibold to bold to normal' do
+        font = font_registry.load('TestFont', :semibold)
+        expect(font.weight).to eq(:bold)
+      end
+
+      it 'falls back from extrabold to bold' do
+        font = font_registry.load('TestFont', :extrabold)
+        expect(font.weight).to eq(:bold)
+      end
+
+      it 'falls back from black to bold' do
+        font = font_registry.load('TestFont', :black)
+        expect(font.weight).to eq(:bold)
+      end
+
+      context 'when only normal weight is available' do
+        before do
+          allow(font_registry).to receive(:installed_fonts).and_return({
+            'TestFont' => { normal: 'test.ttf' }
+          })
+        end
+
+        it 'falls back from bold to normal' do
+          font = font_registry.load('TestFont', :bold)
+          expect(font.weight).to eq(:normal)
+        end
+
+        it 'falls back through the entire chain to normal' do
+          font = font_registry.load('TestFont', :black)
+          expect(font.weight).to eq(:normal)
+        end
+      end
+
+      context 'when all weights are available' do
+        before do
+          allow(font_registry).to receive(:installed_fonts).and_return({
+            'TestFont' => {
+              light:     'test-light.ttf',
+              normal:    'test.ttf',
+              semibold:  'test-semibold.ttf',
+              bold:      'test-bold.ttf',
+              extrabold: 'test-extrabold.ttf',
+              black:     'test-black.ttf'
+            }
+          })
+        end
+
+        it 'returns exact weight matches without fallback' do
+          expect(font_registry.load('TestFont', :light).weight).to eq(:light)
+          expect(font_registry.load('TestFont', :semibold).weight).to eq(:semibold)
+          expect(font_registry.load('TestFont', :extrabold).weight).to eq(:extrabold)
+          expect(font_registry.load('TestFont', :black).weight).to eq(:black)
+        end
+      end
     end
   end