yard 0.9.18 → 0.9.23

data/spec/templates/helpers/html_syntax_highlight_helper_spec.rb

@@ -1,65 +1,65 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
-  include YARD::Templates::Helpers::HtmlHelper
-  include YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
-
-  describe "#html_syntax_highlight" do
-    let(:object) { CodeObjects::NamespaceObject.new(:root, :YARD) }
-
-    before do
-      Registry.root.source_type = :ruby
-    end
-
-    it "does not highlight source if options.highlight is false" do
-      expect(self).to receive(:options).and_return(Options.new.update(:highlight => false))
-      expect(html_syntax_highlight("def x\nend")).to eq "def x\nend"
-    end
-
-    it "highlights source (legacy)" do
-      type = Parser::SourceParser.parser_type
-      Parser::SourceParser.parser_type = :ruby18
-      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      expect = "<span class='rubyid_def def kw'>def</span><span class='rubyid_x identifier id'>x</span>
-        <span class='string val'>'x'</span><span class='plus op'>+</span>
-        <span class='regexp val'>/x/i</span><span class='rubyid_end end kw'>end</span>"
-      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
-      html_equals_string(result, expect)
-      Parser::SourceParser.parser_type = type
-    end
-
-    it "highlights source (ripper)" do
-      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      Parser::SourceParser.parser_type = :ruby
-      expect = "<span class='kw'>def</span> <span class='id identifier rubyid_x'>x</span>
-        <span class='tstring'><span class='tstring_beg'>'</span>
-        <span class='tstring_content'>x</span><span class='tstring_end'>'</span>
-        </span> <span class='op'>+</span> <span class='tstring'>
-        <span class='regexp_beg'>/</span><span class='tstring_content'>x</span>
-        <span class='regexp_end'>/i</span></span>\n<span class='kw'>end</span>"
-      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
-      html_equals_string(result, expect)
-    end if HAVE_RIPPER
-
-    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
-      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      expect(html_syntax_highlight("def &x; ... end")).to eq "def &amp;x; ... end"
-    end if HAVE_RIPPER
-
-    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
-      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      expect(html_syntax_highlight("$ git clone http://url")).to eq "$ git clone http://url"
-    end if HAVE_RIPPER
-
-    it "links constants/methods" do
-      other = CodeObjects::NamespaceObject.new(:root, :Other)
-      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
-      allow(self).to receive(:run_verifier).with([other]).and_return([other])
-      allow(self).to receive(:link_object).with(other, "Other").and_return("LINK!")
-      result = html_syntax_highlight("def x; Other end")
-      html_equals_string(result, "<span class='kw'>def</span>
-        <span class='id identifier rubyid_x'>x</span><span class='semicolon'>;</span>
-        <span class='const'>LINK!</span> <span class='kw'>end</span>")
-    end if HAVE_RIPPER
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Templates::Helpers::HtmlSyntaxHighlightHelper do
+  include YARD::Templates::Helpers::HtmlHelper
+  include YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
+
+  describe "#html_syntax_highlight" do
+    let(:object) { CodeObjects::NamespaceObject.new(:root, :YARD) }
+
+    before do
+      Registry.root.source_type = :ruby
+    end
+
+    it "does not highlight source if options.highlight is false" do
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => false))
+      expect(html_syntax_highlight("def x\nend")).to eq "def x\nend"
+    end
+
+    it "highlights source (legacy)" do
+      type = Parser::SourceParser.parser_type
+      Parser::SourceParser.parser_type = :ruby18
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      expect = "<span class='rubyid_def def kw'>def</span><span class='rubyid_x identifier id'>x</span>
+        <span class='string val'>'x'</span><span class='plus op'>+</span>
+        <span class='regexp val'>/x/i</span><span class='rubyid_end end kw'>end</span>"
+      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
+      html_equals_string(result, expect)
+      Parser::SourceParser.parser_type = type
+    end
+
+    it "highlights source (ripper)" do
+      expect(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      Parser::SourceParser.parser_type = :ruby
+      expect = "<span class='kw'>def</span> <span class='id identifier rubyid_x'>x</span>
+        <span class='tstring'><span class='tstring_beg'>'</span>
+        <span class='tstring_content'>x</span><span class='tstring_end'>'</span>
+        </span> <span class='op'>+</span> <span class='tstring'>
+        <span class='regexp_beg'>/</span><span class='tstring_content'>x</span>
+        <span class='regexp_end'>/i</span></span>\n<span class='kw'>end</span>"
+      result = html_syntax_highlight("def x\n  'x' + /x/i\nend")
+      html_equals_string(result, expect)
+    end if HAVE_RIPPER
+
+    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
+      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      expect(html_syntax_highlight("def &x; ... end")).to eq "def &amp;x; ... end"
+    end if HAVE_RIPPER
+
+    it "returns escaped unhighlighted source if a syntax error is found (ripper)" do
+      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      expect(html_syntax_highlight("$ git clone http://url")).to eq "$ git clone http://url"
+    end if HAVE_RIPPER
+
+    it "links constants/methods" do
+      other = CodeObjects::NamespaceObject.new(:root, :Other)
+      allow(self).to receive(:options).and_return(Options.new.update(:highlight => true))
+      allow(self).to receive(:run_verifier).with([other]).and_return([other])
+      allow(self).to receive(:link_object).with(other, "Other").and_return("LINK!")
+      result = html_syntax_highlight("def x; Other end")
+      html_equals_string(result, "<span class='kw'>def</span>
+        <span class='id identifier rubyid_x'>x</span><span class='semicolon'>;</span>
+        <span class='const'>LINK!</span> <span class='kw'>end</span>")
+    end if HAVE_RIPPER
+  end
+end

data/spec/templates/helpers/markup/rdoc_markup_spec.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Templates::Helpers::Markup::RDocMarkup do
-  describe "loading mechanism" do
-    before { @good_libs = [] }
-
-    def require(lib)
-      return true if @good_libs.include?(lib)
-      raise LoadError
-    end
-
-    def load_markup
-      require 'rdoc/markup'
-      require 'rdoc/markup/to_html'
-      return :RDoc2
-    rescue LoadError
-      begin
-        require 'rdoc/markup/simple_markup'
-        require 'rdoc/markup/simple_markup/to_html'
-        return :RDoc1
-      rescue LoadError
-        raise NameError, "could not load RDocMarkup (rdoc is not installed)"
-      end
-    end
-
-    it "loads RDoc2.x if rdoc/markup is present" do
-      @good_libs += ['rdoc/markup', 'rdoc/markup/to_html']
-      expect(load_markup).to eq :RDoc2
-    end
-
-    it "fails on RDoc2.x if rdoc/markup/to_html is not present" do
-      @good_libs += ['rdoc/markup']
-      expect { load_markup }.to raise_error(NameError)
-    end
-
-    it "loads RDoc1.x if RDoc2 fails and rdoc/markup/simple_markup is present" do
-      @good_libs += ['rdoc/markup/simple_markup', 'rdoc/markup/simple_markup/to_html']
-      expect(load_markup).to eq :RDoc1
-    end
-
-    it "raises an error on loading if neither lib is present" do
-      expect { load_markup }.to raise_error(NameError)
-    end
-  end
-
-  describe "#to_html" do
-    def to_html(text)
-      html = YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
-      html.strip.gsub(/\r?\n/, '')
-    end
-
-    it "handles typewriter text" do
-      expect(to_html('Hello +<code>+')).to eq '<p>Hello <tt>&lt;code&gt;</tt></p>'
-    end
-  end
-
-  describe "#fix_typewriter" do
-    def fix_typewriter(text)
-      YARD::Templates::Helpers::Markup::RDocMarkup.new('').send(:fix_typewriter, text)
-    end
-
-    it "converts +text+ to <tt>text</tt>" do
-      expect(fix_typewriter("Some +typewriter text &lt;+.")).to eq "Some <tt>typewriter text &lt;</tt>."
-      expect(fix_typewriter("Not +typewriter text.")).to eq "Not +typewriter text."
-      expect(fix_typewriter("Alternating +type writer+ text +here+.")).to eq "Alternating <tt>type writer</tt> text <tt>here</tt>."
-      expect(fix_typewriter("No ++problem.")).to eq "No ++problem."
-      expect(fix_typewriter("Math + stuff +is ok+")).to eq "Math + stuff <tt>is ok</tt>"
-      expect(fix_typewriter("Hello +{Foo}+ World")).to eq "Hello <tt>{Foo}</tt> World"
-    end
-
-    it "does not apply to code blocks" do
-      expect(fix_typewriter("<code>Hello +hello+</code>")).to eq "<code>Hello +hello+</code>"
-    end
-
-    it "does not apply to HTML tag attributes" do
-      expect(fix_typewriter("<a href='http://foo.com/A+b+c'>A+b+c</a>")).to eq "<a href='http://foo.com/A+b+c'>A+b+c</a>"
-      expect(fix_typewriter("<foo class='foo+bar+baz'/>")).to eq "<foo class='foo+bar+baz'/>"
-    end
-
-    it "still applies inside of other tags" do
-      expect(fix_typewriter("<p>+foo+</p>")).to eq "<p><tt>foo</tt></p>"
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Templates::Helpers::Markup::RDocMarkup do
+  describe "loading mechanism" do
+    before { @good_libs = [] }
+
+    def require(lib)
+      return true if @good_libs.include?(lib)
+      raise LoadError
+    end
+
+    def load_markup
+      require 'rdoc/markup'
+      require 'rdoc/markup/to_html'
+      return :RDoc2
+    rescue LoadError
+      begin
+        require 'rdoc/markup/simple_markup'
+        require 'rdoc/markup/simple_markup/to_html'
+        return :RDoc1
+      rescue LoadError
+        raise NameError, "could not load RDocMarkup (rdoc is not installed)"
+      end
+    end
+
+    it "loads RDoc2.x if rdoc/markup is present" do
+      @good_libs += ['rdoc/markup', 'rdoc/markup/to_html']
+      expect(load_markup).to eq :RDoc2
+    end
+
+    it "fails on RDoc2.x if rdoc/markup/to_html is not present" do
+      @good_libs += ['rdoc/markup']
+      expect { load_markup }.to raise_error(NameError)
+    end
+
+    it "loads RDoc1.x if RDoc2 fails and rdoc/markup/simple_markup is present" do
+      @good_libs += ['rdoc/markup/simple_markup', 'rdoc/markup/simple_markup/to_html']
+      expect(load_markup).to eq :RDoc1
+    end
+
+    it "raises an error on loading if neither lib is present" do
+      expect { load_markup }.to raise_error(NameError)
+    end
+  end
+
+  describe "#to_html" do
+    def to_html(text)
+      html = YARD::Templates::Helpers::Markup::RDocMarkup.new(text).to_html
+      html.strip.gsub(/\r?\n/, '')
+    end
+
+    it "handles typewriter text" do
+      expect(to_html('Hello +<code>+')).to eq '<p>Hello <tt>&lt;code&gt;</tt></p>'
+    end
+  end
+
+  describe "#fix_typewriter" do
+    def fix_typewriter(text)
+      YARD::Templates::Helpers::Markup::RDocMarkup.new('').send(:fix_typewriter, text)
+    end
+
+    it "converts +text+ to <tt>text</tt>" do
+      expect(fix_typewriter("Some +typewriter text &lt;+.")).to eq "Some <tt>typewriter text &lt;</tt>."
+      expect(fix_typewriter("Not +typewriter text.")).to eq "Not +typewriter text."
+      expect(fix_typewriter("Alternating +type writer+ text +here+.")).to eq "Alternating <tt>type writer</tt> text <tt>here</tt>."
+      expect(fix_typewriter("No ++problem.")).to eq "No ++problem."
+      expect(fix_typewriter("Math + stuff +is ok+")).to eq "Math + stuff <tt>is ok</tt>"
+      expect(fix_typewriter("Hello +{Foo}+ World")).to eq "Hello <tt>{Foo}</tt> World"
+    end
+
+    it "does not apply to code blocks" do
+      expect(fix_typewriter("<code>Hello +hello+</code>")).to eq "<code>Hello +hello+</code>"
+    end
+
+    it "does not apply to HTML tag attributes" do
+      expect(fix_typewriter("<a href='http://foo.com/A+b+c'>A+b+c</a>")).to eq "<a href='http://foo.com/A+b+c'>A+b+c</a>"
+      expect(fix_typewriter("<foo class='foo+bar+baz'/>")).to eq "<foo class='foo+bar+baz'/>"
+    end
+
+    it "still applies inside of other tags" do
+      expect(fix_typewriter("<p>+foo+</p>")).to eq "<p><tt>foo</tt></p>"
+    end
+  end
+end

data/spec/templates/helpers/markup_helper_spec.rb

@@ -1,136 +1,136 @@
-# frozen_string_literal: true
-
-module YARD::Templates::Helpers::MarkupHelper
-  public :load_markup_provider, :markup_class, :markup_provider
-end
-
-class GeneratorMock
-  attr_accessor :options
-  include YARD::Templates::Helpers::MarkupHelper
-  def initialize(options = Templates::TemplateOptions.new)
-    self.options = options
-  end
-end
-
-RSpec.describe YARD::Templates::Helpers::MarkupHelper do
-  before do
-    YARD::Templates::Helpers::MarkupHelper.clear_markup_cache
-  end
-
-  describe "#load_markup_provider" do
-    before do
-      allow(log).to receive(:error)
-      @gen = GeneratorMock.new
-      @gen.options.reset_defaults
-    end
-
-    it "exits on an invalid markup type" do
-      @gen.options.markup = :invalid
-      expect(@gen.load_markup_provider).to be false
-    end
-
-    it "fails when an invalid markup provider is specified" do
-      @gen.options.update(:markup => :markdown, :markup_provider => :invalid)
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_class).to eq nil
-    end
-
-    it "loads RDocMarkup if rdoc is specified and it is installed" do
-      @gen.options.markup = :rdoc
-      expect(@gen.load_markup_provider).to be true
-      expect(@gen.markup_class).to eq YARD::Templates::Helpers::Markup::RDocMarkup
-    end
-
-    it "fails if RDoc cannot be loaded" do
-      @gen.options.markup = :rdoc
-      expect(@gen).to receive(:eval).with('::YARD::Templates::Helpers::Markup::RDocMarkup').and_raise(NameError)
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-
-    it "searches through available markup providers for the markup type if none is set" do
-      expect(@gen).to receive(:eval).with('::RedcarpetCompat').and_return(double(:bluecloth))
-      expect(@gen).to receive(:require).with('redcarpet').and_return(true)
-      expect(@gen).not_to receive(:require).with('maruku')
-      @gen.options.markup = :markdown
-      # this only raises an exception because we mock out require to avoid
-      # loading any libraries but our implementation tries to return the library
-      # name as a constant
-      expect(@gen.load_markup_provider).to be true
-      expect(@gen.markup_provider).to eq :redcarpet
-    end
-
-    it "continues searching if some of the providers are unavailable" do
-      expect(@gen).to receive(:require).with('redcarpet').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('kramdown').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('bluecloth').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('maruku').and_raise(LoadError)
-      expect(@gen).to receive(:require).with('rpeg-markdown').and_return(true)
-      expect(@gen).to receive(:eval).with('::PEGMarkdown').and_return(true)
-      @gen.options.markup = :markdown
-      # this only raises an exception because we mock out require to avoid
-      # loading any libraries but our implementation tries to return the library
-      # name as a constant
-      @gen.load_markup_provider
-      expect(@gen.markup_provider).to eq :"rpeg-markdown"
-    end
-
-    it "overrides the search if `:markup_provider` is set in options" do
-      expect(@gen).to receive(:require).with('rdiscount').and_return(true)
-      expect(@gen).to receive(:eval).with('::RDiscount').and_return(true)
-      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
-      @gen.load_markup_provider
-      expect(@gen.markup_provider).to eq :rdiscount
-    end
-
-    it "fails if no provider is found" do
-      YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
-        expect(@gen).to receive(:require).with(p[:lib].to_s).and_raise(LoadError)
-      end
-      @gen.options.markup = :markdown
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-
-    it "fails if overridden provider is not found" do
-      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
-      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-
-    it "fails if the markup type is not found" do
-      expect(log).to receive(:error).with(/Invalid markup/)
-      @gen.options.markup = :xxx
-      expect(@gen.load_markup_provider).to be false
-      expect(@gen.markup_provider).to eq nil
-    end
-  end
-
-  describe "#markup_for_file" do
-    include YARD::Templates::Helpers::MarkupHelper
-
-    it "looks for a shebang line" do
-      expect(markup_for_file("#!text\ntext here", 'file.rdoc')).to eq :text
-    end
-
-    it "returns the default markup type if no shebang is found or no valid ext is found" do
-      allow(self).to receive(:options).and_return(Options.new.update(:markup => :default_type))
-      expect(markup_for_file('', 'filename')).to eq :default_type
-    end
-
-    it "looks for a file extension if no shebang is found" do
-      expect(markup_for_file('', 'filename.MD')).to eq :markdown
-      expect(markup_for_file('', 'filename.ORG')).to eq :org
-    end
-
-    Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS.each do |type, exts|
-      exts.each do |ext|
-        it "recognizes .#{ext} as #{type} markup type" do
-          expect(markup_for_file('', "filename.#{ext}")).to eq type
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module YARD::Templates::Helpers::MarkupHelper
+  public :load_markup_provider, :markup_class, :markup_provider
+end
+
+class GeneratorMock
+  attr_accessor :options
+  include YARD::Templates::Helpers::MarkupHelper
+  def initialize(options = Templates::TemplateOptions.new)
+    self.options = options
+  end
+end
+
+RSpec.describe YARD::Templates::Helpers::MarkupHelper do
+  before do
+    YARD::Templates::Helpers::MarkupHelper.clear_markup_cache
+  end
+
+  describe "#load_markup_provider" do
+    before do
+      allow(log).to receive(:error)
+      @gen = GeneratorMock.new
+      @gen.options.reset_defaults
+    end
+
+    it "exits on an invalid markup type" do
+      @gen.options.markup = :invalid
+      expect(@gen.load_markup_provider).to be false
+    end
+
+    it "fails when an invalid markup provider is specified" do
+      @gen.options.update(:markup => :markdown, :markup_provider => :invalid)
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_class).to eq nil
+    end
+
+    it "loads RDocMarkup if rdoc is specified and it is installed" do
+      @gen.options.markup = :rdoc
+      expect(@gen.load_markup_provider).to be true
+      expect(@gen.markup_class).to eq YARD::Templates::Helpers::Markup::RDocMarkup
+    end
+
+    it "fails if RDoc cannot be loaded" do
+      @gen.options.markup = :rdoc
+      expect(@gen).to receive(:eval).with('::YARD::Templates::Helpers::Markup::RDocMarkup').and_raise(NameError)
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
+    end
+
+    it "searches through available markup providers for the markup type if none is set" do
+      expect(@gen).to receive(:eval).with('::RedcarpetCompat').and_return(double(:bluecloth))
+      expect(@gen).to receive(:require).with('redcarpet').and_return(true)
+      expect(@gen).not_to receive(:require).with('maruku')
+      @gen.options.markup = :markdown
+      # this only raises an exception because we mock out require to avoid
+      # loading any libraries but our implementation tries to return the library
+      # name as a constant
+      expect(@gen.load_markup_provider).to be true
+      expect(@gen.markup_provider).to eq :redcarpet
+    end
+
+    it "continues searching if some of the providers are unavailable" do
+      expect(@gen).to receive(:require).with('redcarpet').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('kramdown').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('bluecloth').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('maruku').and_raise(LoadError)
+      expect(@gen).to receive(:require).with('rpeg-markdown').and_return(true)
+      expect(@gen).to receive(:eval).with('::PEGMarkdown').and_return(true)
+      @gen.options.markup = :markdown
+      # this only raises an exception because we mock out require to avoid
+      # loading any libraries but our implementation tries to return the library
+      # name as a constant
+      @gen.load_markup_provider
+      expect(@gen.markup_provider).to eq :"rpeg-markdown"
+    end
+
+    it "overrides the search if `:markup_provider` is set in options" do
+      expect(@gen).to receive(:require).with('rdiscount').and_return(true)
+      expect(@gen).to receive(:eval).with('::RDiscount').and_return(true)
+      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
+      @gen.load_markup_provider
+      expect(@gen.markup_provider).to eq :rdiscount
+    end
+
+    it "fails if no provider is found" do
+      YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS[:markdown].each do |p|
+        expect(@gen).to receive(:require).with(p[:lib].to_s).and_raise(LoadError)
+      end
+      @gen.options.markup = :markdown
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
+    end
+
+    it "fails if overridden provider is not found" do
+      expect(@gen).to receive(:require).with('rdiscount').and_raise(LoadError)
+      @gen.options.update(:markup => :markdown, :markup_provider => :rdiscount)
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
+    end
+
+    it "fails if the markup type is not found" do
+      expect(log).to receive(:error).with(/Invalid markup/)
+      @gen.options.markup = :xxx
+      expect(@gen.load_markup_provider).to be false
+      expect(@gen.markup_provider).to eq nil
+    end
+  end
+
+  describe "#markup_for_file" do
+    include YARD::Templates::Helpers::MarkupHelper
+
+    it "looks for a shebang line" do
+      expect(markup_for_file("#!text\ntext here", 'file.rdoc')).to eq :text
+    end
+
+    it "returns the default markup type if no shebang is found or no valid ext is found" do
+      allow(self).to receive(:options).and_return(Options.new.update(:markup => :default_type))
+      expect(markup_for_file('', 'filename')).to eq :default_type
+    end
+
+    it "looks for a file extension if no shebang is found" do
+      expect(markup_for_file('', 'filename.MD')).to eq :markdown
+      expect(markup_for_file('', 'filename.ORG')).to eq :org
+    end
+
+    Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS.each do |type, exts|
+      exts.each do |ext|
+        it "recognizes .#{ext} as #{type} markup type" do
+          expect(markup_for_file('', "filename.#{ext}")).to eq type
+        end
+      end
+    end
+  end
+end