prawn-svg 0.27.1 → 0.31.0

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

@@ -9,7 +9,7 @@ describe Prawn::SVG::Elements::Gradient do
     element.process
   end
 
-  describe "object bounding box" do
+  describe "object bounding box with linear gradient" do
     let(:svg) do
       <<-SVG
         <linearGradient id="flag" x1="0" x2="0.2" y1="0" y2="1">
@@ -29,7 +29,8 @@ describe Prawn::SVG::Elements::Gradient do
       expect(arguments).to eq(
         from: [100.0, 100.0],
         to:   [120.0, 0.0],
-        stops: [[0, "ff0000"], [0.25, "ff0000"], [0.5, "ffffff"], [0.75, "0000ff"], [1, "0000ff"]]
+        stops: [[0, "ff0000"], [0.25, "ff0000"], [0.5, "ffffff"], [0.75, "0000ff"], [1, "0000ff"]],
+        apply_transformations: true,
       )
     end
 
@@ -39,7 +40,35 @@ describe Prawn::SVG::Elements::Gradient do
     end
   end
 
-  describe "user space on use" do
+  describe "object bounding box with radial gradient" do
+    let(:svg) do
+      <<-SVG
+        <radialGradient id="flag" cx="0" cy="0.2" fx="0.5" r="0.8">
+          <stop offset="25%" stop-color="red"/>
+          <stop offset="50%" stop-color="white"/>
+          <stop offset="75%" stop-color="blue"/>
+        </radialGradient>
+      SVG
+    end
+
+    it "is stored in the document gradients table" do
+      expect(document.gradients["flag"]).to eq element
+    end
+
+    it "returns correct gradient arguments for an element" do
+      arguments = element.gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
+      expect(arguments).to eq(
+        from: [150, 80],
+        to:   [100, 80],
+        r1:   0,
+        r2:   Math.sqrt((0.8 * 100) ** 2 + (0.8 * 100) ** 2),
+        stops: [[0, "ff0000"], [0.25, "ff0000"], [0.5, "ffffff"], [0.75, "0000ff"], [1, "0000ff"]],
+        apply_transformations: true,
+      )
+    end
+  end
+
+  describe "user space on use with linear gradient" do
     let(:svg) do
       <<-SVG
         <linearGradient id="flag" gradientUnits="userSpaceOnUse" x1="100" y1="500" x2="200" y2="600">
@@ -54,7 +83,53 @@ describe Prawn::SVG::Elements::Gradient do
       expect(arguments).to eq(
         from: [100.0, 100.0],
         to:   [200.0, 0.0],
-        stops: [[0, "ff0000"], [1, "0000ff"]]
+        stops: [[0, "ff0000"], [1, "0000ff"]],
+        apply_transformations: true,
+      )
+    end
+  end
+
+  describe "user space on use with radial gradient" do
+    let(:svg) do
+      <<-SVG
+        <radialGradient id="flag" gradientUnits="userSpaceOnUse" fx="100" fy="500" cx="200" cy="600" r="150">
+          <stop offset="0" stop-color="red"/>
+          <stop offset="1" stop-color="blue"/>
+        </radialGradient>
+      SVG
+    end
+
+    it "returns correct gradient arguments for an element" do
+      arguments = element.gradient_arguments(double)
+      expect(arguments).to eq(
+        from: [100.0, 100.0],
+        to:   [200.0, 0.0],
+        r1:   0,
+        r2:   150,
+        stops: [[0, "ff0000"], [1, "0000ff"]],
+        apply_transformations: true,
+      )
+    end
+  end
+
+  context "when gradientTransform is specified" do
+    let(:svg) do
+      <<-SVG
+        <linearGradient id="flag" gradientTransform="translateX(10) scale(2)" x1="0" y1="0" x2="10" y2="10">
+          <stop offset="0" stop-color="red"/>
+          <stop offset="1" stop-color="blue"/>
+        </linearGradient>
+      SVG
+    end
+
+    it "passes in the transform via the apply_transformations option" do
+      arguments = element.gradient_arguments(double(bounding_box: [0, 0, 10, 10]))
+
+      expect(arguments).to eq(
+        from: [0, 0],
+        to:   [10, 10],
+        stops: [[0, "ff0000"], [1, "0000ff"]],
+        apply_transformations: [2, 0, 0, 2, 10, 0],
       )
     end
   end

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

