mbrao 1.1.1 → 1.2.0

data/lib/mbrao/exceptions.rb

@@ -8,31 +8,31 @@ module Mbrao
   # The exceptions raised by mbrao.
   module Exceptions
     # Exception raised when metadata are not valid.
-    class InvalidMetadata < ::Exception
+    class InvalidMetadata < RuntimeError
     end
 
     # Exception raised when a date is valid.
-    class InvalidDate < ::Exception
+    class InvalidDate < RuntimeError
     end
 
     # Exception raised when there is a parsing error.
-    class Parsing < ::Exception
+    class Parsing < RuntimeError
     end
 
     # Exception raised when there is a rendering error.
-    class Rendering < ::Exception
+    class Rendering < RuntimeError
     end
 
     # Exception raised when a requested object is not available in any of the desired locales.
-    class UnavailableLocalization < ::Exception
+    class UnavailableLocalization < RuntimeError
     end
 
     # Exception raised when a invalid parsing or rendering engine is requested.
-    class UnknownEngine < ::Exception
+    class UnknownEngine < RuntimeError
     end
 
     # Exception raised when a requested method must be overridden by a subclass.
-    class Unimplemented < ::Exception
+    class Unimplemented < RuntimeError
     end
   end
 end

data/lib/mbrao/parser.rb

@@ -50,7 +50,7 @@ module Mbrao
       # @param options [Hash] A list of options for parsing.
       # @return [Content] The parsed data.
       def parse(content, options = {})
-        self.instance.parse(content, options)
+        instance.parse(content, options)
       end
 
       # Renders a content.
@@ -60,7 +60,7 @@ module Mbrao
       # @param context [Hash] A context for rendering.
       # @return [String] The rendered content.
       def render(content, options = {}, context = {})
-        self.instance.render(content, options, context)
+        instance.render(content, options, context)
       end
 
       # Instantiates a new engine for rendering or parsing.
@@ -77,8 +77,6 @@ module Mbrao
         end
       end
 
-
-
       # Returns a unique (singleton) instance of the parser.
       #
       # @param force [Boolean] If to force recreation of the instance.
@@ -135,65 +133,6 @@ module Mbrao
 
         text.ensure_string.strip =~ regex
       end
-
-      # Converts an object making sure that every `Hash` is converted to a `HashWithIndifferentAccess`.
-      #
-      # @param object [Object] The object to convert. If the object is not an Hash or doesn't respond to `collect` then the original object is returned.
-      # @param sanitize_method [Symbol|nil] If not `nil`, the method to use to sanitize entries. Ignored if a block is present.
-      # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
-      # @return [Object] The converted object.
-      def sanitized_hash(object, sanitize_method = nil, &block)
-        if object.is_a?(Hash) || object.is_a?(HashWithIndifferentAccess) then
-          object.inject(HashWithIndifferentAccess.new) do |hash, pair|
-            hash[pair[0]] = Mbrao::Parser.sanitized_hash(pair[1], sanitize_method, &block)
-            hash
-          end
-        elsif object.respond_to?(:collect) then
-          object.collect {|item| Mbrao::Parser.sanitized_hash(item, sanitize_method, &block) }
-        else
-          sanitized_hash_entry(object, sanitize_method, &block)
-        end
-      end
-
-      # Converts an object to a a flatten array with all values sanitized.
-      #
-      # @param object [Object] The object to convert.
-      # @param uniq [Boolean] If to remove duplicates from the array before sanitizing.
-      # @param compact [Boolean] If to compact the array before sanitizing.
-      # @param sanitize_method [Symbol|nil] If not `nil`, the method to use to sanitize entries. Ignored if a block is present.
-      # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
-      # @return [Array] An flattened array whose all values are strings.
-      def sanitized_array(object, uniq = true, compact = false, sanitize_method = :ensure_string, &block)
-        rv = object.ensure_array.flatten
-        rv.uniq! if uniq
-        rv.compact! if compact
-
-        if block then
-          rv = rv.collect(&block)
-        elsif sanitize_method then
-          rv = rv.collect(&sanitize_method)
-        end
-
-        rv.uniq! if uniq
-        rv.compact! if compact
-        rv
-      end
-
-      private
-        # Sanitizes an value for an hash.
-        #
-        # @param value [Object] The value to sanitize.
-        # @param sanitize_method [Symbol|nil] If not `nil`, the method to use to sanitize the value. Ignored if a block is present.
-        # @param block [Proc] A block to sanitize the value. It must accept the value as unique argument.
-        def sanitized_hash_entry(value, sanitize_method = :ensure_string, &block)
-          if block
-            block.call(value)
-          elsif sanitize_method
-            value.send(sanitize_method)
-          else
-            value
-          end
-        end
     end
   end
 
