hexapdf 0.10.0 → 0.11.0

data/lib/hexapdf/document/pages.rb

@@ -75,10 +75,10 @@ module HexaPDF
       # used to change the orientation to :landscape if needed.
       def add(page = nil, orientation: :portrait)
         if page.kind_of?(Array)
-          page = @document.add(Type: :Page, MediaBox: page)
+          page = @document.add({Type: :Page, MediaBox: page})
         elsif page.kind_of?(Symbol)
           box = Type::Page.media_box(page, orientation: orientation)
-          page = @document.add(Type: :Page, MediaBox: box)
+          page = @document.add({Type: :Page, MediaBox: box})
         end
         @document.catalog.pages.add_page(page)
       end

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -275,7 +275,7 @@ module HexaPDF
           dict[:StmF] = dict[:StrF] = :StdCF
         end
 
-        if dict[:R] <= 4 && !document.trailer[:ID].kind_of?(Array)
+        if dict[:R] <= 4 && !document.trailer[:ID].kind_of?(PDFArray)
           document.trailer.set_random_id
         end
 
@@ -310,7 +310,7 @@ module HexaPDF
         elsif ![2, 3, 4, 6].include?(dict[:R])
           raise(HexaPDF::UnsupportedEncryptionError,
                 "Invalid /R value for standard security handler")
-        elsif dict[:R] <= 4 && !document.trailer[:ID].kind_of?(Array)
+        elsif dict[:R] <= 4 && !document.trailer[:ID].kind_of?(PDFArray)
           raise(HexaPDF::EncryptionError,
                 "Document ID for needed for decryption")
         end

data/lib/hexapdf/font/cmap/parser.rb

@@ -95,7 +95,7 @@ module HexaPDF
           when :Supplement
             cmap.supplement = value if value.kind_of?(Integer)
           when :CMapName
-            cmap.name = value.to_s.force_encoding(::Encoding::UTF_8) if value.kind_of?(Symbol)
+            cmap.name = value.to_s.dup.force_encoding(::Encoding::UTF_8) if value.kind_of?(Symbol)
           when :WMode
             cmap.wmode = value
           end

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

@@ -76,8 +76,8 @@ module HexaPDF
 
           # Apple Mac style information.
           attr_accessor :mac_style
-          bit_field(:mac_style, bold: 0, italic: 1, underline: 2, outline: 3, shadow: 4,
-                    condensed: 5, extended: 6)
+          bit_field(:mac_style, {bold: 0, italic: 1, underline: 2, outline: 3, shadow: 4,
+                                 condensed: 5, extended: 6})
 
           # The smallest readable size in pixels per em for this font.
           attr_accessor :smallest_readable_size

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

@@ -65,8 +65,8 @@ module HexaPDF
 
           # Characteristics and properties of this font.
           attr_accessor :type
-          bit_field(:type, restricted_license_embedding: 1, preview_and_print_embedding: 2,
-                    editable_embedding: 3, no_subsetting: 8, bitmap_embedding_only: 9)
+          bit_field(:type, {restricted_license_embedding: 1, preview_and_print_embedding: 2,
+                            editable_embedding: 3, no_subsetting: 8, bitmap_embedding_only: 9})
 
           # Recommended horizontal size in pixels for subscripts
           attr_accessor :subscript_x_size
@@ -112,8 +112,8 @@ module HexaPDF
 
           # Information concerning the nature of the font patterns.
           attr_accessor :selection
-          bit_field(:selection, italic: 0, underscore: 1, negative: 2, outlined: 3, strikeout: 4,
-                                bold: 5, regular: 6, use_typo_metrics: 7, wws: 8, oblique: 9)
+          bit_field(:selection, {italic: 0, underscore: 1, negative: 2, outlined: 3, strikeout: 4,
+                                 bold: 5, regular: 6, use_typo_metrics: 7, wws: 8, oblique: 9})
 
           # The minimum Unicode index in this font.
           attr_accessor :first_char_index

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -209,15 +209,15 @@ module HexaPDF
       #
       # See: #complete_font_dict
       def build_font_dict
