hexapdf 0.45.0 → 0.46.0

data/lib/hexapdf/document.rb

@@ -278,8 +278,9 @@ module HexaPDF
     # If the same argument is provided in multiple invocations, the import is done only once and
     # the previously imported object is returned.
     #
-    # Note: If you first create a PDF document from scratch and then want to import objects from it
-    # into another PDF document, you need to run the following on the source document:
+    # Note: If you first create a PDF document from scratch or if you modify an existing document,
+    # and then want to import objects from it into another PDF document, you need to run the
+    # following on the source document:
     #
     #   doc.dispatch_message(:complete_objects)
     #   doc.validate
@@ -701,6 +702,27 @@ module HexaPDF
       result
     end
 
+    # Returns an in-memory copy of the PDF document.
+    #
+    # In the context of this method this means that the returned PDF document contains the same PDF
+    # object tree as this document, starting at the trailer. A possibly set encryption is not
+    # transferred to the returned document.
+    #
+    # Note: If this PDF document was created from scratch or if it is an existing document that was
+    # modified, the following commands need to be run on this document beforehand:
+    #
+    #   doc.dispatch_message(:complete_objects)
+    #   doc.validate
+    #
+    # This ensures that all the necessary PDF structures set-up correctly.
+    def duplicate
+      dest = HexaPDF::Document.new
+      dupped_trailer = HexaPDF::Importer.copy(dest, trailer, allow_all: true)
+      dest.revisions.current.trailer.value.replace(dupped_trailer.value)
+      dest.trailer.delete(:Encrypt)
+      dest
+    end
+
     # :call-seq:
     #   doc.write(filename, incremental: false, validate: true, update_fields: true, optimize: false)
     #   doc.write(io, incremental: false, validate: true, update_fields: true, optimize: false)

data/lib/hexapdf/importer.rb

@@ -71,14 +71,18 @@ module HexaPDF
     # Imports the given +object+ (belonging to the +source+ document) by completely copying it and
     # all referenced objects into the +destination+ object.
     #
+    # If the +allow_all+ argument is set to +true+, then the usually omitted catalog and page tree
+    # node objects (see the class description for details) are also copied which allows one to make
+    # an in-memory duplicate of a HexaPDF::Document object.
+    #
     # Specifying +source+ is optionial if it can be determined through +object+.
     #
     # After the operation is finished, all state is discarded. This means that another call to this
     # method for the same object will yield a new - and different - object. This is in contrast to
     # using ::for together with #import which remembers and returns already imported objects (which
     # is generally what one wants).
-    def self.copy(destination, object, source: nil)
-      new(NullableWeakRef.new(destination)).import(object, source: source)
+    def self.copy(destination, object, allow_all: false, source: nil)
+      new(NullableWeakRef.new(destination), allow_all: allow_all).import(object, source: source)
     end
 
     private_class_method :new
@@ -86,9 +90,10 @@ module HexaPDF
     attr_reader :destination #:nodoc:
 
     # Initializes a new importer that can import objects to the +destination+ document.
-    def initialize(destination)
+    def initialize(destination, allow_all: false)
       @destination = destination
       @mapper = {}
+      @allow_all = allow_all
     end
 
     SourceWrapper = Struct.new(:source) #:nodoc:
@@ -136,7 +141,7 @@ module HexaPDF
         internal_import(wrapper.source.object(object), wrapper)
       when HexaPDF::Object
         wrapper.source ||= object.document
-        if object.type == :Catalog || object.type == :Pages
+        if !@allow_all && (object.type == :Catalog || object.type == :Pages)
           @mapper[object.data] = nil
         elsif (mapped_object = @mapper[object.data]&.__getobj__) && !mapped_object.null?
           mapped_object
@@ -149,7 +154,12 @@ module HexaPDF
           obj.data.gen = 0
           @destination.add(obj) if object.indirect?
 
-          obj.data.stream = obj.data.stream.dup if obj.data.stream.kind_of?(String)
+          stream = obj.data.stream
+          if stream.kind_of?(String)
+            obj.data.stream = stream.dup
+          elsif stream&.source.kind_of?(FiberDoubleForString)
+            obj.data.stream = stream.fiber.resume.dup
+          end
           obj.data.value = duplicate(obj.data.value, wrapper)
           obj.data.value.update(duplicate(object.copy_inherited_values, wrapper)) if object.type == :Page
           obj

