hexapdf 0.20.2 → 0.21.0

data/lib/hexapdf/content/operator.rb

@@ -1036,14 +1036,14 @@ module HexaPDF
         s: EndPath.new('s'),
         f: EndPath.new('f'),
         F: EndPath.new('F'),
-        'f*'.to_sym => EndPath.new('f*'),
+        'f*': EndPath.new('f*'),
         B: EndPath.new('B'),
-        'B*'.to_sym => EndPath.new('B*'),
+        'B*': EndPath.new('B*'),
         b: EndPath.new('b'),
-        'b*'.to_sym => EndPath.new('b*'),
+        'b*': EndPath.new('b*'),
         n: EndPath.new('n'),
         W: ClipPath.new('W'),
-        'W*'.to_sym => ClipPath.new('W*'),
+        'W*': ClipPath.new('W*'),
 
         BI: InlineImage.new,
 
@@ -1059,10 +1059,10 @@ module HexaPDF
         Td: MoveText.new,
         TD: MoveTextAndSetLeading.new,
         Tm: SetTextMatrix.new,
-        'T*'.to_sym => MoveTextNextLine.new,
+        'T*': MoveTextNextLine.new,
         Tj: ShowText.new,
-        '\''.to_sym => MoveTextNextLineAndShowText.new,
-        '"'.to_sym => SetSpacingMoveTextNextLineAndShowText.new,
+        "'": MoveTextNextLineAndShowText.new,
+        '"': SetSpacingMoveTextNextLineAndShowText.new,
         TJ: ShowTextWithPositioning.new,
       }
       DEFAULT_OPERATORS.default_proc = proc {|h, k| h[k] = BaseOperator.new(k.to_s) }

data/lib/hexapdf/content/parser.rb

@@ -94,11 +94,11 @@ module HexaPDF
         elsif byte == 40 # (
           parse_literal_string
         elsif byte == 60 # <
-          if @string.getbyte(@ss.pos + 1) != 60
-            parse_hex_string
-          else
+          if @string.getbyte(@ss.pos + 1) == 60
             @ss.pos += 2
             TOKEN_DICT_START
+          else
+            parse_hex_string
           end
         elsif byte == 62 # >
           unless @string.getbyte(@ss.pos + 1) == 62

data/lib/hexapdf/content/processor.rb

@@ -187,7 +187,7 @@ module HexaPDF
 
         # Returns the concatenated text of the boxes.
         def string
-          @boxes.map(&:string).join('')
+          @boxes.map(&:string).join
         end
 
         # :call-seq:
@@ -260,14 +260,14 @@ module HexaPDF
         s: :close_and_stroke_path,
         f: :fill_path_non_zero,
         F: :fill_path_non_zero,
-        'f*'.to_sym => :fill_path_even_odd,
+        'f*': :fill_path_even_odd,
         B: :fill_and_stroke_path_non_zero,
-        'B*'.to_sym => :fill_and_stroke_path_even_odd,
+        'B*': :fill_and_stroke_path_even_odd,
         b: :close_fill_and_stroke_path_non_zero,
-        'b*'.to_sym => :close_fill_and_stroke_path_even_odd,
+        'b*': :close_fill_and_stroke_path_even_odd,
         n: :end_path,
         W: :clip_path_non_zero,
-        'W*'.to_sym => :clip_path_even_odd,
+        'W*': :clip_path_even_odd,
         BT: :begin_text,
         ET: :end_text,
         Tc: :set_character_spacing,
@@ -280,10 +280,10 @@ module HexaPDF
         Td: :move_text,
         TD: :move_text_and_set_leading,
         Tm: :set_text_matrix,
-        'T*'.to_sym => :move_text_next_line,
+        'T*': :move_text_next_line,
         Tj: :show_text,
-        '\''.to_sym => :move_text_next_line_and_show_text,
-        '"'.to_sym => :set_spacing_move_text_next_line_and_show_text,
+        "'": :move_text_next_line_and_show_text,
+        '"': :set_spacing_move_text_next_line_and_show_text,
         TJ: :show_text_with_positioning,
         d0: :set_glyph_width, # only for Type 3 fonts
         d1: :set_glyph_width_and_bounding_box, # only for Type 3 fonts
@@ -392,7 +392,7 @@ module HexaPDF
           data = data.each_with_object(''.b) {|obj, result| result << obj if obj.kind_of?(String) }
         end
         font = graphics_state.font
