mbrao 1.2.3 → 1.3.0

data/spec/mbrao/content_spec.rb

@@ -7,39 +7,39 @@
 require "spec_helper"
 
 describe Mbrao::Content do
-  let(:reference) { Mbrao::Content.new("UID") }
+  subject { Mbrao::Content.new("UID") }
 
   describe "#initialize" do
     it "store the uid" do
-      reference = Mbrao::Content.new("SAMPLE")
-      expect(reference.uid).to eq("SAMPLE")
+      subject = Mbrao::Content.new("SAMPLE")
+      expect(subject.uid).to eq("SAMPLE")
     end
   end
 
   describe "#locales=" do
     it "correctly assign a string, a symbol or an array" do
-      reference.locales = :it
-      expect(reference.locales).to eq(["it"])
-      reference.locales = "en"
-      expect(reference.locales).to eq(["en"])
-      reference.locales = ["en", [:it, :es]]
-      expect(reference.locales).to eq(["en", "it", "es"])
+      subject.locales = :it
+      expect(subject.locales).to eq(["it"])
+      subject.locales = "en"
+      expect(subject.locales).to eq(["en"])
+      subject.locales = ["en", [:it, :es]]
+      expect(subject.locales).to eq(["en", "it", "es"])
     end
   end
 
   shared_examples_for("localized setter") do |attribute|
     it "should assign a single string" do
-      reference.send("#{attribute}=", "ABC")
-      expect(reference.send(attribute)).to eq("ABC")
-      reference.send("#{attribute}=", 1)
-      expect(reference.send(attribute)).to eq("1")
-      reference.send("#{attribute}=", nil)
-      expect(reference.send(attribute)).to eq("")
+      subject.send("#{attribute}=", "ABC")
+      expect(subject.send(attribute)).to eq("ABC")
+      subject.send("#{attribute}=", 1)
+      expect(subject.send(attribute)).to eq("1")
+      subject.send("#{attribute}=", nil)
+      expect(subject.send(attribute)).to eq("")
     end
 
     it "should assign a string with locales and sanitized entries" do
-      reference.send("#{attribute}=", {en: nil, es: "ABC", it: 1})
-      value = reference.send(attribute)
+      subject.send("#{attribute}=", {en: nil, es: "ABC", it: 1})
+      value = subject.send(attribute)
       expect(value).to be_a(::HashWithIndifferentAccess)
       expect(value["en"]).to eq("")
       expect(value[:es]).to eq("ABC")
@@ -49,80 +49,80 @@ describe Mbrao::Content do
 
   shared_examples_for("localized getter") do |attribute, v1, v2|
     it "should raise an exception if not available for that locale" do
-      reference.locales = [:en, :it, :es]
-      reference.send("#{attribute}=", v1)
-      expect { reference.send("get_#{attribute}", [:de, :it]) }.not_to raise_error
-      expect { reference.send("get_#{attribute}", [:de]) }.to raise_error(Mbrao::Exceptions::UnavailableLocalization)
+      subject.locales = [:en, :it, :es]
+      subject.send("#{attribute}=", v1)
+      expect { subject.send("get_#{attribute}", [:de, :it]) }.not_to raise_error
+      expect { subject.send("get_#{attribute}", [:de]) }.to raise_error(Mbrao::Exceptions::UnavailableLocalization)
     end
 
     it "should return the attribute itself if not localized" do
-      reference.locales = [:en, :it, :es]
-      reference.send("#{attribute}=", v1)
-      expect(reference.send("get_#{attribute}", [:de, :it])).to eq(v1)
+      subject.locales = [:en, :it, :es]
+      subject.send("#{attribute}=", v1)
+      expect(subject.send("get_#{attribute}", [:de, :it])).to eq(v1)
     end
 
     it "should return the default locale if no locales are specified" do
       Mbrao::Parser.locale = :it
