prawn-templates 0.0.4 → 0.0.5

data/LICENSE

@@ -0,0 +1,56 @@
+Prawn::Templates is copyrighted free software produced by James Healy 
+along with community contributions. 
+
+Licensing terms follow:
+
+You can redistribute Prawn::Templates and/or modify it under either the terms of the GPLv2
+or GPLv3 (see GPLv2 and GPLv3 files), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+    modifications to Usenet or an equivalent medium, or by allowing
+    the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+    together with instructions (in the manual page or equivalent)
+    on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+    the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial). 
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/lib/pdf/core/document_state.rb

@@ -5,28 +5,36 @@ module PDF
         normalize_metadata(options)
 
         if options[:template]
-          if options[:print_scaling]
-            @store = PDF::Core::ObjectStore.new(:template => options[:template], :print_scaling => options[:print_scaling])
-          else
-            @store = PDF::Core::ObjectStore.new(:template => options[:template])
-          end
+          @store =
+            if options[:print_scaling]
+              PDF::Core::ObjectStore.new(
+                template: options[:template],
+                print_scaling: options[:print_scaling]
+              )
+            else
+              PDF::Core::ObjectStore.new(template: options[:template])
+            end
           @store.info.data.merge!(options[:info]) if options[:info]
         else
-          if options[:print_scaling]
-            @store = PDF::Core::ObjectStore.new(:info => options[:info], :print_scaling => options[:print_scaling])
-          else
-            @store = PDF::Core::ObjectStore.new(:info => options[:info])
-          end
+          @store =
+            if options[:print_scaling]
+              PDF::Core::ObjectStore.new(
+                info: options[:info],
+                print_scaling: options[:print_scaling]
+              )
+            else
+              PDF::Core::ObjectStore.new(info: options[:info])
+            end
         end
 
-        @version                 = 1.3
-        @pages                   = []
-        @page                    = nil
-        @trailer                 = options.fetch(:trailer, {})
-        @compress                = options.fetch(:compress, false)
-        @encrypt                 = options.fetch(:encrypt, false)
-        @encryption_key          = options[:encryption_key]
-        @skip_encoding           = options.fetch(:skip_encoding, false)
+        @version = 1.3
+        @pages = []
+        @page = nil
+        @trailer = options.fetch(:trailer, {})
+        @compress = options.fetch(:compress, false)
+        @encrypt = options.fetch(:encrypt, false)
+        @encryption_key = options[:encryption_key]
+        @skip_encoding = options.fetch(:skip_encoding, false)
         @before_render_callbacks = []
         @on_page_create_callback = nil
       end

data/lib/pdf/core/object_store.rb

@@ -8,14 +8,19 @@ module PDF
         load_file(opts[:template]) if opts[:template]
 
         @info ||= ref(opts[:info] || {}).identifier
-        @root ||= ref(:Type => :Catalog).identifier
+        @root ||= ref(Type: :Catalog).identifier
         if opts[:print_scaling] == :none
-          root.data[:ViewerPreferences] = { :PrintScaling => :None }
+          root.data[:ViewerPreferences] = { PrintScaling: :None }
         end
         if pages.nil?
-          root.data[:Pages] = ref(:Type => :Pages, :Count => 0, :Kids => [])
+          root.data[:Pages] = ref(Type: :Pages, Count: 0, Kids: [])
         end
       end
+
+      def utf8?(str)
+        str.force_encoding(::Encoding::UTF_8)
+        str.valid_encoding?
+      end
     end
   end
 end

data/lib/pdf/core/page.rb

@@ -1,9 +1,29 @@
 module PDF
   module Core
     class Page #:nodoc:
-      # As per the PDF spec, each page can have multiple content streams. This will
-      # add a fresh, empty content stream this the page, mainly for use in loading
-      # template files.
+      def initialize(document, options = {})
+        @document = document
+        @margins = options[:margins] || {
+          left: 36,
+          right: 36,
+          top: 36,
+          bottom: 36
+        }
+        @crops = options[:crops] || ZERO_INDENTS
+        @bleeds = options[:bleeds] || ZERO_INDENTS
+        @trims = options[:trims] || ZERO_INDENTS
+        @art_indents = options[:art_indents] || ZERO_INDENTS
+        @stack = GraphicStateStack.new(options[:graphic_state])
+        if options[:object_id]
+          init_from_object(options)
+        else
+          init_new_page(options)
+        end
+      end
+
+      # As per the PDF spec, each page can have multiple content streams. This
+      # will add a fresh, empty content stream this the page, mainly for use in
+      # loading template files.
       #
       def new_content_stream
         return if in_stamp_stream?
