prawn 0.13.0 → 2.4.0

data/lib/prawn/document.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # document.rb : Implements PDF document generation for Prawn
 #
@@ -6,23 +6,21 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-require "stringio"
-require "prawn/document/bounding_box"
-require "prawn/document/column_box"
-require "prawn/document/internals"
-require "prawn/document/span"
-require "prawn/document/snapshot"
-require "prawn/document/graphics_state"
+require 'stringio'
 
-module Prawn
+require_relative 'document/bounding_box'
+require_relative 'document/column_box'
+require_relative 'document/internals'
+require_relative 'document/span'
 
+module Prawn
   # The Prawn::Document class is how you start creating a PDF document.
   #
   # There are three basic ways you can instantiate PDF Documents in Prawn, they
-  # are through assignment, implicit block or explicit block.  Below is an exmple
-  # of each type, each example does exactly the same thing, makes a PDF document
-  # with all the defaults and puts in the default font "Hello There" and then
-  # saves it to the current directory as "example.pdf"
+  # are through assignment, implicit block or explicit block.  Below is an
+  # example of each type, each example does exactly the same thing, makes a PDF
+  # document with all the defaults and puts in the default font "Hello There"
+  # and then saves it to the current directory as "example.pdf"
   #
   # For example, assignment can be like this:
   #
@@ -44,8 +42,8 @@ module Prawn
   #     pdf.text words
   #   end
   #
-  # Usually, the block forms are used when you are simply creating a PDF document
-  # that you want to immediately save or render out.
+  # Usually, the block forms are used when you are simply creating a PDF
+  # document that you want to immediately save or render out.
   #
   # See the new and generate methods for further details on the above.
   #
@@ -53,14 +51,25 @@ module Prawn
     include Prawn::Document::Internals
     include PDF::Core::Annotations
     include PDF::Core::Destinations
-    include Prawn::Document::Snapshot
-    include Prawn::Document::GraphicsState
     include Prawn::Document::Security
     include Prawn::Text
     include Prawn::Graphics
     include Prawn::Images
     include Prawn::Stamp
     include Prawn::SoftMask
+    include Prawn::TransformationStack
+
+    # @group Extension API
+
+    # NOTE: We probably need to rethink the options validation system, but this
+    # constant temporarily allows for extensions to modify the list.
+
+    VALID_OPTIONS = %i[
+      page_size page_layout margin left_margin
+      right_margin top_margin bottom_margin skip_page_creation
+      compress background info
+      text_formatter print_scaling
+    ].freeze
 
     # Any module added to this array will be included into instances of
     # Prawn::Document at the per-object level.  These will also be inherited by
@@ -82,14 +91,29 @@ module Prawn
     #     party!
     #   end
     #
+    #
     def self.extensions
       @extensions ||= []
     end
 
-    def self.inherited(base) #:nodoc:
+    # @private
+    def self.inherited(base)
+      super
       extensions.each { |e| base.extensions << e }
     end
 
+    # @group Stable Attributes
+
+    attr_accessor :margin_box
+    attr_reader :margins, :y
+    attr_accessor :page_number
+
+    # @group Extension Attributes
+
+    attr_accessor :text_formatter
+
+    # @group Stable API
+
     # Creates and renders a PDF document.
     #
     # When using the implicit block form, Prawn will evaluate the block
@@ -117,32 +141,37 @@ module Prawn
     #     pdf.draw_text content, :at => [200,720], :size => 32
     #   end
     #
-    def self.generate(filename,options={},&block)
-      pdf = new(options,&block)
+    def self.generate(filename, options = {}, &block)
+      pdf = new(options, &block)
       pdf.render_file(filename)
     end
 
     # Creates a new PDF Document.  The following options are available (with
     # the default values marked in [])
     #
-    # <tt>:page_size</tt>:: One of the Document::PageGeometry sizes [LETTER]
+    # <tt>:page_size</tt>:: One of the PDF::Core::PageGeometry sizes [LETTER]
     # <tt>:page_layout</tt>:: Either <tt>:portrait</tt> or <tt>:landscape</tt>
     # <tt>:margin</tt>:: Sets the margin on all sides in points [0.5 inch]
     # <tt>:left_margin</tt>:: Sets the left margin in points [0.5 inch]
     # <tt>:right_margin</tt>:: Sets the right margin in points [0.5 inch]
     # <tt>:top_margin</tt>:: Sets the top margin in points [0.5 inch]
     # <tt>:bottom_margin</tt>:: Sets the bottom margin in points [0.5 inch]
