hexapdf 0.26.1 → 0.26.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '071877a8fbc781ac3d35f5432d6b7d83b80d5d7f981d3fd7110551e0e09bc18b'
-  data.tar.gz: a0ac1aa3be4d720561b9d58d197f547e9c3958fb0c252d8da27d9e9a356c0b7b
+  metadata.gz: 5f7ff4db8b6417cf6f0101a2e72e2481571a40c9542713be82753376d58c047c
+  data.tar.gz: 0b62a42fe5b91bdd8f11c4c31105e560cd4cf2f27259a86b9fd07db2f2280d6e
 SHA512:
-  metadata.gz: 7528b421de6360e09bf4caeb72caec3b71f317314c8e0389fca287ee00bfab0ee952d8cecced2df937ff2e8198655fe81ebd12a494fac94847ae28ca20169384
-  data.tar.gz: 52a0ab62632122772162fa1dbbb80e05b11956d187385c813f97f0a6c6c8b23c83f568cef2df81e93caf2ae558cda005ef0923de45f16d2c943cc9d86f92c868
+  metadata.gz: 0ef60dd2da6c1c233768e564c5afb9330fb07065a33f293a2fbca6c71b8948d2ab754b2c9383ed4a84400e944e98f6c5a3638bf0c970c2b819eb53a0e024a2ca
+  data.tar.gz: 9c0190529f0d25d9ec655bef27d25054b9bfb5dc2ec980742807e73e0eb953550033f5362249cad1ec83ff8e78a1f1ad91785614cecdbaed113ad6365a77ade5

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 0.26.2 - 2022-10-22
+
+### Added
+
+* Support for setting custom properties on [HexaPDF::Layout::Box] and
+  [HexaPDF::Layout::TextFragment]
+
+### Changed
+
+* [HexaPDF::Layout::Style::LinkLayer] to use the 'link' custom box property if
+  no target is set
+
+### Fixed
+
+* [HexaPDF::Layout::Style::Layers] to allow named layers without options
+* [HexaPDF::Revision#each_modified_object] to not yield signature objects
+* [HexaPDF::Revision#each_modified_object] to force comparison of direct objects
+* [HexaPDF::Type::ObjectStream] to work for encrypted documents again
+
+
 ## 0.26.1 - 2022-10-14
 
 ### Changed

data/lib/hexapdf/document/layout.rb

@@ -249,6 +249,10 @@ module HexaPDF
       #     +style_properties+ are specified, the style is duplicated and the additional styles are
       #     applied.
       #
+      # +properties+::
+      #     This can be used to set custom properties on the created text box. See Box#properties
+      #     for details and usage.
+      #
       # +box_style+::
       #     Sometimes it is necessary for the box to have a different style than the text, e.g. when
       #     using overlays. In such a case use +box_style+ for specifiying the style of the box (a
@@ -266,11 +270,13 @@ module HexaPDF
       #   })
       #
       # See: #formatted_text_box, HexaPDF::Layout::TextBox, HexaPDF::Layout::TextFragment
-      def text_box(text, width: 0, height: 0, style: nil, box_style: nil, **style_properties)
+      def text_box(text, width: 0, height: 0, style: nil, properties: nil, box_style: nil,
+                   **style_properties)
         style = retrieve_style(style, style_properties)
         box_style = (box_style ? retrieve_style(box_style) : style)
         box_class_for_name(:text).new(items: [HexaPDF::Layout::TextFragment.create(text, style)],
-                                      width: width, height: height, style: box_style)
+                                      width: width, height: height, properties: properties,
+                                      style: box_style)
       end
 
       # Creates a HexaPDF::Layout::TextBox like #text_box but allows parts of the text to be
@@ -294,7 +300,8 @@ module HexaPDF
       #   If any style properties are set, the used style is duplicated and the additional
       #   properties applied.
       #
-      # See #text_box for details on +width+, +height+, +style+, +style_properties+ and +box_style+.
+      # See #text_box for details on +width+, +height+, +style+, +style_properties+, +properties+
+      # and +box_style+.
       #
       # Examples:
       #
@@ -305,7 +312,8 @@ module HexaPDF
       #   layout.formatted_text_box(["Some ", {text: "string", style: {font_size: 20}}])
       #
       # See: #text_box, HexaPDF::Layout::TextBox, HexaPDF::Layout::TextFragment
-      def formatted_text_box(data, width: 0, height: 0, style: nil, box_style: nil, **style_properties)
+      def formatted_text_box(data, width: 0, height: 0, style: nil, properties: nil, box_style: nil,
+                             **style_properties)
         style = retrieve_style(style, style_properties)
         box_style = (box_style ? retrieve_style(box_style) : style)
         data.map! do |hash|
@@ -315,10 +323,15 @@ module HexaPDF
             link = hash.delete(:link)
             (hash[:overlays] ||= []) << [:link, {uri: link}] if link
             text = hash.delete(:text) || link || ""
-            HexaPDF::Layout::TextFragment.create(text, retrieve_style(hash.delete(:style) || style, hash))
+            properties = hash.delete(:properties)
+            frag_style = retrieve_style(hash.delete(:style) || style, hash)
+            fragment = HexaPDF::Layout::TextFragment.create(text, frag_style)
+            fragment.properties.update(properties) if properties
+            fragment
           end
         end
-        box_class_for_name(:text).new(items: data, width: width, height: height, style: box_style)
+        box_class_for_name(:text).new(items: data, width: width, height: height,
+                                      properties: properties, style: box_style)
       end
 
       # Creates a HexaPDF::Layout::ImageBox for the given image.
@@ -326,7 +339,8 @@ module HexaPDF
       # The +file+ argument can be anything that is accepted by HexaPDF::Document::Images#add or a
       # HexaPDF::Type::Form object.
       #
-      # See #text_box for details on +width+, +height+, +style+ and +style_properties+.
+      # See #text_box for details on +width+, +height+, +style+, +style_properties+ and
+      # +properties+.
       #
       # Examples:
       #
@@ -334,10 +348,11 @@ module HexaPDF
       #   layout.image_box(machu_picchu, height: 30)
       #
       # See: HexaPDF::Layout::ImageBox
-      def image_box(file, width: 0, height: 0, style: nil, **style_properties)
+      def image_box(file, width: 0, height: 0, properties: nil, style: nil, **style_properties)
         style = retrieve_style(style, style_properties)
         image = file.kind_of?(HexaPDF::Stream) ? file : @document.images.add(file)
-        box_class_for_name(:image).new(image: image, width: width, height: height, style: style)
+        box_class_for_name(:image).new(image: image, width: width, height: height,
+                                       properties: properties, style: style)
       end
 
       # :nodoc:

data/lib/hexapdf/layout/box.rb

@@ -116,8 +116,14 @@ module HexaPDF
       # * Style#underlays
       attr_reader :style
 
+      # Hash with custom properties. The keys should be strings and can be arbitrary.
+      #
+      # This can be used to store arbitrary information on boxes for later use. For example, a
+      # generic style layer could use one or more custom properties for its work.
+      attr_reader :properties
+
       # :call-seq:
-      #    Box.new(width: 0, height: 0, style: nil) {|canv, box| block} -> box
+      #    Box.new(width: 0, height: 0, style: nil, properties: {}) {|canv, box| block} -> box
       #
       # Creates a new Box object with the given width and height that uses the provided block when
       # it is asked to draw itself on a canvas (see #draw).
@@ -125,10 +131,11 @@ module HexaPDF
       # Since the final location of the box is not known beforehand, the drawing operations inside
       # the block should draw inside the rectangle (0, 0, content_width, content_height) - note that
       # the width and height of the box may not be known beforehand.
-      def initialize(width: 0, height: 0, style: nil, &block)
+      def initialize(width: 0, height: 0, style: nil, properties: {}, &block)
         @width = @initial_width = width
         @height = @initial_height = height
         @style = Style.create(style)
+        @properties = properties
         @draw_block = block
         @fit_successful = false
         @split_box = false

data/lib/hexapdf/layout/line.rb

@@ -192,13 +192,14 @@ module HexaPDF
 
       # Adds the given item at the end of the item list.
       #
-      # If both the item and the last item in the item list are TextFragment objects and they have
-      # the same style, they are combined.
+      # If both the item and the last item in the item list are TextFragment objects with the same
+      # attributes, they are combined.
       #
       # Note: The cache is not cleared!
       def add(item)
         last = @items.last
-        if last.instance_of?(item.class) && item.kind_of?(TextFragment) && last.style == item.style
+        if last.instance_of?(item.class) && item.kind_of?(TextFragment) &&
+            last.attributes_hash == item.attributes_hash
           if last.items.frozen?
             @items[-1] = last = last.dup
             last.items = last.items.dup

data/lib/hexapdf/layout/style.rb

@@ -382,8 +382,9 @@ module HexaPDF
       class Layers
 
         # Creates a new Layers object popuplated with the given +layers+.
-        def initialize(layers = [])
-          @layers = layers
+        def initialize(layers = nil)
+          @layers = []
+          layers&.each {|name, options| add(name, **(options || {})) }
         end
 
         # Duplicates the array holding the layers.
@@ -402,8 +403,8 @@ module HexaPDF
         # object in 'style.layers_map'. In this case +name+ is used as the reference and the options
         # are passed to layer object if it needs initialization.
         def add(name = nil, **options, &block)
-          if block_given?
-            @layers << block
+          if block_given? || name.kind_of?(Proc)
+            @layers << (block || name)
           elsif name
             @layers << [name, options]
           else
@@ -452,7 +453,9 @@ module HexaPDF
         # be specified):
         #
         # +dest+::
-        #   The destination array or a name of a named destination for in-document links.
+        #   The destination array or a name of a named destination for in-document links. If neither
+        #   +dest+ nor +uri+ nor +file+ is specified, it is assumed that the box has a custom
+        #   property named 'link' which is used for the destination.
         #
         # +uri+::
         #   The URI to link to.
@@ -473,6 +476,7 @@ module HexaPDF
         # Examples:
         #   LinkLayer.new(dest: [page, :XYZ, nil, nil, nil], border: true)
         #   LinkLayer.new(uri: "https://my.example.com/path", border: [5 5 2])
+        #   LinkLayer.new     # use 'link' custom box property for dest
         def initialize(dest: nil, uri: nil, file: nil, border: false, border_color: nil)
           if dest && (uri || file) || uri && file
             raise ArgumentError, "Only one of dest, uri and file is allowed"
@@ -496,6 +500,8 @@ module HexaPDF
         # page.
         def call(canvas, box)
           return unless canvas.context.type == :Page
+          @dest = box.properties['link'] unless @dest || @action
+
           page = canvas.context
           matrix = canvas.graphics_state.ctm
           quad_points = [*matrix.evaluate(0, 0), *matrix.evaluate(box.width, 0),
@@ -554,7 +560,7 @@ module HexaPDF
       # Duplicates the complex properties that can be modified, as well as the cache.
       def initialize_copy(other)
         super
-        @scaled_item_widths = {}
+        @scaled_item_widths = {}.compare_by_identity
         clear_cache
 
         @font_features = @font_features.dup if defined?(@font_features)

data/lib/hexapdf/layout/text_fragment.rb

@@ -105,9 +105,29 @@ module HexaPDF
       #
       # The argument +style+ can either be a Style object or a hash of style properties, see
       # Style::create for details.
-      def initialize(items, style)
+      def initialize(items, style, properties: nil)
         @items = items
         @style = Style.create(style)
+        @properties = properties
+      end
+
+      # Creates a new TextFragment with the same style and custom properties as this one but with
+      # the given +items+.
+      def dup_attributes(items)
+        self.class.new(items, @style, properties: @properties.dup)
+      end
+
+      # Returns the custom properties hash for the text fragment.
+      #
+      # See Box#properties for usage details.
+      def properties
+        @properties ||= {}
+      end
+
+      # Returns the value that should be used as hash key when only the fragment's attributes -
+      # without the items - should play a role.
+      def attributes_hash
+        @style.hash ^ @properties.hash
       end
 
       # The precision used to determine whether two floats represent the same value.

data/lib/hexapdf/layout/text_layouter.rb

@@ -243,43 +243,38 @@ module HexaPDF
                 box_items << glyph if glyph && !glyph.kind_of?(Numeric) && glyph.str == '-'
 
                 unless box_items.empty?
-                  result << Box.new(TextFragment.new(box_items.freeze, item.style))
+                  result << Box.new(item.dup_attributes(box_items.freeze))
                 end
 
                 if glyph
                   case glyph.str
                   when ' '
-                    glues[item.style] ||=
-                      Glue.new(TextFragment.new([glyph].freeze, item.style))
-                    result << glues[item.style]
+                    result << (glues[item.attributes_hash] ||=
+                               Glue.new(item.dup_attributes([glyph].freeze)))
                   when "\n", "\v", "\f", "\u{85}", "\u{2029}"
-                    penalties[item.style] ||=
-                      Penalty.new(Penalty::PARAGRAPH_BREAK, 0,
-                                  item: TextFragment.new([].freeze, item.style))
-                    result << penalties[item.style]
+                    result << (penalties[item.attributes_hash] ||=
+                               Penalty.new(Penalty::PARAGRAPH_BREAK, 0,
+                                           item: item.dup_attributes([].freeze)))
                   when "\u{2028}"
                     result << Penalty.new(Penalty::LINE_BREAK, 0,
-                                          item: TextFragment.new([].freeze, item.style))
+                                          item: item.dup_attributes([].freeze))
                   when "\r"
                     if !item.items[i + 1] || item.items[i + 1].kind_of?(Numeric) ||
                         item.items[i + 1].str != "\n"
-                      penalties[item.style] ||=
-                        Penalty.new(Penalty::PARAGRAPH_BREAK, 0,
-                                    item: TextFragment.new([].freeze, item.style))
-                      result << penalties[item.style]
+                      result << (penalties[item.attributes_hash] ||=
+                                 Penalty.new(Penalty::PARAGRAPH_BREAK, 0,
+                                             item: item.dup_attributes([].freeze)))
                     end
                   when '-'
                     result << Penalty::Standard
                   when "\t"
                     spaces = [item.style.font.decode_utf8(" ").first] * 8
-                    result << Glue.new(TextFragment.new(spaces.freeze, item.style))
+                    result << Glue.new(item.dup_attributes(spaces.freeze))
                   when "\u{00AD}"
-                    hyphen = item.style.font.decode_utf8("-").first
-                    frag = TextFragment.new([hyphen].freeze, item.style)
+                    frag = item.dup_attributes([item.style.font.decode_utf8("-").first].freeze)
                     result << Penalty.new(Penalty::Standard.penalty, frag.width, item: frag)
                   when "\u{00A0}"
-                    space = item.style.font.decode_utf8(" ").first
-                    frag = TextFragment.new([space].freeze, item.style)
+                    frag = item.dup_attributes([item.style.font.decode_utf8(" ").first].freeze)
                     result << Penalty.new(Penalty::ProhibitedBreak.penalty, frag.width, item: frag)
                   when "\u{200B}"
                     result << Penalty.new(0)
@@ -835,7 +830,7 @@ module HexaPDF
           if too_wide_box && (too_wide_box.item.kind_of?(TextFragment) &&
                               too_wide_box.item.items.size > 1)
             rest[0..rest.index(too_wide_box)] = too_wide_box.item.items.map do |item|
-              Box.new(TextFragment.new([item].freeze, too_wide_box.item.style))
+              Box.new(too_wide_box.item.dup_attributes([item].freeze))
             end
             too_wide_box = nil
           else
@@ -939,8 +934,7 @@ module HexaPDF
             frag = line.items[indexes[i]]
             value = -frag.items[indexes[i + 1]].width * adjustment
             if frag.items.frozen?
-              value = HexaPDF::Layout::TextFragment.new([value], frag.style)
-              line.items.insert(indexes[i], value)
+              line.items.insert(indexes[i], frag.dup_attributes([value]))
             else
               frag.items.insert(indexes[i + 1], value)
               frag.clear_cache

data/lib/hexapdf/revision.rb

@@ -243,14 +243,21 @@ module HexaPDF
       @objects.each do |oid, gen, obj|
         if @xref_section.entry?(oid, gen)
           stored_obj = @loader.call(@xref_section[oid, gen])
-          next if (stored_obj.type == :ObjStm || stored_obj.type == :XRef) && obj.null?
+          next if (stored_obj.type == :ObjStm || stored_obj.type == :XRef) && obj.null? ||
+            stored_obj.type == :Sig || stored_obj.type == :DocTimeStamp
 
           streams_are_same = (obj.data.stream == stored_obj.data.stream)
           next if obj.value == stored_obj.value && streams_are_same
 
           if obj.value.kind_of?(Hash) && stored_obj.value.kind_of?(Hash)
             keys = obj.value.keys | stored_obj.value.keys
-            next if keys.all? {|key| obj[key] == stored_obj[key] } && streams_are_same
+            values_unchanged = keys.all? do |key|
+              other = stored_obj[key]
+              # Force comparison of values if both are indirect objects
+              other = other.value if other.kind_of?(Object) && !other.indirect?
+              obj[key] == other
+            end
+            next if values_unchanged && streams_are_same
           end
         end
 

data/lib/hexapdf/type/object_stream.rb

@@ -203,13 +203,6 @@ module HexaPDF
 
       private
 
-      # Parses the stream data after the object is first initialized. Since the parsed stream data
-      # is cached, it is only parsed on initialization and not again if e.g. the stream is changed.
-      def after_data_change
-        super
-        parse_stream
-      end
-
       # Parses the object numbers and their offsets from the start of the stream data.
       def parse_oids_and_offsets(data)
         oids = []
@@ -227,7 +220,12 @@ module HexaPDF
 
       # Returns the container with the to-be-stored objects.
       def objects
-        @objects ||= {}
+        @objects ||= 
+          begin
+            @objects = {}
+            parse_stream
+            @objects
+          end
       end
 
       # Validates that the generation number of the object stream is zero.

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.26.1'
+  VERSION = '0.26.2'
 
 end

data/test/hexapdf/document/test_layout.rb

@@ -90,12 +90,14 @@ describe HexaPDF::Document::Layout do
 
   describe "box" do
     it "creates the request box" do
-      box = @layout.box(:column, columns: 3, gaps: 20, width: 15, height: 30, style: {font_size: 10})
+      box = @layout.box(:column, columns: 3, gaps: 20, width: 15, height: 30, style: {font_size: 10},
+                        properties: {key: :value})
       assert_equal(15, box.width)
       assert_equal(30, box.height)
       assert_equal([-1, -1, -1], box.columns)
       assert_equal([20], box.gaps)
       assert_equal(10, box.style.font_size)
+      assert_equal({key: :value}, box.properties)
     end
 
     it "allows specifying the box's children via a provided block" do
@@ -113,13 +115,14 @@ describe HexaPDF::Document::Layout do
 
   describe "text_box" do
     it "creates a text box" do
-      box = @layout.text_box("Test", width: 10, height: 15)
+      box = @layout.text_box("Test", width: 10, height: 15, properties: {key: :value})
       assert_equal(10, box.width)
       assert_equal(15, box.height)
       assert_same(@doc.fonts.add("Times"), box.style.font)
       items = box.instance_variable_get(:@items)
       assert_equal(1, items.length)
       assert_same(box.style, items.first.style)
+      assert_equal({key: :value}, box.properties)
     end
 
     it "allows setting of a custom style" do
@@ -162,6 +165,11 @@ describe HexaPDF::Document::Layout do
       assert_equal(1, box.instance_variable_get(:@items).length)
     end
 
+    it "allows setting custom properties on the whole box" do
+      box = @layout.formatted_text_box(["Test"], properties: {key: :value})
+      assert_equal({key: :value}, box.properties)
+    end
+
     it "allows using a hash with :text key instead of a simple string" do
       box = @layout.formatted_text_box([{text: "Test"}])
       items = box.instance_variable_get(:@items)
@@ -218,18 +226,26 @@ describe HexaPDF::Document::Layout do
       assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
       refute(items[2].style.overlays?)
     end
+
+    it "allows setting custom properties" do
+      box = @layout.formatted_text_box([{text: 'test', properties: {named_dest: 'test'}}])
+      items = box.instance_variable_get(:@items)
+      assert_equal({named_dest: 'test'}, items[0].properties)
+    end
   end
 
   describe "image_box" do
     it "creates an image box" do
       image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
 
-      box = @layout.image_box(image_path, width: 10, height: 15, style: {font_size: 20}, subscript: true)
+      box = @layout.image_box(image_path, width: 10, height: 15, style: {font_size: 20},
+                              properties: {key: :value}, subscript: true)
       assert_equal(10, box.width)
       assert_equal(15, box.height)
       assert_equal(20, box.style.font_size)
       assert(box.style.subscript)
       assert_same(@doc.images.add(image_path), box.image)
+      assert_equal({key: :value}, box.properties)
     end
 
     it "allows using a form XObject" do

data/test/hexapdf/layout/test_box.rb

@@ -54,6 +54,11 @@ describe HexaPDF::Layout::Box do
       box = create_box(style: HexaPDF::Layout::Style.new(padding: 20))
       assert_equal(20, box.style.padding.top)
     end
+
+    it "allows setting custom properties" do
+      box = create_box(properties: {'key' => :value})
+      assert_equal({'key' => :value}, box.properties)
+    end
   end
 
   it "returns false when asking whether it is a split box by default" do

data/test/hexapdf/layout/test_line.rb

@@ -50,10 +50,12 @@ describe HexaPDF::Layout::Line do
 
     it "combines text fragments if possible" do
       frag1 = setup_fragment("Home")
-      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items.slice!(2, 2), frag1.style)
-      @line << setup_fragment("o") << :other << frag1 << frag2
-      assert_equal(3, @line.items.length)
-      assert_equal(4, @line.items.last.items.length)
+      frag2 = HexaPDF::Layout::TextFragment.new(frag1.items[2, 2], frag1.style)
+      frag3 = HexaPDF::Layout::TextFragment.new(frag1.items[2, 2], frag1.style,
+                                                properties: {'key' => :value})
+      @line << setup_fragment("o") << :other << frag1 << frag2 << frag3
+      assert_equal(4, @line.items.length)
+      assert_equal(6, @line.items[-2].items.length)
     end
 
     it "duplicates the first of two combinable text fragments if its items are frozen" do