-        fd = @document.add(Type: :FontDescriptor,
-                           FontName: @wrapped_font.font_name.intern,
-                           FontWeight: @wrapped_font.weight,
-                           Flags: 0,
-                           FontBBox: @wrapped_font.bounding_box.map {|m| m * scaling_factor },
-                           ItalicAngle: @wrapped_font.italic_angle || 0,
-                           Ascent: @wrapped_font.ascender * scaling_factor,
-                           Descent: @wrapped_font.descender * scaling_factor,
-                           StemV: @wrapped_font.dominant_vertical_stem_width)
+        fd = @document.add({Type: :FontDescriptor,
+                            FontName: @wrapped_font.font_name.intern,
+                            FontWeight: @wrapped_font.weight,
+                            Flags: 0,
+                            FontBBox: @wrapped_font.bounding_box.map {|m| m * scaling_factor },
+                            ItalicAngle: @wrapped_font.italic_angle || 0,
+                            Ascent: @wrapped_font.ascender * scaling_factor,
+                            Descent: @wrapped_font.descender * scaling_factor,
+                            StemV: @wrapped_font.dominant_vertical_stem_width})
         if @wrapped_font[:'OS/2'].version >= 2
           fd[:CapHeight] = @wrapped_font.cap_height * scaling_factor
           fd[:XHeight] = @wrapped_font.x_height * scaling_factor
@@ -242,13 +242,13 @@ module HexaPDF
           @wrapped_font[:'OS/2'].selection_include?(:oblique)
         fd.flag(:symbolic)
 
-        cid_font = @document.add(Type: :Font, Subtype: :CIDFontType2,
-                                 BaseFont: fd[:FontName], FontDescriptor: fd,
-                                 CIDSystemInfo: {Registry: "Adobe", Ordering: "Identity",
-                                                 Supplement: 0},
-                                 CIDToGIDMap: :Identity)
-        @document.add(Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
-                      Encoding: :"Identity-H", DescendantFonts: [cid_font])
+        cid_font = @document.add({Type: :Font, Subtype: :CIDFontType2,
+                                  BaseFont: fd[:FontName], FontDescriptor: fd,
+                                  CIDSystemInfo: {Registry: "Adobe", Ordering: "Identity",
+                                                  Supplement: 0},
+                                  CIDToGIDMap: :Identity})
+        @document.add({Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
+                       Encoding: :"Identity-H", DescendantFonts: [cid_font]})
       end
 
       # Makes sure that the Type0 font object as well as the CIDFont object contain all the needed

data/lib/hexapdf/font/type1_wrapper.rb

@@ -146,7 +146,7 @@ module HexaPDF
       def glyph(name)
         @name_to_glyph[name] ||=
           begin
-            str = Encoding::GlyphList.name_to_unicode(name, @zapf_dingbats_opt)
+            str = Encoding::GlyphList.name_to_unicode(name, **@zapf_dingbats_opt)
             if @wrapped_font.metrics.character_metrics.key?(name)
               Glyph.new(@wrapped_font, name, str)
             else
@@ -160,7 +160,7 @@ module HexaPDF
         str.codepoints.map! do |c|
           @codepoint_to_glyph[c] ||=
             begin
-              name = Encoding::GlyphList.unicode_to_name(+'' << c, @zapf_dingbats_opt)
+              name = Encoding::GlyphList.unicode_to_name(+'' << c, **@zapf_dingbats_opt)
               name = +"u" << c.to_s(16).rjust(6, '0') if name == :'.notdef'
               glyph(name)
             end
@@ -194,25 +194,25 @@ module HexaPDF
       # Generic in the sense that no information regarding the encoding or widths is included.
       def build_font_dict
         unless defined?(@fd)
-          @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.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.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
         end
 
-        @document.wrap(Type: :Font, Subtype: :Type1,
-                       BaseFont: @wrapped_font.font_name.intern, Encoding: :WinAnsiEncoding,
-                       FontDescriptor: @fd)
+        @document.wrap({Type: :Font, Subtype: :Type1,
+                        BaseFont: @wrapped_font.font_name.intern, Encoding: :WinAnsiEncoding,
+                        FontDescriptor: @fd})
       end
 
       # Array of valid encoding names in PDF

data/lib/hexapdf/font_loader.rb

