srdperu-prawn-format 0.1.1.1

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

data/lib/prawn/format/text_object.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require 'prawn/graphics/color'
+
+module Prawn
+  module Format
+    class TextObject
+      include Prawn::Graphics::Color
+
+      RENDER_MODES = {
+        :fill             => 0,
+        :stroke           => 1,
+        :fill_stroke      => 2,
+        :invisible        => 3,
+        :fill_clip        => 4,
+        :stroke_clip      => 5,
+        :fill_stroke_clip => 6,
+        :clip             => 7
+      }
+
+      def initialize
+        @content = nil
+        @last_x = @last_y = 0
+      end
+
+      def open
+        @content = "BT\n"
+        self
+      end
+
+      def close
+        @content << "ET"
+        self
+      end
+
+      def move_to(x, y)
+        move_by(x - @last_x, y - @last_y)
+      end
+
+      def move_by(dx,dy)
+        @last_x += dx
+        @last_y += dy
+        @content << "#{dx} #{dy} Td\n"
+        self
+      end
+
+      def next_line(dy)
+      end
+
+      def show(argument)
+        instruction = argument.is_a?(Array) ? "TJ" : "Tj"
+        @content << "#{Prawn::PdfObject(argument, true)} #{instruction}\n"
+        self
+      end
+
+      def character_space(dc)
+        @content << "#{dc} Tc\n"
+        self
+      end
+
+      def word_space(dw)
+        @content << "#{dw} Tw\n"
+        self
+      end
+
+      def leading(dl)
+        @content << "#{dl} TL\n"
+        self
+      end
+
+      def font(identifier, size)
+        @content << "/#{identifier} #{size} Tf\n"
+        self
+      end
+
+      def render(mode)
+        mode_value = RENDER_MODES[mode] || raise(ArgumentError, "unsupported render mode #{mode.inspect}, should be one of #{RENDER_MODES.keys.inspect}")
+        @content << "#{mode_value} Tr\n"
+        self
+      end
+
+      def rise(value)
+        @content << "#{value} Ts\n"
+        self
+      end
+
+      def rotate(x, y, theta)
+        radians = theta * Math::PI / 180
+        cos, sin = Math.cos(radians), Math.sin(radians)
+        arr = [cos, sin, -sin, cos, x, y]
+        add_content "%.3f %.3f %.3f %.3f %.3f %.3f Tm" % arr
+      end
+
+      def to_s
+        @content
+      end
+
+      def to_str
+        @content
+      end
+
+      def add_content(string)
+        @content << string << "\n"
+      end
+    end
+  end
+end

data/lib/prawn/format/version.rb

@@ -0,0 +1,5 @@
+module Prawn
+  module Format
+    VERSION = "0.2.0.1"
+  end
+end

data/lib/prawn/format.rb

@@ -0,0 +1,229 @@
+# encoding: utf-8
+
+require 'prawn/format/layout_builder'
+require 'prawn/format/text_object'
+
+module Prawn
+  module Format
+    def self.included(mod)
+      mod.send :alias_method, :text_without_formatting, :text
+      mod.send :alias_method, :text, :text_with_formatting
+
+      mod.send :alias_method, :width_of_without_formatting, :width_of
+      mod.send :alias_method, :width_of, :width_of_with_formatting
+
+      mod.send :alias_method, :height_of_without_formatting, :height_of
+      mod.send :alias_method, :height_of, :height_of_with_formatting
+    end
+
+    # Overloaded version of #text. Call via #text, rather than #text_with_formatting
+    # (see above, where it aliased to #text).
+    def text_with_formatting(text, options={}) #:nodoc:
+      if unformatted?(text, options)
+        text_without_formatting(text, options)
+      else
+        format(text, options)
+      end
+    end
+
+    # Overloaded version of #height_of. Call via #height_of, rather than
+    # #height_of_with_formatting (see above, where it aliased to #height_of).
+    def height_of_with_formatting(string, line_width, size=font_size, options={}) #:nodoc:
+      if unformatted?(string, options)
+        height_of_without_formatting(string, line_width, size)
+      else
+        formatted_height(string, line_width, size, options)
+      end
+    end
+
+    # Overloaded version of #width_of. Call via #width_of, rather than
+    # #width_of_with_formatting (see above, where it aliased to #width_of).
+    def width_of_with_formatting(string, options={}) #:nodoc:
+      if unformatted?(string, options)
+        width_of_without_formatting(string, options)
+      else
+        formatted_width(string, options)
+      end
+    end
+
+    DEFAULT_TAGS = {
+      :a      => { :meta => { :name => :anchor, :href => :target }, :color => "0000ff", :text_decoration => :underline },
+      :b      => { :font_weight => :bold },
+      :br     => { :display => :break },
+      :code   => { :font_family => "Courier", :font_size => "90%" },
+      :em     => { :font_style => :italic },
+      :font   => { :meta => { :face => :font_family, :color => :color, :size => :font_size } },
+      :i      => { :font_style => :italic },
+      :pre    => { :white_space => :pre, :font_family => "Courier", :font_size => "90%" },
+      :span   => {},
+      :strong => { :font_weight => :bold },
+      :sub    => { :vertical_align => :sub, :font_size => "70%" },
+      :sup    => { :vertical_align => :super, :font_size => "70%" },
+      :tt     => { :font_family => "Courier" },
+      :u      => { :text_decoration => :underline },
+    }.freeze
+
+    def tags(update={})
+      @tags ||= DEFAULT_TAGS.dup
+      @tags.update(update)
+    end
+
+    def styles(update={})
+      @styles ||= {}
+      @styles.update(update)
+    end
+
+    def default_style
+      { :font_family => font.family || font.name,
+        :font_size   => font_size,
+        :color       => fill_color }
+    end
+
+    def evaluate_measure(measure, options={})
+      case measure
+      when nil then nil
+      when Numeric then return measure
+      when Symbol then
+        mappings = options[:mappings] || {}
+        raise ArgumentError, "unrecognized value #{measure.inspect}" unless mappings.key?(measure)
+        return evaluate_measure(mappings[measure], options)
+      when String then
+        operator, value, unit = measure.match(/^([-+]?)(\d+(?:\.\d+)?)(.*)$/)[1,3]
+
+        value = case unit
+          when "%" then
+            relative = options[:relative] || 0
+            relative * value.to_f / 100
+          when "em" then
+            # not a true em, but good enough for approximating. patches welcome.
+            value.to_f * (options[:em] || font_size)
+          when "", "pt" then return value.to_f
+          when "pc" then return value.to_f * 12
+          when "in" then return value.to_f * 72
+          else raise ArgumentError, "unsupport units in style value: #{measure.inspect}"
+          end
+
+        current = options[:current] || 0
+        case operator
+        when "+" then return current + value
+        when "-" then return current - value
+        else return value
+        end
+      else return measure.to_f
+      end
+    end
+
+    def draw_lines(x, y, width, lines, options={})
+      real_x, real_y = translate(x, y)
+
+      state = options[:state] || {}
+      options[:align] ||= :left
+
+      state = state.merge(:width => width,
+        :x => x, :y => y,
+        :real_x => real_x, :real_y => real_y,
+        :dx => 0, :dy => 0)
+
+      state[:cookies] ||= {}
+      state[:pending_effects] ||= []
+
+      return state if lines.empty?
+
+      text_object do |text|
+        text.rotate(real_x, real_y, options[:rotate] || 0)
+        state[:text] = text
+        lines.each { |line| line.draw_on(self, state, options) }
+      end
+
+      state.delete(:text)
+
+      #rectangle [x, y+state[:dy]], width, state[:dy]
+      #stroke
+
+      return state
+    end
+
+    def layout(text, options={})
+      helper = Format::LayoutBuilder.new(self, text, options)
+      yield helper if block_given?
+      return helper
+    end
+
+    def format(text, options={})
+      if options[:at]
+        x, y = options[:at]
+        format_positioned_text(text, x, y, options)
+      else
+        format_wrapped_text(text, options)
+      end
+    end
+
+    def text_object
+      object = TextObject.new
+
+      if block_given?
+        yield object.open
+        add_content(object.close)
+      end
+
+      return object
+    end
+
+    private
+
+      def unformatted?(text, options={})
+        # If they have a preference, use it
+        if options.key?(:plain)
+          return options[:plain]
+
+        # Otherwise, if they're asking for full-justification, we must assume
+        # the text is formatted (since Prawn's text() method has no full justification)
+        elsif options[:align] == :justify
+          return false
+
+        # Otherwise, look for tags or XML entities in the text
+        else
+          return text !~ /<|&(?:#x?)?\w+;/
+        end
+      end
+
+      def format_positioned_text(text, x, y, options={})
+        helper = layout(text, options)
+        line = helper.next
+        draw_lines(x, y+line.ascent, line.width, [line], options)
+      end
+
+      def format_wrapped_text(text, options={})
+        helper = layout(text, options)
+
+        start_new_page if self.y < bounds.absolute_bottom
+
+        until helper.done?
+          y = self.y - bounds.absolute_bottom
+          height = bounds.stretchy? ? bounds.absolute_top : y
+
+          y = helper.fill(bounds.left, y, bounds.width, options.merge(:height => height))
+
+          if helper.done?
+            self.y = y + bounds.absolute_bottom
+          else
+            start_new_page
+          end
+        end
+      end
+
+      def formatted_height(string, line_width, size=font_size, options={})
+        helper = layout(string, options.merge(:size => size))
+        lines = helper.word_wrap(line_width)
+        return lines.inject(0) { |s, line| s + line.height }
+      end
+
+      def formatted_width(string, options={})
+        helper = layout(string, options)
+        helper.next.width
+      end
+  end
+end
+
+require 'prawn/document'
+Prawn::Document.send(:include, Prawn::Format)