nurettin-prawn 1.0.0.rc1

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

@@ -0,0 +1,253 @@
+# 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 :format_state, :text
+        attr_writer :width
+        attr_accessor :line_height, :descender, :ascender
+        attr_accessor :word_spacing, :left, :baseline
+
+        def initialize(text, format_state, document)
+          @format_state = format_state
+          @document = document
+          @word_spacing = 0
+
+          # keep the original value of "text", so we can reinitialize @text if formatting parameters
+          #   like text direction are changed
+          @original_text = text
+          @text = process_text(@original_text)
+        end
+
+        def width
+          if @word_spacing == 0 then @width
+          else @width + @word_spacing * space_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 direction
+          @format_state[:direction]
+        end
+
+        def default_direction=(direction)
+          unless @format_state[:direction]
+            @format_state[:direction] = direction
+            @text = process_text(@original_text)
+          end
+        end
+
+        def include_trailing_white_space!
+          @format_state.delete(:exclude_trailing_white_space)
+          @text = process_text(@original_text)
+        end
+
+        def space_count
+          @text.count(" ")
+        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
+
+        private
+
+        def process_text(text)
+          string = strip_zero_width_spaces(text)
+          if exclude_trailing_white_space?
+            string = process_soft_hyphens(string.rstrip)
+          end
+          case direction
+          when :rtl
+            if ruby_18 { true }
+              string.scan(/./mu).reverse.join
+            else
+              string.reverse
+            end
+          else
+            string
+          end
+        end
+
+        def exclude_trailing_white_space?
+          @format_state[:exclude_trailing_white_space]
+        end
+
+        def normalized_soft_hyphen
+          @format_state[:normalized_soft_hyphen]
+        end
+
+        def process_soft_hyphens(string)
+          if string.length > 0 && normalized_soft_hyphen
+            ruby_19 {
+              if string.encoding != normalized_soft_hyphen.encoding
+                string.force_encoding(normalized_soft_hyphen.encoding)
+              end
+            }
+            string[0..-2].gsub(normalized_soft_hyphen, "") + string[-1..-1]
+          else
+            string
+          end
+        end
+
+        def strip_zero_width_spaces(string)
+          if !"".respond_to?(:encoding) || string.encoding.to_s == "UTF-8"
+            string.gsub(Prawn::Text::ZWSP, "")
+          else
+            string
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# 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
+
+        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]+"
+          regex = Regexp.new(regex_string, Regexp::MULTILINE)
+        end
+
+        def self.to_array(string)
+          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
+          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