piglop-prawn 0.10.2.1

data/lib/prawn/core/text/line_wrap.rb

@@ -0,0 +1,198 @@
+# encoding: utf-8
+
+# core/text/line_wrap.rb : Implements individual line wrapping
+#
+# Copyright January 2010, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+  module Core
+    module Text
+      
+      class LineWrap #:nodoc:
+
+        # The width of the last wrapped line
+        #
+        def width
+          @accumulated_width || 0
+        end
+
+        # The number of spaces in the last wrapped line
+        #
+        def space_count
+          @space_count
+        end
+
+        # The number of characters consumed from the last line passed into
+        # wrap_line. This may differ from the number of characters in the
+        # returned line because trailing white spaces are removed
+        #
+        def consumed_char_count
+          @consumed_char_count
+        end
+
+        # The pattern used to determine chunks of text to place on a given line
+        #
+        def scan_pattern
+          pattern = "[^#{break_chars}]+#{soft_hyphen}|" +
+                    "[^#{break_chars}]+#{hyphen}+|" +
+                    "[^#{break_chars}]+|" +
+                    "[#{whitespace}]+|" +
+                    "#{hyphen}+[^#{break_chars}]*|" +
+                    "#{soft_hyphen}"
+          new_regexp(pattern)
+        end
+
+        # The pattern used to determine whether any word breaks exist on a
+        # current line, which in turn determines whether character level
+        # word breaking is needed
+        #
+        def word_division_scan_pattern
+          new_regexp("\\s|[#{hyphen}#{soft_hyphen}]")
+        end
+
+        # Take a single line and deterimine what part of it fits within the
+        # width defined by the :width option
+        #
+        def wrap_line(line, options)
+          initialize_line(options)
+
+          previous_segment = nil
+          line.scan(@scan_pattern).each do |segment|
+            segment_width = @document.width_of(segment, :kerning => @kerning)
+
+            if @accumulated_width + segment_width <= @width
+              @accumulated_width += segment_width
+              @output += segment
+            else
+              end_of_the_line(segment)
+              break
+            end
+            previous_segment = segment
+          end
+          raise Errors::CannotFit if @output.empty? && !line.strip.empty?
+
+          finalize_line
+          @space_count = @output.count(" ")
+          @output
+        end
+
+        private
+
+        def initialize_line(options)
+          @document = options[:document]
+          @kerning = options[:kerning]
+          @width = options[:width]
+
+          @scan_pattern = scan_pattern
+          @word_division_scan_pattern = word_division_scan_pattern
+
+          @accumulated_width = 0
+          @output = ""
+        end
+
+        def break_chars
+          "#{whitespace}#{soft_hyphen}#{hyphen}"
+        end
+
+        def whitespace
+          " \\t"
+        end
+
+        def hyphen
+          "-"
+        end
+
+        def soft_hyphen
+          @document.font.normalize_encoding("­")
+        end
+
+        # If there is more than one word on the line, then clean up the last
+        # word on the line; otherwise, wrap by character
+        #
+        def end_of_the_line(segment)
+          if @output =~ @word_division_scan_pattern
+            if segment =~ new_regexp("^#{hyphen}") &&
+                @output !~ new_regexp("[#{break_chars}]$")
+              remove_last_output_word
+            end
+          else
+            wrap_by_char(segment)
+            # since when adding characters individually, kerning has no effect,
+            # recompute width of the output after adding characters
+            # IMPORTANT: leave this computation here, rather than moving it into
+            # append_char because append_char is more general than
+            # end_of_the_line, so while end_of_the_line is likely to be
+            # overridden, wrap_by_char may not be, and we don't want to
+            # recompute line width except where necessary (for example, see
+            # Prawn::Core::Text::Formatted::LineWrap)
+            @accumulated_width = compute_output_width
+          end
+        end
+
+        def remove_last_output_word
+          segments = []
+          regexp = new_regexp("[^#{break_chars}]+|[#{break_chars}]+")
+          @output.scan(regexp).each { |segment| segments << segment }
+          segments.pop
+          @output = segments.join("")
+        end
+
+        def finalize_line
+          @consumed_char_count = @output.length
+
+          @output = @output[0..-2].gsub(soft_hyphen, "") + @output[-1..-1]
+
+          strip_trailing_whitespace
+        end
+
+        def strip_trailing_whitespace
+          @accumulated_width = compute_output_width if @output.strip!
+        end
+
+        def compute_output_width
+          @document.width_of(@output, :kerning => @kerning)
+        end
+
+        def wrap_by_char(segment)
+          if @document.font.unicode?
+            segment.unpack("U*").each do |char_int|
+              break unless append_char([char_int].pack("U"))
+            end
+          else
+            segment.each_char do |char|
+              break unless append_char(char)
+            end
+          end
+        end
+
+        def append_char(char)
+          # kerning doesn't make sense in the context of a single character
+          char_width = @document.width_of(char)
+          @accumulated_width += char_width
+
+          if @accumulated_width >= @width
+            false
+          else
+            @output << char
+            true
+          end
+        end
+
+        def new_regexp(pattern)
+          regexp = ruby_19 {
+            Regexp.new(pattern)
+          }
+          regexp = regexp || ruby_18 {
+            lang = @document.font.unicode? ? 'U' : 'N'
+            Regexp.new(pattern, 0, lang)
+          }
+          regexp
+        end
+
+      end
+    end
+  end
+end