-        font.decode(data).map {|code_point| font.to_utf8(code_point) }.join('')
+        font.decode(data).map {|code_point| font.to_utf8(code_point) }.join
       end
 
       # Decodes the given text object and returns it as a CompositeBox object.

data/lib/hexapdf/document/signatures.rb

@@ -93,12 +93,12 @@ module HexaPDF
 
         # Returns the name to be set on the /Filter key when using this signing handler.
         def filter_name
-          :"Adobe.PPKLite"
+          :'Adobe.PPKLite'
         end
 
         # Returns the name to be set on the /SubFilter key when using this signing handler.
         def sub_filter_name
-          :"adbe.pkcs7.detached"
+          :'adbe.pkcs7.detached'
         end
 
         # Sets the DocMDP permissions that should be applied to the document.
@@ -171,7 +171,7 @@ module HexaPDF
       # Creates a signing handler with the given options and returns it.
       #
       # A signing handler name is mapped to a class via the 'signature.signing_handler'
-      # configuration option.
+      # configuration option. The default signing handler is DefaultHandler.
       def handler(name: :default, **options)
         handler = @document.config.constantize('signature.signing_handler', name) do
           raise HexaPDF::Error, "No signing handler named '#{name}' is available"
@@ -183,7 +183,8 @@ module HexaPDF
       #
       # This method will add a new signature to the document and write the updated document to the
       # given file or IO stream. Afterwards the document can't be modified anymore and still retain
-      # a correct digital signature; create a new document based on the file or IO stream instead.
+      # a correct digital signature. To modify the signed document (e.g. for adding another
+      # signature) create a new document based on the given file or IO stream instead.
       #
       # +signature+::
       #     Can either be a signature object (determined via the /Type key), a signature field or

data/lib/hexapdf/document.rb

@@ -638,6 +638,9 @@ module HexaPDF
     # of the keyword arguments (see HexaPDF::Document::Signatures#handler for details).
     #
     # If not changed, the default signing handler is HexaPDF::Document::Signatures::DefaultHandler.
+    #
+    # *Note*: Once signing is done the document cannot be changed anymore since it was written. If a
+    # document needs to be signed multiple times, it needs to be loaded again after writing.
     def sign(file_or_io, handler: :default, signature: nil, write_options: {}, **handler_options)
       handler = signatures.handler(name: handler, **handler_options)
       signatures.add(file_or_io, handler, signature: signature, write_options: write_options)
@@ -714,6 +717,10 @@ module HexaPDF
       end
     end
 
+    def inspect #:nodoc:
+      "<#{self.class.name}:#{object_id}>"
+    end
+
   end
 
 end

data/lib/hexapdf/encryption/security_handler.rb

@@ -249,6 +249,10 @@ module HexaPDF
         @document = document
         @encrypt_dict_hash = nil
         @encryption_details = {}
+
+        @is_encrypt_dict = document.revisions.each.with_object({}) do |rev, hash|
+          hash[rev.trailer[:Encrypt]] = true
+        end
       end
 
       # Checks if the encryption key computed by this security handler is derived from the
@@ -262,7 +266,7 @@ module HexaPDF
       #
       # See: PDF1.7 s7.6.2
       def decrypt(obj)
-        return obj if obj == document.trailer[:Encrypt] || obj.type == :XRef
+        return obj if @is_encrypt_dict[obj] || obj.type == :XRef
 
         key = object_key(obj.oid, obj.gen, string_algorithm)
         each_string_in_object(obj.value) do |str|

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

@@ -123,7 +123,7 @@ module HexaPDF
 
         # Returns the weight of the font.
         def weight
-          self[:"OS/2"].weight_class || 0
+          self[:'OS/2'].weight_class || 0
         end
 
         # Returns the bounding of the font.
@@ -133,22 +133,22 @@ module HexaPDF
 
         # Returns the cap height of the font.
         def cap_height
-          self[:"OS/2"].cap_height
+          self[:'OS/2'].cap_height
         end
 
         # Returns the x-height of the font.
         def x_height
-          self[:"OS/2"].x_height
+          self[:'OS/2'].x_height
         end
 
         # Returns the ascender of the font.
         def ascender
-          self[:"OS/2"].typo_ascender || self[:hhea].ascent
+          self[:'OS/2'].typo_ascender || self[:hhea].ascent
         end
 
         # Returns the descender of the font.
         def descender
-          self[:"OS/2"].typo_descender || self[:hhea].descent
+          self[:'OS/2'].typo_descender || self[:hhea].descent
         end
 
         # Returns the italic angle of the font, in degrees counter-clockwise from the vertical.