-      reference.send("#{attribute}=", {en: v1, it: v2})
-      expect(reference.send("get_#{attribute}")).to eq(v2)
+      subject.send("#{attribute}=", {en: v1, it: v2})
+      expect(subject.send("get_#{attribute}")).to eq(v2)
     end
 
     it "should return only the subset of valid and request locales" do
       Mbrao::Parser.locale = :it
-      reference.send("#{attribute}=", {en: v1, it: v2, de: v1, es: v2})
+      subject.send("#{attribute}=", {en: v1, it: v2, de: v1, es: v2})
 
-      value = reference.send("get_#{attribute}", [:de, :es])
+      value = subject.send("get_#{attribute}", [:de, :es])
       expect(value).to be_a(::HashWithIndifferentAccess)
       expect(value.keys).to eq(["de", "es"])
 
-      value = reference.send("get_#{attribute}", [:it, :de, :pt, :fr])
+      value = subject.send("get_#{attribute}", [:it, :de, :pt, :fr])
       expect(value.keys.sort).to eq(["de", "it"])
 
-      reference.locales = [:en, :it, :es]
-      value = reference.send("get_#{attribute}", "*")
+      subject.locales = [:en, :it, :es]
+      value = subject.send("get_#{attribute}", "*")
       expect(value.keys.sort).to eq(["de", "en", "es", "it"])
 
-      reference.send("#{attribute}=", {en: v1, "it,es" => v2, " de,    fr " => v1})
-      value = reference.send("get_#{attribute}", [:it, :fr])
+      subject.send("#{attribute}=", {en: v1, "it,es" => v2, " de,    fr " => v1})
+      value = subject.send("get_#{attribute}", [:it, :fr])
       expect(value.keys.sort).to eq(["fr", "it"])
     end
   end
 
   shared_examples_for("date setter") do |attribute|
     it "should correctly parse a datetime classes" do
-      reference.send("#{attribute}=", Date.civil(2012, 8, 8))
-      value = reference.send(attribute)
+      subject.send("#{attribute}=", Date.civil(2012, 8, 8))
+      value = subject.send(attribute)
       expect(value).to be_a(DateTime)
       expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T000000+0000")
 
-      reference.send("#{attribute}=", DateTime.civil(2012, 8, 8, 11, 30, 45))
-      value = reference.send(attribute)
+      subject.send("#{attribute}=", DateTime.civil(2012, 8, 8, 11, 30, 45))
+      value = subject.send(attribute)
       expect(value).to be_a(DateTime)
       expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T113045+0000")
 
       Time.zone = 'Europe/Rome'
       date = Time.at(1344421800)
-      reference.send("#{attribute}=", date)
-      value = reference.send(attribute)
+      subject.send("#{attribute}=", date)
+      value = subject.send(attribute)
       expect(value).to be_a(DateTime)
       expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T103000+0000")
     end
 
     it "should correctly parse a timestamp" do
-      reference.send("#{attribute}=", 1344421800)
-      value = reference.send(attribute)
+      subject.send("#{attribute}=", 1344421800)
+      value = subject.send(attribute)
       expect(value).to be_a(DateTime)
       expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T103000+0000")
     end
 
     it "should try to parse everything else as a ISO8601 format" do
-      reference.send("#{attribute}=", "20120808T083000-0200")
-      value = reference.send(attribute)
+      subject.send("#{attribute}=", "20120808T083000-0200")
+      value = subject.send(attribute)
       expect(value).to be_a(DateTime)
       expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T103000+0000")
 
-      expect { reference.send("#{attribute}=", "ABC") }.to raise_error(Mbrao::Exceptions::InvalidDate)
-      expect { reference.send("#{attribute}=", []) }.to raise_error(Mbrao::Exceptions::InvalidDate)
+      expect { subject.send("#{attribute}=", "ABC") }.to raise_error(Mbrao::Exceptions::InvalidDate)
+      expect { subject.send("#{attribute}=", []) }.to raise_error(Mbrao::Exceptions::InvalidDate)
     end
   end
 
