hexapdf 0.40.0 → 0.42.0

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

@@ -0,0 +1,327 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/acro_form/java_script_actions'
+
+describe HexaPDF::Type::AcroForm::JavaScriptActions do
+  before do
+    @klass = HexaPDF::Type::AcroForm::JavaScriptActions
+    @action = {S: :JavaScript}
+  end
+
+  describe "format" do
+    it "returns the original value if the format action can't be processed" do
+      @action[:JS] = 'Unknown();'
+      @klass.apply_format("10", @action)
+    end
+
+    describe "AFNumber_Format" do
+      before do
+        @value = '1234567.898765'
+        @action[:JS] = ''
+      end
+
+      it "returns a correct JavaScript string" do
+        assert_equal('AFNumber_Format(2, 0, 0, 0, "", true);',
+                     @klass.af_number_format_action)
+        assert_equal('AFNumber_Format(1, 1, 1, 0, "E", false);',
+                     @klass.af_number_format_action(decimals: 1, separator_style: :point_no_thousands,
+                                                    negative_style: :red, currency_string: "E",
+                                                    prepend_currency: false))
+      end
+
+      it "raise an error for invalid arguments" do
+        assert_raises(ArgumentError) { @klass.af_number_format_action(separator_style: :unknown) }
+        assert_raises(ArgumentError) { @klass.af_number_format_action(negative_style: :unknown) }
+      end
+
+      def assert_format(arg_string, result_value, result_color)
+        @action[:JS] = "AFNumber_Format(#{arg_string});"
+        value, text_color = @klass.apply_format(@value, @action)
+        assert_equal(result_value, value)
+        result_color ? assert_equal(result_color, text_color) : assert_nil(text_color)
+      end
+
+      it "works with both commas and points as decimal separator" do
+        @value = '1234567.898'
+        assert_format('2, 2, 0, 0, "", false', "1.234.567,90", "black")
+        @value = '1234567,898'
+        assert_format('2, 2, 0, 0, "", false', "1.234.567,90", "black")
+        @value = '123,4567,898'
+        assert_format('2, 2, 0, 0, "", false', "123,46", "black")
+      end
+
+      it "respects the set number of decimals" do
+        assert_format('0, 2, 0, 0, "E", false', "1.234.568E", "black")
+        assert_format('2, 2, 0, 0, "E", false', "1.234.567,90E", "black")
+      end
+
+      it "respects the digit separator style" do
+        ["1,234,567.90", "1234567.90", "1.234.567,90", "1234567,90"].each_with_index do |result, style|
+          assert_format("2, #{style}, 0, 0, \"\", false", result, "black")
+        end
+      end
+
+      it "respects the negative value styling" do
+        @value = '-1234567.898'
+        [["-E1234567,90", "black"], ["E1234567,90", "red"], ["(E1234567,90)", "black"],
+         ["(E1234567,90)", "red"]].each_with_index do |result, style|
+          assert_format("2, 3, #{style}, 0, \"E\", true", result[0], result[1])
+        end
+      end
+
+      it "respects the specified currency string and position" do
+        assert_format('2, 3, 0, 0, " E", false', "1234567,90 E", "black")
+        assert_format('2, 3, 0, 0, "E ", true', "E 1234567,90", "black")
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = "AFNumber_Format(2,2,0,0,\"\",false )"
+        value, = @klass.apply_format('1234.567', @action)
+        assert_equal('1.234,57', value)
+      end
+
+      it "does nothing to the value if the JavaScript method could not be determined " do
+        assert_format('2, 3, 0, 0, " E", false, a', "1234567.898765", nil)
+      end
+    end
+
+    describe "AFPercent_Format" do
+      before do
+        @value = '123.456789'
+        @action[:JS] = ''
+      end
+
+      it "returns a correct JavaScript string" do
+        assert_equal('AFPercent_Format(2, 0);',
+                     @klass.af_percent_format_action)
+        assert_equal('AFPercent_Format(1, 1);',
+                     @klass.af_percent_format_action(decimals: 1, separator_style: :point_no_thousands))
+      end
+
+      it "raise an error for invalid arguments" do
+        assert_raises(ArgumentError) { @klass.af_percent_format_action(separator_style: :unknown) }
+      end
+
+      def assert_format(arg_string, result_value)
+        @action[:JS] = "AFPercent_Format(#{arg_string});"
+        value, text_color = @klass.apply_format(@value, @action)
+        assert_equal(result_value, value)
+        assert_nil(text_color)
+      end
+
+      it "works with both commas and points as decimal separator" do
+        @value = '123.456789'
+        assert_format('2, 2', "12.345,68%")
+        @value = '123,456789'
+        assert_format('2, 2', "12.345,68%")
+        @value = '123,4567,89'
+        assert_format('2, 2', "12.345,67%")
+      end
+
+      it "respects the set number of decimals" do
+        assert_format('0, 2', "12.346%")
+        assert_format('2, 2', "12.345,68%")
+      end
+
+      it "respects the digit separator style" do
+        ["12,345.68%", "12345.68%", "12.345,68%", "12345,68%"].each_with_index do |result, style|
+          assert_format("2, #{style}", result)
+        end
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = "AFPercent_Format(2,2 )"
+        value, = @klass.apply_format('1.234', @action)
+        assert_equal('123,40%', value)
+      end
+
+      it "does nothing to the value if the JavaScript method could not be determined " do
+        assert_format('2, "df"', "123.456789")
+      end
+    end
+
+    describe "AFTime_Format" do
+      before do
+        @value = '15:25:37'
+        @action[:JS] = ''
+      end
+
+      it "returns a correct JavaScript string" do
+        assert_equal('AFTime_Format(0);',
+                     @klass.af_time_format_action)
+        assert_equal('AFTime_Format(1);',
+                     @klass.af_time_format_action(format: :hh12_mm))
+      end
+
+      it "raise an error for invalid arguments" do
+        assert_raises(ArgumentError) { @klass.af_time_format_action(format: :unknown) }
+      end
+
+      def assert_format(arg_string, result_value)
+        @action[:JS] = "AFTime_Format(#{arg_string});"
+        value, text_color = @klass.apply_format(@value, @action)
+        assert_equal(result_value, value)
+        assert_nil(text_color)
+      end
+
+      it "respects the time format" do
+        ["15:25", "3:25 PM", "15:25:37", "3:25:37 PM"].each_with_index do |result, style|
+          assert_format(style, result)
+        end
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = "AFTime_Format(2 )"
+        value, = @klass.apply_format('15:34', @action)
+        assert_equal('15:34:00', value)
+      end
+
+      it "does nothing to the value if the JavaScript method could not be determined " do
+        assert_format('1, "df"', "15:25:37")
+      end
+    end
+  end
+
+  describe "calculate" do
+    before do
+      @doc = HexaPDF::Document.new
+      @form = @doc.acro_form(create: true)
+      @form.create_text_field('text')
+      @field1 = @form.create_text_field('text.1')
+      @field1.field_value = "10"
+      @field2 = @form.create_text_field('text.2')
+      @field2.field_value = "20"
+      @field3 = @form.create_text_field('text.3')
+      @field3.field_value = "30"
+    end
+
+    it "returns nil if the calculate action is not a JavaScript action" do
+      @action[:S] = :GoTo
+      assert_nil(@klass.calculate(@form, @action))
+    end
+
+    it "returns nil if the calculate action contains unknown JavaScript" do
+      @action[:JS] = 'Unknown();'
+      assert_nil(@klass.calculate(@form, @action))
+    end
+
+    describe "predefined calculations" do
+      it "returns a correct JavaScript string" do
+        assert_equal('AFSimple_Calculate("SUM", ["text.1","text.2"]);',
+                     @klass.af_simple_calculate_action(:sum, ['text.1', @field2]))
+      end
+
+      def assert_calculation(function, fields, value)
+        fields = fields.map {|field| "\"#{field.full_field_name}\"" }.join(", ")
+        @action[:JS] = "AFSimple_Calculate(\"#{function}\", new Array(#{fields}));"
+        assert_equal(value, @klass.calculate(@form, @action))
+      end
+
+      it "can sum fields" do
+        assert_calculation('SUM', [@field1, @field2, @field3], "60")
+      end
+
+      it "can average fields" do
+        assert_calculation('AVG', [@field1, @field2, @field3], "20")
+      end
+
+      it "can multiply fields" do
+        assert_calculation('PRD', [@field1, @field2, @field3], "6000")
+      end
+
+      it "can find the minimum field value" do
+        assert_calculation('MIN', [@field1, @field2, @field3], "10")
+      end
+
+      it "can find the maximum field value" do
+        assert_calculation('MAX', [@field1, @field2, @field3], "30")
+      end
+
+      it "works with floats" do
+        @field1.field_value = "10,54"
+        assert_calculation('SUM', [@field1, @field2], "30.54")
+      end
+
+      it "returns nil if a field cannot be resolved" do
+        @action[:JS] = 'AFSimple_Calculate("SUM", ["unknown"]);'
+        assert_nil(@klass.calculate(@form, @action))
+      end
+
+      it "allows omitting the trailing semicolon" do
+        @action[:JS] = 'AFSimple_Calculate("SUM", ["text.1"] )'
+        assert_equal("10", @klass.calculate(@form, @action))
+      end
+    end
+
+    describe "simplified field notation calculations" do
+      it "returns a correct JavaScript string" do
+        sfn = '(text.1 + text.2) * text.3 - text.1 / text.1 + 0 + 5.43 + 7,24'
+        assert_equal("/** BVCALC #{sfn} EVCALC **/ " \
+                     'event.value = (AFMakeNumber(getField("text.1").value) + ' \
+                     'AFMakeNumber(getField("text.2").value)) * ' \
+                     'AFMakeNumber(getField("text.3").value) - ' \
+                     'AFMakeNumber(getField("text.1").value) / ' \
+                     'AFMakeNumber(getField("text.1").value) ' \
+                     '+ 0.0 + 5.43 + 7.24',
+                     @klass.simplified_field_notation_action(@form, sfn))
+      end
+
+      it "fails if the SFN string is invalid when generating a JavaScript action string" do
+        assert_raises(ArgumentError) { @klass.simplified_field_notation_action(@form, '(test') }
+      end
+
+      def assert_calculation(sfn, value)
+        @action[:JS] = "/** BVCALC #{sfn} EVCALC **/"
+        result = @klass.calculate(@form, @action)
+        value ? assert_equal(value, result) : assert_nil(result)
+      end
+
+      it "works for additions" do
+        assert_calculation('text.1 + text.2 + text.1', "40")
+      end
+
+      it "works for substraction" do
+        assert_calculation('text.2-text\.1', "10")
+      end
+
+      it "works for multiplication" do
+        assert_calculation('text.2\* text\.1 * text\.3', "6000")
+      end
+
+      it "works for division" do
+        assert_calculation('text.2 /text\.1', "2")
+      end
+
+      it "works with parentheses" do
+        assert_calculation('(text.2 + (text.1*text.3))', "320")
+      end
+
+      it "works with numbers" do
+        assert_calculation('text.1 + 10.54 - 1,54 + 3', "22")
+      end
+
+      it "works in a more complex case" do
+        assert_calculation('(text.1 + text.2)/(text.3) * text.1', "10")
+      end
+
+      it "works with floats" do
+        @field1.field_value = "10,54"
+        assert_calculation('text.1 + text.2', "30.54")
+      end
+
+      it "fails if a referenced field is not a terminal field" do
+        assert_calculation('text + text.2', nil)
+      end
+
+      it "fails if a referenced field does not exist" do
+        assert_calculation('unknown + text.2', nil)
+      end
+
+      it "fails if parentheses don't match" do
+        assert_calculation('(text.1 + text.2', nil)
+      end
+    end
+  end
+end

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

