prawn-svg 0.15.0.0 → 0.23.0

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

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Prawn::SVG::Calculators::DocumentSizing do
+  let(:attributes) do
+    {"width" => "150", "height" => "200", "viewBox" => "0 -30 300 800", "preserveAspectRatio" => "xMaxYMid meet"}
+  end
+
+  let(:bounds) { [1200, 800] }
+
+  let(:sizing) { Prawn::SVG::Calculators::DocumentSizing.new(bounds, attributes) }
+
+  describe "#initialize" do
+    it "takes bounds and a set of attributes and calls set_from_attributes" do
+      expect(sizing.instance_variable_get :@bounds).to eq bounds
+      expect(sizing.instance_variable_get :@document_width).to eq "150"
+    end
+  end
+
+  describe "#set_from_attributes" do
+    let(:sizing) { Prawn::SVG::Calculators::DocumentSizing.new(bounds) }
+
+    it "sets ivars from the passed-in attributes hash" do
+      sizing.set_from_attributes(attributes)
+      expect(sizing.instance_variable_get :@document_width).to eq "150"
+      expect(sizing.instance_variable_get :@document_height).to eq "200"
+      expect(sizing.instance_variable_get :@view_box).to eq "0 -30 300 800"
+      expect(sizing.instance_variable_get :@preserve_aspect_ratio).to eq "xMaxYMid meet"
+    end
+  end
+
+  describe "#calculate" do
+    it "calculates the document sizing measurements for a given set of inputs" do
+      sizing.calculate
+      expect(sizing.x_offset).to eq -75 / 0.25
+      expect(sizing.y_offset).to eq -30
+      expect(sizing.x_scale).to eq 0.25
+      expect(sizing.y_scale).to eq 0.25
+      expect(sizing.viewport_width).to eq 300
+      expect(sizing.viewport_height).to eq 800
+      expect(sizing.output_width).to eq 150
+      expect(sizing.output_height).to eq 200
+    end
+
+    it "scales again based on requested width" do
+      sizing.requested_width = 75
+      sizing.calculate
+      expect(sizing.x_scale).to eq 0.125
+      expect(sizing.y_scale).to eq 0.125
+      expect(sizing.viewport_width).to eq 300
+      expect(sizing.viewport_height).to eq 800
+      expect(sizing.output_width).to eq 75
+      expect(sizing.output_height).to eq 100
+    end
+
+    it "scales again based on requested height" do
+      sizing.requested_height = 100
+      sizing.calculate
+      expect(sizing.x_scale).to eq 0.125
+      expect(sizing.y_scale).to eq 0.125
+      expect(sizing.viewport_width).to eq 300
+      expect(sizing.viewport_height).to eq 800
+      expect(sizing.output_width).to eq 75
+      expect(sizing.output_height).to eq 100
+    end
+
+    it "correctly handles % values being passed in" do
+      sizing.document_width = sizing.document_height = "50%"
+      sizing.calculate
+      expect(sizing.output_width).to eq 600
+      expect(sizing.output_height).to eq 400
+    end
+
+    context "when SVG does not specify width and height" do
+      context "when a viewBox is specified" do
+        let(:attributes) { {"viewBox" => "0 0 100 200"} }
+
+        it "defaults to 100% width and the width times aspect ratio in height" do
+          sizing.calculate
+          expect(sizing.viewport_width).to eq 100
+          expect(sizing.viewport_height).to eq 200
+          expect(sizing.output_width).to eq 1200
+          expect(sizing.output_height).to eq 2400
+        end
+      end
+
+      context "when a requested width and height are supplied" do
+        let(:attributes) { {} }
+
+        it "uses the requested width and height" do
+          sizing.requested_width = 550
+          sizing.requested_height = 400
+          sizing.calculate
+
+          expect(sizing.viewport_width).to eq 550
+          expect(sizing.viewport_height).to eq 400
+          expect(sizing.output_width).to eq 550
+          expect(sizing.output_height).to eq 400
+        end
+      end
+
+      context "when a viewBox and a requested width/height are supplied" do
+        let(:attributes) { {"viewBox" => "0 0 100 200"} }
+
+        it "uses the requested width and height" do
+          sizing.requested_width = 550
+          sizing.requested_height = 400
+          sizing.calculate
+
+          expect(sizing.viewport_width).to eq 100
+          expect(sizing.viewport_height).to eq 200
+          expect(sizing.output_width).to eq 550
+          expect(sizing.output_height).to eq 400
+        end
+      end
+
+      context "when neither viewBox nor requested width/height specified" do
+        let(:attributes) { {} }
+
+        it "defaults to 300x150, because that's what HTML does" do
+          sizing.calculate
+
+          expect(sizing.output_width).to eq 300
+          expect(sizing.output_height).to eq 150
+        end
+      end
+    end
+  end
+end