@@ -132,31 +132,38 @@ describe Mbrao::Content do
 
   describe "#body=" do
     it "should set the content as string" do
-      reference.body = "A"
-      expect(reference.body).to eq("A")
-      reference.body = 1
-      expect(reference.body).to eq("1")
-      reference.body = nil
-      expect(reference.body).to eq("")
+      subject.body = "A"
+      expect(subject.body).to eq("A")
+      subject.body = 1
+      expect(subject.body).to eq("1")
+      subject.body = nil
+      expect(subject.body).to eq("")
     end
   end
 
   describe "#tags=" do
     it "should assign a single value" do
-      reference.tags = "ABC"
-      expect(reference.tags).to eq(["ABC"])
-      reference.tags = ["ABC", [1, nil]]
-      expect(reference.tags).to eq(["ABC", "1"])
+      subject.tags = "ABC"
+      expect(subject.tags).to eq(["ABC"])
+      subject.tags = ["ABC", [1, nil]]
+      expect(subject.tags).to eq(["ABC", "1"])
     end
 
     it "should assign values with locales and sanitized entries" do
-      reference.tags = {en: nil, es: "ABC", it: [1, [2, 3]]}
-      value = reference.tags
+      subject.tags = {en: nil, es: "ABC", it: [1, [2, 3]]}
+      value = subject.tags
       expect(value).to be_a(::HashWithIndifferentAccess)
       expect(value["en"]).to eq([])
       expect(value[:es]).to eq(["ABC"])
       expect(value["it"]).to eq(["1", "2", "3"])
     end
+
+    it "should split, flatten and uniquize tags" do
+      subject.tags = ["1", ["2", "3"], "3, 4,5"]
+      expect(subject.tags).to eq(["1","2","3","4","5"])
+      subject.tags = "1,2,3,4,5"
+      expect(subject.tags).to eq(["1","2","3","4","5"])
+    end
   end
 
   describe "#more=" do
@@ -166,26 +173,26 @@ describe Mbrao::Content do
   describe "#author=" do
     it "should assign an existing author" do
       author = ::Mbrao::Author.new("NAME")
-      reference.author = author
-      expect(reference.author).to be(author)
+      subject.author = author
+      expect(subject.author).to be(author)
     end
 
     it "should only assign a name" do
-      reference.author = "NAME"
-      expect(reference.author).to be_a(::Mbrao::Author)
-      expect(reference.author.name).to eq("NAME")
+      subject.author = "NAME"
+      expect(subject.author).to be_a(::Mbrao::Author)
+      expect(subject.author.name).to eq("NAME")
     end
 
     it "should assign by an hash" do
-      reference.author = {name: "NAME", email: "EMAIL@email.com", "website" => "http://WEBSITE.TLD", "image" => "http://IMAGE.TLD", metadata: {a: "b"}, uid: "UID"}
-      expect(reference.author).to be_a(::Mbrao::Author)
-      expect(reference.author.name).to eq("NAME")
-      expect(reference.author.email).to eq("EMAIL@email.com")
-      expect(reference.author.website).to eq("http://WEBSITE.TLD")
-      expect(reference.author.image).to eq("http://IMAGE.TLD")
-      expect(reference.author.metadata).to be_a(::HashWithIndifferentAccess)
-      expect(reference.author.metadata["a"]).to eq("b")
-      expect(reference.author.uid).to eq("UID")
+      subject.author = {name: "NAME", email: "EMAIL@email.com", "website" => "http://WEBSITE.TLD", "image" => "http://IMAGE.TLD", metadata: {a: "b"}, uid: "UID"}
+      expect(subject.author).to be_a(::Mbrao::Author)
+      expect(subject.author.name).to eq("NAME")
+      expect(subject.author.email).to eq("EMAIL@email.com")
+      expect(subject.author.website).to eq("http://WEBSITE.TLD")
+      expect(subject.author.image).to eq("http://IMAGE.TLD")
+      expect(subject.author.metadata).to be_a(::HashWithIndifferentAccess)
+      expect(subject.author.metadata["a"]).to eq("b")
+      expect(subject.author.uid).to eq("UID")
     end
   end
 