@@ -11,22 +31,68 @@ module PDF
         unless dictionary.data[:Contents].is_a?(Array)
           dictionary.data[:Contents] = [content]
         end
-        @content    = document.ref({})
+        @content = document.ref({})
         dictionary.data[:Contents] << document.state.store[@content]
         document.open_graphics_state
       end
 
+      def imported_page?
+        @imported_page
+      end
+
+      def dimensions
+        return inherited_dictionary_value(:MediaBox) if imported_page?
+
+        coords = PDF::Core::PageGeometry::SIZES[size] || size
+        [0, 0] +
+          case layout
+          when :portrait
+            coords
+          when :landscape
+            coords.reverse
+          else
+            raise PDF::Core::Errors::InvalidPageLayout,
+              'Layout must be either :portrait or :landscape'
+          end
+      end
+
       def init_from_object(options)
         @dictionary = options[:object_id].to_i
-        dictionary.data[:Parent] = document.state.store.pages if options[:page_template]
+        if options[:page_template]
+          dictionary.data[:Parent] = document.state.store.pages
+        end
 
         unless dictionary.data[:Contents].is_a?(Array) # content only on leafs
-          @content    = dictionary.data[:Contents].identifier
+          @content = dictionary.data[:Contents].identifier
         end
 
-        @stamp_stream      = nil
-        @stamp_dictionary  = nil
-        @imported_page     = true
+        @stamp_stream = nil
+        @stamp_dictionary = nil
+        @imported_page = true
+      end
+
+      def init_new_page(options)
+        @size = options[:size] || 'LETTER'
+        @layout = options[:layout] || :portrait
+
+        @stamp_stream = nil
+        @stamp_dictionary = nil
+        @imported_page = false
+
+        @content = document.ref({})
+        content << 'q' << "\n"
+        @dictionary = document.ref(
+          Type: :Page,
+          Parent: document.state.store.pages,
+          MediaBox: dimensions,
+          CropBox: crop_box,
+          BleedBox: bleed_box,
+          TrimBox: trim_box,
+          ArtBox: art_box,
+          Contents: content
+        )
+
+        resources[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
       end
     end
   end

data/lib/prawn/document/internals.rb

@@ -1,7 +1,7 @@
 module Prawn
   class Document
     module Internals
-      delegate [ :open_graphics_state ] => :renderer
+      delegate [:open_graphics_state] => :renderer
 
       # adds a new, empty content stream to each page. Used in templating so
       # that imported content streams can be left pristine

data/lib/prawn/templates.rb

@@ -3,12 +3,12 @@ require 'pdf/reader'
 require 'pdf/core'
 require 'prawn/text'
 
-require_relative "../pdf/core/document_state"
-require_relative "../pdf/core/errors"
-require_relative "../pdf/core/object_store"
-require_relative "../pdf/core/page"
-require_relative "text"
-require_relative "document/internals"
+require_relative '../pdf/core/document_state'
+require_relative '../pdf/core/errors'
+require_relative '../pdf/core/object_store'
+require_relative '../pdf/core/page'
+require_relative 'text'
+require_relative 'document/internals'
 
 module Prawn
   # @private
@@ -26,24 +26,28 @@ module Prawn
     def start_new_page(options = {})
       return super unless options[:template]
 
-      if last_page = state.page
-        last_page_size    = last_page.size
-        last_page_layout  = last_page.layout
+      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
+        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
+        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
+        # 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)
+        page_options[:graphic_state] = new_graphic_state
       end
 
       merge_template_options(page_options, options)
@@ -67,7 +71,11 @@ module Prawn
         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
@@ -77,8 +85,11 @@ module Prawn
     end
 
     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)
+      object_id = state.store.import_page(
+        options[:template],
+        options[:template_page] || 1
+      )
+      page_options.merge!(object_id: object_id, page_template: true)
     end
 
     module ObjectStoreExtensions
@@ -96,32 +107,37 @@ module Prawn
       #
       def import_page(input, page_num)
         @loaded_objects = {}
-        if template_id = indexed_template(input, page_num)
-          return template_id
-        end
+        template_id = indexed_template(input, page_num)
+        return template_id if template_id
 
         io = if input.respond_to?(:seek) && input.respond_to?(:read)
                input
              elsif File.file?(input.to_s)
                StringIO.new(File.binread(input.to_s))
              else
-               fail ArgumentError, "input must be an IO-like object or a filename"
+               raise ArgumentError, 'input must be an IO-like object or a ' \
+               'filename'
              end
 
         hash = indexed_hash(input, io)
-        ref  = hash.page_references[page_num - 1]
+        ref = hash.page_references[page_num - 1]
 
         if ref.nil?
           nil
         else
