mbrao 1.2.3 → 1.3.0

data/spec/mbrao/rendering_engines/html_pipeline_spec.rb

@@ -7,100 +7,100 @@
 require "spec_helper"
 
 describe Mbrao::RenderingEngines::HtmlPipeline do
-  let(:reference) { Mbrao::RenderingEngines::HtmlPipeline.new }
+  subject{ Mbrao::RenderingEngines::HtmlPipeline.new }
 
   describe "#render" do
     it "should forward everything to the html-pipeline" do
       pipeline = Object.new
       expect(pipeline).to receive(:call).with("CONTENT").and_return({output: ""})
       expect(::HTML::Pipeline).to receive(:new).with(an_instance_of(Array), an_instance_of(Hash)).and_return(pipeline)
-      reference.render("CONTENT")
+      subject.render("CONTENT")
     end
 
     it "should raise a specific exception if a locale is not available" do
-      expect { reference.render(::Mbrao::Content.create({locales: ["en"]}, "BODY"), {locales: ["it"]}) }.to raise_error(::Mbrao::Exceptions::UnavailableLocalization)
+      expect { subject.render(::Mbrao::Content.create({locales: ["en"]}, "BODY"), {locales: ["it"]}) }.to raise_error(::Mbrao::Exceptions::UnavailableLocalization)
     end
 
       it "should raise an exception if anything goes wrong" do
       allow(::HTML::Pipeline).to receive(:new).and_raise(ArgumentError.new("ERROR"))
-      expect { reference.render("CONTENT") }.to raise_error(::Mbrao::Exceptions::Rendering)
+      expect { subject.render("CONTENT") }.to raise_error(::Mbrao::Exceptions::Rendering)
     end
 
     it "should have default options" do
       filters = [:kramdown, :table_of_contents, :autolink, :emoji, :image_max_width].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
       expect(::HTML::Pipeline).to receive(:new).with(filters, {gfm: true, asset_root: "/"}).and_call_original
-      reference.render("CONTENT")
+      subject.render("CONTENT")
     end
 
     it "should merge context to options" do
       expect(::HTML::Pipeline).to receive(:new).with(an_instance_of(Array), {gfm: true, asset_root: "/", additional: true}).and_call_original
-      reference.render("CONTENT", {}, {additional: true})
+      subject.render("CONTENT", {}, {additional: true})
     end
 
     it "should restrict filter used" do
       filters = [:table_of_contents, :autolink, :emoji, :image_max_width].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
       expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
-      reference.render("CONTENT", {kramdown: false})
+      subject.render("CONTENT", {kramdown: false})
 
       filters = [:kramdown, :autolink, :emoji, :image_max_width].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
       expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
-      reference.render("CONTENT", {toc: false})
+      subject.render("CONTENT", {toc: false})
 
       filters = [:kramdown, :table_of_contents, :emoji, :image_max_width].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
       expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
-      reference.render("CONTENT", {links: false})
+      subject.render("CONTENT", {links: false})
 
       filters = [:kramdown, :table_of_contents, :autolink, :image_max_width].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
       expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
-      reference.render("CONTENT", {emoji: false})
+      subject.render("CONTENT", {emoji: false})
 
       filters = [:kramdown, :table_of_contents, :autolink, :emoji].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
       expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
-      reference.render("CONTENT", {image_max_width: false})
+      subject.render("CONTENT", {image_max_width: false})
     end
   end
 
   describe "#default_pipeline" do
     it "should return a default pipeline" do
-      expect(reference.default_pipeline).to eq([[:kramdown], [:table_of_contents, :toc], [:autolink, :links], [:emoji], [:image_max_width]])
+      expect(subject.default_pipeline).to eq([[:kramdown], [:table_of_contents, :toc], [:autolink, :links], [:emoji], [:image_max_width]])
     end
   end
 
   describe "#default_pipeline=" do
     it "should set a correct pipeline" do
-      reference.default_pipeline = nil
-      expect(reference.default_pipeline).to eq([[]])
+      subject.default_pipeline = nil
+      expect(subject.default_pipeline).to eq([[]])
 
-      reference.default_pipeline = "A"
-      expect(reference.default_pipeline).to eq([[:A]])
+      subject.default_pipeline = "A"
+      expect(subject.default_pipeline).to eq([[:A]])
 
-      reference.default_pipeline = ["A", "B"]
-      expect(reference.default_pipeline).to eq([[:A], [:B]])
+      subject.default_pipeline = ["A", "B"]
+      expect(subject.default_pipeline).to eq([[:A], [:B]])
 
-      reference.default_pipeline = ["1", [["B", ["C"]]]]
-      expect(reference.default_pipeline).to eq([[:"1"], [:B, :C]])
+      subject.default_pipeline = ["1", [["B", ["C"]]]]
+      expect(subject.default_pipeline).to eq([[:"1"], [:B, :C]])
     end
   end
 
   describe "#default_options" do
     it "should return a default hash" do
-      expect(reference.default_options).to eq({gfm: true, asset_root: "/"})
+      expect(subject.default_options).to eq({gfm: true, asset_root: "/"})
     end
 
     it "should return the set hash" do
-      reference.instance_variable_set(:@default_options, {})
-      expect(reference.default_options).to eq({})
+      subject.instance_variable_set(:@default_options, {})
+      expect(subject.default_options).to eq({})
     end
   end
 
   describe "#default_options=" do
     it "should only assign if the value is an Hash" do
-      reference.default_options = {a: "b"}
-      expect(reference.default_options).to eq({a: "b"})
-      reference.default_options = 1
-      expect(reference.default_options).to eq({})
-      reference.default_options = nil
-      expect(reference.default_options).to eq({})
+      subject.default_options = {a: "b"}
+      expect(subject.default_options).to eq({a: "b"})
+      subject.default_options = 1
+      expect(subject.default_options).to eq({})
+      subject.default_options = nil
+      expect(subject.default_options).to eq({})
     end
   end
 end
@@ -113,8 +113,8 @@ describe HTML::Pipeline::KramdownFilter do
     end
 
     it "should remove \r from the text" do
-      reference = HTML::Pipeline::KramdownFilter.new("\rCONTENT\r", {a: "b"}, {c: "d"})
-      expect(reference.instance_variable_get(:@text)).to eq("CONTENT")
+      subject = HTML::Pipeline::KramdownFilter.new("\rCONTENT\r", {a: "b"}, {c: "d"})
+      expect(subject.instance_variable_get(:@text)).to eq("CONTENT")
     end
 
     it "should use Kramdown with given options for building the result" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbrao
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Shogun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-23 00:00:00.000000000 Z
+date: 2013-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lazier