hexapdf 0.1.0 → 0.2.0

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

@@ -56,13 +56,13 @@ module HexaPDF
           #
           # A preferred table is always a table mapping Unicode characters.
           def preferred_table
-            tables.select(&:unicode?).sort {|a, b| a.format <=> b.format}.last
+            tables.select(&:unicode?).sort_by(&:format).last
           end
 
           private
 
           def parse_table #:nodoc:
-            @version, num_tables  = read_formatted(4, 'n2')
+            @version, num_tables = read_formatted(4, 'n2')
             @tables = []
             handle_unknown = font.config['font.true_type.cmap.unknown_format']
 
@@ -90,11 +90,6 @@ module HexaPDF
             end.compact!
           end
 
-          def load_default #:nodoc:
-            @version = 0
-            @tables = []
-          end
-
         end
 
       end

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

@@ -276,11 +276,7 @@ module HexaPDF
 
               code_map = Hash.new do |h, code|
                 i = end_codes.bsearch_index {|c| c >= code}
-                if i && start_codes[i] <= code
-                  glyph_id = compute_glyph_id.call(i, code)
-                else
-                  glyph_id = 0
-                end
+                glyph_id = (i && start_codes[i] <= code ? compute_glyph_id.call(i, code) : 0)
                 h[code] = glyph_id unless glyph_id == 0
               end
 
@@ -355,7 +351,7 @@ module HexaPDF
             #
             # It is assumed that the first twelve bytes of the subtable have already been consumed.
             def self.parse(io, _length)
-              mapper(io.read(4).unpack('N').first.times.map { io.read(12).unpack('N3') })
+              mapper(Array.new(io.read(4).unpack('N').first) { io.read(12).unpack('N3') })
             end
 
             # The parameter +groups+ is an array containing [start_code, end_code, start_glyph_id]

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

@@ -79,11 +79,6 @@ module HexaPDF
             end
           end
 
-          def load_default #:nodoc:
-            @tag = 'true'.b
-            @tables = {}
-          end
-
         end
 
       end

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

@@ -127,14 +127,10 @@ module HexaPDF
           # The mapping from glyph ID to Glyph object or +nil+ (if the glyph has no outline).
           attr_accessor :glyphs
 
-          # Returns the Glyph object for the given glyph ID, or +nil+ if it has no outline (e.g. the
-          # space character).
+          # Returns the Glyph object for the given glyph ID. If the glyph has no outline (e.g. the
+          # space character), an empty Glyph object is returned.
           def [](glyph_id)
-            if @glyphs.key?(glyph_id)
-              return @glyphs[glyph_id]
-            elsif !directory_entry
-              return nil
-            end
+            return @glyphs[glyph_id] if @glyphs.key?(glyph_id)
 
             offset = font[:loca].offset(glyph_id)
             length = font[:loca].length(glyph_id)
@@ -154,10 +150,6 @@ module HexaPDF
             @glyphs = {}
           end
 
-          def load_default #:nodoc:
-            @glyphs = {}
-          end
-
         end
 
       end

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

@@ -98,8 +98,6 @@ module HexaPDF
           #
           # See: Table#checksum_valid?
           def checksum_valid?
-            super unless directory_entry
-
             data = with_io_pos(directory_entry.offset) { io.read(directory_entry.length) }
             data[8, 4] = 0.chr * 4
             directory_entry.checksum == self.class.calculate_checksum(data)
@@ -125,16 +123,6 @@ module HexaPDF
             end
           end
 
-          def load_default #:nodoc:
-            @version = 1.to_r
-            @font_revision = 1.to_r
-            @checksum_adjustment = @flags = @mac_style = @smallest_readable_size =
-              @font_direction_hint =  @index_to_loc_format = 0
-            @units_per_em = 64
-            @created = @modified = Time.now
-            @bbox = [0, 0, 0, 0]
-          end
-
         end
 
       end

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

@@ -94,13 +94,6 @@ module HexaPDF
               @caret_offset, @num_of_long_hor_metrics = read_formatted(32, 's>3ns>6x10n')
           end
 
-          def load_default #:nodoc:
-            @version = 1.to_r
-            @ascent = @descent = @line_gap = @advance_width_max = @min_left_side_bearing =
-              @min_right_side_bearing = @x_max_extent = @caret_slope_rise = @caret_slope_run =
-              @caret_offset = @num_of_long_hor_metrics = 0
-          end
-
         end
 
       end

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