@@ -199,25 +206,25 @@ describe Mbrao::Content do
 
   describe "#metadata=" do
     it "correctly set a non hash value" do
-      reference.metadata = "RAW"
-      expect(reference.metadata).to be_a(::HashWithIndifferentAccess)
-      expect(reference.metadata["raw"]).to eq("RAW")
+      subject.metadata = "RAW"
+      expect(subject.metadata).to be_a(::HashWithIndifferentAccess)
+      expect(subject.metadata["raw"]).to eq("RAW")
     end
 
     it "correctly set a hash value" do
-      reference.metadata = {en: nil, es: "ABC", it: [1, [2, 3]]}
-      expect(reference.metadata).to be_a(::HashWithIndifferentAccess)
-      expect(reference.metadata["es"]).to eq("ABC")
+      subject.metadata = {en: nil, es: "ABC", it: [1, [2, 3]]}
+      expect(subject.metadata).to be_a(::HashWithIndifferentAccess)
+      expect(subject.metadata["es"]).to eq("ABC")
     end
   end
 
   describe "#enabled_for_locales?" do
     it "correctly check availability for certain locales" do
-      reference.locales = [:en, :it]
-      expect(reference.enabled_for_locales?).to be_true
-      expect(reference.enabled_for_locales?(:en)).to be_true
-      expect(reference.enabled_for_locales?(:it, :es)).to be_true
-      expect(reference.enabled_for_locales?(:es, :de)).to be_false
+      subject.locales = [:en, :it]
+      expect(subject.enabled_for_locales?).to be_true
+      expect(subject.enabled_for_locales?(:en)).to be_true
+      expect(subject.enabled_for_locales?(:it, :es)).to be_true
+      expect(subject.enabled_for_locales?(:es, :de)).to be_false
     end
   end
 
@@ -227,11 +234,11 @@ describe Mbrao::Content do
 
   describe "#get_body" do
     it "should create a parsing engine and use it for filtering" do
-      reference.body = "BODY"
+      subject.body = "BODY"
       engine = ::Mbrao::ParsingEngines::Base.new
-      expect(engine).to receive(:filter_content).with(reference, ["it", "en"])
+      expect(engine).to receive(:filter_content).with(subject, ["it", "en"])
       expect(::Mbrao::Parser).to receive(:create_engine).with("ENGINE").and_return(engine)
-      reference.get_body(["it", "en"], "ENGINE")
+      subject.get_body(["it", "en"], "ENGINE")
     end
   end
 
@@ -243,6 +250,58 @@ describe Mbrao::Content do
     it_should_behave_like "localized getter", :more, "ABC", "123"
   end
 