@@ -60,6 +60,8 @@ module HexaPDF
   # variant:: The font variant that should be used (e.g. +:none+, +:bold+, +:italic+,
   #           +:bold_italic+).
   #
+  # Optionally, a font loader can provide a method +available_fonts(document)+ that returns a hash
+  # where the keys are the font names and the values are the variants of all the provided fonts.
   #
   # == Font Wrappers
   #

data/lib/hexapdf/font_loader/from_configuration.rb

@@ -69,6 +69,11 @@ module HexaPDF
         FromFile.call(document, file, subset: subset)
       end
 
+      # Returns a hash of the form 'font_name => [variants, ...]' of the configured fonts.
+      def self.available_fonts(document)
+        document.config['font.map'].transform_values(&:keys)
+      end
+
     end
 
   end

data/lib/hexapdf/font_loader/standard14.rb

@@ -95,6 +95,11 @@ module HexaPDF
         HexaPDF::Font::Type1Wrapper.new(document, font, custom_encoding: custom_encoding)
       end
 
+      # Returns a hash of the form 'font_name => [variants, ...]' of the standard 14 PDF fonts.
+      def self.available_fonts(_document)
+        MAPPING.transform_values(&:keys)
+      end
+
     end
 
   end

data/lib/hexapdf/image_loader/png.rb

@@ -295,7 +295,7 @@ module HexaPDF
           Columns: dict[:Width],
         }
         stream_opts = (from_indexed ? {} : {filter: :FlateDecode, decode_parms: decode_parms})
-        stream = HexaPDF::StreamData.new(lambda { mask_data }, stream_opts)
+        stream = HexaPDF::StreamData.new(lambda { mask_data }, **stream_opts)
 
         smask_dict = {
           Type: :XObject,

data/lib/hexapdf/layout/box.rb

@@ -57,7 +57,7 @@ module HexaPDF
       # 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)
+        style = Style.new(**style)
         if content_box
           width += style.padding.left + style.padding.right +
             style.border.width.left + style.border.width.right
@@ -96,7 +96,7 @@ module HexaPDF
       def initialize(width: 0, height: 0, style: Style.new, &block)
         @width = @initial_width = width
         @height = @initial_height = height
-        @style = (style.kind_of?(Style) ? style : Style.new(style))
+        @style = (style.kind_of?(Style) ? style : Style.new(**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, &:unused_draw_block)
         @image = image
       end
 

data/lib/hexapdf/layout/style.rb

@@ -523,7 +523,7 @@ module HexaPDF
       # Example:
       #   Style.new(font_size: 15, align: :center, valign: center)
       def initialize(**properties)
-        update(properties)
+        update(**properties)
         @scaled_item_widths = {}
       end
 
@@ -624,7 +624,8 @@ module HexaPDF
       #   text_rendering_mode(mode = nil)
       #
       # The text rendering mode, i.e. whether text should be filled, stroked, clipped, invisible or
-      # a combination thereof, defaults to :fill.
+      # a combination thereof, defaults to :fill. The returned values is always a normalized text
+      # rendering mode value.
       #
       # See: HexaPDF::Content::Canvas#text_rendering_mode
 
@@ -698,7 +699,8 @@ module HexaPDF
       # :call-seq:
       #   stroke_cap_style(style = nil)
       #
-      # The line cap style used for stroking operations (e.g. text outlines), defaults to :butt.
+      # The line cap style used for stroking operations (e.g. text outlines), defaults to :butt. The
+      # returned values is always a normalized line cap style value.
       #
       # See: HexaPDF::Content::Canvas#line_cap_style
 
@@ -708,6 +710,7 @@ module HexaPDF
       #   stroke_join_style(style = nil)
       #
       # The line join style used for stroking operations (e.g. text outlines), defaults to :miter.
+      # The returned values is always a normalized line joine style value.
       #
       # See: HexaPDF::Content::Canvas#line_join_style
 
@@ -839,6 +842,8 @@ module HexaPDF
       #          the left/right can still be used. The position hint specifies where the box should
       #          float.
       #
+      # :flow:: Flows the content of the box inside the frame around objects.
+      #
       # :absolute:: Position the box at an absolute position relative to the frame. The coordinates
       #             are given via the position hint.
 
@@ -877,41 +882,62 @@ module HexaPDF
         [:horizontal_scaling, 100],
         [:text_rise, 0],
         [:font_features, {}],
-        [:text_rendering_mode, :fill],
-        [:subscript, false, "value; superscript(false) if superscript"],
-        [:superscript, false, "value; subscript(false) if subscript"],
-        [:underline, false],
-        [:strikeout, false],
+        [:text_rendering_mode, "Content::TextRenderingMode::FILL",
+         setter: "Content::TextRenderingMode.normalize(value)"],
+        [:subscript, false,
+         setter: "value; superscript(false) if superscript",
+         valid_values: [true, false]],
+        [:superscript, false,
+         setter: "value; subscript(false) if subscript",
+         valid_values: [true, false]],
+        [:underline, false, valid_values: [true, false]],
+        [:strikeout, false, valid_values: [true, false]],
         [:fill_color, "default_color"],
         [:fill_alpha, 1],
         [:stroke_color, "default_color"],
         [:stroke_alpha, 1],
         [:stroke_width, 1],
-        [:stroke_cap_style, :butt],
-        [:stroke_join_style, :miter],
+        [:stroke_cap_style, "Content::LineCapStyle::BUTT_CAP",
+         setter: "Content::LineCapStyle.normalize(value)"],
+        [:stroke_join_style, "Content::LineJoinStyle::MITER_JOIN",
+         setter: "Content::LineJoinStyle.normalize(value)"],
         [:stroke_miter_limit, 10.0],
         [:stroke_dash_pattern, "Content::LineDashPattern.new",
-         "Content::LineDashPattern.normalize(value, phase)", ", phase = 0"],
-        [:align, :left],
-        [:valign, :top],
+         setter: "Content::LineDashPattern.normalize(value, phase)", extra_args: ", phase = 0"],
+        [:align, :left, valid_values: [:left, :center, :right, :justify]],
+        [:valign, :top, valid_values: [:top, :center, :bottom]],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         "LineSpacing.new(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value)",
-         ", extra_arg = nil"],
-        [:last_line_gap, false],
+         setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
+         extra_args: ", extra_arg = nil"],
+        [:last_line_gap, false, valid_values: [true, false]],
         [:background_color, nil],
