pdf-core 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0290a0011b662d535affad39a3429a005f9cf7a
-  data.tar.gz: 9b22752a0a1d9e8595994ffd555a0ca8cb68daa2
+  metadata.gz: 7f20557e9a614c10244d01e2b1ed78d4434cef6c
+  data.tar.gz: 8668979b6592e45d81d8274e8acd387642e5a3fb
 SHA512:
-  metadata.gz: 043e585e7e4ea111d09ccad6a8c713cedbaff314a9521394507bf3a77c862d360daa0fbda9c57b5bcf5a4feae4a1cdab1468114c5f6ceac9c37a18cebcf858fd
-  data.tar.gz: 35088210934d898e38a255a754277c3530e4fe8b7c7f5f0800eeb1f6a2680d56bec8420d8533e62e3fdc3c48bd234f8c213f912e89b6e4b235e2176a45f664e1
+  metadata.gz: 68d6e43d2579ff909d9cabc4a9d641648e9830685a2d2b76d24fe85046e48ea22fb7bbb4bf005d3442d4595b44b18dddd29dad37f99ecd32a3b9fa515490503e
+  data.tar.gz: f6f49f285719b0d72d3113bc465db2e588d52c2b1c096c7285cb56f43744a31122d4a0c8338ab88353b29555bb352d4c2cc662eac2c73164948dda3ca5c72933

data/lib/pdf/core.rb

@@ -15,6 +15,7 @@ require_relative "core/graphics_state"
 require_relative "core/page_geometry"
 require_relative "core/outline_root"
 require_relative "core/outline_item"
+require_relative "core/renderer"
 
 module PDF
   module Core

data/lib/pdf/core/renderer.rb

