hexapdf 0.41.0 → 0.43.0

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

@@ -35,6 +35,7 @@
 #++
 
 require 'json'
+require 'time'
 require 'hexapdf/error'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_fragment'
@@ -56,6 +57,7 @@ module HexaPDF
       #   JavaScript actions are:
       #
       #   * +AFNumber_Format+: See #af_number_format_action and #apply_af_number_format
+      #   * +AFPercent_Format+: See #af_percent_format_action and #apply_af_percent_format
       #
       # Calculating a field's value::
       #
@@ -184,6 +186,10 @@ module HexaPDF
           return [value, nil] unless (action_string = action_string(format_action))
           if action_string.start_with?('AFNumber_Format(')
             apply_af_number_format(value, action_string)
+          elsif action_string.start_with?('AFPercent_Format(')
+            apply_af_percent_format(value, action_string)
+          elsif action_string.start_with?('AFTime_Format(')
+            apply_af_time_format(value, action_string)
           else
             [value, nil]
           end
@@ -235,8 +241,15 @@ module HexaPDF
         # See: #apply_af_number_format
         def af_number_format_action(decimals: 2, separator_style: :point, negative_style: :minus_black,
                                     currency_string: "", prepend_currency: true)
-          "AFNumber_Format(#{decimals}, #{AF_NUMBER_FORMAT_MAPPINGS[:separator][separator_style]}, " \
-            "#{AF_NUMBER_FORMAT_MAPPINGS[:negative][negative_style]}, 0, \"#{currency_string}\", " \
+          separator_style = AF_NUMBER_FORMAT_MAPPINGS[:separator].fetch(separator_style) do
+            raise ArgumentError, "Unsupported value for separator_style argument: #{separator_style}"
+          end
+          negative_style = AF_NUMBER_FORMAT_MAPPINGS[:negative].fetch(negative_style) do
+            raise ArgumentError, "Unsupported value for negative_style argument: #{negative_style}"
+          end
+
+          "AFNumber_Format(#{decimals}, #{separator_style}, " \
+            "#{negative_style}, 0, \"#{currency_string}\", " \
             "#{prepend_currency});"
         end
 
@@ -323,21 +336,141 @@ module HexaPDF
             end
           end
 
-          result = sprintf(format, value)
+          [af_format_number(value, format, match[:sep_style]), text_color]
+        end
 
-          before_decimal_point, after_decimal_point = result.split('.')
-          if match[:sep_style] == '0' || match[:sep_style] == '2'
-            separator = (match[:sep_style] == '0' ? ',' : '.')
-            before_decimal_point.gsub!(/\B(?=(\d\d\d)+(?:[^\d]|\z))/, separator)
+        # Returns the appropriate JavaScript action string for the AFPercent_Format function.
+        #
+        # +decimals+::
+        #     The number of decimal digits to use. Default 2.
+        #
+        # +separator_style+::
+        #     Specifies the character for the decimal and thousands separator, one of:
+        #
+        #     :point:: (Default) Use point as decimal separator and comma as thousands separator.
+        #     :point_no_thousands:: Use point as decimal separator and no thousands separator.
+        #     :comma:: Use comma as decimal separator and point as thousands separator.
+        #     :comma_no_thousands:: Use comma as decimal separator and no thousands separator.
+        #
+        # See: #apply_af_percent_format
+        def af_percent_format_action(decimals: 2, separator_style: :point)
+          separator_style = AF_NUMBER_FORMAT_MAPPINGS[:separator].fetch(separator_style) do
+            raise ArgumentError, "Unsupported value for separator_style argument: #{separator_style}"
           end
