prawn 0.4.1 → 0.5.0.1

data/lib/prawn/encoding.rb

@@ -1,121 +0,0 @@
-# encoding: utf-8
-#
-# Copyright September 2008, Gregory Brown, James Healy  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-#
-module Prawn
-  module Encoding
-    # Map between unicode and WinAnsiEnoding
-    #
-    class WinAnsi #:nodoc:
-      CHARACTERS = %w[
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        .notdef       .notdef        .notdef        .notdef
-        
-        space         exclam         quotedbl       numbersign
-        dollar        percent        ampersand      quotesingle
-        parenleft     parenright     asterisk       plus
-        comma         hyphen         period         slash
-        zero          one            two            three
-        four          five           six            seven
-        eight         nine           colon          semicolon
-        less          equal          greater        question
-
-        at            A              B              C
-        D             E              F              G
-        H             I              J              K
-        L             M              N              O
-        P             Q              R              S
-        T             U              V              W
-        X             Y              Z              bracketleft
-        backslash     bracketright   asciicircum    underscore
-
-        grave         a              b              c
-        d             e              f              g
-        h             i              j              k
-        l             m              n              o
-        p             q              r              s
-        t             u              v              w
-        x             y              z              braceleft
-        bar           braceright     asciitilde     .notdef
-
-        Euro          .notdef        quotesinglbase florin
-        quotedblbase  ellipsis       dagger         daggerdbl
-        circumflex    perthousand    Scaron         guilsinglleft
-        OE            .notdef        Zcaron         .notdef
-        .notdef       quoteleft      quoteright     quotedblleft
-        quotedblright bullet         endash         emdash
-        tilde         trademark      scaron         guilsinglright
-        oe            .notdef        zcaron         ydieresis
-       
-        space         exclamdown     cent           sterling
-        currency      yen            brokenbar      section
-        dieresis      copyright      ordfeminine    guillemotleft
-        logicalnot    hyphen         registered     macron
-        degree        plusminus      twosuperior    threesuperior
-        acute         mu             paragraph      periodcentered
-        cedilla       onesuperior    ordmasculine   guillemotright
-        onequarter    onehalf        threequarters  questiondown
-
-        Agrave        Aacute         Acircumflex    Atilde
-        Adieresis     Aring          AE             Ccedilla
-        Egrave        Eacute         Ecircumflex    Edieresis
-        Igrave        Iacute         Icircumflex    Idieresis
-        Eth           Ntilde         Ograve         Oacute
-        Ocircumflex   Otilde         Odieresis      multiply
-        Oslash        Ugrave         Uacute         Ucircumflex
-        Udieresis     Yacute         Thorn          germandbls
-
-        agrave        aacute         acircumflex    atilde
-        adieresis     aring          ae             ccedilla
-        egrave        eacute         ecircumflex    edieresis
-        igrave        iacute         icircumflex    idieresis
-        eth           ntilde         ograve         oacute
-        ocircumflex   otilde         odieresis      divide
-        oslash        ugrave         uacute         ucircumflex
-        udieresis     yacute         thorn          ydieresis
-      ]    
-      
-      def initialize
-        @mapping_file = "#{Prawn::BASEDIR}/data/encodings/win_ansi.txt"
-        load_mapping if self.class.mapping.empty?
-      end
-
-      # Converts a Unicode codepoint into a valid WinAnsi single byte character.
-      #
-      # If there is no WinAnsi equivlant for a character, a _ will be substituted.
-      #
-      def [](codepoint)
-        # unicode codepoints < 255 map directly to the single byte value in WinAnsi
-        return codepoint if codepoint <= 255
-
-        # There are a handful of codepoints > 255 that have equivilants in WinAnsi.
-        # Replace anything else with an underscore
-        self.class.mapping[codepoint] || 95
-      end
-      
-      def self.mapping
-        @mapping ||= {}
-      end
-
-      private
-
-      def load_mapping
-        RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
-        File.open(@mapping_file, mode) do |f|
-          f.each do |l|
-            m, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
-            self.class.mapping["0x#{unicode}".hex] = "0x#{single_byte}".hex if single_byte
-          end
-        end
-      end
-    end
-  end
-end

