yard 0.6.8 → 0.7.0

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

@@ -13,9 +13,9 @@ module YARD
             html_syntax_highlight_ruby_legacy(source)
           end
         end
-        
+
         private
-        
+
         def html_syntax_highlight_ruby_ripper(source)
           tokenlist = Parser::Ruby::RubyParser.parse(source, "(syntax_highlight)").tokens
           output = ""
@@ -35,10 +35,10 @@ module YARD
         rescue Parser::ParserSyntaxError
           h(source)
         end
-        
+
         def html_syntax_highlight_ruby_legacy(source)
           tokenlist = Parser::Ruby::Legacy::TokenList.new(source)
-          tokenlist.map do |s| 
+          tokenlist.map do |s|
             prettyclass = s.class.class_name.sub(/^Tk/, '').downcase
             prettysuper = s.class.superclass.class_name.sub(/^Tk/, '').downcase
 

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

@@ -17,15 +17,15 @@ module YARD
             raise NameError, "could not load RDocMarkup (rdoc is not installed)"
           end
         end
-        
+
         class RDocMarkup
           attr_accessor :from_path
-          
+
           def initialize(text)
             @text = text
             @markup = MARKUP.new
           end
-          
+
           def to_html
             formatter = RDocMarkupToHtml.new
             formatter.from_path = from_path
@@ -34,11 +34,11 @@ module YARD
             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)
             text.gsub(/(\s|^|>)\+(?! )([^\n\+]{1,900})(?! )\+/) do
@@ -54,21 +54,21 @@ module YARD
 
           # Don't allow -- to turn into — 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(/—(?=\S)/, '--')
           end
         end
-        
+
         class RDocMarkupToHtml
           attr_accessor :from_path
-          
+
           # Disable auto-link of URLs
           def handle_special_HYPERLINK(special)
             @hyperlink ? special.text : super
           end
-          
+
           def accept_paragraph(*args)
             par = args.last
             text = par.respond_to?(:txt) ? par.txt : par.text

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

@@ -10,35 +10,37 @@ module YARD
         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 => :rdiscount, :const => 'RDiscount'},
+          {:lib => :kramdown, :const => 'Kramdown::Document'},
           {:lib => :bluecloth, :const => 'BlueCloth'},
-          {:lib => :kramdown, :const => "Kramdown::Document"},
           {:lib => :maruku, :const => 'Maruku'},
-          {:lib => :"rpeg-markdown", :const => "PEGMarkdown"},
-          {:lib => :rdiscount, :const => "RDiscount"}
+          {:lib => :redcarpet, :const => 'RedcarpetCompat'},
+          {:lib => :'rpeg-markdown', :const => 'PEGMarkdown'},
         ],
         :textile => [
-          {:lib => :redcloth, :const => 'RedCloth'}
+          {:lib => :redcloth, :const => 'RedCloth'},
         ],
         :rdoc => [
           {:lib => nil, :const => 'YARD::Templates::Helpers::Markup::RDocMarkup'},
         ],
+        :ruby => [],
         :text => [],
         :html => [],
-        :none => []
+        :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.
@@ -49,39 +51,40 @@ module YARD
         :textile => ['textile', 'txtile'],
         :markdown => ['markdown', 'md', 'mdown', 'mkd'],
         :rdoc => ['rdoc'],
+        :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]
@@ -90,28 +93,30 @@ module YARD
           MarkupHelper.markup_cache[type][:class] = klass
           return true
         end
-        
+
         # Show error message telling user to install first potential provider
         name, lib = *[providers.first[:const], providers.first[:lib] || type]
         log.error "Missing '#{lib}' gem for #{options[:markup].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)
-        if contents =~ MARKUP_FILE_SHEBANG # Shebang support
+        if contents && contents =~ MARKUP_FILE_SHEBANG # Shebang support
           return $1.to_sym
         end
 
@@ -121,28 +126,30 @@ module YARD
         end
         options[:markup]
       end
-      
-      # Strips any shebang lines on the file contents that pertain to 
+
+      # 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] 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] 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])

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

@@ -12,7 +12,7 @@ module YARD
               !object.tags(:param).any? {|t| t.name == param[0][1..-1] }
           end
         end
-        
+
         unless params.empty?
           args = params.map {|n, v| v ? "#{n} = #{v}" : n.to_s }.join(", ")
           h("(#{args})")
@@ -20,14 +20,14 @@ module YARD
           ""
         end
       end
-      
+
       # @return [String] formatted and linked return types for a method
       def format_return_types(object)
         return unless object.has_tag?(:return) && object.tag(:return).types
         return if object.tag(:return).types.empty?
         format_types [object.tag(:return).types.first], false
       end
-      
+
       # @return [String] formatted block if one exists
       def format_block(object)
         if object.has_tag?(:yield) && object.tag(:yield).types
@@ -42,25 +42,25 @@ module YARD
 
         params ? h("{|" + params.join(", ") + "| ... }") : ""
       end