@@ -11,22 +11,22 @@ describe Prawn::SVG::Elements::Path do
 
   describe "command parsing" do
     context "with a valid path" do
-      let(:d) { "A12.34 -56.78 89B4 5 12-34 -.5.7+3 2.3e3 4e4 4e+4 c31,-2e-5C  6,7 T QX 0 Z" }
+      let(:d) { "m12.34 -56.78 1 2M4 5 12-34 -.5.7+3 2.3e3 4e4 4e+4 L31,-2e-5L  6,7 Z ZZa50 50 0 100 100" }
 
       it "correctly parses" do
         calls = []
-        path.stub(:parse_path_command) {|*args| calls << args}
+        allow(path).to receive(:parse_path_command) {|*args| calls << args}
         path.parse
 
-        calls.should == [
-          ["A", [12.34, -56.78, 89]],
-          ["B", [4, 5, 12, -34, -0.5, 0.7, 3, 2.3e3, 4e4, 4e4]],
-          ["c", [31, -2e-5]],
-          ["C", [6, 7]],
-          ["T", []],
-          ["Q", []],
-          ["X", [0]],
-          ["Z", []]
+        expect(calls).to eq [
+          ["m", [[12.34, -56.78], [1, 2]]],
+          ["M", [[4, 5], [12, -34], [-0.5, 0.7], [3, 2.3e3], [4e4, 4e4]]],
+          ["L", [[31, -2e-5]]],
+          ["L", [[6, 7]]],
+          ["Z", []],
+          ["Z", []],
+          ["Z", []],
+          ["a", [[50, 50, 0, 1, 0, 0, 100]]],
         ]
       end
     end
@@ -36,12 +36,12 @@ describe Prawn::SVG::Elements::Path do
 
       it "treats subsequent points to m/M command as relative/absolute depending on command" do
         [
-          ["M", [1,2,3,4]],
-          ["L", [3,4]],
-          ["m", [5,6,7,8]],
-          ["l", [7,8]]
+          ["M", [[1,2],[3,4]]],
+          ["L", [[3,4]]],
+          ["m", [[5,6],[7,8]]],
+          ["l", [[7,8]]]
         ].each do |args|
-          path.should_receive(:parse_path_command).with(*args).and_call_original
+          expect(path).to receive(:parse_path_command).with(*args).and_call_original
         end
 
         path.parse
@@ -52,7 +52,7 @@ describe Prawn::SVG::Elements::Path do
       let(:d) { "" }
 
       it "correctly parses" do
-        path.should_not_receive(:run_path_command)
+        expect(path).not_to receive(:run_path_command)
         path.parse
       end
     end
@@ -292,5 +292,17 @@ describe Prawn::SVG::Elements::Path do
         ]
       end
     end
+
+    context "with highly-compressed flags" do
+      let(:d) { "M100,100a50 50 0 100 100" }
+
+      it "correctly parses them" do
+        expect(subject).to eq [
+          Prawn::SVG::Elements::Path::Move.new([100.0, 100.0]),
+          Prawn::SVG::Elements::Path::Curve.new([50.0, 150.0], [72.57081148225681, 100.0], [50.0, 122.57081148225681]),
+          Prawn::SVG::Elements::Path::Curve.new([99.99999999999999, 200.0], [50.0, 177.42918851774317], [72.5708114822568, 200.0])
+        ]
+      end
+    end
   end
 end

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

@@ -4,6 +4,8 @@ describe Prawn::SVG::Elements::Text do
   let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}, font_registry: Prawn::SVG::FontRegistry.new("Helvetica" => {:normal => nil}, "Courier" => {normal: nil}, 'Times-Roman' => {normal: nil})) }
   let(:element)  { Prawn::SVG::Elements::Text.new(document, document.root, [], fake_state) }
 