-          index_template(input, page_num, load_object_graph(hash, ref).identifier)
+          index_template(
+            input, page_num,
+            load_object_graph(hash, ref).identifier
+          )
         end
 
-      rescue PDF::Reader::MalformedPDFError, PDF::Reader::InvalidObjectError => e
-        msg = "Error reading template file. If you are sure it's a valid PDF, it may be a bug.\n#{e.message}"
+      rescue PDF::Reader::MalformedPDFError,
+             PDF::Reader::InvalidObjectError => e
+        msg = 'Error reading template file. If you are sure it\'s a valid PDF,'\
+              " it may be a bug.\n#{e.message}"
         raise PDF::Core::Errors::TemplateError, msg
       rescue PDF::Reader::UnsupportedFeatureError
-        msg = "Template file contains unsupported PDF features"
+        msg = 'Template file contains unsupported PDF features'
         raise PDF::Core::Errors::TemplateError, msg
       end
 
@@ -181,8 +197,8 @@ module Prawn
       #
       def load_file(template)
         unless (template.respond_to?(:seek) && template.respond_to?(:read)) ||
-               File.file?(template)
-          fail ArgumentError, "#{template} does not exist"
+            File.file?(template)
+          raise ArgumentError, "#{template} does not exist"
         end
 
         hash = PDF::Reader::ObjectHash.new(template)
@@ -191,8 +207,9 @@ module Prawn
         @min_version = hash.pdf_version.to_f
 
         if hash.trailer[:Encrypt]
-          msg = "Template file is an encrypted PDF, it can't be used as a template"
-          fail PDF::Core::Errors::TemplateError, msg
+          msg = 'Template file is an encrypted PDF, it can\'t be used as a '\
+              'template'
+          raise PDF::Core::Errors::TemplateError, msg
         end
 
         if src_info
@@ -202,11 +219,13 @@ module Prawn
         if src_root
           @root = load_object_graph(hash, src_root).identifier
         end
-      rescue PDF::Reader::MalformedPDFError, PDF::Reader::InvalidObjectError => e
-        msg = "Error reading template file. If you are sure it's a valid PDF, it may be a bug.\n#{e.message}"
+      rescue PDF::Reader::MalformedPDFError,
+             PDF::Reader::InvalidObjectError => e
+        msg = 'Error reading template file. If you are sure it\'s a valid PDF,'\
+              " it may be a bug.\n#{e.message}"
         raise PDF::Core::Errors::TemplateError, msg
       rescue PDF::Reader::UnsupportedFeatureError
-        msg = "Template file contains unsupported PDF features"
+        msg = 'Template file contains unsupported PDF features'
         raise PDF::Core::Errors::TemplateError, msg
       end
 
@@ -220,7 +239,9 @@ module Prawn
         @loaded_objects ||= {}
         case object
         when ::Hash then
-          object.each { |key, value| object[key] = load_object_graph(hash, value) }
+          object.each do |key, value|
+            object[key] = load_object_graph(hash, value)
+          end
           object
         when Array then
           object.map { |item| load_object_graph(hash, item) }
@@ -228,7 +249,7 @@ module Prawn
           unless @loaded_objects.key?(object.id)
             @loaded_objects[object.id] = ref(nil)
             new_obj = load_object_graph(hash, hash[object])
-            if new_obj.kind_of?(PDF::Reader::Stream)
+            if new_obj.is_a?(PDF::Reader::Stream)
               stream_dict = load_object_graph(hash, new_obj.hash)
               @loaded_objects[object.id].data = stream_dict
               @loaded_objects[object.id] << new_obj.data
@@ -238,11 +259,11 @@ module Prawn
           end
           @loaded_objects[object.id]
         when PDF::Reader::Stream
-          # Stream is a subclass of string, so this is here to prevent the stream
-          # being wrapped in a LiteralString
+          # Stream is a subclass of string, so this is here to prevent the
+          # stream being wrapped in a LiteralString
           object
         when String
-          is_utf8?(object) ? object : PDF::Core::ByteString.new(object)
+          utf8?(object) ? object : PDF::Core::ByteString.new(object)
         else
           object
         end
@@ -251,7 +272,17 @@ module Prawn
   end
 end
 
-Prawn::Document::VALID_OPTIONS << :template
+if Prawn::Document::VALID_OPTIONS.frozen?
+  Prawn::Document.const_set(
+    :VALID_OPTIONS,
+    (Prawn::Document.send(
+      :remove_const,
+      :VALID_OPTIONS
+    ).dup << :template).freeze
+  )
+else
+  Prawn::Document::VALID_OPTIONS << :template
+end
 Prawn::Document.extensions << Prawn::Templates
 
 PDF::Core::ObjectStore.send(:include, Prawn::Templates::ObjectStoreExtensions)