@@ -230,7 +169,7 @@ module Mbrao
       # @param options [Hash] The options to sanitize.
       # @return [HashWithIndifferentAccess] The sanitized options.
       def sanitize_parsing_options(options)
-        options = (options.is_a?(Hash) ? options : {}).symbolize_keys
+        options = options.ensure_hash(:symbols)
 
         options[:engine] ||= Mbrao::Parser.parsing_engine
         options[:metadata] = options.fetch(:metadata, true).to_boolean
@@ -244,7 +183,7 @@ module Mbrao
       # @param options [Hash] The options to sanitize.
       # @return [HashWithIndifferentAccess] The sanitized options.
       def sanitize_rendering_options(options)
-        options = (options.is_a?(Hash) ? options : {}).symbolize_keys
+        options = options.ensure_hash(:symbols)
 
         options[:engine] ||= Mbrao::Parser.rendering_engine
 

data/lib/mbrao/rendering_engines/html_pipeline.rb

@@ -50,7 +50,7 @@ module Mbrao
       # @param context [Hash] A context for rendering.
       def render(content, options = {}, context = {})
         options = sanitize_options(options)
-        context = context.is_a?(Hash) ? context.symbolize_keys : {}
+        context = context.ensure_hash(:symbols)
 
         begin
           create_pipeline(options, context).call(get_body(content, options))[:output].to_s
@@ -72,7 +72,7 @@ module Mbrao
       #
       # @return [Array] The default pipeline.
       def default_pipeline=(value)
-        @default_pipeline = value.ensure_array.collect {|v| v.ensure_array.flatten.compact.collect { |p| p.ensure_string.to_sym } }
+        @default_pipeline = value.ensure_array(nil, false, false) {|v| v.ensure_array(nil, true, true, true) { |p| p.ensure_string.to_sym } }
       end
 
       # Gets the default options.
@@ -86,7 +86,7 @@ module Mbrao
       #
       # @param value [Object] The new default options.
       def default_options=(value)
-        @default_options = value.is_a?(Hash) ? value : {}
+        @default_options = value.ensure_hash
       end
 
       private
@@ -95,9 +95,9 @@ module Mbrao
         # @param options [Hash] The options to sanitize.
         # @return [Hash] The sanitized options.
         def sanitize_options(options)
-          options = options.is_a?(Hash) ? options.symbolize_keys : {}
+          options = options.ensure_hash(:symbols)
           options = filter_filters(options)
-          options[:pipeline_options] = self.default_options.merge((options[:pipeline_options].is_a?(Hash) ? options[:pipeline_options] : {}).symbolize_keys)
+          options[:pipeline_options] = self.default_options.merge(options[:pipeline_options].ensure_hash(:symbols))
 
           options
         end

data/lib/mbrao/version.rb

@@ -14,10 +14,10 @@ module Mbrao
     MAJOR = 1
 
     # The minor version.
-    MINOR = 1
+    MINOR = 2
 
     # The patch version.
-    PATCH = 1
+    PATCH = 0
 
     # The current version of mbrao.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/lib/mbrao.rb

@@ -21,4 +21,4 @@ require "mbrao/rendering_engines/base"
 require "mbrao/rendering_engines/html_pipeline"
 require "mbrao/integrations/rails" if defined?(ActionView)
 