+  describe "#as_json" do
+    subject {
+      @created_at = DateTime.civil(1984, 7, 7, 11, 30, 0)
+      metadata = {"uid" => "UID", "title" => {it: "IT", en: "EN"}, "author" => "AUTHOR", "tags" => {it: "IT", en: "EN"}, "more" => "MORE", created_at: @created_at, locales: ["it", ["en"]], other: ["OTHER"]}
+      ::Mbrao::Content.create(metadata, "BODY")
+    }
+
+    it "should return the content as a JSON hash" do
+      expect(subject.as_json).to eq({
+        "author" => {"uid" => nil, "name" => "AUTHOR", "email" => nil, "website" => nil, "image" => nil, "metadata" => {}},
+        "body" => "BODY",
+        "created_at" => @created_at,
+        "locales" => ["it", "en"],
+        "metadata" => {"other" => ["OTHER"]},
+        "more" => "MORE",
+        "tags" => {"it" => ["IT"], "en"=>["EN"]},
+        "title" => {"it" => "IT", "en" => "EN"},
+        "uid" => "UID",
+        "updated_at" => @created_at
+      })
+    end
+
+    it "should filter out keys if asked to" do
+      expect(subject.as_json(exclude: [:author, :uid])).to eq({
+        "body" => "BODY",
+        "created_at" => @created_at,
+        "locales" => ["it", "en"],
+        "metadata" => {"other" => ["OTHER"]},
+        "more" => "MORE",
+        "tags" => {"it" => ["IT"], "en"=>["EN"]},
+        "title" => {"it" => "IT", "en" => "EN"},
+        "updated_at" => @created_at
+      })
+    end
+
+    it "should filter out empty values if asked to" do
+      subject.author = nil
+      subject.uid = nil
+
+      expect(subject.as_json(exclude_empty: true)).to eq({
+        "body" => "BODY",
+        "created_at" => @created_at,
+        "locales" => ["it", "en"],
+        "metadata" => {"other" => ["OTHER"]},
+        "more" => "MORE",
+        "tags" => {"it" => ["IT"], "en"=>["EN"]},
+        "title" => {"it" => "IT", "en" => "EN"},
+        "updated_at" => @created_at
+      })
+    end
+  end
+
   describe ".create" do
     it "should return a Content object" do
       expect(::Mbrao::Content.create(nil, "BODY")).to be_a(::Mbrao::Content)

data/spec/mbrao/integrations/rails_spec.rb

@@ -8,7 +8,14 @@ require "spec_helper"
 require "action_view"
 require "mbrao/integrations/rails"
 
+
 describe ActionView::Template::Handlers::MbraoTemplate do
+  class Rails
+    def self.version
+      "3"
+    end
+  end
+
   class DummyTemplate
     def initialize(content)
       @content = content
@@ -34,6 +41,13 @@ describe ActionView::Template::Handlers::MbraoTemplate do
     end
   end
 
+  describe ".register" do
+    it "should register template" do
+      expect(ActionView::Template).to receive(:register_template_handler).with("emt", an_instance_of(ActionView::Template::Handlers::MbraoTemplate))
+      ActionView::Template::Handlers::MbraoTemplate.register
+    end
+  end
+
   describe ".instance" do
     it "should create a new instance" do
       expect(ActionView::Template::Handlers::MbraoTemplate.instance).to be_a(ActionView::Template::Handlers::MbraoTemplate)

data/spec/mbrao/parser_spec.rb

@@ -59,14 +59,14 @@ describe Mbrao::Parser do
 
   describe ".create_engine" do
     it "should create an engine via Lazier.find_class" do
-      reference = ::Mbrao::ParsingEngines::ScopedParser.new
+      subject = ::Mbrao::ParsingEngines::ScopedParser.new
       cls = ::Mbrao::ParsingEngines::ScopedParser
-      expect(cls).to receive(:new).exactly(2).and_return(reference)
+      expect(cls).to receive(:new).exactly(2).and_return(subject)
 
       expect(::Lazier).to receive(:find_class).with(:scoped_parser, "::Mbrao::ParsingEngines::%CLASS%").and_return(cls)
-      expect(::Mbrao::Parser.create_engine(:scoped_parser)).to eq(reference)
+      expect(::Mbrao::Parser.create_engine(:scoped_parser)).to eq(subject)
       expect(::Lazier).to receive(:find_class).with(:scoped_parser, "::Mbrao::RenderingEngines::%CLASS%").and_return(cls)
-      expect(::Mbrao::Parser.create_engine(:scoped_parser, :rendering)).to eq(reference)
+      expect(::Mbrao::Parser.create_engine(:scoped_parser, :rendering)).to eq(subject)
     end
 
     it "should raise an exception if the engine class is not found" do
@@ -122,12 +122,12 @@ describe Mbrao::Parser do
 
   describe "#parse" do
     it "should sanitize options" do
