prawn 0.13.0 → 2.4.0

data/lib/pdf/core/pdf_object.rb

@@ -1,124 +0,0 @@
-# encoding: utf-8
-#
-# pdf_object.rb : Handles Ruby to PDF object serialization
-#
-# Copyright April 2008, Gregory Brown.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-# Top level Module
-#
-module PDF
-  module Core
-    module_function
-
-    if "".respond_to?(:encode)
-      # Ruby 1.9+
-      def utf8_to_utf16(str)
-        "\xFE\xFF".force_encoding("UTF-16BE") + str.encode("UTF-16BE")
-      end
-
-      # encodes any string into a hex representation. The result is a string
-      # with only 0-9 and a-f characters. That result is valid ASCII so tag
-      # it as such to account for behaviour of different ruby VMs
-      def string_to_hex(str)
-        str.unpack("H*").first.force_encoding("ascii")
-      end
-    else
-      # Ruby 1.8
-      def utf8_to_utf16(str)
-        utf16 = "\xFE\xFF"
-
-        str.codepoints do |cp|
-          if cp < 0x10000 # Basic Multilingual Plane
-            utf16 << [cp].pack("n")
-          else
-            # pull out high/low 10 bits
-            hi, lo = (cp - 0x10000).divmod(2**10)
-            # encode a surrogate pair
-            utf16 << [0xD800 + hi, 0xDC00 + lo].pack("n*")
-          end
-        end
-
-        utf16
-      end
-
-      def string_to_hex(str)
-        str.unpack("H*").first
-      end
-    end
-
-    # Serializes Ruby objects to their PDF equivalents.  Most primitive objects
-    # will work as expected, but please note that Name objects are represented
-    # by Ruby Symbol objects and Dictionary objects are represented by Ruby hashes
-    # (keyed by symbols)
-    #
-    #  Examples:
-    #
-    #     PdfObject(true)      #=> "true"
-    #     PdfObject(false)     #=> "false"
-    #     PdfObject(1.2124)    #=> "1.2124"
-    #     PdfObject("foo bar") #=> "(foo bar)"
-    #     PdfObject(:Symbol)   #=> "/Symbol"
-    #     PdfObject(["foo",:bar, [1,2]]) #=> "[foo /bar [1 2]]"
-    #
-    def PdfObject(obj, in_content_stream = false)
-      case(obj)
-      when NilClass   then "null"
-      when TrueClass  then "true"
-      when FalseClass then "false"
-      when Numeric
-        if (str = String(obj)) =~ /e/i
-          # scientific notation is not supported in PDF
-          sprintf("%.16f", obj).gsub(/\.?0+\z/, "")
-        else
-          str
-        end
-      when Array
-        "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
-      when PDF::Core::LiteralString
-        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
-        "(#{obj})"
-      when Time
-        obj = obj.strftime("D:%Y%m%d%H%M%S%z").chop.chop + "'00'"
-        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
-        "(#{obj})"
-      when PDF::Core::ByteString
-        "<" << obj.unpack("H*").first << ">"
-      when String
-        obj = utf8_to_utf16(obj) unless in_content_stream
-        "<" << string_to_hex(obj) << ">"
-       when Symbol
-         "/" + obj.to_s.unpack("C*").map { |n|
-          if n < 33 || n > 126 || [35,40,41,47,60,62].include?(n)
-            "#" + n.to_s(16).upcase
-          else
-            [n].pack("C*")
-          end
-         }.join
-      when ::Hash
-        output = "<< "
-        obj.each do |k,v|
-          unless String === k || Symbol === k
-            raise PDF::Core::Errors::FailedObjectConversion,
-              "A PDF Dictionary must be keyed by names"
-          end
-          output << PdfObject(k.to_sym, in_content_stream) << " " <<
-                    PdfObject(v, in_content_stream) << "\n"
-        end
-        output << ">>"
-      when PDF::Core::Reference
-        obj.to_s
-      when PDF::Core::NameTree::Node
-        PdfObject(obj.to_hash)
-      when PDF::Core::NameTree::Value
-        PdfObject(obj.name) + " " + PdfObject(obj.value)
-      when PDF::Core::OutlineRoot, PDF::Core::OutlineItem
-        PdfObject(obj.to_hash)
-      else
-        raise PDF::Core::Errors::FailedObjectConversion,
-          "This object cannot be serialized to PDF (#{obj.inspect})"
-      end
-    end
-  end
-end

data/lib/pdf/core/reference.rb