data/lib/hexapdf/layout/box.rb

@@ -69,6 +69,10 @@ module HexaPDF
     #     If the subclass supports the value :flow of the 'position' style property, this method
     #     needs to be overridden to return +true+.
     #
+    #     Additionally, if a box object uses flow positioning, #fit_result.x should be set to the
+    #     correct value since Frame#fit can't determine this and uses Frame#left in the absence of a
+    #     set value.
+    #
     # #empty?::
     #     This method should return +true+ if the subclass won't draw anything when #draw is called.
     #
@@ -89,28 +93,13 @@ module HexaPDF
     #     This method draws the box specific content and is called from #draw which already handles
     #     things like drawing the border and background. So #draw should usually not be overridden.
     #
-    # This base class provides various private helper methods for use in the above methods:
-    #
-    # +reserved_width+, +reserved_height+::
-    #     Returns the width respectively the height of the reserved space inside the box that is
-    #     used for the border and padding.
-    #
-    # +reserved_width_left+, +reserved_width_right+, +reserved_height_top+,
-    # +reserved_height_bottom+::
-    #     Returns the reserved space inside the box at the specified edge (left, right, top,
-    #     bottom).
-    #
-    # +update_content_width+, +update_content_height+::
-    #     Takes a block that should return the content width respectively height and sets the box's
-    #     width respectively height accordingly.
-    #
-    # +create_split_box+::
-    #     Creates a new box based on this one and resets the internal data back to their original
-    #     values.
+    # This base class also provides various protected helper methods for use in the above methods:
     #
-    #     The keyword argument +split_box_value+ (defaults to +true+) is used to set the
-    #     +@split_box+ variable to make the new box aware that it is a split box. This can be set to
-    #     any other truthy value to convey more meaning.
+    # * #reserved_width, #reserved_height
+    # * #reserved_width_left, #reserved_width_right, #reserved_height_top,
+    #   #reserved_height_bottom
+    # * #update_content_width, #update_content_height
+    # * #create_split_box
     class Box
 
       include HexaPDF::Utils
@@ -352,7 +341,9 @@ module HexaPDF
                     available_height
                   end
         return @fit_result if !position_flow && (float_compare(@width, available_width) > 0 ||
-                                                 float_compare(@height, available_height) > 0)
+                                                 float_compare(@height, available_height) > 0 ||
+                                                 @width - reserved_width < 0 ||
+                                                 @height - reserved_height < 0)
 
         fit_content(available_width, available_height, frame)
 
@@ -432,7 +423,7 @@ module HexaPDF
           (style.overlays? && !style.overlays.none?))
       end
 
-      private
+      protected
 
       # Returns the width that is reserved by the padding and border style properties.
       def reserved_width
@@ -480,12 +471,18 @@ module HexaPDF
         result
       end
 
+      # :call-seq:
+      #   update_content_width { block }
+      #
       # Updates the width of the box using the content width returned by the block.
       def update_content_width
         return if @initial_width > 0
         @width = yield + reserved_width
       end
 
+      # :call-seq:
+      #   update_content_height { block }
+      #
       # Updates the height of the box using the content height returned by the block.
       def update_content_height
         return if @initial_height > 0
@@ -494,13 +491,12 @@ module HexaPDF
 
       # Fits the content of the box and returns whether fitting was successful.
       #
-      # This is just a stub implementation that sets the #fit_result status to success if the
-      # content rectangle is not degenerate. Subclasses should override it to provide the box
-      # specific behaviour.
+      # This is just a stub implementation that sets the #fit_result status to success. Subclasses
+      # should override it to provide the box specific behaviour.
       #
       # See #fit for details.
       def fit_content(_available_width, _available_height, _frame)
-        fit_result.success! if content_width > 0 && content_height > 0
+        fit_result.success!
       end
 
       # Splits the content of the box.
@@ -525,7 +521,8 @@ module HexaPDF
         end
       end
 
-      # Creates a new box based on this one and resets the data back to their original values.
+      # Creates a new box based on this one and resets the internal data back to their original
+      # values.
       #
       # The variable +@split_box+ is set to +split_box_value+ (defaults to +true+) to make the new
       # box aware that it is a split box. If needed, subclasses can set the variable to other truthy

