prawn-graph 0.0.2 → 0.0.3

data/vendor/prawn-core/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/prawn-core/vendor/ttfunk/lib/ttfunk/subset/windows_1252.rb

@@ -1,51 +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 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

data/vendor/prawn-core/vendor/ttfunk/lib/ttfunk/subset_collection.rb

@@ -1,72 +0,0 @@
-require 'ttfunk/subset'
-
-module TTFunk
-  class SubsetCollection
-    def initialize(original)
-      @original = original
-      @subsets = [Subset.for(@original, :mac_roman)]
-    end
-
-    def [](subset)
-      @subsets[subset]
-    end
-
-    # +characters+ should be an array of UTF-16 characters
-    def use(characters)
-      characters.each do |char|
-        covered = false
-        @subsets.each_with_index do |subset, i|
-          if subset.covers?(char)
-            subset.use(char)
-            covered = true
-            break
-          end
-        end
-
-        if !covered
-          @subsets << Subset.for(@original, :unicode_8bit)
-          @subsets.last.use(char)
-        end
-      end
-    end
-
-    # +characters+ should be an array of UTF-16 characters. Returns
-    # an array of subset chunks, where each chunk is another array of
-    # two elements. The first element is the subset number, and the
-    # second element is the string of characters to render with that
-    # font subset. The strings will be encoded for their subset font,
-    # and so may not look (in the raw) like what was passed in, but
-    # they will render correctly with the indicated subset font.
-    def encode(characters)
-      return [] if characters.empty?
-
-      # TODO: probably would be more optimal to nix the #use method,
-      # and merge it into this one, so it can be done in a single
-      # pass instead of two passes.
-      use(characters)
-
-      parts = []
-      current_subset = 0
-      current_char = 0
-      char = characters[current_char]
-
-      loop do
-        while @subsets[current_subset].includes?(char)
-          char = @subsets[current_subset].from_unicode(char)
-
-          if parts.empty? || parts.last[0] != current_subset
-            parts << [current_subset, char.chr]
-          else
-            parts.last[1] << char
-          end
-
-          current_char += 1
-          return parts if current_char >= characters.length
-          char = characters[current_char]
-        end
-
-        current_subset = (current_subset + 1) % @subsets.length
-      end
-    end
-  end
-end

data/vendor/prawn-core/vendor/ttfunk/lib/ttfunk/table.rb

@@ -1,46 +0,0 @@
-require 'ttfunk/reader'
-
-module TTFunk
-  class Table
-    include Reader
-
-    attr_reader :file
-    attr_reader :offset
-    attr_reader :length
-
-    def initialize(file)
-      @file = file
-
-      info = file.directory_info(tag)
-
-      if info
-        @offset = info[:offset]
-        @length = info[:length]
-
-        parse_from(@offset) { parse! }
-      end
-    end
-
-    def exists?
-      !@offset.nil?
-    end
-
-    def raw
-      if exists?
-        parse_from(offset) { io.read(length) }
-      else
-        nil
-      end
-    end
-
-    def tag
-      self.class.name.split(/::/).last.downcase
-    end
-
-    private
-
-      def parse!
-        # do nothing, by default
-      end
-  end
-end

data/vendor/prawn-core/vendor/ttfunk/lib/ttfunk/table/cmap.rb

@@ -1,34 +0,0 @@
-module TTFunk  
-  class Table
-    class Cmap < Table
-      attr_reader :version
-      attr_reader :tables
-
-      def self.encode(charmap, encoding)
-        result = Cmap::Subtable.encode(charmap, encoding)
-
-        # pack 'version' and 'table-count'
-        result[:table] = [0, 1, result.delete(:subtable)].pack("nnA*")
-        return result
-      end
-
-      def unicode
-        @unicode ||= @tables.select { |table| table.unicode? }
-      end
-
-      private
-
-        def parse!
-          @version, table_count = read(4, "nn")
-          @tables = []
-
-          table_count.times do
-            @tables << Cmap::Subtable.new(file, offset)
-          end
-        end
-    end
-    
-  end
-end
-
-require 'ttfunk/table/cmap/subtable'

data/vendor/prawn-core/vendor/ttfunk/lib/ttfunk/table/cmap/format00.rb

