hexapdf 0.7.0 → 0.8.0

data/lib/hexapdf/dictionary.rb

@@ -78,6 +78,10 @@ module HexaPDF
     #        If a Symbol object instead of a class is provided, the class is looked up using the
     #        'object.type_map' global configuration option when necessary to support lazy loading.
     #
+    #        Note that if multiple types are allowed and one of the allowed types is Dictionary (or
+    #        a Symbol), it has to be the first in the list. Otherwise automatic type conversion
+    #        functions won't work correctly.
+    #
     # required:: Specifies whether this field is required.
     #
     # default:: Specifies the default value for the field, if any.
@@ -156,7 +160,9 @@ module HexaPDF
       if data.class == HexaPDF::Object || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
         data = data.value
       end
-      self[name] = data = field.convert(data, document) if field&.convert?(data)
+      if (result = field&.convert(data, document))
+        self[name] = data = result
+      end
       data
     end
 

data/lib/hexapdf/dictionary_fields.rb

@@ -55,13 +55,10 @@ module HexaPDF
   #   Should return +nil+, a single type class or an array of type classes which will additionally
   #   be allowed for the field.
   #
-  # convert?(data, type)::
-  #   Should return +true+ if the given +data+ object can be converted. The +type+ argument is the
-  #   result of the Field#type method call.
-  #
   # convert(data, type, document)::
-  #   Should return the +converted+ data. The +type+ argument is the result of the Field#type method
-  #   call and +document+ is the HexaPDF::Document for which the data should be converted.
+  #   Should return the +converted+ data if conversion is possible and +nil+ otherwise. The +type+
+  #   argument is the result of the Field#type method call and +document+ is the HexaPDF::Document
+  #   for which the data should be converted.
   module DictionaryFields
 
     # This constant should *always* be used for boolean fields.
@@ -112,14 +109,14 @@ module HexaPDF
         @type = [type].flatten
         @type_mapped = false
         @required, @default, @indirect, @version = required, default, indirect, version
-        @converter = self.class.converter_for(type)
+        @converters = @type.map {|t| self.class.converter_for(t) }.compact
       end
 
       # Returns the array with valid types for this field.
       def type
         return @type if @type_mapped
         @type_mapped = true
-        @type.concat(Array(@converter.additional_types))
+        @type.concat(@converters.map(&:additional_types).compact.flatten)
         @type.map! do |type|
           if type.kind_of?(Symbol)
             HexaPDF::GlobalConfiguration.constantize('object.type_map', type)
@@ -149,7 +146,7 @@ module HexaPDF
 
       # Returns +true+ if the default value can safely be duplicated with #dup.
       def duplicatable_default?
-        @cached_dupdefault ||= HexaPDF::Object::NOT_DUPLICATABLE_CLASSES.none? do |klass|
+        @duplicatable_default ||= HexaPDF::Object::NOT_DUPLICATABLE_CLASSES.none? do |klass|
           @default.kind_of?(klass)
         end
       end
@@ -161,39 +158,13 @@ module HexaPDF
           (obj.kind_of?(HexaPDF::Object) && type.any? {|t| obj.value.kind_of?(t) })
       end
 
-      # If a converter was defined, it is used. Otherwise +false+ is returned.
-      #
-      # See: #convert
-      def convert?(data)
-        @converter.convert?(data, type)
-      end
-
-      # If a converter was defined, it is used for converting the data. Otherwise this is a Noop -
-      # it just returns the data.
-      #
-      # See: #convert?
+      # Converts the data into a useful object if possible. Otherwise returns +nil+.
       def convert(data, document)
-        @converter.convert(data, type, document)
-      end
-
-    end
-
-    # Does nothing.
-    module IdentityConverter
-
-      def self.usable_for?(_type) #:nodoc:
-        true
-      end
-
-      def self.additional_types #:nodoc:
-      end
-
-      def self.convert?(_data, _type) #:nodoc:
-        false
-      end
-
-      def self.convert(data, _type, _document) #:nodoc:
-        data
+        @converters.each do |converter|
+          result = converter.convert(data, type, document)
+          return result unless result.nil?
+        end
+        nil
       end
 
     end