data/lib/hexapdf/layout/frame.rb

@@ -252,7 +252,7 @@ module HexaPDF
                   end
                 end
           when :flow
-            x = 0
+            x = fit_result.x || left
             y = @y - height
           else
             raise HexaPDF::Error, "Invalid value '#{position}' for style property position"

data/lib/hexapdf/layout/inline_box.rb

@@ -43,14 +43,12 @@ module HexaPDF
     # An InlineBox wraps a regular Box so that it can be used as an item for a Line. This enables
     # inline graphics.
     #
-    # Complete box auto-sizing is not possible since the available space cannot be determined
-    # beforehand! This means the box *must* have at least its width set. The height may either also
-    # be set or determined during fitting.
+    # When an inline box gets placed on a line, the method #fit_wrapped_box is called to fit the
+    # wrapped box. This allows the wrapped box to correctly set its width and height which are
+    # needed by the TextLayouter algorithm.
     #
-    # Fitting of the wrapped box via #fit_wrapped_box needs to be done before accessing any other
-    # method that uses the wrapped box. For fitting, a frame is used that has the width of the
-    # wrapped box and its height, or if not set, a practically infinite height. In the latter case
-    # the height *must* be set during fitting.
+    # Note: It is *mandatory* that the wrapped box sets its width and height without relying on the
+    # dimensions of the frame's current region.
     class InlineBox
 
       # Creates an InlineBox that wraps a basic Box. All arguments (except +valign+) and the block
@@ -74,7 +72,6 @@ module HexaPDF
       # The +valign+ argument can be used to specify the vertical alignment of the box relative to
       # other items in the Line.
       def initialize(box, valign: :baseline)
-        raise HexaPDF::Error, "Width of box not set" if box.width == 0
         @box = box
         @valign = valign
       end
@@ -102,8 +99,7 @@ module HexaPDF
       # Draws the wrapped box. If the box has margins specified, the x and y offsets are correctly
       # adjusted.
       def draw(canvas, x, y)
-        canvas.translate(x - @fit_result.x + box.style.margin.left,
-                         y - @fit_result.y + box.style.margin.bottom) { @fit_result.draw(canvas) }
+        @fit_result.draw(canvas, dx: x, dy: y)
       end
 
       # The minimum x-coordinate which is always 0.
@@ -129,19 +125,17 @@ module HexaPDF
       # Fits the wrapped box.
       #
       # If the +frame+ argument is +nil+, a custom frame is created. Otherwise the given +frame+ is
-      # used for the fitting operation.
-      def fit_wrapped_box(frame)
-        frame = if frame
-                  frame.child_frame(0, 0, box.width, box.height == 0 ? 100_000 : box.height)
-                else
-                  Frame.new(0, 0, box.width, box.height == 0 ? 100_000 : box.height)
-                end
-        @fit_result = frame.fit(box)
-        if !@fit_result.success?
-          raise HexaPDF::Error, "Box for inline use could not be fit"
-        elsif box.height > 99_000
-          raise HexaPDF::Error, "Box for inline use has no valid height set after fitting"
-        end
+      # used for creating an appropriate child frame for the fitting operation.
+      #
+      # After this operation the caller is responsible for checking the actual width and height of
+      # the inline box and whether it really fits.
+      def fit_wrapped_box(frame = nil)
+        @fit_result = box.fit(100_000, 100_000, frame || Frame.new(0, 0, 100_000, 100_000))
+        margin = box.style.margin if box.style.margin?
+        @fit_result.x = margin&.left.to_i
+        @fit_result.y = margin&.bottom.to_i
+        @fit_result.mask = Geom2D::Rectangle(0, 0, @fit_result.x + box.width + margin&.right.to_i,
+                                             @fit_result.y + box.height + margin&.top.to_i)
       end
 
     end

data/lib/hexapdf/layout/list_box.rb

@@ -243,7 +243,7 @@ module HexaPDF
           break if !box_fitter.success? || height <= 0
         end
 
-        @height = @results.sum(&:height) + (@results.count - 1) * item_spacing + reserved_height
+        update_content_height { @results.sum(&:height) + (@results.count - 1) * item_spacing }
 
         if @results.size == @children.size && @results.all? {|r| r.box_fitter.success? }
           fit_result.success!
