prawn 2.3.0 → 2.5.0

data/spec/prawn/repeater_spec.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Prawn::Repeater do
-  it 'creates a stamp and increments Prawn::Repeater.count on initialize' do
-    orig_count = described_class.count
-
-    doc = sample_document
-    allow(doc).to receive(:create_stamp).with("prawn_repeater(#{orig_count})")
-
-    repeater(doc, :all) { :do_nothing }
-
-    expect(doc).to have_received(:create_stamp)
-      .with("prawn_repeater(#{orig_count})")
-
-    expect(described_class.count).to eq(orig_count + 1)
-  end
-
-  it 'must provide an :all filter' do
-    doc = sample_document
-    r = repeater(doc, :all) { :do_nothing }
-
-    expect((1..doc.page_count).all? { |i| r.match?(i) }).to eq true
-  end
-
-  it 'must provide an :odd filter' do
-    doc = sample_document
-    r = repeater(doc, :odd) { :do_nothing }
-
-    odd, even = (1..doc.page_count).partition(&:odd?)
-
-    expect(odd.all? { |i| r.match?(i) }).to eq true
-    expect(even.any? { |i| r.match?(i) }).to eq false
-  end
-
-  it 'must be able to filter by an array of page numbers' do
-    doc = sample_document
-    r = repeater(doc, [1, 2, 7]) { :do_nothing }
-
-    expect((1..10).select { |i| r.match?(i) }).to eq([1, 2, 7])
-  end
-
-  it 'must be able to filter by a range of page numbers' do
-    doc = sample_document
-    r = repeater(doc, 2..4) { :do_nothing }
-
-    expect((1..10).select { |i| r.match?(i) }).to eq([2, 3, 4])
-  end
-
-  it 'must be able to filter by an arbitrary proc' do
-    doc = sample_document
-    r = repeater(doc, ->(x) { x == 1 || x % 3 == 0 })
-
-    expect((1..10).select { |i| r.match?(i) }).to eq([1, 3, 6, 9])
-  end
-
-  it 'must try to run a stamp if the page number matches' do
-    doc = sample_document
-    allow(doc).to receive(:stamp)
-
-    repeater(doc, :odd).run(3)
-    expect(doc).to have_received(:stamp)
-  end
-
-  it 'must not try to run a stamp unless the page number matches' do
-    doc = sample_document
-
-    allow(doc).to receive(:stamp)
-    repeater(doc, :odd).run(2)
-    expect(doc).to_not have_received(:stamp)
-  end
-
-  it 'must not try to run a stamp if dynamic is selected' do
-    doc = sample_document
-
-    allow(doc).to receive(:stamp)
-    (1..10).each { |p| repeater(doc, :all, true) { :do_nothing }.run(p) }
-    expect(doc).to_not have_received(:stamp)
-  end
-
-  it 'must try to run a block if the page number matches' do
-    doc = sample_document
-
-    allow(doc).to receive(:draw_text)
-    (1..10).each do |p|
-      repeater(doc, [1, 2], true) { doc.draw_text 'foo' }.run(p)
-    end
-    expect(doc).to have_received(:draw_text).twice
-  end
-
-  it 'must not try to run a block unless the page number matches' do
-    doc = sample_document
-
-    allow(doc).to receive(:draw_text)
-    repeater(doc, :odd, true) { doc.draw_text 'foo' }.run(2)
-    expect(doc).to_not have_received(:draw_text)
-  end
-
-  it 'must treat any block as a closure' do
-    doc = sample_document
-
-    page = 'Page' # ensure access to ivars
-    doc.repeat(:all, dynamic: true) do
-      doc.draw_text "#{page} #{doc.page_number}", at: [500, 0]
-    end
-
-    text = PDF::Inspector::Text.analyze(doc.render)
-    expect(text.strings).to eq((1..10).to_a.map { |p| "Page #{p}" })
-  end
-
-  it 'must treat any block as a closure (Document.new instance_eval form)' do
-    doc = Prawn::Document.new(skip_page_creation: true) do
-      10.times { start_new_page }
-
-      page = 'Page'
-      repeat(:all, dynamic: true) do
-        # ensure self is accessible here
-        draw_text "#{page} #{page_number}", at: [500, 0]
-      end
-    end
-
-    text = PDF::Inspector::Text.analyze(doc.render)
-    expect(text.strings).to eq((1..10).to_a.map { |p| "Page #{p}" })
-  end
-
-  def sample_document
-    doc = Prawn::Document.new(skip_page_creation: true)
-    10.times { |_e| doc.start_new_page }
-    doc
-  end
-
-  def repeater(*args, &block)
-    Prawn::Repeater.new(*args, &block)
-  end
-
-  describe 'graphic state' do
-    let(:pdf) { create_pdf }
-
-    it 'does not alter the graphic state stack color space' do
-      starting_color_space = pdf.state.page.graphic_state.color_space.dup
-      pdf.repeat :all do
-        pdf.text 'Testing', size: 24, style: :bold
-      end
-      expect(pdf.state.page.graphic_state.color_space)
-        .to eq(starting_color_space)
-    end
-
-    context 'with dynamic repeaters' do
-      it 'preserves the graphic state at creation time' do
-        pdf.repeat :all, dynamic: true do
-          pdf.text "fill_color: #{pdf.graphic_state.fill_color}"
-          pdf.text "cap_style: #{pdf.graphic_state.cap_style}"
-        end
-        pdf.fill_color '666666'
-        pdf.cap_style :round
-        text = PDF::Inspector::Text.analyze(pdf.render)
-        expect(text.strings.include?('fill_color: 666666')).to eq(false)
-        expect(text.strings.include?('fill_color: 000000')).to eq(true)
-        expect(text.strings.include?('cap_style: round')).to eq(false)
-        expect(text.strings.include?('cap_style: butt')).to eq(true)
-      end
-    end
-  end
-end