-          result = if after_decimal_point
-                     decimal_point = (match[:sep_style] =~ /[01]/ ? '.' : ',')
-                     "#{before_decimal_point}#{decimal_point}#{after_decimal_point}"
-                   else
-                     before_decimal_point
-                   end
+          "AFPercent_Format(#{decimals}, #{separator_style});"
+        end
+
+        # Regular expression for matching the AFPercent_Format method.
+        #
+        # See: #apply_af_percent_format
+        AF_PERCENT_FORMAT_RE = /
+          \AAFPercent_Format\(
+            \s*(?<ndec>\d+)\s*,
+            \s*(?<sep_style>[0-3])\s*
+          \);?\z
+        /x
+
+        # Implements the JavaScript AFPercent_Format function and returns the formatted field value.
+        #
+        # The argument +value+ has to be the field's value (a String) and +action_string+ has to be
+        # the JavaScript action string.
+        #
+        # The AFPercent_Format function assumes that the text field's value contains a number (as a
+        # string) and formats it according to the instructions.
+        #
+        # It has the form <tt>AFPercent_Format(no_of_decimals, separator_style)</tt> where the
+        # arguments have the following meaning:
+        #
+        # +no_of_decimals+::
+        #   The number of decimal places after the decimal point, e.g. for 3 it would result in
+        #   123.456.
+        #
+        # +separator_style+::
+        #   Defines which decimal separator and whether a thousands separator should be used.
+        #
+        #   Possible values are:
+        #
+        #   +0+:: Comma for thousands separator, point for decimal separator: 12,345.67
+        #   +1+:: No thousands separator, point for decimal separator: 12345.67
+        #   +2+:: Point for thousands separator, comma for decimal separator: 12.345,67
+        #   +3+:: No thousands separator, comma for decimal separator: 12345,67
+        def apply_af_percent_format(value, action_string)
+          return value unless (match = AF_PERCENT_FORMAT_RE.match(action_string))
+          af_format_number(af_make_number(value) * 100, "%.#{match[:ndec]}f%%", match[:sep_style])
+        end
 
-          [result, text_color]
+        AF_TIME_FORMAT_MAPPINGS = { #:nodoc:
+          format_integers: {
+            hh_mm: 0,
+            0 => 0,
+            hh12_mm: 1,
+            1 => 1,
+            hh_mm_ss: 2,
+            2 => 2,
+            hh12_mm_ss: 3,
+            3 => 3,
+          },
+          strftime_format: {
+            '0' => '%H:%M',
+            '1' => '%l:%M %p',
+            '2' => '%H:%M:%S',
+            '3' => '%l:%M:%S %p',
+          },
+        }
+
+        # Returns the appropriate JavaScript action string for the AFTime_Format function.
+        #
+        # +format+::
+        #     Specifies the time format, one of:
+        #
+        #     :hh_mm:: (Default) Use 24h time format %H:%M (e.g. 15:25)
+        #     :hh12_mm:: (Default) Use 12h time format %l:%M %p (e.g. 3:25 PM)
+        #     :hh_mm_ss:: Use 24h time format with seconds %H:%M:%S (e.g. 15:25:37)
+        #     :hh12_mm_ss:: Use 24h time format with seconds %l:%M:%S %p (e.g. 3:25:37 PM)
+        #
+        # See: #apply_af_time_format
+        def af_time_format_action(format: :hh_mm)
+          format = AF_TIME_FORMAT_MAPPINGS[:format_integers].fetch(format) do
+            raise ArgumentError, "Unsupported value for time_format argument: #{format}"
+          end
+          "AFTime_Format(#{format});"
+        end
+
+        # Regular expression for matching the AFTime_Format method.
+        #
+        # See: #apply_af_time_format
+        AF_TIME_FORMAT_RE = /
+          \AAFTime_Format\(
+            \s*(?<time_format>[0-3])\s*
+          \);?\z
+        /x
+
+        # Implements the JavaScript AFTime_Format function and returns the formatted field value.
+        #
+        # The argument +value+ has to be the field's value (a String) and +action_string+ has to be
+        # the JavaScript action string.
+        #
+        # The AFTime_Format function assumes that the text field's value contains a valid time
+        # string (for HexaPDF that is anything Time.parse can work with) and formats it according to
+        # the instructions.
+        #
+        # It has the form <tt>AFTime_Format(time_format)</tt> where the argument has the following
+        # meaning:
+        #
+        # +time_format+::
+        #   Defines the time format which should be applied.
+        #
+        #   Possible values are:
+        #
+        #   +0+:: Use 24h time format, e.g. 15:25
+        #   +1+:: Use 12h time format, e.g. 3:25 PM
+        #   +2+:: Use 24h time format with seconds, e.g. 15:25:37
+        #   +3+:: Use 12h time format with seconds, e.g. 3:25:37 PM
+        def apply_af_time_format(value, action_string)
+          return value unless (match = AF_TIME_FORMAT_RE.match(action_string))
+          value = Time.parse(value) rescue nil
+          return "" unless value
+          value.strftime(AF_TIME_FORMAT_MAPPINGS[:strftime_format][match[:time_format]]).strip
         end
 
         # Handles JavaScript calculate actions for single-line text fields.