data/lib/prawn/errors.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-# errors.rb : Implements custom error classes for Prawn
-#
-# Copyright April 2008, Gregory Brown.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-module Prawn
-  module Errors
-     
-     # This error is raised when Prawn::PdfObject() encounters a Ruby object it
-     # cannot convert to PDF
-     #
-     class FailedObjectConversion < StandardError; end
-     
-     # This error is raised when Document#page_layout is set to anything
-     # other than :portrait or :landscape            
-     #
-     class InvalidPageLayout < StandardError; end        
-     
-     # This error is raised when Prawn cannot find a specified font   
-     #
-     class UnknownFont < StandardError; end   
-
-     # This error is raised when Prawn is being used on a M17N aware VM,
-     # and the user attempts to add text that isn't compatible with UTF-8
-     # to their document
-     #
-     class IncompatibleStringEncoding < StandardError; end     
-     
-     # This error is raised when Prawn encounters an unknown key in functions
-     # that accept an options hash.  This usually means there is a typo in your
-     # code or that the option you are trying to use has a different name than
-     # what you have specified. 
-     #
-     class UnknownOption < StandardError; end
-     
-  end
-end   

data/lib/prawn/font.rb

@@ -1,277 +0,0 @@
-# encoding: utf-8
-#
-# font.rb : The Prawn font class
-#
-# Copyright May 2008, Gregory Brown / James Healy. All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-require "prawn/font/afm"
-require "prawn/font/ttf"
-require "prawn/font/dfont"
-
-module Prawn
-
-  class Document
-    # Without arguments, this returns the currently selected font. Otherwise,
-    # it sets the current font.
-    #
-    # The single parameter must be a string. It can be one of the 14 built-in
-    # fonts supported by PDF, or the location of a TTF file. The Font::AFM::BUILT_INS
-    # array specifies the valid built in font values.
-    #
-    #   pdf.font "Times-Roman"
-    #   pdf.font "Chalkboard.ttf"
-    #
-    # If a ttf font is specified, the glyphs necessary to render your document
-    # will be embedded in the rendered PDF. This should be your preferred option
-    # in most cases. It will increase the size of the resulting file, but also 
-    # make it more portable.
-    #
-    def font(name=nil, options={})
-      return @font || font("Helvetica") if name.nil?
-
-      new_font = find_font(name, options)
-
-      if block_given?
-        save_font do
-          set_font(new_font, options[:size])
-          yield
-        end
-      else
-        set_font(new_font, options[:size])
-      end
-
-      @font
-    end
-
-    # When called with no argument, returns the current font size.
-    # When called with a single argument but no block, sets the current font
-    # size.  When a block is used, the font size is applied transactionally and
-    # is rolled back when the block exits.  You may still change the font size
-    # within a transactional block for individual text segments, or nested calls
-    # to font_size.
-    #
-    #   Prawn::Document.generate("font_size.pdf") do
-    #     font_size 16
-    #     text "At size 16"
-    #
-    #     font_size(10) do
-    #       text "At size 10"
-    #       text "At size 6", :size => 6
-    #       text "At size 10"
-    #     end
-    #
-    #     text "At size 16"
-    #   end
-    #
-    # When called without an argument, this method returns the current font
-    # size.
-    #
-    def font_size(points=nil)
-      return @font_size unless points
-      size_before_yield = @font_size
-      @font_size = points
-      block_given? ? yield : return
-      @font_size = size_before_yield
-    end
-
-    # Sets the font directly, given an actual Font object
-    # and size.
-    def set_font(font, size=nil) # :nodoc:
-      @font = font
-      @font_size = size if size
-    end
-
-    # Saves the current font, and then yields. When the block
-    # finishes, the original font is restored.
-    def save_font
-      @font ||= find_font("Helvetica")
-      original_font = @font
-      original_size = @font_size
-
-      yield
-    ensure
-      set_font(original_font, original_size) if original_font
-    end
-
-    # Looks up the given font using the given criteria. Once a font has been
-    # found by that matches the criteria, it will be cached to subsequent lookups
-    # for that font will return the same object.
-    #--
-    # Challenges involved: the name alone is not sufficient to uniquely identify
-    # a font (think dfont suitcases that can hold multiple different fonts in a
-    # single file). Thus, the :name key is included in the cache key.
-    #
-    # It is further complicated, however, since fonts in some formats (like the
-    # dfont suitcases) can be identified either by numeric index, OR by their
-    # name within the suitcase, and both should hash to the same font object
-    # (to avoid the font being embedded multiple times). This is not yet implemented,
-    # which means if someone selects a font both by name, and by index, the
-    # font will be embedded twice. Since we do font subsetting, this double
-    # embedding won't be catastrophic, just annoying.
-    # ++
-    #
-    def find_font(name, options={}) #:nodoc:
-      if font_families.key?(name)
-        family, name = name, font_families[name][options[:style] || :normal]
-
-        if name.is_a?(Hash)
-          options = options.merge(name)
-          name = options[:file]
-        end
-      end
-
-      key = "#{name}:#{options[:font] || 0}"
-      font_registry[key] ||= Font.load(self, name, options.merge(:family => family))
-    end
-
-    # Hash of Font objects keyed by names
-    #
-    def font_registry #:nodoc:
-      @font_registry ||= {}
-    end
-
-    # Hash that maps font family names to their styled individual font names
-    #
-    # To add support for another font family, append to this hash, e.g:
-    #
-    #   pdf.font_families.update(
-    #    "MyTrueTypeFamily" => { :bold        => "foo-bold.ttf",
-    #                            :italic      => "foo-italic.ttf",
-    #                            :bold_italic => "foo-bold-italic.ttf",
-    #                            :normal      => "foo.ttf" })
-    #
-    # This will then allow you to use the fonts like so:
-    #
-    #   pdf.font("MyTrueTypeFamily", :style => :bold)
-    #   pdf.text "Some bold text"
-    #   pdf.font("MyTrueTypeFamily")
-    #   pdf.text "Some normal text"
-    #
-    # This assumes that you have appropriate TTF fonts for each style you
-    # wish to support.
-    #
-    def font_families
-      @font_families ||= Hash.new { |h,k| h[k] = {} }.merge!(
-        { "Courier"     => { :bold        => "Courier-Bold",
-                             :italic      => "Courier-Oblique",
-                             :bold_italic => "Courier-BoldOblique",
-                             :normal      => "Courier" },
-
-          "Times-Roman" => { :bold         => "Times-Bold",
-                             :italic       => "Times-Italic",
-                             :bold_italic  => "Times-BoldItalic",
-                             :normal       => "Times-Roman" },
-
-          "Helvetica"   => { :bold         => "Helvetica-Bold",
-                             :italic       => "Helvetica-Oblique",
-                             :bold_italic  => "Helvetica-BoldOblique",
-                             :normal       => "Helvetica" }
-        })
-    end
-  end
-
-  # Provides font information and helper functions.
-  #
-  class Font
-
-    # The current font name
-    attr_reader :name
-
-    # The current font family
-    attr_reader :family
-
-    # The options hash used to initialize the font
-    attr_reader :options
-
-    def self.load(document,name,options={})
-      case name
-      when /\.ttf$/   then TTF.new(document, name, options)
-      when /\.dfont$/ then DFont.new(document, name, options)
-      when /\.afm$/   then AFM.new(document, name, options)
-      else                 AFM.new(document, name, options)
-      end
-    end
-
-    def initialize(document,name,options={}) #:nodoc:
-      @document   = document
-      @name       = name
-      @options    = options
-
-      @family     = options[:family]
-
-      @document.proc_set :PDF, :Text
-      @identifier = :"F#{@document.font_registry.size + 1}"
-
-      @references = {}
-    end
-
-    def ascender
-      @ascender / 1000.0 * size
-    end
-
-    def descender
-      @descender / 1000.0 * size
-    end
-
-    def line_gap
-      @line_gap / 1000.0 * size
-    end
-
-    def identifier_for(subset)
-      "#{@identifier}.#{subset}"
-    end
-
-    def inspect
-      "#{self.class.name}< #{name}: #{size} >"
-    end
-
-    # Returns the width of the given string using the given font. If :size is not
-    # specified as one of the options, the string is measured using the current
-    # font size. You can also pass :kerning as an option to indicate whether
-    # kerning should be used when measuring the width (defaults to +false+).
-    #
-    # Note that the string _must_ be encoded properly for the font being used.
-    # For AFM fonts, this is WinAnsi. For TTF, make sure the font is encoded as
-    # UTF-8. You can use the #normalize_encoding method to make sure strings
-    # are in an encoding appropriate for the font.
-    def width_of(string, options={})
-      raise NotImplementedError, "subclasses of Prawn::Font must implement #width_of"
-    end
-
-    # Normalizes the encoding of the string to an encoding supported by the font.
-    # The string is expected to be UTF-8 going in, and will be reencoded in-place
-    # (the argument will be modified directly). The return value is not defined.
-    def normalize_encoding(string)
-      raise NotImplementedError, "subclasses of Prawn::Font must implement #normalize_encoding"
-    end
-
-    def height_at(size)
-      @normalized_height ||= (@ascender - @descender + @line_gap) / 1000.0
-      @normalized_height * size
-    end
-
-    # Gets height of current font in PDF points at current font size
-    #
-    def height
-      height_at(size)
-    end
-
-    # Registers the given subset of the current font with the current PDF
-    # page. This is safe to call multiple times for a given font and subset,
-    # as it will only add the font the first time it is called.
-    #
-    def add_to_current_page(subset)
-      @references[subset] ||= register(subset)
-      @document.page_fonts.merge!(identifier_for(subset) => @references[subset])
-    end
-
-    private
-
-    def size
-      @document.font_size
-    end
-
-  end
-
-end

