prawn 2.1.0 → 2.2.0

data/spec/prawn/graphics/blend_mode_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Prawn::Graphics::BlendMode do
+  def make_blend_mode(blend_mode)
+    pdf.blend_mode(blend_mode) do
+      yield if block_given?
+    end
+  end
+
+  let(:pdf) { create_pdf }
+
+  it 'the PDF version should be at least 1.4' do
+    make_blend_mode(:Multiply)
+    str = pdf.render
+    expect(str[0, 8]).to eq('%PDF-1.4')
+  end
+
+  it 'a new extended graphics state should be created for ' \
+     'each unique blend mode setting' do
+    make_blend_mode(:Multiply) do
+      make_blend_mode(:Screen)
+    end
+    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+    expect(extgstates.length).to eq(2)
+  end
+
+  it 'a new extended graphics state should not be created for ' \
+     'each duplicate blend mode setting' do
+    make_blend_mode(:Multiply) do
+      make_blend_mode(:Multiply)
+    end
+    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+    expect(extgstates.length).to eq(1)
+  end
+
+  it 'setting the blend mode with only one parameter sets a single '\
+    'blend mode value' do
+    make_blend_mode(:Multiply)
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates.first
+    expect(extgstate[:blend_mode]).to eq(:Multiply)
+  end
+
+  it 'setting the blend mode with multiple parameters sets an array of '\
+    'blend modes' do
+    make_blend_mode([:Multiply, :Screen, :Overlay])
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates.first
+    expect(extgstate[:blend_mode]).to eq([:Multiply, :Screen, :Overlay])
+  end
+
+  describe 'with more than one page' do
+    it 'the extended graphic state resource should be added to both pages' do
+      make_blend_mode(:Multiply)
+      pdf.start_new_page
+      make_blend_mode(:Multiply)
+      extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+      extgstate = extgstates[0]
+      expect(extgstates.length).to eq(2)
+      expect(extgstate[:blend_mode]).to eq(:Multiply)
+    end
+  end
+end

data/spec/prawn/graphics/transparency_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Prawn::Graphics::Transparency do
+  def make_transparent(opacity, stroke_opacity = opacity)
+    pdf.transparent(opacity, stroke_opacity) do
+      yield if block_given?
+    end
+  end
+
+  let(:pdf) { create_pdf }
+
+  it 'the PDF version should be at least 1.4' do
+    make_transparent(0.5)
+    str = pdf.render
+    expect(str[0, 8]).to eq('%PDF-1.4')
+  end
+
+  it 'a new extended graphics state should be created for ' \
+    'each unique transparency setting' do
+    make_transparent(0.5, 0.2) do
+      make_transparent(0.5, 0.75)
+    end
+    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+    expect(extgstates.length).to eq(2)
+  end
+
+  it 'a new extended graphics state should not be created for ' \
+    'each duplicate transparency setting' do
+    make_transparent(0.5, 0.75) do
+      make_transparent(0.5, 0.75)
+    end
+    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+    expect(extgstates.length).to eq(1)
+  end
+
+  it 'setting the transparency with only one parameter sets the ' \
+    'transparency for both the fill and the stroke' do
+    make_transparent(0.5)
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates[0]
+    expect(extgstate[:opacity]).to eq(0.5)
+    expect(extgstate[:stroke_opacity]).to eq(0.5)
+  end
+
+  it 'setting the transparency with a numerical parameter and ' \
+    'a :stroke should set the fill transparency to the numerical parameter ' \
+    'and the stroke transparency to the option' do
+    make_transparent(0.5, 0.2)
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates[0]
+    expect(extgstate[:opacity]).to eq(0.5)
+    expect(extgstate[:stroke_opacity]).to eq(0.2)
+  end
+
+  it 'does not allow negative values' do
+    make_transparent(-0.5, -0.2)
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates[0]
+    expect(extgstate[:opacity]).to eq(0.0)
+    expect(extgstate[:stroke_opacity]).to eq(0.0)
+  end
+
+  it 'does not allow too big values' do
+    make_transparent(2.0, 3.0)
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates[0]
+    expect(extgstate[:opacity]).to eq(1.0)
+    expect(extgstate[:stroke_opacity]).to eq(1.0)
+  end
+
+  describe 'with more than one page' do
+    it 'the extended graphic state resource should be added to both pages' do
+      make_transparent(0.5, 0.2)
+      pdf.start_new_page
+      make_transparent(0.5, 0.2)
+      extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+      extgstate = extgstates[0]
+      expect(extgstates.length).to eq(2)
+      expect(extgstate[:opacity]).to eq(0.5)
+      expect(extgstate[:stroke_opacity]).to eq(0.2)
+    end
+  end
+end