@@ -483,6 +616,24 @@ module HexaPDF
           value.to_s.tr(',', '.').to_f
         end
 
+        # Formats the numeric value according to the format string and separator style.
+        def af_format_number(value, format, sep_style)
+          result = sprintf(format, value)
+
+          before_decimal_point, after_decimal_point = result.split('.')
+          if sep_style == '0' || sep_style == '2'
+            separator = (sep_style == '0' ? ',' : '.')
+            before_decimal_point.gsub!(/\B(?=(\d\d\d)+(?:[^\d]|\z))/, separator)
+          end
+
+          if after_decimal_point
+            decimal_point = (sep_style <= "1" ? '.' : ',')
+            "#{before_decimal_point}#{decimal_point}#{after_decimal_point}"
+          else
+            before_decimal_point
+          end
+        end
+
         # Returns the JavaScript action string for the given action.
         def action_string(action)
           return nil unless action && action[:S] == :JavaScript

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

@@ -170,7 +170,7 @@ module HexaPDF
           elsif comb_text_field? && !key?(:MaxLen)
             raise HexaPDF::Error, "A comb text field need a valid /MaxLen value"
           elsif str && !str.kind_of?(String)
-            @document.config['acro_form.on_invalid_value'].call(self, str)
+            str = @document.config['acro_form.on_invalid_value'].call(self, str)
           end
           str = str.gsub(/[[:space:]]/, ' ') if str && concrete_field_type == :single_line_text_field
           if key?(:MaxLen) && str && str.length > self[:MaxLen]
@@ -254,9 +254,21 @@ module HexaPDF
         # :number::
         #     Assumes that the field value is a number and formats it according to the given
         #     arguments. See JavaScriptActions.af_number_format_action for details on the arguments.
+        #
+        # :percent::
+        #     Assumes that the field value is a number and formats it as percentage (where 1=100%
+        #     and 0=0%). See JavaScriptActions.af_percent_format_action for details on the
+        #     arguments.
+        #
+        # :time::
+        #     Assumes that the field value is a string with a time value and formats it according to
+        #     the given argument. See JavaScriptActions.af_time_format_action for details on the
+        #     arguments.
         def set_format_action(type, **arguments)
           action_string = case type
                           when :number then JavaScriptActions.af_number_format_action(**arguments)
+                          when :percent then JavaScriptActions.af_percent_format_action(**arguments)
+                          when :time then JavaScriptActions.af_time_format_action(**arguments)
                           else
                             raise ArgumentError, "Invalid value for type argument: #{type.inspect}"
                           end

data/lib/hexapdf/type/resources.rb

@@ -143,7 +143,8 @@ module HexaPDF
       #
       # If the dictionary is not found, an error is raised.
       def font(name)
-        object_getter(:Font, name)
+        font = object_getter(:Font, name)
+        font.kind_of?(Hash) ? document.wrap(font) : font
       end
 
       # Adds the font dictionary to the resources and returns the name under which it is stored.

data/lib/hexapdf/utils.rb