@@ -60,17 +60,13 @@ module HexaPDF
 
           def parse_table #:nodoc:
             nr_entries = font[:hhea].num_of_long_hor_metrics
-            @horizontal_metrics = nr_entries.times.map { Metric.new(*read_formatted(4, 'ns>')) }
+            @horizontal_metrics = Array.new(nr_entries) { Metric.new(*read_formatted(4, 'ns>')) }
             last_advance_width = @horizontal_metrics[-1].advance_width
             read_formatted(directory_entry.length - 4 * nr_entries, 's>*').map do |lsb|
               @horizontal_metrics << Metric.new(last_advance_width, lsb)
             end
           end
 
-          def load_default #:nodoc:
-            @horizontal_metrics = []
-          end
-
         end
 
       end

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

@@ -67,10 +67,6 @@ module HexaPDF
             @offsets.map! {|offset| offset * 2} if entry_size == 0
           end
 
-          def load_default #:nodoc:
-            @offsets = []
-          end
-
         end
 
       end

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

@@ -96,14 +96,6 @@ module HexaPDF
               @max_component_depth = read_formatted(directory_entry.length - 4, 'n14')
           end
 
-          def load_default #:nodoc:
-            @version = 1.to_r
-            @num_glyphs = @max_points = @max_contours = @max_component_points =
-              @max_component_contours = @max_twilight_points = @max_storage = @max_function_defs =
-              @max_instruction_defs = @max_stack_elements = @max_size_of_instructions =
-              @max_component_elements = @max_component_depth = 0
-          end
-
         end
 
       end

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

@@ -68,7 +68,7 @@ module HexaPDF
             postscript_cid_name: 20,
             wws_family: 21,
             wws_subfamily: 22,
-          }
+          }.freeze
 
           # Contains the information for a Name Record.
           #
@@ -167,14 +167,6 @@ module HexaPDF
             @records[name_or_id.kind_of?(Symbol) ? NAME_MAP[name_or_id] : name_or_id]
           end
 
-          # Adds a new record for the given name identifier (either a symbol or an ID).
-          #
-          # The optional platform, encoding and language IDs are preset to represent the text as
-          # English in Mac Roman encoding.
-          def add(name_or_id, text, platform_id: 1, encoding_id: 0, language_id: 0)
-            self[name_or_id] << Record.new(text, platform_id, encoding_id, language_id)
-          end
-
           private
 
           def parse_table #:nodoc:
@@ -184,10 +176,10 @@ module HexaPDF
             @records = Hash.new {|h, k| h[k] = Records.new}
             @language_tags = {}
 
-            record_rows = count.times.map { read_formatted(12, 'n6') }
+            record_rows = Array.new(count) { read_formatted(12, 'n6') }
             if @format == 1
               count = read_formatted(2, 'n').first
-              language_rows = count.times.map { read_formatted(4, 'n2') }
+              language_rows = Array.new(count) { read_formatted(4, 'n2') }
             end
 
             record_rows.each do |pid, eid, lid, nid, length, offset|
@@ -204,12 +196,6 @@ module HexaPDF
             end
           end
 
-          def load_default #:nodoc:
-            @format = 0
-            @records = Hash.new {|h, k| h[k] = Records.new}
-            @language_tags = {}
-          end
-
         end
 
       end

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

@@ -178,20 +178,6 @@ module HexaPDF
               read_formatted(directory_entry.length - 58, 'a4n3s>3n2Q>s>2n5')
           end
 
-          def load_default #:nodoc:
-            @version = 5
-            @panose = ''.b
-            @vendor_id = '    '.b
-            @x_avg_char_width = @weight_class = @width_class = @type = @subscript_x_size =
-              @subscript_y_size = @subscript_x_offset = @subscript_y_offset = @superscript_x_size =
-              @superscript_y_size = @superscript_x_offset = @superscript_y_offset =
-              @strikeout_size = @strikeout_position = @family_class = @unicode_range = @selection =
-              @first_char_index = @last_char_index = @typo_ascender = @typo_descender =
-              @typo_line_gap = @win_ascent = @win_descent = @code_page_range = @x_height =
-              @cap_height = @default_char = @break_char = @max_context = @lower_point_size =
-              @upper_point_size  = 0
-          end
-
         end
 
       end

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

