prawn-git 2.0.1

data/lib/prawn/text/formatted/parser.rb

@@ -0,0 +1,224 @@
+# encoding: utf-8
+
+# text/formatted/parser.rb : Implements a bi-directional parser between a subset
+#                            of html and formatted text arrays
+#
+# Copyright February 2010, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+  module Text
+    module Formatted
+
+      class Parser
+        # @group Extension API
+
+        PARSER_REGEX = begin
+          regex_string = "\n|" +
+                         "<b>|</b>|" +
+                         "<i>|</i>|" +
+                         "<u>|</u>|" +
+                         "<strikethrough>|</strikethrough>|" +
+                         "<sub>|</sub>|" +
+                         "<sup>|</sup>|" +
+                         "<link[^>]*>|</link>|" +
+                         "<color[^>]*>|</color>|" +
+                         "<font[^>]*>|</font>|" +
+                         "<strong>|</strong>|" +
+                         "<em>|</em>|" +
+                         "<a[^>]*>|</a>|" +
+                         "[^<\n]+"
+          Regexp.new(regex_string, Regexp::MULTILINE)
+        end
+
+        def self.format(string, *args)
+          tokens = string.gsub(/<br\s*\/?>/, "\n").scan(PARSER_REGEX)
+          self.array_from_tokens(tokens)
+        end
+
+        def self.to_string(array)
+          prefixes = { :bold => "<b>",
+                       :italic => "<i>",
+                       :underline => "<u>",
+                       :strikethrough => "<strikethrough>",
+                       :subscript => "<sub>",
+                       :superscript => "<sup>" }
+          suffixes = { :bold => "</b>",
+                       :italic => "</i>",
+                       :underline => "</u>",
+                       :strikethrough => "</strikethrough>",
+                       :subscript => "</sub>",
+                       :superscript => "</sup>" }
+          array.collect do |hash|
+            prefix = ""
+            suffix = ""
+            if hash[:styles]
+              hash[:styles].each do |style|
+                prefix = prefix + prefixes[style]
+                suffix = suffixes[style] + suffix
+              end
+            end
+
+            font = hash[:font] ? " name='#{hash[:font]}'" : nil
+            size = hash[:size] ? " size='#{hash[:size]}'" : nil
+            if hash[:character_spacing]
+              character_spacing = " character_spacing='#{hash[:character_spacing]}'"
+            else
+              character_spacing = nil
+            end
+            if font || size || character_spacing
+              prefix = prefix + "<font#{font}#{size}#{character_spacing}>"
+              suffix = "</font>"
+            end
+
+            link = hash[:link] ? " href='#{hash[:link]}'" : nil
+            anchor = hash[:anchor] ? " anchor='#{hash[:anchor]}'" : nil
+            if link || anchor
+              prefix = prefix + "<link#{link}#{anchor}>"
+              suffix = "</link>"
+            end
+
+            if hash[:color]
+              if hash[:color].kind_of?(Array)
+                prefix = prefix + "<color c='#{hash[:color][0]}'" +
+                                        " m='#{hash[:color][1]}'" +
+                                        " y='#{hash[:color][2]}'" +
+                                        " k='#{hash[:color][3]}'>"
+              else
+                prefix = prefix + "<color rgb='#{hash[:color]}'>"
+              end
+              suffix = "</color>"
+            end
+
+            string = hash[:text].gsub("&", "&amp;").gsub(">", "&gt;").gsub("<", "&lt;")
+            prefix + string + suffix
+          end.join
+        end
+
+        def self.array_paragraphs(array) #:nodoc:
+          paragraphs = []
+          paragraph = []
+          previous_string = "\n"
+          scan_pattern = /[^\n]+|\n/
+          array.each do |hash|
+            hash[:text].scan(scan_pattern).each do |string|
+              if string == "\n"
+                paragraph << hash.dup.merge(:text => "\n") if previous_string == "\n"
+                paragraphs << paragraph unless paragraph.empty?
+                paragraph = []
+              else
+                paragraph << hash.dup.merge(:text => string)
+              end
+              previous_string = string
+            end
+          end
+          paragraphs << paragraph unless paragraph.empty?
+          paragraphs
+        end
+
+        private
+
+        def self.array_from_tokens(tokens)
+          array = []
+          styles = []
+          colors = []
+          link = nil
+          anchor = nil
+          local = nil
+          fonts = []
+          sizes = []
+          character_spacings = []
+
+          while token = tokens.shift
+            case token
+            when "<b>", "<strong>"
+              styles << :bold
+            when "<i>", "<em>"
+              styles << :italic
+            when "<u>"
+              styles << :underline
+            when "<strikethrough>"
+              styles << :strikethrough
+            when "<sub>"
+              styles << :subscript
+            when "<sup>"
+              styles << :superscript
+            when "</b>", "</strong>"
+              styles.delete(:bold)
+            when "</i>", "</em>"
+              styles.delete(:italic)
+            when "</u>"
+              styles.delete(:underline)
+            when "</strikethrough>"
+              styles.delete(:strikethrough)
+            when "</sub>"
+              styles.delete(:subscript)
+            when "</sup>"
+              styles.delete(:superscript)
+            when "</link>", "</a>"
+              link = nil
+              anchor = nil
+              local = nil
+            when "</color>"
+              colors.pop
+            when "</font>"
+              fonts.pop
+              sizes.pop
+              character_spacings.pop
+            else
+              if token =~ /^<link[^>]*>$/ or token =~ /^<a[^>]*>$/
+                matches = /href="([^"]*)"/.match(token) || /href='([^']*)'/.match(token)
+                link = matches[1] unless matches.nil?
+
+                matches = /anchor="([^"]*)"/.match(token) || /anchor='([^']*)'/.match(token)
+                anchor = matches[1] unless matches.nil?
+
+                matches = /local="([^"]*)"/.match(token) || /local='([^']*)'/.match(token)
+                local = matches[1] unless matches.nil?
+              elsif token =~ /^<color[^>]*>$/
+                matches = /rgb="#?([^"]*)"/.match(token) || /rgb='#?([^']*)'/.match(token)
+                colors << matches[1] if matches
+
+                matches = /c="#?([^"]*)" +m="#?([^"]*)" +y="#?([^"]*)" +k="#?([^"]*)"/.match(token) ||
+                          /c='#?([^']*)' +m='#?([^']*)' +y='#?([^']*)' +k='#?([^']*)'/.match(token)
+                colors << [matches[1].to_i, matches[2].to_i, matches[3].to_i, matches[4].to_i] if matches
+
+                # intend to support rgb="#ffffff" or rgb='#ffffff',
+                # r="255" g="255" b="255" or r='255' g='255' b='255',
+                # and c="100" m="100" y="100" k="100" or
+                # c='100' m='100' y='100' k='100'
+                # color = { :rgb => "#ffffff" }
+                # color = { :r => 255, :g => 255, :b => 255 }
+                # color = { :c => 100, :m => 100, :y => 100, :k => 100 }
+              elsif token =~ /^<font[^>]*>$/
+                matches = /name="([^"]*)"/.match(token) || /name='([^']*)'/.match(token)
+                fonts << matches[1] unless matches.nil?
+
+                matches = /size="([^"]*)"/.match(token) || /size='([^']*)'/.match(token)
+                sizes << matches[1].to_f unless matches.nil?
+
+                matches = /character_spacing="([^"]*)"/.match(token) || /character_spacing='([^']*)'/.match(token)
+                character_spacings << matches[1].to_f unless matches.nil?
+              else
+                string = token.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&")
+                array << { :text => string,
+                           :styles => styles.dup,
+                           :color => colors.last,
+                           :local => local,
+                           :link => link,
+                           :anchor => anchor,
+                           :font => fonts.last,
+                           :size => sizes.last,
+                           :character_spacing => character_spacings.last }
+              end
+            end
+          end
+          array
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+# wrap.rb: Handles text wrapping for for formatted text
+#
+# Contributed by Daniel Nelson
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require_relative "line_wrap"
+require_relative "arranger"
+
+module Prawn
+  module Text
+    module Formatted #:nodoc:
+      # @private
+
+      module Wrap #:nodoc:
+
+        def initialize(array, options)
+          @line_wrap = Prawn::Text::Formatted::LineWrap.new
+          @arranger = Prawn::Text::Formatted::Arranger.new(@document,
+            :kerning => options[:kerning])
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+        end
+
+
+        # See the developer documentation for PDF::Core::Text#wrap
+        #
+        # Formatted#wrap should set the following variables:
+        #   <tt>@line_height</tt>::
+        #        the height of the tallest fragment in the last printed line
+        #   <tt>@descender</tt>::
+        #        the descender height of the tallest fragment in the last
+        #        printed line
+        #   <tt>@ascender</tt>::
+        #        the ascender heigth of the tallest fragment in the last
+        #        printed line
+        #   <tt>@baseline_y</tt>::
+        #       the baseline of the current line
+        #   <tt>@nothing_printed</tt>::
+        #       set to true until something is printed, then false
+        #   <tt>@everything_printed</tt>::
+        #       set to false until everything printed, then true
+        #
+        # Returns any formatted text that was not printed
+        #
+        def wrap(array) #:nodoc:
+          initialize_wrap(array)
+
+          stop = false
+          while !stop
+            # wrap before testing if enough height for this line because the
+            # height of the highest fragment on this line will be used to
+            # determine the line height
+            @line_wrap.wrap_line(:document => @document,
+                                 :kerning => @kerning,
+                                 :width => available_width,
+                                 :arranger => @arranger,
+                                 :disable_wrap_by_char => @disable_wrap_by_char)
+
+            if enough_height_for_this_line?
+              move_baseline_down
+              print_line
+            else
+              stop = true
+            end
+
+            stop ||= @single_line || @arranger.finished?
+          end
+          @text = @printed_lines.join("\n")
+          @everything_printed = @arranger.finished?
+          @arranger.unconsumed
+        end
+
+        private
+
+        def print_line
+          @nothing_printed = false
+          printed_fragments = []
+          fragments_this_line = []
+
+          word_spacing = word_spacing_for_this_line
+          while fragment = @arranger.retrieve_fragment
+            fragment.word_spacing = word_spacing
+            if fragment.text == "\n"
+              printed_fragments << "\n" if @printed_lines.last == ""
+              break
+            end
+            printed_fragments << fragment.text
+            fragments_this_line << fragment
+          end
+
+          accumulated_width = 0
+          fragments_this_line.reverse! if @direction == :rtl
+          fragments_this_line.each do |fragment_this_line|
+            fragment_this_line.default_direction = @direction
+            format_and_draw_fragment(fragment_this_line, accumulated_width,
+                                     @line_wrap.width, word_spacing)
+            accumulated_width += fragment_this_line.width
+          end
+
+          @printed_lines << printed_fragments.map { |s| s.force_encoding(::Encoding::UTF_8) }.join
+        end
+
+        def word_spacing_for_this_line
+          if @align == :justify &&
+              @line_wrap.space_count > 0 &&
+              !@line_wrap.paragraph_finished?
+            (available_width - @line_wrap.width) / @line_wrap.space_count
+          else
+            0
+          end
+        end
+
+        def enough_height_for_this_line?
+          @line_height = @arranger.max_line_height
+          @descender   = @arranger.max_descender
+          @ascender    = @arranger.max_ascender
+          if @baseline_y == 0
+            diff = @ascender + @descender
+          else
+            diff = @descender + @line_height + @leading
+          end
+          require_relatived_total_height = @baseline_y.abs + diff
+          if require_relatived_total_height > @height + 0.0001
+            # no room for the full height of this line
+            @arranger.repack_unretrieved
+            false
+          else
+            true
+          end
+        end
+
+        def initialize_wrap(array)
+          @text = nil
+          @arranger.format_array = array
+
+          # these values will depend on the maximum value within a given line
+          @line_height = 0
+          @descender   = 0
+          @ascender    = 0
+          @baseline_y  = 0
+
+          @printed_lines = []
+          @nothing_printed = true
+          @everything_printed = false
+        end
+
+        def format_and_draw_fragment(fragment, accumulated_width,
+                                     line_width, word_spacing)
+          @arranger.apply_color_and_font_settings(fragment) do
+            draw_fragment(fragment, accumulated_width,
+                          line_width, word_spacing)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/prawn/utilities.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+# utilities.rb : General-purpose utility classes which don't fit anywhere else
+#
+# Copyright August 2012, Alex Dowad. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'thread'
+
+module Prawn
+
+  # Throughout the Prawn codebase, repeated calculations which can benefit from caching are made
+  # In some cases, caching and reusing results can not only save CPU cycles but also greatly
+  #   reduce memory requirements
+  # But at the same time, we don't want to throw away thread safety
+  # We have two interchangeable thread-safe cache implementations:
+
+  # @private
+  class SynchronizedCache
+    # As an optimization, this could access the hash directly on VMs with a global interpreter lock (like MRI)
+    def initialize
+      @cache = {}
+      @mutex = Mutex.new
+    end
+    def [](key)
+      @mutex.synchronize { @cache[key] }
+    end
+    def []=(key,value)
+      @mutex.synchronize { @cache[key] = value }
+    end
+  end
+
+  # @private
+  class ThreadLocalCache
+    def initialize
+      @cache_id = "cache_#{self.object_id}".to_sym
+    end
+    def [](key)
+      (Thread.current[@cache_id] ||= {})[key]
+    end
+    def []=(key,value)
+      (Thread.current[@cache_id] ||= {})[key] = value
+    end
+  end
+end

