# frozen_string_literal: true

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 'draws 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.52285, 550.0], [100.0, 545.52285],
          [100.0, 540.0], [100.0, 460.0], [100.0, 454.47715], [95.52285, 450.0],
          [90.0, 450.0], [60.0, 450.0], [54.47715, 450.0], [50.0, 454.47715],
          [50.0, 460.0], [50.0, 540.0], [50.0, 545.52285], [54.47715, 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.61424,
          113.80712, 150,
          100.0, 150.0,

          86.19288, 150.0,
          75.0, 127.61424,
          75.0, 100.0,

          75.0, 72.38576,
          86.19288, 50.0,
          100.0, 50.0,

          113.80712, 50.0,
          125.0, 72.38576,
          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..]).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..])
    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 'raises an error for a color string with invalid characters' do
      expect { pdf.fill_color('f0f0f?') }.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? { |x1, x2| (x1 - x2).abs < 0.01 }).to be true
        expect(pattern[:Shading][:Function][:C1].zip([0, 0, 1]).all? { |x1, x2| (x1 - x2).abs < 0.01 }).to be true
      end

      it 'creates a unique ID for each pattern resource' do
        pdf.fill_gradient(
          [256, 512],
          [356, 512],
          'ffffff',
          'fe00ff',
        )
        pdf.fill_gradient(
          [256, 256],
          [356, 256],
          'ffffff',
          '0000ff',
        )

        str = pdf.render
        pattern_ids = str.scan(/SP\h{40}\s+scn/)
        expect(pattern_ids.uniq.length).to eq 2
      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? { |x1, x2| (x1 - x2).abs < 0.01 }).to be true
        expect(pattern[:Shading][:Function][:C1].zip([0, 0, 1]).all? { |x1, x2| (x1 - x2).abs < 0.01 }).to be 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(:transformations) 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
          expect(transformations).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
          expect(transformations).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
          expect(transformations).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.12345 5.12345] 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 {
        pdf.render
        pdf.restore_graphics_state
      }.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)

      %i[color_space dash fill_color stroke_color].each do |attr|
        expect(new_state.public_send(attr)).to eq(pdf.graphic_state.public_send(attr))
        expect(new_state.public_send(attr)).to_not equal(pdf.graphic_state.public_send(attr))
      end
    end

    it 'copies mutable attributes when duping' do
      new_state = pdf.graphic_state.dup

      %i[color_space dash fill_color stroke_color].each do |attr|
        expect(new_state.public_send(attr)).to eq(pdf.graphic_state.public_send(attr))
        expect(new_state.public_send(attr)).to_not equal(pdf.graphic_state.public_send(attr))
      end
    end

    it 'saves the transformation stack on graphics state save' do
      allow(pdf).to receive(:save_transformation_stack)
      allow(pdf).to receive(:restore_transformation_stack)

      pdf.save_graphics_state

      expect(pdf).to have_received(:save_transformation_stack)
      expect(pdf).to_not have_received(:restore_transformation_stack)
    end

    it 'saves and restores the transformation stack when save graphics state used in block form' do
      allow(pdf).to receive(:save_transformation_stack)
      allow(pdf).to receive(:restore_transformation_stack)

      pdf.save_graphics_state do
        # Deliberately empty block
      end

      expect(pdf).to have_received(:save_transformation_stack)
      expect(pdf).to have_received(:restore_transformation_stack)
    end

    it 'restores the transformation stack on graphics state restore' do
      allow(pdf).to receive(:restore_transformation_stack)

      pdf.restore_graphics_state

      expect(pdf).to have_received(:restore_transformation_stack)
    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.0 0.0 0.12346 -1.0 5.5 20.0 cm')
      pdf.transformation_matrix(1, 0, 0.123456789, -1.0, 5.5, 20)
      expect(pdf.renderer).to have_received(:add_content).with('1.0 0.0 0.12346 -1.0 5.5 20.0 cm')
    end

    it 'uses fixed digits with very small number' do
      values = Array.new(6, 0.000000000001)
      string = Array.new(6, '0.0').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.0').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

    it 'properly serializes the matrix', issue: 1178 do
      pdf.transformation_matrix(1, 0, 0, 1, 0.0, 1.8977874316715393e-05)
      rendered_document = pdf.render

      expect(rendered_document).to_not include('2.0e-05')

      matrices = PDF::Inspector::Graphics::Matrix.analyze(rendered_document)
      expect(matrices.matrices).to eq([[1, 0, 0, 1, 0.0, 0.00002]])
    end
  end

  describe 'When using transformations shortcuts' do
    describe '#rotate' do
      let(:angle) { 12.32 }
      let(:cos) { Math.cos(angle * Math::PI / 180) }
      let(:sin) { Math.sin(angle * Math::PI / 180) }

      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
      let(:angle) { 12.32 }
      let(:cos) { Math.cos(angle * Math::PI / 180) }
      let(:sin) { Math.sin(angle * Math::PI / 180) }

      it 'rotates around the origin' do
        x = 12
        y = 54.32
        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
        x = 12
        y = 54.32
        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 {
          pdf.rotate(angle, origin: [0, 0])
        }.to raise_error(Prawn::Errors::BlockRequired)
      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
        factor = 0.12
        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
      let(:factor) { 0.12 }

      it 'scales from the origin' do
        x = 12
        y = 54.32
        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
        x = 12
        y = 54.32
        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 {
          pdf.scale(factor, origin: [0, 0])
        }.to raise_error(Prawn::Errors::BlockRequired)
      end
    end
  end

  def reduce_precision(float)
    float.round(5)
  end
end