data/test/hexapdf/layout/test_style.rb

@@ -448,12 +448,16 @@ end
 describe HexaPDF::Layout::Style::Layers do
   before do
     @layers = HexaPDF::Layout::Style::Layers.new
+    value = Object.new
+    value.define_singleton_method(:new) {|*| :new }
+    @config = Object.new
+    @config.define_singleton_method(:constantize) {|*| value }
   end
 
   it "can be initialized with an array of layers" do
-    data = [lambda {}]
+    data = [lambda {}, [:test]]
     layers = HexaPDF::Layout::Style::Layers.new(data)
-    assert_equal(data, layers.enum_for(:each, {}).to_a)
+    assert_equal([data[0], :new], layers.enum_for(:each, @config).to_a)
   end
 
   it "can be duplicated" do
@@ -469,13 +473,15 @@ describe HexaPDF::Layout::Style::Layers do
       assert_equal([block], @layers.enum_for(:each, {}).to_a)
     end
 
+    it "can use a given proc" do
+      block = proc { true }
+      @layers.add(block)
+      assert_equal([block], @layers.enum_for(:each, {}).to_a)
+    end
+
     it "can store a reference" do
       @layers.add(:link, option: :value)
-      value = Object.new
-      value.define_singleton_method(:new) {|*| :new }
-      config = Object.new
-      config.define_singleton_method(:constantize) {|*| value }
-      assert_equal([:new], @layers.enum_for(:each, config).to_a)
+      assert_equal([:new], @layers.enum_for(:each, @config).to_a)
     end
 
     it "fails if neither a block nor a name is given when adding a layer" do