data/lib/prawn/font/afm.rb

@@ -1,202 +0,0 @@
-require 'prawn/encoding'
-
-module Prawn
-  class Font
-    class AFM < Font
-      BUILT_INS = %w[ Courier Helvetica Times-Roman Symbol ZapfDingbats
-                      Courier-Bold Courier-Oblique Courier-BoldOblique
-                      Times-Bold Times-Italic Times-BoldItalic
-                      Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique ]
-
-      def self.metrics_path
-        if m = ENV['METRICS']
-          @metrics_path ||= m.split(':')
-        else
-          @metrics_path ||= [
-            ".", "/usr/lib/afm",
-            "/usr/local/lib/afm",
-            "/usr/openwin/lib/fonts/afm/",
-             Prawn::BASEDIR+'/data/fonts/']
-        end
-      end
-
-      attr_reader :attributes
-
-      def initialize(document, name, options={})
-        unless BUILT_INS.include?(name)
-          raise Prawn::Errors::UnknownFont, "#{name} is not a known font."
-        end
-
-        super
-
-        @attributes     = {}
-        @glyph_widths   = {}
-        @bounding_boxes = {}
-        @kern_pairs     = {}
-
-        file_name = @name.dup
-        file_name << ".afm" unless file_name =~ /\.afm$/
-        file_name = file_name[0] == ?/ ? file_name : find_font(file_name)
-
-        parse_afm(file_name)
-
-        @ascender  = @attributes["ascender"].to_i
-        @descender = @attributes["descender"].to_i
-        @line_gap  = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
-      end
-
-      def bbox
-        @bbox ||= @attributes['fontbbox'].split(/\s+/).map { |e| Integer(e) }
-      end
-
-      # calculates the width of the supplied string.
-      #
-      # String *must* be encoded as WinAnsi
-      #
-      def width_of(string, options={})
-        scale = (options[:size] || size) / 1000.0
-
-        if options[:kerning]
-          strings, numbers = kern(string).partition { |e| e.is_a?(String) }
-          total_kerning_offset = numbers.inject(0.0) { |s,r| s + r }
-          (unscaled_width_of(strings.join) - total_kerning_offset) * scale
-        else
-          unscaled_width_of(string) * scale
-        end
-      end
-
-      def has_kerning_data?
-        @kern_pairs.any?
-      end
-
-      # built-in fonts only work with winansi encoding, so translate the
-      # string. Changes the encoding in-place, so the argument itself
-      # is replaced with a string in WinAnsi encoding.
-      def normalize_encoding(text)
-        enc = Prawn::Encoding::WinAnsi.new
-        text.replace text.unpack("U*").collect { |i| enc[i] }.pack("C*")
-      end
-
-      # Perform any changes to the string that need to happen
-      # before it is rendered to the canvas. Returns an array of
-      # subset "chunks", where each chunk is an array of two elements.
-      # The first element is the font subset number, and the second
-      # is either a string or an array (for kerned text).
-      #
-      # For Adobe fonts, there is only ever a single subset, so
-      # the first element of the array is "0", and the second is
-      # the string itself (or an array, if kerning is performed).
-      #
-      # The +text+ parameter must be in WinAnsi encoding (cp1252).
-      def encode_text(text, options={})
-        [[0, options[:kerning] ? kern(text) : text]]
-      end
-
-      private
-
-      def register(subset)
-        @document.ref(:Type     => :Font,
-                      :Subtype  => :Type1,
-                      :BaseFont => name.to_sym,
-                      :Encoding => :WinAnsiEncoding)
-      end
-
-      def find_font(file)
-        self.class.metrics_path.find { |f| File.exist? "#{f}/#{file}" } + "/#{file}"
-      rescue NoMethodError
-        raise Prawn::Errors::UnknownFont,
-          "Couldn't find the font: #{file} in any of:\n" +
-           self.class.metrics_path.join("\n")
-      end
-
-      def parse_afm(file_name)
-        section = []
-
-        File.foreach(file_name) do |line|
-          case line
-          when /^Start(\w+)/
-            section.push $1
-            next
-          when /^End(\w+)/
-            section.pop
-            next
-          end
-
-          case section
-          when ["FontMetrics", "CharMetrics"]
-            next unless line =~ /^CH?\s/
-
-            name                  = line[/\bN\s+(\.?\w+)\s*;/, 1]
-            @glyph_widths[name]   = line[/\bWX\s+(\d+)\s*;/, 1].to_i
-            @bounding_boxes[name] = line[/\bB\s+([^;]+);/, 1].to_s.rstrip
-          when ["FontMetrics", "KernData", "KernPairs"]
-            next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
-            @kern_pairs[[$1, $2]] = $3.to_i
-          when ["FontMetrics", "KernData", "TrackKern"],
-            ["FontMetrics", "Composites"]
-            next
-          else
-            parse_generic_afm_attribute(line)
-          end
-        end
-      end
-
-      def parse_generic_afm_attribute(line)
-        line =~ /(^\w+)\s+(.*)/
-        key, value = $1.to_s.downcase, $2
-
-        @attributes[key] =  @attributes[key] ?
-        Array(@attributes[key]) << value : value
-      end
-
-      # converts a string into an array with spacing offsets
-      # bewteen characters that need to be kerned
-      #
-      # String *must* be encoded as WinAnsi
-      #
-      def kern(string)
-        kerned = [[]]
-        last_byte = nil
-
-        kern_pairs = latin_kern_pairs_table
-
-        string.unpack("C*").each do |byte|
-          if k = last_byte && kern_pairs[[last_byte, byte]]
-            kerned << -k << [byte]
-          else
-            kerned.last << byte
-          end         
-          last_byte = byte
-        end
-
-        kerned.map { |e| 
-          e = (Array === e ? e.pack("C*") : e)
-          e.respond_to?(:force_encoding) ? e.force_encoding("Windows-1252") : e  
-        }
-      end
-
-      def latin_kern_pairs_table
-        @kern_pairs_table ||= @kern_pairs.inject({}) do |h,p|
-          h[p[0].map { |n| Encoding::WinAnsi::CHARACTERS.index(n) }] = p[1]
-          h
-        end
-      end
-
-      def latin_glyphs_table
-        @glyphs_table ||= (0..255).map do |i|
-          @glyph_widths[Encoding::WinAnsi::CHARACTERS[i]].to_i
-        end
-      end
-      
-      private
-      
-      def unscaled_width_of(string)
-        glyph_table = latin_glyphs_table
-        
-        string.unpack("C*").inject(0) do |s,r|
-          s + glyph_table[r]
-        end
-      end
-    end
-  end
-end