prawn 0.11.1.pre → 0.11.1

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

@@ -1,211 +0,0 @@
-# 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
-          whitespace_pattern = new_regexp("[#{whitespace}]")
-
-          line.scan(@scan_pattern).each do |segment|
-
-            # Don't let leading white space count against available space
-            if @output.empty? && segment =~ whitespace_pattern
-              @discarded_char_count += segment.length
-              next
-            end
-
-            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
-
-          @discarded_char_count = 0
-          @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 + @discarded_char_count
-
-          unless @output.empty?
-            @output = @output[0..-2].gsub(soft_hyphen, "") + @output[-1..-1]
-          end
-
-          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

@@ -1,82 +0,0 @@
-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.space_count > 0 &&
-              @line_wrap.width.to_f / available_width.to_f >= 0.75
-            (available_width - @line_wrap.width) / @line_wrap.space_count
-          else
-            0
-          end
-        end
-
-      end
-    end
-  end
-end

data/vendor/pdf-inspector/README

@@ -1,18 +0,0 @@
-PDF::Inspector : A tool for analyzing PDF output
-
-This library provides a number of PDF::Reader[0] based tools for use in testing
-PDF output.  Presently, the primary purpose of this tool is to support the 
-tests found in Prawn[1], a pure Ruby PDF generation library.
-
-However, it may be useful to others, so we have made it available on Github[2]
-
-Questions can be directed to the Prawn mailing list[3], but please remember
-that this code is not necessarily suitable for production and has no officially
-planned release date.  
-
-That having been said, patches are welcome!
-
-[0] http://github.com/yob/pdf-reader                                         
-[1] http://github.com/sandal/prawn                                           
-[2] http://github.com/sandal/pdf-inspector              
-[3] http://groups.google.com/group/prawn-ruby

data/vendor/pdf-inspector/lib/pdf/inspector.rb

@@ -1,26 +0,0 @@
-require "rubygems"
-require "pdf/reader"
-require "pdf/inspector/text" 
-require "pdf/inspector/xobject"
-require "pdf/inspector/extgstate"
-require "pdf/inspector/graphics"
-require "pdf/inspector/page"
-
-module PDF
-  class Inspector
-    def self.analyze(output,*args,&block) 
-      obs = self.new(*args, &block)
-      PDF::Reader.string(output,obs)
-      obs  
-    end         
-    
-    def self.analyze_file(filename,*args,&block)
-      analyze(File.open(filename, "rb") { |f| f.read },*args,&block)
-    end  
-    
-    def self.parse(obj)
-      PDF::Reader::Parser.new(
-        PDF::Reader::Buffer.new(StringIO.new(obj)), nil).parse_token
-    end
-  end
-end

data/vendor/pdf-inspector/lib/pdf/inspector/extgstate.rb

@@ -1,18 +0,0 @@
-module PDF
-  class Inspector
-    class ExtGState < Inspector
-      attr_accessor :extgstates
-
-      def initialize
-        @extgstates = []
-      end
-
-      def resource_extgstate(*params)
-        @extgstates << {
-                        :opacity => params[1][:ca],
-                        :stroke_opacity => params[1][:CA]
-                        }
-      end
-    end
-  end
-end

data/vendor/pdf-inspector/lib/pdf/inspector/graphics.rb

@@ -1,131 +0,0 @@
-module PDF
-  class Inspector 
-    module Graphics                   
-      class Line < Inspector
-        attr_accessor :points, :widths
-
-        def initialize
-          @points = []
-          @widths = [] 
-        end  
-
-        def append_line(*params)
-          @points << params
-        end    
-
-        def begin_new_subpath(*params)
-          @points << params
-        end           
-        
-        def set_line_width(params)
-          @widths << params
-        end
-
-      end 
-      
-      class Rectangle < Inspector
-        attr_reader :rectangles
-
-        def initialize
-          @rectangles = []     
-        end
-
-        def append_rectangle(*params) 
-          @rectangles << { :point  => params[0..1],    
-                           :width  => params[2],
-                           :height => params[3]  }     
-        end
-      end
-      
-      class Curve < Inspector
-
-        attr_reader :coords
-
-        def initialize
-          @coords = []          
-        end   
-
-        def begin_new_subpath(*params)   
-          @coords += params
-        end
-
-        def append_curved_segment(*params)
-          @coords += params
-        end           
-
-      end   
-      
-      class Color < Inspector
-        attr_reader :stroke_color, :fill_color, :stroke_color_count, 
-                    :fill_color_count
-
-        def initialize
-          @stroke_color_count = 0
-          @fill_color_count   = 0
-        end
-
-        def set_color_for_stroking_and_special(*params)
-          @stroke_color_count += 1
-          @stroke_color = params
-        end
-
-        def set_color_for_nonstroking_and_special(*params)
-          @fill_color_count += 1
-          @fill_color = params
-        end
-      end 
-      
-      class Dash < Inspector
-        attr_reader :stroke_dash, :stroke_dash_count
-
-        def initialize
-          @stroke_dash_count = 0
-        end
-
-        def set_line_dash(*params)
-          @stroke_dash_count += 1
-          @stroke_dash = params
-        end
-      end
-      
-      class CapStyle < Inspector
-        attr_reader :cap_style, :cap_style_count
-
-        def initialize
-          @cap_style_count = 0
-        end
-
-        def set_line_cap_style(*params)
-          @cap_style_count += 1
-          @cap_style = params[0]
-        end
-      end
-      
-      class JoinStyle < Inspector
-        attr_reader :join_style, :join_style_count
-
-        def initialize
-          @join_style_count = 0
-        end
-
-        def set_line_join_style(*params)
-          @join_style_count += 1
-          @join_style = params[0]
-        end
-      end
-      
-      class Matrix < Inspector
-        attr_reader :matrices
-
-        def initialize
-          @matrices = []
-        end
-
-        def concatenate_matrix(*values)
-          @matrices << values
-        end
-      end
-      
-    end                                
-  end
-end