@@ -39,8 +39,27 @@ require 'geom2d/utils'
 module HexaPDF
 
   # This module contains helper methods for the whole library.
+  #
+  # Furthermore, it refines Numeric to provide #mm, #cm, and #inch methods.
   module Utils
 
+    refine Numeric do
+      # Intrepeting self as millimeters returns the equivalent number of points.
+      def mm
+        self * 72 / 25.4
+      end
+
+      # Intrepeting self as centimeters returns the equivalent number of points.
+      def cm
+        self * 72 / 2.54
+      end
+
+      # Intrepeting self as inches returns the equivalent number of points.
+      def inch
+        self * 72
+      end
+    end
+
     # The precision with which to compare floating point numbers.
     #
     # This is chosen with respect to precision that is used for serializing floating point numbers.

data/lib/hexapdf/version.rb

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

data/test/hexapdf/layout/test_box_fitter.rb

@@ -20,13 +20,13 @@ describe HexaPDF::Layout::BoxFitter do
     @box_fitter.fit(HexaPDF::Layout::TextBox.new(items: [ibox] * count))
   end
 
-  def check_result(*pos, content_heights:, successful: true, boxes_remain: false)
+  def check_result(*pos, content_heights:, success: true, boxes_remain: false)
     pos.each_slice(2).with_index do |(x, y), index|
       assert_equal(x, @box_fitter.fit_results[index].x, "x #{index}")
       assert_equal(y, @box_fitter.fit_results[index].y, "y #{index}")
     end
     assert_equal(content_heights, @box_fitter.content_heights)
-    successful ? assert(@box_fitter.fit_successful?) : refute(@box_fitter.fit_successful?)
+    success ? assert(@box_fitter.success?) : refute(@box_fitter.success?)
     rboxes = @box_fitter.remaining_boxes.empty?
     boxes_remain ? refute(rboxes) : assert(rboxes)
   end
@@ -55,7 +55,7 @@ describe HexaPDF::Layout::BoxFitter do
     fit_box(70)
     fit_box(40)
     fit_box(20)
-    check_result(10, 80, 0, 10, 0, 0, 100, 100, successful: false, boxes_remain: true,
+    check_result(10, 80, 0, 10, 0, 0, 100, 100, success: false, boxes_remain: true,
                  content_heights: [90, 50])
     assert_equal(2, @box_fitter.remaining_boxes.size)
   end

data/test/hexapdf/layout/test_text_box.rb

@@ -50,10 +50,12 @@ describe HexaPDF::Layout::TextBox do
     end
 
     it "fits into the frame's outline" do
+      @frame.remove_area(Geom2D::Rectangle(0, 80, 20, 20))
+      @frame.remove_area(Geom2D::Rectangle(80, 70, 20, 20))
       box = create_box([@inline_box] * 20, style: {position: :flow})
       assert(box.fit(100, 100, @frame))
       assert_equal(100, box.width)
-      assert_equal(20, box.height)
+      assert_equal(30, box.height)
     end
 
     it "takes the style option last_line_gap into account" do
@@ -190,6 +192,30 @@ describe HexaPDF::Layout::TextBox do
                                           [:restore_graphics_state]])
     end
 
+    it "correctly draws borders, backgrounds... for position :flow" do
+      @frame.remove_area(Geom2D::Rectangle(0, 0, 40, 100))
+      box = create_box([@inline_box], style: {position: :flow, border: {width: 1}})
+      box.fit(60, 100, @frame)
+      box.draw(@canvas, 0, 90)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:append_rectangle, [40, 90, 10, 10]],
+                                          [:clip_path_non_zero],
+                                          [:end_path],
+                                          [:append_rectangle, [40.5, 90.5, 9.0, 9.0]],
+                                          [:stroke_path],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 41, 89]],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
     it "draws nothing onto the canvas if the box is empty" do
       box = create_box([])
       box.draw(@canvas, 5, 5)

data/test/hexapdf/test_dictionary.rb