@@ -114,6 +114,12 @@ describe HexaPDF::Type::AcroForm::TextField do
       assert(widget[:AP][:N])
     end
 
+    it "calls acro_form.on_invalid_value if the provided value is not a string" do
+      @doc.config['acro_form.on_invalid_value'] = proc {|_field, value| value.to_s }
+      @field.field_value = 10
+      assert_equal("10", @field.field_value)
+    end
+
     it "fails if the :password flag is set" do
       @field.flag(:password)
       assert_raises(HexaPDF::Error) { @field.field_value = 'test' }
@@ -197,6 +203,62 @@ describe HexaPDF::Type::AcroForm::TextField do
     end
   end
 
+  describe "set_format_action" do
+    it "applies the number format" do
+      @doc.acro_form(create: true)
+      @field.set_format_action(:number, decimals: 0)
+      assert(@field.key?(:AA))
+      assert(@field[:AA].key?(:F))
+      assert_equal('AFNumber_Format(0, 0, 0, 0, "", true);', @field[:AA][:F][:JS])
+    end
+
+    it "applies the percent format" do
+      @doc.acro_form(create: true)
+      @field.set_format_action(:percent, decimals: 0)
+      assert(@field.key?(:AA))
+      assert(@field[:AA].key?(:F))
+      assert_equal('AFPercent_Format(0, 0);', @field[:AA][:F][:JS])
+    end
+
+    it "applies the time format" do
+      @doc.acro_form(create: true)
+      @field.set_format_action(:time, format: :hh_mm_ss)
+      assert(@field.key?(:AA))
+      assert(@field[:AA].key?(:F))
+      assert_equal('AFTime_Format(2);', @field[:AA][:F][:JS])
+    end
+
+    it "fails if an unknown format action is specified" do
+      assert_raises(ArgumentError) { @field.set_format_action(:unknown) }
+    end
+  end
+
+  describe "set_calculate_action" do
+    before do
+      @form = @doc.acro_form(create: true)
+      @form.create_text_field('text1')
+      @form.create_text_field('text2')
+    end
+
+    it "sets the calculate action using AFSimple_Calculate" do
+      @field.set_calculate_action(:sum, fields: ['text1', @form.field_by_name('text2')])
+      assert(@field.key?(:AA))
+      assert(@field[:AA].key?(:C))
+      assert_equal('AFSimple_Calculate("SUM", ["text1","text2"]);', @field[:AA][:C][:JS])
+      assert_equal([@field], @form[:CO].value)
+    end
+
+    it "sets the simplified field notation calculate action" do
+      @field.set_calculate_action(:sfn, fields: "text1")
+      assert_equal('/** BVCALC text1 EVCALC **/ event.value = AFMakeNumber(getField("text1").value)',
+                   @field[:AA][:C][:JS])
+    end
+
+    it "fails if an unknown calculate action is specified" do
+      assert_raises(ArgumentError) { @field.set_calculate_action(:unknown) }
+    end
+  end
+
   describe "validation" do
     it "checks the value of the /FT field" do
       @field.delete(:FT)