-Lazier.load!(:object)
+Lazier.load!(:object, :hash)

data/mbrao.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = ">= 1.9.3"
 
-  gem.add_dependency("lazier", "~> 2.8.1")
-  gem.add_dependency("html-pipeline", "~> 0.0.8")
-  gem.add_dependency("slim", "~> 1.3.6")
-  gem.add_dependency("kramdown", "~> 1.0.1")
+  gem.add_dependency("lazier", "~> 3.3.3")
+  gem.add_dependency("html-pipeline", "~> 0.1.0")
+  gem.add_dependency("slim", "~> 2.0.0")
+  gem.add_dependency("kramdown", "~> 1.1.0")
 end

data/spec/coverage_helper.rb

@@ -5,7 +5,10 @@
 #
 
 require "pathname"
-require "simplecov"  
+require "simplecov"
+require "coveralls"
+
+Coveralls.wear!
 
 SimpleCov.start do
   root = Pathname.new(File.dirname(__FILE__)) + ".."

data/spec/mbrao/author_spec.rb

@@ -9,21 +9,21 @@ require "spec_helper"
 describe Mbrao::Author do
   describe ".create" do
     it "creates a author from a non-hash" do
-      Mbrao::Author.should_receive(:new).with("NAME")
+      expect(Mbrao::Author).to receive(:new).with("NAME")
       Mbrao::Author.create("NAME")
 
-      Mbrao::Author.should_receive(:new).with(nil)
+      expect(Mbrao::Author).to receive(:new).with(nil)
       Mbrao::Author.create(nil)
 
-      Mbrao::Author.should_receive(:new).with([])
+      expect(Mbrao::Author).to receive(:new).with([])
       Mbrao::Author.create([])
 
-      Mbrao::Author.should_receive(:new).with(["NAME"])
+      expect(Mbrao::Author).to receive(:new).with(["NAME"])
       Mbrao::Author.create(["NAME"])
     end
 
     it "creates a author from a hash" do
-      Mbrao::Author.should_receive(:new).with("NAME", "EMAIL", "WEBSITE", "IMAGE", {"other" => "OTHER"}, "UID")
+      expect(Mbrao::Author).to receive(:new).with("NAME", "EMAIL", "WEBSITE", "IMAGE", {"other" => "OTHER"}, "UID")
       Mbrao::Author.create({name: "NAME", email: "EMAIL", website: "WEBSITE", image: "IMAGE", other: "OTHER", uid: "UID"})
     end
   end

data/spec/mbrao/content_spec.rb

@@ -51,7 +51,7 @@ describe Mbrao::Content do
     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(Mbrao::Exceptions::UnavailableLocalization)
+      expect { reference.send("get_#{attribute}", [:de, :it]) }.not_to raise_error
       expect { reference.send("get_#{attribute}", [:de]) }.to raise_error(Mbrao::Exceptions::UnavailableLocalization)
     end
 
@@ -229,8 +229,8 @@ describe Mbrao::Content do
     it "should create a parsing engine and use it for filtering" do
       reference.body = "BODY"
       engine = ::Mbrao::ParsingEngines::Base.new
-      engine.should_receive(:filter_content).with(reference, ["it", "en"])
-      ::Mbrao::Parser.should_receive(:create_engine).with("ENGINE").and_return(engine)
+      expect(engine).to receive(:filter_content).with(reference, ["it", "en"])
+      expect(::Mbrao::Parser).to receive(:create_engine).with("ENGINE").and_return(engine)
       reference.get_body(["it", "en"], "ENGINE")
     end
   end

data/spec/mbrao/integrations/rails_spec.rb

@@ -22,7 +22,7 @@ describe ActionView::Template::Handlers::MbraoTemplate do
       {locale: "LOCALE"}
     end
 
-    def self.helper_method(method)
+    def self.helper_method(_)
     end
   end
 
@@ -39,7 +39,7 @@ describe ActionView::Template::Handlers::MbraoTemplate do
 
     it "should always return the same instance" do
       other = ActionView::Template::Handlers::MbraoTemplate.instance