@@ -176,12 +176,12 @@ module HexaPDF
 
         # Returns the distance from the baseline to the top of the strikeout line.
         def strikeout_position
-          self[:"OS/2"].strikeout_position
+          self[:'OS/2'].strikeout_position
         end
 
         # Returns the stroke width for the strikeout line.
         def strikeout_thickness
-          self[:"OS/2"].strikeout_size
+          self[:'OS/2'].strikeout_size
         end
 
         # Returns th glyph ID of the missing glyph, i.e. 0.

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

@@ -55,7 +55,7 @@ module HexaPDF
             'hmtx' => font[:hmtx].raw_data,
           }
           tables['cmap'] = font[:cmap].raw_data if font[:cmap]
-          tables['cvt '] = font[:"cvt "].raw_data if font[:"cvt "]
+          tables['cvt '] = font[:'cvt '].raw_data if font[:'cvt ']
           tables['fpgm'] = font[:fpgm].raw_data if font[:fpgm]
           tables['prep'] = font[:prep].raw_data if font[:prep]
           Builder.build(tables)

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

@@ -99,7 +99,7 @@ module HexaPDF
             'loca' => loca,
             'hmtx' => hmtx,
           }
-          tables['cvt '] = @font[:"cvt "].raw_data if @font[:"cvt "]
+          tables['cvt '] = @font[:'cvt '].raw_data if @font[:'cvt ']
           tables['fpgm'] = @font[:fpgm].raw_data if @font[:fpgm]
           tables['prep'] = @font[:prep].raw_data if @font[:prep]
 

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

@@ -282,12 +282,12 @@ module HexaPDF
             def self.mapper(end_codes, start_codes, id_deltas, id_range_offsets, glyph_indexes)
               compute_glyph_id = lambda do |index, code|
                 offset = id_range_offsets[index]
-                if offset != 0
+                if offset == 0
+                  glyph_id = (code + id_deltas[index]) % 65536
+                else
                   glyph_id = glyph_indexes[offset - end_codes.length + (code - start_codes[index])]
                   glyph_id ||= 0 # Handle invalid subtable entries
                   glyph_id = (glyph_id + id_deltas[index]) % 65536 if glyph_id != 0
-                else
-                  glyph_id = (code + id_deltas[index]) % 65536
                 end
                 glyph_id
               end

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -126,7 +126,6 @@ module HexaPDF
       # If +subset+ is true, the font is subset.
       def initialize(document, font, pdf_object: nil, subset: true)
         @wrapped_font = font
-        @missing_glyph_callable = document.config['font.on_missing_glyph']
 
         @subsetter = (subset ? HexaPDF::Font::TrueType::Subsetter.new(font) : nil)
 
@@ -165,12 +164,10 @@ module HexaPDF
       # Note: Although this method is public, it should normally not be used by application code!
       def glyph(id, str = nil)
         @id_to_glyph[id] ||=
-          begin
-            if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
-              Glyph.new(@wrapped_font, id, str || (+'' << (@cmap.gid_to_code(id) || 0xFFFD)))
-            else
-              @missing_glyph_callable.call("\u{FFFD}", font_type, @wrapped_font)
-            end
+          if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
+            Glyph.new(@wrapped_font, id, str || (+'' << (@cmap.gid_to_code(id) || 0xFFFD)))
+          else
+            @pdf_object.document.config['font.on_missing_glyph'].call("\u{FFFD}", self)
           end
       end
 
@@ -178,12 +175,10 @@ module HexaPDF
       def decode_utf8(str)
         str.codepoints.map! do |c|
           @codepoint_to_glyph[c] ||=
-            begin
-              if (gid = @cmap[c])
-                glyph(gid, +'' << c)
-              else
-                @missing_glyph_callable.call(+'' << c, font_type, @wrapped_font)
-              end
+            if (gid = @cmap[c])
+              glyph(gid, +'' << c)
+            else
+              @pdf_object.document.config['font.on_missing_glyph'].call(+'' << c, self)
             end
         end
       end
@@ -250,7 +245,7 @@ module HexaPDF
                                                  Supplement: 0},
                                  CIDToGIDMap: :Identity})
         dict = document.add({Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
-                             Encoding: :"Identity-H", DescendantFonts: [cid_font]})
+                             Encoding: :'Identity-H', DescendantFonts: [cid_font]})
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do

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