-    # <tt>:skip_page_creation</tt>:: Creates a document without starting the first page [false]
-    # <tt>:compress</tt>:: Compresses content streams before rendering them [false]
-    # <tt>:optimize_objects</tt>:: Reduce number of PDF objects in output, at expense of render time [false]
-    # <tt>:background</tt>:: An image path to be used as background on all pages [nil]
+    # <tt>:skip_page_creation</tt>:: Creates a document without starting the
+    #                                first page [false]
+    # <tt>:compress</tt>:: Compresses content streams before rendering them
+    #                      [false]
+    # <tt>:background</tt>:: An image path to be used as background on all pages
+    #                        [nil]
     # <tt>:background_scale</tt>:: Backgound image scale [1] [nil]
-    # <tt>:info</tt>:: Generic hash allowing for custom metadata properties [nil]
-    # <tt>:template</tt>:: The path to an existing PDF file to use as a template [nil]
-    # <tt>:text_formatter</tt>: The text formatter to use for <tt>:inline_format</tt>ted text [Prawn::Text::Formatted::Parser]
+    # <tt>:info</tt>:: Generic hash allowing for custom metadata properties
+    #                  [nil]
+    # <tt>:text_formatter</tt>: The text formatter to use for
+    #                           <tt>:inline_format</tt>ted text
+    #                           [Prawn::Text::Formatted::Parser]
     #
-    # Setting e.g. the :margin to 100 points and the :left_margin to 50 will result in margins
-    # of 100 points on every side except for the left, where it will be 50.
+    # Setting e.g. the :margin to 100 points and the :left_margin to 50 will
+    # result in margins of 100 points on every side except for the left, where
+    # it will be 50.
     #
     # The :margin can also be an array much like CSS shorthand:
     #
@@ -153,8 +182,8 @@ module Prawn
     #   # Top is 10, right is 20, bottom is 30, left is 40.
     #   :margin => [10, 20, 30, 40]
     #
-    # Additionally, :page_size can be specified as a simple two value array giving
-    # the width and height of the document you need in PDF Points.
+    # Additionally, :page_size can be specified as a simple two value array
+    # giving the width and height of the document you need in PDF Points.
     #
     # Usage:
     #
@@ -162,54 +191,47 @@ module Prawn
     #   pdf = Prawn::Document.new
     #
     #   # New document, A4 paper, landscaped
-    #   pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
+    #   pdf = Prawn::Document.new(page_size: "A4", page_layout: :landscape)
     #
     #   # New document, Custom size
-    #   pdf = Prawn::Document.new(:page_size => [200, 300])
+    #   pdf = Prawn::Document.new(page_size: [200, 300])
     #
     #   # New document, with background
-    #   pdf = Prawn::Document.new(:background => "#{Prawn::DATADIR}/images/pigs.jpg")
+    #   pdf = Prawn::Document.new(
+    #     background: "#{Prawn::DATADIR}/images/pigs.jpg"
+    #   )
     #
-    def initialize(options={},&block)
+    def initialize(options = {}, &block)
       options = options.dup
 
-      Prawn.verify_options [:page_size, :page_layout, :margin, :left_margin,
-        :right_margin, :top_margin, :bottom_margin, :skip_page_creation,
-        :compress, :skip_encoding, :background, :info,
-        :optimize_objects, :template, :text_formatter], options
+      Prawn.verify_options VALID_OPTIONS, options
 
       # need to fix, as the refactoring breaks this
       # raise NotImplementedError if options[:skip_page_creation]
 
       self.class.extensions.reverse_each { |e| extend e }