-        [:padding, "Quad.new(0)", "Quad.new(value)"],
-        [:margin, "Quad.new(0)", "Quad.new(value)"],
-        [:border, "Border.new", "Border.new(value)"],
-        [:overlays, "Layers.new", "Layers.new(value)"],
-        [:underlays, "Layers.new", "Layers.new(value)"],
-        [:position, :default],
+        [:padding, "Quad.new(0)", setter: "Quad.new(value)"],
+        [:margin, "Quad.new(0)", setter: "Quad.new(value)"],
+        [:border, "Border.new", setter: "Border.new(**value)"],
+        [:overlays, "Layers.new", setter: "Layers.new(value)"],
+        [:underlays, "Layers.new", setter: "Layers.new(value)"],
+        [:position, :default, valid_values: [:default, :float, :flow, :absolute]],
         [:position_hint, nil],
-      ].each do |name, default, setter = "value", extra_args = ""|
+      ].each do |name, default, options = {}|
         default = default.inspect unless default.kind_of?(String)
+        setter = options.delete(:setter) || "value"
+        extra_args = options.delete(:extra_args) || ""
+        valid_values = options.delete(:valid_values)
+        raise ArgumentError, "Invalid keywords: #{options.keys.join(', ')}" unless options.empty?
+        valid_values_const = "#{name}_valid_values".upcase
+        const_set(valid_values_const, valid_values)
         module_eval(<<-EOF, __FILE__, __LINE__ + 1)
           def #{name}(value = UNSET#{extra_args})