data/spec/prawn/graphics_spec.rb

@@ -0,0 +1,817 @@
+require 'spec_helper'
+
+describe Prawn::Graphics do
+  let(:pdf) { create_pdf }
+
+  describe 'When drawing a line' do
+    it 'draws a line from (100,600) to (100,500)' do
+      pdf.line([100, 600], [100, 500])
+
+      line_drawing = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+
+      expect(line_drawing.points).to eq([[100, 600], [100, 500]])
+    end
+
+    it 'should draw two lines at (100,600) to (100,500) ' \
+      'and (75,100) to (50,125)' do
+      pdf.line(100, 600, 100, 500)
+      pdf.line(75, 100, 50, 125)
+
+      line_drawing = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+
+      expect(line_drawing.points).to eq(
+        [[100.0, 600.0], [100.0, 500.0], [75.0, 100.0], [50.0, 125.0]]
+      )
+    end
+
+    it 'properlies set line width via line_width=' do
+      pdf.line_width = 10
+      line = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+      expect(line.widths.first).to eq(10)
+    end
+
+    it 'properlies set line width via line_width(width)' do
+      pdf.line_width(10)
+      line = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+      expect(line.widths.first).to eq(10)
+    end
+
+    it 'carries the current line width settings over to new pages' do
+      pdf.line_width(10)
+      pdf.start_new_page
+      line = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+      expect(line.widths.length).to eq(2)
+      expect(line.widths[1]).to eq(10)
+    end
+
+    describe '(Horizontally)' do
+      it 'draws from [x1,pdf.y],[x2,pdf.y]' do
+        pdf.horizontal_line(100, 150)
+        line = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+        expect(line.points).to eq([
+          [100.0 + pdf.bounds.absolute_left, pdf.y],
+          [150.0 + pdf.bounds.absolute_left, pdf.y]
+        ])
+      end
+
+      it 'draws a line from (200, 250) to (300, 250)' do
+        pdf.horizontal_line(200, 300, at: 250)
+        line_drawing = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+        expect(line_drawing.points).to eq([[200, 250], [300, 250]])
+      end
+    end
+
+    describe '(Vertically)' do
+      it 'draws a line from (350, 300) to (350, 400)' do
+        pdf.vertical_line(300, 400, at: 350)
+        line_drawing = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+        expect(line_drawing.points).to eq([[350, 300], [350, 400]])
+      end
+      it 'requires a y coordinate' do
+        expect { pdf.vertical_line(400, 500) }
+          .to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe 'When drawing a polygon' do
+    it 'draws each line passed to polygon()' do
+      pdf.polygon([100, 500], [100, 400], [200, 400])
+
+      line_drawing = PDF::Inspector::Graphics::Line.analyze(pdf.render)
+      expect(line_drawing.points)
+        .to eq([[100, 500], [100, 400], [200, 400], [100, 500]])
+    end
+  end
+
+  describe 'When drawing a rectangle' do
+    it 'uses a point, width, and height for coords' do
+      pdf.rectangle [200, 200], 50, 100
+
+      rectangles = PDF::Inspector::Graphics::Rectangle.analyze(pdf.render)
+        .rectangles
+      # PDF uses bottom left corner
+      expect(rectangles[0][:point]).to eq([200, 100])
+      expect(rectangles[0][:width]).to eq(50)
+      expect(rectangles[0][:height]).to eq(100)
+    end
+  end
+
+  describe 'When drawing a curve' do
+    it 'draws a bezier curve from 50,50 to 100,100' do
+      pdf.move_to [50, 50]
+      pdf.curve_to [100, 100], bounds: [[20, 90], [90, 70]]
+      curve = PDF::Inspector::Graphics::Curve.analyze(pdf.render)
+      expect(curve.coords)
+        .to eq([50.0, 50.0, 20.0, 90.0, 90.0, 70.0, 100.0, 100.0])
+    end
+
+    it 'draws a bezier curve from 100,100 to 50,50' do
+      pdf.curve [100, 100], [50, 50], bounds: [[20, 90], [90, 75]]
+      curve = PDF::Inspector::Graphics::Curve.analyze(pdf.render)
+      expect(curve.coords)
+        .to eq([100.0, 100.0, 20.0, 90.0, 90.0, 75.0, 50.0, 50.0])
+    end
+  end
+
+  describe 'When drawing a rounded rectangle' do
+    before { pdf.rounded_rectangle([50, 550], 50, 100, 10) }
+    let(:original_point) do
+      curve = PDF::Inspector::Graphics::Curve.analyze(pdf.render)
+      curve_points = curve.coords.each_slice(2).to_a
+      curve_points.shift
+    end
+    let(:all_coords) do
+      curve = PDF::Inspector::Graphics::Curve.analyze(pdf.render)
+      curve_points = curve.coords.each_slice(2).to_a
+      curve_points.shift
+      curves = curve_points.each_slice(3).to_a
+      line_points = PDF::Inspector::Graphics::Line.analyze(pdf.render).points
+      line_points.shift
+      line_points.zip(curves).flatten.each_slice(2).to_a.unshift original_point
+    end
+
+    it 'draws a rectangle by connecting lines with rounded bezier curves' do
+      expect(all_coords).to eq(
+        [
+          [60.0, 550.0], [90.0, 550.0], [95.5228, 550.0], [100.0, 545.5228],
+          [100.0, 540.0], [100.0, 460.0], [100.0, 454.4772], [95.5228, 450.0],
+          [90.0, 450.0], [60.0, 450.0], [54.4772, 450.0], [50.0, 454.4772],
+          [50.0, 460.0], [50.0, 540.0], [50.0, 545.5228], [54.4772, 550.0],
+          [60.0, 550.0]
+        ]
+      )
+    end
+
+    it 'starts and end with the same point' do
+      expect(original_point).to eq(all_coords.last)
+    end
+  end
+
+  describe 'When drawing an ellipse' do
+    let(:curve) do
+      pdf.ellipse [100, 100], 25, 50
+      PDF::Inspector::Graphics::Curve.analyze(pdf.render)
+    end
+
+    it 'uses a Bézier approximation' do
+      expect(curve.coords).to eq([
+        125.0, 100.0,
+
+        125.0, 127.6142,
+        113.8071, 150,
+        100.0, 150.0,
+
+        86.1929, 150.0,
+        75.0, 127.6142,
+        75.0, 100.0,
+
+        75.0, 72.3858,
+        86.1929, 50.0,
+        100.0, 50.0,
+
+        113.8071, 50.0,
+        125.0, 72.3858,
+        125.0, 100.0,
+
+        100.0, 100.0
+      ])
+    end
+
+    it 'moves the pointer to the center of the ellipse after drawing' do
+      expect(curve.coords[-2..-1]).to eq([100, 100])
+    end
+  end
+
+  describe 'When drawing a circle' do
+    let(:curve) do
+      pdf.circle [100, 100], 25
+      pdf.ellipse [100, 100], 25, 25
+      PDF::Inspector::Graphics::Curve.analyze(pdf.render)
+    end
+
+    it 'strokes the same path as the equivalent ellipse' do
+      middle = curve.coords.length / 2
+      expect(curve.coords[0...middle]).to eq(curve.coords[middle..-1])
+    end
+  end
+
+  describe 'When filling' do
+    it 'defaults to the f operator (nonzero winding number rule)' do
+      allow(pdf.renderer).to receive(:add_content).with('f')
+      pdf.fill
+      expect(pdf.renderer).to have_received(:add_content).with('f')
+    end
+
+    it 'uses f* for :fill_rule => :even_odd' do
+      allow(pdf.renderer).to receive(:add_content).with('f*')
+      pdf.fill(fill_rule: :even_odd)
+      expect(pdf.renderer).to have_received(:add_content).with('f*')
+    end
+
+    it 'uses b by default for fill_and_stroke (nonzero winding number)' do
+      allow(pdf.renderer).to receive(:add_content).with('b')
+      pdf.fill_and_stroke
+      expect(pdf.renderer).to have_received(:add_content).with('b')
+    end
+
+    it 'uses b* for fill_and_stroke(:fill_rule => :even_odd)' do
+      allow(pdf.renderer).to receive(:add_content).with('b*')
+      pdf.fill_and_stroke(fill_rule: :even_odd)
+      expect(pdf.renderer).to have_received(:add_content).with('b*')
+    end
+  end
+
+  describe 'When setting colors' do
+    it 'sets stroke colors' do
+      pdf.stroke_color 'ffcccc'
+      colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+      # 100% red, 80% green, 80% blue
+      expect(colors.stroke_color).to eq([1.0, 0.8, 0.8])
+    end
+
+    it 'sets fill colors' do
+      pdf.fill_color 'ccff00'
+      colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+      # 80% red, 100% green, 0% blue
+      expect(colors.fill_color).to eq([0.8, 1.0, 0])
+    end
+
+    it 'raises an error for a color with a leading #' do
+      expect { pdf.fill_color '#ccff00' }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error for a color string that is not a hex' do
+      expect { pdf.fill_color 'zcff00' }.to raise_error(ArgumentError)
+    end
+
+    it 'resets the colors on each new page if they have been defined' do
+      pdf.fill_color 'ccff00'
+
+      pdf.start_new_page
+      pdf.stroke_color 'ff00cc'
+
+      pdf.start_new_page
+      colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+      expect(colors.fill_color_count).to eq(3)
+      expect(colors.stroke_color_count).to eq(2)
+
+      expect(colors.fill_color).to eq([0.8, 1.0, 0.0])
+      expect(colors.stroke_color).to eq([1.0, 0.0, 0.8])
+    end
+
+    it 'sets the color space when setting colors on new pages to please fussy '\
+      'readers' do
+      pdf.stroke_color '000000'
+      pdf.stroke { pdf.rectangle([10, 10], 10, 10) }
+      pdf.start_new_page
+      pdf.stroke_color '000000'
+      pdf.stroke { pdf.rectangle([10, 10], 10, 10) }
+      colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+      expect(colors.stroke_color_space_count[:DeviceRGB]).to eq(2)
+    end
+  end
+
+  describe 'Patterns' do
+    describe 'linear gradients' do
+      it 'creates a /Pattern resource' do
+        pdf.fill_gradient(
+          [0, pdf.bounds.height],
+          [pdf.bounds.width, pdf.bounds.height],
+          'FF0000', '0000FF'
+        )
+
+        grad = PDF::Inspector::Graphics::Pattern.analyze(pdf.render)
+        pattern = grad.patterns.values.first
+
+        expect(pattern).to_not be_nil
+        expect(pattern[:Shading][:ShadingType]).to eq(2)
+        expect(pattern[:Shading][:Coords]).to eq([0, 0, pdf.bounds.width, 0])
+        expect(pattern[:Shading][:Function][:C0].zip([1, 0, 0]).all? do |x1, x2|
+          (x1 - x2).abs < 0.01
+        end).to eq true
+        expect(pattern[:Shading][:Function][:C1].zip([0, 0, 1]).all? do |x1, x2|
+          (x1 - x2).abs < 0.01
+        end).to eq true
+      end
+
+      it 'fill_gradient should set fill color to the pattern' do
+        pdf.fill_gradient(
+          [0, pdf.bounds.height],
+          [pdf.bounds.width, pdf.bounds.height],
+          'FF0000', '0000FF'
+        )
+
+        str = pdf.render
+        expect(str).to match(%r{/Pattern\s+cs\s*/SP\h{40}\s+scn})
+      end
+
+      it 'stroke_gradient should set stroke color to the pattern' do
+        pdf.stroke_gradient(
+          [0, pdf.bounds.height],
+          [pdf.bounds.width, pdf.bounds.height],
+          'FF0000', '0000FF'
+        )
+
+        str = pdf.render
+        expect(str).to match(%r{/Pattern\s+CS\s*/SP\h{40}\s+SCN})
+      end
+
+      it 'uses a stitching function to render a gradient with multiple stops' do
+        pdf.fill_gradient(
+          from: [0, pdf.bounds.height],
+          to: [pdf.bounds.width, pdf.bounds.height],
+          stops: { 0 => 'FF0000', 0.8 => '00FF00', 1 => '0000FF' }
+        )
+
+        grad = PDF::Inspector::Graphics::Pattern.analyze(pdf.render)
+        pattern = grad.patterns.values.first
+
+        expect(pattern).to_not be_nil
+
+        stitching = pattern[:Shading][:Function]
+        expect(stitching[:FunctionType]).to eq(3)
+        expect(stitching[:Functions]).to be_an(Array)
+        expect(stitching[:Functions].map { |f| f[:C0] })
+          .to eq([[1, 0, 0], [0, 1, 0]])
+        expect(stitching[:Functions].map { |f| f[:C1] })
+          .to eq([[0, 1, 0], [0, 0, 1]])
+        expect(stitching[:Bounds]).to eq([0.8])
+        expect(stitching[:Encode]).to eq([0, 1, 0, 1])
+      end
+
+      it 'uses a stitching function to render a gradient with equally spaced '\
+        'stops' do
+        pdf.fill_gradient(
+          from: [0, pdf.bounds.height],
+          to: [pdf.bounds.width, pdf.bounds.height],
+          stops: %w[FF0000 00FF00 0000FF]
+        )
+
+        grad = PDF::Inspector::Graphics::Pattern.analyze(pdf.render)
+        pattern = grad.patterns.values.first
+
+        expect(pattern).to_not be_nil
+
+        stitching = pattern[:Shading][:Function]
+        expect(stitching[:FunctionType]).to eq(3)
+        expect(stitching[:Functions]).to be_an(Array)
+        expect(stitching[:Functions].map { |f| f[:C0] })
+          .to eq([[1, 0, 0], [0, 1, 0]])
+        expect(stitching[:Functions].map { |f| f[:C1] })
+          .to eq([[0, 1, 0], [0, 0, 1]])
+        expect(stitching[:Bounds]).to eq([0.5])
+      end
+    end
+
+    describe 'radial gradients' do
+      it 'creates a /Pattern resource' do
+        pdf.fill_gradient(
+          [0, pdf.bounds.height], 10,
+          [pdf.bounds.width, pdf.bounds.height], 20,
+          'FF0000', '0000FF'
+        )
+
+        grad = PDF::Inspector::Graphics::Pattern.analyze(pdf.render)
+        pattern = grad.patterns.values.first
+
+        expect(pattern).to_not be_nil
+        expect(pattern[:Shading][:ShadingType]).to eq(3)
+        expect(pattern[:Shading][:Coords])
+          .to eq([0, 0, 10, pdf.bounds.width, 0, 20])
+        expect(pattern[:Shading][:Function][:C0].zip([1, 0, 0]).all? do |x1, x2|
+          (x1 - x2).abs < 0.01
+        end).to eq true
+        expect(pattern[:Shading][:Function][:C1].zip([0, 0, 1]).all? do |x1, x2|
+          (x1 - x2).abs < 0.01
+        end).to eq true
+      end
+
+      it 'fill_gradient should set fill color to the pattern' do
+        pdf.fill_gradient(
+          [0, pdf.bounds.height], 10,
+          [pdf.bounds.width, pdf.bounds.height], 20,
+          'FF0000', '0000FF'
+        )
+
+        str = pdf.render
+        expect(str).to match(%r{/Pattern\s+cs\s*/SP\h{40}\s+scn})
+      end
+
+      it 'stroke_gradient should set stroke color to the pattern' do
+        pdf.stroke_gradient(
+          [0, pdf.bounds.height], 10,
+          [pdf.bounds.width, pdf.bounds.height], 20,
+          'FF0000', '0000FF'
+        )
+
+        str = pdf.render
+        expect(str).to match(%r{/Pattern\s+CS\s*/SP\h{40}\s+SCN})
+      end
+    end
+
+    describe 'gradient transformations' do
+      subject do
+        pdf.scale 2 do
+          pdf.translate 40, 40 do
+            pdf.fill_gradient [0, 10], [15, 15], 'FF0000', '0000FF', opts
+            pdf.fill_gradient [0, 10], 15, [15, 15], 25, 'FF0000', '0000FF',
+              opts
+          end
+        end
+
+        grad = PDF::Inspector::Graphics::Pattern.analyze(pdf.render)
+        grad.patterns.values.map { |pattern| pattern[:Matrix] }.uniq
+      end
+
+      context 'when :apply_transformations is true' do
+        let(:opts) { { apply_transformations: true } }
+
+        it 'uses the transformation stack to translate user co-ordinates to '\
+          'document co-ordinates required by /Pattern' do
+          is_expected.to eq([[2, 0, 0, 2, 80, 100]])
+        end
+      end
+
+      context 'when :apply_transformations is false' do
+        let(:opts) { { apply_transformations: false } }
+
+        it "doesn't transform the gradient" do
+          is_expected.to eq([[1, 0, 0, 1, 0, 10]])
+        end
+      end
+
+      context 'when :apply_transformations is unset' do
+        let(:opts) { {} }
+
+        it "doesn't transform the gradient and displays a warning" do
+          allow(pdf).to receive(:warn).twice
+          is_expected.to eq([[1, 0, 0, 1, 0, 10]])
+          expect(pdf).to have_received(:warn).twice
+        end
+      end
+    end
+  end
+
+  describe 'When using painting shortcuts' do
+    it 'converts stroke_some_method(args) into some_method(args); stroke' do
+      allow(pdf).to receive(:line_to).with([100, 100])
+      allow(pdf).to receive(:stroke)
+
+      pdf.stroke_line_to [100, 100]
+
+      expect(pdf).to have_received(:line_to).with([100, 100])
+      expect(pdf).to have_received(:stroke)
+    end
+
+    it 'converts fill_some_method(args) into some_method(args); fill' do
+      allow(pdf).to receive(:line_to).with([100, 100])
+      allow(pdf).to receive(:fill)
+
+      pdf.fill_line_to [100, 100]
+
+      expect(pdf).to have_received(:line_to).with([100, 100])
+      expect(pdf).to have_received(:fill)
+    end
+
+    it 'does not break method_missing' do
+      expect { pdf.i_have_a_pretty_girlfriend_named_jia }
+        .to raise_error(NoMethodError)
+    end
+  end
+
+  describe 'When using graphics states' do
+    it 'adds the right content on save_graphics_state' do
+      allow(pdf.renderer).to receive(:add_content).with('q')
+
+      pdf.save_graphics_state
+
+      expect(pdf.renderer).to have_received(:add_content).with('q')
+    end
+
+    it 'adds the right content on restore_graphics_state' do
+      allow(pdf.renderer).to receive(:add_content).with('Q')
+
+      pdf.restore_graphics_state
+
+      expect(pdf.renderer).to have_received(:add_content).with('Q')
+    end
+
+    it 'saves and restore when save_graphics_state is used with a block' do
+      allow(pdf.renderer).to receive(:add_content).with('q')
+      allow(pdf).to receive(:foo)
+      allow(pdf.renderer).to receive(:add_content).with('Q')
+
+      pdf.save_graphics_state do
+        pdf.foo
+      end
+
+      expect(pdf.renderer).to have_received(:add_content).with('q').ordered
+      expect(pdf).to have_received(:foo).ordered
+      expect(pdf.renderer).to have_received(:add_content).with('Q').ordered
+    end
+
+    it 'adds the previous color space when restoring to a graphic state with '\
+      'different color space' do
+      pdf.stroke_color '000000'
+      pdf.save_graphics_state
+      pdf.stroke_color 0, 0, 0, 0
+      pdf.restore_graphics_state
+      pdf.stroke_color 0, 0, 100, 0
+      expect(pdf.graphic_state.color_space).to eq(stroke: :DeviceCMYK)
+      colors = PDF::Inspector::Graphics::Color.analyze(pdf.render)
+      expect(colors.color_space).to eq(:DeviceCMYK)
+      expect(colors.stroke_color_space_count[:DeviceCMYK]).to eq(2)
+    end
+
+    it 'uses the correct dash setting after restoring and starting new page' do
+      pdf.dash 5
+      pdf.save_graphics_state
+      pdf.dash 10
+      expect(pdf.graphic_state.dash[:dash]).to eq(10)
+      pdf.restore_graphics_state
+      pdf.start_new_page
+      expect(pdf.graphic_state.dash[:dash]).to eq(5)
+    end
+
+    it 'rounds dash values to four decimal places' do
+      pdf.dash 5.12345
+      expect(pdf.graphic_state.dash_setting).to eq('[5.1235 5.1235] 0.0 d')
+    end
+
+    it 'raises an error when dash is called w. a zero length or space' do
+      expect { pdf.dash(0) }.to raise_error(ArgumentError)
+      expect { pdf.dash([0]) }.to raise_error(ArgumentError)
+      expect { pdf.dash([0, 0]) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error when dash is called w. negative lengths' do
+      expect { pdf.dash(-1) }.to raise_error(ArgumentError)
+      expect { pdf.dash([1, -3]) }.to raise_error(ArgumentError)
+    end
+
+    it 'the current graphic state keeps track of previous unchanged settings' do
+      pdf.stroke_color '000000'
+      pdf.save_graphics_state
+      pdf.dash 5
+      pdf.save_graphics_state
+      pdf.cap_style :round
+      pdf.save_graphics_state
+      pdf.fill_color 0, 0, 100, 0
+      pdf.save_graphics_state
+
+      expect(pdf.graphic_state.stroke_color).to eq('000000')
+      expect(pdf.graphic_state.join_style).to eq(:miter)
+      expect(pdf.graphic_state.fill_color).to eq([0, 0, 100, 0])
+      expect(pdf.graphic_state.cap_style).to eq(:round)
+      expect(pdf.graphic_state.color_space)
+        .to eq(fill: :DeviceCMYK, stroke: :DeviceRGB)
+      expect(pdf.graphic_state.dash).to eq(space: 5, phase: 0, dash: 5)
+      expect(pdf.graphic_state.line_width).to eq(1)
+    end
+
+    it "doesn't add extra graphic space closings when rendering multiple " \
+      'times' do
+      pdf.render
+      state = PDF::Inspector::Graphics::State.analyze(pdf.render)
+      expect(state.save_graphics_state_count).to eq(1)
+      expect(state.restore_graphics_state_count).to eq(1)
+    end
+
+    it 'adds extra graphic state enclosings when content is added on multiple '\
+      'renderings' do
+      pdf.render
+      pdf.text 'Adding a bit more content'
+      state = PDF::Inspector::Graphics::State.analyze(pdf.render)
+      expect(state.save_graphics_state_count).to eq(2)
+      expect(state.restore_graphics_state_count).to eq(2)
+    end
+
+    it 'adds extra graphic state enclosings when new settings are applied on '\
+      'multiple renderings' do
+      pdf.render
+      pdf.stroke_color 0, 0, 0, 0
+      state = PDF::Inspector::Graphics::State.analyze(pdf.render)
+      expect(state.save_graphics_state_count).to eq(2)
+      expect(state.restore_graphics_state_count).to eq(2)
+    end
+
+    it 'raise_errors error if closing an empty graphic stack' do
+      expect do
+        pdf.render
+        pdf.restore_graphics_state
+      end.to raise_error(PDF::Core::Errors::EmptyGraphicStateStack)
+    end
+
+    it 'copies mutable attributes when passing a previous_state to '\
+      'the initializer' do
+      new_state = PDF::Core::GraphicState.new(pdf.graphic_state)
+
+      [:color_space, :dash, :fill_color, :stroke_color].each do |attr|
+        expect(new_state.send(attr)).to eq(pdf.graphic_state.send(attr))
+        expect(new_state.send(attr)).to_not equal(pdf.graphic_state.send(attr))
+      end
+    end
+
+    it 'copies mutable attributes when duping' do
+      new_state = pdf.graphic_state.dup
+
+      [:color_space, :dash, :fill_color, :stroke_color].each do |attr|
+        expect(new_state.send(attr)).to eq(pdf.graphic_state.send(attr))
+        expect(new_state.send(attr)).to_not equal(pdf.graphic_state.send(attr))
+      end
+    end
+  end
+
+  describe 'When using transformation matrix' do
+    # Note: The (approximate) number of significant decimal digits of precision
+    # in fractional part is 5 (PDF Reference, Third Edition, p. 706)
+
+    it 'sends the right content on transformation_matrix' do
+      allow(pdf.renderer).to receive(:add_content)
+        .with('1.00000 0.00000 0.12346 -1.00000 5.50000 20.00000 cm')
+      pdf.transformation_matrix 1, 0, 0.123456789, -1.0, 5.5, 20
+      expect(pdf.renderer).to have_received(:add_content)
+        .with('1.00000 0.00000 0.12346 -1.00000 5.50000 20.00000 cm')
+    end
+
+    it 'uses fixed digits with very small number' do
+      values = Array.new(6, 0.000000000001)
+      string = Array.new(6, '0.00000').join ' '
+      allow(pdf.renderer).to receive(:add_content).with("#{string} cm")
+      pdf.transformation_matrix(*values)
+      expect(pdf.renderer).to have_received(:add_content).with("#{string} cm")
+    end
+
+    it 'is received by the inspector' do
+      pdf.transformation_matrix 1, 0, 0, -1, 5.5, 20
+      matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+      expect(matrices.matrices).to eq([[1, 0, 0, -1, 5.5, 20]])
+    end
+
+    it 'saves the graphics state inside the given block' do
+      values = Array.new(6, 0.000000000001)
+      string = Array.new(6, '0.00000').join ' '
+
+      allow(pdf).to receive(:save_graphics_state).with(no_args)
+      allow(pdf.renderer).to receive(:add_content).with(any_args).twice
+      allow(pdf.renderer).to receive(:add_content).with("#{string} cm")
+      allow(pdf).to receive(:do_something)
+      allow(pdf).to receive(:restore_graphics_state).with(no_args)
+
+      pdf.transformation_matrix(*values) do
+        pdf.do_something
+      end
+
+      expect(pdf).to have_received(:save_graphics_state).with(no_args).ordered
+      expect(pdf.renderer).to have_received(:add_content).with("#{string} cm")
+        .ordered
+      expect(pdf).to have_received(:do_something).ordered
+      expect(pdf).to have_received(:restore_graphics_state).with(no_args)
+        .ordered
+    end
+  end
+
+  describe 'When using transformations shortcuts' do
+    let(:x) { 12 }
+    let(:y) { 54.32 }
+    let(:angle) { 12.32 }
+    let(:cos) { Math.cos(angle * Math::PI / 180) }
+    let(:sin) { Math.sin(angle * Math::PI / 180) }
+    let(:factor) { 0.12 }
+
+    describe '#rotate' do
+      it 'rotates' do
+        allow(pdf).to receive(:transformation_matrix)
+          .with(cos, sin, -sin, cos, 0, 0)
+        pdf.rotate(angle)
+        expect(pdf).to have_received(:transformation_matrix)
+          .with(cos, sin, -sin, cos, 0, 0)
+      end
+    end
+
+    describe '#rotate with :origin option' do
+      it 'rotates around the origin' do
+        x_prime = x * cos - y * sin
+        y_prime = x * sin + y * cos
+
+        pdf.rotate(angle, origin: [x, y]) { pdf.text('hello world') }
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x - x_prime),
+          reduce_precision(y - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+      end
+
+      it 'rotates around the origin in a document with a margin' do
+        pdf = Prawn::Document.new
+
+        pdf.rotate(angle, origin: [x, y]) { pdf.text('hello world') }
+
+        x_ = x + pdf.bounds.absolute_left
+        y_ = y + pdf.bounds.absolute_bottom
+        x_prime = x_ * cos - y_ * sin
+        y_prime = x_ * sin + y_ * cos
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x_ - x_prime),
+          reduce_precision(y_ - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+      end
+
+      it 'raise_errors BlockRequired if no block is given' do
+        expect do
+          pdf.rotate(angle, origin: [x, y])
+        end.to raise_error(Prawn::Errors::BlockRequired)
+      end
+
+      def reduce_precision(float)
+        (format '%.5f', float).to_f
+      end
+    end
+
+    describe '#translate' do
+      it 'translates' do
+        x = 12
+        y = 54.32
+        allow(pdf).to receive(:transformation_matrix).with(1, 0, 0, 1, x, y)
+        pdf.translate(x, y)
+        expect(pdf).to have_received(:transformation_matrix)
+          .with(1, 0, 0, 1, x, y)
+      end
+    end
+
+    describe '#scale' do
+      it 'scales' do
+        allow(pdf).to receive(:transformation_matrix)
+          .with(factor, 0, 0, factor, 0, 0)
+        pdf.scale(factor)
+        expect(pdf).to have_received(:transformation_matrix)
+          .with(factor, 0, 0, factor, 0, 0)
+      end
+    end
+
+    describe '#scale with :origin option' do
+      it 'scales from the origin' do
+        x_prime = factor * x
+        y_prime = factor * y
+
+        pdf.scale(factor, origin: [x, y]) { pdf.text('hello world') }
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x - x_prime),
+          reduce_precision(y - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([factor, 0, 0, factor, 0, 0])
+      end
+
+      it 'scales from the origin in a document with a margin' do
+        pdf = Prawn::Document.new
+        x_ = x + pdf.bounds.absolute_left
+        y_ = y + pdf.bounds.absolute_bottom
+        x_prime = factor * x_
+        y_prime = factor * y_
+
+        pdf.scale(factor, origin: [x, y]) { pdf.text('hello world') }
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x_ - x_prime),
+          reduce_precision(y_ - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([factor, 0, 0, factor, 0, 0])
+      end
+
+      it 'raise_errors BlockRequired if no block is given' do
+        expect do
+          pdf.scale(factor, origin: [x, y])
+        end.to raise_error(Prawn::Errors::BlockRequired)
+      end
+
+      def reduce_precision(float)
+        (format '%.5f', float).to_f
+      end
+    end
+  end
+end