+  let(:default_style) { {:size=>16, :style=>:normal, :text_anchor=>'start', :at=>[:relative, :relative], :offset=>[0,0]} }
+
   describe "xml:space preserve" do
     let(:svg) { %(<text#{attributes}>some\n\t  text</text>) }
 
@@ -77,17 +79,81 @@ Even more
 
       expect(element.base_calls).to eq [
         ["text_group", [], [
-          ["fill", [], [
-            ["font", ["Helvetica", {style: :normal}], []],
-            ["character_spacing", [5.0], [
-              ["draw_text", ["spaced", {:size=>16, :style=>:normal, :text_anchor=>'start', :at=>[:relative, :relative], :offset=>[0,0]}], []]
-            ]]
+          ["font", ["Helvetica", {style: :normal}], []],
+          ["character_spacing", [5.0], [
+            ["draw_text", ["spaced", default_style], []]
           ]]
         ]]
       ]
     end
   end
 
+  describe "underline" do
+    let(:svg) { '<text text-decoration="underline">underlined</text>' }
+
+    it "marks the element to be underlined" do
+      element.process
+
+      expect(element.base_calls).to eq [
+        ["text_group", [], [
+          ["font", ["Helvetica", {:style=>:normal}], []],
+          ["draw_text", ["underlined", default_style.merge(decoration: 'underline')], []]
+        ]]
+      ]
+    end
+  end
+
+  describe "fill/stroke modes" do
+    context "with a stroke and no fill" do
+      let(:svg) { '<text stroke="red" fill="none">stroked</text>' }
+
+      it "calls text_rendering_mode with the requested options" do
+        element.process
+
+        expect(element.base_calls).to eq [
+          ["text_group", [], [
+            ["stroke_color", ["ff0000"], []],
+            ["font", ["Helvetica", {style: :normal}], []],
+            ["text_rendering_mode", [:stroke], [
+              ["draw_text", ["stroked", default_style], []]
+            ]]
+          ]]
+        ]
+      end
+    end
+
+    context "with a mixture of everything" do
+      let(:svg) { '<text stroke="red" fill="none">stroked <tspan fill="black">both</tspan><tspan stroke="none">neither</tspan></text>' }
+
+      it "calls text_rendering_mode with the requested options" do
+        element.process
+
+        expect(element.base_calls).to eq [
+          ["text_group", [], [
+            ["stroke_color", ["ff0000"], []],
+            ["font", ["Helvetica", {style: :normal}], []],
+            ["text_rendering_mode", [:stroke], [
+              ["draw_text", ["stroked ", default_style], []],
+              ["save", [], []],
+              ["fill_color", ["000000"], []],
+              ["font", ["Helvetica", {style: :normal}], []],
+              ["text_rendering_mode", [:fill_stroke], [
+                ["draw_text", ["both", default_style], []]
+              ]],
+              ["restore", [], []],
+              ["save", [], []],
+              ["font", ["Helvetica", {style: :normal}], []],
+              ["text_rendering_mode", [:invisible], [
+                ["draw_text", ["neither", default_style], []]
+              ]],
+              ["restore", [], []],
+            ]]
+          ]]
+        ]
+      end
+    end
+  end
+
   describe "font finding" do
     context "with a font that exists" do
       let(:svg) { '<text font-family="monospace">hello</text>' }
@@ -124,11 +190,9 @@ Even more
 
     it "references the text" do
       element.process
-      expect(flatten_calls(element.base_calls)[11..15]).to eq [
+      expect(flatten_calls(element.base_calls)[9..11]).to eq [
         ["fill_color", ["ff0000"]],
-        ["fill", []],
         ["font", ["Helvetica", {:style=>:normal}]],
-        ["character_spacing", [0]],
         ["draw_text", ["my reference text", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[10.0, :relative], :offset=>[0,0]}]],
       ]
     end
@@ -137,14 +201,12 @@ Even more
   describe "dx and dy attributes" do
     let(:svg) { '<text x="10 20" dx="30 50 80" dy="2">Hi there, this is a good test</text>' }
 
-    it "correctly calculates the positinos of the text" do
+    it "correctly calculates the positions of the text" do
       element.process
 
       expect(flatten_calls(element.base_calls)).to eq [
         ["text_group", []],
-        ["fill", []],
         ["font", ["Helvetica", {:style=>:normal}]],
-        ["character_spacing", [0]],
         ["draw_text", ["H", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[10.0, :relative], :offset=>[30.0, 2.0]}]],
         ["draw_text", ["i", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[20.0, :relative], :offset=>[50.0, 0]}]],
         ["draw_text", [" there, this is a good test", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[80.0, 0]}]]
@@ -155,21 +217,17 @@ Even more
   describe "rotate attribute" do
     let(:svg) { '<text rotate="10 20 30 40 50 60 70 80 90 100">Hi <tspan rotate="0">this</tspan> ok!</text>' }
 
-    it "correctly calculates the positinos of the text" do
+    it "correctly calculates the positions of the text" do
       element.process
 
       expect(flatten_calls(element.base_calls)).to eq [
         ["text_group", []],
-        ["fill", []],
         ["font", ["Helvetica", {:style=>:normal}]],
-        ["character_spacing", [0]],
         ["draw_text", ["H", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-10.0}]],
         ["draw_text", ["i", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-20.0}]],
         ["draw_text", [" ", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-30.0}]],
         ["save", []],