-      ActionView::Template::Handlers::MbraoTemplate.should_not_receive(:new)
+      expect(ActionView::Template::Handlers::MbraoTemplate).not_to receive(:new)
       expect(ActionView::Template::Handlers::MbraoTemplate.instance).to eq(other)
     end
 
@@ -60,11 +60,11 @@ describe ActionView::Template::Handlers::MbraoTemplate do
     it "should initialize a Content and assign it to the controller" do
       controller = DummyController.new
       renderer = DummyRenderer.new
-      renderer.stub(:controller).and_return(controller)
+      allow(renderer).to receive(:controller).and_return(controller)
 
       expect(controller.respond_to?(:mbrao_content)).to be_false
-      ::Mbrao::Parser.should_receive(:parse).and_call_original
-      controller.class.should_receive(:helper_method).with(:mbrao_content)
+      expect(::Mbrao::Parser).to receive(:parse).and_call_original
+      expect(controller.class).to receive(:helper_method).with(:mbrao_content)
       ActionView::Template::Handlers::MbraoTemplate.instance.render(renderer, "CONTENT")
 
       expect(controller.respond_to?(:mbrao_content)).to be_true
@@ -74,12 +74,12 @@ describe ActionView::Template::Handlers::MbraoTemplate do
     it "should render contents, using specified engine and locale" do
       controller = DummyController.new
       renderer = DummyRenderer.new
-      renderer.stub(:controller).and_return(controller)
+      allow(renderer).to receive(:controller).and_return(controller)
 
       content = ::Mbrao::Content.create({engine: "ENGINE"}, "CONTENT")
-      ::Mbrao::Parser.stub(:parse).and_return(content)
+      allow(::Mbrao::Parser).to receive(:parse).and_return(content)
 
-      ::Mbrao::Parser.should_receive(:render).with(content, {engine: "ENGINE", locale: "LOCALE"})
+      expect(::Mbrao::Parser).to receive(:render).with(content, {engine: "ENGINE", locale: "LOCALE"})
       ActionView::Template::Handlers::MbraoTemplate.instance.render(DummyRenderer.new, "CONTENT")
     end
   end

data/spec/mbrao/parser_spec.rb

@@ -45,14 +45,14 @@ describe Mbrao::Parser do
 
   describe ".parse" do
     it "should forward to the instance" do
-      ::Mbrao::Parser.instance.should_receive(:parse).with("TEXT", {options: {}})
+      expect(::Mbrao::Parser.instance).to receive(:parse).with("TEXT", {options: {}})
       ::Mbrao::Parser.parse("TEXT", {options: {}})
     end
   end
 
   describe ".render" do
     it "should forward to the instance" do
-      ::Mbrao::Parser.instance.should_receive(:render).with("TEXT", {options: {}}, {content: {}})
+      expect(::Mbrao::Parser.instance).to receive(:render).with("TEXT", {options: {}}, {content: {}})
       ::Mbrao::Parser.render("TEXT", {options: {}}, {content: {}})
     end
   end
@@ -61,11 +61,11 @@ describe Mbrao::Parser do
     it "should create an engine via Lazier.find_class" do
       reference = ::Mbrao::ParsingEngines::ScopedParser.new
       cls = ::Mbrao::ParsingEngines::ScopedParser
-      cls.should_receive(:new).exactly(2).and_return(reference)
+      expect(cls).to receive(:new).exactly(2).and_return(reference)
 
-      ::Lazier.should_receive(:find_class).with(:scoped_parser, "::Mbrao::ParsingEngines::%CLASS%").and_return(cls)
+      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)
-      ::Lazier.should_receive(:find_class).with(:scoped_parser, "::Mbrao::RenderingEngines::%CLASS%").and_return(cls)
+      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)
     end
 
@@ -77,19 +77,19 @@ describe Mbrao::Parser do
   describe ".instance" do
     it("should call .new") do
       ::Mbrao::Parser.instance_variable_set(:@instance, nil)