@@ -106,14 +106,6 @@ module HexaPDF
                            end
           end
 
-          def load_default #:nodoc:
-            @format = 1.to_r
-            @italic_angle = 0.to_r
-            @underline_position = @underline_thickness = @is_fixed_pitch = @min_mem_type42 =
-              @max_mem_type42 = @min_mem_type1 = @max_mem_type1 = 0
-            @glyph_names = {}
-          end
-
 
           # 'post' table format 1
           module Format1

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -203,7 +203,7 @@ module HexaPDF
         cid_font[:DW] = default_width = glyph(3).width
 
         glyphs = @encoded_glyphs.keys.reject {|g| g.width == default_width}.sort_by(&:id)
-        if glyphs.length > 0
+        unless glyphs.empty?
           cid_font[:W] = widths = []
           last_id = -10
           cur_widths = nil

data/lib/hexapdf/font/type1.rb

@@ -36,8 +36,8 @@ module HexaPDF
 
     # This module provides classes for handling Type1 fonts.
     #
-    # Note that not all parts of the file format are supported, only those needed for using the
-    # fonts with PDF.
+    # Note that not all parts of the various file formats are supported, only those needed for using
+    # the fonts with PDF.
     module Type1
 
       autoload(:AFMParser, 'hexapdf/font/type1/afm_parser')

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

@@ -50,6 +50,7 @@ module HexaPDF
       # * full_name
       # * family_name
       # * weight
+      # * weight_class
       # * font_bbox
       # * italic_angle
       # * ascender
@@ -71,7 +72,7 @@ module HexaPDF
         attr_reader :metrics
 
         def_delegators :@metrics, :font_name, :full_name, :family_name
-        def_delegators :@metrics, :weight, :bounding_box, :italic_angle
+        def_delegators :@metrics, :weight, :weight_class, :bounding_box, :italic_angle
         def_delegators :@metrics, :ascender, :descender, :cap_height, :x_height
         def_delegators :@metrics, :dominant_horizontal_stem_width, :dominant_vertical_stem_width
 

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

@@ -56,7 +56,7 @@ module HexaPDF
         # A string indicating the default encoding used for the font.
         attr_accessor :encoding_scheme
 
-        # Weight of the font.
+        # A string describing the weight of the font.
         attr_accessor :weight
 
         # The font bounding box as array of four numbers, specifying the x- and y-coordinates of the
@@ -110,6 +110,15 @@ module HexaPDF
           @kerning_pairs = Hash.new {|h, k| h[k] = {}}
         end
 
+        WEIGHT_NAME_TO_NUMBER = {'Bold' => 700, 'Medium' => 500, 'Roman' => 400}.freeze #:nodoc:
+
+        # Returns the weight of the font as a number.
+        #
+        # The return value 0 is used if the weight class cannot be determined.
+        def weight_class
+          WEIGHT_NAME_TO_NUMBER.fetch(weight, 0)
+        end
+
       end
 
     end

data/lib/hexapdf/font/type1_wrapper.rb

@@ -150,6 +150,7 @@ module HexaPDF
         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,
@@ -169,7 +170,7 @@ module HexaPDF
       end
 
       # Array of valid encoding names in PDF
-      VALID_ENCODING_NAMES = [:WinAnsiEncoding, :MacRomanEncoding, :MacExpertEncoding]
+      VALID_ENCODING_NAMES = [:WinAnsiEncoding, :MacRomanEncoding, :MacExpertEncoding].freeze
 
       # Completes the font dictionary by filling in the values that depend on the used encoding.
       def complete_font_dict

data/lib/hexapdf/font_loader/from_configuration.rb

@@ -60,7 +60,7 @@ module HexaPDF
           raise HexaPDF::Error, "The configured font file #{file} does not exist"
         end
 
-        font = HexaPDF::Font::TrueType::Font.new(io: File.open(file))
+        font = HexaPDF::Font::TrueType::Font.new(File.open(file))
         HexaPDF::Font::TrueTypeWrapper.new(document, font)
       end
 

data/lib/hexapdf/font_loader/standard14.rb

