prawn 2.0.2 → 2.3.0

data/spec/prawn/graphics_stroke_styles_spec.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::Graphics do
+  let(:pdf) { create_pdf }
+
+  describe 'When stroking with default settings' do
+    it 'cap_style should be :butt' do
+      expect(pdf.cap_style).to eq(:butt)
+    end
+
+    it 'join_style should be :miter' do
+      expect(pdf.join_style).to eq(:miter)
+    end
+
+    it 'dashed? should be_false' do
+      expect(pdf).to_not be_dashed
+    end
+  end
+
+  describe 'Cap styles' do
+    it 'is able to use assignment operator' do
+      pdf.cap_style = :round
+      expect(pdf.cap_style).to eq(:round)
+    end
+
+    describe '#cap_style(:butt)' do
+      it 'rendered PDF should include butt style cap' do
+        pdf.cap_style(:butt)
+        cap_style = PDF::Inspector::Graphics::CapStyle.analyze(pdf.render)
+          .cap_style
+        expect(cap_style).to eq(0)
+      end
+    end
+
+    describe '#cap_style(:round)' do
+      it 'rendered PDF should include round style cap' do
+        pdf.cap_style(:round)
+        cap_style = PDF::Inspector::Graphics::CapStyle.analyze(pdf.render)
+          .cap_style
+        expect(cap_style).to eq(1)
+      end
+    end
+
+    describe '#cap_style(:projecting_square)' do
+      it 'rendered PDF should include projecting_square style cap' do
+        pdf.cap_style(:projecting_square)
+        cap_style = PDF::Inspector::Graphics::CapStyle.analyze(pdf.render)
+          .cap_style
+        expect(cap_style).to eq(2)
+      end
+    end
+
+    it 'carries the current cap style settings over to new pages' do
+      pdf.cap_style(:round)
+      pdf.start_new_page
+      cap_styles = PDF::Inspector::Graphics::CapStyle.analyze(pdf.render)
+      expect(cap_styles.cap_style_count).to eq(2)
+      expect(cap_styles.cap_style).to eq(1)
+    end
+  end
+
+  describe 'Join styles' do
+    it 'is able to use assignment operator' do
+      pdf.join_style = :round
+      expect(pdf.join_style).to eq(:round)
+    end
+
+    describe '#join_style(:miter)' do
+      it 'rendered PDF should include miter style join' do
+        pdf.join_style(:miter)
+        join_style = PDF::Inspector::Graphics::JoinStyle.analyze(pdf.render)
+          .join_style
+        expect(join_style).to eq(0)
+      end
+    end
+
+    describe '#join_style(:round)' do
+      it 'rendered PDF should include round style join' do
+        pdf.join_style(:round)
+        join_style = PDF::Inspector::Graphics::JoinStyle.analyze(pdf.render)
+          .join_style
+        expect(join_style).to eq(1)
+      end
+    end
+
+    describe '#join_style(:bevel)' do
+      it 'rendered PDF should include bevel style join' do
+        pdf.join_style(:bevel)
+        join_style = PDF::Inspector::Graphics::JoinStyle.analyze(pdf.render)
+          .join_style
+        expect(join_style).to eq(2)
+      end
+    end
+
+    it 'carries the current join style settings over to new pages' do
+      pdf.join_style(:round)
+      pdf.start_new_page
+      join_styles = PDF::Inspector::Graphics::JoinStyle.analyze(pdf.render)
+      expect(join_styles.join_style_count).to eq(2)
+      expect(join_styles.join_style).to eq(1)
+    end
+
+    context 'with invalid arguments' do
+      it 'raises an exception' do
+        expect { pdf.join_style(:mitre) }
+          .to raise_error(Prawn::Errors::InvalidJoinStyle)
+      end
+    end
+  end
+
+  describe 'Dashes' do
+    it 'is able to use assignment operator' do
+      pdf.dash = 2
+      expect(pdf).to be_dashed
+    end
+
+    describe 'setting a dash' do
+      it 'dashed? should be_true' do
+        pdf.dash(2)
+        expect(pdf).to be_dashed
+      end
+
+      it 'rendered PDF should include a stroked dash' do
+        pdf.dash(2)
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[2, 2], 0])
+      end
+    end
+
+    describe 'setting a dash by passing a single argument' do
+      it 'space between dashes should be the same length as the dash in the '\
+        'rendered PDF' do
+        pdf.dash(2)
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[2, 2], 0])
+      end
+    end
+
+    describe 'with a space option that differs from the first argument' do
+      it 'space between dashes in the rendered PDF should be different length '\
+        'than the length of the dash' do
+        pdf.dash(2, space: 3)
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[2, 3], 0])
+      end
+    end
+
+    describe 'with a non-zero phase option' do
+      it 'rendered PDF should include a non-zero phase' do
+        pdf.dash(2, phase: 1)
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[2, 2], 1])
+      end
+    end
+
+    describe 'setting a dash by using an array' do
+      it 'dash and spaces should be set from the array' do
+        pdf.dash([1, 2, 3, 4])
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[1, 2, 3, 4], 0])
+      end
+
+      it 'at least one number in the array must not be zero' do
+        pdf.dash([1, 0])
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[1, 0], 0])
+      end
+
+      it 'space options has to be ignored' do
+        pdf.dash([1, 2, 3, 4], space: 3)
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[1, 2, 3, 4], 0])
+      end
+
+      it 'phase options should be correctly used' do
+        pdf.dash([1, 2, 3, 4], phase: 3)
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[1, 2, 3, 4], 3])
+      end
+    end
+
+    describe 'clearing stroke dash' do
+      it 'restores solid line' do
+        pdf.dash(2)
+        pdf.undash
+        dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+        expect(dashes.stroke_dash).to eq([[], 0])
+      end
+    end
+
+    it 'carries the current dash settings over to new pages' do
+      pdf.dash(2)
+      pdf.start_new_page
+      dashes = PDF::Inspector::Graphics::Dash.analyze(pdf.render)
+      expect(dashes.stroke_dash_count).to eq(2)
+      expect(dashes.stroke_dash).to eq([[2, 2], 0])
+    end
+
+    describe '#dashed?' do
+      it 'an initial document should not be dashed' do
+        expect(pdf.dashed?).to eq(false)
+      end
+
+      it 'returns true if any of the currently active settings are dashed' do
+        pdf.dash(2)
+        pdf.save_graphics_state
+        expect(pdf.dashed?).to eq(true)
+      end
+
+      it 'returns false if the document was most recently undashed' do
+        pdf.dash(2)
+        pdf.save_graphics_state
+        pdf.undash
+        pdf.save_graphics_state
+        expect(pdf.dashed?).to eq(false)
+      end
+
+      it 'returns true when restoring to a state that was dashed' do
+        pdf.dash(2)
+        pdf.save_graphics_state
+        pdf.undash
+        pdf.restore_graphics_state
+        expect(pdf.dashed?).to eq(true)
+      end
+    end
+  end
+end