-      reference = BlankParser.new
-      expect(::Mbrao::Parser).to receive(:create_engine).exactly(3).and_return(reference)
+      subject = BlankParser.new
+      expect(::Mbrao::Parser).to receive(:create_engine).exactly(3).and_return(subject)
 
-      expect(reference).to receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser})
-      expect(reference).to receive(:parse).with("CONTENT", {"metadata" => true, "content" => false, "engine" => :blank_parser})
-      expect(reference).to receive(:parse).with("CONTENT", {"metadata" => false, "content" => false, "engine" => :blank_parser})
+      expect(subject).to receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser})
+      expect(subject).to receive(:parse).with("CONTENT", {"metadata" => true, "content" => false, "engine" => :blank_parser})
+      expect(subject).to receive(:parse).with("CONTENT", {"metadata" => false, "content" => false, "engine" => :blank_parser})
 
       ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser})
       ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser, content: 2})
@@ -135,31 +135,31 @@ describe Mbrao::Parser do
     end
 
     it "should call .create_engine call its #parse method" do
-      reference = BlankParser.new
-      expect(::Mbrao::Parser).to receive(:create_engine).and_return(reference)
+      subject = BlankParser.new
+      expect(::Mbrao::Parser).to receive(:create_engine).and_return(subject)
 
-      expect(reference).to receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser, "other" => "OK"})
+      expect(subject).to receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser, "other" => "OK"})
       ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser, other: "OK"})
     end
   end
 
   describe "#render" do
     it "should sanitize options" do
-      reference = Object.new
-      expect(::Mbrao::Parser).to receive(:create_engine).exactly(2).and_return(reference)
+      subject = Object.new
+      expect(::Mbrao::Parser).to receive(:create_engine).exactly(2).and_return(subject)
 
-      expect(reference).to receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
-      expect(reference).to receive(:render).with("CONTENT", {"engine" => :html_pipeline}, {content: "OK"})
+      expect(subject).to receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
+      expect(subject).to receive(:render).with("CONTENT", {"engine" => :html_pipeline}, {content: "OK"})
 
       ::Mbrao::Parser.new.render("CONTENT", {engine: :blank_rendered}, {content: "OK"})
       ::Mbrao::Parser.new.render("CONTENT", {engine: :html_pipeline}, {content: "OK"})
     end
 
     it "should call .create_engine call its #parse method" do
-      reference = Object.new
-      expect(::Mbrao::Parser).to receive(:create_engine).with(:blank_rendered, :rendering).and_return(reference)
+      subject = Object.new
+      expect(::Mbrao::Parser).to receive(:create_engine).with(:blank_rendered, :rendering).and_return(subject)
 
-      expect(reference).to receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
+      expect(subject).to receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
       ::Mbrao::Parser.new.render("CONTENT", {engine: :blank_rendered}, {content: "OK"})
     end
   end

data/spec/mbrao/parsing_engines/base_spec.rb

@@ -7,11 +7,11 @@
 require "spec_helper"
 
 describe Mbrao::ParsingEngines::Base do
-  let(:reference) { Mbrao::ParsingEngines::Base.new }
+  subject{ Mbrao::ParsingEngines::Base.new }
 
   shared_examples_for("unimplemented") do |method|
     it "should raise an exception" do
-      expect { reference.send(method, "CONTENT", {}) }.to raise_error(Mbrao::Exceptions::Unimplemented)
+      expect { subject.send(method, "CONTENT", {}) }.to raise_error(Mbrao::Exceptions::Unimplemented)
     end
   end
 
@@ -28,25 +28,25 @@ describe Mbrao::ParsingEngines::Base do
   end
 
   describe "#parse" do
-    let(:reference) { ::Mbrao::ParsingEngines::Base.new }
+    subject{ ::Mbrao::ParsingEngines::Base.new }
 
     it "should forward to ::Mbrao::Content.create" do
