alphasights-prawn 0.10.0

data/lib/prawn/compatibility.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+#
+# Why would we ever use Ruby 1.8.7 when we can backport with something
+# as simple as this?
+#
+class String  #:nodoc:
+  def first_line
+    self.each_line { |line| return line }
+  end
+  unless "".respond_to?(:lines)
+    alias_method :lines, :to_a
+  end
+  unless "".respond_to?(:each_char)
+    def each_char #:nodoc:
+      # copied from jcode
+      if block_given?
+        scan(/./m) { |x| yield x }
+      else
+        scan(/./m)
+      end
+    end
+  end
+end
+
+unless File.respond_to?(:binread) 
+  def File.binread(file) #:nodoc:
+    File.open(file,"rb") { |f| f.read } 
+  end
+end
+
+if RUBY_VERSION < "1.9"
+  
+  def ruby_18  #:nodoc:  
+    yield
+  end
+  
+  def ruby_19  #:nodoc:  
+    false
+  end
+     
+else  
+ 
+  def ruby_18  #:nodoc:  
+    false  
+  end
+  
+  def ruby_19  #:nodoc:  
+    yield
+  end 
+  
+end 

data/lib/prawn/core.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+# Prawn : A library for PDF generation in Ruby
+#
+# Copyright April 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "set"
+
+%w[ttfunk/lib].each do |dep|
+  $LOAD_PATH.unshift(File.dirname(__FILE__) + "/../../vendor/#{dep}")
+end
+
+begin
+  require 'ttfunk'
+rescue LoadError
+  puts "Failed to load ttfunk. If you are running Prawn from git:"
+  puts "  git submodule init"
+  puts "  git submodule update"
+  exit
+end
+
+module Prawn
+  extend self
+
+  file = __FILE__
+  file = File.readlink(file) if File.symlink?(file)
+  dir  = File.dirname(file)
+                          
+  # The base source directory for Prawn as installed on the system
+  #
+  BASEDIR = File.expand_path(File.join(dir, '..', '..'))
+
+  # Whe set to true, Prawn will verify hash options to ensure only valid keys
+  # are used.  Off by default.
+  #
+  # Example:
+  #   >> Prawn::Document.new(:tomato => "Juicy")
+  #   Prawn::Errors::UnknownOption: 
+  #   Detected unknown option(s): [:tomato]
+  #   Accepted options are: [:page_size, :page_layout, :left_margin, ...]
+  #
+  attr_accessor :debug
+  
+  def verify_options(accepted, actual) #:nodoc:
+    return unless debug || $DEBUG
+    unless (act=Set[*actual.keys]).subset?(acc=Set[*accepted])
+      raise Prawn::Errors::UnknownOption,
+        "\nDetected unknown option(s): #{(act - acc).to_a.inspect}\n" <<
+        "Accepted options are: #{accepted.inspect}"
+    end
+    yield if block_given?
+  end
+  
+  module Configurable #:nodoc:
+    def configuration(*args)
+      @config ||= Marshal.load(Marshal.dump(default_configuration))
+      if Hash === args[0]
+        @config.update(args[0])
+      elsif args.length > 1
+        @config.values_at(*args)
+      elsif args.length == 1
+        @config[args[0]]
+      else
+        @config
+      end
+    end
+    
+    alias_method :C, :configuration
+  end
+end
+ 
+require "prawn/compatibility"
+require "prawn/errors"
+require "prawn/core/pdf_object"
+require "prawn/core/reference"
+require "prawn/core/page"
+require "prawn/core/object_store"
+require "prawn/core/document_state"
+require "prawn/core/literal_string"
+require "prawn/core/byte_string"
+require "prawn/core/name_tree"
+require "prawn/core/annotations"
+require "prawn/core/destinations"
+require "prawn/core/chunk"

data/lib/prawn/core/annotations.rb

@@ -0,0 +1,61 @@
+# 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 Prawn
+  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] = Prawn::Core::LiteralString.new(options[:Dest])
+        end
+
+        options
+      end
+      
+    end
+  end
+end

data/lib/prawn/core/byte_string.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module Prawn
+  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/prawn/core/chunk.rb

@@ -0,0 +1,36 @@
+module Prawn
+  module Core
+    class Chunk
+      def initialize(command, params={}, &action)
+         @command      = command 
+         @params       = params
+         @action       = action
+      end
+
+      attr_reader :command, :params, :action
+
+      def content
+        action.call(self)
+      end
+
+      def to_pdf
+        case results = content
+        when Array
+          results.map { |sub_chunk| sub_chunk.to_pdf }.join("\n")
+        when Prawn::Core::Chunk
+          results.to_pdf
+        else
+          results
+        end
+      end
+
+      def [](attr)
+        @params[attr]
+      end
+
+      def []=(attr, value)
+        @params[attr] = value
+      end
+    end
+  end
+end