data/test/hexapdf/type/test_resources.rb

@@ -146,6 +146,11 @@ describe HexaPDF::Type::Resources do
         @res.font(:test)
       end
     end
+
+    it "wraps the resulting object in the appropriate font class" do
+      @res[:Font] = {test: {Type: :Font, Subtype: :Type1}}
+      assert_kind_of(HexaPDF::Type::FontType1, @res.font(:test))
+    end
   end
 
   describe "add_font" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.40.0
+  version: 0.42.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-23 00:00:00.000000000 Z
+date: 2024-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -306,6 +306,7 @@ files:
 - examples/028-frame_mask_mode.rb
 - examples/029-composer_fallback_fonts.rb
 - examples/030-pdfa.rb
+- examples/031-acro_form_java_script.rb
 - examples/emoji-smile.png
 - examples/emoji-wink.png
 - examples/machupicchu.jpg
@@ -324,6 +325,7 @@ files:
 - lib/hexapdf/cli/modify.rb
 - lib/hexapdf/cli/optimize.rb
 - lib/hexapdf/cli/split.rb
+- lib/hexapdf/cli/usage.rb
 - lib/hexapdf/cli/watermark.rb
 - lib/hexapdf/composer.rb
 - lib/hexapdf/configuration.rb
@@ -429,6 +431,7 @@ files:
 - lib/hexapdf/font_loader/from_configuration.rb
 - lib/hexapdf/font_loader/from_file.rb
 - lib/hexapdf/font_loader/standard14.rb
