pdf-core 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e04dbc623a502e35e4ab9879b4e418a22799525
+  data.tar.gz: 8bcd0c9a82f9330fa074af80e43f8f371edba50f
+SHA512:
+  metadata.gz: ede1498abbf6a6a93e1410cd019c320beb0b490a64ebbbf2bc1d13c2ba56e257e098db49da253444a7dbc70482a28b8ca1f8dd41bf9fa310a88080856a1445e5
+  data.tar.gz: d872d4b0b03aab9bd55bb3a1c2caa855280bbb6216e1ca89bcd0fd4aa9329f70893a846e0db53fd826a4069c1300e1f100369b88e7ba976d0d9ff49b50c4d9d7

data/lib/pdf/core.rb

@@ -0,0 +1,35 @@
+require_relative "core/pdf_object"
+require_relative "core/annotations"
+require_relative "core/byte_string"
+require_relative "core/destinations"
+require_relative "core/filters"
+require_relative "core/stream"
+require_relative "core/reference"
+require_relative "core/literal_string"
+require_relative "core/filter_list"
+require_relative "core/page"
+require_relative "core/object_store"
+require_relative "core/document_state"
+require_relative "core/name_tree"
+require_relative "core/graphics_state"
+require_relative "core/page_geometry"
+require_relative "core/outline"
+
+module PDF
+  module Core
+    module Errors
+      # This error is raised when PdfObject() fails
+      FailedObjectConversion = Class.new(StandardError)
+
+      # This error is raised when object store fails to load a template file
+      TemplateError = Class.new(StandardError)
+
+      # This error is raise when trying to restore a graphic state that
+      EmptyGraphicStateStack = Class.new(StandardError)
+
+      # This error is raised when Document#page_layout is set to anything
+      # other than :portrait or :landscape
+      InvalidPageLayout = Class.new(StandardError)
+    end
+  end
+end

data/lib/pdf/core/annotations.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+# annotations.rb : Implements low-level annotation support for PDF
+#
+# Copyright November 2008, Jamis Buck. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module PDF
+  module Core
+    # Provides very low-level support for annotations.
+    #
+    module Annotations #:nodoc:
+
+      # Adds a new annotation (section 8.4 in PDF spec) to the current page.
+      # +options+ must be a Hash describing the annotation.
+      #
+      def annotate(options)
+        state.page.dictionary.data[:Annots] ||= []
+        options = sanitize_annotation_hash(options)
+        state.page.dictionary.data[:Annots] << ref!(options)
+        return options
+      end
+
+      # A convenience method for creating Text annotations. +rect+ must be an array
+      # of four numbers, describing the bounds of the annotation. +contents+ should
+      # be a string, to be shown when the annotation is activated.
+      #
+      def text_annotation(rect, contents, options={})
+        options = options.merge(:Subtype => :Text, :Rect => rect, :Contents => contents)
+        annotate(options)
+      end
+
+      # A convenience method for creating Link annotations. +rect+ must be an array
+      # of four numbers, describing the bounds of the annotation. The +options+ hash
+      # should include either :Dest (describing the target destination, usually as a
+      # string that has been recorded in the document's Dests tree), or :A (describing
+      # an action to perform on clicking the link), or :PA (for describing a URL to
+      # link to).
+      #
+      def link_annotation(rect, options={})
+        options = options.merge(:Subtype => :Link, :Rect => rect)
+        annotate(options)
+      end
+
+      private
+
+      def sanitize_annotation_hash(options)
+        options = options.merge(:Type => :Annot)
+
+        if options[:Dest].is_a?(String)
+          options[:Dest] = PDF::Core::LiteralString.new(options[:Dest])
+        end
+
+        options
+      end
+
+    end
+  end
+end

data/lib/pdf/core/byte_string.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module PDF 
+  module Core
+    # This is used to differentiate strings that must be encoded as
+    # a byte string, such as binary data from encrypted strings.
+    class ByteString < String #:nodoc:
+    end
+  end
+end