-      expect(reference).to receive(:separate_components).with("CONTENT", {a: "b"}).and_return([{a: "b"}, "BODY"])
-      allow(reference).to receive(:parse_metadata).and_return({a: "b"})
+      expect(subject).to receive(:separate_components).with("CONTENT", {a: "b"}).and_return([{a: "b"}, "BODY"])
+      allow(subject).to receive(:parse_metadata).and_return({a: "b"})
       expect(::Mbrao::Content).to receive(:create).with({a: "b"}, "BODY")
-      reference.parse("CONTENT", {a: "b"})
+      subject.parse("CONTENT", {a: "b"})
     end
 
     it "should return a Content object" do
-      allow(reference).to receive(:separate_components).with("CONTENT", {a: "b"}).and_return([])
-      allow(reference).to receive(:parse_metadata).and_return({})
-      expect(reference.parse("CONTENT", {a: "b"})).to be_a(::Mbrao::Content)
+      allow(subject).to receive(:separate_components).with("CONTENT", {a: "b"}).and_return([])
+      allow(subject).to receive(:parse_metadata).and_return({})
+      expect(subject.parse("CONTENT", {a: "b"})).to be_a(::Mbrao::Content)
     end
 
     it "should separate_components" do
-      expect(reference).to receive(:separate_components).with("CONTENT", {a: "b"})
-      allow(reference).to receive(:parse_metadata).and_return({})
-      reference.parse("CONTENT", {a: "b"})
+      expect(subject).to receive(:separate_components).with("CONTENT", {a: "b"})
+      allow(subject).to receive(:parse_metadata).and_return({})
+      subject.parse("CONTENT", {a: "b"})
     end
   end
 end

data/spec/mbrao/parsing_engines/plain_text_spec.rb

@@ -7,7 +7,7 @@
 require "spec_helper"
 
 describe Mbrao::ParsingEngines::PlainText do