-        ["fill", []],
         ["font", ["Helvetica", {:style=>:normal}]],
-        ["character_spacing", [0]],
         ["draw_text", ["this", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0]}]],
         ["restore", []],
         ["draw_text", [" ", {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-80.0}]],

data/spec/prawn/svg/font_registry_spec.rb

@@ -32,6 +32,36 @@ RSpec.describe Prawn::SVG::FontRegistry do
     end
   end
 
+  describe "#installed_fonts" do
+    let(:ttf)  { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Italic") }
+    let(:ttf2) { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Regular") }
+    before { Prawn::SVG::FontRegistry.external_font_families.clear }
+
+    let(:pdf) do
+      doc = Prawn::Document.new
+      doc.font_families.update({
+        "Awesome Font" => {:italic => "second.ttf", :normal => "file.ttf"}
+      })
+      doc
+    end
+
+    let(:font_registry) { Prawn::SVG::FontRegistry.new(pdf.font_families) }
+
+    it "does not override existing entries in pdf when loading external fonts" do
+      expect(Prawn::SVG::FontRegistry).to receive(:font_path).and_return(["x"])
+      expect(Dir).to receive(:[]).with("x/**/*").and_return(["file.ttf", "second.ttf"])
+      expect(Prawn::SVG::TTF).to receive(:new).with("file.ttf").and_return(ttf)
+      expect(Prawn::SVG::TTF).to receive(:new).with("second.ttf").and_return(ttf2)
+      expect(File).to receive(:file?).at_least(:once).and_return(true)
+
+      Prawn::SVG::FontRegistry.load_external_fonts
+      font_registry.installed_fonts
+
+      existing_font = font_registry.installed_fonts["Awesome Font"]
+      expect(existing_font).to eq(:italic => "second.ttf",:normal => "file.ttf")
+    end
+  end
+
   describe "::load_external_fonts" do
     let(:ttf)  { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Italic") }
     let(:ttf2) { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Regular") }

data/spec/prawn/svg/interface_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Prawn::SVG::Interface do
-  let(:bounds) { double(width: 800, height: 600) }
+  let(:bounds) { double(width: 800, height: 600, absolute_left: 0, absolute_top: 0) }
   let(:prawn)  { instance_double(Prawn::Document, font_families: {}, bounds: bounds, cursor: 600) }
   let(:svg)    { '<svg width="250" height="100"></svg>' }
 
@@ -30,6 +30,38 @@ describe Prawn::SVG::Interface do
         expect(interface.document.warnings).to eq ["Zero or negative sizing data means this SVG cannot be rendered"]
       end
     end
+
+    describe "rewrites" do
+      before do
+        [:save_font, :bounding_box].each { |message| allow(prawn).to receive(message).and_yield }
+        allow(prawn).to receive_messages([:move_to, :line_to, :close_path, :fill_color, :stroke_color, :transformation_matrix, :restore_graphics_state])
+        allow(prawn).to receive(:save_graphics_state) { |&block| block.call if block }
+      end
+
+      context "when fill_and_stroke is issued" do
+        context "and fill rule is not set" do
+          let(:interface) { Prawn::SVG::Interface.new('<svg width="250" height="100"><rect width="10" height="10" stroke="red"></rect></svg>', prawn, {}) }
+
+          it "adds content 'B'" do
+            expect(prawn).to receive(:rectangle).with([0, 100], 10, 10)
+            expect(prawn).to receive(:add_content).with("W n")
+            expect(prawn).to receive(:add_content).with("B")
+            interface.draw
+          end
+        end
+
+        context "and fill rule is evenodd" do
+          let(:interface) { Prawn::SVG::Interface.new('<svg width="250" height="100"><rect width="10" height="10" stroke="red" fill-rule="evenodd"></rect></svg>', prawn, {}) }
+
+          it "adds content 'B*'" do
+            expect(prawn).to receive(:rectangle).with([0, 100], 10, 10)
+            expect(prawn).to receive(:add_content).with("W n")
+            expect(prawn).to receive(:add_content).with("B*")
+            interface.draw
+          end
+        end
+      end
+    end
   end
 
   describe "#position" do

data/spec/prawn/svg/loaders/data_spec.rb

@@ -29,6 +29,14 @@ RSpec.describe Prawn::SVG::Loaders::Data do
     end
   end
 
+  context "with a data URL that's uppercase" do
+    let(:url) { "DATA:IMAGE/PNG;BASE64;METADATA;HERE,aGVsbG8=" }
+
+    it "loads the data" do
+      expect(subject).to eq "hello"
+    end
+  end
+
   context "with a URL that's not a data scheme" do
     let(:url) { "http://some.host" }
 

data/spec/prawn/svg/transform_parser_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::TransformParser do
+  class Test
+    include Prawn::SVG::Calculators::Pixels
+    include Prawn::SVG::TransformParser
+
+    State = Struct.new(:viewport_sizing)
+    Properties = Struct.new(:numerical_font_size)
+    Document = Struct.new(:sizing)
+
+    def document
+      Document.new(_sizing)
+    end
+
+    def state
+      State.new(_sizing)
+    end
+
+    def computed_properties
+      Properties.new(14)
+    end
+
+    def _sizing
+      Prawn::SVG::Calculators::DocumentSizing.new([1000, 800])
+    end
+  end
+
+  subject { Test.new.parse_transform_attribute(transform) }
+
+  context "with no transform" do
+    let(:transform) { '' }
+    it { is_expected.to eq [1, 0, 0, 1, 0, 0] }
+  end
+
+  context "with translate" do
+    let(:transform) { 'translate(10 20)' }
+    it { is_expected.to eq [1, 0, 0, 1, 10, -20] }
+  end
+
+  context "with single argument translate" do
+    let(:transform) { 'translate(10)' }
+    it { is_expected.to eq [1, 0, 0, 1, 10, 0] }
+  end
+
+  context "with translateX" do
+    let(:transform) { 'translateX(10)' }
+    it { is_expected.to eq [1, 0, 0, 1, 10, 0] }
+  end
+
+  context "with translateY" do
+    let(:transform) { 'translateY(10)' }
+    it { is_expected.to eq [1, 0, 0, 1, 0, -10] }
+  end
+
+  let(:sin30) { Math.sin(30 * Math::PI / 180.0) }
+  let(:cos30) { Math.cos(30 * Math::PI / 180.0) }
+  let(:tan30) { Math.tan(30 * Math::PI / 180.0) }
+
+  context "with single argument rotate" do
+    let(:transform) { 'rotate(30)' }
+    it { is_expected.to eq [cos30, -sin30, sin30, cos30, 0, 0] }
+  end
+
+  context "with triple argument rotate" do
+    let(:transform) { 'rotate(30 100 200)' }
+    it { is_expected.to eq [cos30, -sin30, sin30, cos30, 113.39745962155611, 23.205080756887753] }
+  end
+
+  context "with scale" do
+    let(:transform) { 'scale(1.5)' }
+    it { is_expected.to eq [1.5, 0, 0, 1.5, 0, 0] }
+  end
+
+  context "with skewX" do
+    let(:transform) { 'skewX(30)' }
+    it { is_expected.to eq [1, 0, -tan30, 1, 0, 0] }
+  end
+
+  context "with skewY" do
+    let(:transform) { 'skewY(30)' }
+    it { is_expected.to eq [1, -tan30, 0, 1, 0, 0] }
+  end
+
+  context "with matrix" do
+    let(:transform) { 'matrix(1 2 3 4 5 6)' }
+    it { is_expected.to eq [1, -2, -3, 4, 5, -6] }
+  end
+
+  context "with multiple" do
+    let(:transform) { 'scale(2) translate(7) scale(3)' }
+    it { is_expected.to eq [6, 0, 0, 6, 14, 0] }
+  end
+end