-      ::Mbrao::Parser.should_receive(:new)
+      expect(::Mbrao::Parser).to receive(:new)
       ::Mbrao::Parser.instance
     end
 
     it("should return the same instance") do
-      ::Mbrao::Parser.stub(:new) do Time.now end
+      allow(::Mbrao::Parser).to receive(:new) do Time.now end
       instance = ::Mbrao::Parser.instance
       expect(::Mbrao::Parser.instance).to be(instance)
       ::Mbrao::Parser.instance_variable_set(:@instance, nil)
     end
 
     it("should return a new instance if requested to") do
-      ::Mbrao::Parser.stub(:new) do Time.now end
+      allow(::Mbrao::Parser).to receive(:new) do Time.now end
       instance = ::Mbrao::Parser.instance
       expect(::Mbrao::Parser.instance(true)).not_to be(instance)
       ::Mbrao::Parser.instance_variable_set(:@instance, nil)
@@ -120,91 +120,14 @@ describe Mbrao::Parser do
     end
   end
 
-  describe ".sanitized_hash" do
-    it "should inject a new hash from existing one" do
-      reference = {a: "b"}
-      reference.should_receive(:inject).with(an_instance_of(HashWithIndifferentAccess)).and_call_original
-      sanitized = Mbrao::Parser.sanitized_hash(reference)
-      expect(sanitized).to be_a(HashWithIndifferentAccess)
-      expect(sanitized["a"]).to eq("b")
-
-    end
-
-    it "should collect sanitized elements" do
-      reference = [{a: "b"}]
-      reference.should_receive(:collect).and_call_original
-      sanitized = Mbrao::Parser.sanitized_hash(reference)
-      expect(sanitized).to be_a(Array)
-      expect(sanitized[0]).to eq({"a" => "b"})
-
-    end
-
-    it "should iterate over nested elements recursively" do
-      reference = [{a: "b"}]
-      Mbrao::Parser.should_receive(:sanitized_hash).with(anything, :ensure_array).exactly(4).and_call_original
-      sanitized = Mbrao::Parser.sanitized_hash({c: reference}, :ensure_array)
-      expect(sanitized).to be_a(HashWithIndifferentAccess)
-      expect(sanitized["c"]).to eq([{"a" => ["b"]}])
-    end
-
-    it "should convert a non-enumerable object using a method" do
-      reference = {a: "b"}
-      expect(Mbrao::Parser.sanitized_hash(reference, :ensure_array).fetch("a")).to eq(["b"])
-    end
-
-    it "should convert a non-enumerable object using a block" do
-      reference = {a: ["b", "c"]}
-      expect((Mbrao::Parser.sanitized_hash(reference) {|v| v.upcase }.fetch("a"))).to eq(["B", "C"])
-    end
-
-    it "should not modify a non-enumerable object if requested to" do
-      reference = {a: nil}
-      expect((Mbrao::Parser.sanitized_hash(reference, false).fetch("a"))).to be_nil
-    end
-  end
-
-  describe ".sanitized_array" do
-    it "should return a sanitized array" do
-      expect(Mbrao::Parser.sanitized_array([:en, ["A", 1]])).to eq(["en", "A", "1"])
-      expect(Mbrao::Parser.sanitized_array(:en)).to eq(["en"])
-      expect(Mbrao::Parser.sanitized_array(:en)).to eq(["en"])
-      expect(Mbrao::Parser.sanitized_array([:en, nil])).to eq(["en", ""])
-    end
-
-    it "should not uniq if requested to" do
-      ref = [{a: "b"}]
-      ref.should_not_receive(:uniq)
-      expect(Mbrao::Parser.sanitized_array(ref, false)).to eq(["{:a=>\"b\"}"])
-    end
-
-    it "should compact if requested to" do
-      ref = [{a: "b"}, nil]
-      ref.should_not_receive(:compact)
-      expect(Mbrao::Parser.sanitized_array(ref, false, true)).to eq(["{:a=>\"b\"}"])
-    end
-
-    it "should use the requested method for sanitizing" do
-      ref = [{a: "b"}]
-      ref.should_not_receive(:ensure_string)
-      Hash.any_instance.should_receive(:to_json).and_call_original
-      expect(Mbrao::Parser.sanitized_array(ref, true, false, :to_json)).to eq(["{\"a\":\"b\"}"])
-    end
-
-    it "should use the block for sanitizing" do
-      ref = [{a: "b"}]
-      ref.should_not_receive(:ensure_string)
-      expect(Mbrao::Parser.sanitized_array(ref) {|e| e.keys.first }).to eq([:a])
-    end
-  end
-
   describe "#parse" do
     it "should sanitize options" do
       reference = BlankParser.new