-      @internal_state = PDF::Core::DocumentState.new(options)
-      @internal_state.populate_pages_from_store(self)
-      min_version(state.store.min_version) if state.store.min_version
+      self.state = PDF::Core::DocumentState.new(options)
+      state.populate_pages_from_store(self)
+      renderer.min_version(state.store.min_version) if state.store.min_version
+
+      renderer.min_version(1.6) if options[:print_scaling] == :none
 
       @background = options[:background]
       @background_scale = options[:background_scale] || 1
-      @font_size  = 12
+      @font_size = 12
 
-      @bounding_box  = nil
-      @margin_box    = nil
+      @bounding_box = nil
+      @margin_box = nil
 
       @page_number = 0
 
-      @text_formatter = options.delete(:text_formatter) || Text::Formatted::Parser
+      @text_formatter = options.delete(:text_formatter) ||
+        Text::Formatted::Parser
 
       options[:size] = options.delete(:page_size)
       options[:layout] = options.delete(:page_layout)
 
-      if options[:template]
-        fresh_content_streams(options)
-        go_to_page(1)
-      else
-        if options[:skip_page_creation] || options[:template]
-          start_new_page(options.merge(:orphan => true))
-        else
-          start_new_page(options)
-        end
-      end
+      initialize_first_page(options)
 
       @bounding_box = @margin_box
 
@@ -218,19 +240,7 @@ module Prawn
       end
     end
 
-    attr_accessor :margin_box
-    attr_reader   :margins, :y
-    attr_writer   :font_size
-    attr_accessor :page_number
-    attr_accessor :text_formatter
-
-    def state
-      @internal_state
-    end
-
-    def page
-      state.page
-    end
+    # @group Stable API
 
     # Creates and advances to a new page in the document.
     #
@@ -242,31 +252,30 @@ module Prawn
     #   pdf.start_new_page(:left_margin => 50, :right_margin => 50)
     #   pdf.start_new_page(:margin => 100)
     #
-    # A template for a page can be specified by pointing to the path of and existing pdf.
-    # One can also specify which page of the template which defaults otherwise to 1.
-    #
-    #  pdf.start_new_page(:template => multipage_template.pdf, :template_page => 2)
-    #
-    # Note: templates get indexed by either the object_id of the filename or stream
-    # entered so that if you reuse the same template multiple times be sure to use the
-    # same instance for more efficient use of resources and smaller rendered pdfs.
     def start_new_page(options = {})
-      if last_page = state.page
-        last_page_size    = last_page.size
-        last_page_layout  = last_page.layout
-        last_page_margins = last_page.margins
+      last_page = state.page
+      if last_page
+        last_page_size = last_page.size
+        last_page_layout = last_page.layout
+        last_page_margins = last_page.margins.dup
       end
 
-      page_options = {:size => options[:size] || last_page_size,
-                      :layout  => options[:layout] || last_page_layout,
-                      :margins => last_page_margins}
+      page_options = {
+        size: options[:size] || last_page_size,
+        layout: options[:layout] || last_page_layout,
+        margins: last_page_margins
+      }
       if last_page
-        new_graphic_state = last_page.graphic_state.dup  if last_page.graphic_state
-        #erase the color space so that it gets reset on new page for fussy pdf-readers
-        new_graphic_state.color_space = {} if new_graphic_state
-        page_options.merge!(:graphic_state => new_graphic_state)
+        if last_page.graphic_state
+          new_graphic_state = last_page.graphic_state.dup
+        end
+
+        # erase the color space so that it gets reset on new page for fussy
+        # pdf-readers
+        new_graphic_state&.color_space = {}
+
+        page_options[:graphic_state] = new_graphic_state
       end
-      merge_template_options(page_options, options) if options[:template]
 
       state.page = PDF::Core::Page.new(self, page_options)
 
@@ -279,15 +288,17 @@ module Prawn
         @bounding_box = @margin_box
       end
 
-      state.page.new_content_stream if options[:template]
-      use_graphic_settings(options[:template])
-      forget_text_rendering_mode! if options[:template]
+      use_graphic_settings
 
       unless options[:orphan]
         state.insert_page(state.page, @page_number)
         @page_number += 1
 
-        canvas { image(@background, :scale => @background_scale, :at => bounds.top_left) } if @background
+        if @background
+          canvas do
+            image(@background, scale: @background_scale, at: bounds.top_left)
+          end
+        end
         @y = @bounding_box.absolute_top
 
         float do