@@ -1,103 +0,0 @@
-# encoding: utf-8
-
-# reference.rb : Implementation of PDF indirect objects
-#
-# Copyright April 2008, Gregory Brown.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-
-module PDF
-  module Core
-    class Reference #:nodoc:
-
-      attr_accessor :gen, :data, :offset, :stream, :live, :identifier
-
-      def initialize(id, data)
-        @identifier = id
-        @gen        = 0
-        @data       = data
-        @stream     = Stream.new
-      end
-
-      def object
-        output = "#{@identifier} #{gen} obj\n"
-        unless @stream.empty?
-          output << PDF::Core::PdfObject(data.merge @stream.data) << "\n" << @stream.object
-        else
-          output << PDF::Core::PdfObject(data) << "\n"
-        end
-
-        output << "endobj\n"
-      end
-
-      def <<(io)
-        raise "Cannot attach stream to non-dictionary object" unless @data.is_a?(::Hash)
-        (@stream ||= Stream.new) << io
-      end
-
-      def to_s
-        "#{@identifier} #{gen} R"
-      end
-
-      # Creates a deep copy of this ref. If +share+ is provided, shares the
-      # given dictionary entries between the old ref and the new.
-      #
-      def deep_copy(share=[])
-        r = dup
-
-        case r.data
-        when ::Hash
-          # Copy each entry not in +share+.
-          (r.data.keys - share).each do |k|
-            r.data[k] = Marshal.load(Marshal.dump(r.data[k]))
-          end
-        when PDF::Core::NameTree::Node
-          r.data = r.data.deep_copy
-        else
-          r.data = Marshal.load(Marshal.dump(r.data))
-        end
-
-        r.stream = Marshal.load(Marshal.dump(r.stream))
-        r
-      end
-
-      # Replaces the data and stream with that of other_ref.
-      def replace(other_ref)
-        @data   = other_ref.data
-        @stream = other_ref.stream
-      end
-
-      # Marks this and all referenced objects live, recursively.
-      def mark_live
-        return if defined?(@live) && @live
-        @live = true
-        referenced_objects.each { |o| o.mark_live }
-      end
-
-      private
-
-      # All objects referenced by this one. Used for GC.
-      def referenced_objects(obj=@data)
-        case obj
-        when self.class
-          []
-        when ::Hash
-          obj.values.map{|v| [v] + referenced_objects(v) }
-        when Array
-          obj.map{|v| [v] + referenced_objects(v) }
-        when PDF::Core::OutlineRoot, PDF::Core::OutlineItem
-          referenced_objects(obj.to_hash)
-        else []
-        end.flatten.grep(self.class)
-      end
-
-    end
-
-    module_function
-
-    def Reference(*args, &block) #:nodoc:
-      Reference.new(*args, &block)
-    end
-  end
-end

data/lib/pdf/core/stream.rb

@@ -1,98 +0,0 @@
-# encoding: utf-8
-
-# prawn/core/stream.rb : Implements Stream objects
-#
-# Copyright February 2013, Alexander Mankuta.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-module PDF
-  module Core
-    class Stream
-      attr_reader :filters
-
-      def initialize(io = nil)
-        @filtered_stream = ''
-        @stream = io
-        @filters = FilterList.new
-      end
-
-      def <<(io)
-        (@stream ||= '') << io
-        @filtered_stream = nil
-        self
-      end
-
-      def compress!
-        unless @filters.names.include? :FlateDecode
-          @filtered_stream = nil
-          @filters << :FlateDecode
-        end
-      end
-
-      def compressed?
-        @filters.names.include? :FlateDecode
-      end
-
-      def empty?
-        @stream.nil?
-      end
-
-      def filtered_stream
-        if @stream
-          if @filtered_stream.nil?
-            @filtered_stream = @stream.dup
-
-            @filters.each do |(filter_name, params)|
-              if filter = PDF::Core::Filters.const_get(filter_name)
-                @filtered_stream = filter.encode @filtered_stream, params
-              end
-            end
-          end
-
-          @filtered_stream
-          # XXX Fillter stream
-        else
-          nil
-        end
-      end
-
-      def length
-        @stream.length
-      end
-
-      def object
-        if filtered_stream
-          "stream\n#{filtered_stream}\nendstream\n"
-        else
-          ''
-        end
-      end
-
-      def data
-        if @stream
-          filter_names = @filters.names
-          filter_params = @filters.decode_params
-
-          d = {
-            :Length => filtered_stream.length
-          }
-          if filter_names.any?
-            d[:Filter] = filter_names
-          end
-          if filter_params.any? {|f| !f.nil? }
-            d[:DecodeParms] = filter_params
-          end
-
-          d
-        else
-          {}
-        end
-      end
-
-      def inspect
-        "#<#{self.class.name}:0x#{'%014x' % object_id} @stream=#{@stream.inspect}, @filters=#{@filters.inspect}>"
-      end
-    end
-  end
-end