data/spec/prawn/svg/color_spec.rb

@@ -1,26 +1,61 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Prawn::Svg::Color do
-  describe :color_to_hex do
+describe Prawn::SVG::Color do
+  describe "::color_to_hex" do
     it "converts #xxx to a hex value" do
-      Prawn::Svg::Color.color_to_hex("#9ab").should == "99aabb"
+      Prawn::SVG::Color.color_to_hex("#9ab").should == "99aabb"
     end
 
     it "converts #xxxxxx to a hex value" do
-      Prawn::Svg::Color.color_to_hex("#9ab123").should == "9ab123"
+      Prawn::SVG::Color.color_to_hex("#9ab123").should == "9ab123"
     end
 
     it "converts an html colour name to a hex value" do
-      Prawn::Svg::Color.color_to_hex("White").should == "ffffff"
+      Prawn::SVG::Color.color_to_hex("White").should == "ffffff"
     end
 
     it "converts an rgb string to a hex value" do
-      Prawn::Svg::Color.color_to_hex("rgb(16, 32, 48)").should == "102030"
-      Prawn::Svg::Color.color_to_hex("rgb(-5, 50%, 120%)").should == "007fff"
+      Prawn::SVG::Color.color_to_hex("rgb(16, 32, 48)").should == "102030"
+      Prawn::SVG::Color.color_to_hex("rgb(-5, 50%, 120%)").should == "007fff"
     end
 
     it "scans the string and finds the first colour it can parse" do
-      Prawn::Svg::Color.color_to_hex("function(#someurl, 0) nonexistent rgb( 3 ,4,5 ) white").should == "030405"
+      Prawn::SVG::Color.color_to_hex("function(#someurl, 0) nonexistent rgb( 3 ,4,5 ) white").should == "030405"
+    end
+
+    it "ignores url()s" do
+      expect(Prawn::SVG::Color.color_to_hex("url(#someplace) red")).to eq 'ff0000'
+    end
+
+    it "returns black if the color doesn't exist" do
+      expect(Prawn::SVG::Color.color_to_hex("blurble")).to eq '000000'
+    end
+
+    it "returns nil if there's no fallback after a url()" do
+      expect(Prawn::SVG::Color.color_to_hex("url(#someplace)")).to be nil
+    end
+  end
+
+  describe "::parse" do
+    let(:gradients) { {"flan" => flan_gradient, "drob" => drob_gradient} }
+    let(:flan_gradient) { double }
+    let(:drob_gradient) { double }
+
+    it "returns a list of all colors parsed, ignoring impossible or non-existent colors" do
+      results = Prawn::SVG::Color.parse("url(#nope) url(#flan) blurble green #123", gradients)
+      expect(results).to eq [
+        flan_gradient,
+        Prawn::SVG::Color::Hex.new("008000"),
+        Prawn::SVG::Color::Hex.new("112233")
+      ]
+    end
+
+    it "appends black to the list if there aren't any url() references" do
+      results = Prawn::SVG::Color.parse("blurble green", gradients)
+      expect(results).to eq [
+        Prawn::SVG::Color::Hex.new("008000"),
+        Prawn::SVG::Color::Hex.new("000000")
+      ]
     end
   end
 end