@@ -66,7 +66,7 @@ module HexaPDF
         'ZapfDingbats' => {
           none: 'ZapfDingbats',
         },
-      }
+      }.freeze
 
       # Creates a new font object backed by the AFM font metrics read from the file or IO stream.
       #

data/lib/hexapdf/image_loader/jpeg.rb

@@ -49,7 +49,7 @@ module HexaPDF
       # object.
       #
       # See: ITU T.81 B1.1.3
-      SOF_MARKERS = [0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF]
+      SOF_MARKERS = [0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF].freeze
 
       # Adobe uses the marker 0xEE (APPE) for its purposes. We need to use it for determinig
       # whether to invert the colors for CMYK/YCCK images or not (Adobe does this...).

data/lib/hexapdf/image_loader/pdf.rb

@@ -79,7 +79,7 @@ module HexaPDF
                else
                  HexaPDF::Document.new(io: file_or_io)
                end
-        form = idoc.pages.page(0).to_form_xobject
+        form = idoc.pages[0].to_form_xobject
         document.add(document.import(form))
       end
 

data/lib/hexapdf/image_loader/png.rb

@@ -78,10 +78,10 @@ module HexaPDF
         1 => Content::RenderingIntent::RELATIVE_COLORIMETRIC,
         2 => Content::RenderingIntent::SATURATION,
         3 => Content::RenderingIntent::ABSOLUTE_COLORIMETRIC,
-      }
+      }.freeze
 
       # The primary chromaticities and white point used by the sRGB specification.
-      SRGB_CHRM = [0.3127, 0.329, 0.64, 0.33, 0.3, 0.6, 0.15, 0.06]
+      SRGB_CHRM = [0.3127, 0.329, 0.64, 0.33, 0.3, 0.6, 0.15, 0.06].freeze
 
       # :call-seq:
       #   PNG.handles?(filename)     -> true or false

data/lib/hexapdf/object.rb

@@ -121,7 +121,7 @@ module HexaPDF
     include Comparable
 
     # A list of classes whose objects cannot be duplicated.
-    NOT_DUPLICATABLE_CLASSES = [NilClass, FalseClass, TrueClass, Symbol, Integer, Float]
+    NOT_DUPLICATABLE_CLASSES = [NilClass, FalseClass, TrueClass, Symbol, Integer, Float].freeze
 
     # :call-seq:
     #   HexaPDF::Object.deep_copy(object)    -> copy
@@ -134,7 +134,7 @@ module HexaPDF
       when Array
         object.map {|o| deep_copy(o)}
       when HexaPDF::Object
-        (object.indirect? ? object : deep_copy(object.value))
+        (object.indirect? || object.must_be_indirect? ? object : deep_copy(object.value))
       when HexaPDF::Reference
         object
       when *NOT_DUPLICATABLE_CLASSES
@@ -265,10 +265,10 @@ module HexaPDF
     # *Note*: Even if the return value is +true+ there may be problems since HexaPDF doesn't
     # currently implement the full PDF spec. However, if the return value is +false+, there is
     # certainly a problem!
-    def validate(auto_correct: true, &block)
+    def validate(auto_correct: true)
       catch do |catch_tag|
         perform_validation do |msg, correctable|
-          block.call(msg, correctable) if block
+          yield(msg, correctable) if block_given?
           throw(catch_tag, false) unless auto_correct && correctable
         end
         true
@@ -350,12 +350,25 @@ module HexaPDF
     #       self.value = {}
     #     end
     #   end
-    def perform_validation
+    def perform_validation(&block)
       # Validate that the object is indirect if #must_be_indirect? is +true+.
       if must_be_indirect? && !indirect?
         yield("Object must be an indirect object", true)
         document.add(self)
       end
+
+      validate_nested(value, &block)
+    end
+
+    # Validates all nested values of the object, i.e. values inside collection objects.
+    def validate_nested(obj, &block)
+      if obj.kind_of?(HexaPDF::Object) && !obj.indirect?
+        obj.validate(&block)
+      elsif obj.kind_of?(Hash)
+        obj.each_value {|val| validate_nested(val, &block)}
+      elsif obj.kind_of?(Array)
+        obj.each {|val| validate_nested(val, &block)}
+      end
     end
 
   end