prawn-svg 0.24.0 → 0.25.0

data/lib/prawn/svg/elements/text_component.rb

@@ -0,0 +1,186 @@
+class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
+  attr_reader :commands
+
+  Printable = Struct.new(:element, :text, :leading_space?, :trailing_space?)
+  PositionsList = Struct.new(:x, :y, :dx, :dy, :rotation, :parent)
+
+  def parse
+    state.text.x = attributes['x'].split(COMMA_WSP_REGEXP).collect {|n| x(n)} if attributes['x']
+    state.text.y = attributes['y'].split(COMMA_WSP_REGEXP).collect {|n| y(n)} if attributes['y']
+    state.text.dx = attributes['dx'].split(COMMA_WSP_REGEXP).collect {|n| x_pixels(n)} if attributes['dx']
+    state.text.dy = attributes['dy'].split(COMMA_WSP_REGEXP).collect {|n| y_pixels(n)} if attributes['dy']
+    state.text.rotation = attributes['rotate'].split(COMMA_WSP_REGEXP).collect(&:to_f) if attributes['rotate']
+
+    @commands = []
+
+    text_children.each do |child|
+      if child.node_type == :text
+        append_text(child)
+      else
+        case child.name
+        when 'tspan', 'tref'
+          append_child(child)
+        else
+          warnings << "Unknown tag '#{child.name}' inside text tag; ignoring"
+        end
+      end
+    end
+  end
+
+  def apply
+    raise SkipElementQuietly if computed_properties.display == "none"
+
+    font = select_font
+    apply_font(font) if font
+
+    # text_anchor isn't a Prawn option; we have to do some math to support it
+    # and so we handle this in Prawn::SVG::Interface#rewrite_call_arguments
+    opts = {
+      size:        computed_properties.numerical_font_size,
+      style:       font && font.subfamily,
+      text_anchor: computed_properties.text_anchor
+    }
+
+    spacing = computed_properties.letter_spacing
+    spacing = spacing == 'normal' ? 0 : pixels(spacing)
+
+    add_call_and_enter 'character_spacing', spacing
+
+    @commands.each do |command|
+      case command
+      when Printable
+        apply_text(command.text, opts)
+      when self.class
+        add_call 'save'
+        command.apply_step(calls)
+        add_call 'restore'
+      else
+        raise
+      end
+    end
+
+    # It's possible there was no text to render.  In that case, add a 'noop' so
+    # character_spacing doesn't blow up when it finds it doesn't have a block to execute.
+    add_call 'noop' if calls.empty?
+  end
+
+  protected
+
+  def append_text(child)
+    if state.preserve_space
+      text = child.value.tr("\n\t", ' ')
+    else
+      text = child.value.tr("\n", '').tr("\t", ' ')
+      leading = text[0] == ' '
+      trailing = text[-1] == ' '
+      text = text.strip.gsub(/ {2,}/, ' ')
+    end
+
+    @commands << Printable.new(self, text, leading, trailing)
+  end
+
+  def append_child(child)
+    new_state = state.dup
+    new_state.text = PositionsList.new([], [], [], [], [], state.text)
+
+    element = self.class.new(document, child, calls, new_state)
+    @commands << element
+    element.parse_step
+  end
+
+  def apply_text(text, opts)
+    while text != ""
+      x = y = dx = dy = rotate = nil
+      remaining = rotation_remaining = false
+
+      list = state.text
+      while list
+        shifted = list.x.shift
+        x ||= shifted
+        shifted = list.y.shift
+        y ||= shifted
+        shifted = list.dx.shift
+        dx ||= shifted
+        shifted = list.dy.shift
+        dy ||= shifted
+
+        shifted = list.rotation.length > 1 ? list.rotation.shift : list.rotation.first
+        if shifted && rotate.nil?
+          rotate = shifted
+          remaining ||= list.rotation != [0]
+        end
+
+        remaining ||= list.x.any? || list.y.any? || list.dx.any? || list.dy.any? || (rotate && rotate != 0)
+        rotation_remaining ||= list.rotation.length > 1
+        list = list.parent
+      end
+
+      opts[:at] = [x || :relative, y || :relative]
+      opts[:offset] = [dx || 0, dy || 0]
+
+      if rotate && rotate != 0
+        opts[:rotate] = -rotate
+      else
+        opts.delete(:rotate)
+      end
+
+      if remaining
+        add_call 'draw_text', text[0..0], opts.dup
+        text = text[1..-1]
+      else
+        add_call 'draw_text', text, opts.dup
+
+        # we can get to this path with rotations still pending
+        # solve this by shifting them out by the number of
+        # characters we've just drawn
+        shift = text.length - 1
+        if rotation_remaining && shift > 0
+          list = state.text
+          while list
+            count = [shift, list.rotation.length - 1].min
+            list.rotation.shift(count) if count > 0
+            list = list.parent
+          end
+        end
+
+        break
+      end
+    end
+  end
+
+  def text_children
+    if name == 'tref'
+      reference = find_referenced_element
+      reference ? reference.source.children : []
+    else
+      source.children
+    end
+  end
+
+  def find_referenced_element
+    href = attributes['xlink:href']
+
+    if href && href[0..0] == '#'
+      element = document.elements_by_id[href[1..-1]]
+      element if element.name == 'text'
+    end
+  end
+
+  def select_font
+    font_families = [computed_properties.font_family, document.fallback_font_name]
+    font_style = :italic if computed_properties.font_style == 'italic'
+    font_weight = Prawn::SVG::Font.weight_for_css_font_weight(computed_properties.font_weight)
+
+    font_families.compact.each do |name|
+      font = document.font_registry.load(name, font_weight, font_style)
+      return font if font
+    end
+
+    warnings << "Font family '#{computed_properties.font_family}' style '#{computed_properties.font_style}' is not a known font, and the fallback font could not be found."
+    nil
+  end
+
+  def apply_font(font)
+    add_call 'font', font.name, style: font.subfamily
+  end
+end

