prawn-svg 0.28.0 → 0.32.0

data/lib/prawn/svg/properties.rb

@@ -37,6 +37,7 @@ class Prawn::SVG::Properties
     "stroke-opacity"   => Config.new("1", true),
     "stroke-width"     => Config.new("1", true),
     "text-anchor"      => Config.new("start", true, %w(inherit start middle end), true),
+    'text-decoration'  => Config.new('none', true, %w(inherit none underline), true),
   }.freeze
 
   PROPERTIES.each do |name, value|

data/lib/prawn/svg/transform_parser.rb

@@ -0,0 +1,72 @@
+module Prawn::SVG::TransformParser
+  def parse_transform_attribute(transform)
+    matrix = Matrix.identity(3)
+
+    parse_css_method_calls(transform).each do |name, arguments|
+      case name
+      when 'translate'
+        x, y = arguments
+        matrix *= Matrix[[1, 0, x_pixels(x.to_f)], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
+
+      when 'translateX'
+        x = arguments.first
+        matrix *= Matrix[[1, 0, x_pixels(x.to_f)], [0, 1, 0], [0, 0, 1]]
+
+      when 'translateY'
+        y = arguments.first
+        matrix *= Matrix[[1, 0, 0], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
+
+      when 'rotate'
+        angle, x, y = arguments.collect { |a| a.to_f }
+        angle = angle * Math::PI / 180.0
+
+        case arguments.length
+        when 1
+          matrix *= Matrix[[Math.cos(angle), Math.sin(angle), 0], [-Math.sin(angle), Math.cos(angle), 0], [0, 0, 1]]
+        when 3
+          matrix *= Matrix[[1, 0, x_pixels(x.to_f)], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
+          matrix *= Matrix[[Math.cos(angle), Math.sin(angle), 0], [-Math.sin(angle), Math.cos(angle), 0], [0, 0, 1]]
+          matrix *= Matrix[[1, 0, -x_pixels(x.to_f)], [0, 1, y_pixels(y.to_f)], [0, 0, 1]]
+        else
+          warnings << "transform 'rotate' must have either one or three arguments"
+        end
+
+      when 'scale'
+        x_scale = arguments[0].to_f
+        y_scale = (arguments[1] || x_scale).to_f
+        matrix *= Matrix[[x_scale, 0, 0], [0, y_scale, 0], [0, 0, 1]]
+
+      when 'skewX'
+        angle = arguments[0].to_f * Math::PI / 180.0
+        matrix *= Matrix[[1, -Math.tan(angle), 0], [0, 1, 0], [0, 0, 1]]
+
+      when 'skewY'
+        angle = arguments[0].to_f * Math::PI / 180.0
+        matrix *= Matrix[[1, 0, 0], [-Math.tan(angle), 1, 0], [0, 0, 1]]
+
+      when 'matrix'
+        if arguments.length != 6
+          warnings << "transform 'matrix' must have six arguments"
+        else
+          a, b, c, d, e, f = arguments.collect { |argument| argument.to_f }
+          matrix *= Matrix[[a, -c, e], [-b, d, -f], [0, 0, 1]]
+        end
+
+      else
+        warnings << "Unknown/unsupported transformation '#{name}'; ignoring"
+      end
+    end
+
+    matrix.to_a[0..1].transpose.flatten
+  end
+
+  private
+
+  def parse_css_method_calls(string)
+    string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
+      name, argument_string = call
+      arguments = argument_string.strip.split(/\s*[,\s]\s*/)
+      [name, arguments]
+    end
+  end
+end

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module SVG
-    VERSION = '0.28.0'
+    VERSION = '0.32.0'
   end
 end

data/prawn-svg.gemspec

@@ -6,7 +6,6 @@ Gem::Specification.new do |gem|
   gem.version = Prawn::SVG::VERSION
   gem.summary = "SVG renderer for Prawn PDF library"
   gem.description = "This gem allows you to render SVG directly into a PDF using the 'prawn' gem.  Since PDF is vector-based, you'll get nice scaled graphics if you use SVG instead of an image."
-  gem.has_rdoc = false
   gem.author = "Roger Nesbitt"
   gem.email = "roger@seriousorange.com"
   gem.homepage = "http://github.com/mogest/prawn-svg"
@@ -18,10 +17,11 @@ Gem::Specification.new do |gem|
   gem.name          = "prawn-svg"
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = '>= 2.1.0'
+  gem.required_ruby_version = '>= 2.3.0'
 
   gem.add_runtime_dependency "prawn", ">= 0.11.1", "< 3"
   gem.add_runtime_dependency "css_parser", "~> 1.6"
+  gem.add_runtime_dependency "rexml", "~> 3.2"
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "rake", "~> 10.1"
+  gem.add_development_dependency "rake", "~> 13.0"
 end

data/spec/integration_spec.rb

@@ -28,34 +28,34 @@ describe "Integration test" do
       element.process
 
       expect(element.calls).to eq [
-        ["fill_color", ["000000"], []],
-        ["transformation_matrix", [1, 0, 0, 1, 0, 0], []],
-        ["transformation_matrix", [1, 0, 0, 1, 0, 0], []],
-        ["save", [], []], ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["0000ff"], []],
-        ["fill", [], [
-          ["rectangle", [[0.0, 200.0], 10.0, 10.0], []]
+        ["fill_color", ["000000"], {}, []],
+        ["transformation_matrix", [1, 0, 0, 1, 0, 0], {}, []],
+        ["transformation_matrix", [1, 0, 0, 1, 0, 0], {}, []],
+        ["save", [], {}, []], ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["0000ff"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[0.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["008000"], []],
-        ["fill", [], [
-          ["rectangle", [[10.0, 200.0], 10.0, 10.0], []]
+        ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["008000"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[10.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["ff0000"], []],
-        ["fill", [], [
-          ["rectangle", [[20.0, 200.0], 10.0, 10.0], []]
+        ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["ff0000"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[20.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["ffff00"], []],
-        ["fill", [], [
-          ["rectangle", [[30.0, 200.0], 10.0, 10.0], []]
+        ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["ffff00"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[30.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []]
+        ["restore", [], {}, []]
       ]
     end
   end

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

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Attributes::Opacity do
+  class OpacityTestElement
+    include Prawn::SVG::Attributes::Opacity
+
+    attr_accessor :properties, :state
+
+    def initialize
+      @properties = ::Prawn::SVG::Properties.new
+      @state = ::Prawn::SVG::State.new
+    end
+
+    def clamp(value, min_value, max_value)
+      [[value, min_value].max, max_value].min
+    end
+  end
+
+  let(:element) { OpacityTestElement.new }
+
+  describe "#parse_opacity_attributes_and_call" do
+    subject { element.parse_opacity_attributes_and_call }
+
+    context "with no opacity specified" do
+      it "does nothing" do
+        expect(element).not_to receive(:add_call_and_enter)
+        subject
+      end
+    end
+
+    context "with opacity" do
+      it "sets fill and stroke opacity" do
+        element.properties.opacity = '0.4'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 0.4)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.4
+        expect(element.state.stroke_opacity).to eq 0.4
+      end
+    end
+
+    context "with just fill opacity" do
+      it "sets fill opacity and sets stroke opacity to 1" do
+        element.properties.fill_opacity = '0.4'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 1)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.4
+        expect(element.state.stroke_opacity).to eq 1
+      end
+    end
+
+    context "with an existing fill/stroke opacity" do
+      it "multiplies the new opacity by the old" do
+        element.state.fill_opacity = 0.5
+        element.state.stroke_opacity = 0.8
+
+        element.properties.fill_opacity = '0.4'
+        element.properties.stroke_opacity = '0.5'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.2, 0.4)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.2
+        expect(element.state.stroke_opacity).to eq 0.4
+      end
+    end
+
+    context "with stroke, fill, and opacity all specified" do
+      it "choses the lower of them" do
+        element.properties.fill_opacity = '0.4'
+        element.properties.stroke_opacity = '0.6'
+        element.properties.opacity = '0.5'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 0.5)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.4
+        expect(element.state.stroke_opacity).to eq 0.5
+      end
+    end
+  end
+end

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

@@ -14,43 +14,38 @@ describe Prawn::SVG::Attributes::Transform do
 
   let(:element) { TransformTestElement.new }
 
-  describe "#parse_transform_attribute_and_call" do
-    subject { element.send :parse_transform_attribute_and_call }
-
-    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(: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
-      end
+  subject { element.send :parse_transform_attribute_and_call }
+
+  context "when a non-identity matrix is requested" do
+    let(:transform) { 'translate(-5.5)' }
+
+    it "passes the transform and executes the returned matrix" do
+      expect(element).to receive(:parse_transform_attribute).with(transform).and_return([1, 2, 3, 4, 5, 6])
+      expect(element).to receive(:add_call_and_enter).with('transformation_matrix', 1, 2, 3, 4, 5, 6)
+
+      element.attributes['transform'] = transform
+      subject
+    end
+  end
+
+  context "when an identity matrix is requested" do
+    let(:transform) { 'translate(0)' }
+
+    it "does not execute any commands" do
+      expect(element).to receive(:parse_transform_attribute).with(transform).and_return([1, 0, 0, 1, 0, 0])
+      expect(element).not_to receive(:add_call_and_enter)
+
+      element.attributes['transform'] = transform
+      subject
     end
+  end
+
+  context "when transform is blank" do
+    it "does nothing" do
+      expect(element).not_to receive(:parse_transform_attribute)
+      expect(element).not_to receive(:add_call_and_enter)
 
-    describe "rotate" do
-      it "handles a single angle argument" do
-        expect(element).to receive(:add_call_and_enter).with('rotate', -5.5, :origin => [0, 0])
-        expect(element).to receive(:y).with('0').and_return(0)
-
-        element.attributes['transform'] = 'rotate(5.5)'
-        subject
-      end
-
-      it "handles three arguments" do
-        expect(element).to receive(:add_call_and_enter).with('rotate', -5.5, :origin => [1.0, 2.0])
-        expect(element).to receive(:x).with(1.0).and_return(1.0)
-        expect(element).to receive(:y).with(2.0).and_return(2.0)
-
-        element.attributes['transform'] = 'rotate(5.5 1 2)'
-        subject
-      end
-
-      it "does nothing and warns if two arguments" do
-        expect(element).to receive(:warnings).and_return([])
-        element.attributes['transform'] = 'rotate(5.5 1)'
-        subject
-      end
+      subject
     end
   end
 end

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

@@ -31,8 +31,8 @@ describe Prawn::SVG::Calculators::DocumentSizing do
   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_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
@@ -74,12 +74,12 @@ describe Prawn::SVG::Calculators::DocumentSizing do
       context "when a viewBox is specified" do
         let(:attributes) { {"viewBox" => "0 0 100 200"} }
 
-        it "defaults to 100% width and height" do
+        it "defaults to 100% width and uses the viewbox ratio for 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 800
+          expect(sizing.output_height).to eq 2400
         end
       end
 

data/spec/prawn/svg/css/stylesheets_spec.rb

@@ -11,6 +11,7 @@ RSpec.describe Prawn::SVG::CSS::Stylesheets do
           rect { fill: #ff0000; }
           rect ~ rect { fill: #330000; }
           rect + rect { fill: #440000; }
+          rect:first-child:last-child { fill: #441234; }
 
           circle:first-child { fill: #550000; }
           circle:nth-child(2) { fill: #660000; }
@@ -37,9 +38,13 @@ RSpec.describe Prawn::SVG::CSS::Stylesheets do
             <rect width="6" height="6" />
           </g>
 
-          <circle width="7" />
-          <circle width="8" />
-          <circle width="9" />
+          <circle width="100" />
+
+          <g id="circles">
+            <circle width="7" />
+            <circle width="8" />
+            <circle width="9" />
+          </g>
         </g>
 
         <square width="10" chocolate="hi there" />
@@ -56,13 +61,17 @@ RSpec.describe Prawn::SVG::CSS::Stylesheets do
       result = Prawn::SVG::CSS::Stylesheets.new(CssParser::Parser.new, REXML::Document.new(svg)).load
       width_and_styles = result.map { |k, v| [k.attributes["width"].to_i, v] }.sort_by(&:first)
 
-      expect(width_and_styles).to eq [
+      expected = [
         [1, [["fill", "#ff0000", false]]],
         [2, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#440000", false], ["fill", "#220000", false]]],
         [3, [["fill", "#ff0000", false], ["fill", "#00ff00", false]]],
         [4, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#440000", false], ["fill", "#00ff00", false]]],
-        [5, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#330000", false], ["fill", "#00ff00", false]]],
-        [6, [["fill", "#ff0000", false], ["fill", "#0000ff", false]]],
+      ]
+
+      expected << [5, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#330000", false], ["fill", "#440000", false], ["fill", "#00ff00", false]]]
+
+      expected.concat [
+        [6, [["fill", "#ff0000", false], ["fill", "#441234", false], ["fill", "#0000ff", false]]],
         [7, [["fill", "#550000", false]]],
         [8, [["fill", "#660000", false]]],
         [9, [["fill", "#770000", false]]],
@@ -74,6 +83,8 @@ RSpec.describe Prawn::SVG::CSS::Stylesheets do
         [15, [["fill", "#dd0000", false]]],
         [16, [["fill", "#ee0000", false]]],
       ]
+
+      expect(width_and_styles).to eq(expected)
     end
   end
 

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

@@ -25,19 +25,19 @@ describe Prawn::SVG::Elements::Base do
     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"/>
+          <something transform="scale(2)" fill-opacity="0.5" fill="red" stroke="blue" stroke-width="5"/>
         SVG
       end
 
       it "appends the relevant calls" do
         element.process
         expect(element.base_calls).to eq [
-          ["rotate", [-90.0, {origin: [0, 600.0]}], [
-            ["transparent", [0.5, 1], [
-              ["fill_color", ["ff0000"], []],
-              ["stroke_color", ["0000ff"], []],
-              ["line_width", [5.0], []],
-              ["fill_and_stroke", [], []]
+          ["transformation_matrix", [2, 0, 0, 2, 0, 0], {}, [
+            ["transparent", [0.5, 1], {}, [
+              ["fill_color", ["ff0000"], {}, []],
+              ["stroke_color", ["0000ff"], {}, []],
+              ["line_width", [5.0], {}, []],
+              ["fill_and_stroke", [], {}, []]
             ]]
           ]]
         ]
@@ -50,37 +50,37 @@ describe Prawn::SVG::Elements::Base do
 
       context "with neither fill nor stroke" do
         let(:svg) { '<rect style="fill: none;"></rect>' }
-        it        { is_expected.to eq ['end_path', [], []] }
+        it        { is_expected.to eq ['end_path', [], {}, []] }
       end
 
       context "with a fill only" do
         let(:svg) { '<rect style="fill: black;"></rect>' }
-        it        { is_expected.to eq ['fill', [], []] }
+        it        { is_expected.to eq ['fill', [], {}, []] }
       end
 
       context "with a stroke only" do
         let(:svg) { '<rect style="fill: none; stroke: black;"></rect>' }
-        it        { is_expected.to eq ['stroke', [], []] }
+        it        { is_expected.to eq ['stroke', [], {}, []] }
       end
 
       context "with fill and stroke" do
         let(:svg) { '<rect style="fill: black; stroke: black;"></rect>' }
-        it        { is_expected.to eq ['fill_and_stroke', [], []] }
+        it        { is_expected.to eq ['fill_and_stroke', [], {}, []] }
       end
 
       context "with fill with evenodd fill rule" do
         let(:svg) { '<rect style="fill: black; fill-rule: evenodd;"></rect>' }
-        it        { is_expected.to eq ['fill', [{fill_rule: :even_odd}], []] }
+        it        { is_expected.to eq ['fill', [], {fill_rule: :even_odd}, []] }
       end
     end
 
     it "appends calls to the parent element" do
       expect(element).to receive(:apply) do
-        element.send :add_call, "test", "argument"
+        element.send :add_call, "test", "argument", kw: 'argument'
       end
 
       element.process
-      expect(element.parent_calls).to eq [["fill", [], [["test", ["argument"], []]]]]
+      expect(element.parent_calls).to eq [["fill", [], {}, [["test", ["argument"], {kw: 'argument'}, []]]]]
     end
 
     it "quietly absorbs a SkipElementQuietly exception" do
@@ -149,8 +149,8 @@ describe Prawn::SVG::Elements::Base do
       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']]
+        expect(flattened_calls).to include ['fill_color', ['ff0000'], {}]
+        expect(flattened_calls).not_to include ['fill_color', ['00ff00'], {}]
       end
     end