@@ -590,6 +596,13 @@ describe HexaPDF::Layout::Style::LinkLayer do
       assert_equal({S: :Launch, F: "local-file.pdf", NewWindow: true}, annot[:A].value)
       assert_nil(annot[:Dest])
     end
+
+    it "works for destinations set via the 'link' custom box property" do
+      @box.properties['link'] = [@canvas.context, :FitH]
+      annot = call_link({})
+      assert_equal([@canvas.context, :FitH], annot[:Dest].value)
+      assert_nil(annot[:A])
+    end
   end
 end
 

data/test/hexapdf/layout/test_text_fragment.rb

@@ -46,11 +46,36 @@ describe HexaPDF::Layout::TextFragment do
     end
 
     it "can use style options" do
-      frag = HexaPDF::Layout::TextFragment.new(@items, font: @font, font_size: 20)
+      frag = HexaPDF::Layout::TextFragment.new(@items, {font: @font, font_size: 20})
       assert_equal(20, frag.style.font_size)
     end
   end
 
+  it "allows duplicating with only its attributes while also setting new items" do
+    setup_fragment([20])
+    @fragment.properties['key'] = :value
+    frag = @fragment.dup_attributes([21])
+    assert_equal([21], frag.items)
+    assert_same(frag.style, @fragment.style)
+    assert_equal(:value, frag.properties['key'])
+  end
+
+  it "creates an attributes hash for storing the fragment based on the attributes without the items" do
+    setup_fragment([20])
+    hash = @fragment.attributes_hash
+    @fragment.properties['key'] = :value
+    new_hash = @fragment.attributes_hash
+    refute_equal(hash, new_hash)
+    @fragment.items << [21]
+    assert_equal(new_hash, @fragment.attributes_hash)
+  end
+
+  it "allows setting custom properties" do
+    setup_fragment([])
+    @fragment.properties[:key] = :value
+    assert_equal({key: :value}, @fragment.properties)
+  end
+
   it "returns :text for valign" do
     assert_equal(:text, setup_fragment([]).valign)
   end