@@ -316,37 +316,32 @@ module HexaPDF
       def item_marker_box(document, index)
         return @marker_type.call(document, self, index) if @marker_type.kind_of?(Proc)
 
-        unless (fragment = @item_marker_fragment)
+        unless (items = @item_marker_items)
           marker_style = {
-            font: style.font? ? style.font : document.fonts.add("Times"),
-            font_size: style.font_size || 10, fill_color: style.fill_color
+            font_size: style.font_size || 10,
+            fill_color: style.fill_color,
           }
-          fragment = case @marker_type
-                     when :disc
-                       TextFragment.create("•", marker_style)
-                     when :circle
-                       unless marker_style[:font].decode_codepoint("❍".ord).valid?
-                         marker_style[:font] = document.fonts.add("ZapfDingbats")
-                       end
-                       TextFragment.create("❍", **marker_style,
-                                           font_size: style.font_size / 2.0,
-                                           text_rise: -style.font_size / 1.8)
-                     when :square
-                       unless marker_style[:font].decode_codepoint("■".ord).valid?
-                         marker_style[:font] = document.fonts.add("ZapfDingbats")
-                       end
-                       TextFragment.create("■", **marker_style,
-                                           font_size: style.font_size / 2.0,
-                                           text_rise: -style.font_size / 1.8)
-                     when :decimal
-                       text = (@start_number + index).to_s << "."
-                       TextFragment.create(text, marker_style)
-                     else
-                       raise HexaPDF::Error, "Unknown list marker type #{@marker_type.inspect}"
-                     end
-          @item_marker_fragment = fragment unless @marker_type == :decimal
+          marker_style[:font] = style.font if style.font?
+          items = case @marker_type
+                  when :disc
+                    document.layout.text_fragments("•", style: marker_style)
+                  when :circle
+                    document.layout.text_fragments("❍", style: marker_style,
+                                                   font_size: style.font_size / 2.0,
+                                                   text_rise: -style.font_size / 1.8)
+                  when :square
+                    document.layout.text_fragments("■", style: marker_style,
+                                                   font_size: style.font_size / 2.0,
+                                                   text_rise: -style.font_size / 1.8)
+                  when :decimal
+                    text = (@start_number + index).to_s << "."
+                    document.layout.text_fragments(text, style: marker_style)
+                  else
+                    raise HexaPDF::Error, "Unknown list marker type #{@marker_type.inspect}"
+                  end
+          @item_marker_items = items unless @marker_type == :decimal
         end
-        TextBox.new(items: [fragment], style: {text_align: :right, padding: [0, 5, 0, 0]})
+        TextBox.new(items: items, style: {text_align: :right, padding: [0, 5, 0, 0]})
       end
 
       # Draws the list items onto the canvas at position [x, y].

data/lib/hexapdf/layout/page_style.rb

@@ -41,7 +41,10 @@ require 'hexapdf/layout/frame'
 module HexaPDF
   module Layout
 
-    # A PageStyle defines the initial look of a page and the placement of one or more frames.
+    # A PageStyle defines the dimensions of a page, its initial look, the Frame for object placement
+    # and which page style should be used next.
+    #
+    # This class is used by HexaPDF::Composer to style the individual pages.
     class PageStyle
 
       # The page size.
@@ -65,14 +68,15 @@ module HexaPDF
       # The callable object is given a canvas and the page style as arguments. It needs to draw the
       # initial content of the page. Note that the graphics state of the canvas is *not* saved
       # before executing the template code and restored afterwards. If this is needed, the object
-      # needs to do it itself.
+      # needs to do it itself. The #next_style attribute can optionally be set.
       #
-      # Furthermore it should set the #frame and #next_style attributes appropriately, if not done
-      # beforehand. The #create_frame method can be used for easily creating a rectangular frame.
+      # Furthermore, the callable object should set the #frame that defines the area on the page
+      # where content should be placed. The #create_frame method can be used for easily creating a
+      # rectangular frame.
       #
       # Example:
       #
-      #   page_style.template = lambda do |canvas, style
+      #   page_style.template = lambda do |canvas, style|
       #     box = canvas.context.box
       #     canvas.fill_color("fd0") do
       #       canvas.rectangle(0, 0, box.width, box.height).fill
@@ -81,22 +85,24 @@ module HexaPDF
       #   end
       attr_accessor :template
 