data/spec/prawn/image_handler_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Prawn::ImageHandler do
+  let(:image_handler) { described_class.new }
+
+  let(:handler_a) { instance_double('Handler A') }
+  let(:handler_b) { instance_double('Handler B') }
+
+  it 'finds the image handler for an image' do
+    allow(handler_a).to receive(:can_render?).and_return(true)
+
+    image_handler.register(handler_a)
+    image_handler.register(handler_b)
+
+    handler = image_handler.find('arbitrary blob')
+    expect(handler).to eq(handler_a)
+  end
+
+  it 'can prepend handlers' do
+    allow(handler_b).to receive(:can_render?).and_return(true)
+
+    image_handler.register(handler_a)
+    image_handler.register!(handler_b)
+
+    handler = image_handler.find('arbitrary blob')
+    expect(handler).to eq(handler_b)
+  end
+
+  it 'can unregister a handler' do
+    allow(handler_b).to receive(:can_render?).and_return(true)
+
+    image_handler.register(handler_a)
+    image_handler.register(handler_b)
+
+    image_handler.unregister(handler_a)
+
+    handler = image_handler.find('arbitrary blob')
+    expect(handler).to eq(handler_b)
+  end
+
+  it 'raises an error when no matching handler is found' do
+    allow(handler_a).to receive(:can_render?).and_return(false)
+    allow(handler_b).to receive(:can_render?).and_return(false)
+
+    image_handler.register(handler_a)
+    image_handler.register(handler_b)
+
+    expect { image_handler.find('arbitrary blob') }
+      .to(raise_error(Prawn::Errors::UnsupportedImageType))
+  end
+end