data/test/hexapdf/layout/test_text_layouter.rb

@@ -31,12 +31,14 @@ module TestTextLayouterHelpers
     else
       assert_same(item.style, obj.item.style)
       assert_equal(item.items, obj.item.items)
+      assert_equal(item.properties, obj.item.properties)
     end
   end
 
   def assert_glue(obj, fragment)
     assert_kind_of(HexaPDF::Layout::TextLayouter::Glue, obj)
     assert_same(fragment.style, obj.item.style)
+    assert_equal(fragment.properties, obj.item.properties)
   end
 
   def assert_penalty(obj, penalty, item = nil)
@@ -45,6 +47,7 @@ module TestTextLayouterHelpers
     if item
       assert_same(item.style, obj.item.style)
       assert_equal(item.items, obj.item.items)
+      assert_equal(item.properties, obj.item.properties)
     end
   end
 
@@ -83,12 +86,10 @@ describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
     @obj = HexaPDF::Layout::TextLayouter::SimpleTextSegmentation
   end
 
-  def setup_fragment(text, style = nil)
-    if style
-      HexaPDF::Layout::TextFragment.create(text, style)
-    else
-      HexaPDF::Layout::TextFragment.create(text, font: @font)
-    end
+  def setup_fragment(text, style = {font: @font})
+    fragment = HexaPDF::Layout::TextFragment.create(text, style)
+    fragment.properties['key'] = :value
+    fragment
   end
 
   it "handles InlineBox objects" do