-  let(:reference) { Mbrao::ParsingEngines::PlainText.new }
+  subject{ Mbrao::ParsingEngines::PlainText.new }
 
   let(:sample_metadata) {
     <<EOM
@@ -76,30 +76,30 @@ EOS4
 
   describe "#separate_components" do
     it "should return correct metadata and contents" do
-      expect(reference.separate_components(sample_valid)).to eq([sample_metadata.strip, sample_content.strip])
+      expect(subject.separate_components(sample_valid)).to eq([sample_metadata.strip, sample_content.strip])
     end
 
     it "should return the whole content if metadata are either incorrectly tagged or not present" do
-      expect(reference.separate_components(sample_invalid)).to eq(["", sample_invalid.strip])
-      expect(reference.separate_components(sample_no_metadata)).to eq(["", sample_no_metadata.strip])
+      expect(subject.separate_components(sample_invalid)).to eq(["", sample_invalid.strip])
+      expect(subject.separate_components(sample_no_metadata)).to eq(["", sample_no_metadata.strip])
     end
 
     it "should use different tags" do
-      expect(reference.separate_components("[meta]{{metadata}}OK\n[/meta] REST", {meta_tags: ["[meta]", "[/meta]"]})).to eq(["{{metadata}}OK", "REST"])
+      expect(subject.separate_components("[meta]{{metadata}}OK\n[/meta] REST", {meta_tags: ["[meta]", "[/meta]"]})).to eq(["{{metadata}}OK", "REST"])
     end
   end
 
   describe "#parse_metadata" do
     it "should correctly parse YAML formatted metadata" do
-      expect(reference.parse_metadata("---\nyaml:\n  :a: 'b'")).to eq({"yaml" => {a: "b"}})
+      expect(subject.parse_metadata("---\nyaml:\n  :a: 'b'")).to eq({"yaml" => {a: "b"}})
     end
 
     it "should return a default value if parsing failed" do
-      expect(reference.parse_metadata("---\n\"yaml:", {default: "DEFAULT"})).to eq("DEFAULT")
+      expect(subject.parse_metadata("---\n\"yaml:", {default: "DEFAULT"})).to eq("DEFAULT")
     end
 
     it "should raise an exception if parsing failed and no default is available" do
-      expect { reference.parse_metadata("---\n\"yaml:") }.to raise_error(::Mbrao::Exceptions::InvalidMetadata)
+      expect { subject.parse_metadata("---\n\"yaml:") }.to raise_error(::Mbrao::Exceptions::InvalidMetadata)
     end
   end
 
@@ -109,33 +109,33 @@ EOS4
     end
 
     it "should return the original content if locales contains *" do
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "*"))).to eq(["START", "IT, EN", "MIDDLE", "!IT and !ES", "EN in !IT", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "*"))).to eq(["START", "IT, EN", "MIDDLE", "!IT and !ES", "EN in !IT", "!IT", "END"])
     end
 
     it "should use default locale if nothing is specified" do
       ::Mbrao::Parser.locale = :it
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content)))).to eq(["START", "IT, EN", "MIDDLE", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content)))).to eq(["START", "IT, EN", "MIDDLE", "END"])
     end
 
     it "should ignore unclosed tag, trying to close the leftmost start tag" do
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, "{{content: it}}\n{{content: en}}NO{{/content}}")))).to eq(["{{content: en}}NO"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, "{{content: it}}\n{{content: en}}NO{{/content}}")))).to eq(["{{content: en}}NO"])
     end
 
     it "should correctly filter by tag" do
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "en"))).to eq(["START", "IT, EN", "MIDDLE", "!IT and !ES", "EN in !IT", "!IT", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "it"))).to eq(["START", "IT, EN", "MIDDLE", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "es"))).to eq(["START", "MIDDLE", "!IT", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "fr"))).to eq(["START", "MIDDLE", "!IT and !ES", "!IT", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["it", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["es", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "EN in !IT", "!IT", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["fr", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "!IT and !ES", "EN in !IT", "!IT", "END"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["fr", "es", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "EN in !IT", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "en"))).to eq(["START", "IT, EN", "MIDDLE", "!IT and !ES", "EN in !IT", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "it"))).to eq(["START", "IT, EN", "MIDDLE", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "es"))).to eq(["START", "MIDDLE", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), "fr"))).to eq(["START", "MIDDLE", "!IT and !ES", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["it", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["es", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "EN in !IT", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["fr", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "!IT and !ES", "EN in !IT", "!IT", "END"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample_nested_content), ["fr", "es", "en"]))).to eq(["START", "IT, EN", "MIDDLE", "EN in !IT", "!IT", "END"])
     end
 
     it "should use different tags" do
       sample = "[content-it]{{content: !it}}IT[/content]\nOK"
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample), "it", {content_tags: ["[content-%ARGS%]", "[/content]"]}))).to eq(["{{content: !it}}IT", "OK"])
-      expect(parse_content(reference.filter_content(::Mbrao::Content.create(nil, sample), "en", {content_tags: ["[content-%ARGS%]", "[/content]"]}))).to eq(["OK"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample), "it", {content_tags: ["[content-%ARGS%]", "[/content]"]}))).to eq(["{{content: !it}}IT", "OK"])
+      expect(parse_content(subject.filter_content(::Mbrao::Content.create(nil, sample), "en", {content_tags: ["[content-%ARGS%]", "[/content]"]}))).to eq(["OK"])
     end
   end
 end

data/spec/mbrao/rendering_engines/base_spec.rb

@@ -7,11 +7,11 @@
 require "spec_helper"
 
 describe Mbrao::RenderingEngines::Base do
-  let(:reference) { Mbrao::RenderingEngines::Base.new }
+  subject{ Mbrao::RenderingEngines::Base.new }
 
   describe "#render" do
     it "should raise an exception" do
-      expect { reference.render("CONTENT", {}, {}) }.to raise_error(Mbrao::Exceptions::Unimplemented)
+      expect { subject.render("CONTENT", {}, {}) }.to raise_error(Mbrao::Exceptions::Unimplemented)
     end
   end
 end