prawn 0.11.1.pre → 0.11.1

data/vendor/ttfunk/lib/ttfunk/resource_file.rb

@@ -1,78 +0,0 @@
-module TTFunk
-  class ResourceFile
-    attr_reader :map
-
-    def self.open(path)
-      ::File.open(path, "rb") do |io|
-        file = new(io)
-        yield file
-      end
-    end
-
-    def initialize(io)
-      @io = io
-
-      data_offset, map_offset, data_length, map_length = @io.read(16).unpack("N*")
-
-      @map = {}
-      @io.pos = map_offset + 24 # skip header copy, next map handle, file reference, and attrs
-      type_list_offset, name_list_offset = @io.read(4).unpack("n*")
-
-      type_list_offset += map_offset
-      name_list_offset += map_offset
-
-      @io.pos = type_list_offset
-      max_index = @io.read(2).unpack("n").first
-      0.upto(max_index) do
-        type, max_type_index, ref_list_offset = @io.read(8).unpack("A4nn")
-        @map[type] = { :list => [], :named => {} }
-
-        parse_from(type_list_offset + ref_list_offset) do
-          0.upto(max_type_index) do
-            id, name_ofs, attr = @io.read(5).unpack("nnC")
-            data_ofs = @io.read(3)
-            data_ofs = data_offset + [0, data_ofs].pack("CA*").unpack("N").first
-            handle = @io.read(4).unpack("N").first
-
-            entry = { :id => id, :attributes => attr, :offset => data_ofs, :handle => handle }
-
-            if name_list_offset + name_ofs < map_offset + map_length
-              parse_from(name_ofs + name_list_offset) do
-                len = @io.read(1).unpack("C").first
-                entry[:name] = @io.read(len)
-              end
-            end
-
-            @map[type][:list] << entry
-            @map[type][:named][entry[:name]] = entry if entry[:name]
-          end
-        end
-      end
-    end
-
-    def [](type, index=0)
-      if @map[type]
-        collection = index.is_a?(Fixnum) ? :list : :named
-        if @map[type][collection][index]
-          parse_from(@map[type][collection][index][:offset]) do
-            length = @io.read(4).unpack("N").first
-            return @io.read(length)
-          end
-        end
-      end
-    end
-
-    def resources_for(type)
-      (@map[type] && @map[type][:named] || {}).keys
-    end
-
-    private
-
-      def parse_from(offset)
-        saved, @io.pos = @io.pos, offset
-        yield
-      ensure
-        @io.pos = saved
-      end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/subset.rb

@@ -1,18 +0,0 @@
-require 'ttfunk/subset/unicode'
-require 'ttfunk/subset/unicode_8bit'
-require 'ttfunk/subset/mac_roman'
-require 'ttfunk/subset/windows_1252'
-
-module TTFunk
-  module Subset
-    def self.for(original, encoding)
-      case encoding.to_sym
-        when :unicode      then Unicode.new(original)
-        when :unicode_8bit then Unicode8Bit.new(original)
-        when :mac_roman    then MacRoman.new(original)
-        when :windows_1252 then Windows1252.new(original)
-        else raise NotImplementedError, "encoding #{encoding} is not supported"
-      end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/subset/base.rb

