prawn-format 0.1.0

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.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

data/lib/prawn/format/lexer.rb

@@ -0,0 +1,222 @@
+# encoding: utf-8
+
+require 'strscan'
+
+module Prawn
+  module Format
+
+    # The Lexer class is used by the formatting subsystem to scan a string
+    # and extract tokens from it. The tokens it looks for are either text,
+    # XML entities, or XML tags.
+    #
+    # Note that the lexer only scans for a subset of XML--it is not a true
+    # XML scanner, and understands just enough to provide a basic markup
+    # language for use in formatting documents.
+    #
+    # The subset includes only XML entities and tags--instructions, comments,
+    # and the like are not supported.
+    class Lexer
+      # When the scanner encounters a state or entity it is not able to
+      # handle, this exception will be raised.
+      class InvalidFormat < RuntimeError; end
+
+      # Controls whether whitespace is lexed verbatim or not. If not,
+      # adjacent whitespace is compressed into a single space character
+      # (this includes newlines).
+      attr_accessor :verbatim
+
+      # Create a new lexer that will scan the given text. The text must be
+      # UTF-8 encoded, and must consist of well-formed XML in the subset
+      # understand by the lexer.
+      def initialize(text)
+        @scanner = StringScanner.new(text)
+        @state = :start
+        @verbatim = false
+      end
+
+      # Returns the next token from the scanner. If the end of the string
+      # has been reached, this will return nil. Otherwise, the token itself
+      # is returned as a hash. The hash will always include a :type key,
+      # identifying the type of the token. It will be one of :text, :open,
+      # or :close.
+      #
+      # For :text tokens, the hash will also contain a :text key, which will
+      # point to an array of strings. Each element of the array contains
+      # either word, whitespace, or some other character at which the line
+      # may be broken.
+      #
+      # For :open tokens, the hash will contain a :tag key which identifies
+      # the name of the tag (as a symbol), and an :options key, which
+      # is another hash that contains the options that were given with the
+      # tag.
+      #
+      # For :close tokens, the hash will contain only a :tag key.
+      def next
+        if @state == :start && @scanner.eos?
+          return nil
+        else
+          scan_next_token
+        end
+      end
+
+      # Iterates over each token in the string, until the end of the string
+      # is reached. Each token is yielded. See #next for a discussion of the
+      # available token types.
+      def each
+        while (token = next_token)
+          yield token
+        end
+      end
+
+      private
+
+        def scan_next_token
+          case @state
+          when :start then scan_start_state
+          when :self_close then scan_self_close_state
+          end
+        end
+
+        if RUBY_VERSION >= "1.9.0"
+          def scan_other_text
+            @scanner.scan(/[^-\xE2\x80\x94\s<&]+/)
+          end
+        else
+          def scan_other_text
+            return nil if @scanner.eos?
+
+            result = @scanner.scan_until(/[-\s<&]|\xE2\x80\x94/)
+            if result
+              @scanner.pos -= @scanner.matched.length
+              return nil if result == "<" || result == "&"
+              return result[0,result.length - @scanner.matched.length]
+            else
+              result = @scanner.rest
+              @scanner.terminate
+              return result
+            end
+          end
+        end
+
+        def scan_text_chunk
+          @scanner.scan(/-/)            || # hyphen
+          @scanner.scan(/\xe2\x80\x94/) || # mdash
+          scan_other_text
+        end
+
+        def scan_verbatim_text_chunk
+          @scanner.scan(/\r\n|\r|\n/) || # newline
+          @scanner.scan(/\t/)         || # tab
+          @scanner.scan(/ +/)         || # spaces
+          scan_text_chunk
+        end
+
+        def scan_nonverbatim_text_chunk
+          (@scanner.scan(/\s+/) && " ") || # whitespace
+          scan_text_chunk
+        end
+
+        def scan_next_text_chunk
+          if @verbatim
+            scan_verbatim_text_chunk
+          else
+            scan_nonverbatim_text_chunk
+          end
+        end
+
+        def scan_start_state
+          if @scanner.scan(/</)
+            if @scanner.scan(%r(/))
+              scan_end_tag
+            else
+              scan_open_tag
+            end
+          elsif @scanner.scan(/&/)
+            scan_entity
+          else
+            pieces = []
+            loop do
+              chunk = scan_next_text_chunk or break
+              pieces << chunk
+            end
+            { :type => :text, :text => pieces }
+          end
+        end
+
+        ENTITY_MAP = {
+          "lt"    => "<",
+          "gt"    => ">",
+          "amp"   => "&",
+          "mdash" => "\xE2\x80\x94",
+          "ndash" => "\xE2\x80\x93",
+          "nbsp"  => "\xC2\xA0",
+          "bull"  => "\342\200\242",
+          "quot"  => '"',
+        }
+
+        def scan_entity
+          entity = @scanner.scan(/(?:#x?)?\w+/) or error("bad format for entity")
+          @scanner.scan(/;/) or error("missing semicolon to terminate entity")
+
+          text = case entity
+            when /#(\d+)/ then [$1.to_i].pack("U*")
+            when /#x([0-9a-f]+)/ then [$1.to_i(16)].pack("U*")
+            else
+              result = ENTITY_MAP[entity] or error("unrecognized entity #{entity.inspect}")
+              result.dup
+            end
+
+          { :type => :text, :text => [text] }
+        end
+
+        def scan_open_tag
+          tag = @scanner.scan(/\w+/) or error("'<' without valid tag")
+          tag = tag.downcase.to_sym
+
+          options = {}
+          @scanner.skip(/\s*/)
+          while !@scanner.eos? && @scanner.peek(1) =~ /\w/
+            name = @scanner.scan(/\w+/)
+            @scanner.scan(/\s*=\s*/) or error("expected assigment after option #{name}")
+            if (delim = @scanner.scan(/['"]/))
+              value = @scanner.scan(/[^#{delim}]*/)
+              @scanner.scan(/#{delim}/) or error("expected option value to end with #{delim}")
+            else
+              value = @scanner.scan(/[^\s>]*/)
+            end
+            options[name.downcase.to_sym] = value
+            @scanner.skip(/\s*/)
+          end
+
+          if @scanner.scan(%r(/))
+            @self_close = true
+            @tag = tag
+            @state = :self_close
+          else
+            @self_close = false
+            @state = :start
+          end
+
+          @scanner.scan(/>/) or error("unclosed tag #{tag.inspect}")
+
+          { :type => :open, :tag => tag, :options => options }
+        end
+
+        def scan_end_tag
+          tag = @scanner.scan(/\w+/).to_sym
+          @scanner.skip(/\s*/)
+          @scanner.scan(/>/) or error("unclosed ending tag #{tag.inspect}")
+          { :type => :close, :tag => tag }
+        end
+
+        def scan_self_close_state
+          @state = :start
+          { :type => :close, :tag => @tag }
+        end
+
+        def error(message)
+          raise InvalidFormat, "#{message} at #{@scanner.pos} -> #{@scanner.rest.inspect[0,50]}..."
+        end
+    end
+  end
+end