@@ -138,11 +139,13 @@ describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
       assert_equal([], result[index].item.items)
       assert(result[index].item.items.frozen?)
       assert_same(frag.style, result[index].item.style)
+      assert_equal(frag.properties, result[index].item.properties)
     end
     assert_penalty(result[15], HexaPDF::Layout::TextLayouter::Penalty::LINE_BREAK)
     assert_equal([], result[15].item.items)
     assert(result[15].item.items.frozen?)
     assert_same(frag.style, result[15].item.style)
+    assert_equal(frag.properties, result[15].item.properties)
   end
 
   it "insert a standard penalty after a hyphen" do

data/test/hexapdf/test_composer.rb

@@ -86,24 +86,15 @@ describe HexaPDF::Composer do
   end
 
   describe "style" do
-    it "creates a new style if it does not exist based on the base argument" do
-      @composer.style(:base, font_size: 20)
-      assert_equal(20, @composer.style(:newstyle, subscript: true).font_size)
-      refute(@composer.style(:base).subscript)
-      assert_equal(10, @composer.style(:another_new, base: nil).font_size)
-      assert(@composer.style(:yet_another_new, base: :newstyle).subscript)
-    end
-
-    it "returns the named style" do
-      assert_kind_of(HexaPDF::Layout::Style, @composer.style(:base))
-    end
-
-    it "updates the style with the given properties" do
-      assert_equal(20, @composer.style(:base, font_size: 20).font_size)
+    it "delegates to layout.style" do
+      @composer.document.layout.style(:base, font_size: 20)
+      assert_equal(20, @composer.style(:base).font_size)
+      @composer.style(:base, font_size: 30)
+      assert_equal(30, @composer.document.layout.style(:base).font_size)
     end
   end
 