@@ -214,15 +185,11 @@ module HexaPDF
         Hash
       end
 
-      # Returns +true+ if the given data value can be converted to the Dictionary subclass
-      # specified by type (see Field#type).
-      def self.convert?(data, type)
-        !data.kind_of?(type.first) && (data.kind_of?(Hash) ||
-          data.kind_of?(HexaPDF::Dictionary))
-      end
-
-      # Wraps the given data value in the PDF specific type class.
+      # Wraps the given data value in the PDF specific type class if it can be converted. Otherwise
+      # returns +nil+.
       def self.convert(data, type, document)
+        return if data.kind_of?(type.first) || !(data.kind_of?(Hash) ||
+          data.kind_of?(HexaPDF::Dictionary))
         document.wrap(data, type: type.first)
       end
 
@@ -240,13 +207,11 @@ module HexaPDF
       def self.additional_types
       end
 
-      # Returns +true+ if the given data should be converted to a UTF-8 encoded string.
-      def self.convert?(data, _type)
-        data.kind_of?(String) && data.encoding == Encoding::BINARY
-      end
-
-      # Converts the string into UTF-8 encoding, assuming it is currently a binary string.
+      # Converts the string into UTF-8 encoding, assuming it is a binary string. Otherwise +nil+ is
+      # returned.
       def self.convert(str, _type, _document)
+        return unless str.kind_of?(String) && str.encoding == Encoding::BINARY
+
         if str.getbyte(0) == 254 && str.getbyte(1) == 255
           str[2..-1].force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
         else
@@ -270,13 +235,10 @@ module HexaPDF
         String
       end
 
-      # Returns +true+ if the given data should be converted to a UTF-8 encoded string.
-      def self.convert?(data, _type)
-        data.kind_of?(String) && data.encoding != Encoding::BINARY
-      end
-
-      # Converts the string into UTF-8 encoding, assuming it is currently a binary string.
+      # Converts the string into binary encoding, assuming it is a non-binary string. Otherwise
+      # returns +nil+.
       def self.convert(str, _type, _document)
+        return if !str.kind_of?(String) || str.encoding == Encoding::BINARY
         str.force_encoding(Encoding::BINARY)
       end
 