data/spec/prawn/svg/css_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::CSS do
+  describe "#parse_font_family_string" do
+    it "correctly handles quotes and escaping" do
+      tests = {
+        "" => [],
+        "font" => ["font"],
+        "font name, other font" => ["font name", "other font"],
+        "'font name', other font" => ["font name", "other font"],
+        "'font, name', other font" => ["font, name", "other font"],
+        '"font name", other font' => ["font name", "other font"],
+        '"font, name", other font' => ["font, name", "other font"],
+        'weird \\" name' => ['weird " name'],
+        'weird\\, name' => ["weird, name"],
+        ' stupid , spacing ' => ["stupid", "spacing"],
+      }
+
+      tests.each do |string, expected|
+        expect(Prawn::SVG::CSS.parse_font_family_string(string)).to eq expected
+      end
+    end
+  end
+end

data/spec/prawn/svg/document_spec.rb

@@ -1,27 +1,56 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Prawn::Svg::Document do  
-  before(:each) do
-    @document = Prawn::Svg::Document.new("<svg></svg>", [100, 100], {})
+describe Prawn::SVG::Document do
+  let(:bounds) { [100, 100] }
+  let(:options) { {} }
+
+  describe "#initialize" do
+    context "when unparsable XML is provided" do
+      let(:svg) { "this isn't SVG data" }
+
+      it "raises an exception" do
+        expect {
+          Prawn::SVG::Document.new(svg, bounds, options)
+        }.to raise_error Prawn::SVG::Document::InvalidSVGData, "The data supplied is not a valid SVG document."
+      end
+    end
+
+    context "when the user passes in a filename instead of SVG data" do
+      let(:svg) { "some_file.svg" }
+
+      it "raises an exception letting them know what they've done" do
+        expect {
+          Prawn::SVG::Document.new(svg, bounds, options)
+        }.to raise_error Prawn::SVG::Document::InvalidSVGData, "The data supplied is not a valid SVG document.  It looks like you've supplied a filename instead; use IO.read(filename) to get the data before you pass it to prawn-svg."
+      end
+    end
   end
 
