srdperu-prawn-format 0.1.1.1

data/lib/prawn/format/effects/link.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Prawn
+  module Format
+    module Effects
+
+      class Link
+        def initialize(target, x)
+          @target = target
+          @x = x
+        end
+
+        def finish(document, draw_state)
+          x1 = draw_state[:real_x] + @x
+          x2 = draw_state[:real_x] + draw_state[:dx]
+          y  = draw_state[:real_y] + draw_state[:dy]
+
+          rect = [x1, y + draw_state[:line].descent, x2, y + draw_state[:line].ascent]
+          if @target.match(/^#/)
+	    document.link_annotation(rect, :Dest => @target.sub(/^#/,""), :Border => [0,0,0])
+	  else
+	    document.link_annotation(rect, :Border => [0,0,0], :A => { :Type => :Action, :S => :URI, :URI => Prawn::LiteralString.new(@target) } )
+	  end #new
+        end
+
+        def wrap(document, draw_state)
+          finish(document, draw_state)
+          @x = 0
+        end
+      end
+
+    end
+  end
+end

data/lib/prawn/format/effects/underline.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Prawn
+  module Format
+    module Effects
+
+      class Underline
+        def initialize(from, state)
+          @from = from
+          @state = state
+        end
+
+        def finish(document, draw_state)
+          x1 = draw_state[:x] + @from
+          x2 = draw_state[:x] + draw_state[:dx]
+          y  = draw_state[:y] + draw_state[:dy] - 2
+
+          document.stroke_color(@state.color)
+          document.move_to(x1, y)
+          document.line_to(x2, y)
+          document.stroke
+        end
+
+        def wrap(document, draw_state)
+          finish(document, draw_state)
+          @from = 0
+        end
+      end
+
+    end
+  end
+end

data/lib/prawn/format/instructions/base.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Prawn
+  module Format
+    module Instructions
+
+      class Base
+        attr_reader :state, :ascent, :descent
+
+        def initialize(state)
+          @state = state
+          state.document.font_size(state.font_size) do
+            @height = state.font.height
+            @ascent = state.font.ascender
+            @descent = state.font.descender
+          end
+        end
+
+        def spaces
+          0
+        end
+
+        def width(*args)
+          0
+        end
+
+        def height(*args)
+          @height
+        end
+
+        def break?
+          false
+        end
+
+        def force_break?
+          false
+        end
+
+        def discardable?
+          false
+        end
+
+        def start_verbatim?
+          false
+        end
+
+        def end_verbatim?
+          false
+        end
+
+        def style
+          {}
+        end
+
+        def accumulate(list)
+          list.push(self)
+        end
+      end
+
+    end
+  end
+end

data/lib/prawn/format/instructions/tag_close.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'prawn/format/instructions/base'
+
+module Prawn
+  module Format
+    module Instructions
+
+      class TagClose < Base
+        def self.close(state, tag, draw_state)
+          closer = new(state, tag)
+          closer.draw(state.document, draw_state)
+        end
+
+        attr_reader :tag
+
+        def initialize(state, tag)
+          super(state)
+          @tag = tag
+        end
+
+        def [](property)
+          @tag[:style][property]
+        end
+
+        def draw(document, draw_state, options={})
+          (@tag[:effects] || []).each do |effect|
+            effect.finish(document, draw_state)
+            draw_state[:pending_effects].delete(effect)
+          end
+        end
+
+        def break?
+          force_break?
+        end
+
+        def style
+          @tag[:style]
+        end
+
+        def force_break?
+          @tag[:style][:display] == :break
+        end
+
+        def end_verbatim?
+          @tag[:style][:white_space] == :pre
+        end
+      end
+
+    end
+  end
+end

data/lib/prawn/format/instructions/tag_open.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'prawn/format/instructions/base'
+require 'prawn/format/effects/link'
+require 'prawn/format/effects/underline'
+
+module Prawn
+  module Format
+    module Instructions
+
+      class TagOpen < Base
+        attr_reader :tag
+
+        def initialize(state, tag)
+          super(state)
+          @tag = tag
+        end
+
+        def draw(document, draw_state, options={})
+          draw_width(document, draw_state)
+          draw_destination(document, draw_state)
+          draw_link(document, draw_state)
+          draw_underline(document, draw_state)
+        end
+
+        def start_verbatim?
+          @tag[:style][:white_space] == :pre
+        end
+
+        def style
+          @tag[:style]
+        end
+
+        def width
+          @state.width
+        end
+
+        private
+
+          def draw_width(document, draw_state)
+            if width > 0
+              draw_state[:dx] += width
+              draw_state[:text].move_to(draw_state[:dx], draw_state[:dy])
+            end
+          end
+
+          def draw_destination(document, draw_state)
+            return unless tag[:style][:anchor]
+
+            x = draw_state[:real_x]
+            y = draw_state[:real_y] + draw_state[:dy] + ascent
+
+            label, destination = case tag[:style][:anchor]
+              when /^zoom=([\d\.]+):(.*)$/
+                [$2, document.dest_xyz(x, y, $1.to_f)]
+              when /^fit:(.*)$/
+                [$1, document.dest_fit]
+              when /^fith:(.*)$/
+                [$1, document.dest_fit_horizontally(y)]
+              when /^fitv:(.*)$/
+                [$1, document.dest_fit_vertically(x)]
+              when /^fitb:(.*)$/
+                [$1, document.dest_fit_bounds]
+              when /^fitbh:(.*)$/
+                [$1, document.dest_fit_bounds_horizontally(y)]
+              when /^fitbv:(.*)$/
+                [$1, document.dest_fit_bounds_vertically(x)]
+              else
+                [tag[:style][:anchor], document.dest_fit_bounds]
+              end
+
+            document.add_dest(label, destination)
+          end
+
+          def draw_link(document, draw_state)
+            return unless tag[:style][:target]
+            add_effect(Effects::Link.new(tag[:style][:target], draw_state[:dx]), draw_state)
+          end
+
+          def draw_underline(document, draw_state)
+            return unless tag[:style][:text_decoration] == :underline
+            add_effect(Effects::Underline.new(draw_state[:dx], @state), draw_state)
+          end
+
+          def add_effect(effect, draw_state)
+            tag[:effects] ||= []
+            tag[:effects].push(effect)
+
+            draw_state[:pending_effects].push(effect)
+          end
+      end
+
+    end
+  end
+end

data/lib/prawn/format/instructions/text.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require 'prawn/format/instructions/base'
+
+module Prawn
+  module Format
+    module Instructions
+
+      class Text < Base
+        attr_reader :text
+
+        def initialize(state, text, options={})
+          super(state)
+          @text = text
+          @break = options.key?(:break) ? options[:break] : text.index(/[-\xE2\x80\x94\s]/)
+          @discardable = options.key?(:discardable) ? options[:discardable] : text.index(/\s/)
+          state.font.normalize_encoding(@text) if options.fetch(:normalize, true)
+        end
+
+        def dup
+          self.class.new(state, @text.dup, :normalize => false,
+            :break => @break, :discardable => @discardable)
+        end
+
+        def accumulate(list)
+          if list.last.is_a?(Text) && list.last.state == state
+            list.last.text << @text
+          else
+            list.push(dup)
+          end
+
+          return list
+        end
+
+        def spaces
+          @spaces ||= @text.scan(/ /).length
+        end
+
+        def height(ignore_discardable=false)
+          if ignore_discardable && discardable?
+            0
+          else
+            @height
+          end
+        end
+
+        def break?
+          @break
+        end
+
+        def discardable?
+          @discardable
+        end
+
+        def compatible?(with)
+          with.is_a?(self.class) && with.state == state
+        end
+
+        def width(type=:all)
+          @width ||= @state.font.compute_width_of(@text, :size => @state.font_size, :kerning => @state.kerning?)
+
+          case type
+          when :discardable then discardable? ? @width : 0
+          when :nondiscardable then discardable? ? 0 : @width
+          else @width
+          end
+        end
+
+        def to_s
+          @text
+        end
+
+        def draw(document, draw_state, options={})
+          @state.apply!(draw_state[:text], draw_state[:cookies])
+
+          encoded_text = @state.font.encode_text(@text, :kerning => @state.kerning?)
+          encoded_text.each do |subset, chunk|
+            @state.apply_font!(draw_state[:text], draw_state[:cookies], subset)
+            draw_state[:text].show(chunk)
+          end
+          draw_state[:dx] += width
+
+          draw_state[:dx] += draw_state[:padding] * spaces if draw_state[:padding]
+        end
+      end
+
+    end
+  end
+end

data/lib/prawn/format/layout_builder.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require 'prawn/format/line'
+require 'prawn/format/parser'
+
+module Prawn
+  module Format
+    class LayoutBuilder
+      attr_reader :document, :options
+
+      def initialize(document, text, options={})
+        @document = document
+        @options  = options
+        @tags     = document.tags.merge(options[:tags] || {})
+        @styles   = document.styles.merge(options[:styles] || {})
+        style     = document.default_style.merge(options[:default_style] || {})
+
+        translate_prawn_options(style, options)
+
+        @parser   = Parser.new(@document, text,
+                      :tags => @tags, :styles => @styles, :style => style)
+
+        @state    = {}
+      end
+
+      def done?
+        @parser.eos?
+      end
+
+      def word_wrap(width, options={}, &block)
+        if options[:height] && block
+          raise ArgumentError, "cannot specify both height and a block"
+        elsif options[:height]
+          block = Proc.new { |l, h| h > options[:height] }
+        elsif block.nil?
+          block = Proc.new { |l, h| false }
+        end
+
+        lines = []
+        total_height = 0
+
+        while (line = self.next(width))
+          if block[line, total_height + line.height]
+            unget(line)
+            break
+          end
+
+          total_height += line.height
+          lines.push(line)
+        end
+
+        return lines
+      end
+
+      def fill(x, y, width, fill_options={}, &block)
+        lines = word_wrap(width, fill_options, &block)
+        draw_options = options.merge(fill_options).merge(:state => @state)
+        @state = document.draw_lines(x, y, width, lines, draw_options)
+        @state.delete(:cookies)
+        return @state[:dy] + y
+      end
+
+      def next(line_width=nil)
+        line = []
+        width = 0
+        break_at = nil
+
+        while (instruction = @parser.next)
+          next if !@parser.verbatim? && line.empty? && instruction.discardable? # ignore discardables at line start
+          line.push(instruction)
+
+          if instruction.break?
+            width += instruction.width(:nondiscardable)
+            break_at = line.length if line_width && width <= line_width
+            width += instruction.width(:discardable)
+          else
+            width += instruction.width
+          end
+
+          if instruction.force_break? || line_width && width >= line_width
+            break_at ||= line.length
+
+            @parser.push(line.pop) while line.length > break_at
+            hard_break = instruction.force_break? || @parser.eos?
+
+            return Line.new(line, hard_break)
+          end
+        end
+
+        Line.new(line, true) if line.any?
+      end
+
+      def unget(line)
+        line.source.reverse_each { |instruction| @parser.push(instruction) }
+      end
+
+      def translate_prawn_options(style, options)
+        style[:kerning] = options[:kerning] if options.key?(:kerning)
+        style[:font_size] = options[:size] if options.key?(:size)
+
+        case options[:style]
+        when :bold then
+          style[:font_weight] = :bold
+        when :italic then
+          style[:font_style] = :italic
+        when :bold_italic then
+          style[:font_weight] = :bold
+          style[:font_style] = :italic
+        end
+      end
+    end
+  end
+end