prawn 2.4.0 → 2.5.0

data/spec/prawn/graphics_stroke_styles_spec.rb

@@ -1,229 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,283 +0,0 @@
-# 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