-  describe "text" do
+  describe "text/formatted_text/image/box" do
     before do
       test_self = self
       @composer.define_singleton_method(:draw_box) do |arg|
@@ -111,151 +102,36 @@ describe HexaPDF::Composer do
       end
     end
 
-    it "creates a text box and draws it on the canvas" do
-      @composer.text("Test", width: 10, height: 15)
+    it "delegates #text to layout.text" do
+      @composer.text("Test", width: 10, height: 15, style: {font_size: 20},
+                     box_style: {font_size: 30}, line_spacing: 2)
       assert_equal(10, @box.width)
       assert_equal(15, @box.height)
-      assert_same(@composer.document.fonts.add("Times"), @box.style.font)
+      assert_equal(30, @box.style.font_size)
       items = @box.instance_variable_get(:@items)
       assert_equal(1, items.length)
-      assert_same(@box.style, items.first.style)
+      assert_same(20, items.first.style.font_size)
     end
 
-    it "allows setting of a custom style" do
-      style = HexaPDF::Layout::Style.new(font_size: 20, font: ['Times', {variant: :bold}])
-      @composer.text("Test", style: style)
-      assert_same(@box.style, style)
-      assert_same(@composer.document.fonts.add("Times", variant: :bold), @box.style.font)
-      assert_equal(20, @box.style.font_size)
-
-      @composer.text("Test", style: {font_size: 20})
-      assert_equal(20, @box.style.font_size)
-
-      @composer.style(:named, font_size: 20)
-      @composer.text("Test", style: :named)
-      assert_equal(20, @box.style.font_size)
-    end
-
-    it "updates the used style with the provided options" do
-      @composer.text("Test", style: {subscript: true}, font_size: 20)
-      assert_equal(20, @box.style.font_size)
-    end
-
-    it "allows using a box style different from the text style" do
-      style = HexaPDF::Layout::Style.new(font_size: 20)
-      @composer.text("Test", box_style: style)
-      refute_same(@box.instance_variable_get(:@items).first.style, style)
-      assert_same(@box.style, style)
-
-      @composer.style(:named, font_size: 20)
-      @composer.text("Test", box_style: :named)
-      assert_equal(20, @box.style.font_size)
-    end
-  end
-
-  describe "formatted_text" do
-    before do
-      test_self = self
-      @composer.define_singleton_method(:draw_box) do |arg|
-        test_self.instance_variable_set(:@box, arg)
-      end
-    end
-
-    it "creates a text box with the given text and draws it on the canvas" do
+    it "delegates #formatted_text to layout.formatted_text" do
       @composer.formatted_text(["Test"], width: 10, height: 15)
       assert_equal(10, @box.width)
       assert_equal(15, @box.height)
       assert_equal(1, @box.instance_variable_get(:@items).length)
     end
 