data/lib/pdf/core/destinations.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+# Implements destination support for PDF
+#
+# Copyright November 2008, Jamis Buck. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module PDF
+  module Core
+    module Destinations #:nodoc:
+
+      # The maximum number of children to fit into a single node in the Dests tree.
+      NAME_TREE_CHILDREN_LIMIT = 20 #:nodoc:
+
+      # The Dests name tree in the Name dictionary (see Prawn::Document::Internal#names).
+      # This name tree is used to store named destinations (PDF spec 8.2.1).
+      # (For more on name trees, see section 3.8.4 in the PDF spec.)
+      #
+      def dests
+        names.data[:Dests] ||= ref!(PDF::Core::NameTree::Node.new(self, NAME_TREE_CHILDREN_LIMIT))
+      end
+
+      # Adds a new destination to the dests name tree (see #dests). The
+      # +reference+ parameter will be converted into a PDF::Core::Reference if
+      # it is not already one.
+      #
+      def add_dest(name, reference)
+        reference = ref!(reference) unless reference.is_a?(PDF::Core::Reference)
+        dests.data.add(name, reference)
+      end
+
+      # Return a Dest specification for a specific location (and optional zoom
+      # level).
+      #
+      def dest_xyz(left, top, zoom=nil, dest_page=page)
+        [dest_page.dictionary, :XYZ, left, top, zoom]
+      end
+
+      # Return a Dest specification that will fit the given page into the
+      # viewport.
+      #
+      def dest_fit(dest_page=page)
+        [dest_page.dictionary, :Fit]
+      end
+
+      # Return a Dest specification that will fit the given page horizontally
+      # into the viewport, aligned vertically at the given top coordinate.
+      #
+      def dest_fit_horizontally(top, dest_page=page)
+        [dest_page.dictionary, :FitH, top]
+      end
+
+      # Return a Dest specification that will fit the given page vertically
+      # into the viewport, aligned horizontally at the given left coordinate.
+      #
+      def dest_fit_vertically(left, dest_page=page)
+        [dest_page.dictionary, :FitV, left]
+      end
+
+      # Return a Dest specification that will fit the given rectangle into the
+      # viewport, for the given page.
+      #
+      def dest_fit_rect(left, bottom, right, top, dest_page=page)
+        [dest_page.dictionary, :FitR, left, bottom, right, top]
+      end
+
+      # Return a Dest specfication that will fit the given page's bounding box
+      # into the viewport.
+      #
+      def dest_fit_bounds(dest_page=page)
+        [dest_page.dictionary, :FitB]
+      end
+
+      # Same as #dest_fit_horizontally, but works on the page's bounding box
+      # instead of the entire page.
+      #
+      def dest_fit_bounds_horizontally(top, dest_page=page)
+        [dest_page.dictionary, :FitBH, top]
+      end
+
+      # Same as #dest_fit_vertically, but works on the page's bounding box
+      # instead of the entire page.
+      #
+      def dest_fit_bounds_vertically(left, dest_page=page)
+        [dest_page.dictionary, :FitBV, left]
+      end
+    end
+  end
+end

data/lib/pdf/core/document_state.rb

@@ -0,0 +1,78 @@
+module PDF
+  module Core
+    class DocumentState #:nodoc:
+      def initialize(options)
+        normalize_metadata(options)
+
+        if options[:template]
+          @store = PDF::Core::ObjectStore.new(:template => options[:template])
+          @store.info.data.merge!(options[:info]) if options[:info]
+        else
+          @store = PDF::Core::ObjectStore.new(:info => options[:info])
+        end
+
+        @version                 = 1.3
+        @pages                   = []
+        @page                    = nil
+        @trailer                 = {}
+        @compress                = options.fetch(:compress, false)
+        @encrypt                 = options.fetch(:encrypt, false)
+        @encryption_key          = options[:encryption_key]
+        @optimize_objects        = options.fetch(:optimize_objects, false)
+        @skip_encoding           = options.fetch(:skip_encoding, false)
+        @before_render_callbacks = []
+        @on_page_create_callback = nil
+      end
+
+      attr_accessor :store, :version, :pages, :page, :trailer, :compress,
+        :encrypt, :encryption_key, :optimize_objects, :skip_encoding,
+        :before_render_callbacks, :on_page_create_callback
+
+      def populate_pages_from_store(document)
+        return 0 if @store.page_count <= 0 || @pages.size > 0
+
+        count = (1..@store.page_count)
+        @pages = count.map do |index|
+          orig_dict_id = @store.object_id_for_page(index)
+          PDF::Core::Page.new(document, :object_id => orig_dict_id)
+        end
+
+      end
+
+      def normalize_metadata(options)
+        options[:info] ||= {}
+        options[:info][:Creator] ||= "Prawn"
+        options[:info][:Producer] ||= "Prawn"
+
+        options[:info]
+      end
+
+      def insert_page(page, page_number)
+        pages.insert(page_number, page)
+        store.pages.data[:Kids].insert(page_number, page.dictionary)
+        store.pages.data[:Count] += 1
+      end
+
+      def on_page_create_action(doc)
+        on_page_create_callback[doc] if on_page_create_callback
+      end
+
+      def before_render_actions(doc)
+        before_render_callbacks.each{ |c| c.call(self) }
+      end
+
+      def page_count
+        pages.length
+      end
+
+      def render_body(output)
+        store.compact if optimize_objects
+        store.each do |ref|
+          ref.offset = output.size
+          output << (@encrypt ? ref.encrypted_object(@encryption_key) :
+                                ref.object)
+        end
+      end
+    end
+  end
+end