-      ::Mbrao::Parser.should_receive(:create_engine).exactly(3).and_return(reference)
+      expect(::Mbrao::Parser).to receive(:create_engine).exactly(3).and_return(reference)
 
-      reference.should_receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser})
-      reference.should_receive(:parse).with("CONTENT", {"metadata" => true, "content" => false, "engine" => :blank_parser})
-      reference.should_receive(:parse).with("CONTENT", {"metadata" => false, "content" => false, "engine" => :blank_parser})
+      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})
 
       ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser})
       ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser, content: 2})
@@ -213,9 +136,9 @@ describe Mbrao::Parser do
 
     it "should call .create_engine call its #parse method" do
       reference = BlankParser.new
-      ::Mbrao::Parser.should_receive(:create_engine).and_return(reference)
+      expect(::Mbrao::Parser).to receive(:create_engine).and_return(reference)
 
-      reference.should_receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser, "other" => "OK"})
+      expect(reference).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
@@ -223,10 +146,10 @@ describe Mbrao::Parser do
   describe "#render" do
     it "should sanitize options" do
       reference = Object.new
-      ::Mbrao::Parser.should_receive(:create_engine).exactly(2).and_return(reference)
+      expect(::Mbrao::Parser).to receive(:create_engine).exactly(2).and_return(reference)
 
-      reference.should_receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
-      reference.should_receive(:render).with("CONTENT", {"engine" => :html_pipeline}, {content: "OK"})
+      expect(reference).to receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
+      expect(reference).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"})
@@ -234,9 +157,9 @@ describe Mbrao::Parser do
 
     it "should call .create_engine call its #parse method" do
       reference = Object.new
-      ::Mbrao::Parser.should_receive(:create_engine).with(:blank_rendered, :rendering).and_return(reference)
+      expect(::Mbrao::Parser).to receive(:create_engine).with(:blank_rendered, :rendering).and_return(reference)
 
-      reference.should_receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
+      expect(reference).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

@@ -31,21 +31,21 @@ describe Mbrao::ParsingEngines::Base do
     let(:reference) { ::Mbrao::ParsingEngines::Base.new }
 
     it "should forward to ::Mbrao::Content.create" do
-      reference.should_receive(:separate_components).with("CONTENT", {a: "b"}).and_return([{a: "b"}, "BODY"])
-      reference.stub(:parse_metadata).and_return({a: "b"})
-      ::Mbrao::Content.should_receive(:create).with({a: "b"}, "BODY")
+      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(::Mbrao::Content).to receive(:create).with({a: "b"}, "BODY")
       reference.parse("CONTENT", {a: "b"})
     end
 
     it "should return a Content object" do
-      reference.stub(:separate_components).with("CONTENT", {a: "b"}).and_return([])
-      reference.stub(:parse_metadata).and_return({})
+      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)
     end
 
     it "should separate_components" do
-      reference.should_receive(:separate_components).with("CONTENT", {a: "b"})
-      reference.stub(:parse_metadata).and_return({})
+      expect(reference).to receive(:separate_components).with("CONTENT", {a: "b"})
+      allow(reference).to receive(:parse_metadata).and_return({})
       reference.parse("CONTENT", {a: "b"})
     end
   end