@@ -296,6 +307,26 @@ module Prawn
       end
     end
 
+    # Remove page of the document by index
+    #
+    #   pdf = Prawn::Document.new
+    #   pdf.page_count #=> 1
+    #   3.times { pdf.start_new_page }
+    #   pdf.page_count #=> 4
+    #   pdf.delete_page(-1)
+    #   pdf.page_count #=> 3
+    #
+    def delete_page(index)
+      return false if index.abs > (state.pages.count - 1)
+
+      state.pages.delete_at(index)
+
+      state.store.pages.data[:Kids].delete_at(index)
+      state.store.pages.data[:Count] -= 1
+      @page_number -= 1
+      true
+    end
+
     # Returns the number of pages in the document
     #
     #   pdf = Prawn::Document.new
@@ -312,9 +343,9 @@ module Prawn
     #
     # See Prawn::Document#number_pages for a sample usage of this capability.
     #
-    def go_to_page(k)
-      @page_number = k
-      state.page = state.pages[k-1]
+    def go_to_page(page_number)
+      @page_number = page_number
+      state.page = state.pages[page_number - 1]
       generate_margin_box
       @y = @bounding_box.absolute_top
     end
@@ -361,20 +392,13 @@ module Prawn
     # Renders the PDF document to string.
     # Pass an open file descriptor to render to file.
     #
-    def render(output = StringIO.new)
-      finalize_all_page_contents
-
-      render_header(output)
-      render_body(output)
-      render_xref(output)
-      render_trailer(output)
-      if output.instance_of?(StringIO)
-        str = output.string
-        str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
-        return str
-      else
-        return nil
+    def render(*arguments, &block)
+      (1..page_count).each do |i|
+        go_to_page i
+        repeaters.each { |r| r.run(i) }
       end
+
+      renderer.render(*arguments, &block)
     end
 
     # Renders the PDF document to file.
@@ -382,8 +406,7 @@ module Prawn
     #   pdf.render_file "foo.pdf"
     #
     def render_file(filename)
-      Kernel.const_defined?("Encoding") ? mode = "wb:ASCII-8BIT" : mode = "wb"
-      File.open(filename,mode) { |f| render(f) }
+      File.open(filename, 'wb') { |f| render(f) }
     end
 
     # The bounds method returns the current bounding box you are currently in,
@@ -392,14 +415,15 @@ module Prawn
     # block, the box defined by that call will be returned instead of the
     # document margin box.
     #
-    # Another important point about bounding boxes is that all x and y measurements
-    # within a bounding box code block are relative to the bottom left corner of the
-    # bounding box.
+    # Another important point about bounding boxes is that all x and
+    # y measurements within a bounding box code block are relative to the bottom
+    # left corner of the bounding box.
     #
     # For example:
     #
     #  Prawn::Document.new do
-    #    # In the default "margin box" of a Prawn document of 0.5in along each edge
+    #    # In the default "margin box" of a Prawn document of 0.5in along each
+    #    # edge
     #
     #    # Draw a border around the page (the manual way)
     #    stroke do
@@ -419,14 +443,15 @@ module Prawn
 
     # Returns the innermost non-stretchy bounding box.
     #
+    # @private
     def reference_bounds
       @bounding_box.reference_bounds
     end
 
     # Sets Document#bounds to the BoundingBox provided.  See above for a brief
     # description of what a bounding box is.  This function is useful if you
-    # really need to change the bounding box manually, but usually, just entering
-    # and exiting bounding box code blocks is good enough.
+    # really need to change the bounding box manually, but usually, just
+    # entering and exiting bounding box code blocks is good enough.
     #
     def bounds=(bounding_box)
       @bounding_box = bounding_box
@@ -435,15 +460,15 @@ module Prawn
     # Moves up the document by n points relative to the current position inside
     # the current bounding box.
     #
-    def move_up(n)
-      self.y += n
+    def move_up(amount)
+      self.y += amount
     end
 
-    # Moves down the document by n points relative to the current position inside
-    # the current bounding box.
+    # Moves down the document by n points relative to the current position
+    # inside the current bounding box.
     #