@@ -89,19 +89,17 @@ module HexaPDF
         # Returns the built-in encoding of the font.
         def encoding
           @encoding ||=
-            begin
-              if @metrics.encoding_scheme == 'AdobeStandardEncoding'
-                Encoding.for_name(:StandardEncoding)
-              elsif font_name == 'ZapfDingbats' || font_name == 'Symbol'
-                Encoding.for_name((font_name + "Encoding").to_sym)
-              else
-                encoding = Encoding::Base.new
-                @metrics.character_metrics.each do |key, char_metric|
-                  next unless key.kind_of?(Integer) && key >= 0
-                  encoding.code_to_name[key] = char_metric.name
-                end
-                encoding
+            if @metrics.encoding_scheme == 'AdobeStandardEncoding'
+              Encoding.for_name(:StandardEncoding)
+            elsif font_name == 'ZapfDingbats' || font_name == 'Symbol'
+              Encoding.for_name("#{font_name}Encoding".to_sym)
+            else
+              encoding = Encoding::Base.new
+              @metrics.character_metrics.each do |key, char_metric|
+                next unless key.kind_of?(Integer) && key >= 0
+                encoding.code_to_name[key] = char_metric.name
               end
+              encoding
             end
         end
 

data/lib/hexapdf/font/type1_wrapper.rb

@@ -119,7 +119,6 @@ module HexaPDF
       def initialize(document, font, pdf_object: nil, custom_encoding: false)
         @wrapped_font = font
         @pdf_object = pdf_object || create_pdf_object(document)
-        @missing_glyph_callable = document.config['font.on_missing_glyph']
 
         if pdf_object
           @encoding = pdf_object.encoding
@@ -160,7 +159,7 @@ module HexaPDF
             if @wrapped_font.metrics.character_metrics.key?(name)
               Glyph.new(@wrapped_font, name, str)
             else
-              @missing_glyph_callable.call(str, font_type, @wrapped_font)
+              @pdf_object.document.config['font.on_missing_glyph'].call(str, self)
             end
           end
       end
@@ -212,24 +211,23 @@ module HexaPDF
 
       # Creates a PDF object representing the wrapped font for the given PDF document.
       def create_pdf_object(document)
-        fd = document.wrap({Type: :FontDescriptor,
-                            FontName: @wrapped_font.font_name.intern,
-                            FontWeight: @wrapped_font.weight_class,
-                            FontBBox: @wrapped_font.bounding_box,
-                            ItalicAngle: @wrapped_font.italic_angle || 0,
-                            Ascent: @wrapped_font.ascender || 0,
-                            Descent: @wrapped_font.descender || 0,
-                            CapHeight: @wrapped_font.cap_height,
-                            XHeight: @wrapped_font.x_height,
-                            StemH: @wrapped_font.dominant_horizontal_stem_width,
-                            StemV: @wrapped_font.dominant_vertical_stem_width || 0})
+        fd = document.add({Type: :FontDescriptor,
+                           FontName: @wrapped_font.font_name.intern,
+                           FontWeight: @wrapped_font.weight_class,
+                           FontBBox: @wrapped_font.bounding_box,
+                           ItalicAngle: @wrapped_font.italic_angle || 0,
+                           Ascent: @wrapped_font.ascender || 0,
+                           Descent: @wrapped_font.descender || 0,
+                           CapHeight: @wrapped_font.cap_height,
+                           XHeight: @wrapped_font.x_height,
+                           StemH: @wrapped_font.dominant_horizontal_stem_width,
+                           StemV: @wrapped_font.dominant_vertical_stem_width || 0})
         fd.flag(:fixed_pitch) if @wrapped_font.metrics.is_fixed_pitch
         fd.flag(@wrapped_font.metrics.character_set == 'Special' ? :symbolic : :nonsymbolic)
-        fd.must_be_indirect = true
 
-        dict = document.wrap({Type: :Font, Subtype: :Type1,
-                              BaseFont: @wrapped_font.font_name.intern,
-                              FontDescriptor: fd})
+        dict = document.add({Type: :Font, Subtype: :Type1,
+                             BaseFont: @wrapped_font.font_name.intern,
+                             FontDescriptor: fd})
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do

data/lib/hexapdf/layout/box.rb

@@ -51,13 +51,16 @@ module HexaPDF
     # * If width or height is set to zero, they are determined automatically during layouting.
     class Box
 