data/lib/prawn/svg/elements/use.rb

@@ -21,7 +21,7 @@ class Prawn::SVG::Elements::Use < Prawn::SVG::Elements::Base
 
   def apply
     if @x || @y
-      add_call_and_enter "translate", distance(@x || 0, :x), -distance(@y || 0, :y)
+      add_call_and_enter "translate", x_pixels(@x || 0), -y_pixels(@y || 0)
     end
 
     add_calls_from_element @definition_element

data/lib/prawn/svg/elements/viewport.rb

@@ -0,0 +1,28 @@
+class Prawn::SVG::Elements::Viewport < Prawn::SVG::Elements::Base
+  def parse
+    parent_dimensions = [state.viewport_sizing.viewport_width, state.viewport_sizing.viewport_height]
+
+    @sizing = Prawn::SVG::Calculators::DocumentSizing.new(parent_dimensions, attributes)
+    @sizing.calculate
+
+    @x = x_pixels(attributes['x'] || 0)
+    @y = y_pixels(attributes['y'] || 0)
+
+    state.viewport_sizing = @sizing
+  end
+
+  def apply
+    if @x != 0 || @y != 0
+      add_call 'transformation_matrix', 1, 0, 0, 1, @x, -@y
+    end
+
+    add_call 'rectangle', [0, y(0)], @sizing.output_width, @sizing.output_height
+    add_call 'clip'
+    add_call 'transformation_matrix', @sizing.x_scale, 0, 0, @sizing.y_scale, 0, 0
+    add_call 'transformation_matrix', 1, 0, 0, 1, -@sizing.x_offset, @sizing.y_offset
+  end
+
+  def container?
+    true
+  end
+end

data/lib/prawn/svg/interface.rb

@@ -118,28 +118,36 @@ module Prawn
       end
 
       def rewrite_call_arguments(prawn, call, arguments)
-        if call == 'relative_draw_text'
-          call.replace "draw_text"
-          arguments.last[:at][0] = @relative_text_position if @relative_text_position
-        end
-
         case call
         when 'text_group'
-          @relative_text_position = nil
+          @cursor = [0, document.sizing.output_height]
           yield
 
         when 'draw_text'
           text, options = arguments
 
-          width = prawn.width_of(text, options.merge(:kerning => true))
+          at = options.fetch(:at)
+
+          at[0] = @cursor[0] if at[0] == :relative
+          at[1] = @cursor[1] if at[1] == :relative
 
-          if (anchor = options.delete(:text_anchor)) && %w(middle end).include?(anchor)
-            width /= 2 if anchor == 'middle'
-            options[:at][0] -= width
+          if offset = options.delete(:offset)
+            at[0] += offset[0]
+            at[1] -= offset[1]
           end
 
