pdf-core 0.0.1

data/lib/pdf/core/page_geometry.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+# Describes PDF page geometries
+#
+# 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
+
+    # Dimensions pulled from PDF::Writer, rubyforge.org/projects/ruby-pdf
+    #
+    # All of these dimensions are in PDF Points (1/72 inch)
+    #
+    # ===Inbuilt Sizes:
+    #
+    #
+    # 4A0:: => 4767.87 x 6740.79
+    # 2A0:: => 3370.39 x 4767.87
+    # A0:: => 2383.94 x 3370.39
+    # A1:: => 1683.78 x 2383.94
+    # A2:: => 1190.55 x 1683.78
+    # A3:: => 841.89 x 1190.55
+    # A4:: => 595.28 x 841.89
+    # A5:: => 419.53 x 595.28
+    # A6:: => 297.64 x 419.53
+    # A7:: => 209.76 x 297.64
+    # A8:: => 147.40 x 209.76
+    # A9:: => 104.88 x 147.40
+    # A10:: => 73.70 x 104.88
+    # B0:: => 2834.65 x 4008.19
+    # B1:: => 2004.09 x 2834.65
+    # B2:: => 1417.32 x 2004.09
+    # B3:: => 1000.63 x 1417.32
+    # B4:: => 708.66 x 1000.63
+    # B5:: => 498.90 x 708.66
+    # B6:: => 354.33 x 498.90
+    # B7:: => 249.45 x 354.33
+    # B8:: => 175.75 x 249.45
+    # B9:: => 124.72 x 175.75
+    # B10:: => 87.87 x 124.72
+    # C0:: => 2599.37 x 3676.54
+    # C1:: => 1836.85 x 2599.37
+    # C2:: => 1298.27 x 1836.85
+    # C3:: => 918.43 x 1298.27
+    # C4:: => 649.13 x 918.43
+    # C5:: => 459.21 x 649.13
+    # C6:: => 323.15 x 459.21
+    # C7:: => 229.61 x 323.15
+    # C8:: => 161.57 x 229.61
+    # C9:: => 113.39 x 161.57
+    # C10:: => 79.37 x 113.39
+    # RA0:: => 2437.80 x 3458.27
+    # RA1:: => 1729.13 x 2437.80
+    # RA2:: => 1218.90 x 1729.13
+    # RA3:: => 864.57 x 1218.90
+    # RA4:: => 609.45 x 864.57
+    # SRA0:: => 2551.18 x 3628.35
+    # SRA1:: => 1814.17 x 2551.18
+    # SRA2:: => 1275.59 x 1814.17
+    # SRA3:: => 907.09 x 1275.59
+    # SRA4:: => 637.80 x 907.09
+    # EXECUTIVE:: => 521.86 x 756.00
+    # FOLIO:: => 612.00 x 936.00
+    # LEGAL:: => 612.00 x 1008.00
+    # LETTER:: => 612.00 x 792.00
+    # TABLOID:: => 792.00 x 1224.00
+    #
+    module PageGeometry
+
+      SIZES = { "4A0" => [4767.87, 6740.79],
+                "2A0" => [3370.39, 4767.87],
+                 "A0" => [2383.94, 3370.39],
+                 "A1" => [1683.78, 2383.94],
+                 "A2" => [1190.55, 1683.78],
+                 "A3" => [841.89, 1190.55],
+                 "A4" => [595.28, 841.89],
+                 "A5" => [419.53, 595.28],
+                 "A6" => [297.64, 419.53],
+                 "A7" => [209.76, 297.64],
+                 "A8" => [147.40, 209.76],
+                 "A9" => [104.88, 147.40],
+                "A10" => [73.70, 104.88],
+                 "B0" => [2834.65, 4008.19],
+                 "B1" => [2004.09, 2834.65],
+                 "B2" => [1417.32, 2004.09],
+                 "B3" => [1000.63, 1417.32],
+                 "B4" => [708.66, 1000.63],
+                 "B5" => [498.90, 708.66],
+                 "B6" => [354.33, 498.90],
+                 "B7" => [249.45, 354.33],
+                 "B8" => [175.75, 249.45],
+                 "B9" => [124.72, 175.75],
+                "B10" => [87.87, 124.72],
+                 "C0" => [2599.37, 3676.54],
+                 "C1" => [1836.85, 2599.37],
+                 "C2" => [1298.27, 1836.85],
+                 "C3" => [918.43, 1298.27],
+                 "C4" => [649.13, 918.43],
+                 "C5" => [459.21, 649.13],
+                 "C6" => [323.15, 459.21],
+                 "C7" => [229.61, 323.15],
+                 "C8" => [161.57, 229.61],
+                 "C9" => [113.39, 161.57],
+                "C10" => [79.37, 113.39],
+                "RA0" => [2437.80, 3458.27],
+                "RA1" => [1729.13, 2437.80],
+                "RA2" => [1218.90, 1729.13],
+                "RA3" => [864.57, 1218.90],
+                "RA4" => [609.45, 864.57],
+               "SRA0" => [2551.18, 3628.35],
+               "SRA1" => [1814.17, 2551.18],
+               "SRA2" => [1275.59, 1814.17],
+               "SRA3" => [907.09, 1275.59],
+               "SRA4" => [637.80, 907.09],
+          "EXECUTIVE" => [521.86, 756.00],
+              "FOLIO" => [612.00, 936.00],
+              "LEGAL" => [612.00, 1008.00],
+             "LETTER" => [612.00, 792.00],
+            "TABLOID" => [792.00, 1224.00] }
+
+    end
+  end
+end
+

data/lib/pdf/core/pdf_object.rb

@@ -0,0 +1,99 @@
+# 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
+
+    def utf8_to_utf16(str)
+      "\xFE\xFF".force_encoding(::Encoding::UTF_16BE) + str.encode(::Encoding::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(::Encoding::US_ASCII)
+    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

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

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

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