-            value == UNSET ? (@#{name} ||= #{default}) : (@#{name} = #{setter}; self)
+            if value == UNSET
+              @#{name} ||= #{default}
+            elsif #{valid_values_const} && !#{valid_values_const}.include?(value)
+              raise ArgumentError, "\#{value.inspect} is not a valid #{name} value " \\
+                "(\#{#{valid_values_const}.map(&:inspect).join(', ')})"
+            else
+              @#{name} = #{setter}
+              self
+            end
           end
           def #{name}?
             defined?(@#{name})

data/lib/hexapdf/layout/text_box.rb

@@ -48,7 +48,7 @@ module HexaPDF
       # Creates a new TextBox object with the given inline items (e.g. TextFragment and InlineBox
       # objects).
       def initialize(items, **kwargs)
-        super(kwargs)
+        super(**kwargs)
         @tl = TextLayouter.new(style)
         @items = items
         @result = nil

data/lib/hexapdf/layout/text_fragment.rb

@@ -65,7 +65,7 @@ module HexaPDF
       # 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)
+        style = (style.nil? ? Style.new(**options) : style)
         fragment = new(style.font.decode_utf8(text), style)
         TextShaper.new.shape_text(fragment)
       end
@@ -106,7 +106,7 @@ module HexaPDF
       # The argument +style+ can either be a Style object or a hash of style options.
       def initialize(items, style)
         @items = items
-        @style = (style.kind_of?(Style) ? style : Style.new(style))
+        @style = (style.kind_of?(Style) ? style : Style.new(**style))
       end
 
       # The precision used to determine whether two floats represent the same value.

data/lib/hexapdf/layout/text_layouter.rb

@@ -173,12 +173,6 @@ module HexaPDF
           :penalty
         end
 
-        # Singleton object describing a Penalty for a mandatory paragraph break.
-        MandatoryParagraphBreak = new(PARAGRAPH_BREAK)
-
-        # Singleton object describing a Penalty for a mandatory line break.
-        MandatoryLineBreak = new(LINE_BREAK)
-
         # Singleton object describing a Penalty for a prohibited break.
         ProhibitedBreak = new(Penalty::INFINITY)
 
@@ -218,6 +212,7 @@ module HexaPDF
         def self.call(items)
           result = []
           glues = {}
+          penalties = {}
           items.each do |item|
             if item.kind_of?(InlineBox)
               result << Box.new(item)
@@ -246,13 +241,20 @@ module HexaPDF
                       Glue.new(TextFragment.new([glyph].freeze, item.style))
                     result << glues[item.style]
                   when "\n", "\v", "\f", "\u{85}", "\u{2029}"
-                    result << Penalty::MandatoryParagraphBreak
+                    penalties[item.style] ||=
+                      Penalty.new(Penalty::PARAGRAPH_BREAK, 0,
+                                  item: TextFragment.new([].freeze, item.style))
+                    result << penalties[item.style]
                   when "\u{2028}"
-                    result << Penalty::MandatoryLineBreak
+                    result << Penalty.new(Penalty::LINE_BREAK, 0,
+                                          item: TextFragment.new([].freeze, item.style))
                   when "\r"
                     if !item.items[i + 1] || item.items[i + 1].kind_of?(Numeric) ||
                         item.items[i + 1].str != "\n"
-                      result << Penalty::MandatoryParagraphBreak
+                      penalties[item.style] ||=
+                        Penalty.new(Penalty::PARAGRAPH_BREAK, 0,
+                                    item: TextFragment.new([].freeze, item.style))
+                      result << penalties[item.style]
                     end
                   when '-'
                     result << Penalty::Standard
@@ -386,6 +388,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
+                add_box_item(item.item) if item.item
                 break unless yield(create_unjustified_line, item)
                 reset_after_line_break(index + 1)
               elsif item.penalty >= Penalty::INFINITY
@@ -455,6 +458,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
+                add_box_item(item.item) if item.item
                 break unless (action = yield(create_unjustified_line, item))
                 reset_after_line_break_variable_width(index + 1, true, action)
               elsif item.penalty >= Penalty::INFINITY
@@ -646,7 +650,7 @@ module HexaPDF
       # The +style+ argument can either be a Style object or a hash of style options. See #style for
       # the properties that are used by the layouter.
       def initialize(style = Style.new)
-        @style = (style.kind_of?(Style) ? style : Style.new(style))
+        @style = (style.kind_of?(Style) ? style : Style.new(**style))
       end
 
       # :call-seq: