yard 0.9.18 → 0.9.23

data/lib/yard/templates/helpers/html_syntax_highlight_helper.rb

@@ -1,78 +1,78 @@
-# frozen_string_literal: true
-module YARD
-  module Templates
-    module Helpers
-      # Helper methods for syntax highlighting.
-      module HtmlSyntaxHighlightHelper
-        include ModuleHelper
-
-        # Highlights Ruby source
-        # @param [String] source the Ruby source code
-        # @return [String] the highlighted Ruby source
-        def html_syntax_highlight_ruby(source)
-          if Parser::SourceParser.parser_type == :ruby
-            html_syntax_highlight_ruby_ripper(source)
-          else
-            html_syntax_highlight_ruby_legacy(source)
-          end
-        end
-
-        private
-
-        def html_syntax_highlight_ruby_ripper(source)
-          resolver = Parser::Ruby::TokenResolver.new(source, object)
-          output = String.new("")
-          resolver.each do |s, token_obj|
-            token_obj = clean_token_object(token_obj)
-            output << "<span class='tstring'>" if [:tstring_beg, :regexp_beg].include?(s[0])
-            case s.first
-            when :nl, :ignored_nl, :sp
-              output << h(s[1])
-            when :ident, :const
-              klass = s.first == :ident ? "id identifier rubyid_#{h(s[1])}" : s.first
-              val = token_obj ? link_object(token_obj, s[1]) : h(s[1])
-              output << "<span class='#{klass}'>#{val}</span>"
-            else
-              output << "<span class='#{s.first}'>#{h(s[1])}</span>"
-            end
-            output << "</span>" if [:tstring_end, :regexp_end].include?(s[0])
-          end
-          output
-        rescue Parser::ParserSyntaxError
-          h(source)
-        end
-
-        def html_syntax_highlight_ruby_legacy(source)
-          tokenlist = Parser::Ruby::Legacy::TokenList.new(source)
-          tokenlist.map do |s|
-            prettyclass = s.class.class_name.sub(/^Tk/, '').downcase
-            prettysuper = s.class.superclass.class_name.sub(/^Tk/, '').downcase
-
-            case s
-            when Parser::Ruby::Legacy::RubyToken::TkWhitespace, Parser::Ruby::Legacy::RubyToken::TkUnknownChar
-              h s.text
-            when Parser::Ruby::Legacy::RubyToken::TkId
-              prettyval = h(s.text)
-              "<span class='rubyid_#{prettyval} #{prettyclass} #{prettysuper}'>#{prettyval}</span>"
-            else
-              "<span class='#{prettyclass} #{prettysuper}'>#{h s.text}</span>"
-            end
-          end.join
-        end
-
-        def clean_token_object(token_obj)
-          return unless token_obj
-          if token_obj == object
-            token_obj = nil
-          elsif token_obj.is_a?(CodeObjects::MethodObject)
-            token_obj = prune_method_listing([token_obj], false).first
-          else
-            token_obj = run_verifier([token_obj]).first
-          end
-
-          token_obj
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Templates
+    module Helpers
+      # Helper methods for syntax highlighting.
+      module HtmlSyntaxHighlightHelper
+        include ModuleHelper
+
+        # Highlights Ruby source
+        # @param [String] source the Ruby source code
+        # @return [String] the highlighted Ruby source
+        def html_syntax_highlight_ruby(source)
+          if Parser::SourceParser.parser_type == :ruby
+            html_syntax_highlight_ruby_ripper(source)
+          else
+            html_syntax_highlight_ruby_legacy(source)
+          end
+        end
+
+        private
+
+        def html_syntax_highlight_ruby_ripper(source)
+          resolver = Parser::Ruby::TokenResolver.new(source, object)
+          output = String.new("")
+          resolver.each do |s, token_obj|
+            token_obj = clean_token_object(token_obj)
+            output << "<span class='tstring'>" if [:tstring_beg, :regexp_beg].include?(s[0])
+            case s.first
+            when :nl, :ignored_nl, :sp
+              output << h(s[1])
+            when :ident, :const
+              klass = s.first == :ident ? "id identifier rubyid_#{h(s[1])}" : s.first
+              val = token_obj ? link_object(token_obj, s[1]) : h(s[1])
+              output << "<span class='#{klass}'>#{val}</span>"
+            else
+              output << "<span class='#{s.first}'>#{h(s[1])}</span>"
+            end
+            output << "</span>" if [:tstring_end, :regexp_end].include?(s[0])
+          end
+          output
+        rescue Parser::ParserSyntaxError
+          source =~ /^<span\s+class=/ ? source : h(source)
+        end
+
+        def html_syntax_highlight_ruby_legacy(source)
+          tokenlist = Parser::Ruby::Legacy::TokenList.new(source)
+          tokenlist.map do |s|
+            prettyclass = s.class.class_name.sub(/^Tk/, '').downcase
+            prettysuper = s.class.superclass.class_name.sub(/^Tk/, '').downcase
+
+            case s
+            when Parser::Ruby::Legacy::RubyToken::TkWhitespace, Parser::Ruby::Legacy::RubyToken::TkUnknownChar
+              h s.text
+            when Parser::Ruby::Legacy::RubyToken::TkId
+              prettyval = h(s.text)
+              "<span class='rubyid_#{prettyval} #{prettyclass} #{prettysuper}'>#{prettyval}</span>"
+            else
+              "<span class='#{prettyclass} #{prettysuper}'>#{h s.text}</span>"
+            end
+          end.join
+        end
+
+        def clean_token_object(token_obj)
+          return unless token_obj
+          if token_obj == object
+            token_obj = nil
+          elsif token_obj.is_a?(CodeObjects::MethodObject)
+            token_obj = prune_method_listing([token_obj], false).first
+          else
+            token_obj = run_verifier([token_obj]).first
+          end
+
+          token_obj
+        end
+      end
+    end
+  end
+end

data/lib/yard/templates/helpers/markup/rdoc_markdown.rb

@@ -1,23 +1,23 @@
-# frozen_string_literal: true
-module YARD
-  module Templates
-    module Helpers
-      module Markup
-        begin require 'rdoc'; rescue LoadError; nil end
-        begin
-          require 'rdoc/markdown'
-        rescue LoadError
-          raise NameError, "could not load RDoc Markdown support (rdoc is too old)"
-        end
-
-        class RDocMarkdown < RDocMarkup
-          def initialize(text)
-            super RDoc::Markdown.new.parse(text)
-          end
-
-          def fix_typewriter(html) html end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Templates
+    module Helpers
+      module Markup
+        begin require 'rdoc'; rescue LoadError; nil end
+        begin
+          require 'rdoc/markdown'
+        rescue LoadError
+          raise NameError, "could not load RDoc Markdown support (rdoc is too old)"
+        end
+
+        class RDocMarkdown < RDocMarkup
+          def initialize(text)
+            super RDoc::Markdown.new.parse(text)
+          end
+
+          def fix_typewriter(html) html end
+        end
+      end
+    end
+  end
+end

data/lib/yard/templates/helpers/markup/rdoc_markup.rb

@@ -1,109 +1,109 @@
-# frozen_string_literal: true
-require 'thread'
-
-module YARD
-  module Templates
-    module Helpers
-      module Markup
-        begin require 'rdoc'; rescue LoadError; nil end
-        begin
-          require 'rdoc/markup'
-          require 'rdoc/markup/to_html'
-          class RDocMarkup; MARKUP = RDoc::Markup end
-          class RDocMarkupToHtml < RDoc::Markup::ToHtml
-            if defined?(RDoc::VERSION) && RDoc::VERSION >= '4.0.0' &&
-               defined?(RDoc::Options)
-              def initialize
-                options = RDoc::Options.new
-                options.pipe = true
-                super(options)
-              end
-            end
-          end
-        rescue LoadError
-          begin
-            require 'rdoc/markup/simple_markup'
-            require 'rdoc/markup/simple_markup/to_html'
-            class RDocMarkup; MARKUP = SM::SimpleMarkup end
-            class RDocMarkupToHtml < SM::ToHtml; end
-          rescue LoadError
-            raise NameError, "could not load RDocMarkup (rdoc is not installed)"
-          end
-        end
-
-        class RDocMarkup
-          attr_accessor :from_path
-
-          @@formatter = nil
-          @@markup = nil
-          @@mutex = nil
-
-          def initialize(text)
-            @text = text
-
-            @@formatter ||= RDocMarkupToHtml.new
-            @@markup ||= MARKUP.new
-            @@mutex ||= Mutex.new
-          end
-
-          def to_html
-            html = nil
-            @@mutex.synchronize do
-              @@formatter.from_path = from_path
-              html = @@markup.convert(@text, @@formatter)
-            end
-            html = fix_dash_dash(html)
-            html = fix_typewriter(html)
-            html
-          end
-
-          private
-
-          # Fixes RDoc behaviour with ++ only supporting alphanumeric text.
-          #
-          # @todo Refactor into own SimpleMarkup subclass
-          def fix_typewriter(text)
-            code_tags = 0
-            text.gsub(%r{<(/)?(pre|code|tt)|(\s|^|>)\+(?! )([^\n\+]{1,900})(?! )\+}) do |str|
-              closed = $1
-              tag = $2
-              first_text = $3
-              type_text = $4
-
-              if tag
-                code_tags += (closed ? -1 : 1)
-                next str
-              end
-              next str unless code_tags == 0
-              first_text + '<tt>' + type_text + '</tt>'
-            end
-          end
-
-          # Don't allow -- to turn into &#8212; element. The chances of this being
-          # some --option is far more likely than the typographical meaning.
-          #
-          # @todo Refactor into own SimpleMarkup subclass
-          def fix_dash_dash(text)
-            text.gsub(/&#8212;(?=\S)/, '--')
-          end
-        end
-
-        class RDocMarkupToHtml
-          attr_accessor :from_path
-
-          # Disable auto-link of URLs
-          def handle_special_HYPERLINK(special) # rubocop:disable Style/MethodName
-            @hyperlink ? special.text : super
-          end
-
-          def accept_paragraph(*args)
-            par = args.last
-            text = par.respond_to?(:txt) ? par.txt : par.text
-            @hyperlink = text =~ /\{(https?:|mailto:|link:|www\.)/ ? true : false
-            super
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require 'thread'
+
+module YARD
+  module Templates
+    module Helpers
+      module Markup
+        begin require 'rdoc'; rescue LoadError; nil end
+        begin
+          require 'rdoc/markup'
+          require 'rdoc/markup/to_html'
+          class RDocMarkup; MARKUP = RDoc::Markup end
+          class RDocMarkupToHtml < RDoc::Markup::ToHtml
+            if defined?(RDoc::VERSION) && RDoc::VERSION >= '4.0.0' &&
+               defined?(RDoc::Options)
+              def initialize
+                options = RDoc::Options.new
+                options.pipe = true
+                super(options)
+              end
+            end
+          end
+        rescue LoadError
+          begin
+            require 'rdoc/markup/simple_markup'
+            require 'rdoc/markup/simple_markup/to_html'
+            class RDocMarkup; MARKUP = SM::SimpleMarkup end
+            class RDocMarkupToHtml < SM::ToHtml; end
+          rescue LoadError
+            raise NameError, "could not load RDocMarkup (rdoc is not installed)"
+          end
+        end
+
+        class RDocMarkup
+          attr_accessor :from_path
+
+          @@formatter = nil
+          @@markup = nil
+          @@mutex = nil
+
+          def initialize(text)
+            @text = text
+
+            @@formatter ||= RDocMarkupToHtml.new
+            @@markup ||= MARKUP.new
+            @@mutex ||= Mutex.new
+          end
+
+          def to_html
+            html = nil
+            @@mutex.synchronize do
+              @@formatter.from_path = from_path
+              html = @@markup.convert(@text, @@formatter)
+            end
+            html = fix_dash_dash(html)
+            html = fix_typewriter(html)
+            html
+          end
+
+          private
+
+          # Fixes RDoc behaviour with ++ only supporting alphanumeric text.
+          #
+          # @todo Refactor into own SimpleMarkup subclass
+          def fix_typewriter(text)
+            code_tags = 0
+            text.gsub(%r{<(/)?(pre|code|tt)|(\s|^|>)\+(?! )([^\n\+]{1,900})(?! )\+}) do |str|
+              closed = $1
+              tag = $2
+              first_text = $3
+              type_text = $4
+
+              if tag
+                code_tags += (closed ? -1 : 1)
+                next str
+              end
+              next str unless code_tags == 0
+              first_text + '<tt>' + type_text + '</tt>'
+            end
+          end
+
+          # Don't allow -- to turn into &#8212; element. The chances of this being
+          # some --option is far more likely than the typographical meaning.
+          #
+          # @todo Refactor into own SimpleMarkup subclass
+          def fix_dash_dash(text)
+            text.gsub(/&#8212;(?=\S)/, '--')
+          end
+        end
+
+        class RDocMarkupToHtml
+          attr_accessor :from_path
+
+          # Disable auto-link of URLs
+          def handle_special_HYPERLINK(special) # rubocop:disable Style/MethodName
+            @hyperlink ? special.text : super
+          end
+
+          def accept_paragraph(*args)
+            par = args.last
+            text = par.respond_to?(:txt) ? par.txt : par.text
+            @hyperlink = text =~ /\{(https?:|mailto:|link:|www\.)/ ? true : false
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yard/templates/helpers/markup_helper.rb

@@ -1,172 +1,172 @@
-# frozen_string_literal: true
-require 'rubygems'
-
-module YARD
-  module Templates::Helpers
-    # Helper methods for loading and managing markup types.
-    module MarkupHelper
-      class << self
-        # Clears the markup provider cache information. Mainly used for testing.
-        # @return [void]
-        def clear_markup_cache
-          self.markup_cache = {}
-        end
-
-        # @return [Hash{Symbol=>{(:provider,:class)=>Object}}] the cached markup providers
-        # @private
-        # @since 0.6.4
-        attr_accessor :markup_cache
-      end
-
-      MarkupHelper.clear_markup_cache
-
-      # The default list of markup providers for each markup type
-      MARKUP_PROVIDERS = {
-        :markdown => [
-          {:lib => :redcarpet, :const => 'RedcarpetCompat'},
-          {:lib => :rdiscount, :const => 'RDiscount'},
-          {:lib => :kramdown, :const => 'Kramdown::Document'},
-          {:lib => :bluecloth, :const => 'BlueCloth'},
-          {:lib => :maruku, :const => 'Maruku'},
-          {:lib => :'rpeg-markdown', :const => 'PEGMarkdown'},
-          {:lib => :rdoc, :const => 'YARD::Templates::Helpers::Markup::RDocMarkdown'}
-        ],
-        :textile => [
-          {:lib => :redcloth, :const => 'RedCloth'}
-        ],
-        :textile_strict => [
-          {:lib => :redcloth, :const => 'RedCloth'}
-        ],
-        :rdoc => [
-          {:lib => nil, :const => 'YARD::Templates::Helpers::Markup::RDocMarkup'}
-        ],
-        :org => [
-          {:lib => :'org-ruby', :const => 'Orgmode::Parser'}
-        ],
-        :asciidoc => [
-          {:lib => :asciidoctor, :const => 'Asciidoctor'}
-        ],
-        :ruby => [],
-        :text => [],
-        :pre  => [],
-        :html => [],
-        :none => []
-      }
-
-      # Returns a list of extensions for various markup types. To register
-      # extensions for a type, add them to the array of extensions for the
-      # type.
-      # @since 0.6.0
-      MARKUP_EXTENSIONS = {
-        :html => ['htm', 'html', 'shtml'],
-        :text => ['txt'],
-        :textile => ['textile', 'txtile'],
-        :asciidoc => ['asciidoc', 'ad', 'adoc', 'asc'],
-        :markdown => ['markdown', 'md', 'mdown', 'mkd'],
-        :rdoc => ['rdoc'],
-        :org => ['org'],
-        :ruby => ['rb', 'ru']
-      }
-
-      # Contains the Regexp object that matches the shebang line of extra
-      # files to detect the markup type.
-      MARKUP_FILE_SHEBANG = /\A#!(\S+)\s*$/
-
-      # Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}.
-      # If a provider is specified, immediately try to load it.
-      #
-      # On success this sets `@markup_provider` and `@markup_class` to
-      # the provider name and library constant class/module respectively for
-      # the loaded provider.
-      #
-      # On failure this method will inform the user that no provider could be
-      # found and exit the program.
-      #
-      # @return [Boolean] whether the markup provider was successfully loaded.
-      def load_markup_provider(type = options.markup)
-        return true if MarkupHelper.markup_cache[type]
-        MarkupHelper.markup_cache[type] ||= {}
-
-        providers = MARKUP_PROVIDERS[type.to_sym]
-        return true if providers && providers.empty?
-        if providers && options.markup_provider
-          providers = providers.select {|p| p[:lib] == options.markup_provider }
-        end
-
-        if providers.nil? || providers.empty?
-          log.error "Invalid markup type '#{type}' or markup provider " \
-                    "(#{options.markup_provider}) is not registered."
-          return false
-        end
-
-        # Search for provider, return the library class name as const if found
-        providers.each do |provider|
-          begin require provider[:lib].to_s; rescue LoadError; next end if provider[:lib]
-          begin klass = eval("::" + provider[:const]); rescue NameError; next end # rubocop:disable Lint/Eval
-          MarkupHelper.markup_cache[type][:provider] = provider[:lib] # Cache the provider
-          MarkupHelper.markup_cache[type][:class] = klass
-          return true
-        end
-
-        # Show error message telling user to install first potential provider
-        lib = providers.first[:lib] || type
-        log.error "Missing '#{lib}' gem for #{type.to_s.capitalize} formatting. Install it with `gem install #{lib}`"
-        false
-      end
-
-      # Checks for a shebang or looks at the file extension to determine
-      # the markup type for the file contents. File extensions are registered
-      # for a markup type in {MARKUP_EXTENSIONS}.
-      #
-      # A shebang should be on the first line of a file and be in the form:
-      #
-      #   #!markup_type
-      #
-      # Standard markup types are text, html, rdoc, markdown, textile
-      #
-      # @param [String] contents Unused. Was necessary prior to 0.7.0.
-      #   Newer versions of YARD use {CodeObjects::ExtraFileObject#contents}
-      # @return [Symbol] the markup type recognized for the file
-      # @see MARKUP_EXTENSIONS
-      # @since 0.6.0
-      def markup_for_file(contents, filename)
-        return $1.to_sym if contents && contents =~ MARKUP_FILE_SHEBANG # Shebang support
-
-        ext = (File.extname(filename)[1..-1] || '').downcase
-        MARKUP_EXTENSIONS.each do |type, exts|
-          return type if exts.include?(ext)
-        end
-        options.markup
-      end
-
-      # Strips any shebang lines on the file contents that pertain to
-      # markup or preprocessing data.
-      #
-      # @deprecated Use {CodeObjects::ExtraFileObject#contents} instead
-      # @return [String] the file contents minus any preprocessing tags
-      # @since 0.6.0
-      def markup_file_contents(contents)
-        contents =~ MARKUP_FILE_SHEBANG ? $' : contents
-      end
-
-      # Gets the markup provider class/module constant for a markup type
-      # Call {#load_markup_provider} before using this method.
-      #
-      # @param [Symbol] type the markup type (:rdoc, :markdown, etc.)
-      # @return [Class] the markup class
-      def markup_class(type = options.markup)
-        load_markup_provider(type)
-        MarkupHelper.markup_cache[type][:class]
-      end
-
-      # Gets the markup provider name for a markup type
-      # Call {#load_markup_provider} before using this method.
-      #
-      # @param [Symbol] type the markup type (:rdoc, :markdown, etc.)
-      # @return [Symbol] the markup provider name (usually the gem name of the library)
-      def markup_provider(type = options.markup)
-        MarkupHelper.markup_cache[type][:provider]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require 'rubygems'
+
+module YARD
+  module Templates::Helpers
+    # Helper methods for loading and managing markup types.
+    module MarkupHelper
+      class << self
+        # Clears the markup provider cache information. Mainly used for testing.
+        # @return [void]
+        def clear_markup_cache
+          self.markup_cache = {}
+        end
+
+        # @return [Hash{Symbol=>{(:provider,:class)=>Object}}] the cached markup providers
+        # @private
+        # @since 0.6.4
+        attr_accessor :markup_cache
+      end
+
+      MarkupHelper.clear_markup_cache
+
+      # The default list of markup providers for each markup type
+      MARKUP_PROVIDERS = {
+        :markdown => [
+          {:lib => :redcarpet, :const => 'RedcarpetCompat'},
+          {:lib => :rdiscount, :const => 'RDiscount'},
+          {:lib => :kramdown, :const => 'Kramdown::Document'},
+          {:lib => :bluecloth, :const => 'BlueCloth'},
+          {:lib => :maruku, :const => 'Maruku'},
+          {:lib => :'rpeg-markdown', :const => 'PEGMarkdown'},
+          {:lib => :rdoc, :const => 'YARD::Templates::Helpers::Markup::RDocMarkdown'}
+        ],
+        :textile => [
+          {:lib => :redcloth, :const => 'RedCloth'}
+        ],
+        :textile_strict => [
+          {:lib => :redcloth, :const => 'RedCloth'}
+        ],
+        :rdoc => [
+          {:lib => nil, :const => 'YARD::Templates::Helpers::Markup::RDocMarkup'}
+        ],
+        :org => [
+          {:lib => :'org-ruby', :const => 'Orgmode::Parser'}
+        ],
+        :asciidoc => [
+          {:lib => :asciidoctor, :const => 'Asciidoctor'}
+        ],
+        :ruby => [],
+        :text => [],
+        :pre  => [],
+        :html => [],
+        :none => []
+      }
+
+      # Returns a list of extensions for various markup types. To register
+      # extensions for a type, add them to the array of extensions for the
+      # type.
+      # @since 0.6.0
+      MARKUP_EXTENSIONS = {
+        :html => ['htm', 'html', 'shtml'],
+        :text => ['txt'],
+        :textile => ['textile', 'txtile'],
+        :asciidoc => ['asciidoc', 'ad', 'adoc', 'asc'],
+        :markdown => ['markdown', 'md', 'mdown', 'mkd'],
+        :rdoc => ['rdoc'],
+        :org => ['org'],
+        :ruby => ['rb', 'ru']
+      }
+
+      # Contains the Regexp object that matches the shebang line of extra
+      # files to detect the markup type.
+      MARKUP_FILE_SHEBANG = /\A#!(\S+)\s*$/
+
+      # Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}.
+      # If a provider is specified, immediately try to load it.
+      #
+      # On success this sets `@markup_provider` and `@markup_class` to
+      # the provider name and library constant class/module respectively for
+      # the loaded provider.
+      #
+      # On failure this method will inform the user that no provider could be
+      # found and exit the program.
+      #
+      # @return [Boolean] whether the markup provider was successfully loaded.
+      def load_markup_provider(type = options.markup)
+        return true if MarkupHelper.markup_cache[type]
+        MarkupHelper.markup_cache[type] ||= {}
+
+        providers = MARKUP_PROVIDERS[type.to_sym]
+        return true if providers && providers.empty?
+        if providers && options.markup_provider
+          providers = providers.select {|p| p[:lib] == options.markup_provider }
+        end
+
+        if providers.nil? || providers.empty?
+          log.error "Invalid markup type '#{type}' or markup provider " \
+                    "(#{options.markup_provider}) is not registered."
+          return false
+        end
+
+        # Search for provider, return the library class name as const if found
+        providers.each do |provider|
+          begin require provider[:lib].to_s; rescue LoadError; next end if provider[:lib]
+          begin klass = eval("::" + provider[:const]); rescue NameError; next end # rubocop:disable Lint/Eval
+          MarkupHelper.markup_cache[type][:provider] = provider[:lib] # Cache the provider
+          MarkupHelper.markup_cache[type][:class] = klass
+          return true
+        end
+
+        # Show error message telling user to install first potential provider
+        lib = providers.first[:lib] || type
+        log.error "Missing '#{lib}' gem for #{type.to_s.capitalize} formatting. Install it with `gem install #{lib}`"
+        false
+      end
+
+      # Checks for a shebang or looks at the file extension to determine
+      # the markup type for the file contents. File extensions are registered
+      # for a markup type in {MARKUP_EXTENSIONS}.
+      #
+      # A shebang should be on the first line of a file and be in the form:
+      #
+      #   #!markup_type
+      #
+      # Standard markup types are text, html, rdoc, markdown, textile
+      #
+      # @param [String] contents Unused. Was necessary prior to 0.7.0.
+      #   Newer versions of YARD use {CodeObjects::ExtraFileObject#contents}
+      # @return [Symbol] the markup type recognized for the file
+      # @see MARKUP_EXTENSIONS
+      # @since 0.6.0
+      def markup_for_file(contents, filename)
+        return $1.to_sym if contents && contents =~ MARKUP_FILE_SHEBANG # Shebang support
+
+        ext = (File.extname(filename)[1..-1] || '').downcase
+        MARKUP_EXTENSIONS.each do |type, exts|
+          return type if exts.include?(ext)
+        end
+        options.markup
+      end
+
+      # Strips any shebang lines on the file contents that pertain to
+      # markup or preprocessing data.
+      #
+      # @deprecated Use {CodeObjects::ExtraFileObject#contents} instead
+      # @return [String] the file contents minus any preprocessing tags
+      # @since 0.6.0
+      def markup_file_contents(contents)
+        contents =~ MARKUP_FILE_SHEBANG ? $' : contents
+      end
+
+      # Gets the markup provider class/module constant for a markup type
+      # Call {#load_markup_provider} before using this method.
+      #
+      # @param [Symbol] type the markup type (:rdoc, :markdown, etc.)
+      # @return [Class] the markup class
+      def markup_class(type = options.markup)
+        load_markup_provider(type)
+        MarkupHelper.markup_cache[type][:class]
+      end
+
+      # Gets the markup provider name for a markup type
+      # Call {#load_markup_provider} before using this method.
+      #
+      # @param [Symbol] type the markup type (:rdoc, :markdown, etc.)
+      # @return [Symbol] the markup provider name (usually the gem name of the library)
+      def markup_provider(type = options.markup)
+        MarkupHelper.markup_cache[type][:provider]
+      end
+    end
+  end
+end