prawn-svg 0.21.0 → 0.22.1

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

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
-describe Prawn::Svg::Calculators::AspectRatio do
+describe Prawn::SVG::Calculators::AspectRatio do
   def test(*args)
-    aspect = Prawn::Svg::Calculators::AspectRatio.new(*args)
+    aspect = Prawn::SVG::Calculators::AspectRatio.new(*args)
     [[aspect.width, aspect.height], [aspect.x, aspect.y]]
   end
 

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

@@ -1,13 +1,13 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
-describe Prawn::Svg::Calculators::DocumentSizing do
+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) }
+  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
@@ -17,7 +17,7 @@ describe Prawn::Svg::Calculators::DocumentSizing do
   end
 
   describe "#set_from_attributes" do
-    let(:sizing) { Prawn::Svg::Calculators::DocumentSizing.new(bounds) }
+    let(:sizing) { Prawn::SVG::Calculators::DocumentSizing.new(bounds) }
 
     it "sets ivars from the passed-in attributes hash" do
       sizing.set_from_attributes(attributes)

data/spec/prawn/svg/color_spec.rb

@@ -1,40 +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'
+      expect(Prawn::SVG::Color.color_to_hex("url(#someplace) red")).to eq 'ff0000'
     end
 
-    it "returns nil if the color doesn't exist" do
-      expect(Prawn::Svg::Color.color_to_hex("blurble")).to be nil
+    it "returns black if the color doesn't exist" do
+      expect(Prawn::SVG::Color.color_to_hex("blurble")).to eq '000000'
     end
 
-    it "raises UnresolvableURLWithNoFallbackError if there's no fallback after a url()" do
-      expect {
-        Prawn::Svg::Color.color_to_hex("url(#someplace)")
-      }.to raise_error(Prawn::Svg::Color::UnresolvableURLWithNoFallbackError)
+    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/document_spec.rb

@@ -1,13 +1,13 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Prawn::Svg::Document do  
+describe Prawn::SVG::Document 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)
+    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)
+    expect(Prawn::SVG::Calculators::DocumentSizing).to receive(:new).and_return(sizing)
   end
 
-  let(:document) { Prawn::Svg::Document.new("<svg></svg>", [100, 100], {}) }
+  let(:document) { Prawn::SVG::Document.new("<svg></svg>", [100, 100], {}) }
 
   describe :points do    
     it "converts a variety of measurement units to points" do

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

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Elements::Base do
+  let(:svg) { "<svg></svg>" }
+  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}) }
+  let(:parent_calls) { [] }
+  let(:element) { Prawn::SVG::Elements::Base.new(document, document.root, parent_calls, {}) }
+
+  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 [["end_path", [], [["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 nil
+    end
+
+    it "doesn't change anything if 'inherit' fill attribute provided" do
+      element.attributes['fill'] = 'inherit'
+      subject
+      expect(element.state[:fill]).to be nil
+    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'
+      subject
+      expect(element.state[:fill]).to be true
+    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, [], {}) }
+
+  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