-    def move_down(n)
-      self.y -= n
+    def move_down(amount)
+      self.y -= amount
     end
 
     # Moves down the document and then executes a block.
@@ -487,7 +512,6 @@ module Prawn
       move_down(y)
     end
 
-
     # Indents the specified number of PDF points for the duration of the block
     #
     #  pdf.text "some text"
@@ -504,119 +528,117 @@ module Prawn
       bounds.indent(left, right, &block)
     end
 
-
-    def mask(*fields) # :nodoc:
-     # Stores the current state of the named attributes, executes the block, and
-     # then restores the original values after the block has executed.
-     # -- I will remove the nodoc if/when this feature is a little less hacky
-      stored = {}
-      fields.each { |f| stored[f] = send(f) }
-      yield
-      fields.each { |f| send("#{f}=", stored[f]) }
-    end
-
-    # Attempts to group the given block vertically within the current context.
-    # First attempts to render it in the current position on the current page.
-    # If that attempt overflows, it is tried anew after starting a new context
-    # (page or column). Returns a logically true value if the content fits in
-    # one page/column, false if a new page or column was needed.
-    #
-    # Raises CannotGroup if the provided content is too large to fit alone in
-    # the current page or column.
-    #
-    def group(second_attempt=false)
-      old_bounding_box = @bounding_box
-      @bounding_box = SimpleDelegator.new(@bounding_box)
-
-      def @bounding_box.move_past_bottom
-        raise RollbackTransaction
-      end
-
-      success = transaction { yield }
-
-      @bounding_box = old_bounding_box
-
-      unless success
-        raise Prawn::Errors::CannotGroup if second_attempt
-        old_bounding_box.move_past_bottom
-        group(second_attempt=true) { yield }
-      end
-
-      success
-    end
-
-    # Places a text box on specified pages for page numbering.  This should be called
-    # towards the end of document creation, after all your content is already in
-    # place.  In your template string, <page> refers to the current page, and
-    # <total> refers to the total amount of pages in the document.  Page numbering should
-    # occur at the end of your Prawn::Document.generate block because the method iterates
-    # through existing pages after they are created.
+    # Places a text box on specified pages for page numbering.  This should be
+    # called towards the end of document creation, after all your content is
+    # already in place.  In your template string, <page> refers to the current
+    # page, and <total> refers to the total amount of pages in the document.
+    # Page numbering should occur at the end of your Prawn::Document.generate
+    # block because the method iterates through existing pages after they are
+    # created.
     #
     # Parameters are:
     #
     # <tt>string</tt>:: Template string for page number wording.
     #                   Should include '<page>' and, optionally, '<total>'.
     # <tt>options</tt>:: A hash for page numbering and text box options.
-    #     <tt>:page_filter</tt>:: A filter to specify which pages to place page numbers on.
-    #                             Refer to the method 'page_match?'
+    #     <tt>:page_filter</tt>:: A filter to specify which pages to place page
+    #                             numbers on. Refer to the method 'page_match?'
     #     <tt>:start_count_at</tt>:: The starting count to increment pages from.
-    #     <tt>:total_pages</tt>:: If provided, will replace <total> with the value given.
-    #                             Useful to override the total number of pages when using
-    #                             the start_count_at option.
+    #     <tt>:total_pages</tt>:: If provided, will replace <total> with the
+    #                             value given. Useful to override the total
+    #                             number of pages when using the start_count_at
+    #                             option.
     #     <tt>:color</tt>:: Text fill color.
     #
-    #     Please refer to Prawn::Text::text_box for additional options concerning text
-    #     formatting and placement.
-    #
-    # Example: Print page numbers on every page except for the first.  Start counting from
-    #          five.
+    #     Please refer to Prawn::Text::text_box for additional options
+    #     concerning text formatting and placement.
     #