-          space_width = prawn.width_of("n", options)
-          @relative_text_position = options[:at][0] + width + space_width
+          width = prawn.width_of(text, options.merge(kerning: true))
+
+          case options.delete(:text_anchor)
+          when 'middle'
+            at[0] -= width / 2
+            @cursor = [at[0] + width / 2, at[1]]
+          when 'end'
+            at[0] -= width
+            @cursor = at.dup
+          else
+            @cursor = [at[0] + width, at[1]]
+          end
 
         when 'transformation_matrix'
           left = prawn.bounds.absolute_left

data/lib/prawn/svg/pathable.rb

@@ -60,8 +60,12 @@ module Prawn::SVG::Pathable
         angle = Math.atan2(command.destination[1] - last_point[1], command.destination[0] - last_point[0]) * 180.0 / Math::PI
         [angle, angle]
       when Curve
-        start = Math.atan2(command.point1[1] - last_point[1], command.point1[0] - last_point[0]) * 180.0 / Math::PI
-        stop = Math.atan2(command.destination[1] - command.point2[1], command.destination[0] - command.point2[0]) * 180.0 / Math::PI
+        point = select_non_equal_point(last_point, command.point1, command.point2, command.destination)
+        start = Math.atan2(point[1] - last_point[1], point[0] - last_point[0]) * 180.0 / Math::PI
+
+        point = select_non_equal_point(command.destination, command.point2, command.point1, last_point)
+        stop = Math.atan2(command.destination[1] - point[1], command.destination[0] - point[0]) * 180.0 / Math::PI
+
         [start, stop]
       else
         raise NotImplementedError, "Unknown path command type"
@@ -127,4 +131,16 @@ module Prawn::SVG::Pathable
   def translate(point)
     [point[0].to_f, document.sizing.output_height - point[1].to_f]
   end
+
+  private
+
+  def select_non_equal_point(base, point_a, point_b, point_c)
+    if point_a != base
+      point_a
+    elsif point_b != base
+      point_b
+    else
+      point_c
+    end
+  end
 end

data/lib/prawn/svg/state.rb

@@ -1,8 +1,9 @@
 class Prawn::SVG::State
   attr_accessor :disable_drawing,
-    :text_relative, :text_x_positions, :text_y_positions, :preserve_space,
+    :text, :preserve_space,
     :fill_opacity, :stroke_opacity, :stroke_width,
-    :computed_properties
+    :computed_properties,
+    :viewport_sizing
 
   def initialize
     @stroke_width = 1

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module SVG
-    VERSION = '0.24.0'
+    VERSION = '0.25.0'
   end
 end

data/spec/prawn/svg/attributes/transform_spec.rb

@@ -20,8 +20,8 @@ describe Prawn::SVG::Attributes::Transform do
     describe "translate" do
       it "handles a missing y argument" do
         expect(element).to receive(:add_call_and_enter).with('translate', -5.5, 0)
-        expect(element).to receive(:distance).with(-5.5, :x).and_return(-5.5)
-        expect(element).to receive(:distance).with(0.0, :y).and_return(0.0)
+        expect(element).to receive(:x_pixels).with(-5.5).and_return(-5.5)
+        expect(element).to receive(:y_pixels).with(0.0).and_return(0.0)
 
         element.attributes['transform'] = 'translate(-5.5)'
         subject

data/spec/prawn/svg/calculators/pixels_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Calculators::Pixels do
+  class TestPixelsCalculator
+    include Prawn::SVG::Calculators::Pixels
+
+    [:x, :y, :pixels, :x_pixels, :y_pixels].each { |method| public method }
+  end
+
+  let(:viewport_sizing) do
+    instance_double(Prawn::SVG::Calculators::DocumentSizing, viewport_width: 600, viewport_height: 400, viewport_diagonal: 500, :requested_width= => nil, :requested_height= => nil)
+  end
+
+  let(:document_sizing) do
+    instance_double(Prawn::SVG::Calculators::DocumentSizing, output_height: 800)
+  end
+
+  let(:state) { instance_double(Prawn::SVG::State, viewport_sizing: viewport_sizing) }
+  let(:document) { instance_double(Prawn::SVG::Document, sizing: document_sizing) }
+
+  subject { TestPixelsCalculator.new }
+
+  before do
+    allow(subject).to receive(:state).and_return(state)
+    allow(subject).to receive(:document).and_return(document)
+  end
+
+  describe "#pixels" do
+    it "converts a variety of measurement units to points" do
+      expect(subject.pixels(32)).to eq 32.0
+      expect(subject.pixels(32.0)).to eq 32.0
+      expect(subject.pixels("32")).to eq 32.0
+      expect(subject.pixels("32unknown")).to eq 32.0
+      expect(subject.pixels("32pt")).to eq 32.0
+      expect(subject.pixels("32in")).to eq 32.0 * 72
+      expect(subject.pixels("32ft")).to eq 32.0 * 72 * 12
+      expect(subject.pixels("32pc")).to eq 32.0 * 15
+      expect(subject.pixels("32mm")).to be_within(0.0001).of(32 * 72 * 0.0393700787)
+      expect(subject.pixels("32cm")).to be_within(0.0001).of(32 * 72 * 0.393700787)
+      expect(subject.pixels("32m")).to be_within(0.0001).of(32 * 72 * 39.3700787)
+      expect(subject.pixels("50%")).to eq 250
+    end
+  end
+
+  describe "#x_pixels" do
+    it "uses the viewport width for percentages" do
+      expect(subject.x_pixels("50")).to eq 50
+      expect(subject.x_pixels("50%")).to eq 300
+    end
+  end
+
+  describe "#y_pixels" do
+    it "uses the viewport height for percentages" do
+      expect(subject.y_pixels("50")).to eq 50
+      expect(subject.y_pixels("50%")).to eq 200
+    end
+  end
+
+  describe "#x" do
+    it "performs the same as #x_pixels" do
+      expect(subject.x("50")).to eq 50
+      expect(subject.x("50%")).to eq 300
+    end
+  end
+
+  describe "#y" do
+    it "performs the same as #y_pixels but subtracts the pixels from the page height" do
+      expect(subject.y("50")).to eq 800 - 50
+      expect(subject.y("50%")).to eq 800 - 200
+    end
+  end
+end

data/spec/prawn/svg/document_spec.rb

@@ -25,32 +25,4 @@ describe Prawn::SVG::Document do
       end
     end
   end
-
-  describe "#points" do
-    before do
-      sizing = instance_double(Prawn::SVG::Calculators::DocumentSizing, viewport_width: 600, viewport_height: 400, viewport_diagonal: 500, :requested_width= => nil, :requested_height= => nil)
-      expect(sizing).to receive(:calculate)
-      expect(Prawn::SVG::Calculators::DocumentSizing).to receive(:new).and_return(sizing)
-    end
-
-    let(:document) { Prawn::SVG::Document.new("<svg></svg>", [100, 100], {}) }
-
-    it "converts a variety of measurement units to points" do
-      document.send(:points, 32).should == 32.0
-      document.send(:points, 32.0).should == 32.0
-      document.send(:points, "32").should == 32.0
-      document.send(:points, "32unknown").should == 32.0
-      document.send(:points, "32pt").should == 32.0
-      document.send(:points, "32in").should == 32.0 * 72
-      document.send(:points, "32ft").should == 32.0 * 72 * 12
-      document.send(:points, "32pc").should == 32.0 * 15
-      document.send(:points, "32mm").should be_within(0.0001).of(32 * 72 * 0.0393700787)
-      document.send(:points, "32cm").should be_within(0.0001).of(32 * 72 * 0.393700787)
-      document.send(:points, "32m").should be_within(0.0001).of(32 * 72 * 39.3700787)
-
-      document.send(:points, "50%").should == 250
-      document.send(:points, "50%", :x).should == 300
-      document.send(:points, "50%", :y).should == 200
-    end
-  end
 end

data/spec/prawn/svg/elements/base_spec.rb

@@ -4,7 +4,7 @@ describe Prawn::SVG::Elements::Base do
   let(:svg) { "<svg></svg>" }
   let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}, font_registry: Prawn::SVG::FontRegistry.new("Helvetica" => {:normal => nil})) }
   let(:parent_calls) { [] }
-  let(:element) { Prawn::SVG::Elements::Base.new(document, document.root, parent_calls, Prawn::SVG::State.new) }
+  let(:element) { Prawn::SVG::Elements::Base.new(document, document.root, parent_calls, fake_state) }
 
   describe "#initialize" do
     let(:svg) { '<something id="hello"/>' }