-    it "allows using a hash with :text key instead of a simple string" do
-      @composer.formatted_text([{text: "Test"}])
-      items = @box.instance_variable_get(:@items)
-      assert_equal(4, items[0].items.length)
-    end
-
-    it "uses an empty string if the :text key for a hash is not specified" do
-      @composer.formatted_text([{font_size: "Test"}])
-      items = @box.instance_variable_get(:@items)
-      assert_equal(0, items[0].items.length)
-    end
-
-    it "allows setting a custom base style for all parts" do
-      @composer.formatted_text(["Test", "other"], font_size: 20)
-      items = @box.instance_variable_get(:@items)
-      assert_equal(20, @box.style.font_size)
-      assert_equal(20, items[0].style.font_size)
-      assert_equal(20, items[1].style.font_size)
-    end
-
-    it "allows using custom style properties for a single part" do
-      @composer.formatted_text([{text: "Test", font_size: 20}, "test"], align: :center)
-      items = @box.instance_variable_get(:@items)
-      assert_equal(10, @box.style.font_size)
-
-      assert_equal(20, items[0].style.font_size)
-      assert_equal(:center, items[0].style.align)
-
-      assert_equal(10, items[1].style.font_size)
-      assert_equal(:center, items[1].style.align)
-    end
-
-    it "allows using a custom style as basis for a single part" do
-      @composer.formatted_text([{text: "Test", style: {font_size: 20}, subscript: true}, "test"],
-                               align: :center)
-      items = @box.instance_variable_get(:@items)
-      assert_equal(10, @box.style.font_size)
-
-      assert_equal(20, items[0].style.font_size)
-      assert_equal(:left, items[0].style.align)
-      assert(items[0].style.subscript)
-
-      assert_equal(10, items[1].style.font_size)
-      assert_equal(:center, items[1].style.align)
-      refute(items[1].style.subscript)
-    end
-
-    it "allows specifying a link to an URL via the :link key" do
-      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}, "test"])
-      items = @box.instance_variable_get(:@items)
-      assert_equal(3, items.length)
-      assert_equal(4, items[0].items.length, "text should be Test")
-      assert_equal(3, items[1].items.length, "text should be URI")
-      assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
-      refute(items[2].style.overlays?)
-    end
-  end
-
-  describe "image" do
-    it "creates an image box and draws it on the canvas" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
-      image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
-
-      @composer.image(image_path, width: 10, height: 15, style: {font_size: 20}, subscript: true)
-      assert_equal(10, box.width)
-      assert_equal(15, box.height)
-      assert_equal(20, box.style.font_size)
-      assert(box.style.subscript)
-      assert_same(@composer.document.images.add(image_path), box.image)
-    end
-
-    it "allows using a form XObject" do
+    it "delegates #image to layout.image" do
       form = @composer.document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 10, 10]})
       @composer.image(form, width: 10)