@@ -1,54 +0,0 @@
-require 'ttfunk/encoding/mac_roman'
-require 'ttfunk/encoding/windows_1252'
-
-module TTFunk
-  class Table
-    class Cmap
-
-      module Format00
-        attr_reader :language
-        attr_reader :code_map
-
-        # Expects a hash mapping character codes to glyph ids (where the
-        # glyph ids are from the original font). Returns a hash including
-        # a new map (:charmap) that maps the characters in charmap to a
-        # another hash containing both the old (:old) and new (:new) glyph
-        # ids. The returned hash also includes a :subtable key, which contains
-        # the encoded subtable for the given charmap.
-        def self.encode(charmap)
-          next_id = 0 
-          glyph_indexes = Array.new(256, 0)
-          glyph_map = { 0 => 0 }
-
-          new_map = charmap.keys.sort.inject({}) do |map, code|
-            glyph_map[charmap[code]] ||= next_id += 1
-            map[code] = { :old => charmap[code], :new => glyph_map[charmap[code]] }
-            glyph_indexes[code] = glyph_map[charmap[code]]
-            map
-          end
-
-          # format, length, language, indices
-          subtable = [0, 262, 0, *glyph_indexes].pack("nnnC*")
-
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
-        end
-
-        def [](code)
-          @code_map[code] || 0
-        end
-
-        def supported?
-          true
-        end
-
-        private
-
-          def parse_cmap!
-            length, @language = read(4, "nn")
-            @code_map = read(256, "C*")
-          end
-      end
-
-    end
-  end
-end

data/vendor/prawn-core/vendor/ttfunk/lib/ttfunk/table/cmap/format04.rb

@@ -1,126 +0,0 @@
-module TTFunk
-  class Table
-    class Cmap
-
-      module Format04
-        attr_reader :language
-        attr_reader :code_map
-
-        # Expects a hash mapping character codes to glyph ids (where the
-        # glyph ids are from the original font). Returns a hash including
-        # a new map (:charmap) that maps the characters in charmap to a
-        # another hash containing both the old (:old) and new (:new) glyph
-        # ids. The returned hash also includes a :subtable key, which contains
-        # the encoded subtable for the given charmap.
-        def self.encode(charmap)
-          end_codes = []
-          start_codes = []
-          next_id = 0
-          last = difference = nil
-
-          glyph_map = { 0 => 0 }
-          new_map = charmap.keys.sort.inject({}) do |map, code|
-            old = charmap[code]
-            glyph_map[old] ||= next_id += 1
-            map[code] = { :old => old, :new => glyph_map[old] }
-
-            delta = glyph_map[old] - code
-            if last.nil? || delta != difference
-              end_codes << last if last
-              start_codes << code
-              difference = delta
-            end
-            last = code
-
-            map
-          end
-
-          end_codes << last if last
-          end_codes << 0xFFFF
-          start_codes << 0xFFFF
-          segcount = start_codes.length
-
-          # build the conversion tables
-          deltas = []
-          range_offsets = []
-          glyph_indices = []
-
-          offset = 0
-          start_codes.zip(end_codes).each_with_index do |(a, b), segment|
-            if a == 0xFFFF
-              deltas << 0
-              range_offsets << 0
-              break
-            end
-
-            start_glyph_id = new_map[a][:new]
-            if a - start_glyph_id >= 0x8000
-              deltas << 0
-              range_offsets << 2 * (glyph_indices.length + segcount - segment)
-              a.upto(b) { |code| glyph_indices << new_map[code][:new] }
-            else
-              deltas << -a + start_glyph_id
-              range_offsets << 0
-            end
-            offset += 2
-          end
-
-          # format, length, language
-          subtable = [4, 16 + 8 * segcount + 2 * glyph_indices.length, 0].pack("nnn")
-
-          search_range = 2 * 2 ** (Math.log(segcount) / Math.log(2)).to_i
-          entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
-          range_shift = (2 * segcount) - search_range
-          subtable << [segcount * 2, search_range, entry_selector, range_shift].pack("nnnn")
-
-          subtable << end_codes.pack("n*") << "\0\0" << start_codes.pack("n*")
-          subtable << deltas.pack("n*") << range_offsets.pack("n*") << glyph_indices.pack("n*")
-
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
-        end
-
-        def [](code)
-          @code_map[code] || 0
-        end
-
-        def supported?
-          true
-        end
-
-        private
-
-          def parse_cmap!
-            length, @language, segcount_x2 = read(6, "nnn")
-            segcount = segcount_x2 / 2
-
-            io.read(6) # skip searching hints
-
-            end_code = read(segcount_x2, "n*")
-            io.read(2) # skip reserved value
-            start_code = read(segcount_x2, "n*")
-            id_delta = read_signed(segcount)
-            id_range_offset = read(segcount_x2, "n*")
-
-            glyph_ids = read(length - io.pos + @offset, "n*")
-
-            @code_map = {}
-
-            end_code.each_with_index do |tail, i|
-              start_code[i].upto(tail) do |code|
-                if id_range_offset[i].zero?
-                  glyph_id = code + id_delta[i]
-                else
-                  index = id_range_offset[i] / 2 + (code - start_code[i]) - (segcount - i)
-                  glyph_id = glyph_ids[index] || 0 # because some TTF fonts are broken
-                  glyph_id += id_delta[i] if glyph_id != 0
-                end
-
-                @code_map[code] = glyph_id & 0xFFFF
-              end
-            end
-          end
-      end
-
-    end
-  end
-end