data/spec/prawn/soft_mask_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Prawn::SoftMask do
-  let(:pdf) { create_pdf }
-
-  def make_soft_mask
-    pdf.save_graphics_state do
-      pdf.soft_mask do
-        if block_given?
-          yield
-        else
-          pdf.fill_color '808080'
-          pdf.fill_rectangle [100, 100], 200, 200
-        end
-      end
-
-      pdf.fill_color '000000'
-      pdf.fill_rectangle [0, 0], 200, 200
-    end
-  end
-
-  it 'has PDF version at least 1.4' do
-    make_soft_mask
-    str = pdf.render
-    expect(str[0, 8]).to eq('%PDF-1.4')
-  end
-
-  it 'creates a new extended graphics state for each unique soft mask' do
-    make_soft_mask do
-      pdf.fill_color '808080'
-      pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    make_soft_mask do
-      pdf.fill_color '808080'
-      pdf.fill_rectangle [10, 10], 200, 200
-    end
-
-    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
-    expect(extgstates.length).to eq(2)
-  end
-
-  it 'a new extended graphics state contains soft mask with drawing '\
-    'instructions' do
-    make_soft_mask do
-      pdf.fill_color '808080'
-      pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates.first
-    expect(extgstate[:soft_mask][:G].data).to eq(
-      "q\n/DeviceRGB cs\n0.0 0.0 0.0 scn\n/DeviceRGB CS\n0.0 0.0 0.0 SCN\n"\
-      "1 w\n0 J\n0 j\n[] 0 d\n/DeviceRGB cs\n0.502 0.502 0.502 scn\n"\
-      "100.0 -100.0 200.0 200.0 re\nf\nQ\n"
-    )
-  end
-
-  it 'does not create duplicate extended graphics states' do
-    make_soft_mask do
-      pdf.fill_color '808080'
-      pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    make_soft_mask do
-      pdf.fill_color '808080'
-      pdf.fill_rectangle [100, 100], 200, 200
-    end
-
-    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
-    expect(extgstates.length).to eq(1)
-  end
-end