-      assert_equal(796, @composer.y)
-      assert_equal(36, @composer.x)
+      assert_equal(10, @box.width)
+      assert_equal(0, @box.height)
     end
-  end
 
-  describe "box" do
-    it "creates the named box and draws it on the canvas" do
-      box = nil
-      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+    it "delegates #box to layout.box" do
       image = @composer.document.images.add(File.join(TEST_DATA_DIR, 'images', 'gray.jpg'))
       @composer.box(:list, width: 20) {|list| list.image(image) }
-      assert_equal(20, box.width)
-      assert_same(image, box.children[0].image)
+      assert_equal(20, @box.width)
+      assert_same(image, @box.children[0].image)
     end
   end
 

data/test/hexapdf/test_revision.rb

@@ -25,10 +25,13 @@ describe HexaPDF::Revision do
         HexaPDF::Object.new(nil, oid: entry.oid, gen: entry.gen)
       else
         case entry.oid
+        when 2 then HexaPDF::Dictionary.new({Type: :Sig}, oid: entry.oid, gen: entry.gen)
         when 4 then HexaPDF::Dictionary.new({Type: :XRef}, oid: entry.oid, gen: entry.gen)
         when 5 then HexaPDF::Dictionary.new({Type: :ObjStm}, oid: entry.oid, gen: entry.gen)
         when 7 then HexaPDF::Type::Catalog.new({Type: :Catalog}, oid: entry.oid, gen: entry.gen,
                                               document: self)
+        when 6 then HexaPDF::Dictionary.new({Array: HexaPDF::PDFArray.new([1, 2])},
+                                            oid: entry.oid, gen: entry.gen)
         else HexaPDF::Object.new(:Test, oid: entry.oid, gen: entry.gen)
         end
       end
@@ -43,7 +46,7 @@ describe HexaPDF::Revision do
 
   it "takes an xref section and/or a parser on initialization" do
     rev = HexaPDF::Revision.new({}, loader: @loader, xref_section: @xref_section)
-    assert_equal(:Test, rev.object(2).value)
+    assert_equal({Type: :Sig}, rev.object(2).value)
   end
 
   it "returns the next free object number" do
@@ -100,7 +103,7 @@ describe HexaPDF::Revision do
 
     it "loads an object that is defined in the cross-reference section" do
       obj = @rev.object(HexaPDF::Reference.new(2, 0))
-      assert_equal(:Test, obj.value)
+      assert_equal({Type: :Sig}, obj.value)
       assert_equal(2, obj.oid)
       assert_equal(0, obj.gen)
     end
@@ -190,7 +193,7 @@ describe HexaPDF::Revision do
 
   describe "each_modified_object" do
     it "returns modified objects" do
-      obj = @rev.object(2)
+      obj = @rev.object(3)
       obj.value = :Other
       @rev.add(@obj)
       deleted = @rev.object(6)
@@ -214,6 +217,18 @@ describe HexaPDF::Revision do
       obj.delete(:Type)
       assert_equal([], @rev.each_modified_object.to_a)
     end
+
+    it "doesn't return dictionaries that have direct HexaPDF::Object child objects" do
+      obj = @rev.object(6)
+      obj[:Array] = HexaPDF::PDFArray.new([1, 2]) # same value but differen #data instance
+      assert_equal([], @rev.each_modified_object.to_a)
+    end
+
+    it "doesn't return signature objects" do
+      obj = @rev.object(2)
+      obj[:x] = :y
+      assert_equal([], @rev.each_modified_object.to_a)
+    end
   end
 
   describe "reset_objects" do

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.26.1)>>
+      <</Producer(HexaPDF version 0.26.2)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.26.1)>>
+      <</Producer(HexaPDF version 0.26.2)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -206,7 +206,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.26.1)>>
+      <</Producer(HexaPDF version 0.26.2)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream

data/test/hexapdf/type/test_object_stream.rb

@@ -30,6 +30,12 @@ describe HexaPDF::Type::ObjectStream do
                                            stream: "1 0 5 2 5 [1 2]")
   end
 
+  it "parses an associated stream the first time the stored objects are accessed" do
+    assert_nil(@obj.instance_variable_get(:@objects))
+    assert_equal(0, @obj.object_index(HexaPDF::Reference.new(1, 0)))
+    assert_equal(1, @obj.object_index(HexaPDF::Reference.new(5, 0)))
+  end
+
   it "correctly parses stream data" do
     data = @obj.parse_stream
     assert_equal([5, 1], data.object_by_index(0))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.26.1
+  version: 0.26.2
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-14 00:00:00.000000000 Z
+date: 2022-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -706,7 +706,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby