hexapdf 0.10.0 → 0.11.0

data/lib/hexapdf/name_tree_node.rb

@@ -60,9 +60,9 @@ module HexaPDF
 
     include Utils::SortedTreeNode
 
-    define_field :Kids,   type: Array
-    define_field :Names,  type: Array
-    define_field :Limits, type: Array
+    define_field :Kids,   type: PDFArray
+    define_field :Names,  type: PDFArray
+    define_field :Limits, type: PDFArray
 
     private
 

data/lib/hexapdf/number_tree_node.rb

@@ -49,9 +49,9 @@ module HexaPDF
 
     include Utils::SortedTreeNode
 
-    define_field :Kids,   type: Array
-    define_field :Nums,   type: Array
-    define_field :Limits, type: Array
+    define_field :Kids,   type: PDFArray
+    define_field :Nums,   type: PDFArray
+    define_field :Limits, type: PDFArray
 
     private
 

data/lib/hexapdf/pdf_array.rb

@@ -0,0 +1,207 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2019 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/object'
+
+module HexaPDF
+
+  # Implementation of the PDF array type.
+  #
+  # This is mainly done to provide automatic resolution of indirect object references when using the
+  # #[] method. Therefore not all Array methods are implemented - use the #value directly if other
+  # methods are needed.
+  #
+  # See: PDF1.7 s7.3.6
+  class PDFArray < HexaPDF::Object
+
+    include Enumerable
+
+    # :call-seq:
+    #   array[index]             -> obj or nil
+    #   array[start, length]     -> new_array or nil
+    #   array[range]             -> new_array or nil
+    #
+    # Returns the value at the given index, or a subarray using the given +start+ and +length+, or a
+    # subarray specified by +range+.
+    #
+    # This method should be used instead of direct access to a value because it provides some
+    # advantages:
+    #
+    # * References are automatically resolved.
+    #
+    # * Returns the native Ruby object for values with class HexaPDF::Object. However, all
+    #   subclasses of HexaPDF::Object are returned as is (it makes no sense, for example, to return
+    #   the hash that describes the Catalog instead of the Catalog object).
+    def [](arg1, arg2 = nil)
+      data = value[arg1, *arg2]
+      return if data.nil?
+
+      if arg2 || arg1.kind_of?(Range)
+        index = (arg2 ? arg1 : arg1.begin)
+        data.map! {|item| process_entry(item, index).tap { index += 1 } }
+      else
+        process_entry(data, arg1)
+      end
+    end
+
+    # Stores the data under the given index in the array.
+    #
+    # If the current value for this index has the class HexaPDF::Object (and only this, no
+    # subclasses) and the given data has not (including subclasses), the data is stored inside the
+    # HexaPDF::Object.
+    def []=(index, data)
+      if value[index].class == HexaPDF::Object && !data.kind_of?(HexaPDF::Object) &&
+          !data.kind_of?(HexaPDF::Reference)
+        value[index].value = data
+      else
+        value[index] = data
+      end
+    end
+
+    # Returns the values at the given indices.
+    #
+    # See #[] for details
+    def values_at(*indices)
+      indices.map! {|index| self[index] }
+    end
+
+    # Append a value to the array.
+    def <<(data)
+      value << data
+    end
+
+    # Insert one or more values into the array at the given index.
+    def insert(index, *objects)
+      value.insert(index, *objects)
+    end
+
+    # Deletes the value at the given index.
+    def delete_at(index)
+      value.delete_at(index)
+    end
+
+    # :call-seq:
+    #   array.slice!(index)             -> obj or nil
+    #   array.slice!(start, length)     -> new_array or nil
+    #   array.slice!(range)             -> new_array or nil
+    #
+    # Deletes the element(s) given by an index (and optionally a length) or by a range, and returns
+    # them or +nil+ if the index is out of range.
+    def slice!(arg1, arg2 = nil)
+      data = value.slice!(arg1, *arg2)
+      if arg2 || arg1.kind_of?(Range)
+        data.map! {|item| process_entry(item) }
+      else
+        process_entry(data)
+      end
+    end
+
+    # :call-seq:
+    #   array.reject! {|item| block }   -> array or nil
+    #   array.reject!                   -> Enumerator
+    #
+    # Deletes all elements from the array for which the block returns +true+. If no changes were
+    # done, returns +nil+.
+    def reject!
+      value.reject! {|item| yield(process_entry(item)) }
+    end
+
+    # :call-seq:
+    #   array.index(obj)              -> int or nil
+    #   array.index {|item| block }   -> int or nil
+    #   array.index                   -> Enumerator
+    #
+    # Returns the index of the first object such that object is == to +obj+, or, if a block is
+    # given, the index of the first object for which the block returns +true+.
+    def index(*obj, &block)
+      find_index(*obj, &block)
+    end
+
+    # Returns the number of elements in the array.
+    def length
+      value.length
+    end
+    alias size length
+
+    # Returns +true+ if the array has no elements.
+    def empty?
+      value.empty?
+    end
+
+    # :call-seq:
+    #   array.each {|value| block}    -> array
+    #   array.each                    -> Enumerator
+    #
+    # Calls the given block once for every value of the array.
+    #
+    # Note that the yielded value is already preprocessed like in #[].
+    def each
+      return to_enum(__method__) unless block_given?
+      value.each_index {|index| yield(self[index]) }
+      self
+    end
+
+    # Returns a duplicate of the underlying array.
+    def to_ary
+      value.dup
+    end
+
+    private
+
+    # Ensures that the value is useful for a PDFArray.
+    def after_data_change # :nodoc:
+      super
+      data.value ||= []
+      unless value.kind_of?(Array)
+        raise ArgumentError, "A PDF array object needs an array value, not a #{value.class}"
+      end
+    end
+
+    # Processes the given array entry with index +index+.
+    def process_entry(data, index = nil)
+      if data.kind_of?(HexaPDF::Reference)
+        data = document.deref(data)
+        value[index] = data if index
+      end
+      if data.class == HexaPDF::Object || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
+        data = data.value
+      end
+      data
+    end
+
+  end
+
+end

data/lib/hexapdf/rectangle.rb

@@ -34,7 +34,7 @@
 # commercial licenses are available at <https://gettalong.at/hexapdf/>.
 #++
 
-require 'hexapdf/object'
+require 'hexapdf/pdf_array'
 
 module HexaPDF
 
@@ -52,36 +52,36 @@ module HexaPDF
   # is the top right x-coordinate and +top+ is the top right y-coordinate.
   #
   # See: PDF1.7 s7.9.5
-  class Rectangle < HexaPDF::Object
+  class Rectangle < HexaPDF::PDFArray
 
     # Returns the x-coordinate of the bottom-left corner.
     def left
-      value[0]
+      self[0]
     end
 
     # Returns the x-coordinate of the top-right corner.
     def right
-      value[2]
+      self[2]
     end
 
     # Returns the y-coordinate of the bottom-left corner.
     def bottom
-      value[1]
+      self[1]
     end
 
     # Returns the y-coordinate of the top-right corner.
     def top
-      value[3]
+      self[3]
     end
 
     # Returns the width of the rectangle.
     def width
-      value[2] - value[0]
+      self[2] - self[0]
     end
 
     # Returns the height of the rectangle.
     def height
-      value[3] - value[1]
+      self[3] - self[1]
     end
 
     # Compares this rectangle to +other+ like in Object#== but also allows comparison to simple
@@ -96,16 +96,16 @@ module HexaPDF
     # top right corner.
     def after_data_change
       super
-      unless value.kind_of?(Array) && value.size == 4 && value.all? {|i| i.kind_of?(Numeric) }
+      unless value.size == 4 && all?(Numeric)
         raise ArgumentError, "A PDF rectangle structure must contain an array of four numbers"
       end
-      value[0], value[2] = value[2], value[0] if value[0] > value[2]
-      value[1], value[3] = value[3], value[1] if value[1] > value[3]
+      self[0], self[2] = self[2], self[0] if self[0] > self[2]
+      self[1], self[3] = self[3], self[1] if self[1] > self[3]
     end
 
     def perform_validation #:nodoc:
       super
-      unless value.kind_of?(Array) && value.size == 4 && value.all? {|i| i.kind_of?(Numeric) }
+      unless value.size == 4 && all?(Numeric)
         yield("A PDF rectangle structure must contain an array of four numbers", false)
       end
     end

data/lib/hexapdf/serializer.rb

@@ -185,7 +185,7 @@ module HexaPDF
     def serialize_symbol(obj)
       NAME_CACHE[obj] ||=
         begin
-          str = obj.to_s.force_encoding(Encoding::BINARY)
+          str = obj.to_s.dup.force_encoding(Encoding::BINARY)
           str.gsub!(NAME_REGEXP, NAME_SUBSTS)
           "/#{str}"
         end

data/lib/hexapdf/stream.rb

@@ -132,15 +132,17 @@ module HexaPDF
   # The basic Object class cannot hold stream data, only this subclass contains the necessary
   # methods to conveniently work with the stream data!
   #
+  # Note that support for external streams (/F, /FFilter, /FDecodeParms) is not yet implemented!
+  #
   # See: PDF1.7 s7.3.8, Dictionary
   class Stream < Dictionary
 
     define_field :Length,       type: Integer # not required, will be auto-filled when writing
-    define_field :Filter,       type: [Symbol, Array]
-    define_field :DecodeParms,  type: [Dictionary, Array]
+    define_field :Filter,       type: [Symbol, PDFArray]
+    define_field :DecodeParms,  type: [Dictionary, PDFArray]
     define_field :F,            type: :Filespec, version: '1.2'
-    define_field :FFilter,      type: [Symbol, Array], version: '1.2'
-    define_field :FDecodeParms, type: [Dictionary, Array], version: '1.2'
+    define_field :FFilter,      type: [Symbol, PDFArray], version: '1.2'
+    define_field :FDecodeParms, type: [Dictionary, PDFArray], version: '1.2'
     define_field :DL,           type: Integer
 
     # Stream objects must always be indirect.

data/lib/hexapdf/task/optimize.rb

@@ -115,7 +115,7 @@ module HexaPDF
         if object_streams == :generate
           process_object_streams(doc, :generate, xref_streams)
         elsif xref_streams == :generate
-          doc.add(Type: :XRef)
+          doc.add({Type: :XRef})
         end
       end
 
@@ -142,7 +142,7 @@ module HexaPDF
           doc.revisions.each_with_index do |rev, rev_index|
             xref_stream = false
             count = 0
-            objstms = [doc.wrap(Type: :ObjStm)]
+            objstms = [doc.wrap({Type: :ObjStm})]
             rev.each do |obj|
               if obj.type == :XRef
                 xref_stream = true
@@ -156,7 +156,7 @@ module HexaPDF
               objstms[-1].add_object(obj)
               count += 1
               if count == 200
-                objstms << doc.wrap(Type: :ObjStm)
+                objstms << doc.wrap({Type: :ObjStm})
                 count = 0
               end
             end

data/lib/hexapdf/type.rb

@@ -70,6 +70,8 @@ module HexaPDF
     autoload(:FontType0, 'hexapdf/type/font_type0')
     autoload(:CIDFont, 'hexapdf/type/cid_font')
     autoload(:FontType3, 'hexapdf/type/font_type3')
+    autoload(:IconFit, 'hexapdf/type/icon_fit')
+    autoload(:AcroForm, 'hexapdf/type/acro_form')
 
   end
 

data/lib/hexapdf/type/acro_form.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2019 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+module HexaPDF
+  module Type
+
+    # Namespace module for all AcroForm related dictionary types.
+    #
+    # See: PDF1.7 s12.7
+    module AcroForm
+
+      autoload(:Form, 'hexapdf/type/acro_form/form')
+      autoload(:Field, 'hexapdf/type/acro_form/field')
+
+    end
+
+  end
+end

data/lib/hexapdf/type/acro_form/field.rb

@@ -0,0 +1,129 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2019 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/dictionary'
+
+module HexaPDF
+  module Type
+    module AcroForm
+
+      # Field dictionaries are used to define the properties of form fields of AcroForm objects.
+      #
+      # Fields can be organized in a hierarchy using the /Kids and /Parent keys, for namespacing
+      # purposes and to set default values. Those fields that have other fields as children are
+      # called non-terminal fields, otherwise they are called terminal fields.
+      #
+      # See: PDF1.7 s12.7.3.1
+      class Field < Dictionary
+
+        define_type :XXAcroFormField
+
+        # List of inheritable fields.
+        INHERITABLE_FIELDS = [:FT, :Ff, :V, :DV]
+
+        define_field :FT,     type: Symbol, allowed_values: [:Btn, :Tx, :Ch, :Sig]
+        define_field :Parent, type: :XXAcroFormField
+        define_field :Kids,   type: PDFArray
+        define_field :T,      type: String
+        define_field :TU,     type: String, version: '1.3'
+        define_field :TM,     type: String, version: '1.3'
+        define_field :Ff,     type: Integer, default: 0
+        define_field :V,      type: [Symbol, String, Stream, PDFArray, Dictionary]
+        define_field :DV,     type: [Symbol, String, Stream, PDFArray, Dictionary]
+        define_field :AA,     type: Dictionary, version: '1.2'
+
+        # Form fields must always be indirect objects.
+        def must_be_indirect?
+          true
+        end
+
+        # Returns the value for the entry +name+.
+        #
+        # If +name+ is an inheritable value and the value has not been set on this field object, its
+        # value is retrieved from the parent fields.
+        #
+        # See: Dictionary#[]
+        def [](name)
+          if value[name].nil? && INHERITABLE_FIELDS.include?(name)
+            field = self
+            field = field[:Parent] while field.value[name].nil? && field[:Parent]
+            field == self || field.value[name].nil? ? super : field[name]
+          else
+            super
+          end
+        end
+
+        # Returns the type of the field, either :Btn (pushbuttons, check boxes, radio buttons), :Tx
+        # (text fields), :Ch (scrollable list boxes, combo boxes) or :Sig (signature fields).
+        def field_type
+          self[:FT]
+        end
+
+        # Returns the full name of the field or +nil+ if no name is set.
+        #
+        # The full name of a field is constructed using the full name of the parent field, a period
+        # and the partial name of the field.
+        def full_name
+          if key?(:Parent)
+            [self[:Parent].full_name, self[:T]].compact.join('.')
+          else
+            self[:T]
+          end
+        end
+
+        # Returns +true+ if this is a terminal field.
+        def terminal_field?
+          kids = self[:Kids]
+          kids.nil? || kids.empty? || kids.any? {|kid| kid[:Subtype] == :Widget }
+        end
+
+        private
+
+        def perform_validation #:nodoc:
+          super
+          if terminal_field? && field_type.nil?
+            yield("/FT is required for terminal fields")
+          end
+          if key?(:T) && self[:T].include?('.')
+            yield("/T shall not contain a period")
+          end
+        end
+
+      end
+
+    end
+  end
+end