@@ -323,11 +323,13 @@ describe HexaPDF::Dictionary do
     end
   end
 
-  describe "to_h" do
-    it "returns a shallow copy of the value" do
-      obj = @dict.to_h
+  describe "to_hash" do
+    it "returns a copy of the value where each entry is pre-processed" do
+      @dict[:value] = HexaPDF::Reference.new(1, 0)
+      obj = @dict.to_hash
       refute_equal(obj.object_id, @dict.value.object_id)
-      assert_equal(obj, @dict.value)
+      assert_equal(:obj, obj[:Object])
+      assert_equal("deref", obj[:value])
     end
   end
 

data/test/hexapdf/test_parser.rb

@@ -367,6 +367,11 @@ describe HexaPDF::Parser do
       assert_equal(5, @parser.startxref_offset)
     end
 
+    it "handles the case of multiple %%EOF and the last one being invalid" do
+      create_parser("startxref\n5\n%%EOF\ntartxref\n3\n%%EOF")
+      assert_equal(5, @parser.startxref_offset)
+    end
+
     it "fails even in big files when nothing is found" do
       create_parser("\nhallo" * 5000)
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
@@ -402,6 +407,13 @@ describe HexaPDF::Parser do
       exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
       assert_match(/startxref on same line/, exp.message)
     end
+
+    it "fails on strict parsing if there are multiple %%EOF and the last one is invalid" do
+      @document.config['parser.on_correctable_error'] = proc { true }
+      create_parser("startxref\n5\n%%EOF\ntartxref\n3\n%%EOF")
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.startxref_offset }
+      assert_match(/missing startxref keyword/, exp.message)
+    end
   end
 
   describe "file_header_version" do

data/test/hexapdf/test_utils.rb

@@ -6,6 +6,22 @@ require 'hexapdf/utils'
 describe HexaPDF::Utils do
   include HexaPDF::Utils
 
+  describe "Numeric refinement" do
+    using HexaPDF::Utils
+
+    it "converts mm to points" do
+      assert_equal(72, 25.4.mm)
+    end
+
+    it "converts cm to points" do
+      assert_equal(72, 2.54.cm)
+    end
+
+    it "converts inch to points" do
+      assert_equal(144, 2.inch)
+    end
+  end
+
   it "checks floats for equality with a certain precision" do
     assert(float_equal(1.0, 1))
     assert(float_equal(1.0, 1.0000003))

data/test/hexapdf/type/acro_form/test_button_field.rb

@@ -93,6 +93,11 @@ describe HexaPDF::Type::AcroForm::ButtonField do
       @field.field_value = "check"
       assert_equal(:check, @field[:V])
       assert_raises(HexaPDF::Error) { @field.field_value = :unknown }
+
+      @field.field_value = :Off
+      @field.create_widget(@doc.pages[0], value: :other)
+      @field.field_value = true
+      assert_equal(:check, @field[:V])
     end
 
     it "returns the correct concrete field type" do

data/test/hexapdf/type/acro_form/test_form.rb

@@ -128,6 +128,12 @@ describe HexaPDF::Type::AcroForm::Form do
       @acro_form = @doc.acro_form(create: true)
     end
 
+    it "creates a pure namespace field" do
+      field = @acro_form.create_namespace_field('text')
+      assert_equal('text', field.full_field_name)
+      assert_nil(field.concrete_field_type)
+    end
+
     describe "handles the general case" do
       it "works for names with a dot" do
         @acro_form[:Fields] = [{T: "root"}]
@@ -142,8 +148,13 @@ describe HexaPDF::Type::AcroForm::Form do
         assert([field], @acro_form[:Fields])
       end
 
-      it "fails if the parent field is not found" do
-        assert_raises(HexaPDF::Error) { @acro_form.create_text_field("root.field") }
+      it "creates the parent fields as namespace fields if necessary" do
+        field = @acro_form.create_text_field("root.sub.field")
+        level1 = @acro_form.field_by_name('root')
+        assert_equal(1, level1[:Kids].size)
+        level2 = @acro_form.field_by_name('root.sub')
+        assert_equal(1, level2[:Kids].size)
+        assert_same(field, level2[:Kids][0])
       end
     end
 