-  describe :points do    
+  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, "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 :instance_variable_set, "@actual_width", 600
-      @document.send :instance_variable_set, "@actual_height", 400
-      @document.send(:points, "50%").should == 300
-      @document.send(:points, "50%", :y).should == 200
+      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

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+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) }
+
+  describe "#initialize" do
+    let(:svg) { '<something id="hello"/>' }
+
+    it "adds itself to the elements_by_id hash if an id attribute is supplied" do
+      element
+      expect(document.elements_by_id["hello"]).to eq element
+    end
+  end
+
+  describe "#process" do
+    it "calls #parse and #apply so subclasses can parse the element" do
+      expect(element).to receive(:parse).ordered
+      expect(element).to receive(:apply).ordered
+      element.process
+    end
+
+    describe "applying calls from the standard attributes" do
+      let(:svg) do
+        <<-SVG
+          <something transform="rotate(90)" fill-opacity="0.5" fill="red" stroke="blue" stroke-width="5" font-family="Helvetica"/>
+        SVG
+      end
+
+      it "appends the relevant calls" do
+        element.process
+        expect(element.base_calls).to eq [
+          ["rotate", [-90.0, {origin: [0, 150.0]}], [
+            ["transparent", [0.5, 1], [
+              ["fill_color", ["ff0000"], []],
+              ["stroke_color", ["0000ff"], []],
+              ["line_width", [5.0], []],
+              ["font", ["Helvetica", {:style=>:normal}], [
+                ["fill_and_stroke", [], []]
+              ]]
+            ]]
+          ]]
+        ]
+      end
+    end
+
+    it "appends calls to the parent element" do
+      expect(element).to receive(:apply) do
+        element.send :add_call, "test", "argument"
+      end
+
+      element.process
+      expect(element.parent_calls).to eq [["fill", [], [["test", ["argument"], []]]]]
+    end
+
+    it "quietly absorbs a SkipElementQuietly exception" do
+      expect(element).to receive(:parse).and_raise(Prawn::SVG::Elements::Base::SkipElementQuietly)
+      expect(element).to_not receive(:apply)
+      element.process
+      expect(document.warnings).to be_empty
+    end
+
+    it "absorbs a SkipElementError exception, logging a warning" do
+      expect(element).to receive(:parse).and_raise(Prawn::SVG::Elements::Base::SkipElementError, "hello")
+      expect(element).to_not receive(:apply)
+      element.process
+      expect(document.warnings).to eq ["hello"]
+    end
+  end
+
+  describe "#parse_fill_and_stroke_attributes_and_call" do
+    before do
+      element.send(:combine_attributes_and_style_declarations)
+    end
+
+    subject { element.send :parse_fill_and_stroke_attributes_and_call }
+
+    it "doesn't change anything if no fill attribute provided" do
+      subject
+      expect(element.state.fill).to be true
+
+      element.state.fill = false
+      subject
+      expect(element.state.fill).to be false
+    end
+
+    it "doesn't change anything if 'inherit' fill attribute provided" do
+      element.attributes['fill'] = 'inherit'
+      subject
+      expect(element.state.fill).to be true
+
+      element.state.fill = false
+      subject
+      expect(element.state.fill).to be false
+    end
+
+    it "turns off filling if 'none' fill attribute provided" do
+      element.attributes['fill'] = 'none'
+      subject
+      expect(element.state.fill).to be false
+    end
+
+    it "uses the fill attribute's color" do
+      expect(element).to receive(:add_call).with('fill_color', 'ff0000')
+      element.attributes['fill'] = 'red'
+      subject
+      expect(element.state.fill).to be true
+    end
+
+    it "uses black if the fill attribute's color is unparseable" do
+      expect(element).to receive(:add_call).with('fill_color', '000000')
+      element.attributes['fill'] = 'blarble'
+      subject
+      expect(element.state.fill).to be true
+    end
+
+    it "uses the color attribute if 'currentColor' fill attribute provided" do
+      expect(element).to receive(:add_call).with('fill_color', 'ff0000')
+      element.attributes['fill'] = 'currentColor'
+      element.attributes['color'] = 'red'
+      element.send :parse_color_attribute
+      subject
+      expect(element.state.fill).to be true
+    end
+
+    context "with a color attribute defined on a parent element" do
+      let(:svg) { '<svg style="color: green;"><g style="color: red;"><rect width="10" height="10" style="fill: currentColor;"></rect></g></svg>' }
+      let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, parent_calls) }
+      let(:flattened_calls) { flatten_calls(element.base_calls) }
+
+      it "uses the parent's color element if 'currentColor' fill attribute provided" do
+        element.process
+
+        expect(flattened_calls).to include ['fill_color', ['ff0000']]
+        expect(flattened_calls).not_to include ['fill_color', ['00ff00']]
+      end
+    end
+
+    it "turns off filling if UnresolvableURLWithNoFallbackError is raised" do
+      element.attributes['fill'] = 'url()'
+      subject
+      expect(element.state.fill).to be false
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Elements::Gradient do
+  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {width: 800, height: 600}) }
+  let(:element)  { Prawn::SVG::Elements::Gradient.new(document, document.root, [], Prawn::SVG::State.new) }
+
+  before do
+    allow(element).to receive(:assert_compatible_prawn_version)
+    element.process
+  end
+
+  describe "object bounding box" do
+    let(:svg) do
+      <<-SVG
+        <linearGradient id="flag" x1="0" x2="0.2" y1="0" y2="1">
+          <stop offset="25%" stop-color="red"/>
+          <stop offset="50%" stop-color="white"/>
+          <stop offset="75%" stop-color="blue"/>
+        </linearGradient>
+      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: [100.0, 100.0],
+        to:   [120.0, 0.0],
+        stops: [[0, "ff0000"], [0.25, "ff0000"], [0.5, "ffffff"], [0.75, "0000ff"], [1, "0000ff"]]
+      )
+    end
+
+    it "returns nil if the element doesn't have a bounding box" do
+      arguments = element.gradient_arguments(double(bounding_box: nil))
+      expect(arguments).to be nil
+    end
+  end
+
+  describe "user space on use" do
+    let(:svg) do
+      <<-SVG
+        <linearGradient id="flag" gradientUnits="userSpaceOnUse" x1="100" y1="500" x2="200" y2="600">
+          <stop offset="0" stop-color="red"/>
+          <stop offset="1" stop-color="blue"/>
+        </linearGradient>
+      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],
+        stops: [[0, "ff0000"], [1, "0000ff"]]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Elements::Path do
+  let(:source) { double(name: "path", attributes: {}) }
+  let(:path) { Prawn::SVG::Elements::Path.new(nil, source, [], {}) }
+
+  before do
+    allow(path).to receive(:attributes).and_return("d" => d)
+  end
+
+  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" }
+
+      it "correctly parses" do
+        calls = []
+        path.stub(:run_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", []]
+        ]
+      end
+    end
+
+    context "with m and M commands" do
+      let(:d) { "M 1,2 3,4 m 5,6 7,8" }
+
+      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]]
+        ].each do |args|
+          path.should_receive(:run_path_command).with(*args).and_call_original
+        end
+
+        path.parse
+      end
+    end
+
+    context "with an empty path" do
+      let(:d) { "" }
+
+      it "correctly parses" do
+        path.should_not_receive(:run_path_command)
+        path.parse
+      end
+    end
+
+    context "with a path with invalid characters" do
+      let(:d) { "M 10 % 20" }
+
+      it "raises" do
+        expect { path.parse }.to raise_error(Prawn::SVG::Elements::Base::SkipElementError)
+      end
+    end
+
+    context "with a path with numerical data before a command letter" do
+      let(:d) { "M 10 % 20" }
+
+      it "raises" do
+        expect { path.parse }.to raise_error(Prawn::SVG::Elements::Base::SkipElementError)
+      end
+    end
+  end
+
+  context "when given an A path" do
+    subject { path.parse; path.commands }
+
+    context "that is pretty normal" do
+      let(:d) { "M 100 200 A 10 10 0 0 1 200 200" }
+
+      it "uses bezier curves to approximate an arc path" do
+        expect(subject).to eq [
+          ["move_to", [100.0, 200.0]],
+          ["curve_to", [150.0, 150.0, 100.0, 172.57081148225683, 122.57081148225683, 150.0]],
+          ["curve_to", [200.0, 200.0, 177.42918851774317, 150.0, 200.0, 172.57081148225683]]
+        ]
+      end
+    end
+
+    context "with an identical start and end point" do
+      let(:d) { "M 100 200 A 30 30 0 0 1 100 200" }
+
+      it "ignores the path" do
+        expect(subject).to eq [
+          ["move_to", [100.0, 200.0]]
+        ]
+      end
+    end
+    
+    context "with an rx of 0" do
+      let(:d) { "M 100 200 A 0 10 0 0 1 200 200" }
+
+      it "substitutes a line_to" do
+        expect(subject).to eq [
+          ["move_to", [100.0, 200.0]],
+          ["line_to", [200.0, 200.0]]
+        ]
+      end
+    end
+
+    context "with an ry of 0" do
+      let(:d) { "M 100 200 A 10 0 0 0 1 200 200" }
+
+      it "substitutes a line_to" do
+        expect(subject).to eq [
+          ["move_to", [100.0, 200.0]],
+          ["line_to", [200.0, 200.0]]
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Elements::Style do
+  let(:svg) do
+    <<-SVG
+<style>a
+  before&gt;
+  x <![CDATA[ y
+  inside <>&gt;
+  k ]]> j
+  after
+z</style>
+    SVG
+  end
+
+  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}) }
+  let(:element) { Prawn::SVG::Elements::Style.new(document, document.root, [], {}) }
+
+  it "correctly collects the style information in a <style> tag" do
+    expect(document.css_parser).to receive(:add_block!).with("a\n  before>\n  x  y\n  inside <>&gt;\n  k  j\n  after\nz")
+    element.process
+  end
+end