-    #   Prawn::Document.generate("page_with_numbering.pdf") do
-    #     number_pages "<page> in a total of <total>",
-    #                                          {:start_count_at => 5,
-    #                                           :page_filter => lambda{ |pg| pg != 1 },
-    #                                           :at => [bounds.right - 50, 0],
-    #                                           :align => :right,
-    #                                           :size => 14}
-    #   end
+    # Example:
+    #   Print page numbers on every page except for the first. Start counting
+    #   from five.
+    #
+    #     Prawn::Document.generate("page_with_numbering.pdf") do
+    #       number_pages "<page> in a total of <total>", {
+    #         start_count_at: 5,
+    #         page_filter: lambda { |pg| pg != 1 },
+    #         at: [bounds.right - 50, 0],
+    #         align: :right,
+    #         size: 14
+    #       }
+    #     end
     #
-    def number_pages(string, options={})
+    def number_pages(string, options = {})
       opts = options.dup
       start_count_at = opts.delete(:start_count_at).to_i
-      page_filter = if opts.has_key?(:page_filter)
-        opts.delete(:page_filter)
-      else
-        :all
-      end
+
+      page_filter =
+        if opts.key?(:page_filter)
+          opts.delete(:page_filter)
+        else
+          :all
+        end
+
       total_pages = opts.delete(:total_pages)
       txtcolor = opts.delete(:color)
       # An explicit height so that we can draw page numbers in the margins
-      opts[:height] = 50 unless opts.has_key?(:height)
+      opts[:height] = 50 unless opts.key?(:height)
 
       start_count = false
       pseudopage = 0
       (1..page_count).each do |p|
         unless start_count
-          pseudopage = case start_count_at
-                       when 0
-                         1
-                       else
-                         start_count_at.to_i
-                       end
+          pseudopage =
+            case start_count_at
+            when 0
+              1
+            else
+              start_count_at.to_i
+            end
         end
         if page_match?(page_filter, p)
           go_to_page(p)
-          # have to use fill_color here otherwise text reverts back to default fill color
+          # have to use fill_color here otherwise text reverts back to default
+          # fill color
           fill_color txtcolor unless txtcolor.nil?
           total_pages = total_pages.nil? ? page_count : total_pages
-          str = string.gsub("<page>","#{pseudopage}").gsub("<total>","#{total_pages}")
+          str = string.gsub('<page>', pseudopage.to_s)
+            .gsub('<total>', total_pages.to_s)
           text_box str, opts
-          start_count = true  # increment page count as soon as first match found
+          start_count = true # increment page count as soon as first match found
         end
         pseudopage += 1 if start_count
       end
     end
 
+    # @group Experimental API
+
+    # Attempts to group the given block vertically within the current context.
+    # First attempts to render it in the current position on the current page.
+    # If that attempt overflows, it is tried anew after starting a new context
+    # (page or column). Returns a logically true value if the content fits in
+    # one page/column, false if a new page or column was needed.
+    #
+    # Raises CannotGroup if the provided content is too large to fit alone in
+    # the current page or column.
+    #
+    # @private
+    def group(*_arguments)
+      raise NotImplementedError,
+        'Document#group has been disabled because its implementation ' \
+        'lead to corrupted documents whenever a page boundary was ' \
+        'crossed. We will try to work on reimplementing it in a ' \
+        'future release'
+    end
+
+    # @private
+    def transaction
+      raise NotImplementedError,
+        'Document#transaction has been disabled because its implementation ' \
+        'lead to corrupted documents whenever a page boundary was ' \
+        'crossed. We will try to work on reimplementing it in a ' \
+        'future release'
+    end
+
     # Provides a way to execute a block of code repeatedly based on a
     # page_filter.
     #
@@ -632,9 +654,9 @@ module Prawn
       when :all
         true
       when :odd
-        page_number % 2 == 1
+        page_number.odd?
       when :even
-        page_number % 2 == 0
+        page_number.even?
       when Range, Array
         page_filter.include?(page_number)
       when Proc
@@ -642,26 +664,45 @@ module Prawn
       end
     end
 
+    # @private
 
-    # Returns true if content streams will be compressed before rendering,
-    # false otherwise
-    #
-    def compression_enabled?
-      !!state.compress
+    def mask(*fields)
+      # Stores the current state of the named attributes, executes the block,
+      # and then restores the original values after the block has executed.
+      # -- I will remove the nodoc if/when this feature is a little less hacky
+      stored = {}
+      fields.each { |f| stored[f] = public_send(f) }
+      yield
+      fields.each { |f| public_send("#{f}=", stored[f]) }
     end
 