data/lib/prawn/core/destinations.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+# prawn/core/destinations.rb : 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 Prawn
+  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!(Prawn::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 Prawn::Reference if
+      # it is not already one.
+      #
+      def add_dest(name, reference)
+        reference = ref!(reference) unless reference.is_a?(Prawn::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, page=current_page)
+        [page, :XYZ, left, top, zoom]
+      end
+
+      # Return a Dest specification that will fit the given page into the
+      # viewport.
+      #
+      def dest_fit(page=current_page)
+        [page, :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, page=current_page)
+        [page, :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, page=current_page)
+        [page, :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, page=current_page)
+        [page, :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(page=current_page)
+        [page, :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, page=current_page)
+        [page, :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, page=current_page)
+        [page, :FitBV, left]
+      end
+    end
+  end
+end

data/lib/prawn/core/document_state.rb

@@ -0,0 +1,78 @@
+module Prawn
+  module Core
+    class DocumentState #:nodoc:
+      def initialize(options)
+        normalize_metadata(options)
+
+        if options[:template]
+          @store = Prawn::Core::ObjectStore.new(:template => options[:template])
+        else
+          @store = Prawn::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)
+          Prawn::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"
+
+        info = 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/prawn/core/literal_string.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Prawn
+  module Core
+    # This is used to differentiate strings that must be encoded as
+    # a *literal* string, versus those that can be encoded in
+    # the PDF hexadecimal format.
+    #
+    # Some features of the PDF format appear to require that literal
+    # strings be used. One such feature is the /Dest key of a link
+    # annotation; if a hex encoded string is used there, the links
+    # do not work (as tested in Mac OS X Preview, and Adobe Acrobat
+    # Reader).
+    class LiteralString < String #:nodoc:
+    end
+  end
+end

data/lib/prawn/core/name_tree.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+# name_tree.rb : Implements NameTree for PDF
+#
+# Copyright November 2008, Jamis Buck. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Core
+    module NameTree #:nodoc:
+      class Node #:nodoc:
+        attr_reader :children
+        attr_reader :limit
+        attr_reader :document
+        attr_accessor :parent
+        attr_accessor :ref
+
+        def initialize(document, limit, parent=nil)
+          @document = document
+          @children = []
+          @limit = limit
+          @parent = parent
+          @ref = nil
+        end
+
+        def empty?
+          children.empty?
+        end
+
+        def size
+          leaf? ? children.size : children.inject(0) { |sum, child| sum + child.size }
+        end
+
+        def leaf?
+          children.empty? || children.first.is_a?(Value)
+        end
+
+        def add(name, value)
+          self << Value.new(name, value)
+        end
+
+        def to_hash
+          hash = {}
+
+          hash[:Limits] = [least, greatest] if parent
+          if leaf?
+            hash[:Names] = children if leaf?
+          else
+            hash[:Kids] = children.map { |child| child.ref }
+          end
+
+          return hash
+        end
+
+        def least
+          if leaf?
+            children.first.name
+          else
+            children.first.least
+          end
+        end
+
+        def greatest
+          if leaf?
+            children.last.name
+          else
+            children.last.greatest
+          end
+        end
+
+        def <<(value)
+          if children.empty?
+            children << value
+          elsif leaf?
+            children.insert(insertion_point(value), value)
+            split! if children.length > limit
+          else
+            fit = children.detect { |child| child >= value }
+            fit = children.last unless fit
+            fit << value
+          end
+
+          value
+        end
+
+        def >=(value)
+          children.empty? || children.last >= value
+        end
+
+        def split!
+          if parent
+            parent.split(self)
+          else
+            left, right = new_node(self), new_node(self)
+            split_children(self, left, right)
+            children.replace([left, right])
+          end
+        end
+
+        protected
+
+          def split(node)
+            new_child = new_node(self)
+            split_children(node, node, new_child)
+            index = children.index(node)
+            children.insert(index+1, new_child)
+            split! if children.length > limit
+          end
+
+        private
+
+          def new_node(parent=nil)
+            node = Node.new(document, limit, parent)
+            node.ref = document.ref!(node)
+            return node
+          end
+
+          def split_children(node, left, right)
+            half = (node.limit+1)/2
+
+            left_children, right_children = node.children[0...half], node.children[half..-1]
+
+            left.children.replace(left_children)
+            right.children.replace(right_children)
+
+            unless node.leaf?
+              left_children.each { |child| child.parent = left }
+              right_children.each { |child| child.parent = right }
+            end
+          end
+
+          def insertion_point(value)
+            children.each_with_index do |child, index|
+              return index if child >= value
+            end
+            return children.length
+          end
+      end
+
+      class Value #:nodoc:
+        include Comparable
+
+        attr_reader :name
+        attr_reader :value
+
+        def initialize(name, value)
+          @name, @value = Prawn::Core::LiteralString.new(name), value
+        end
+
+        def <=>(leaf)
+          name <=> leaf.name
+        end
+
+        def inspect
+          "#<Value: #{name.inspect} : #{value.inspect}>"
+        end
+
+        def to_s
+          "#{name} : #{value}"
+        end
+      end
+    end
+  end
+end