+- lib/hexapdf/font_loader/variant_from_name.rb
 - lib/hexapdf/image_loader.rb
 - lib/hexapdf/image_loader/jpeg.rb
 - lib/hexapdf/image_loader/pdf.rb
@@ -477,6 +480,7 @@ files:
 - lib/hexapdf/type/acro_form/choice_field.rb
 - lib/hexapdf/type/acro_form/field.rb
 - lib/hexapdf/type/acro_form/form.rb
+- lib/hexapdf/type/acro_form/java_script_actions.rb
 - lib/hexapdf/type/acro_form/signature_field.rb
 - lib/hexapdf/type/acro_form/text_field.rb
 - lib/hexapdf/type/acro_form/variable_text_field.rb
@@ -698,6 +702,7 @@ files:
 - test/hexapdf/font_loader/test_from_configuration.rb
 - test/hexapdf/font_loader/test_from_file.rb
 - test/hexapdf/font_loader/test_standard14.rb
+- test/hexapdf/font_loader/test_variant_from_name.rb
 - test/hexapdf/image_loader/test_jpeg.rb
 - test/hexapdf/image_loader/test_pdf.rb
 - test/hexapdf/image_loader/test_png.rb
@@ -748,6 +753,7 @@ files:
 - test/hexapdf/type/acro_form/test_choice_field.rb
 - test/hexapdf/type/acro_form/test_field.rb
 - test/hexapdf/type/acro_form/test_form.rb
+- test/hexapdf/type/acro_form/test_java_script_actions.rb
 - test/hexapdf/type/acro_form/test_signature_field.rb
 - test/hexapdf/type/acro_form/test_text_field.rb
 - test/hexapdf/type/acro_form/test_variable_text_field.rb