-    private
+    # @group Extension API
+
+    def initialize_first_page(options)
+      if options[:skip_page_creation]
+        start_new_page(options.merge(orphan: true))
+      else
+        start_new_page(options)
+      end
+    end
+
+    ## Internals. Don't depend on them!
+
+    # @private
+    attr_accessor :state
 
-    def merge_template_options(page_options, options)
-      object_id = state.store.import_page(options[:template], options[:template_page] || 1)
-      page_options.merge!(:object_id => object_id, :page_template => true)
+    # @private
+    def page
+      state.page
     end
 
-    # setting override_settings to true ensures that a new graphic state does not end up using
-    # previous settings especially from imported template streams
+    private
+
+    # setting override_settings to true ensures that a new graphic state does
+    # not end up using previous settings.
     def use_graphic_settings(override_settings = false)
-      set_fill_color if current_fill_color != "000000" || override_settings
-      set_stroke_color if current_stroke_color != "000000" || override_settings
+      set_fill_color if current_fill_color != '000000' || override_settings
+      set_stroke_color if current_stroke_color != '000000' || override_settings
       write_line_width if line_width != 1 || override_settings
       write_stroke_cap_style if cap_style != :butt || override_settings
       write_stroke_join_style if join_style != :miter || override_settings
@@ -670,14 +711,16 @@ module Prawn
 
     def generate_margin_box
       old_margin_box = @margin_box
-      page           = state.page
+      page = state.page
 
       @margin_box = BoundingBox.new(
         self,
-        nil,  # margin box has no parent
-        [ page.margins[:left], page.dimensions[-1] - page.margins[:top] ] ,
-        :width => page.dimensions[-2] - (page.margins[:left] + page.margins[:right]),
-        :height => page.dimensions[-1] - (page.margins[:top] + page.margins[:bottom])
+        nil, # margin box has no parent
+        [page.margins[:left], page.dimensions[-1] - page.margins[:top]],
+        width: page.dimensions[-2] -
+          (page.margins[:left] + page.margins[:right]),
+        height: page.dimensions[-1] -
+          (page.margins[:top] + page.margins[:bottom])
       )
 
       # This check maintains indentation settings across page breaks
@@ -688,32 +731,30 @@ module Prawn
 
       # we must update bounding box if not flowing from the previous page
       #
-      # FIXME: This may have a bug where the old margin is restored
-      # when the bounding box exits.
-      @bounding_box = @margin_box if old_margin_box == @bounding_box
+      @bounding_box = @margin_box unless @bounding_box&.parent
     end
 
     def apply_margin_options(options)
-      if options[:margin]
-        # Treat :margin as CSS shorthand with 1-4 values.
-        margin = Array(options[:margin])
-        positions = { 4 => [0,1,2,3], 3 => [0,1,2,1],
-                      2 => [0,1,0,1], 1 => [0,0,0,0] }[margin.length]
-
-        [:top, :right, :bottom, :left].zip(positions).each do |p,i|
-          options[:"#{p}_margin"] ||= margin[i]
-        end
-      end
-
-      [:left,:right,:top,:bottom].each do |side|
-         if margin = options[:"#{side}_margin"]
-           state.page.margins[side] = margin
-         end
+      sides = %i[top right bottom left]
+      margin = Array(options[:margin])
+
+      # Treat :margin as CSS shorthand with 1-4 values.
+      positions = {
+        4 => [0, 1, 2, 3],
+        3 => [0, 1, 2, 1],
+        2 => [0, 1, 0, 1],
+        1 => [0, 0, 0, 0],
+        0 => []
+      }[margin.length]
+
+      sides.zip(positions).each do |side, pos|
+        new_margin = options[:"#{side}_margin"] || (margin[pos] if pos)
+        state.page.margins[side] = new_margin if new_margin
       end
     end
 
     def font_metric_cache #:nodoc:
-      @font_metric_cache ||= FontMetricCache.new( self )
+      @font_metric_cache ||= FontMetricCache.new(self)
     end
   end
 end