@@ -1,141 +0,0 @@
-require 'ttfunk/table/cmap'
-require 'ttfunk/table/glyf'
-require 'ttfunk/table/head'
-require 'ttfunk/table/hhea'
-require 'ttfunk/table/hmtx'
-require 'ttfunk/table/kern'
-require 'ttfunk/table/loca'
-require 'ttfunk/table/maxp'
-require 'ttfunk/table/name'
-require 'ttfunk/table/post'
-require 'ttfunk/table/simple'
-
-module TTFunk
-  module Subset
-    class Base
-      attr_reader :original
-
-      def initialize(original)
-        @original = original
-      end
-
-      def unicode?
-        false
-      end
-
-      def to_unicode_map
-        {}
-      end
-
-      def encode(options={})
-        cmap_table = new_cmap_table(options)
-        glyphs = collect_glyphs(original_glyph_ids)
-
-        old2new_glyph = cmap_table[:charmap].inject({ 0 => 0 }) { |map, (code, ids)| map[ids[:old]] = ids[:new]; map }
-        next_glyph_id = cmap_table[:max_glyph_id]
-
-        glyphs.keys.each do |old_id|
-          unless old2new_glyph.key?(old_id) 
-            old2new_glyph[old_id] = next_glyph_id
-            next_glyph_id += 1
-          end
-        end
-
-        new2old_glyph = old2new_glyph.invert
-
-        # "mandatory" tables. Every font should ("should") have these, including
-        # the cmap table (encoded above).
-        glyf_table = TTFunk::Table::Glyf.encode(glyphs, new2old_glyph, old2new_glyph)
-        loca_table = TTFunk::Table::Loca.encode(glyf_table[:offsets])
-        hmtx_table = TTFunk::Table::Hmtx.encode(original.horizontal_metrics, new2old_glyph)
-        hhea_table = TTFunk::Table::Hhea.encode(original.horizontal_header, hmtx_table)
-        maxp_table = TTFunk::Table::Maxp.encode(original.maximum_profile, old2new_glyph)
-        post_table = TTFunk::Table::Post.encode(original.postscript, new2old_glyph)
-        name_table = TTFunk::Table::Name.encode(original.name)
-        head_table = TTFunk::Table::Head.encode(original.header, loca_table)
-
-        # "optional" tables. Fonts may omit these if they do not need them. Because they
-        # apply globally, we can simply copy them over, without modification, if they
-        # exist.
-        os2_table  = original.os2.raw
-        cvt_table  = TTFunk::Table::Simple.new(original, "cvt ").raw
-        fpgm_table = TTFunk::Table::Simple.new(original, "fpgm").raw
-        prep_table = TTFunk::Table::Simple.new(original, "prep").raw
-
-        # for PDF's, the kerning info is all included in the PDF as the text is
-        # drawn. Thus, the PDF readers do not actually use the kerning info in
-        # embedded fonts. If the library is used for something else, the generated
-        # subfont may need a kerning table... in that case, you need to opt into it.
-        if options[:kerning]
-          kern_table = TTFunk::Table::Kern.encode(original.kerning, old2new_glyph)
-        end
-
-        tables = { 'cmap' => cmap_table[:table],
-                   'glyf' => glyf_table[:table],
-                   'loca' => loca_table[:table],
-                   'kern' => kern_table,
-                   'hmtx' => hmtx_table[:table],
-                   'hhea' => hhea_table,
-                   'maxp' => maxp_table,
-                   'OS/2' => os2_table,
-                   'post' => post_table,
-                   'name' => name_table,
-                   'head' => head_table,
-                   'prep' => prep_table,
-                   'fpgm' => fpgm_table,
-                   'cvt ' => cvt_table }
-
-        tables.delete_if { |tag, table| table.nil? }
-
-        search_range = (Math.log(tables.length) / Math.log(2)).to_i * 16
-        entry_selector = (Math.log(search_range) / Math.log(2)).to_i
-        range_shift = tables.length * 16 - search_range
-
-        newfont = [original.directory.scaler_type, tables.length, search_range, entry_selector, range_shift].pack("Nn*")
-
-        directory_size = tables.length * 16
-        offset = newfont.length + directory_size
-
-        table_data = ""
-        head_offset = nil
-        tables.each do |tag, data|
-          newfont << [tag, checksum(data), offset, data.length].pack("A4N*")
-          table_data << data
-          head_offset = offset if tag == 'head'
-          offset += data.length
-          while offset % 4 != 0
-            offset += 1
-            table_data << "\0"
-          end
-        end
-
-        newfont << table_data
-        sum = checksum(newfont)
-        adjustment = 0xB1B0AFBA - sum
-        newfont[head_offset+8,4] = [adjustment].pack("N")
-
-        return newfont
-      end
-
-      private
-
-        def unicode_cmap
-          @unicode_cmap ||= @original.cmap.unicode.first
-        end
-
-        def checksum(data)
-          data += "\0" * (4 - data.length % 4) unless data.length % 4 == 0
-          data.unpack("N*").inject(0) { |sum, dword| sum + dword } & 0xFFFF_FFFF
-        end
-
-        def collect_glyphs(glyph_ids)
-          glyphs = glyph_ids.inject({}) { |h, id| h[id] = original.glyph_outlines.for(id); h }
-          additional_ids = glyphs.values.select { |g| g && g.compound? }.map { |g| g.glyph_ids }.flatten
-
-          glyphs.update(collect_glyphs(additional_ids)) if additional_ids.any?
-
-          return glyphs
-        end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/subset/mac_roman.rb

@@ -1,50 +0,0 @@
-require 'set'
-require 'ttfunk/subset/base'
-require 'ttfunk/encoding/mac_roman'
-
-module TTFunk
-  module Subset
-    class MacRoman < Base
-      def initialize(original)
-        super
-        @subset = Array.new(256)
-      end
-
-      def to_unicode_map
-        Encoding::MacRoman::TO_UNICODE
-      end
-
-      def use(character)
-        @subset[Encoding::MacRoman::FROM_UNICODE[character]] = character
-      end
-
-      def covers?(character)
-        Encoding::MacRoman.covers?(character)
-      end
-
-      def includes?(character)
-        code = Encoding::MacRoman::FROM_UNICODE[character]
-        code && @subset[code]
-      end
-
-      def from_unicode(character)
-        Encoding::MacRoman::FROM_UNICODE[character]
-      end
-
-      protected
-
-        def new_cmap_table(options)
-          mapping = {}
-          @subset.each_with_index do |unicode, roman|
-            mapping[roman] = unicode_cmap[unicode] if roman
-          end
-
-          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
-        end
-
-        def original_glyph_ids
-          ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] }).compact.uniq.sort
-        end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/subset/unicode.rb

