prawn-svg 0.22.1 → 0.23.0

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

@@ -2,7 +2,7 @@ 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, [], {}) }
+  let(:element)  { Prawn::SVG::Elements::Gradient.new(document, document.root, [], Prawn::SVG::State.new) }
 
   before do
     allow(element).to receive(:assert_compatible_prawn_version)

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

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Prawn::SVG::Elements::Text do
   let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}) }
-  let(:element)  { Prawn::SVG::Elements::Text.new(document, document.root, [], {}) }
+  let(:element)  { Prawn::SVG::Elements::Text.new(document, document.root, [], Prawn::SVG::State.new) }
 
   describe "xml:space preserve" do
     let(:svg) { %(<text#{attributes}>some\n\t  text</text>) }
@@ -33,11 +33,11 @@ describe Prawn::SVG::Elements::Text do
   end
 
   describe "when text-anchor is specified" do
-    let(:svg) { '<g text-anchor="middle" font-family="sans-serif" font-size="12"><text x="50" y="14">Text</text></g>' }
+    let(:svg) { '<g text-anchor="middle" font-size="12"><text x="50" y="14">Text</text></g>' }
 
     it "should inherit text-anchor from parent element" do
       element.process
-      expect(element.state[:text_anchor]).to eq 'middle'
+      expect(element.state.text_anchor).to eq 'middle'
     end
   end
 
@@ -48,7 +48,7 @@ describe Prawn::SVG::Elements::Text do
       element.process
 
       expect(element.base_calls).to eq [
-        ["end_path", [], [
+        ["fill", [], [
           ["text_group", [], [
             ["character_spacing", [5.0], [
               ["draw_text", ["spaced", {:style=>nil, :at=>[0.0, 150.0]}], []]

data/spec/prawn/svg/font_registry_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::FontRegistry do
+  describe "#load" do
+    let(:pdf) { Prawn::Document.new }
+    let(:font_registry) { Prawn::SVG::FontRegistry.new(pdf.font_families) }
+
+    it "matches a built in font" do
+      font_registry.load("blah, 'courier', nothing").name.should == 'Courier'
+    end
+
+    it "matches a default font" do
+      font_registry.load("serif").name.should == 'Times-Roman'
+      font_registry.load("blah, serif").name.should == 'Times-Roman'
+      font_registry.load("blah, serif , test").name.should == 'Times-Roman'
+    end
+
+    if Prawn::SVG::FontRegistry.new({}).installed_fonts["Verdana"]
+      it "matches a font installed on the system" do
+        font_registry.load("verdana, sans-serif").name.should == 'Verdana'
+        font_registry.load("VERDANA, sans-serif").name.should == 'Verdana'
+        font_registry.load("something, \"Times New Roman\", serif").name.should == "Times New Roman"
+        font_registry.load("something, Times New Roman, serif").name.should == "Times New Roman"
+      end
+    else
+      it "not running font test because we couldn't find Verdana installed on the system"
+    end
+
+    it "returns nil if it can't find any such font" do
+      font_registry.load("blah, thing").should be_nil
+      font_registry.load("").should be_nil
+    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") }
+
+    before { Prawn::SVG::FontRegistry.external_font_families.clear }
+
+    it "scans the font path and loads in some 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
+
+      result = Prawn::SVG::FontRegistry.external_font_families
+      expect(result).to eq("Awesome Font" => {:italic => "file.ttf", :normal => "second.ttf"})
+    end
+  end
+end

data/spec/prawn/svg/font_spec.rb

@@ -1,31 +1,4 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Prawn::SVG::Font do
-  describe :load do
-    it "matches a built in font" do
-      Prawn::SVG::Font.load("blah, 'courier', nothing").name.should == 'Courier'
-    end
-
-    it "matches a default font" do
-      Prawn::SVG::Font.load("serif").name.should == 'Times-Roman'
-      Prawn::SVG::Font.load("blah, serif").name.should == 'Times-Roman'
-      Prawn::SVG::Font.load("blah, serif , test").name.should == 'Times-Roman'
-    end
-
-    if Prawn::SVG::Font.installed_fonts["Verdana"]
-      it "matches a font installed on the system" do
-        Prawn::SVG::Font.load("verdana, sans-serif").name.should == 'Verdana'
-        Prawn::SVG::Font.load("VERDANA, sans-serif").name.should == 'Verdana'
-        Prawn::SVG::Font.load("something, \"Times New Roman\", serif").name.should == "Times New Roman"
-        Prawn::SVG::Font.load("something, Times New Roman, serif").name.should == "Times New Roman"
-      end
-    else
-      it "not running font test because we couldn't find Verdana installed on the system"
-    end
-
-    it "returns nil if it can't find any such font" do
-      Prawn::SVG::Font.load("blah, thing").should be_nil
-      Prawn::SVG::Font.load("").should be_nil
-    end
-  end
 end

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::Loaders::Data do
+  let(:uri) { URI(url) }
+
+  subject { Prawn::SVG::Loaders::Data.new.from_url(url) }
+
+  context "with a valid image/png data URL" do
+    let(:url) { "data:image/png;base64,aGVsbG8=" }
+
+    it "loads the data" do
+      expect(subject).to eq "hello"
+    end
+  end
+
+  context "with a valid image/jpeg data URL" do
+    let(:url) { "data:image/jpeg;base64,aGVsbG8=" }
+
+    it "loads the data" do
+      expect(subject).to eq "hello"
+    end
+  end
+
+  context "with a data URL that has extra metadata" 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" }
+
+    it "returns nil" do
+      expect(subject).to be nil
+    end
+  end
+
+  context "with a data URL that's not an image" do
+    let(:url) { "data:application/pdf;base64,aGVsbG8=" }
+
+    it "raises" do
+      expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /image/
+    end
+  end
+
+  context "with a data URL that's not base64 encoded" do
+    let(:url) { "data:image/png;base32,agvsbg" }
+
+    it "raises" do
+      expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /base64/
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::Loaders::File do
+  let(:root_path) { "." }
+
+  subject { Prawn::SVG::Loaders::File.new(root_path).from_url(url) }
+
+  context "when an invalid path is supplied" do
+    let(:root_path) { "/does/not/exist" }
+
+    it "raises with an ArgumentError" do
+      expect { subject }.to raise_error ArgumentError, /is not a directory/
+    end
+  end
+
+  context "when a relative path is supplied" do
+    let(:url) { "some/relative/./path" }
+
+    it "loads the file" do
+      expect(File).to receive(:expand_path).with(".").and_return("/our/root/path")
+      expect(File).to receive(:expand_path).with("/our/root/path/some/relative/./path").and_return("/our/root/path/some/relative/path")
+
+      expect(Dir).to receive(:exist?).with("/our/root/path").and_return(true)
+      expect(File).to receive(:exist?).with("/our/root/path/some/relative/path").and_return(true)
+      expect(IO).to receive(:read).with("/our/root/path/some/relative/path").and_return("data")
+
+      expect(subject).to eq 'data'
+    end
+  end
+
+  context "when an absolute path without file scheme is supplied" do
+    let(:url) { "/some/absolute/./path" }
+
+    it "loads the file" do
+      expect(File).to receive(:expand_path).with(".").and_return("/some")
+      expect(File).to receive(:expand_path).with(url).and_return("/some/absolute/path")
+
+      expect(Dir).to receive(:exist?).with("/some").and_return(true)
+      expect(File).to receive(:exist?).with("/some/absolute/path").and_return(true)
+      expect(IO).to receive(:read).with("/some/absolute/path").and_return("data")
+
+      expect(subject).to eq 'data'
+    end
+  end
+
+  context "when an absolute path with file scheme is supplied" do
+    let(:url) { "file:///some/absolute/./path" }
+
+    it "loads the file" do
+      expect(File).to receive(:expand_path).with(".").and_return("/some")
+      expect(File).to receive(:expand_path).with("/some/absolute/./path").and_return("/some/absolute/path")
+
+      expect(Dir).to receive(:exist?).with("/some").and_return(true)
+      expect(File).to receive(:exist?).with("/some/absolute/path").and_return(true)
+      expect(IO).to receive(:read).with("/some/absolute/path").and_return("data")
+
+      expect(subject).to eq 'data'
+    end
+  end
+
+  context "when a path outside of our root is specified" do
+    let(:url) { "/some/absolute/./path" }
+
+    it "raises" do
+      expect(File).to receive(:expand_path).with(".").and_return("/other")
+      expect(File).to receive(:expand_path).with(url).and_return("/some/absolute/path")
+
+      expect(Dir).to receive(:exist?).with("/other").and_return(true)
+
+      expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /not inside the root path/
+    end
+  end
+
+  context "when a file: url with a host is specified" do
+    let(:url) { "file://somewhere/somefile" }
+
+    it "raises" do
+      expect(File).to receive(:expand_path).with(".").and_return("/other")
+      expect(Dir).to receive(:exist?).with("/other").and_return(true)
+
+      expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /with a host/
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::Loaders::Web do
+  let(:url) { "http://hello.there/path" }
+  let(:uri) { URI(url) }
+
+  subject { Prawn::SVG::Loaders::Web.new.from_url(url) }
+
+  it "loads an HTTP URL" do
+    expect(Net::HTTP).to receive(:get).with(uri).and_return("hello!")
+    expect(subject).to eq "hello!"
+  end
+
+  context "with an https URL" do
+    let(:url) { "https://hello.there/path"}
+
+    it "loads the HTTPS URL" do
+      expect(Net::HTTP).to receive(:get).with(uri).and_return("hello!")
+      expect(subject).to eq "hello!"
+    end
+  end
+
+  context "when the HTTP call raises" do
+    it "re-raises the error as UrlLoader errors" do
+      expect(Net::HTTP).to receive(:get).with(uri).and_raise(SocketError, "argh")
+      expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, 'argh'
+    end
+  end
+
+  context "with a non-http, non-https URL" do
+    let(:url) { "mailto:someone@something" }
+
+    it "returns nil" do
+      expect(subject).to be nil
+    end
+  end
+end

data/spec/prawn/svg/ttf_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::TTF do
+  subject { Prawn::SVG::TTF.new(filename) }
+
+  context "with a truetype font" do
+    let(:filename) { "#{File.dirname(__FILE__)}/../../sample_ttf/OpenSans-SemiboldItalic.ttf" }
+
+    it "gets the English family and subfamily from the font file" do
+      expect(subject.family).to eq 'Open Sans'
+      expect(subject.subfamily).to eq 'Semibold Italic'
+    end
+  end
+
+  context "with a file that isn't a TTF" do
+    let(:filename) { __FILE__ }
+
+    it "has a nil family and subfamily" do
+      expect(subject.family).to be nil
+      expect(subject.subfamily).to be nil
+    end
+  end
+
+  context "with a file that doesn't exist" do
+    let(:filename) { "does_not_exist" }
+
+    it "has a nil family and subfamily" do
+      expect(subject.family).to be nil
+      expect(subject.subfamily).to be nil
+    end
+  end
+end

data/spec/prawn/svg/url_loader_spec.rb

@@ -1,46 +1,112 @@
 require 'spec_helper'
 
 describe Prawn::SVG::UrlLoader do
-  let(:loader) { Prawn::SVG::UrlLoader.new(:enable_cache => true, :enable_web => true) }
+  let(:enable_cache) { true }
+  let(:enable_web)   { true }
+  let(:enable_file)  { "." }
+  let(:loader) { Prawn::SVG::UrlLoader.new(enable_cache: enable_cache, enable_web: enable_web, enable_file_with_root: enable_file) }
 
   describe "#initialize" do
     it "sets options" do
       expect(loader.enable_cache).to be true
-      expect(loader.enable_web).to be true
     end
   end
 
-  describe "#valid?" do
-    it "knows what a valid URL looks like" do
-      expect(loader.valid?("http://valid.example/url")).to be true
-      expect(loader.valid?("not/a/valid/url")).to be false
+  describe "#load" do
+    let(:url) { "http://hello/there" }
+    let(:data_loader) { instance_double(Prawn::SVG::Loaders::Data) }
+    let(:web_loader) { instance_double(Prawn::SVG::Loaders::Web) }
+    let(:file_loader) { instance_double(Prawn::SVG::Loaders::File) }
+
+    before do
+      allow(Prawn::SVG::Loaders::Data).to receive(:new).and_return(data_loader)
+      allow(Prawn::SVG::Loaders::Web).to receive(:new).and_return(web_loader)
+      allow(Prawn::SVG::Loaders::File).to receive(:new).with(enable_file).and_return(file_loader)
     end
 
-    it "doesn't accept schemes it doesn't like" do
-      expect(loader.valid?("mail://valid.example/url")).to be false
+    subject { loader.load(url) }
+
+    it "calls the Data loader and returns its output if successful" do
+      expect(data_loader).to receive(:from_url).with(url).and_return("data")
+      expect(web_loader).not_to receive(:from_url)
+
+      expect(subject).to eq 'data'
     end
-  end
 
-  describe "#load" do
-    let(:url) { "http://hello/there" }
+    it "calls the Web loader if the Data loader returns nothing, and returns its output if successful" do
+      expect(data_loader).to receive(:from_url).with(url)
+      expect(web_loader).to receive(:from_url).with(url).and_return("data")
+
+      expect(subject).to eq 'data'
+    end
+
+    it "calls the File loader if the Data and Web loaders return nothing, and returns its output if successful" do
+      expect(data_loader).to receive(:from_url).with(url)
+      expect(web_loader).to receive(:from_url).with(url)
+      expect(file_loader).to receive(:from_url).with(url).and_return("data")
+
+      expect(subject).to eq 'data'
+    end
+
+    it "raises if none of the loaders return any data" do
+      expect(data_loader).to receive(:from_url).with(url)
+      expect(web_loader).to receive(:from_url).with(url)
+      expect(file_loader).to receive(:from_url).with(url)
 
-    it "loads an HTTP URL and saves to the cache" do
-      o = double(:read => "hello!")
-      loader.should_receive(:open).with(url).and_return(o)
-      
-      expect(loader.load(url)).to eq "hello!"
-      expect(loader.url_cache[url]).to eq "hello!"
+      expect { subject }.to raise_error(Prawn::SVG::UrlLoader::Error, /No handler available/)
     end
 
-    it "loads an HTTP URL from the cache without calling open" do
-      loader.url_cache[url] = "hello"
-      loader.should_not_receive(:open)
-      expect(loader.load(url)).to eq "hello"
+    context "when caching is enabled" do
+      it "caches the result" do
+        expect(data_loader).to receive(:from_url).with(url).and_return("data")
+        expect(subject).to eq 'data'
+        expect(loader.retrieve_from_cache(url)).to eq 'data'
+      end
     end
 
-    it "loads a data URL" do
-      loader.should_not_receive(:open)
-      expect(loader.load("data:image/png;base64,aGVsbG8=")).to eq "hello"
+    context "when caching is disabled" do
+      let(:enable_cache) { false }
+
+      it "does not cache the result" do
+        expect(data_loader).to receive(:from_url).with(url).and_return("data")
+        expect(subject).to eq 'data'
+        expect(loader.retrieve_from_cache(url)).to be nil
+      end
+    end
+
+    context "when the cache is populated" do
+      before { loader.add_to_cache(url, 'data') }
+
+      it "returns the cached value without calling a loader" do
+        expect(data_loader).not_to receive(:from_url)
+        expect(web_loader).not_to receive(:from_url)
+
+        expect(subject).to eq 'data'
+      end
+    end
+
+    context "when web requests are disabled" do
+      let(:enable_web) { false }
+
+      it "doesn't use the web loader" do
+        expect(data_loader).to receive(:from_url)
+        expect(web_loader).not_to receive(:from_url)
+        expect(file_loader).to receive(:from_url)
+
+        expect { subject }.to raise_error(Prawn::SVG::UrlLoader::Error, /No handler available/)
+      end
+    end
+
+    context "when file requests are disabled" do
+      let(:enable_file) { nil }
+
+      it "doesn't use the file loader" do
+        expect(data_loader).to receive(:from_url)
+        expect(web_loader).to receive(:from_url)
+        expect(file_loader).not_to receive(:from_url)
+
+        expect { subject }.to raise_error(Prawn::SVG::UrlLoader::Error, /No handler available/)
+      end
     end
   end
 end