yard 0.6.8 → 0.7.0

data/lib/yard/tags/default_factory.rb

@@ -3,7 +3,7 @@ module YARD
     class DefaultFactory
       TYPELIST_OPENING_CHARS = '[({<'
       TYPELIST_CLOSING_CHARS = '>})]'
-      
+
       # Parses tag text and creates a new tag with descriptive text
       #
       # @param tag_name        the name of the tag to parse
@@ -12,7 +12,7 @@ module YARD
       def parse_tag(tag_name, text)
         Tag.new(tag_name, text.strip)
       end
-      
+
       # Parses tag text and creates a new tag with a key name and descriptive text
       #
       # @param tag_name        the name of the tag to parse
@@ -22,8 +22,8 @@ module YARD
         name, text = *extract_name_from_text(text)
         Tag.new(tag_name, text, nil, name)
       end
-      
-      # Parses tag text and creates a new tag with formally declared types and 
+
+      # Parses tag text and creates a new tag with formally declared types and
       # descriptive text
       #
       # @param tag_name        the name of the tag to parse
@@ -34,8 +34,8 @@ module YARD
         raise TagFormatError, "cannot specify a name before type list for '@#{tag_name}'" if name
         Tag.new(tag_name, text, types)
       end
-      
-      # Parses tag text and creates a new tag with formally declared types, a key 
+
+      # Parses tag text and creates a new tag with formally declared types, a key
       # name and descriptive text
       #
       # @param tag_name        the name of the tag to parse
@@ -46,12 +46,12 @@ module YARD
         name, text = *extract_name_from_text(text) unless name
         Tag.new(tag_name, text, types, name)
       end
-      
+
       def parse_tag_with_title_and_text(tag_name, text)
         title, desc = *extract_title_and_desc_from_text(text)
         Tag.new(tag_name, desc, nil, title)
       end
-      
+
       def parse_tag_with_types_name_and_default(tag_name, text)
         # Can't allow () in a default tag, otherwise the grammar is too ambiguous when types is omitted.
         open, close = TYPELIST_OPENING_CHARS.gsub('(', ''), TYPELIST_CLOSING_CHARS.gsub(')', '')
@@ -64,23 +64,23 @@ module YARD
           DefaultTag.new(tag_name, text, types, name, nil)
         end
       end
-      
+
       def parse_tag_with_options(tag_name, text)
         name, text = *extract_name_from_text(text)
         OptionTag.new(tag_name, name, parse_tag_with_types_name_and_default(tag_name, text))
       end
-      
+
       private
-      
+
       # Extracts the name from raw tag text returning the name and remaining value
       #
       # @param [String] text the raw tag text
-      # @return [Array] an array holding the name as the first element and the 
+      # @return [Array] an array holding the name as the first element and the
       #                 value as the second element
       def extract_name_from_text(text)
         text.strip.split(/\s+/, 2)
       end
-            
+
       def extract_title_and_desc_from_text(text)
         raise TagFormatError if text.nil? || text.empty?
         title, desc = nil, nil
@@ -93,16 +93,16 @@ module YARD
         end
         [title, desc]
       end
-      
-      # Parses a [], <>, {} or () block at the beginning of a line of text 
+
+      # Parses a [], <>, {} or () block at the beginning of a line of text
       # into a list of comma delimited values.
-      # 
+      #
       # @example
       #   obj.parse_types('[String, Array<Hash, String>, nil]') # => [nil, ['String', 'Array<Hash, String>', 'nil'], ""]
       #   obj.parse_types('b<String> A string') # => ['b', ['String'], 'A string']
-      # 
-      # @return [Array(String, Array<String>, String)] the text before the type 
-      #   list (or nil), followed by the type list parsed into an array of 
+      #
+      # @return [Array(String, Array<String>, String)] the text before the type
+      #   list (or nil), followed by the type list parsed into an array of
       #   strings, followed by the text following the type list.
       def extract_types_and_name_from_text(text, opening_types = TYPELIST_OPENING_CHARS, closing_types = TYPELIST_CLOSING_CHARS)
         s, e = 0, 0

data/lib/yard/tags/default_tag.rb

@@ -2,7 +2,7 @@ module YARD
   module Tags
     class DefaultTag < Tag
       attr_reader :defaults
-      
+
       def initialize(tag_name, text, types = nil, name = nil, defaults = nil)
         super(tag_name, text, types, name)
         @defaults = defaults

data/lib/yard/tags/library.rb

@@ -17,7 +17,7 @@ module YARD
     #
     # The second line will expand to:
     #   def author_tag(text) tag_factory.parse_tag(text) end
-    # 
+    #
     # Note that +tag_factory+ is the factory object used to parse tags. This value
     # defaults to the {DefaultFactory} class and can be set by changing {Library.default_factory}.
     #
@@ -30,10 +30,10 @@ module YARD
     #
     # This will allow you to use @mytag TEXT to add meta data to classes through
     # the docstring. You can use the {Library#factory} object to help parse standard
-    # tag syntax. 
-    # 
+    # tag syntax.
+    #
     # == Adding/Changing the Tag Syntax
-    # If you have specialized tag parsing needs you can substitute the {#factory} 
+    # If you have specialized tag parsing needs you can substitute the {#factory}
     # object with your own by setting {Library.default_factory= Library.default_factory}
     # to a new class with its own parsing methods before running YARD. This is useful
     # if you want to change the syntax of existing tags (@see, @since, etc.)
@@ -43,34 +43,34 @@ module YARD
     class Library
       class << self
         attr_reader :labels
-        
+
         def instance
           @instance ||= new
         end
-        
+
         def default_factory
           @default_factory ||= DefaultFactory.new
         end
-        
+
         # Replace the factory object responsible for parsing tags by setting
         # this to an object (or class) that responds to +parse_TAGNAME+ methods
         # where +TAGNAME+ is the name of the tag.
-        # 
+        #
         # You should set this value before performing any source parsing with
         # YARD, otherwise your factory class will not be used.
-        # 
+        #
         # @example
         #   YARD::Tags::Library.default_factory = MyFactory
-        # 
+        #
         # @param [Class, Object] factory the factory that parses all tags
-        # 
+        #
         # @see DefaultFactory
         def default_factory=(factory)
           @default_factory = factory.is_a?(Class) ? factory.new : factory
         end
-        
+
         # Returns the factory method used to parse the tag text for a specific tag
-        # 
+        #
         # @param [Symbol] tag the tag name
         # @return [Symbol] the factory method name for the tag
         # @return [Class<Tag>] the Tag class to use to parse the tag
@@ -79,48 +79,48 @@ module YARD
         def factory_method_for(tag)
           @factory_methods[tag]
         end
-        
-        # Sets the list of tags to display when rendering templates. The order of 
-        # tags in the list is also significant, as it represents the order that 
+
+        # Sets the list of tags to display when rendering templates. The order of
+        # tags in the list is also significant, as it represents the order that
         # tags are displayed in templates.
-        # 
-        # You can use the {Array#place} to insert new tags to be displayed in 
+        #
+        # You can use the {Array#place} to insert new tags to be displayed in
         # the templates at specific positions:
-        # 
+        #
         #   Library.visible_tags.place(:mytag).before(:return)
-        # 
+        #
         # @return [Array<Symbol>] a list of ordered tags
         # @since 0.6.0
         attr_accessor :visible_tags
-        
+
         # Sets the list of tags that should apply to any children inside the
         # namespace they are defined in. For instance, a "@since" tag should
         # apply to all methods inside a module is it defined in. Transitive
         # tags can be overridden by directly defining a tag on the child object.
-        # 
+        #
         # @return [Array<Symbol>] a list of transitive tags
         # @since 0.6.0
         attr_accessor :transitive_tags
-      
+
         # Sorts the labels lexically by their label name, often used when displaying
         # the tags.
-        # 
+        #
         # @return [Array<Symbol>, String] the sorted labels as an array of the tag name and label
         def sorted_labels
           labels.sort_by {|a| a.last.downcase }
         end
-      
+
         # Convenience method to define a new tag using one of {Tag}'s factory methods, or the
         # regular {DefaultFactory#parse_tag} factory method if none is supplied.
         #
         # @param [#to_s] tag the tag name to create
-        # @param [#to_s, Class<Tag>] meth the {Tag} factory method to call when 
+        # @param [#to_s, Class<Tag>] meth the {Tag} factory method to call when
         #   creating the tag or the name of the class to directly create a tag for
         def define_tag(label, tag, meth = nil)
           if meth.is_a?(Class) && Tag > meth
             class_eval <<-eof, __FILE__, __LINE__
-              def #{tag}_tag(text) 
-                #{meth}.new(#{tag.inspect}, text) 
+              def #{tag}_tag(text)
+                #{meth}.new(#{tag.inspect}, text)
               end
             eof
           else
@@ -138,9 +138,9 @@ module YARD
           tag
         end
       end
-      
+
       private
-      
+
       def send_to_factory(tag_name, meth, text)
         meth = meth.to_s
         send_name = "parse_tag" + (meth.empty? ? "" : "_" + meth)
@@ -151,46 +151,51 @@ module YARD
           raise NoMethodError, "Factory #{@factory.class_name} does not implement factory method :#{meth}."
         end
       end
-      
+
       public
-      
+
       # A factory class to handle parsing of tags, defaults to {default_factory}
       attr_accessor :factory
-      
+
       def initialize(factory = Library.default_factory)
         self.factory = factory
       end
-      
-      define_tag "Abstract",          :abstract
-      define_tag "API Visibility",    :api
-      define_tag "Attribute",         :attr,         :with_types_and_name
-      define_tag "Attribute Getter",  :attr_reader,  :with_types_and_name
-      define_tag "Attribute Setter",  :attr_writer,  :with_types_and_name
-      define_tag "Author",            :author
-      define_tag "Deprecated",        :deprecated
-      define_tag "Example",           :example,     :with_title_and_text
-      define_tag "End Grouping",      :endgroup
-      define_tag "Grouping",          :group
-      define_tag "Note",              :note
-      define_tag "Options Hash",      :option,      :with_options
-      define_tag "Overloads",         :overload,    OverloadTag
-      define_tag "Parameters",        :param,       :with_types_and_name
-      define_tag "Private",           :private
-      define_tag "Raises",            :raise,       :with_types
-      define_tag "Returns",           :return,      :with_types
-      define_tag "See Also",          :see,         :with_name
-      define_tag "Since",             :since
-      define_tag "Todo Item",         :todo
-      define_tag "Version",           :version
-      define_tag "Yields",            :yield,       :with_types
-      define_tag "Yield Parameters",  :yieldparam,  :with_types_and_name
-      define_tag "Yield Returns",     :yieldreturn, :with_types
-      
-      self.visible_tags = [:abstract, :deprecated, :note, :todo, :example, :overload, 
-        :param, :option, :yield, :yieldparam, :yieldreturn, :return, :raise, 
+
+      define_tag "Abstract",           :abstract
+      define_tag "API Visibility",     :api
+      define_tag "Attribute (macro)",  :attribute,   :with_types
+      define_tag "Attribute",          :attr,        :with_types_and_name
+      define_tag "Attribute Getter",   :attr_reader, :with_types_and_name
+      define_tag "Attribute Setter",   :attr_writer, :with_types_and_name
+      define_tag "Author",             :author
+      define_tag "Deprecated",         :deprecated
+      define_tag "Example",            :example,     :with_title_and_text
+      define_tag "End Grouping",       :endgroup
+      define_tag "Grouping",           :group
+      define_tag "Macro",              :macro,       :with_types_and_name
+      define_tag "Method (macro)",     :method,      :with_title_and_text
+      define_tag "Note",               :note
+      define_tag "Options Hash",       :option,      :with_options
+      define_tag "Overloads",          :overload,    OverloadTag
+      define_tag "Parameters",         :param,       :with_types_and_name
+      define_tag "Private",            :private
+      define_tag "Raises",             :raise,       :with_types
+      define_tag "Returns",            :return,      :with_types
+      define_tag "Scope (macro)",      :scope
+      define_tag "See Also",           :see,         :with_name
+      define_tag "Since",              :since
+      define_tag "Todo Item",          :todo
+      define_tag "Version",            :version
+      define_tag "Visibility (macro)", :visibility
+      define_tag "Yields",             :yield,       :with_types
+      define_tag "Yield Parameters",   :yieldparam,  :with_types_and_name
+      define_tag "Yield Returns",      :yieldreturn, :with_types
+
+      self.visible_tags = [:abstract, :deprecated, :note, :todo, :example, :overload,
+        :param, :option, :yield, :yieldparam, :yieldreturn, :return, :raise,
         :see, :author, :since, :version]
-      
-      self.transitive_tags = [:since]
+
+      self.transitive_tags = [:since, :api]
     end
   end
 end

data/lib/yard/tags/option_tag.rb

@@ -2,7 +2,7 @@ module YARD
   module Tags
     class OptionTag < Tag
       attr_accessor :pair
-      
+
       def initialize(tag_name, name, pair)
         super(tag_name, nil, nil, name)
         @pair = pair

data/lib/yard/tags/overload_tag.rb

@@ -2,17 +2,17 @@ module YARD
   module Tags
     class OverloadTag < Tag
       attr_reader :signature, :parameters, :docstring
-      
+
       def initialize(tag_name, text)
         super(tag_name, nil)
         parse_tag(text)
         parse_signature
       end
-      
+
       def tag(name) docstring.tag(name) end
       def tags(name = nil) docstring.tags(name) end
       def has_tag?(name) docstring.has_tag?(name) end
-        
+
       def object=(value)
         super(value)
         docstring.object = value
@@ -22,22 +22,22 @@ module YARD
         return @name unless prefix
         object.scope == :class ? @name.to_s : "#{object.send(:sep)}#{@name}"
       end
-      
+
       def method_missing(*args, &block)
         object.send(*args, &block)
       end
-      
+
       def type
         object.type
       end
-      
+
       def is_a?(other)
         object.is_a?(other) || self.class >= other.class || false
       end
       alias kind_of? is_a?
-      
+
       private
-      
+
       def parse_tag(text)
         @signature, text = *text.split(/\r?\n/, 2)
         @signature.strip!
@@ -47,7 +47,7 @@ module YARD
         text.strip!
         @docstring = Docstring.new(text, nil)
       end
-      
+
       def parse_signature
         if signature =~ /^(?:def\s)?\s*(#{CodeObjects::METHODMATCH})(?:(?:\s+|\s*\()(.*)(?:\)\s*$)?)?/m
           meth, args = $1, $2

data/lib/yard/tags/ref_tag_list.rb

@@ -2,13 +2,13 @@ module YARD
   module Tags
     class RefTagList
       attr_accessor :owner, :tag_name, :name
-      
+
       def initialize(tag_name, owner, name = nil)
         @owner = CodeObjects::Proxy === owner ? owner : P(owner)
         @tag_name = tag_name.to_s
         @name = name
       end
-      
+
       def tags
         if owner.is_a?(CodeObjects::Base)
           o = owner.tags(tag_name)

data/lib/yard/tags/tag.rb

@@ -2,7 +2,7 @@ module YARD
   module Tags
     # Represents a metadata tag value (+@tag+). Tags can have any combination of
     # {#types}, {#name} and {#text}, or none of the above.
-    # 
+    #
     # @example Programmatic tag creation
     #   # The following docstring syntax:
     #   #   @param [String, nil] arg an argument
@@ -12,18 +12,18 @@ module YARD
     class Tag
       # @return [String] the name of the tag
       attr_accessor :tag_name
-      
+
       # @return [String] the tag text associated with the tag
       # @return [nil] if no tag text is supplied
       attr_accessor :text
-      
+
       # @return [Array<String>] a list of types associated with the tag
       # @return [nil] if no types are associated with the tag
       attr_accessor :types
-      
+
       # @return [String] a name associated with the tag
       attr_accessor :name
-      
+
       # @return [CodeObjects::Base] the associated object
       attr_accessor :object
 
@@ -31,7 +31,7 @@ module YARD
       # and a key name can be specified.
       #
       # Types are mainly for meta tags that rely on type information, such as +param+, +return+, etc.
-      # 
+      #
       # Key names are for tags that declare meta data for a specific key or name, such as +param+,
       # +raise+, etc.
       #
@@ -47,7 +47,7 @@ module YARD
       # Convenience method to access the first type specified. This should mainly
       # be used for tags that only specify one type.
       #
-      # @return [String] the first of the list of specified types 
+      # @return [String] the first of the list of specified types
       # @see #types
       def type
         types.first