data/lib/prawn/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Prawn
+  VERSION = "2.0.1"
+end

data/lib/prawn/view.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+#
+# prawn/view.rb : Implements a mixin for Prawn's DSL
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  # This mixin allows you to create modular Prawn code without the
+  # need to create subclasses of Prawn::Document.
+  #
+  #     class Greeter
+  #       include Prawn::View
+  #
+  #       def initialize(name)
+  #         @name = name
+  #       end
+  #
+  #       def say_hello
+  #         text "Hello, #{@name}!"
+  #       end
+  #
+  #       def say_goodbye
+  #         font("Courier") do
+  #           text "Goodbye, #{@name}!"
+  #         end
+  #       end
+  #    end
+  #
+  #    greeter = Greeter.new("Gregory")
+  #
+  #    greeter.say_hello
+  #    greeter.say_goodbye
+  #
+  #    greeter.save_as("greetings.pdf")
+  #
+  # The short story about why you should use this mixin rather than
+  # creating subclasses of +Prawn::Document+ is that it helps
+  # prevent accidental conflicts between your code and Prawn's
+  # code.
+  #
+  # Here's the slightly longer story...
+  #
+  # By using composition rather than inheritance under the hood, this
+  # mixin allows you to keep your state separate from +Prawn::Document+'s
+  # state, and also will prevent unexpected method name collisions due
+  # to late binding effects.
+  #
+  # This mixin is mostly meant for extending Prawn's functionality
+  # with your own additions, but you can also use it to replace or
+  # wrap existing Prawn methods. Calling +super+ will still work
+  # as expected, and alternatively you can explictly call
+  # +document.some_method+ to delegate to Prawn where needed.
+  module View
+    # @group Experimental API
+
+    # Lazily instantiates a +Prawn::Document+ object.
+    #
+    # You can also redefine this method in your own classes to use
+    # a custom document class.
+    def document
+      @document ||= Prawn::Document.new
+    end
+
+    # Delegates all unhandled calls to object returned by +document+ method.
+    # (which is an instance of Prawn::Document by default)
+    def method_missing(m, *a, &b)
+      return super unless document.respond_to?(m)
+
+      document.send(m, *a, &b)
+    end
+
+    # Syntactic sugar that uses +instance_eval+ under the hood to provide
+    # a block-based DSL.
+    #
+    #    greeter.update do
+    #      say_hello
+    #      say_goodbye
+    #    end
+    #
+    def update(&b)
+      instance_eval(&b)
+    end
+
+    # Syntatic sugar that calls +document.render_file+ under the hood.
+    #
+    #    greeter.save_as("greetings.pdf")
+    def save_as(filename)
+      document.render_file(filename)
+    end
+  end
+end