data/spec/prawn/images/jpg_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Spec'ing the PNG class. Not complete yet - still needs to check the
+# contents of palette and transparency to ensure they're correct.
+# Need to find files that have these sections first.
+
+require 'spec_helper'
+
+describe Prawn::Images::JPG do
+  let(:img_data) { File.binread("#{Prawn::DATADIR}/images/pigs.jpg") }
+
+  it 'reads the basic attributes correctly' do
+    jpg = described_class.new(img_data)
+
+    expect(jpg.width).to eq(604)
+    expect(jpg.height).to eq(453)
+    expect(jpg.bits).to eq(8)
+    expect(jpg.channels).to eq(3)
+  end
+end

data/spec/prawn/images/png_spec.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+# Spec'ing the PNG class. Not complete yet - still needs to check the
+# contents of palette and transparency to ensure they're correct.
+# Need to find files that have these sections first.
+#
+# see http://www.w3.org/TR/PNG/ for a detailed description of the PNG spec,
+# particuarly Table 11.1 for the different color types
+
+require 'spec_helper'
+
+describe Prawn::Images::PNG do
+  describe 'When making a pdf file with png images' do
+    image_dir = "#{Prawn::BASEDIR}/data/images"
+    images = [
+      ['Type 0', "#{image_dir}/web-links.png"],
+      ['Type 0 with transparency', "#{image_dir}/ruport_type0.png"],
+      ['Type 2', "#{image_dir}/ruport.png"],
+      ['Type 2 with transparency', "#{image_dir}/arrow2.png"],
+      ['Type 3', "#{image_dir}/indexed_color.png"],
+      ['Type 3 with transparency', "#{image_dir}/indexed_transparency.png"],
+      ['Type 4', "#{image_dir}/page_white_text.png"],
+      ['Type 6', "#{image_dir}/dice.png"],
+      ['Type 6 in 16bit', "#{image_dir}/16bit.png"]
+    ]
+
+    images.each do |header, file|
+      describe "and the image is #{header}" do
+        it 'does not error' do
+          expect do
+            Prawn::Document.generate("#{header}.pdf", page_size: 'A5') do
+              fill_color '00FF00'
+
+              fill_rectangle bounds.top_left, bounds.width, bounds.height
+              text header
+
+              image file, at: [50, 450]
+            end
+          end.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe 'When reading a greyscale PNG file (color type 0)' do
+    let(:data_filename) { "#{Prawn::DATADIR}/images/web-links.dat" }
+    let(:img_data) { File.binread("#{Prawn::DATADIR}/images/web-links.png") }
+
+    it 'reads the attributes from the header chunk correctly' do
+      png = described_class.new(img_data)
+
+      expect(png.width).to eq(21)
+      expect(png.height).to eq(14)
+      expect(png.bits).to eq(8)
+      expect(png.color_type).to eq(0)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'reads the image data chunk correctly' do
+      png = described_class.new(img_data)
+      data = Zlib::Inflate.inflate(File.binread(data_filename))
+      expect(png.img_data).to eq(data)
+    end
+  end
+
+  describe 'When reading a greyscale PNG with transparency (color type 0)' do
+    let(:img_data) { File.binread("#{Prawn::DATADIR}/images/ruport_type0.png") }
+
+    # In a greyscale type 0 PNG image, the tRNS chunk should contain a single
+    # value that indicates the color that should be interpreted as transparent.
+    #
+    # http://www.w3.org/TR/PNG/#11tRNS
+    it 'reads the tRNS chunk correctly' do
+      png = described_class.new(img_data)
+      expect(png.transparency[:grayscale]).to eq(255)
+    end
+  end
+
+  describe 'When reading an RGB PNG file (color type 2)' do
+    let(:data_filename) { "#{Prawn::DATADIR}/images/ruport_data.dat" }
+    let(:img_data) { File.binread("#{Prawn::DATADIR}/images/ruport.png") }
+
+    it 'reads the attributes from the header chunk correctly' do
+      png = described_class.new(img_data)
+
+      expect(png.width).to eq(258)
+      expect(png.height).to eq(105)
+      expect(png.bits).to eq(8)
+      expect(png.color_type).to eq(2)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'reads the image data chunk correctly' do
+      png = described_class.new(img_data)
+      data = Zlib::Inflate.inflate(File.binread(data_filename))
+      expect(png.img_data).to eq(data)
+    end
+  end
+
+  describe 'When reading an RGB PNG file with transparency (color type 2)' do
+    let(:img_data) { File.binread("#{Prawn::DATADIR}/images/arrow2.png") }
+
+    # In a RGB type 2 PNG image, the tRNS chunk should contain a single RGB
+    # value that indicates the color that should be interpreted as transparent.
+    # In this case it's green.
+    #
+    # http://www.w3.org/TR/PNG/#11tRNS
+    it 'reads the tRNS chunk correctly' do
+      png = described_class.new(img_data)
+      expect(png.transparency[:rgb]).to eq([0, 255, 0])
+    end
+  end
+
+  describe 'When reading an indexed color PNG file with transparency '\
+    '(color type 3)' do
+    let(:filename) { "#{Prawn::DATADIR}/images/indexed_transparency.png" }
+    let(:color_filename) do
+      "#{Prawn::DATADIR}/images/indexed_transparency_color.dat"
+    end
+    let(:transparency_filename) do
+      "#{Prawn::DATADIR}/images/indexed_transparency_alpha.dat"
+    end
+    let(:img_data) { File.binread(filename) }
+    let(:png) { described_class.new(img_data) }
+
+    it 'reads the attributes from the header chunk correctly' do
+      expect(png.width).to eq(200)
+      expect(png.height).to eq(200)
+      expect(png.bits).to eq(8)
+      expect(png.color_type).to eq(3)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'reads the image data correctly' do
+      data = Zlib::Inflate.inflate(File.binread(color_filename))
+      expect(png.img_data).to eq(data)
+    end
+
+    it 'reads the image transparency correctly' do
+      png.split_alpha_channel!
+
+      data = Zlib::Inflate.inflate(File.binread(transparency_filename))
+      expect(png.alpha_channel).to eq(data)
+    end
+  end
+
+  describe 'When reading an indexed color PNG file (color type 3)' do
+    let(:data_filename) { "#{Prawn::DATADIR}/images/indexed_color.dat" }
+    let(:img_data) do
+      File.binread("#{Prawn::DATADIR}/images/indexed_color.png")
+    end
+
+    it 'reads the attributes from the header chunk correctly' do
+      png = described_class.new(img_data)
+
+      expect(png.width).to eq(150)
+      expect(png.height).to eq(200)
+      expect(png.bits).to eq(8)
+      expect(png.color_type).to eq(3)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'reads the image data chunk correctly' do
+      png = described_class.new(img_data)
+      data = Zlib::Inflate.inflate(File.binread(data_filename))
+      expect(png.img_data).to eq(data)
+    end
+  end
+
+  describe 'When reading a greyscale+alpha PNG file (color type 4)' do
+    let(:color_data_filename) do
+      "#{Prawn::DATADIR}/images/page_white_text.color"
+    end
+    let(:alpha_data_filename) do
+      "#{Prawn::DATADIR}/images/page_white_text.alpha"
+    end
+    let(:img_data) do
+      File.binread("#{Prawn::DATADIR}/images/page_white_text.png")
+    end
+
+    it 'reads the attributes from the header chunk correctly' do
+      png = described_class.new(img_data)
+
+      expect(png.width).to eq(16)
+      expect(png.height).to eq(16)
+      expect(png.bits).to eq(8)
+      expect(png.color_type).to eq(4)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'correctly returns the raw image data (with no alpha channel) from '\
+      'the image data chunk' do
+      png = described_class.new(img_data)
+      png.split_alpha_channel!
+      data = File.binread(color_data_filename)
+      expect(png.img_data).to eq(data)
+    end
+
+    it 'correctly extracts the alpha channel data from the image data chunk' do
+      png = described_class.new(img_data)
+      png.split_alpha_channel!
+      data = File.binread(alpha_data_filename)
+      expect(png.alpha_channel).to eq(data)
+    end
+  end
+
+  describe 'When reading an RGB+alpha PNG file (color type 6)' do
+    let(:color_data_filename) { "#{Prawn::DATADIR}/images/dice.color" }
+    let(:alpha_data_filename) { "#{Prawn::DATADIR}/images/dice.alpha" }
+    let(:img_data) { File.binread("#{Prawn::DATADIR}/images/dice.png") }
+
+    it 'reads the attributes from the header chunk correctly' do
+      png = described_class.new(img_data)
+
+      expect(png.width).to eq(320)
+      expect(png.height).to eq(240)
+      expect(png.bits).to eq(8)
+      expect(png.color_type).to eq(6)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'correctly returns the raw image data (with no alpha channel) from '\
+      'the image data chunk' do
+      png = described_class.new(img_data)
+      png.split_alpha_channel!
+      data = File.binread(color_data_filename)
+      expect(png.img_data).to eq(data)
+    end
+
+    it 'correctly extracts the alpha channel data from the image data chunk' do
+      png = described_class.new(img_data)
+      png.split_alpha_channel!
+      data = File.binread(alpha_data_filename)
+      expect(png.alpha_channel).to eq(data)
+    end
+  end
+
+  describe 'When reading a 16bit RGB+alpha PNG file (color type 6)' do
+    let(:color_data_filename) { "#{Prawn::DATADIR}/images/16bit.color" }
+    # alpha channel truncated to 8-bit
+    let(:alpha_data_filename) { "#{Prawn::DATADIR}/images/16bit.alpha" }
+    let(:img_data) { File.binread("#{Prawn::DATADIR}/images/16bit.png") }
+
+    it 'reads the attributes from the header chunk correctly' do
+      png = described_class.new(img_data)
+
+      expect(png.width).to eq(32)
+      expect(png.height).to eq(32)
+      expect(png.bits).to eq(16)
+      expect(png.color_type).to eq(6)
+      expect(png.compression_method).to eq(0)
+      expect(png.filter_method).to eq(0)
+      expect(png.interlace_method).to eq(0)
+    end
+
+    it 'correctly returns the raw image data (with no alpha channel) from '\
+      'the image data chunk' do
+      png = described_class.new(img_data)
+      png.split_alpha_channel!
+      data = File.binread(color_data_filename)
+      expect(png.img_data).to eq(data)
+    end
+
+    it 'correctly extracts the alpha channel data from the image data chunk' do
+      png = described_class.new(img_data)
+      png.split_alpha_channel!
+      data = File.binread(alpha_data_filename)
+      expect(png.alpha_channel).to eq(data)
+    end
+  end
+end