-      # Creates a new Box object, using the provided block as drawing block (see ::new). Any
-      # additional keyword arguments are used for creating the box's Style object.
+      # Creates a new Box object, using the provided block as drawing block (see ::new).
       #
       # If +content_box+ is +true+, the width and height are taken to mean the content width and
       # height and the style's padding and border are removed from them appropriately.
-      def self.create(width: 0, height: 0, content_box: false, **style, &block)
-        style = Style.new(**style)
+      #
+      # The +style+ argument defines the Style object (see Style::create for details) for the box.
+      # Any additional keyword arguments have to be style properties and are applied to the style
+      # object.
+      def self.create(width: 0, height: 0, content_box: false, style: nil, **style_properties, &block)
+        style = Style.create(style).update(**style_properties)
         if content_box
           width += style.padding.left + style.padding.right +
             style.border.width.left + style.border.width.right
@@ -81,12 +84,12 @@ module HexaPDF
       # * Style#background_alpha
       # * Style#padding
       # * Style#border
-      # * Style#overlay_callback
-      # * Style#underlay_callback
+      # * Style#overlays
+      # * Style#underlays
       attr_reader :style
 
       # :call-seq:
-      #    Box.new(width: 0, height: 0, style: Style.new) {|canv, box| block} -> box
+      #    Box.new(width: 0, height: 0, style: nil) {|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).
@@ -94,10 +97,10 @@ 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: Style.new, &block)
+      def initialize(width: 0, height: 0, style: nil, &block)
         @width = @initial_width = width
         @height = @initial_height = height
-        @style = (style.kind_of?(Style) ? style : Style.new(**style))
+        @style = Style.create(style)
         @draw_block = block
       end
 

data/lib/hexapdf/layout/image_box.rb

@@ -56,7 +56,7 @@ module HexaPDF
       # Creates a new Image box object for the given +image+ argument which needs to be an image
       # object (e.g. returned by HexaPDF::Document::Images#add).
       def initialize(image, **kwargs)
-        super(**kwargs, &:unused_draw_block)
+        super(**kwargs)
         @image = image
       end
 

data/lib/hexapdf/layout/style.rb

@@ -518,6 +518,27 @@ module HexaPDF
 
       UNSET = ::Object.new # :nodoc:
 
+      # :call-seq:
+      #   Style.create(style)     -> style
+      #   Style.create(properties_hash)   -> style
+      #
+      # Creates a Style object based on the +style+ argument and returns it:
+      #
+      # * If +style+ is already a Style object, it is just returned.
+      #
+      # * If +style+ is a hash, a new Style object with the style properties specified by the hash
+      # * is created.
+      #
+      # * If +style+ is +nil+, a new Style object with only default values is created.
+      def self.create(style)
+        case style
+        when self then style
+        when Hash then new(**style)
+        when nil then new
+        else raise ArgumentError, "Invalid argument class #{style.class}"
+        end
+      end
+
       # Creates a new Style object.
       #
       # The +properties+ hash may be used to set the initial values of properties by using keys
@@ -945,7 +966,8 @@ module HexaPDF
         [:valign, :top, {valid_values: [:top, :center, :bottom]}],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
+         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) || value.kind_of?(Numeric) ? " \
+           "{type: value, value: extra_arg} : value))",
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
         [:background_color, nil],
@@ -1115,13 +1137,11 @@ module HexaPDF
       # inside a TextFragment.
       def scaled_item_width(item)
         @scaled_item_widths[item] ||=
-          begin
-            if item.kind_of?(Numeric)
-              -item * scaled_font_size
-            else
-              item.width * scaled_font_size + scaled_character_spacing +
-                (item.apply_word_spacing? ? scaled_word_spacing : 0)
-            end
+          if item.kind_of?(Numeric)
+            -item * scaled_font_size
+          else
+            item.width * scaled_font_size + scaled_character_spacing +
+              (item.apply_word_spacing? ? scaled_word_spacing : 0)
           end
       end
 

data/lib/hexapdf/layout/text_fragment.rb

@@ -61,11 +61,11 @@ module HexaPDF
 
       # Creates a new TextFragment object for the given text, shapes it and returns it.
       #
-      # The needed style of the text fragment can either be specified by the +style+ argument or via
-      # the +options+ (in which case a new Style object is created). Regardless of the way, the
-      # resulting style object needs at least the font set.
-      def self.create(text, style = nil, **options)
-        style = (style.nil? ? Style.new(**options) : style)
+      # The needed style of the text fragment is specified by the +style+ argument (see
+      # Style::create for details). Note that the resulting style object needs at least the font
+      # set.
+      def self.create(text, style)
+        style = Style.create(style)
         fragment = new(style.font.decode_utf8(text), style)
         TextShaper.new.shape_text(fragment)
       end