data/spec/prawn/stamp_spec.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Prawn::Stamp do
-  describe 'create_stamp before any page is added' do
-    let(:pdf) { Prawn::Document.new(skip_page_creation: true) }
-
-    it 'works with the font class' do
-      # If anything goes wrong, Prawn::Errors::NotOnPage will be raised
-      pdf.create_stamp('my_stamp') do
-        pdf.font.height
-      end
-    end
-
-    it 'works with setting color' do
-      # If anything goes wrong, Prawn::Errors::NotOnPage will be raised
-      pdf.create_stamp('my_stamp') do
-        pdf.fill_color = 'ff0000'
-      end
-    end
-  end
-
-  describe '#stamp_at' do
-    let(:pdf) { create_pdf }
-
-    it 'works' do
-      pdf.create_stamp('MyStamp')
-      pdf.stamp_at('MyStamp', [100, 200])
-      # I had modified PDF::Inspector::XObject to receive the
-      # invoke_xobject message and count the number of times it was
-      # called, but it was only called once, so I reverted checking the
-      # output with a regular expression
-      expect(pdf.render).to match(%r{/Stamp1 Do.*?}m)
-    end
-  end
-
-  describe 'Document with a stamp' do
-    let(:pdf) { create_pdf }
-
-    it 'raises NameTaken error when attempt to create stamp with '\
-       'same name as an existing stamp' do
-      pdf.create_stamp('MyStamp')
-      expect do
-        pdf.create_stamp('MyStamp')
-      end.to raise_error(Prawn::Errors::NameTaken)
-    end
-
-    it 'raises InvalidName error when attempt to create stamp with '\
-        'a blank name' do
-      expect do
-        pdf.create_stamp('')
-      end.to raise_error(Prawn::Errors::InvalidName)
-    end
-
-    it 'a new XObject should be defined for each stamp created' do
-      pdf.create_stamp('MyStamp')
-      pdf.create_stamp('AnotherStamp')
-      pdf.stamp('MyStamp')
-      pdf.stamp('AnotherStamp')
-
-      inspector = PDF::Inspector::XObject.analyze(pdf.render)
-      xobjects = inspector.page_xobjects.last
-      expect(xobjects.length).to eq(2)
-    end
-
-    it 'calling stamp with a name that does not match an existing stamp ' \
-      'should raise_error UndefinedObjectName' do
-      pdf.create_stamp('MyStamp')
-      expect do
-        pdf.stamp('OtherStamp')
-      end.to raise_error(Prawn::Errors::UndefinedObjectName)
-    end
-
-    it 'stamp should be drawn into the document each time stamp is called' do
-      pdf.create_stamp('MyStamp')
-      pdf.stamp('MyStamp')
-      pdf.stamp('MyStamp')
-      pdf.stamp('MyStamp')
-      # I had modified PDF::Inspector::XObject to receive the
-      # invoke_xobject message and count the number of times it was
-      # called, but it was only called once, so I reverted checking the
-      # output with a regular expression
-      expect(pdf.render).to match(%r{(/Stamp1 Do.*?){3}}m)
-    end
-
-    it 'stamp should render clickable links' do
-      pdf.create_stamp 'bar' do
-        pdf.text '<b>Prawn</b> <link href="http://github.com">GitHub</link>',
-          inline_format: true
-      end
-      pdf.stamp 'bar'
-
-      output = pdf.render
-      objects = output.split('endobj')
-
-      objects.each do |obj|
-        next unless %r{/Type /Page$}.match?(obj)
-
-        # The page object must contain the annotation reference
-        # to render a clickable link
-        expect(obj).to match(%r{^/Annots \[\d \d .\]$})
-      end
-    end
-
-    it 'resources added during stamp creation should be added to the ' \
-      'stamp XObject, not the page' do
-      pdf.create_stamp('MyStamp') do
-        pdf.transparent(0.5) { pdf.circle([100, 100], 10) }
-      end
-      pdf.stamp('MyStamp')
-
-      # Inspector::XObject does not give information about resources, so
-      # resorting to string matching
-
-      output = pdf.render
-      objects = output.split('endobj')
-      objects.each do |object|
-        if %r{/Type /Page$}.match?(object)
-          expect(object).to_not match(%r{/ExtGState})
-        elsif %r{/Type /XObject$}.match?(object)
-          expect(object).to match(%r{/ExtGState})
-        end
-      end
-    end
-
-    it 'stamp stream should be wrapped in a graphic state' do
-      pdf.create_stamp('MyStamp') do
-        pdf.text "This should have a 'q' before it and a 'Q' after it"
-      end
-      pdf.stamp('MyStamp')
-      stamps = PDF::Inspector::XObject.analyze(pdf.render)
-      expect(stamps.xobject_streams[:Stamp1].data.chomp).to match(/q(.|\s)*Q\Z/)
-    end
-
-    it 'does not add to the page graphic state stack' do
-      expect(pdf.state.page.stack.stack.size).to eq(1)
-
-      pdf.create_stamp('MyStamp') do
-        pdf.save_graphics_state
-        pdf.save_graphics_state
-        pdf.save_graphics_state
-        pdf.text "This should have a 'q' before it and a 'Q' after it"
-        pdf.restore_graphics_state
-      end
-      expect(pdf.state.page.stack.stack.size).to eq(1)
-    end
-
-    it 'is able to change fill and stroke colors within the stamp stream' do
-      pdf.create_stamp('MyStamp') do
-        pdf.fill_color(100, 100, 20, 0)
-        pdf.stroke_color(100, 100, 20, 0)
-      end
-      pdf.stamp('MyStamp')
-      stamps = PDF::Inspector::XObject.analyze(pdf.render)
-      stamp_stream = stamps.xobject_streams[:Stamp1].data
-      expect(stamp_stream).to include("/DeviceCMYK cs\n1.0 1.0 0.2 0.0 scn")
-      expect(stamp_stream).to include("/DeviceCMYK CS\n1.0 1.0 0.2 0.0 SCN")
-    end
-
-    it 'saves the color space even when same as current page color space' do
-      pdf.stroke_color(100, 100, 20, 0)
-      pdf.create_stamp('MyStamp') do
-        pdf.stroke_color(100, 100, 20, 0)
-      end
-      pdf.stamp('MyStamp')
-      stamps = PDF::Inspector::XObject.analyze(pdf.render)
-      stamp_stream = stamps.xobject_streams[:Stamp1].data
-      expect(stamp_stream).to include("/DeviceCMYK CS\n1.0 1.0 0.2 0.0 SCN")
-    end
-  end
-end