@@ -1,48 +0,0 @@
-require 'set'
-require 'ttfunk/subset/base'
-
-module TTFunk
-  module Subset
-    class Unicode < Base
-      def initialize(original)
-        super
-        @subset = Set.new
-      end
-
-      def unicode?
-        true
-      end
-
-      def to_unicode_map
-        @subset.inject({}) { |map, code| map[code] = code; map }
-      end
-
-      def use(character)
-        @subset << character
-      end
-
-      def covers?(character)
-        true
-      end
-
-      def includes?(character)
-        @subset.includes(character)
-      end
-
-      def from_unicode(character)
-        character
-      end
-
-      protected
-
-        def new_cmap_table(options)
-          mapping = @subset.inject({}) { |map, code| map[code] = unicode_cmap[code]; map }
-          TTFunk::Table::Cmap.encode(mapping, :unicode)
-        end
-
-        def original_glyph_ids
-          ([0] + @subset.map { |code| unicode_cmap[code] }).uniq.sort
-        end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/subset/unicode_8bit.rb

@@ -1,63 +0,0 @@
-require 'set'
-require 'ttfunk/subset/base'
-
-module TTFunk
-  module Subset
-    class Unicode8Bit < Base
-      def initialize(original)
-        super
-        @subset = { 0x20 => 0x20 }
-        @unicodes = { 0x20 => 0x20 }
-        @next = 0x21 # apparently, PDF's don't like to use chars between 0-31
-      end
-
-      def unicode?
-        true
-      end
-
-      def to_unicode_map
-        @subset.dup
-      end
-
-      def use(character)
-        if !@unicodes.key?(character)
-          @subset[@next] = character
-          @unicodes[character] = @next
-          @next += 1
-        end
-      end
-
-      def covers?(character)
-        @unicodes.key?(character) || @next < 256
-      end
-
-      def includes?(character)
-        @unicodes.key?(character)
-      end
-
-      def from_unicode(character)
-        @unicodes[character]
-      end
-
-      protected
-
-        def new_cmap_table(options)
-          mapping = @subset.inject({}) do |map, (code,unicode)|
-            map[code] = unicode_cmap[unicode]
-            map
-          end
-
-          # since we're mapping a subset of the unicode glyphs into an
-          # arbitrary 256-character space, the actual encoding we're
-          # using is irrelevant. We choose MacRoman because it's a 256-character
-          # encoding that happens to be well-supported in both TTF and
-          # PDF formats.
-          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
-        end
-
-        def original_glyph_ids
-          ([0] + @unicodes.keys.map { |unicode| unicode_cmap[unicode] }).uniq.sort
-        end
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/subset/windows_1252.rb

@@ -1,55 +0,0 @@
-require 'set'
-require 'ttfunk/subset/base'
-require 'ttfunk/encoding/windows_1252'
-
-module TTFunk
-  module Subset
-    class Windows1252 < Base
-      def initialize(original)
-        super
-        @subset = Array.new(256)
-      end
-
-      def to_unicode_map
-        Encoding::Windows1252::TO_UNICODE
-      end
-
-      def use(character)
-        @subset[Encoding::Windows1252::FROM_UNICODE[character]] = character
-      end
-
-      def covers?(character)
-        Encoding::Windows1252.covers?(character)
-      end
-
-      def includes?(character)
-        code = Encoding::Windows1252::FROM_UNICODE[character]
-        code && @subset[code]
-      end
-
-      def from_unicode(character)
-        Encoding::Windows1252::FROM_UNICODE[character]
-      end
-
-      protected
-
-        def new_cmap_table(options)
-          mapping = {}
-          @subset.each_with_index do |unicode, cp1252|
-            mapping[cp1252] = unicode_cmap[unicode] if cp1252
-          end
-
-          # yes, I really mean "mac roman". TTF has no cp1252 encoding, and the
-          # alternative would be to encode it using a format 4 unicode table, which
-          # is overkill. for our purposes, mac-roman suffices. (If we were building
-          # a _real_ font, instead of a PDF-embeddable subset, things would probably
-          # be different.)
-          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
-        end
-
-        def original_glyph_ids
-          ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] }).compact.uniq.sort
-        end
-    end
-  end
-end