data/spec/mbrao/rendering_engines/html_pipeline_spec.rb

@@ -12,51 +12,50 @@ describe Mbrao::RenderingEngines::HtmlPipeline do
   describe "#render" do
     it "should forward everything to the html-pipeline" do
       pipeline = Object.new
-      pipeline.should_receive(:call).with("CONTENT").and_return({output: ""})
-      ::HTML::Pipeline.should_receive(:new).with(an_instance_of(Array), an_instance_of(Hash)).and_return(pipeline)
+      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")
     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)
     end
 
       it "should raise an exception if anything goes wrong" do
-      ::HTML::Pipeline.stub(:new).and_raise(ArgumentError.new("ERROR"))
+      allow(::HTML::Pipeline).to receive(:new).and_raise(ArgumentError.new("ERROR"))
       expect { reference.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].collect {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
-      ::HTML::Pipeline.should_receive(:new).with(filters, {gfm: true, asset_root: "/"}).and_call_original
+      expect(::HTML::Pipeline).to receive(:new).with(filters, {gfm: true, asset_root: "/"}).and_call_original
       reference.render("CONTENT")
     end
 
     it "should merge context to options" do
-      ::HTML::Pipeline.should_receive(:new).with(an_instance_of(Array), {gfm: true, asset_root: "/", additional: true}).and_call_original
+      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})
     end
 
     it "should restrict filter used" do
       filters = [:table_of_contents, :autolink, :emoji, :image_max_width].collect {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
-      ::HTML::Pipeline.should_receive(:new).with(filters, an_instance_of(Hash)).and_call_original
+      expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
       reference.render("CONTENT", {kramdown: false})
 
       filters = [:kramdown, :autolink, :emoji, :image_max_width].collect {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
-      ::HTML::Pipeline.should_receive(:new).with(filters, an_instance_of(Hash)).and_call_original
+      expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
       reference.render("CONTENT", {toc: false})
 
       filters = [:kramdown, :table_of_contents, :emoji, :image_max_width].collect {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
-      ::HTML::Pipeline.should_receive(:new).with(filters, an_instance_of(Hash)).and_call_original
+      expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
       reference.render("CONTENT", {links: false})
 
       filters = [:kramdown, :table_of_contents, :autolink, :image_max_width].collect {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
-      ::HTML::Pipeline.should_receive(:new).with(filters, an_instance_of(Hash)).and_call_original
+      expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
       reference.render("CONTENT", {emoji: false})
 
       filters = [:kramdown, :table_of_contents, :autolink, :emoji].collect {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }
-      ::HTML::Pipeline.should_receive(:new).with(filters, an_instance_of(Hash)).and_call_original
+      expect(::HTML::Pipeline).to receive(:new).with(filters, an_instance_of(Hash)).and_call_original
       reference.render("CONTENT", {image_max_width: false})
     end
   end
@@ -109,7 +108,7 @@ end
 describe HTML::Pipeline::KramdownFilter do
   describe "#initialize" do
     it "should call the parent constructor" do
-      HTML::Pipeline::TextFilter.should_receive(:new).with("\rCONTENT\r", {a: "b"}, {c: "d"})
+      expect(HTML::Pipeline::TextFilter).to receive(:new).with("\rCONTENT\r", {a: "b"}, {c: "d"})
       HTML::Pipeline::KramdownFilter.new("\rCONTENT\r", {a: "b"}, {c: "d"})
     end
 
@@ -120,8 +119,8 @@ describe HTML::Pipeline::KramdownFilter do
 
     it "should use Kramdown with given options for building the result" do
       object = Object.new
-      Kramdown::Document.should_receive(:new).with("CONTENT", {a: "b"}).and_return(object)
-      object.should_receive(:to_html)
+      expect(Kramdown::Document).to receive(:new).with("CONTENT", {a: "b"}).and_return(object)
+      expect(object).to receive(:to_html)
       HTML::Pipeline::KramdownFilter.new("\rCONTENT\r", {a: "b"}, {c: "d"}).call
     end
   end