data/lib/prawn/core/text/wrap.rb

@@ -0,0 +1,80 @@
+require "prawn/core/text/line_wrap"
+
+module Prawn
+  module Core
+    module Text
+      module Wrap #:nodoc:
+
+        def initialize(text, options)
+          @line_wrap = Prawn::Core::Text::LineWrap.new
+        end
+
+        # #wrap is part of the developer API. Override it in extensions to Prawn
+        # that inherit Text::Box but need a different placement algorithm.
+        # #wrap is where the actual placement of text happens. If @inked is
+        # false, then all the placement computations should be performed, and
+        # unprinted text returned, but no text should actually be drawn to the
+        # PDF. This enables look-ahead computations that need to know whether all
+        # the text was printed under a set of conditions or how tall the text was
+        # under certain conditions.
+        #
+        # #wrap is called from several places within box.rb and relies on
+        # certain conditions established by render. Do not call #wrap from
+        # outside of Text::Box or its descendants.
+        #
+        # #wrap should set the following instance variables:
+        #   <tt>@text</tt>:: the text that was printed
+        #   <tt>@line_height</tt>:: the height of the last printed line
+        #   <tt>@descender</tt>:: the descender height of the last printed line
+        #   <tt>@ascender</tt>:: the ascender heigth of the last printed line
+        #   <tt>@baseline_y</tt>:: the base line of the last printed line
+        #
+        # Returns any unprinted text
+        #
+        def wrap(text) #:nodoc:
+          @text = nil
+          remaining_text = text
+          @line_height = @document.font.height
+          @descender   = @document.font.descender
+          @ascender    = @document.font.ascender
+          @baseline_y  = -@ascender
+
+          printed_lines = []
+
+          while remaining_text &&
+              remaining_text.length > 0 &&
+              @baseline_y.abs + @descender <= @height
+            line_to_print = @line_wrap.wrap_line(remaining_text.first_line,
+                                                 :document => @document,
+                                                 :kerning => @kerning,
+                                                 :width => available_width)
+
+            remaining_text = remaining_text.slice(@line_wrap.consumed_char_count..
+                                                  remaining_text.length)
+            include_ellipses = (@overflow == :ellipses && last_line? &&
+                                remaining_text.length > 0)
+            printed_lines << draw_line(line_to_print, @line_wrap.width,
+                                       word_spacing_for_this_line, include_ellipses)
+            @baseline_y -= (@line_height + @leading)
+            break if @single_line
+          end
+
+          @text = printed_lines.join("\n")
+
+          remaining_text
+        end
+
+        private
+
+        def word_spacing_for_this_line
+          if @align != :justify || @line_wrap.width.to_f / available_width.to_f < 0.75
+            0
+          else
+            (available_width - @line_wrap.width) / @line_wrap.space_count
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/prawn/core/text.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+# prawn/core/text.rb : Implements low level text helpers for Prawn
+#
+# Copyright January 2010, Daniel Nelson.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+ruby_18 { $KCODE="U" }
+
+module Prawn
+  module Core
+    module Text #:nodoc:
+
+      # These should be used as a base. Extensions may build on this list
+      #
+      VALID_OPTIONS = [:kerning, :size, :style]
+
+      attr_reader :skip_encoding
+
+      # Low level text placement method. All font and size alterations
+      # should already be set
+      #
+      def draw_text!(text, options)
+        x,y = map_to_absolute(options[:at])
+        add_text_content(text,x,y,options)
+      end
+
+      # Low level call to set the current font style and extract text options from
+      # an options hash. Should be called from within a save_font block
+      #
+      def process_text_options(options)
+        if options[:style]
+          raise "Bad font family" unless font.family
+          font(font.family, :style => options[:style])
+        end
+
+        # must compare against false to keep kerning on as default
+        unless options[:kerning] == false
+          options[:kerning] = font.has_kerning_data?
+        end
+
+        options[:size] ||= font_size
+      end
+
+      # Document wide setting of whether or not to use kerning with text
+      # Defaults to true
+      # Can be overridden using the :kerning text option
+      #
+      def default_kerning?
+        return true if @default_kerning.nil?
+        @default_kerning
+      end
+
+      def default_kerning(boolean)
+        @default_kerning = boolean
+      end
+
+      alias_method :default_kerning=, :default_kerning
+
+      # Increases or decreases the space between characters.
+      # For horizontal text, a positive value will increase the space.
+      # For veritical text, a positive value will decrease the space.
+      #
+      def character_spacing(amount=nil)
+        return @character_spacing || 0 if amount.nil?
+        @character_spacing = amount
+        add_content "\n%.3f Tc" % amount
+        yield
+        add_content "\n0 Tc"
+        @character_spacing = 0
+      end
+
+      # Increases or decreases the space between words.
+      # For horizontal text, a positive value will increase the space.
+      # For veritical text, a positive value will decrease the space.
+      #
+      def word_spacing(amount=nil)
+        return @word_spacing || 0 if amount.nil?
+        @word_spacing = amount
+        add_content "\n%.3f Tw" % amount
+        yield
+        add_content "\n0 Tw"
+        @word_spacing = 0
+      end
+
+      private
+
+      def add_text_content(text, x, y, options)
+        chunks = font.encode_text(text,options)
+
+        add_content "\nBT"
+
+        if options[:rotate]
+          rad = options[:rotate].to_i * Math::PI / 180
+          arr = [ Math.cos(rad), Math.sin(rad), -Math.sin(rad), Math.cos(rad), x, y ]
+          add_content "%.3f %.3f %.3f %.3f %.3f %.3f Tm" % arr
+        else
+          add_content "#{x} #{y} Td"
+        end
+
+        chunks.each do |(subset, string)|
+          font.add_to_current_page(subset)
+          add_content "/#{font.identifier_for(subset)} #{font_size} Tf"
+
+          operation = options[:kerning] && string.is_a?(Array) ? "TJ" : "Tj"
+          add_content Prawn::Core::PdfObject(string, true) << " " << operation
+        end
+
+        add_content "ET\n"
+      end
+    end
+
+  end
+end