@@ -97,16 +97,17 @@ module HexaPDF
       # * Style#stroke_join_style
       # * Style#stroke_miter_limit
       # * Style#stroke_dash_pattern
-      # * Style#underlay_callback
-      # * Style#overlay_callback
+      # * Style#underlays
+      # * Style#overlays
       attr_reader :style
 
       # Creates a new TextFragment object with the given items and style.
       #
-      # The argument +style+ can either be a Style object or a hash of style options.
+      # The argument +style+ can either be a Style object or a hash of style properties, see
+      # Style::create for details.
       def initialize(items, style)
         @items = items
-        @style = (style.kind_of?(Style) ? style : Style.new(**style))
+        @style = Style.create(style)
       end
 
       # The precision used to determine whether two floats represent the same value.

data/lib/hexapdf/parser.rb

@@ -71,6 +71,11 @@ module HexaPDF
       @contains_xref_streams
     end
 
+    # Returns +true+ if the PDF file was damaged and could be reconstructed.
+    def reconstructed?
+      !@reconstructed_revision.nil?
+    end
+
     # Loads the indirect (potentially compressed) object specified by the given cross-reference
     # entry.
     #

data/lib/hexapdf/tokenizer.rb

@@ -125,11 +125,11 @@ module HexaPDF
       elsif byte == 40 # (
         parse_literal_string
       elsif byte == 60 # <
-        if @ss.string.getbyte(@ss.pos + 1) != 60
-          parse_hex_string
-        else
+        if @ss.string.getbyte(@ss.pos + 1) == 60
           @ss.pos += 2
           TOKEN_DICT_START
+        else
+          parse_hex_string
         end
       elsif byte == 62 # >
         unless @ss.string.getbyte(@ss.pos + 1) == 62

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

@@ -260,9 +260,10 @@ module HexaPDF
               canvas.save_graphics_state do
                 canvas.rectangle(padding, padding, rect.width - 2 * padding,
                                  rect.height - 2 * padding).clip_path.end_path
-                if @field.concrete_field_type == :multiline_text_field
+                case @field.concrete_field_type
+                when :multiline_text_field
                   draw_multiline_text(canvas, rect, style, padding)
-                elsif @field.concrete_field_type == :list_box
+                when :list_box
                   draw_list_box(canvas, rect, style, padding)
                 else
                   draw_single_line_text(canvas, rect, style, padding)
@@ -503,9 +504,10 @@ module HexaPDF
         # appearance string, the annotation rectangle and the border style.
         def calculate_font_size(font, font_size, rect, border_style)
           if font_size == 0
-            if @field.concrete_field_type == :multiline_text_field
+            case @field.concrete_field_type
+            when :multiline_text_field
               0 # Handled by multiline drawing code
-            elsif @field.concrete_field_type == :list_box
+            when :list_box
               12 # Seems to be Adobe's default
             else
               unit_font_size = (font.wrapped_font.bounding_box[3] - font.wrapped_font.bounding_box[1]) *

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

@@ -128,8 +128,8 @@ module HexaPDF
           items = option_items
           array_value = [value].flatten
           all_included = array_value.all? {|v| items.include?(v) }
-          self[:V] = if (combo_box? && value.kind_of?(String) &&
-                         (flagged?(:edit) || all_included))
+          self[:V] = if combo_box? && value.kind_of?(String) &&
+                         (flagged?(:edit) || all_included)
                        delete(:I)
                        value
                      elsif list_box? && all_included &&

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

@@ -258,7 +258,7 @@ module HexaPDF
         #
         # See: HexaPDF::Type::Annotations::Widget
         def each_widget(direct_only: false, &block) # :yields: widget
-          return to_enum(__method__) unless block_given?
+          return to_enum(__method__, direct_only: direct_only) unless block_given?
 
           if embedded_widget?
             yield(document.wrap(self))
@@ -336,7 +336,7 @@ module HexaPDF
 
           if embedded_widget?
             WIDGET_FIELDS.each {|key| delete(key) }
-            document.revisions.each {|revision| break if revision.update(self)}
+            document.revisions.each {|revision| break if revision.update(self) }
           else
             self[:Kids].delete_at(widget_index)
             document.delete(widget)