@@ -0,0 +1,268 @@
+require "stringio"
+
+module PDF
+  module Core
+    class Renderer
+      def initialize(state)
+        @state = state
+        @state.populate_pages_from_store(self)
+        
+        min_version(state.store.min_version) if state.store.min_version
+
+        @page_number = 0
+      end
+
+      attr_reader :state
+
+      # Creates a new Reference and adds it to the Document's object
+      # list.  The +data+ argument is anything that Prawn::PdfObject() can convert.
+      #
+      # Returns the identifier which points to the reference in the ObjectStore
+      #
+      def ref(data)
+        ref!(data).identifier
+      end
+
+      # Like ref, but returns the actual reference instead of its identifier.
+      #
+      # While you can use this to build up nested references within the object
+      # tree, it is recommended to persist only identifiers, and then provide
+      # helper methods to look up the actual references in the ObjectStore
+      # if needed.  If you take this approach, Document::Snapshot
+      # will probably work with your extension
+      #
+      def ref!(data)
+        state.store.ref(data)
+      end
+
+      # At any stage in the object tree an object can be replaced with an
+      # indirect reference. To get access to the object safely, regardless
+      # of if it's hidden behind a Prawn::Reference, wrap it in deref().
+      #
+      def deref(obj)
+        obj.is_a?(PDF::Core::Reference) ? obj.data : obj
+      end
+
+      # Appends a raw string to the current page content.
+      #
+      #  # Raw line drawing example:
+      #  x1,y1,x2,y2 = 100,500,300,550
+      #  pdf.add_content("%.3f %.3f m" % [ x1, y1 ])  # move
+      #  pdf.add_content("%.3f %.3f l" % [ x2, y2 ])  # draw path
+      #  pdf.add_content("S") # stroke
+      #
+      def add_content(str)
+        save_graphics_state if graphic_state.nil?
+        state.page.content << str << "\n"
+      end
+
+      # The Name dictionary (PDF spec 3.6.3) for this document. It is
+      # lazily initialized, so that documents that do not need a name
+      # dictionary do not incur the additional overhead.
+      #
+      def names
+        state.store.root.data[:Names] ||= ref!(:Type => :Names)
+      end
+
+      # Returns true if the Names dictionary is in use for this document.
+      #
+      def names?
+        state.store.root.data[:Names]
+      end
+
+      # Defines a block to be called just before the document is rendered.
+      #
+      def before_render(&block)
+        state.before_render_callbacks << block
+      end
+
+      # Defines a block to be called just before a new page is started.
+      #
+      def on_page_create(&block)
+         if block_given?
+            state.on_page_create_callback = block
+         else
+            state.on_page_create_callback = nil
+         end
+      end
+
+      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
+        end
+
+        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)
+        end
+
+        state.page = PDF::Core::Page.new(self, page_options)
+
+        state.insert_page(state.page, @page_number)
+        @page_number += 1
+
+        state.on_page_create_action(self)
+      end
+
+      def page_count
+        state.page_count
+      end
+
+      # Re-opens the page with the given (1-based) page number so that you can
+      # draw on it.
+      #
+      # 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]
+      end
+
+      def finalize_all_page_contents
+        (1..page_count).each do |i|
+          go_to_page i
+          while graphic_stack.present?
+            restore_graphics_state
+          end
+          state.page.finalize
+        end
+      end
+
+      # raise the PDF version of the file we're going to generate.
+      # A private method, designed for internal use when the user adds a feature
+      # to their document that requires a particular version.
+      #
+      def min_version(min)
+        state.version = min if min > state.version
+      end
+
+      # Renders the PDF document to string.
+      # Pass an open file descriptor to render to file.
+      #
+      def render(output = StringIO.new)
+        if output.instance_of?(StringIO)
+          output.set_encoding(::Encoding::ASCII_8BIT)
+        end
+        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(::Encoding::ASCII_8BIT)
+          return str
+        else
+          return nil
+        end
+      end
+
+      # Renders the PDF document to file.
+      #
+      #   pdf.render_file "foo.pdf"
+      #
+      def render_file(filename)
+        File.open(filename, "wb") { |f| render(f) }
+      end
+
+      # Write out the PDF Header, as per spec 3.4.1
+      #
+      def render_header(output)
+        state.before_render_actions(self)
+
+        # pdf version
+        output << "%PDF-#{state.version}\n"
+
+        # 4 binary chars, as recommended by the spec
+        output << "%\xFF\xFF\xFF\xFF\n"
+      end
+
+      # Write out the PDF Body, as per spec 3.4.2
+      #
+      def render_body(output)
+        state.render_body(output)
+      end
+
+      # Write out the PDF Cross Reference Table, as per spec 3.4.3
+      #
+      def render_xref(output)
+        @xref_offset = output.size
+        output << "xref\n"
+        output << "0 #{state.store.size + 1}\n"
+        output << "0000000000 65535 f \n"
+        state.store.each do |ref|
+          output.printf("%010d", ref.offset)
+          output << " 00000 n \n"
+        end
+      end
+
+      # Write out the PDF Trailer, as per spec 3.4.4
+      #
+      def render_trailer(output)
+        trailer_hash = {:Size => state.store.size + 1,
+                        :Root => state.store.root,
+                        :Info => state.store.info}
+        trailer_hash.merge!(state.trailer) if state.trailer
+
+        output << "trailer\n"
+        output << PDF::Core::PdfObject(trailer_hash) << "\n"
+        output << "startxref\n"
+        output << @xref_offset << "\n"
+        output << "%%EOF" << "\n"
+      end
+
+      def open_graphics_state
+        add_content "q"
+      end
+
+      def close_graphics_state
+        add_content "Q"
+      end
+
+      def save_graphics_state(graphic_state = nil)
+        graphic_stack.save_graphic_state(graphic_state)
+        open_graphics_state
+        if block_given?
+          yield
+          restore_graphics_state
+        end
+      end
+
+      # Returns true if content streams will be compressed before rendering,
+      # false otherwise
+      #
+      def compression_enabled?
+        !!state.compress
+      end
+
+      # Pops the last saved graphics state off the graphics state stack and
+      # restores the state to those values
+      def restore_graphics_state
+        if graphic_stack.empty?
+          raise PDF::Core::Errors::EmptyGraphicStateStack,
+            "\n You have reached the end of the graphic state stack"
+        end
+        close_graphics_state
+        graphic_stack.restore_graphic_state
+      end
+
+      def graphic_stack
+        state.page.stack
+      end
+
+      def graphic_state
+        save_graphics_state unless graphic_stack.current_state
+        graphic_stack.current_state
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdf-core
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Gregory Brown
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-11 00:00:00.000000000 Z
+date: 2014-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pdf-reader
@@ -118,6 +118,7 @@ files:
 - lib/pdf/core/page_geometry.rb
 - lib/pdf/core/pdf_object.rb
 - lib/pdf/core/reference.rb
+- lib/pdf/core/renderer.rb
 - lib/pdf/core/stream.rb
 - lib/pdf/core/text.rb
 - pdf-core.gemspec