data/lib/pdf/core/text.rb

@@ -1,275 +0,0 @@
-# encoding: utf-8
-
-# prawn/core/text.rb : Implements low level text helpers for Prawn
-#
-# Copyright January 2010, Daniel Nelson.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-module PDF
-  module Core
-    module Text #:nodoc:
-
-      # These should be used as a base. Extensions may build on this list
-      #
-      VALID_OPTIONS = [:kerning, :size, :style]
-      MODES = { :fill => 0, :stroke => 1, :fill_stroke => 2, :invisible => 3,
-                :fill_clip => 4, :stroke_clip => 5, :fill_stroke_clip => 6,
-                :clip => 7 }
-
-      attr_reader :skip_encoding
-
-      # Low level text placement method. All font and size alterations
-      # should already be set
-      #
-      def draw_text!(text, options)
-        x,y = map_to_absolute(options[:at])
-        add_text_content(text,x,y,options)
-      end
-
-      # Low level call to set the current font style and extract text options from
-      # an options hash. Should be called from within a save_font block
-      #
-      def process_text_options(options)
-        if options[:style]
-          raise "Bad font family" unless font.family
-          font(font.family, :style => options[:style])
-        end
-
-        # must compare against false to keep kerning on as default
-        unless options[:kerning] == false
-          options[:kerning] = font.has_kerning_data?
-        end
-
-        options[:size] ||= font_size
-      end
-
-      # Retrieve the current default kerning setting.
-      #
-      # Defaults to true
-      #
-      def default_kerning?
-        return true if !defined?(@default_kerning)
-        @default_kerning
-      end
-
-      # Call with a boolean to set the document-wide kerning setting. This can be
-      # overridden using the :kerning text option when drawing text or a text
-      # box.
-      #
-      #   pdf.default_kerning = false
-      #   pdf.text("hello world")                   # text is not kerned
-      #   pdf.text("hello world", :kerning => true) # text is kerned
-      #
-      def default_kerning(boolean)
-        @default_kerning = boolean
-      end
-
-      alias_method :default_kerning=, :default_kerning
-
-      # Call with no argument to retrieve the current default leading.
-      #
-      # Call with a number to set the document-wide text leading. This can be
-      # overridden using the :leading text option when drawing text or a text
-      # box.
-      #
-      #   pdf.default_leading = 7
-      #   pdf.text("hello world")                # a leading of 7 is used
-      #   pdf.text("hello world", :leading => 0) # a leading of 0 is used
-      #
-      # Defaults to 0
-      #
-      def default_leading(number=nil)
-        if number.nil?
-          defined?(@default_leading) && @default_leading || 0
-        else
-          @default_leading = number
-        end
-      end
-
-      alias_method :default_leading=, :default_leading
-
-      # Call with no argument to retrieve the current text direction.
-      #
-      # Call with a symbol to set the document-wide text direction. This can be
-      # overridden using the :direction text option when drawing text or a text
-      # box.
-      #
-      #   pdf.text_direction = :rtl
-      #   pdf.text("hello world")                     # prints "dlrow olleh"
-      #   pdf.text("hello world", :direction => :ltr) # prints "hello world"
-      #
-      # Valid directions are:
-      #
-      # * :ltr             - left-to-right (default)
-      # * :rtl             - right-to-left
-      #
-      # Side effects:
-      #
-      # * When printing left-to-right, the default text alignment is :left
-      # * When printing right-to-left, the default text alignment is :right
-      #
-      def text_direction(direction=nil)
-        if direction.nil?
-          defined?(@text_direction) && @text_direction || :ltr
-        else
-          @text_direction = direction
-        end
-      end
-
-      alias_method :text_direction=, :text_direction
-
-      # Call with no argument to retrieve the current fallback fonts.
-      #
-      # Call with an array of font names. Each name must be the name of an AFM
-      # font or the name that was used to register a family of TTF fonts (see
-      # Prawn::Document#font_families). If present, then each glyph will be
-      # rendered using the first font that includes the glyph, starting with the
-      # current font and then moving through :fallback_fonts from left to right.
-      #
-      # Call with an empty array to turn off fallback fonts
-      #
-      # file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
-      # font_families["Kai"] = {
-      #   :normal => { :file => file, :font => "Kai" }
-      # }
-      # file = "#{Prawn::DATADIR}/fonts/Action Man.dfont"
-      # font_families["Action Man"] = {
-      #   :normal      => { :file => file, :font => "ActionMan" },
-      # }
-      # fallback_fonts ["Times-Roman", "Kai"]
-      # font "Action Man"
-      # text "hello ƒ 你好"
-      # > hello prints in Action Man
-      # > ƒ prints in Times-Roman
-      # > 你好 prints in Kai
-      #
-      # fallback_fonts [] # clears document-wide fallback fonts
-      #
-      # Side effects:
-      #
-      # * Increased overhead when fallback fonts are declared as each glyph is
-      #   checked to see whether it exists in the current font
-      #
-      def fallback_fonts(fallback_fonts=nil)
-        if fallback_fonts.nil?
-          defined?(@fallback_fonts) && @fallback_fonts || []
-        else
-          @fallback_fonts = fallback_fonts
-        end
-      end
-
-      alias_method :fallback_fonts=, :fallback_fonts
-
-      # Call with no argument to retrieve the current text rendering mode.
-      #
-      # Call with a symbol and block to temporarily change the current
-      # text rendering mode.
-      #
-      #   pdf.text_rendering_mode(:stroke) do
-      #     pdf.text("Outlined Text")
-      #   end
-      #
-      # Valid modes are:
-      #
-      # * :fill             - fill text (default)
-      # * :stroke           - stroke text
-      # * :fill_stroke      - fill, then stroke text
-      # * :invisible        - invisible text
-      # * :fill_clip        - fill text then add to path for clipping
-      # * :stroke_clip      - stroke text then add to path for clipping
-      # * :fill_stroke_clip - fill then stroke text, then add to path for clipping
-      # * :clip             - add text to path for clipping
-      #
-      # There's the special mode :unknown which only occurs when we're working
-      # with templates.  If left in :unknown, the first text command will force
-      # an assertion to :fill.
-      def text_rendering_mode(mode=nil)
-        return (defined?(@text_rendering_mode) && @text_rendering_mode || :fill) if mode.nil?
-        unless MODES.key?(mode)
-          raise ArgumentError, "mode must be between one of #{MODES.keys.join(', ')} (#{mode})"
-        end
-        original_mode = self.text_rendering_mode
-        if original_mode == :unknown
-          original_mode = :fill
-          add_content "\n#{MODES[:fill]} Tr"
-        end
-        if original_mode == mode
-          yield
-        else
-          @text_rendering_mode = mode
-          add_content "\n#{MODES[mode]} Tr"
-          yield
-          add_content "\n#{MODES[original_mode]} Tr"
-          @text_rendering_mode = original_mode
-        end
-      end
-
-      def forget_text_rendering_mode!
-        @text_rendering_mode = :unknown
-      end
-
-      # Increases or decreases the space between characters.
-      # For horizontal text, a positive value will increase the space.
-      # For veritical text, a positive value will decrease the space.
-      #
-      def character_spacing(amount=nil)
-        return defined?(@character_spacing) && @character_spacing || 0 if amount.nil?
-        original_character_spacing = character_spacing
-        if original_character_spacing == amount
-          yield
-        else
-          @character_spacing = amount
-          add_content "\n%.3f Tc" % amount
-          yield
-          add_content "\n%.3f Tc" % original_character_spacing
-          @character_spacing = original_character_spacing
-        end
-      end
-
-      # Increases or decreases the space between words.
-      # For horizontal text, a positive value will increase the space.
-      # For veritical text, a positive value will decrease the space.
-      #
-      def word_spacing(amount=nil)
-        return defined?(@word_spacing) && @word_spacing || 0 if amount.nil?
-        original_word_spacing = word_spacing
-        if original_word_spacing == amount
-          yield
-        else
-          @word_spacing = amount
-          add_content "\n%.3f Tw" % amount
-          yield
-          add_content "\n%.3f Tw" % original_word_spacing
-          @word_spacing = original_word_spacing
-        end
-      end
-
-      private
-
-      def add_text_content(text, x, y, options)
-        chunks = font.encode_text(text,options)
-
-        add_content "\nBT"
-
-        if options[:rotate]
-          rad = options[:rotate].to_f * Math::PI / 180
-          arr = [ Math.cos(rad), Math.sin(rad), -Math.sin(rad), Math.cos(rad), x, y ]
-          add_content "%.3f %.3f %.3f %.3f %.3f %.3f Tm" % arr
-        else
-          add_content "#{x} #{y} Td"
-        end
-
-        chunks.each do |(subset, string)|
-          font.add_to_current_page(subset)
-          add_content "/#{font.identifier_for(subset)} #{font_size} Tf"
-
-          operation = options[:kerning] && string.is_a?(Array) ? "TJ" : "Tj"
-          add_content PDF::Core::PdfObject(string, true) << " " << operation
-        end
-
-        add_content "ET\n"
-      end
-    end
-  end
-end

data/lib/pdf/core.rb

@@ -1,35 +0,0 @@
-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