prawn-format 0.1.0

data/lib/prawn/format/line.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module Prawn
+  module Format
+
+    class Line
+      attr_reader :source
+      attr_reader :instructions
+
+      def initialize(instructions, hard_break)
+        # need to remember the "source" instructions, because lines can
+        # pushed back onto the stack en masse when flowing into boxes,
+        # if a line is discovered to not fit. Thus, a line must preserve
+        # all instructions it was originally given.
+
+        @source = instructions
+        @hard_break = hard_break
+      end
+
+      def instructions
+        @instructions ||= begin
+          instructions = source.dup
+
+          # ignore discardable items at the end of lines
+          instructions.pop while instructions.any? && instructions.last.discardable?
+
+          consolidate(instructions)
+        end
+      end
+
+      def spaces
+        @spaces ||= begin
+          spaces = instructions.inject(0) { |sum, instruction| sum + instruction.spaces }
+          [1, spaces].max
+        end
+      end
+
+      def hard_break?
+        @hard_break
+      end
+
+      def width
+        instructions.inject(0) { |sum, instruction| sum + instruction.width }
+      end
+
+      # distance from top of line to baseline
+      def ascent
+        instructions.map { |instruction| instruction.ascent }.max || 0
+      end
+
+      # distance from bottom of line to baseline
+      def descent
+        instructions.map { |instruction| instruction.descent }.min || 0
+      end
+
+      def height(include_blank=false)
+        instructions.map { |instruction| instruction.height(include_blank) }.max
+      end
+
+      def draw_on(document, state, options={})
+        return if instructions.empty?
+
+        format_state = instructions.first.state
+
+        case(options[:align])
+        when :left
+          state[:dx] = 0
+        when :center
+          state[:dx] = (state[:width] - width) / 2.0
+        when :right
+          state[:dx] = state[:width] - width
+        when :justify
+          state[:dx] = 0
+          state[:padding] = hard_break? ? 0 : (state[:width] - width) / spaces
+          state[:text].word_space(state[:padding])
+        end
+
+        state[:dy] -= ascent
+
+        state[:text].move_to(state[:dx], state[:dy])
+        state[:line] = self
+
+        document.save_font do
+          instructions.each { |instruction| instruction.draw(document, state, options) }
+          state[:pending_effects].each { |effect| effect.wrap(document, state) }
+        end
+
+        state[:dy] -= (options[:spacing] || 0) + (height - ascent)
+      end
+
+      private
+
+        def consolidate(list)
+          list.inject([]) { |l,i| i.accumulate(l) }
+        end
+    end
+
+  end
+end