-      
+
       # @return [String] formats line numbers for source code of an object
       def format_lines(object)
         return "" if object.source.nil? || object.line.nil?
         i = -1
         object.source.split(/\n/).map { object.line + (i += 1) }.join("\n")
       end
-      
+
       # @return [String] formats source of an object
       def format_code(object, show_lines = false)
         i = -1
         lines = object.source.split(/\n/)
         longestline = (object.line + lines.size).to_s.length
-        lines.map do |line| 
+        lines.map do |line|
           lineno = object.line + (i += 1)
           (" " * (longestline - lineno.to_s.length)) + lineno.to_s + "    " + line
         end.join("\n")
       end
-      
+
       # @return [String] formats source code of a constant value
       def format_constant(value)
         sp = value.split("\n").last[/^(\s+)/, 1]

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

@@ -8,7 +8,7 @@ module YARD
           out = ""
           text = text.split(/\n/)
           text.each_with_index do |line, i|
-            out << 
+            out <<
             case line
             when /^\s*$/; "\n\n"
             when /^\s+\S/, /^=/; line + "\n"
@@ -20,30 +20,30 @@ module YARD
 
         # @return [String] wraps text at +col+ columns.
         def wrap(text, col = 72)
-          text.gsub(/(.{1,#{col}})( +|$\n?)|(.{1,#{col}})/, "\\1\\3\n") 
+          text.gsub(/(.{1,#{col}})( +|$\n?)|(.{1,#{col}})/, "\\1\\3\n")
         end
-                
+
         # @return [String] indents +text+ by +len+ characters.
         def indent(text, len = 4)
           text.gsub(/^/, ' ' * len)
         end
-        
+
         # @return [String] aligns a title to the right
         def title_align_right(text, col = 72)
           align_right(text, '-', col)
         end
-        
+
         # @return [String] aligns text to the right
         def align_right(text, spacer = ' ', col = 72)
           text = text[0, col - 4] + '...' if (col - 1 - text.length) < 0
           spacer * (col - 1 - text.length) + " " + text
         end
-        
+
         # @return [String] returns a horizontal rule for output
         def hr(col = 72, sep = "-")
           sep * col
         end
-        
+
         # @return [String] the formatted signature for a method
         def signature(meth)
           # use first overload tag if it has a return type and method itself does not

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

@@ -12,21 +12,21 @@ module YARD
         when :private;   '-'
         end
       end
-      
+
       # Formats the path of an object for Graphviz syntax
       # @param [CodeObjects::Base] object an object to format the path of
       # @return [String] the encoded path
       def format_path(object)
         object.path.gsub('::', '_')
       end
-      
+
       # Encodes text in escaped Graphviz syntax
       # @param [String] text text to encode
       # @return [String] the encoded text
       def h(text)
         text.to_s.gsub(/(\W)/, '\\\\\1')
       end
-      
+
       # Tidies data by formatting and indenting text
       # @param [String] data pre-formatted text
       # @return [String] tidied text.

data/lib/yard/templates/section.rb

@@ -5,18 +5,18 @@ module YARD
     # @since 0.6.0
     class Section < Array
       attr_accessor :name
-      
+
       def initialize(name, *args)
         self.name = name
         replace(parse_sections(args))
       end
-      
+
       def dup
         obj = super
         obj.name = name
         obj
       end
-      
+
       def [](*args)
         if args.first.is_a?(Range) || args.size > 1
           obj = super(*args)
@@ -27,11 +27,11 @@ module YARD
         end
         find {|o| o.name == args.first }
       end
-      
+
       def eql?(other)
         super(other) && name == other.name
       end
-      
+
       def ==(other)
         case other
         when Section
@@ -42,26 +42,26 @@ module YARD
           name == other
         end
       end
-      
+
       def push(*args)
         super(*parse_sections(args))
       end
       alias << push
-      
+
       def unshift(*args)
         super(*parse_sections(args))
       end
-      
+
       def inspect
         n = name.respond_to?(:path) ? "T('#{name.path}')" : name.inspect
         subsects = empty? ? "" : ", subsections=#{super}"
         "Section(#{n}#{subsects})"
       end
-      
+
       def place(*args)
         super(*parse_sections(args))
       end
-      
+
       def to_a
         list = [name]
         unless empty?
@@ -71,7 +71,7 @@ module YARD
         end
         list
       end
-      
+
       def any(item)
         find do |section|
           return section if section == item
@@ -79,9 +79,9 @@ module YARD
         end
         nil
       end
-      
+
       private
-      
+
       def parse_sections(args)
         if args.size == 1 && args.first.is_a?(Array) && !args.first.is_a?(Section)
           args = args.first
@@ -94,7 +94,7 @@ module YARD
           else
             subsections = args[index + 1].is_a?(Array) ? args[index + 1] : []
             if subsections.is_a?(Section)
-              subsections = [] 
+              subsections = []
             end
             sections << Section.new(name, subsections)
           end