@@ -304,14 +266,11 @@ module HexaPDF
       # :nodoc:
       DATE_RE = /\AD:(\d{4})(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([Z+-])?(?:(\d\d)(?:'|'(\d\d)'?|\z)?)?\z/n
 
-      # Returns +true+ if the given data should be converted to a Time object.
-      def self.convert?(data, _type)
-        data.kind_of?(String) && data.match?(DATE_RE)
-      end
-
-      # Converts the string into a Time object.
+      # Checks if the given object is a string and converts into a Time object if possible.
+      # Otherwise returns +nil+.
       def self.convert(str, _type, _document)
-        m = DATE_RE.match(str)
+        return unless str.kind_of?(String) && (m = str.match(DATE_RE))
+
         utc_offset = (m[7].nil? || m[7] == 'Z' ? 0 : "#{m[7]}#{m[8]}:#{m[9] || '00'}")
         Time.new(m[1].to_i, (m[2] ? m[2].to_i : 1), (m[3] ? m[3].to_i : 1),
                  m[4].to_i, m[5].to_i, m[6].to_i, utc_offset)
@@ -333,14 +292,12 @@ module HexaPDF
         [Hash, String]
       end
 
-      # Returns +true+ if the given data is a string file specification.
-      def self.convert?(data, type)
-        !data.kind_of?(type.first) &&
-          (data.kind_of?(Hash) || data.kind_of?(HexaPDF::Dictionary) || data.kind_of?(String))
-      end
-
-      # Converts a string file specification or a hash into a full file specification.
+      # Converts a string file specification or a hash into a full file specification. Otherwise
+      # returns +nil+.
       def self.convert(data, type, document)
+        return if data.kind_of?(type.first) ||
+          !(data.kind_of?(Hash) || data.kind_of?(HexaPDF::Dictionary) || data.kind_of?(String))
+
         data = {F: data} if data.kind_of?(String)
         document.wrap(data, type: type.first)
       end
@@ -360,21 +317,16 @@ module HexaPDF
         Array
       end
 
-      # Returns +true+ if the given data value is an Array.
-      def self.convert?(data, _type)
-        data.kind_of?(Array)
-      end
-
-      # Wraps the given data value in the Rectangle class.
+      # Wraps a given array in the Rectangle class. Otherwise returns +nil+.
       def self.convert(data, _type, document)
+        return unless data.kind_of?(Array)
         document.wrap(data, type: Rectangle)
       end
 
     end
 
     Field.converters.replace([FileSpecificationConverter, DictionaryConverter, StringConverter,
-                              PDFByteStringConverter, DateConverter, RectangleConverter,
-                              IdentityConverter])
+                              PDFByteStringConverter, DateConverter, RectangleConverter])
 
   end
 

data/lib/hexapdf/document.rb

@@ -554,8 +554,8 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   doc.validate(auto_correct: true)                               -> true or false
-    #   doc.validate(auto_correct: true) {|msg, correctable| block }   -> true or false
+    #   doc.validate(auto_correct: true)                                       -> true or false
+    #   doc.validate(auto_correct: true) {|object, msg, correctable| block }   -> true or false
     #
     # Validates all objects of the document, with optional auto-correction, and returns +true+ if
     # everything is fine.
@@ -563,9 +563,13 @@ module HexaPDF
     # If a block is given, it is called on validation problems.
     #
     # See HexaPDF::Object#validate for more information.
-    def validate(auto_correct: true, &block)
+    def validate(auto_correct: true)
+      cur_obj = trailer
+      block = (block_given? ? lambda {|msg, correctable| yield(cur_obj, msg, correctable) } : nil)
+
       result = trailer.validate(auto_correct: auto_correct, &block)
       each(current: false) do |obj|
+        cur_obj = obj
         result &&= obj.validate(auto_correct: auto_correct, &block)
       end
       result
@@ -601,9 +605,9 @@ module HexaPDF
       end
 
       if validate
-        self.validate(auto_correct: true) do |msg, correctable|
+        self.validate(auto_correct: true) do |obj, msg, correctable|
           next if correctable
-          raise HexaPDF::Error, "Validation error: #{msg}"
+          raise HexaPDF::Error, "Validation error for (#{obj.oid},#{obj.gen}): #{msg}"
         end
       end
 

data/lib/hexapdf/document/fonts.rb

@@ -50,7 +50,7 @@ module HexaPDF
       # :call-seq:
       #   fonts.add(name, **options)            -> font
       #
-      # Adds the font to the document and returns if (using the loaders specified with the
+      # Adds the font to the document and returns it (using the loaders specified with the
       # configuration option 'font_loaders').
       #
       # If a font with the same parameters has been loaded before, the cached font object is used.

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -524,7 +524,7 @@ module HexaPDF
         decrypted = aes_algorithm.new(encryption_key, "\0" * 16, :decrypt).process(dict[:Perms])
         if decrypted[9, 3] != "adb"
           raise HexaPDF::EncryptionError, "/Perms field cannot be decrypted"
-        elsif (dict[:P] & 0xFFFFFFFF) != (decrypted[0, 4].unpack('V').first & 0xFFFFFFFF)
+        elsif (dict[:P] & 0xFFFFFFFF) != (decrypted[0, 4].unpack1('V') & 0xFFFFFFFF)
           raise HexaPDF::EncryptionError, "Decrypted permissions don't match /P"
         elsif decrypted[8] != (dict[:EncryptMetadata] ? 'T' : 'F')
           raise HexaPDF::EncryptionError, "Decrypted /Perms field doesn't match /EncryptMetadata"

data/lib/hexapdf/filter/ascii85_decode.rb

@@ -144,7 +144,7 @@ module HexaPDF
 
           if rest
             rlen = rest.length
-            num = (rest + "\0" * (4 - rlen)).unpack('N').first
+            num = (rest + "\0" * (4 - rlen)).unpack1('N')
             ((VALUE_TO_CHAR[num / POW85_4 % 85] + VALUE_TO_CHAR[num / POW85_3 % 85] <<
               VALUE_TO_CHAR[num / POW85_2 % 85] << VALUE_TO_CHAR[num / POW85_1 % 85] <<
               VALUE_TO_CHAR[num % 85])[0, rlen + 1] << "~>").force_encoding(Encoding::BINARY)

data/lib/hexapdf/filter/ascii_hex_decode.rb

@@ -70,7 +70,7 @@ module HexaPDF
       def self.encoder(source, _ = nil)
         Fiber.new do
           while source.alive? && (data = source.resume)
-            Fiber.yield(data.unpack('H*').first.force_encoding(Encoding::BINARY))
+            Fiber.yield(data.unpack1('H*').force_encoding(Encoding::BINARY))
           end
           '>'.b
         end

data/lib/hexapdf/font/cmap/writer.rb

@@ -57,14 +57,14 @@ module HexaPDF
           result = create_sections("bfchar", chars.size / 2) do |index|
             index *= 2
             sprintf("<%04X>", chars[index]) << "<" <<
-              ((+'').force_encoding(::Encoding::UTF_16BE) << chars[index + 1]).unpack('H*').first <<
+              ((+'').force_encoding(::Encoding::UTF_16BE) << chars[index + 1]).unpack1('H*') <<
               ">\n"
           end
 
           result << create_sections("bfrange", ranges.size / 3) do |index|
             index *= 3
             sprintf("<%04X><%04X>", ranges[index], ranges[index + 1]) << "<" <<
-              ((+'').force_encoding(::Encoding::UTF_16BE) << ranges[index + 2]).unpack('H*').first <<
+              ((+'').force_encoding(::Encoding::UTF_16BE) << ranges[index + 2]).unpack1('H*') <<
               ">\n"
           end
 

data/lib/hexapdf/font/true_type/builder.rb

@@ -63,7 +63,7 @@ module HexaPDF
             table_checksum = Table.calculate_checksum(data)
             data << "\0" * (4 - original_data_length % 4) if original_data_length % 4 != 0
             # tag, offset, data.length are all 32bit uint, table_checksum for header and body
-            checksum += tag.unpack('N').first + 2 * table_checksum + offset + data.length
+            checksum += tag.unpack1('N') + 2 * table_checksum + offset + data.length
             font_data << [tag, table_checksum, offset, original_data_length].pack('a4N3')
             offset += data.length
           end

data/lib/hexapdf/font/true_type/table.rb

@@ -137,7 +137,7 @@ module HexaPDF
 
         # Reads a 16.16-bit signed fixed-point integer and returns a Rational as result.
         def read_fixed
-          Rational(io.read(4).unpack('i>').first, 65536)
+          Rational(io.read(4).unpack1('i>'), 65536)
         end
 
       end

data/lib/hexapdf/font/true_type/table/cmap.rb

@@ -56,7 +56,7 @@ module HexaPDF
           #
           # A preferred table is always a table mapping Unicode characters.
           def preferred_table
-            tables.select(&:unicode?).sort_by(&:format).last
+            tables.select(&:unicode?).max_by(&:format)
           end
 
           private

data/lib/hexapdf/font/true_type/table/cmap_subtable.rb

@@ -117,7 +117,7 @@ module HexaPDF
           # +true+ is returned. Otherwise nothing is done and +false+ is returned.
           def parse(io, offset)
             io.pos = offset
-            @format = io.read(2).unpack('n').first
+            @format = io.read(2).unpack1('n')
             if [8, 10, 12].include?(@format)
               io.pos += 2
               length, @language = io.read(8).unpack('N2')
@@ -245,7 +245,7 @@ module HexaPDF
             #
             # It is assumed that the first six bytes of the subtable have already been consumed.
             def self.parse(io, length)
-              seg_count_x2 = io.read(8).unpack('n').first
+              seg_count_x2 = io.read(8).unpack1('n')
               end_codes = io.read(seg_count_x2).unpack('n*')
               io.pos += 2
               start_codes = io.read(seg_count_x2).unpack('n*')
@@ -346,7 +346,7 @@ module HexaPDF
             #
             # It is assumed that the first twelve bytes of the subtable have already been consumed.
             def self.parse(io, _length)
-              mapper(Array.new(io.read(4).unpack('N').first) { io.read(12).unpack('N3') })
+              mapper(Array.new(io.read(4).unpack1('N')) { io.read(12).unpack('N3') })
             end
 
             # The parameter +groups+ is an array containing [start_code, end_code, start_glyph_id]

data/lib/hexapdf/font/true_type/table/kern.rb

@@ -152,7 +152,7 @@ module HexaPDF
             # Parses the format 0 subtable and returns a hash of the form
             #   {left_char: {right_char: kern_value}}
             def self.parse(io, _length)
-              number_of_pairs = io.read(8).unpack('n').first
+              number_of_pairs = io.read(8).unpack1('n')
               pairs = Hash.new {|h, k| h[k] = {} }
               io.read(number_of_pairs * 6).unpack('n*').each_slice(3) do |left, right, value|
                 pairs[left][right] = (value < 0x8000 ? value : -(value ^ 0xffff) - 1)

data/lib/hexapdf/font/true_type/table/post.rb

@@ -160,7 +160,7 @@ module HexaPDF
             # returns the contained glyph name map.
             def self.parse(io, length)
               end_pos = io.pos + length
-              num_glyphs = io.read(2).unpack('n').first
+              num_glyphs = io.read(2).unpack1('n')
               glyph_name_index = io.read(2 * num_glyphs).unpack('n*')
               names = []
               names << io.read(io.getbyte).force_encoding(::Encoding::UTF_8) while io.pos < end_pos

data/lib/hexapdf/font/type1/character_metrics.rb

@@ -48,7 +48,7 @@ module HexaPDF
         attr_accessor :name
 
         # Character bounding box as array of four numbers, specifying the x- and y-coordinates of
-        # the lower-left corner and the x- and y-coordinates of the upper-right corner.
+        # the bottom left corner and the x- and y-coordinates of the top right corner.
         attr_accessor :bbox
 
       end

data/lib/hexapdf/font/type1/font_metrics.rb

@@ -60,7 +60,7 @@ module HexaPDF
         attr_accessor :weight
 
         # The font bounding box as array of four numbers, specifying the x- and y-coordinates of the
-        # lower-left corner and the x- and y-coordinates of the upper-right corner.
+        # bottom left corner and the x- and y-coordinates of the top right corner.
         attr_accessor :bounding_box
 
         # The y-value of the top of the capital H (or 0 or nil if the font doesn't contain a capital

data/lib/hexapdf/image_loader/jpeg.rb

@@ -116,7 +116,7 @@ module HexaPDF
 
           # B1.1.4 - next two bytes are the length of the segment (except for RSTm or TEM markers
           # but those shouldn't appear here)
-          length = io.read(2).unpack('n').first
+          length = io.read(2).unpack1('n')
 
           if code1 == ADOBE_MARKER # Adobe apps invert the colors when using CMYK color space
             invert_colors = true

data/lib/hexapdf/image_loader/png.rb

@@ -167,12 +167,12 @@ module HexaPDF
                 io.seek(length, IO::SEEK_CUR)
               end
             when 'sRGB' # PNG s11.3.3.5
-              @intent = io.read(length).unpack('C').first
+              @intent = io.read(length).unpack1('C')
               dict[:Intent] = RENDERING_INTENT_MAP[@intent]
               @chrm = SRGB_CHRM
               @gamma = 2.2
             when 'gAMA' # PNG s11.3.3.2
-              gamma = 100_000.0 / io.read(length).unpack('N').first
+              gamma = 100_000.0 / io.read(length).unpack1('N')
               unless @intent || gamma == 1.0 # sRGB trumps gAMA
                 @gamma = gamma
                 @chrm ||= SRGB_CHRM # don't overwrite data from a cHRM chunk

data/lib/hexapdf/layout.rb

@@ -46,6 +46,9 @@ module HexaPDF
     autoload(:TextShaper, 'hexapdf/layout/text_shaper')
     autoload(:TextLayouter, 'hexapdf/layout/text_layouter')
     autoload(:Box, 'hexapdf/layout/box')
+    autoload(:Frame, 'hexapdf/layout/frame')
+    autoload(:WidthFromPolygon, 'hexapdf/layout/width_from_polygon')
+    autoload(:TextBox, 'hexapdf/layout/text_box')
 
   end