prawn 0.12.0 → 0.13.0

data/examples/text/indent_paragraphs.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-#
-# Example of two ways of indenting paragraphs
-#
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-Prawn::Document.generate "indent_paragraphs.pdf" do |pdf|
-  hello = "hello " * 50
-  world = "world " * 50
-  string = hello + "©\n" + world + "©"
-  pdf.text(string, :indent_paragraphs => 60, :align => :justify)
-
-  pdf.move_cursor_to(pdf.font.height)
-  pdf.text(string, :indent_paragraphs => 60, :align => :justify)
-
-  pdf.move_cursor_to(pdf.font.height * 3)
-  pdf.text(string, :indent_paragraphs => 60, :align => :justify)
-
-  # can also indent using a non-breaking space
-  nbsp = Prawn::Text::NBSP
-  pdf.text("\n\n\n\n#{nbsp * 10}" + hello + "\n#{nbsp * 10}" + world, :align => :justify)
-end

data/lib/prawn/core.rb

@@ -1,85 +0,0 @@
-# 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, '..', '..'))
-
-  # 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"
-

data/lib/prawn/core/text/formatted/arranger.rb

@@ -1,294 +0,0 @@
-# encoding: utf-8
-
-# core/text/formatted/arranger.rb : Implements a data structure for 2-stage
-#                                   processing of lines of formatted text
-#
-# Copyright February 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
-      module Formatted #:nodoc:
-
-        class Arranger #:nodoc:
-          attr_reader :max_line_height
-          attr_reader :max_descender
-          attr_reader :max_ascender
-
-          # The following present only for testing purposes
-          attr_reader :unconsumed
-          attr_reader :consumed
-          attr_reader :fragments
-          attr_reader :current_format_state
-
-          def initialize(document, options={})
-            @document = document
-            @fragments = []
-            @unconsumed = []
-            @kerning = options[:kerning]
-          end
-
-          def space_count
-            if @unfinalized_line
-              raise "Lines must be finalized before calling #space_count"
-            end
-            @fragments.inject(0) do |sum, fragment|
-              sum + fragment.space_count
-            end
-          end
-
-          def line_width
-            if @unfinalized_line
-              raise "Lines must be finalized before calling #line_width"
-            end
-            @fragments.inject(0) do |sum, fragment|
-              sum + fragment.width
-            end
-          end
-
-          def line
-            if @unfinalized_line
-              raise "Lines must be finalized before calling #line"
-            end
-            @fragments.collect do |fragment|
-              if ruby_18 { true }
-                fragment.text
-              else
-                fragment.text.dup.force_encoding("utf-8")
-              end
-            end.join
-          end
-
-          def finalize_line
-            @unfinalized_line = false
-            omit_trailing_whitespace_from_line_width
-            @fragments = []
-            @consumed.each do |hash|
-              text = hash[:text]
-              format_state = hash.dup
-              format_state.delete(:text)
-              fragment = Prawn::Text::Formatted::Fragment.new(text,
-                                                              format_state,
-                                                              @document)
-              @fragments << fragment
-              set_fragment_measurements(fragment)
-              set_line_measurement_maximums(fragment)
-            end
-          end
-
-          def format_array=(array)
-            initialize_line
-            @unconsumed = []
-            array.each do |hash|
-              hash[:text].scan(/[^\n]+|\n/) do |line|
-                @unconsumed << hash.merge(:text => line)
-              end
-            end
-          end
-
-          def initialize_line
-            @unfinalized_line = true
-            @max_line_height = 0
-            @max_descender = 0
-            @max_ascender = 0
-
-            @consumed = []
-            @fragments = []
-          end
-
-          def finished?
-            @unconsumed.length == 0
-          end
-
-          def next_string
-            unless @unfinalized_line
-              raise "Lines must not be finalized when calling #next_string"
-            end
-            hash = @unconsumed.shift
-            if hash.nil?
-              nil
-            else
-              @consumed << hash.dup
-              @current_format_state = hash.dup
-              @current_format_state.delete(:text)
-              hash[:text]
-            end
-          end
-
-          def preview_next_string
-            hash = @unconsumed.first
-            if hash.nil? then nil
-            else hash[:text]
-            end
-          end
-
-          def apply_color_and_font_settings(fragment, &block)
-            if fragment.color
-              original_fill_color = @document.fill_color
-              original_stroke_color = @document.stroke_color
-              @document.fill_color(*fragment.color)
-              @document.stroke_color(*fragment.color)
-              apply_font_settings(fragment, &block)
-              @document.stroke_color = original_stroke_color
-              @document.fill_color = original_fill_color
-            else
-              apply_font_settings(fragment, &block)
-            end
-          end
-
-          def apply_font_settings(fragment=nil, &block)
-            if fragment.nil?
-              font = current_format_state[:font]
-              size = current_format_state[:size]
-              character_spacing = current_format_state[:character_spacing] ||
-                                  @document.character_spacing
-              styles = current_format_state[:styles]
-              font_style = font_style(styles)
-            else
-              font = fragment.font
-              size = fragment.size
-              character_spacing = fragment.character_spacing
-              styles = fragment.styles
-              font_style = font_style(styles)
-            end
-
-            @document.character_spacing(character_spacing) do
-              if font || font_style != :normal
-                raise "Bad font family" unless @document.font.family
-                @document.font(font || @document.font.family, :style => font_style) do
-                  apply_font_size(size, styles, &block)
-                end
-              else
-                apply_font_size(size, styles, &block)
-              end
-            end
-          end
-
-          def update_last_string(printed, unprinted, normalized_soft_hyphen=nil)
-            return if printed.nil?
-            if printed.empty?
-              @consumed.pop
-            else
-              @consumed.last[:text] = printed
-              if normalized_soft_hyphen
-                @consumed.last[:normalized_soft_hyphen] = normalized_soft_hyphen
-              end
-            end
-
-            unless unprinted.empty?
-              @unconsumed.unshift(@current_format_state.merge(:text => unprinted))
-            end
-
-            load_previous_format_state if printed.empty?
-          end
-
-          def retrieve_fragment
-            if @unfinalized_line
-              raise "Lines must be finalized before fragments can be retrieved"
-            end
-            @fragments.shift
-          end
-
-          def repack_unretrieved
-            new_unconsumed = []
-            while fragment = retrieve_fragment
-              fragment.include_trailing_white_space!
-              new_unconsumed << fragment.format_state.merge(:text => fragment.text)
-            end
-            @unconsumed = new_unconsumed.concat(@unconsumed)
-          end
-
-          def font_style(styles)
-            if styles.nil?
-              :normal
-            elsif styles.include?(:bold) && styles.include?(:italic)
-              :bold_italic
-            elsif styles.include?(:bold)
-              :bold
-            elsif styles.include?(:italic)
-              :italic
-            else
-              :normal
-            end
-          end
-
-          private
-
-          def load_previous_format_state
-            if @consumed.empty?
-              @current_format_state = {}
-            else
-              hash = @consumed.last
-              @current_format_state = hash.dup
-              @current_format_state.delete(:text)
-            end
-          end
-
-          def apply_font_size(size, styles)
-            if subscript?(styles) || superscript?(styles)
-              relative_size = 0.583
-              if size.nil?
-                size = @document.font_size * relative_size
-              else
-                size = size * relative_size
-              end
-            end
-            if size.nil?
-              yield
-            else
-              @document.font_size(size) { yield }
-            end
-          end
-
-          def subscript?(styles)
-            if styles.nil? then false
-            else styles.include?(:subscript)
-            end
-          end
-
-          def superscript?(styles)
-            if styles.nil? then false
-            else styles.include?(:superscript)
-            end
-          end
-
-          def omit_trailing_whitespace_from_line_width
-            @consumed.reverse_each do |hash|
-              if hash[:text] == "\n"
-                break
-              elsif hash[:text].strip.empty? && @consumed.length > 1
-                # this entire fragment is trailing white space
-                hash[:exclude_trailing_white_space] = true
-              else
-                # this fragment contains the first non-white space we have
-                # encountered since the end of the line
-                hash[:exclude_trailing_white_space] = true
-                break
-              end
-            end
-          end
-
-          def set_fragment_measurements(fragment)
-            apply_font_settings(fragment) do
-              fragment.width = @document.width_of(fragment.text,
-                                                  :kerning => @kerning)
-              fragment.line_height = @document.font.height
-              fragment.descender = @document.font.descender
-              fragment.ascender = @document.font.ascender
-            end
-          end
-
-          def set_line_measurement_maximums(fragment)
-            @max_line_height = [@max_line_height, fragment.line_height].max
-            @max_descender = [@max_descender, fragment.descender].max
-            @max_ascender = [@max_ascender, fragment.ascender].max
-          end
-          
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,273 +0,0 @@
-# encoding: utf-8
-
-# core/text/formatted/line_wrap.rb : Implements individual line wrapping of 
-#                                    formatted text
-#
-# Copyright February 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
-      module Formatted #:nodoc:
-        
-        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
-          attr_reader :space_count
-
-          # Whether this line is the last line in the paragraph
-          def paragraph_finished?
-            @newline_encountered || is_next_string_newline? || @arranger.finished?
-          end
-
-          # Work in conjunction with the Prawn::Core::Formatted::Arranger
-          # defined in the :arranger option to determine what formatted text
-          # will fit within the width defined by the :width option
-          #
-          def wrap_line(options)
-            initialize_line(options)
-
-            while fragment = @arranger.next_string
-              @fragment_output = ""
-
-              fragment.lstrip! if first_fragment_on_this_line?(fragment)
-              next if empty_line?(fragment)
-
-              unless apply_font_settings_and_add_fragment_to_line(fragment)
-                break
-              end
-            end
-            @arranger.finalize_line
-            @accumulated_width = @arranger.line_width
-            @space_count = @arranger.space_count
-            @arranger.line
-          end
-
-          private
-
-          def first_fragment_on_this_line?(fragment)
-            line_empty? && fragment != "\n"
-          end
-
-          def empty_line?(fragment)
-            empty = line_empty? && fragment.empty? && is_next_string_newline?
-            @arranger.update_last_string("", "", soft_hyphen) if empty
-            empty
-          end
-
-          def is_next_string_newline?
-            @arranger.preview_next_string == "\n"
-          end
-
-          def apply_font_settings_and_add_fragment_to_line(fragment)
-            result = nil
-            @arranger.apply_font_settings do
-              result = add_fragment_to_line(fragment)
-            end
-            result
-          end
-
-          # returns true iff all text was printed without running into the end of
-          # the line
-          #
-          def add_fragment_to_line(fragment)
-            if fragment == ""
-              true
-            elsif fragment == "\n"
-              @newline_encountered = true
-              false
-            else
-              fragment.scan(scan_pattern).each do |segment|
-                if segment == zero_width_space
-                  segment_width = 0
-                else
-                  segment_width = @document.width_of(segment, :kerning => @kerning)
-                end
-
-                if @accumulated_width + segment_width <= @width
-                  @accumulated_width += segment_width
-                  @fragment_output += segment
-                else
-                  end_of_the_line_reached(segment)
-                  fragment_finished(fragment)
-                  return false
-                end
-              end
-
-              fragment_finished(fragment)
-              true
-            end
-          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|[#{zero_width_space}#{soft_hyphen}#{hyphen}]")
-          end
-
-          def break_chars
-            "#{whitespace}#{soft_hyphen}#{hyphen}"
-          end
-
-          def whitespace
-            " \\t#{zero_width_space}"
-          end
-
-          def hyphen
-            "-"
-          end
-
-          def soft_hyphen
-            @document.font.normalize_encoding(Prawn::Text::SHY)
-          end
-
-          def zero_width_space
-            @document.font.unicode? ? Prawn::Text::ZWSP : ""
-          end
-
-          def line_empty?
-            @line_empty && @accumulated_width == 0
-          end
-
-          def initialize_line(options)
-            @document = options[:document]
-            @kerning = options[:kerning]
-            @width = options[:width]
-
-            @accumulated_width = 0
-            @line_empty = true
-            @line_contains_more_than_one_word = false
-
-            @arranger = options[:arranger]
-            @arranger.initialize_line
-
-            @newline_encountered = false
-            @line_full = false
-          end
-
-          def fragment_finished(fragment)
-            if fragment == "\n"
-              @newline_encountered = true
-              @line_empty = false
-            else
-              update_output_based_on_last_fragment(fragment, soft_hyphen)
-              update_line_status_based_on_last_output
-              determine_whether_to_pull_preceding_fragment_to_join_this_one(fragment)
-            end
-            remember_this_fragment_for_backward_looking_ops
-          end
-
-          def update_output_based_on_last_fragment(fragment, normalized_soft_hyphen=nil)
-            remaining_text = fragment.slice(@fragment_output.length..fragment.length)
-            raise Errors::CannotFit if line_finished? && line_empty? &&
-              @fragment_output.empty? && !fragment.strip.empty?
-            @arranger.update_last_string(@fragment_output, remaining_text, normalized_soft_hyphen)
-          end
-
-          def determine_whether_to_pull_preceding_fragment_to_join_this_one(current_fragment)
-            if @fragment_output.empty? &&
-                !current_fragment.empty? &&
-                @line_contains_more_than_one_word
-              unless previous_fragment_ended_with_breakable? ||
-                  fragment_begins_with_breakable?(current_fragment)
-                @fragment_output = @previous_fragment_output_without_last_word
-                update_output_based_on_last_fragment(@previous_fragment)
-              end
-            end
-          end
-
-          def remember_this_fragment_for_backward_looking_ops
-            @previous_fragment = @fragment_output.dup
-            pf = @previous_fragment
-            @previous_fragment_ended_with_breakable = pf =~ /[#{break_chars}]$/
-            last_word = pf.slice(/[^#{break_chars}]*$/)
-            last_word_length = last_word.nil? ? 0 : last_word.length
-            @previous_fragment_output_without_last_word = pf.slice(0, pf.length - last_word_length)
-          end
-
-          def previous_fragment_ended_with_breakable?
-            @previous_fragment_ended_with_breakable
-          end
-
-          def fragment_begins_with_breakable?(fragment)
-            fragment =~ /^[#{break_chars}]/
-          end
-
-          def line_finished?
-            @line_full || paragraph_finished?
-          end
-
-          def update_line_status_based_on_last_output
-            @line_contains_more_than_one_word = true if @fragment_output =~ word_division_scan_pattern
-          end
-
-          def end_of_the_line_reached(segment)
-            update_line_status_based_on_last_output
-            wrap_by_char(segment) unless @line_contains_more_than_one_word
-            @line_full = true
-          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)
-
-            if @accumulated_width + char_width <= @width
-              @accumulated_width += char_width
-              @fragment_output << char
-              true
-            else
-              false
-            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
-end