data/lib/prawn/format/parser.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+require 'prawn/format/instructions/text'
+require 'prawn/format/instructions/tag_open'
+require 'prawn/format/instructions/tag_close'
+require 'prawn/format/lexer'
+require 'prawn/format/line'
+require 'prawn/format/state'
+
+module Prawn
+  module Format
+
+    # The Parser class is used by the formatting subsystem to take
+    # the raw tokens from the Lexer class and wrap them in
+    # "instructions", which are then used by the LayoutBuilder to
+    # determine how each token should be rendered.
+    #
+    # The parser also ensures that tags are opened and closed
+    # consistently. It is not forgiving at all--if you forget to
+    # close a tag, the parser will raise an exception (TagError).
+    # 
+    # It will also raise an exception if a tag is encountered with
+    # no style definition for it.
+    class Parser
+      # This is the exception that gets raised when the parser cannot
+      # process a particular tag.
+      class TagError < RuntimeError; end
+
+      attr_reader :document
+      attr_reader :tags
+      attr_reader :state
+
+      # Creates a new parser associated with the given +document+, and which
+      # will parse the given +text+. The +options+ may include either of two
+      # optional keys:
+      #
+      # * :tags is used to specify the hash of tags and their associated
+      #   styles. Any tag not specified here will not be recognized by the
+      #   parser, and will cause an error if it is encountered in +text+.
+      # * :styles is used to specify the mapping of style classes to their
+      #   definitions. The keys should be symbols, and the values should be
+      #   hashes. The values have the same format as for the :tags map.
+      # * :style is the default style for any text not otherwise wrapped by
+      #   tags.
+      #
+      # Example:
+      #
+      #   parser = Parser.new(@pdf, "<b class='ruby'>hello</b>",
+      #       :tags => { :b => { :font_weight => :bold } },
+      #       :styles => { :ruby => { :color => "red" } },
+      #       :style => { :font_family => "Times-Roman" })
+      #
+      # See Format::State for a description of the supported style options.
+      def initialize(document, text, options={})
+        @document = document
+        @lexer = Lexer.new(text)
+        @tags = options[:tags] || {}
+        @styles = options[:styles] || {}
+
+        @state = State.new(document, :style => options[:style])
+        @lexer.verbatim = (@state.white_space == :pre)
+
+        @action = :start
+
+        @saved = []
+        @tag_stack = []
+      end
+
+      def verbatim?
+        @lexer.verbatim
+      end
+
+      # Returns the next instruction from the stream. If there are no more
+      # instructions in the stream (e.g., the end has been encountered), this
+      # returns +nil+.
+      def next
+        return @saved.pop if @saved.any?
+
+        case @action
+        when :start then start_parse
+        when :text  then text_parse
+        else raise "BUG: unknown parser action: #{@action.inspect}"
+        end
+      end
+
+      # "Ungets" the given +instruction+. This makes it so the next call to
+      # +next+ will return +instruction+. This is useful for backtracking.
+      def push(instruction)
+        @saved.push(instruction)
+      end
+
+      # This is identical to +next+, except it does not consume the
+      # instruction. This means that +peek+ returns the instruction that will
+      # be returned by the next call to +next+. It is useful for testing
+      # the next instruction in the stream without advancing the stream.
+      def peek
+        save = self.next
+        push(save) if save
+        return save
+      end
+
+      # Returns +true+ if the end of the stream has been reached. Subsequent
+      # calls to +peek+ or +next+ will return +nil+.
+      def eos?
+        peek.nil?
+      end
+
+      private
+
+        def start_parse
+          instruction = nil
+          while (@token = @lexer.next)
+            case @token[:type]
+            when :text
+              @position = 0
+              instruction = text_parse
+            when :open
+              instruction = process_open_tag
+            when :close
+              raise TagError, "closing #{@token[:tag]}, but no tags are open" if @tag_stack.empty?
+              raise TagError, "closing #{@tag_stack.last[:tag]} with #{@token[:tag]}" if @tag_stack.last[:tag] != @token[:tag]
+
+              instruction = Instructions::TagClose.new(@state, @tag_stack.pop)
+              @state = @state.previous
+            else
+              raise ArgumentError, "[BUG] unknown token type #{@token[:type].inspect} (#{@token.inspect})"
+            end
+
+            if instruction
+              if instruction.start_verbatim?
+                @lexer.verbatim = true
+              elsif instruction.end_verbatim?
+                @lexer.verbatim = false
+              end
+
+              return instruction
+            end
+          end
+
+          return nil
+        end
+
+        def text_parse
+          if @token[:text][@position]
+            @action = :text
+            @position += 1
+
+            text = @token[:text][@position - 1]
+            if @state.white_space == :pre && text =~ /(?:\r\n|\r|\n)/
+              Instructions::TagClose.new(@state, { :style => { :display => :break }, :options => {} })
+            else
+              Instructions::Text.new(@state, text)
+            end
+          else
+            @action = :start
+            start_parse
+          end
+        end
+
+        def process_open_tag
+          @tag_stack << @token
+          raise TagError, "undefined tag #{@token[:tag]}" unless @tags[@token[:tag]]
+          @token[:style] = @tags[@token[:tag]].dup
+
+          (@token[:options][:class] || "").split(/\s/).each do |name|
+            @token[:style].update(@styles[name.to_sym] || {})
+          end
+
+          if @token[:style][:meta]
+            @token[:style][:meta].each do |key, value|
+              @token[:style][value] = @token[:options][key]
+            end
+          end
+
+          @state = @state.with_style(@token[:style])
+          Instructions::TagOpen.new(@state, @token)
+        end
+    end
+
+  end
+end

data/lib/prawn/format/state.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+module Prawn
+  module Format
+    class State
+      attr_reader :document
+      attr_reader :original_style, :style
+
+      def initialize(document, options={})
+        @document = document
+        @previous = options[:previous]
+
+        @original_style = (@previous && @previous.inheritable_style || {}).
+          merge(options[:style] || {})
+
+        compute_styles!
+
+        @style[:kerning] = font.has_kerning_data? unless @style.key?(:kerning)
+      end
+
+      def inheritable_style
+        @inheritable_style ||= begin
+          subset = original_style.dup
+          subset.delete(:meta)
+          subset.delete(:display)
+          subset.delete(:width)
+
+          # explicitly set font-size so that relative font-sizes don't get
+          # recomputed upon each nesting.
+          subset[:font_size] = font_size
+
+          subset
+        end
+      end
+
+      def kerning?
+        @style[:kerning]
+      end
+
+      def display
+        @style[:display] || :inline
+      end
+
+      def font_size
+        @style[:font_size] || 12
+      end
+
+      def font_family
+        @style[:font_family] || "Helvetica"
+      end
+
+      def font_style
+        @style[:font_style] || :normal
+      end
+
+      def font_weight
+        @style[:font_weight] || :normal
+      end
+
+      def color
+        @style[:color] || "000000"
+      end
+
+      def vertical_align
+        @style[:vertical_align] || 0
+      end
+
+      def text_decoration
+        @style[:text_decoration] || :none
+      end
+
+      def white_space
+        @style[:white_space] || :normal
+      end
+
+      def width
+        @style[:width] || 0
+      end
+
+      def font
+        @font ||= document.find_font(font_family, :style => pdf_font_style)
+      end
+
+      def pdf_font_style
+        if bold? && italic?
+          :bold_italic
+        elsif bold?
+          :bold
+        elsif italic?
+          :italic
+        else
+          :normal
+        end
+      end
+
+      def with_style(style)
+        self.class.new(document, :previous => self, :style => style)
+      end
+
+      def apply!(text_object, cookies)
+        if cookies[:color] != color
+          cookies[:color] = color
+          text_object.fill_color(color)
+        end
+
+        if cookies[:vertical_align] != vertical_align
+          cookies[:vertical_align] = vertical_align
+          text_object.rise(vertical_align)
+        end
+      end
+
+      def apply_font!(text_object, cookies, subset)
+        if cookies[:font] != [font_family, pdf_font_style, font_size, subset]
+          cookies[:font] = [font_family, pdf_font_style, font_size, subset]
+          font = document.font(font_family, :style => pdf_font_style)
+          font.add_to_current_page(subset)
+          text_object.font(font.identifier_for(subset), font_size)
+        end
+      end
+
+      def italic?
+        font_style == :italic
+      end
+
+      def bold?
+        font_weight == :bold
+      end
+
+      def previous(attr=nil, default=nil)
+        return @previous unless attr
+        return default unless @previous
+        return @previous.send(attr) || default
+      end
+
+      private
+
+        def compute_styles!
+          @style = @original_style.dup
+
+          evaluate_style(:font_size, 12, :current)
+          evaluate_style(:vertical_align, 0, font_size, :super => "+40%", :sub => "-30%")
+          evaluate_style(:width, 0, document.bounds.width)
+
+          @style[:color] = evaluate_color(@style[:color])
+        end
+
+        def evaluate_style(which, default, relative_to, mappings={})
+          current = previous(which, default)
+          relative_to = current if relative_to == :current
+          @style[which] = document.evaluate_measure(@style[which],
+            :em => @previous && @previous.font_size || 12,
+            :current => current, :relative => relative_to, :mappings => mappings) || default
+        end
+
+        HTML_COLORS = {
+          "aqua"    => "00FFFF",
+          "black"   => "000000",
+          "blue"    => "0000FF",
+          "fuchsia" => "FF00FF",
+          "gray"    => "808080",
+          "green"   => "008000",
+          "lime"    => "00FF00",
+          "maroon"  => "800000",
+          "navy"    => "000080",
+          "olive"   => "808000",
+          "purple"  => "800080",
+          "red"     => "FF0000",
+          "silver"  => "C0C0C0",
+          "teal"    => "008080",
+          "white"   => "FFFFFF",
+          "yellow"  => "FFFF00"
+        }
+
+        def evaluate_color(color)
+          case color
+          when nil then nil
+          when /^\s*#?([a-f0-9]{3})\s*$/i then
+            return $1.gsub(/./, '\&0')
+          when /^\s*#?([a-f0-9]+)$\s*/i then
+            return $1
+          when /^\s*rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*$/
+            return "%02x%02x%02x" % [$1.to_i, $2.to_i, $3.to_i]
+          else
+            return HTML_COLORS[color.strip.downcase]
+          end
+        end
+    end
+  end
+end