-      # The HexaPDF::Layout::Frame object that defines the area on the page where content should be
-      # placed.
+      # The Frame object that defines the area for the last page created with #create_page where
+      # content should be placed.
       #
-      # This can either be set beforehand or during execution of the #template.
-      #
-      # If no frame has been set, a frame covering the page except for a default margin on all sides
-      # is set during #create_page.
+      # This value is usually updated during execution of the #template. If the value is not
+      # updated, a frame covering the page except for a default margin on all sides is set during
+      # #create_page.
       attr_accessor :frame
 
       # Defines the name of the page style that should be used for the next page.
       #
+      # Note that this value can be different each time a new page is created via #create_page.
+      #
       # If this attribute is +nil+ (the default), it means that this style should be used again.
       attr_accessor :next_style
 
       # Creates a new page style instance for the given page size, orientation and next style
-      # values. If a block is given, it is used as template for defining the initial content.
+      # values. If a block is given, it is used as #template for defining the initial content of a
+      # page.
       #
       # Example:
       #
@@ -113,14 +119,15 @@ module HexaPDF
         @next_style = next_style
       end
 
-      # Creates a new page in the given document with this page style and returns it.
+      # Creates a new page in the given document using this page style and returns it.
       #
-      # If #frame has not been set beforehand or during execution of the #template, a default frame
-      # covering the whole page except a margin of 36 is created.
+      # If the #frame has not changed during execution of the #template, a default frame covering
+      # the whole page except a margin of 36 is assigned.
       def create_page(document)
+        frame_before = @frame
         page = document.pages.create(media_box: page_size, orientation: orientation)
         template&.call(page.canvas, self)
-        self.frame ||= create_frame(page, 36)
+        self.frame = create_frame(page, 36) if @frame.equal?(frame_before)
         page
       end
 

data/lib/hexapdf/layout/style.rb

@@ -1369,8 +1369,8 @@ module HexaPDF
       #       composer.text('Text underneath')
       #
       # :fill_frame_horizontal::
-      #     The mask covers the box including the margin around the box and the space to the left
-      #     and right in the frame.
+      #     The mask covers the box including the margin around the box, the space to the left and
+      #     right in the frame and the space to the top of the current region.
       #
       #     Examples:
       #

data/lib/hexapdf/layout/text_box.rb

@@ -106,11 +106,6 @@ module HexaPDF
         true
       end
 
-      # :nodoc:
-      def draw(canvas, x, y)
-        super(canvas, x + @x_offset, y)
-      end
-
       # :nodoc:
       def empty?
         super && (!@result || @result.lines.empty?)
@@ -137,7 +132,8 @@ module HexaPDF
             min_x = [min_x, line.x_offset].min
             max_x = [max_x, line.x_offset + line.width].max
           end