data/lib/prawn/core.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+# Prawn : A library for PDF generation in Ruby
+#
+# Copyright April 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "set"
+
+%w[ttfunk/lib].each do |dep|
+  $LOAD_PATH.unshift(File.dirname(__FILE__) + "/../../vendor/#{dep}")
+end
+
+begin
+  require 'ttfunk'
+rescue LoadError
+  puts "Failed to load ttfunk. If you are running Prawn from git:"
+  puts "  git submodule init"
+  puts "  git submodule update"
+  exit
+end
+
+module Prawn
+  extend self
+
+  file = __FILE__
+  file = File.readlink(file) if File.symlink?(file)
+  dir  = File.dirname(file)
+                          
+  # The base source directory for Prawn as installed on the system
+  #
+  BASEDIR = File.expand_path(File.join(dir, '..', '..'))
+  
+  VERSION = "0.10.2"
+  
+  extend self
+
+  # Whe set to true, Prawn will verify hash options to ensure only valid keys
+  # are used.  Off by default.
+  #
+  # Example:
+  #   >> Prawn::Document.new(:tomato => "Juicy")
+  #   Prawn::Errors::UnknownOption: 
+  #   Detected unknown option(s): [:tomato]
+  #   Accepted options are: [:page_size, :page_layout, :left_margin, ...]
+  #
+  attr_accessor :debug
+  
+  def verify_options(accepted, actual) #:nodoc:
+    return unless debug || $DEBUG
+    unless (act=Set[*actual.keys]).subset?(acc=Set[*accepted])
+      raise Prawn::Errors::UnknownOption,
+        "\nDetected unknown option(s): #{(act - acc).to_a.inspect}\n" <<
+        "Accepted options are: #{accepted.inspect}"
+    end
+    yield if block_given?
+  end
+  
+  module Configurable #:nodoc:
+    def configuration(*args)
+      @config ||= Marshal.load(Marshal.dump(default_configuration))
+      if Hash === args[0]
+        @config.update(args[0])
+      elsif args.length > 1
+        @config.values_at(*args)
+      elsif args.length == 1
+        @config[args[0]]
+      else
+        @config
+      end
+    end
+    
+    alias_method :C, :configuration
+  end
+end
+ 
+require "prawn/compatibility"
+require "prawn/errors"
+require "prawn/core/pdf_object"
+require "prawn/core/reference"
+require "prawn/core/page"
+require "prawn/core/object_store"
+require "prawn/core/document_state"
+require "prawn/core/literal_string"
+require "prawn/core/byte_string"
+require "prawn/core/name_tree"
+require "prawn/core/annotations"
+require "prawn/core/destinations"
+