data/lib/pdf/core/filter_list.rb

@@ -0,0 +1,51 @@
+module PDF 
+  module Core
+    class FilterList
+      def initialize
+        @list = []
+      end
+
+      def <<(filter)
+        case filter
+        when Symbol
+          @list << [filter, nil]
+        when ::Hash
+          filter.each do |name, params|
+            @list << [name, params]
+          end
+        else
+          raise "Can not interpret input as filter: #{filter.inspect}"
+        end
+
+        self
+      end
+
+      def normalized
+        @list
+      end
+      alias_method :to_a, :normalized
+
+      def names
+        @list.map do |(name, _)|
+          name
+        end
+      end
+
+      def decode_params
+        @list.map do |(_, params)|
+          params
+        end
+      end
+
+      def inspect
+        @list.inspect
+      end
+
+      def each(&block)
+        @list.each do |filter|
+          block.call(filter)
+        end
+      end
+    end
+  end
+end

data/lib/pdf/core/filters.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+# prawn/core/filters.rb : Implements stream filters
+#
+# Copyright February 2013, Alexander Mankuta.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'zlib'
+
+module PDF
+  module Core
+    module Filters
+      module FlateDecode
+        def self.encode(stream, params = nil)
+          Zlib::Deflate.deflate(stream)
+        end
+
+        def self.decode(stream, params = nil)
+          Zlib::Inflate.inflate(stream)
+        end
+      end
+
+      # Pass through stub
+      module DCTDecode
+        def self.encode(stream, params = nil)
+          stream
+        end
+
+        def self.decode(stream, params = nil)
+          stream
+        end
+      end
+    end
+  end
+end

data/lib/pdf/core/graphics_state.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+#
+# Implements graphics state saving and restoring
+#
+# Copyright January 2010, Michael Witrant. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details
+#
+
+
+module PDF
+  module Core
+    class GraphicStateStack
+      attr_accessor :stack
+
+      def initialize(previous_state = nil)
+        self.stack = [GraphicState.new(previous_state)]
+      end
+
+      def save_graphic_state(graphic_state = nil)
+        stack.push(GraphicState.new(graphic_state || current_state))
+      end
+
+      def restore_graphic_state
+        if stack.empty?
+          raise PDF::Core::Errors::EmptyGraphicStateStack,
+            "\n You have reached the end of the graphic state stack"
+        end
+        stack.pop
+      end
+
+      def current_state
+        stack.last
+      end
+
+      def present?
+        stack.size > 0
+      end
+
+      def empty?
+        stack.empty?
+      end
+
+    end
+
+    class GraphicState
+      attr_accessor :color_space, :dash, :cap_style, :join_style, :line_width, :fill_color, :stroke_color
+
+      def initialize(previous_state = nil)
+        @color_space = previous_state ? previous_state.color_space.dup : {}
+        @fill_color = previous_state ? previous_state.fill_color : "000000"
+        @stroke_color = previous_state ? previous_state.stroke_color : "000000"
+        @dash = previous_state ? previous_state.dash : { :dash => nil, :space => nil, :phase => 0 }
+        @cap_style = previous_state ? previous_state.cap_style : :butt
+        @join_style = previous_state ? previous_state.join_style : :miter
+        @line_width = previous_state ? previous_state.line_width : 1
+      end
+
+      def dash_setting
+        if @dash[:dash].kind_of?(Array)
+          "[#{@dash[:dash].join(' ')}] #{@dash[:phase]} d"
+        else
+          "[#{@dash[:dash]} #{@dash[:space]}] #{@dash[:phase]} d"
+        end
+      end
+    end
+  end
+end