-          @width = (min_x.finite? ? (@x_offset = min_x; max_x - min_x) : 0) + reserved_width
+          @width = (min_x.finite? ? max_x - min_x : 0) + reserved_width
+          fit_result.x = @x_offset = min_x
           @height = @initial_height > 0 ? @initial_height : @result.height + reserved_height
         else
           @result = @tl.fit(@items, @width - reserved_width, @height - reserved_height,

data/lib/hexapdf/parser.rb

@@ -71,6 +71,10 @@ module HexaPDF
     end
 
     # Returns +true+ if the PDF file is a linearized file.
+    #
+    # Note: The method uses heuristics to determine whether a PDF file is linearized. In case of
+    # slightly invalid or damaged PDFs that HexaPDF can recover from it is possible that this method
+    # returns +true+ even though the PDF isn't actually linearized.
     def linearized?
       @linearized ||=
         begin
@@ -293,7 +297,7 @@ module HexaPDF
             next
           elsif type == 'n'
             if pos == 0 || gen > 65535
-              maybe_raise("Invalid in use cross-reference entry",
+              maybe_raise("Invalid in use cross-reference entry for object number #{oid}",
                           pos: @tokenizer.pos)
               xref.add_free_entry(oid, gen)
             else

data/lib/hexapdf/revisions.rb

@@ -97,7 +97,7 @@ module HexaPDF
               merge_revision = offset
             end
 
-            if merge_revision == offset
+            if merge_revision == offset && !revisions.empty?
               xref_section.merge!(revisions.first.xref_section)
               offset = trailer[:Prev] # Get possible next offset before overwriting trailer
               trailer = revisions.first.trailer

data/lib/hexapdf/stream.rb

@@ -51,6 +51,9 @@ module HexaPDF
   # normalized to arrays on assignment to ease further processing.
   class StreamData
 
+    # The source.
+    attr_reader :source
+
     # The filter(s) that need to be applied for getting the decoded stream data.
     attr_reader :filter
 
@@ -110,9 +113,6 @@ module HexaPDF
 
     protected
 
-    # The source.
-    attr_reader :source
-
     # The optional offset into the bytes provided by source.
     attr_reader :offset
 

data/lib/hexapdf/tokenizer.rb

@@ -82,6 +82,7 @@ module HexaPDF
     # correctable situations are only raised if the return value of calling the object is +true+.
     def initialize(io, on_correctable_error: nil)
       @io = io
+      @io_chunk = String.new(''.b)
       @ss = StringScanner.new(''.b)
       @original_pos = -1
       @on_correctable_error = on_correctable_error || proc { false }
@@ -439,9 +440,9 @@ module HexaPDF
       @io.seek(@next_read_pos)
       return false if @io.eof?
 
-      @ss << @io.read(8192)
+      @ss << @io.read(8192, @io_chunk)
       if @ss.pos > 8192 && @ss.string.length > 16384
-        @ss.string.slice!(0, 8192)
+        @ss.string.replace(@ss.string.byteslice(8192..-1))
         @ss.pos -= 8192
         @original_pos += 8192
       end

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

@@ -65,6 +65,8 @@ module HexaPDF
       #
       # == Type Specific Field Flags
       #
+      # See the class description for Field for the general field flags.
+      #
       # :no_toggle_to_off:: Only used with radio buttons fields. If this flag is set, one button
       #                     needs to be selected at all times. Otherwise, clicking on the selected
       #                     button deselects it.

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

@@ -51,6 +51,8 @@ module HexaPDF
       #
       # == Type Specific Field Flags
       #
+      # See the class description for Field for the general field flags.
+      #
       # :combo:: If set, the field represents a combo box.
       #
       # :edit:: If set, the combo box includes an editable text box for entering arbitrary values.

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

@@ -76,6 +76,8 @@ module HexaPDF
       #
       # :no_export:: The field should *not* be exported by a submit-form action.
       #
+      # Also see the class description of the subclasses for additional, type specific field flags.
+      #
       # == Field Type Implementation Notes
       #
       # If an AcroForm field type adds additional inheritable dictionary fields, it has to set the
@@ -124,6 +126,8 @@ module HexaPDF
         #
         # Returns an array of flag names representing the set bit flags.
         #
+        # See the class description for a list of available flags.
+        #
 
         ##
         # :method: flagged?
@@ -133,6 +137,8 @@ module HexaPDF
         # Returns +true+ if the given flag is set. The argument can either be the flag name or the
         # bit index.
         #
+        # See the class description for a list of available flags.
+        #
 
         ##
         # :method: flag
@@ -142,6 +148,8 @@ module HexaPDF
         # Sets the given flags, given as flag names or bit indices. If +clear_existing+ is +true+,
         # all prior flags will be cleared.
         #
+        # See the class description for a list of available flags.
+        #
         bit_field(:flags, {read_only: 0, required: 1, no_export: 2},
                   lister: "flags", getter: "flagged?", setter: "flag", unsetter: "unflag",
                   value_getter: "self[:Ff]", value_setter: "self[:Ff]")

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

@@ -388,13 +388,14 @@ module HexaPDF
             page_annots = page[:Annots].to_a - to_delete
             page[:Annots].value.replace(page_annots)
           end
-          to_delete.each {|widget| document.delete(widget) }
 
           if field[:Parent]
             field[:Parent][:Kids].delete(field)
           else
             self[:Fields].delete(field)
           end
+
+          to_delete.each {|widget| document.delete(widget) }
           document.delete(field)
         end
 

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

@@ -50,6 +50,8 @@ module HexaPDF
       #
       # == Type Specific Field Flags
       #
+      # See the class description for Field for the general field flags.
+      #
       # :multiline:: If set, the text field may contain multiple lines.
       #
       # :password:: The field is a password field. This changes the behaviour of the PDF reader

data/lib/hexapdf/version.rb

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