@@ -241,6 +252,103 @@ describe HexaPDF::Type::AcroForm::Form do
     end
   end
 
+  describe "delete_field" do
+    before do
+      @field = @acro_form.create_signature_field("sig")
+    end
+
+    it "deletes a field via name" do
+      @acro_form.delete_field('sig')
+      assert_equal(0, @acro_form.root_fields.size)
+    end
+
+    it "deletes a field via field object" do
+      @acro_form.delete_field(@field)
+      assert_equal(0, @acro_form.root_fields.size)
+    end
+
+    it "deletes the set signature object" do
+      obj = @doc.add({})
+      @field.field_value = obj
+      @acro_form.delete_field(@field)
+      assert(obj.null?)
+    end
+
+    it "deletes all widget annotations from the document and the annotation array" do
+      widget1 = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      widget2 = @field.create_widget(@doc.pages.add, Rect: [0, 0, 0, 0])
+      refute(@doc.pages[1][:Annots].empty?)
+      @acro_form.delete_field(@field)
+      assert(@doc.pages[0][:Annots].empty?)
+      assert(@doc.pages[1][:Annots].empty?)
+      assert(@doc.object(widget1).null?)
+      assert(@doc.object(widget2).null?)
+    end
+
+    it "deletes the field from the field hierarchy" do
+      @acro_form.delete_field('sig')
+      refute(@acro_form.field_by_name('sig'))
+      assert(@acro_form[:Fields].empty?)
+
+      @acro_form.create_signature_field("sub.sub.sig")
+      @acro_form.delete_field("sub.sub.sig")
+      refute(@acro_form.field_by_name('sub.sub.sig'))
+      assert(@acro_form[:Fields][0][:Kids][0][:Kids].empty?)
+    end
+
+    it "deletes the field itself" do
+      @acro_form.delete_field('sig')
+      assert(@doc.object(@field).null?)
+    end
+  end
+
+  describe "fill" do
+    it "works for text field types" do
+      field = @acro_form.create_text_field('test')
+      @acro_form.fill("test" => "value")
+      assert_equal("value", field.field_value)
+    end
+
+    it "works for radio buttons" do
+      field = @acro_form.create_radio_button("test")
+      field.create_widget(@doc.pages.add, value: :name)
+      @acro_form.fill("test" => "name")
+      assert_equal(:name, field.field_value)
+    end
+
+    it "works for check boxes" do
+      field = @acro_form.create_check_box('test')
+      field.create_widget(@doc.pages.add)
+
+      ["t", "true", "y", "yes"].each do |value|
+        @acro_form.fill("test" => value)
+        assert_equal(:Yes, field.field_value)
+        field.field_value = :Off
+      end
+
+      ["f", "false", "n", "no"].each do |value|
+        @acro_form.fill("test" => value)
+        assert_nil(field.field_value)
+        field.field_value = :Yes
+      end
+
+      field.create_widget(@doc.pages.add, value: :Other)
+      @acro_form.fill("test" => "Other")
+      assert_equal(:Other, field.field_value)
+    end
+
+    it "raises an error if a field is not found" do
+      error = assert_raises(HexaPDF::Error) { @acro_form.fill("unknown" => "test") }
+      assert_match(/named 'unknown' not found/, error.message)
+    end
+
+    it "raises an error if a field type is not supported for filling in" do
+      @acro_form.create_check_box('test').initialize_as_push_button
+      error = assert_raises(HexaPDF::Error) { @acro_form.fill("test" => "test") }
+      assert_match(/push_button not yet supported/, error.message)
+    end
+  end
+
   it "returns the default resources" do
     assert_kind_of(HexaPDF::Type::Resources, @acro_form.default_resources)
   end