alphasights-prawn 0.10.0

data/lib/prawn/text/formatted.rb

@@ -0,0 +1,4 @@
+require "prawn/core/text/formatted/wrap"
+require "prawn/text/formatted/box"
+require "prawn/text/formatted/parser"
+require "prawn/text/formatted/fragment"

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

@@ -0,0 +1,228 @@
+# encoding: utf-8
+
+# text/formatted/rectangle.rb : Implements text boxes with 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 Text
+    module Formatted
+
+      # Draws the requested formatted text into a box. When the text overflows
+      # the rectangle shrink to fit or truncate the text. Text boxes are
+      # independent of the document y position.
+      #
+      # == Formatted Text Array
+      #
+      # Formatted text is comprised of an array of hashes, where each hash
+      # defines text and format information. As of the time of writing, the
+      # following hash options are supported:
+      #
+      # <tt>:text</tt>::
+      #     the text to format according to the other hash options
+      # <tt>:styles</tt>::
+      #     an array of styles to apply to this text. Available styles include
+      #     :bold, :italic, :underline, :strikethrough, :subscript, and
+      #     :superscript
+      # <tt>:size</tt>::
+      #     a number denoting the font size to apply to this text
+      # <tt>:character_spacing</tt>::
+      #     a number denoting how much to increase or decrease the default
+      #     spacing between characters
+      # <tt>:font</tt>::
+      #     the name of a font. The name must be an AFM font with the desired
+      #     faces or must be a font that is already registered using
+      #     Prawn::Document#font_families
+      # <tt>:color</tt>::
+      #     anything compatible with Prawn::Graphics::Color#fill_color and
+      #     Prawn::Graphics::Color#stroke_color
+      # <tt>:link</tt>::
+      #     a URL to which to create a link. A clickable link will be created
+      #     to that URL. Note that you must explicitly underline and color using
+      #     the appropriate tags if you which to draw attention to the link
+      # <tt>:anchor</tt>::
+      #     a destination that has already been or will be registered using
+      #     Prawn::Core::Destinations#add_dest. A clickable link will be
+      #     created to that destination. Note that you must explicitly underline
+      #     and color using the appropriate tags if you which to draw attention
+      #     to the link
+      # <tt>:callback</tt>::
+      #     an object (or array of such objects) with two methods:
+      #     #render_behind and #render_in_front, which are called immediately
+      #     prior to and immediately after rendring the text fragment and which
+      #     are passed the fragment as an argument
+      #
+      # == Example
+      #
+      #   formatted_text_box([{ :text => "hello" },
+      #                       { :text => "world",
+      #                         :size => 24,
+      #                         :styles => [:bold, :italic] }])
+      #
+      # == Options
+      #
+      # Accepts the same options as Text::Box with the below exceptions
+      #
+      # <tt>:overflow</tt>::
+      #     does not accept :ellipses
+      #
+      # == Returns
+      #
+      # Returns a formatted text array representing any text that did not print
+      # under the current settings.
+      #
+      # == Exceptions
+      #
+      # Raises "Bad font family" if no font family is defined for the current font
+      #
+      # Raises <tt>Prawn::Errrors::CannotFit</tt> if not wide enough to print
+      # any text
+      #
+      # Raises <tt>NotImplementedError</tt> if <tt>:ellipses</tt> <tt>overflow</tt>
+      # option included
+      #
+      def formatted_text_box(array, options)
+        Text::Formatted::Box.new(array, options.merge(:document => self)).render
+      end
+
+      # Generally, one would use the Prawn::Text::Formatted#formatted_text_box
+      # convenience method. However, using Text::Formatted::Box.new in
+      # conjunction with #render(:dry_run => true) enables one to do look-ahead
+      # calculations prior to placing text on the page, or to determine how much
+      # vertical space was consumed by the printed text
+      #
+      class Box < Prawn::Text::Box
+        include Prawn::Core::Text::Formatted::Wrap
+
+        def initialize(array, options={})
+          super(array, options)
+          if @overflow == :ellipses
+            raise NotImplementedError, "ellipses overflow unavailable with" +
+              "formatted box"
+          end
+        end
+
+        # The height actually used during the previous <tt>render</tt>
+        # 
+        def height
+          return 0 if @baseline_y.nil? || @descender.nil?
+          @baseline_y.abs + @line_height - @ascender
+        end
+
+        # <tt>fragment</tt> is a Prawn::Text::Formatted::Fragment object
+        #
+        def draw_fragment(fragment, accumulated_width=0, line_width=0, word_spacing=0) #:nodoc:
+          case(@align)
+          when :left, :justify
+            x = @at[0]
+          when :center
+            x = @at[0] + @width * 0.5 - line_width * 0.5
+          when :right
+            x = @at[0] + @width - line_width
+          end
+
+          x += accumulated_width
+
+          y = @at[1] + @baseline_y
+
+          y += fragment.y_offset
+
+          fragment.left = x
+          fragment.baseline = y
+
+          draw_fragment_underlays(fragment)
+
+          if @inked
+            if @align == :justify
+              @document.word_spacing(word_spacing) {
+                @document.draw_text!(fragment.text, :at => [x, y],
+                                     :kerning => @kerning)
+              }
+            else
+              @document.draw_text!(fragment.text, :at => [x, y],
+                                   :kerning => @kerning)
+            end
+
+            draw_fragment_overlays(fragment)
+          end
+        end
+
+        private
+
+        def original_text
+          @original_array.collect { |hash| hash.dup }
+        end
+
+        def original_text=(array)
+          @original_array = array
+        end
+
+        def normalize_encoding
+          array = original_text
+          array.each do |hash|
+            hash[:text] = @document.font.normalize_encoding(hash[:text])
+          end
+          array
+        end
+
+        def move_baseline_down
+          if @baseline_y == 0
+            @baseline_y  = -@ascender
+          else
+            @baseline_y -= (@line_height + @leading)
+          end
+        end
+
+        def draw_fragment_underlays(fragment)
+          fragment.callback_objects.each do |obj|
+            obj.render_behind(fragment) if obj.respond_to?(:render_behind)
+          end
+        end
+
+        def draw_fragment_overlays(fragment)
+          draw_fragment_overlay_styles(fragment)
+          draw_fragment_overlay_link(fragment)
+          draw_fragment_overlay_anchor(fragment)
+          fragment.callback_objects.each do |obj|
+            obj.render_in_front(fragment) if obj.respond_to?(:render_in_front)
+          end
+        end
+
+        def draw_fragment_overlay_link(fragment)
+          return unless fragment.link
+          box = fragment.absolute_bounding_box
+          @document.link_annotation(box,
+                                    :Border => [0, 0, 0],
+                                    :A => { :Type => :Action,
+                                            :S => :URI,
+                          :URI => Prawn::Core::LiteralString.new(fragment.link) })
+        end
+
+        def draw_fragment_overlay_anchor(fragment)
+          return unless fragment.anchor
+          box = fragment.absolute_bounding_box
+          @document.link_annotation(box,
+                                    :Border => [0, 0, 0],
+                                    :Dest => fragment.anchor)
+        end
+
+        def draw_fragment_overlay_styles(fragment)
+          underline = fragment.styles.include?(:underline)
+          if underline
+            @document.stroke_line(fragment.underline_points)
+          end
+          
+          strikethrough = fragment.styles.include?(:strikethrough)
+          if strikethrough
+            @document.stroke_line(fragment.strikethrough_points)
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+# text/formatted/fragment.rb : Implements information about a formatted fragment
+#
+# Copyright March 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
+
+      # Prawn::Text::Formatted::Fragment is a state store for a formatted text
+      # fragment. It does not render anything.
+      #
+      class Fragment
+
+        attr_reader :text, :format_state
+        attr_writer :width
+        attr_accessor :line_height, :descender, :ascender
+        attr_accessor :word_spacing, :left, :baseline
+
+        def initialize(text, format_state, document)
+          @text = text
+          @format_state = format_state
+          @document = document
+          @word_spacing = 0
+        end
+
+        def width
+          if @word_spacing == 0 then @width
+          else @width + @word_spacing * @text.count(" ")
+          end
+        end
+
+        def height
+          top - bottom
+        end
+
+        def subscript?
+          styles.include?(:subscript)
+        end
+
+        def superscript?
+          styles.include?(:superscript)
+        end
+
+        def y_offset
+          if subscript? then -descender
+          elsif superscript? then 0.85 * ascender
+          else 0
+          end
+        end
+
+        def bounding_box
+          [left, bottom, right, top]
+        end
+
+        def absolute_bounding_box
+          box = bounding_box
+          box[0] += @document.bounds.absolute_left
+          box[2] += @document.bounds.absolute_left
+          box[1] += @document.bounds.absolute_bottom
+          box[3] += @document.bounds.absolute_bottom
+          box
+        end
+
+        def underline_points
+          y = baseline - 1.25
+          [[left, y], [right, y]]
+        end
+
+        def strikethrough_points
+          y = baseline + ascender * 0.3
+          [[left, y], [right, y]]
+        end
+
+        def styles
+          @format_state[:styles] || []
+        end
+
+        def link
+          @format_state[:link]
+        end
+
+        def anchor
+          @format_state[:anchor]
+        end
+
+        def color
+          @format_state[:color]
+        end
+
+        def font
+          @format_state[:font]
+        end
+
+        def size
+          @format_state[:size]
+        end
+
+        def character_spacing
+          @format_state[:character_spacing] ||
+            @document.character_spacing
+        end
+
+        def callback_objects
+          callback = @format_state[:callback]
+          if callback.nil?
+            []
+          elsif callback.is_a?(Array)
+            callback
+          else
+            [callback]
+          end
+        end
+
+        def right
+          left + width
+        end
+
+        def top
+          baseline + ascender
+        end
+
+        def bottom
+          baseline - descender
+        end
+
+        def top_left
+          [left, top]
+        end
+
+        def top_right
+          [right, top]
+        end
+
+        def bottom_right
+          [right, bottom]
+        end
+
+        def bottom_left
+          [left, bottom]
+        end
+
+        def absolute_left
+          absolute_bounding_box[0]
+        end
+
+        def absolute_right
+          absolute_bounding_box[2]
+        end
+
+        def absolute_top
+          absolute_bounding_box[3]
+        end
+
+        def absolute_bottom
+          absolute_bounding_box[1]
+        end
+
+        def absolute_top_left
+          [absolute_left, absolute_top]
+        end
+
+        def absolute_top_right
+          [absolute_right, absolute_top]
+        end
+
+        def absolute_bottom_left
+          [absolute_left, absolute_bottom]
+        end
+
+        def absolute_bottom_right
+          [absolute_right, absolute_bottom]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# 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
+
+        def self.to_array(string)
+          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]+"
+          regex = Regexp.new(regex_string, Regexp::MULTILINE)
+          tokens = string.scan(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?
+        end
+
+        private
+
+        def self.array_from_tokens(tokens)
+          array = []
+          styles = []
+          colors = []
+          link = nil
+          anchor = 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
+            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?
+              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,
+                           :link => link,
+                           :anchor => anchor,
+                           :font => fonts.last,
+                           :size => sizes.last,
+                           :character_spacing => character_spacings.last }
+              end
+            end
+          end
+          array
+        end
+
+      end
+    end
+  end
+end