RubyGems - mango - Versions diffs - 0.6.3 → 0.7.0 - Mend

mango 0.6.3 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2484) hide show

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/default/layout/html/script_setup.erb ADDED

@@ -0,0 +1,8 @@
+<script type="text/javascript" charset="utf-8">
+  hasFrames = window.top.frames.main ? true : false;
+  relpath = '/';
+  docsPrefix = '<%= base_path(router.docs_prefix) %>';
+  listPrefix = '<%= base_path(router.list_prefix) %>';
+  searchPrefix = '<%= base_path(router.search_prefix) %>';
+  framesUrl = '<%= url_for_frameset %>';
+</script>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/default/layout/html/setup.rb ADDED

@@ -0,0 +1,7 @@
+def javascripts
+  super + %w(js/autocomplete.js)
+end
+def stylesheets
+  super + %w(css/custom.css)
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/default/method_details/html/permalink.erb ADDED

@@ -0,0 +1,4 @@
+<script>
+$("#<%= anchor_for(object) %>").prepend(
+  '<a class="permalink" href="/<%= base_path(router.docs_prefix) %>/<%= serializer.serialized_path(object) %>">permalink</a>');
+</script>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/default/method_details/html/setup.rb ADDED

@@ -0,0 +1,4 @@
+def init
+  super
+  sections.place(:permalink).after_any(:method_signature)
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/contents.erb ADDED

@@ -0,0 +1,13 @@
+<ul>
+  <% @libraries.sort_by {|name, y| name.downcase }.each do |name, library_versions| %>
+  <li class="r<%= @row = @row == 1 ? 2 : 1 %>">
+    <% library_versions = library_versions.dup %>
+    <% first_lib = library_versions.pop %>
+    <a href="/<%= router.docs_prefix %>/<%= first_lib.name %>/frames"><%= name %></a>
+    <% if first_lib.version %>
+      <small>(<%= first_lib.version %><% if library_versions.size > 0 %>,
+        <%= library_versions.reverse.map {|lib| "<a href=\"/#{router.docs_prefix}/#{lib}/frames\">#{lib.version}</a>" }.join(', ') %><% end %>)</small>
+    <% end %>
+  </li>
+  <% end %>
+</ul>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/headers.erb ADDED

@@ -0,0 +1,26 @@
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<title>YARD Documentation Server <%= YARD::VERSION %> - Library Listing</title>
+<link rel="stylesheet" href="/css/style.css" type="text/css" media="screen" charset="utf-8" />
+<link rel="stylesheet" href="/css/custom.css" type="text/css" media="screen" charset="utf-8" />
+<script type="text/javascript" charset="utf-8" src="/js/jquery.js"></script>
+<script type="text/javascript">
+  function framesLinks() {
+    $('#framelink').toggle(function() {
+      $(this).text('links with frames');
+      $('ul li a').each(function() {
+        $(this).attr('href', $(this).attr('href').replace(/\/frames$/, ''));
+      });
+    }, function() {
+      $(this).text('links without frames');
+      $('ul li a').each(function() {
+        $(this).attr('href', $(this).attr('href') + '/frames');
+      });
+    })
+  }
+  $(framesLinks);
+</script>
+<style type="text/css" media="screen">
+  ul { list-style: circle inside none; padding: 0; }
+  li { font-size: 1.2em; line-height: 1.4em; padding: 3px 5px; }
+</style>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/library_list.erb ADDED

@@ -0,0 +1,12 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <%= erb(:headers) %>
+  </head>
+  <body>
+    <div id="content">
+      <%= yieldall %>
+    </div>
+  </body>
+</html>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/setup.rb ADDED

@@ -0,0 +1,3 @@
+def init
+  sections :library_list, [:title, :contents]
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/title.erb ADDED

	@@ -0,0 +1,2 @@
1	+ <h1>YARD Documentation Server <%= YARD::VERSION %></h1>
2	+ <h2>Library Listing <small>(<a id="framelink" href="#">links without frames</a>)</small></h2>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/processing/html/processing.erb ADDED

@@ -0,0 +1,51 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <link rel="stylesheet" href="/css/style.css" type="text/css" media="screen" charset="utf-8" />
+    <link rel="stylesheet" href="/css/custom.css" type="text/css" media="screen" charset="utf-8" />
+    <script type="text/javascript" charset="utf-8" src="/js/jquery.js"></script>
+    <script type="text/javascript" charset="utf-8">
+      function checkPage(process) {
+        $.ajax({cache: false, url: "<%= router.request.path %>" + (process ? "?process=true" : ""), statusCode: { 200: function() { window.location = "<%= @path %>"; } } });
+        setTimeout('checkPage()', 2000);
+      }
+      function setFade() {
+        centerMessage();
+        $(window).resize(function() { centerMessage(); });
+        $('#fade').fadeIn();
+        $('#processing').fadeIn();
+      }
+      function centerMessage() {
+        $('#fade').css('width', $(window).width() + 'px');
+        $('#fade').css('height', $(window).height() - parseInt($('#fade').css('top')) + 'px');
+        $('#processing').css('left', ($(window).width() / 2 - $('#processing').width() / 2) + 'px');
+        $('#processing').css('top', ($(window).height() / 2 - $('#processing').height() / 2) + 'px');
+      }
+      $(function() { checkPage(true); });
+      $(setFade);
+    </script>
+    <style type="text/css" media="screen">
+      body { overflow: hidden; }
+    </style>
+    <title>Processing <%= @library.to_s(false) %></title>
+  </head>
+  <body>
+    <div id="menu">
+      <% unless @single_library %>
+        <a href="/<%= router.docs_prefix %>" target="_top">Libraries</a> &raquo;
+        <span class="title"><%= @library.name %> <% if @library.version %><small>(<%= @library.version %>)</small><% end %></span>
+      <% end %>
+    </div>
+    <div id="fade"></div>
+    <div id="processing">
+      <h1>Processing <%= @library.name %></h1>
+      <p>
+        <strong><%= @library.name %></strong> <% if @library.version %>(<%= @library.version %>)<% end %> is being processed.
+        You'll be redirected when the pages are built, it shouldn't take much longer.
+      </p>
+      <img src="/images/processing.gif" align="center" />
+    </div>
+  </body>
+</html>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/processing/html/setup.rb ADDED

@@ -0,0 +1,3 @@
+def init
+  sections :processing
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/search/html/search.erb ADDED

@@ -0,0 +1,18 @@
+<div id="search_results">
+  <h1>Search Results <small>(for '<%= h @query %>')</small></h1>
+  <p>Showing <%= @visible_results.size %> of <%= @results.size %> results</p>
+  <ul>
+    <% n = 1 %>
+    <% @visible_results.each do |result| %>
+      <% name = result.type == :method ? result.name(true).to_s : result.name.to_s %>
+      <% path = name.gsub(/(#{Regexp.quote @query})/i, '<strong>\1</strong>') %>
+      <li class="r<%= n %>">
+        <a href="<%= url_for(result) %>" title="<%= result.path %>"><%= path %></a>
+          <% if !result.namespace.root? %>
+          <small>(<%= result.namespace.path %>)</small>
+          <% end %>
+      </li>
+      <% n = n == 2 ? 1 : 2 %>
+    <% end %>
+  </ul>
+</div>

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/search/html/setup.rb ADDED

@@ -0,0 +1,8 @@
+def init
+  sections :search, [T('../default/layout')]
+end
+def search
+  options.breadcrumb_title = h("Search for '#{@query}'")
+  yieldall :contents => erb(:search)
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/server/webrick_adapter.rb ADDED

@@ -0,0 +1,43 @@
+require 'webrick'
+module YARD
+  module Server
+    # The main adapter to initialize a WEBrick server.
+    class WebrickAdapter < Adapter
+      # Initializes a WEBrick server. If {Adapter#server_options} contains a
+      # +:daemonize+ key set to true, the server will be daemonized.
+      def start
+        server_options[:ServerType] = WEBrick::Daemon if server_options[:daemonize]
+        server = WEBrick::HTTPServer.new(server_options)
+        server.mount('/', WebrickServlet, self)
+        trap("INT") { server.shutdown }
+        server.start
+      end
+    end
+    # The main WEBrick servlet implementation, accepting only GET requests.
+    class WebrickServlet < WEBrick::HTTPServlet::AbstractServlet
+      attr_accessor :adapter
+      def initialize(server, adapter)
+        super
+        self.adapter = adapter
+      end
+      def do_GET(request, response)
+        status, headers, body = *adapter.router.call(request)
+        response.status = status
+        response.body = body.is_a?(Array) ? body[0] : body
+        headers.each do |key, value|
+          response[key] = value
+        end
+      end
+    end
+  end
+end
+# @private
+class WEBrick::HTTPRequest
+  attr_accessor :version_supplied
+  def xhr?; (self['X-Requested-With'] || "").downcase == 'xmlhttprequest' end
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/tags/default_factory.rb ADDED

@@ -0,0 +1,176 @@
+module YARD
+  module Tags
+    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
+      # @param [String] text   the raw tag text
+      # @return [Tag]          a tag object with the tag_name and text values filled
+      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
+      # @param [String] text   the raw tag text
+      # @return [Tag]          a tag object with the tag_name, name and text values filled
+      def parse_tag_with_name(tag_name, text)
+        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
+      # descriptive text
+      #
+      # @param tag_name        the name of the tag to parse
+      # @param [String] text   the raw tag text
+      # @return [Tag]          a tag object with the tag_name, types and text values filled
+      def parse_tag_with_types(tag_name, text)
+        name, types, text = *extract_types_and_name_from_text(text)
+        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
+      # name and descriptive text
+      #
+      # @param tag_name        the name of the tag to parse
+      # @param [String] text   the raw tag text
+      # @return [Tag]          a tag object with the tag_name, name, types and text values filled
+      def parse_tag_with_types_and_name(tag_name, text)
+        name, types, text = *extract_types_and_name_from_text(text)
+        name, text = *extract_name_from_text(text) unless name
+        Tag.new(tag_name, text, types, name)
+      end
+      # Parses tag text and creates a new tag with formally declared types, a title
+      # on the first line and descriptive text
+      #
+      # @param tag_name        the name of the tag to parse
+      # @param [String] text   the raw tag text
+      # @return [Tag]          a tag object with the tag_name, name, types and text values filled
+      def parse_tag_with_types_and_title(tag_name, text)
+        name, types, text = *extract_types_and_name_from_text_unstripped(text)
+        if name
+          title, desc = name, text
+        else
+          title, desc = *extract_title_and_desc_from_text(text)
+        end
+        Tag.new(tag_name, desc, types, title)
+      rescue TagFormatError
+        Tag.new(tag_name, '', types, nil)
+      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(')', '')
+        name, types, text = *extract_types_and_name_from_text(text, open, close)
+        name, text = *extract_name_from_text(text) unless name
+        if text =~ /\A\(/
+          _, default, text = *extract_types_and_name_from_text(text, '(', ')')
+          DefaultTag.new(tag_name, text, types, name, default)
+        else
+          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
+      #                 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
+        if text =~ /\A[ \t]\n/
+          desc = text
+        else
+          text = text.split(/\r?\n/)
+          title = text.shift.squeeze(' ').strip
+          desc = text.join("\n")
+        end
+        [title, desc]
+      end
+      # 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
+      #   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)
+        before, list, text = *extract_types_and_name_from_text_unstripped(text, opening_types, closing_types)
+        if list.nil?
+          [nil, nil, text.strip]
+        else
+          [before ? before.strip : nil, list.map {|e| e.strip }, text.strip]
+        end
+      end
+      def extract_types_and_name_from_text_unstripped(text, opening_types = TYPELIST_OPENING_CHARS, closing_types = TYPELIST_CLOSING_CHARS)
+        s, e = 0, 0
+        before = ''
+        list, level, seen_space, i = [''], 0, false, 0
+        last_seen = ''
+        while i < text.length
+          c = text[i, 1]
+          if level > 0 && c == '#' && text[i+1..-1] =~ CodeObjects::METHODNAMEMATCH
+            list.last << c + $&
+            i += $&.length + 1
+            next
+          elsif opening_types.include?(c)
+            list.last << c if level > 0
+            s = i if level == 0
+            level += 1
+          elsif closing_types.include?(c)
+            level -= 1 unless last_seen == '=' && c == '>'
+            break e = i if level == 0
+            list.last << c
+          elsif c == ',' && level == 1
+            list.push ''
+          elsif c =~ /\S/ && level == 0
+            break e = i if seen_space && list == ['']
+            before << c
+          elsif c =~ /\s/ && level == 0 && !before.empty?
+            seen_space = true
+          elsif level >= 1
+            list.last << c
+          end
+          last_seen = c
+          i += 1
+        end
+        before = before.empty? ? nil : before
+        if list.size == 1 && list.first == ''
+          [nil, nil, text]
+        else
+          [before, list, text[(e+1)..-1]]
+        end
+      end
+    end
+  end
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/tags/default_tag.rb ADDED

@@ -0,0 +1,12 @@
+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
+      end
+    end
+  end
+end

data/vendor/bundler/ruby/2.0.0/gems/yard-0.8.7.3/lib/yard/tags/directives.rb ADDED

@@ -0,0 +1,599 @@
+require 'ostruct'
+module YARD
+  module Tags
+    # The base directive class. Subclass this class to create a custom
+    # directive, registering it with {Library.define_directive}. Directive
+    # classes are executed via the {#call} method, which perform all directive
+    # processing on the object.
+    #
+    # If processing occurs within a handler, the {#handler} attribute is
+    # available to access more information about parsing context and state.
+    # Handlers are only available when parsing from {Parser::SourceParser},
+    # not when parsing directly from {DocstringParser}. If the docstring is
+    # attached to an object declaration, {#object} will be set and available
+    # to modify the generated code object directly. Note that both of these
+    # attributes may be nil, and directives should test their existence
+    # before attempting to use them.
+    #
+    # @abstract Subclasses should implement {#call}.
+    # @see Library.define_directive
+    # @since 0.8.0
+    class Directive
+      # @return [Tag] the meta-data tag containing data input to the directive
+      attr_accessor :tag
+      # Set this field to replace the directive definition inside of a docstring
+      # with arbitrary text. For instance, the {MacroDirective} uses this field
+      # to expand its macro data in place of the call to a +@!macro+.
+      #
+      # @return [String] the text to expand in the original docstring in place
+      #   of this directive definition.
+      # @return [nil] if no expansion should take place for this directive
+      attr_accessor :expanded_text
+      # @return [DocstringParser] the parser that is parsing all tag
+      #   information out of the docstring
+      attr_accessor :parser
+      # @!attribute [r] object
+      # @return [CodeObjects::Base, nil] the object the parent docstring is
+      #   attached to. May be nil.
+      def object; parser.object end
+      # @!attribute [r] handler
+      # @return [Handlers::Base, nil] the handler object the docstring parser
+      #   might be attached to. May be nil. Only available when parsing
+      #   through {Parser::SourceParser}.
+      def handler; parser.handler end
+      # @!endgroup
+      # @param [Tag] tag the meta-data tag containing all input to the docstring
+      # @param [DocstringParser] parser the docstring parser object
+      def initialize(tag, parser)
+        self.tag = tag
+        self.parser = parser
+        self.expanded_text = nil
+      end
+      # @!group Parser callbacks
+      # Called when processing the directive. Subclasses should implement
+      # this method to perform all functionality of the directive.
+      #
+      # @abstract implement this method to perform all data processing for
+      #   the directive.
+      # @return [void]
+      def call; raise NotImplementedError end
+      # Called after parsing all directives and tags in the docstring. Used
+      # to perform any cleanup after all directives perform their main task.
+      # @return [void]
+      def after_parse; end
+      protected :parser
+    end
+    # Ends a group listing definition. Group definition automatically end
+    # when class or module blocks are closed, and defining a new group overrides
+    # the last group definition, but occasionally you need to end the current
+    # group to return to the default listing. Use {tag:!group} to begin a
+    # group listing.
+    #
+    # @example
+    #   class Controller
+    #     # @!group Callbacks
+    #
+    #     def before_filter; end
+    #     def after_filter; end
+    #
+    #     # @!endgroup
+    #
+    #     def index; end
+    #   end
+    # @see tag:!group
+    # @since 0.6.0
+    class EndGroupDirective < Directive
+      def call
+        return unless handler
+        handler.extra_state.group = nil
+      end
+    end
+    # Defines a group listing. All methods (and attributes) seen after this
+    # directive are placed into a group with the given description as the
+    # group name. The group listing is used by templates to organize methods
+    # and attributes into respective logical groups. To end a group listing
+    # use {tag:!endgroup}.
+    #
+    # @note A group definition only applies to the scope it is defined in.
+    #   If a new class or module is opened after the directive, this directive
+    #   will not apply to methods in that class or module.
+    # @example
+    #   # @!group Callbacks
+    #
+    #   def before_filter; end
+    #   def after_filter; end
+    # @see tag:!endgroup
+    # @since 0.6.0
+    class GroupDirective < Directive
+      def call
+        return unless handler
+        handler.extra_state.group = tag.text
+      end
+    end
+    # Defines a block of text to be expanded whenever the macro is called by name
+    # in subsequent docstrings. The macro data can be any arbitrary text data, be
+    # it regular documentation, meta-data tags or directives.
+    #
+    # == Defining a Macro
+    #
+    # A macro must first be defined in order to be used. Note that a macro is also
+    # expanded upon definition if it defined on an object (the docstring of a
+    # method, class, module or constant object as opposed to a free standing
+    # comment). To define a macro, use the "new" or "attach" identifier in the
+    # types specifier list. A macro will also automatically be created if an
+    # indented macro data block is given, so the keywords are not strictly needed.
+    #
+    # === Anonymous Macros
+    #
+    # In addition to standard named macros, macros can be defined anonymously if
+    # no name is given. In this case, they can not be re-used in future docstrings,
+    # but they will expand in the first definition. This is useful when needing
+    # to take advantage of the macro expansion variables (described below).
+    #
+    # == Using a Macro
+    #
+    # To re-use a macro in another docstring after it is defined, simply use
+    # <tt>@!macro the_name</tt> with no indented block of macro data. The resulting
+    # data will be expanded in place.
+    #
+    # == Attaching a Macro to a DSL Method
+    #
+    # Macros can be defined to auto-expand on DSL-style class method calls. To
+    # define a macro to be auto expanded in this way, use the "attach" keyword
+    # in the type specifier list ("new" is implied).
+    #
+    # Attached macros can also be attached directly on the class method declaration
+    # that provides the DSL method to its subclasses. The syntax in either case
+    # is the same.
+    #
+    # == Macro Expansion Variables
+    #
+    # In the case of using macros on DSL-style method calls, a number of expansion
+    # variables can be used for interpolation inside of the macro data. The variables,
+    # similar in syntax to Ruby's global variables, are as follows:
+    #
+    # * $0 - the method name being called
+    # * $1, $2, $3, ... - the Nth argument in the method call
+    # * $& - the full source line
+    #
+    # The following example shows what the expansion variables might hold for a given
+    # DSL method call:
+    #
+    #   property :foo, :a, :b, :c, String
+    #   # $0 => "property"
+    #   # $1 => "foo"
+    #   # $2 => "a"
+    #   # $& => "property :foo, :a, :b, :c, String"
+    #
+    # === Ranges
+    #
+    # Ranges are also acceptable with the syntax <tt>${N-M}</tt>. Negative values
+    # on either N or M are valid, and refer to indexes from the end of the list.
+    # Consider a DSL method that creates a method using the first argument with
+    # argument names following, ending with the return type of the method. This
+    # could be documented as:
+    #
+    #     # @!macro dsl_method
+    #     #   @!method $1(${2--2})
+    #     #   @return [${-1}] the return value of $0
+    #     create_method_with_args :foo, :a, :b, :c, String
+    #
+    # As described, the method is using the signature <tt>foo(a, b, c)</tt> and the return
+    # type from the last argument, +String+. When using ranges, tokens are joined
+    # with commas. Note that this includes using $0:
+    #
+    #     !!!plain
+    #     $0-1 # => Interpolates to "create_method_with_args, foo"
+    #
+    # If you want to separate them with spaces, use <tt>$1 $2 $3 $4 ...</tt>. Note that
+    # if the token cannot be expanded, it will return the empty string (not an error),
+    # so it would be safe to list <tt>$1 $2 ... $10</tt>, for example.
+    #
+    # === Escaping Interpolation
+    #
+    # Interpolation can be escaped by prefixing the +$+ with +\\\+, like so:
+    #
+    #     # @!macro foo
+    #     #   I have \$2.00 USD.
+    #
+    # @example Defining a simple macro
+    #   # @!macro [new] returnself
+    #   #   @return [self] returns itself
+    # @example Using a simple macro in multiple docstrings
+    #   # Documentation for map
+    #   # ...
+    #   # @macro returnself
+    #   def map; end
+    #
+    #   # Documentation for filter
+    #   # ...
+    #   # @macro returnself
+    #   def filter; end
+    # @example Attaching a macro to a class method (for DSL usage)
+    #     class Resource
+    #       # Defines a new property
+    #       # @param [String] name the property name
+    #       # @param [Class] type the property's type
+    #       # @!macro [attach] property
+    #       #   @return [$2] the $1 property
+    #       def self.property(name, type) end
+    #     end
+    #
+    #     class Post < Resource
+    #       property :title, String
+    #       property :view_count, Integer
+    #     end
+    # @example Attaching a macro directly to a DSL method
+    #     class Post < Resource
+    #       # @!macro [attach] property
+    #       #   @return [$2] the $1 property
+    #       property :title, String
+    #
+    #       # Macro will expand on this definition too
+    #       property :view_count, Integer
+    #     end
+    # @since 0.7.0
+    class MacroDirective < Directive
+      def call
+        raise TagFormatError if tag.name.nil? && tag.text.to_s.empty?
+        unless macro_data = find_or_create
+          warn
+          return
+        end
+        self.expanded_text = expand(macro_data)
+      end
+      private
+      def new?
+        (tag.types && tag.types.include?('new')) ||
+          (tag.text && !tag.text.strip.empty?)
+      end
+      def attach?
+        new? && # must have data or there is nothing to attach
+        class_method? || # always attach to class methods
+        (tag.types && tag.types.include?('attach'))
+      end
+      def class_method?
+        object && object.is_a?(CodeObjects::MethodObject) &&
+          object.scope == :class
+      end
+      def anonymous?
+        tag.name.nil? || tag.name.empty?
+      end
+      def expand(macro_data)
+        return if attach? && class_method?
+        return if !anonymous? && new? &&
+          (!handler || handler.statement.source.empty?)
+        call_params = []
+        caller_method = nil
+        full_source = ''
+        if handler
+          call_params = handler.call_params
+          caller_method = handler.caller_method
+          full_source = handler.statement.source
+        end
+        all_params = ([caller_method] + call_params).compact
+        CodeObjects::MacroObject.expand(macro_data, all_params, full_source)
+      end
+      def find_or_create
+        if new? || attach?
+          if handler && attach?
+            obj = object ? object :
+              P("#{handler.namespace}.#{handler.caller_method}")
+          else
+            obj = nil
+          end
+          if anonymous? # anonymous macro
+            return tag.text || ""
+          else
+            macro = CodeObjects::MacroObject.create(tag.name, tag.text, obj)
+          end
+        else
+          macro = CodeObjects::MacroObject.find(tag.name)
+        end
+        macro ? macro.macro_data : nil
+      end
+      def warn
+        if object && handler
+          log.warn "Invalid/missing macro name for " +
+            "#{object.path} (#{handler.parser.file}:#{handler.statement.line})"
+        end
+      end
+    end
+    # Defines a method object with a given method signature, using indented
+    # block data as the method's docstring. The signature is similar to the
+    # {tag:overload} tag. The comment containing this directive does not need
+    # to be attached to any source, but if it is, that source code will be
+    # used as the method's source.
+    #
+    # To define an attribute method, see {tag:!attribute}
+    #
+    # @note For backwards compatibility support, you do not need to indent
+    #   the method's docstring text. If a +@!method+ directive is seen with
+    #   no indented block, the entire docstring is used as the new method's
+    #   docstring text.
+    # @example Defining a simple method
+    #   # @!method quit(username, message = "Quit")
+    #   #   Sends a quit message to the server for a +username+.
+    #   #   @param [String] username the username to quit
+    #   #   @param [String] message the quit message
+    #   quit_message_method
+    # @example Attaching multiple methods to the same source
+    #   # @!method method1
+    #   # @!method method2
+    #   create_methods :method1, :method2
+    # @see tag:!attribute
+    # @since 0.7.0
+    class MethodDirective < Directive
+      SCOPE_MATCH = /\A\s*self\s*\.\s*/
+      def call; end
+      def after_parse
+        return unless handler
+        use_indented_text
+        create_object
+      end
+      protected
+      def method_name
+        sig = sanitized_tag_signature
+        if sig && sig =~ /^#{CodeObjects::METHODNAMEMATCH}(\s|\(|$)/
+          sig[/\A\s*([^\(; \t]+)/, 1]
+        else
+          handler.call_params.first
+        end
+      end
+      def method_signature
+        "def #{sanitized_tag_signature || method_name}"
+      end
+      def sanitized_tag_signature
+        if tag.name && tag.name =~ SCOPE_MATCH
+          parser.state.scope = :class
+          $'
+        else
+          tag.name
+        end
+      end
+      def use_indented_text
+        return if tag.text.empty?
+        handler = parser.handler
+        object = parser.object
+        self.parser = parser.class.new(parser.library)
+        parser.state.inside_directive = true
+        parser.parse(tag.text, object, handler)
+        parser.state.inside_directive = false
+      end
+      def create_object
+        name = method_name
+        scope = parser.state.scope || handler.scope
+        visibility = parser.state.visibility || handler.visibility
+        ns = CodeObjects::NamespaceObject === object ? object : handler.namespace
+        obj = CodeObjects::MethodObject.new(ns, name, scope)
+        handler.register_file_info(obj)
+        handler.register_source(obj)
+        handler.register_visibility(obj, visibility)
+        handler.register_group(obj)
+        obj.signature = method_signature
+        obj.parameters = OverloadTag.new(:overload, method_signature).parameters
+        obj.docstring = Docstring.new!(parser.text, parser.tags, obj,
+          parser.raw_text, parser.reference)
+        handler.register_module_function(obj)
+        obj
+      end
+    end
+    # Defines an attribute with a given name, using indented block data as the
+    # attribute's docstring. If the type specifier is supplied with "r", "w", or
+    # "rw", the attribute is made readonly, writeonly or readwrite respectively.
+    # A readwrite attribute is the default, if no type is specified. The comment
+    # containing this directive does not need to be attached to any source, but
+    # if it is, that source code will be used as the method's source.
+    #
+    # To define an regular method, see {tag:!method}
+    #
+    # @note For backwards compatibility support, you do not need to indent
+    #   the attribute's docstring text. If an +@!attribute+ directive is seen with
+    #   no indented block, the entire docstring is used as the new attribute's
+    #   docstring text.
+    # @example Defining a simple readonly attribute
+    #   # @!attribute [r] count
+    #   #   @return [Fixnum] the size of the list
+    # @example Defining a simple readwrite attribute
+    #   # @!attribute name
+    #   #   @return [String] the name of the user
+    # @see tag:!method
+    # @since 0.7.0
+    class AttributeDirective < MethodDirective
+      def after_parse
+        return unless handler
+        use_indented_text
+        create_attribute_data(create_object)
+      end
+      protected
+      def method_name
+        name = sanitized_tag_signature || handler.call_params.first
+        name += '=' unless readable?
+        name
+      end
+      def method_signature
+        if readable?
+          "def #{method_name}"
+        else
+          "def #{method_name}(value)"
+        end
+      end
+      private
+      def create_attribute_data(object)
+        return unless object
+        clean_name = object.name.to_s.sub(/=$/, '')
+        attrs = object.namespace.attributes[object.scope]
+        attrs[clean_name] ||= SymbolHash[:read => nil, :write => nil]
+        if readable?
+          attrs[clean_name][:read] = object
+        end
+        if writable?
+          if object.name.to_s[-1,1] == '='
+            writer = object
+            writer.parameters = [['value', nil]]
+          else
+            writer = CodeObjects::MethodObject.new(object.namespace,
+              object.name.to_s + '=', object.scope)
+            writer.signature = "def #{object.name}=(value)"
+            writer.visibility = object.visibility
+            writer.dynamic = object.dynamic
+            writer.source = object.source
+            writer.group = object.group
+            writer.parameters = [['value', nil]]
+            handler.register_file_info(writer)
+          end
+          attrs[clean_name][:write] = writer
+        end
+      end
+      def writable?
+        !tag.types || tag.types.join.include?('w')
+      end
+      def readable?
+        !tag.types || tag.types.join =~ /(?!w)r/
+      end
+    end
+    # Parses a block of code as if it were present in the source file at that
+    # location. This directive is useful if a class has dynamic meta-programmed
+    # behaviour that cannot be recognized by YARD.
+    #
+    # You can specify the language of the code block using the types
+    # specification list. By default, the code language is "ruby".
+    #
+    # @example Documenting dynamic module inclusion
+    #   class User
+    #     # includes "UserMixin" and extends "UserMixin::ClassMethods"
+    #     # using the UserMixin.included callback.
+    #     # @!parse include UserMixin
+    #     # @!parse extend UserMixin::ClassMethods
+    #   end
+    # @example Declaring a method as an attribute
+    #   # This should really be an attribute
+    #   # @!parse attr_reader :foo
+    #   def object; @parent.object end
+    # @example Parsing C code
+    #   # @!parse [c]
+    #   #   void Init_Foo() {
+    #   #     rb_define_method(rb_cFoo, "method", method, 0);
+    #   #   }
+    # @since 0.8.0
+    class ParseDirective < Directive
+      def call
+        lang = tag.types ? tag.types.first.to_sym :
+          (handler ? handler.parser.parser_type : :ruby)
+        if handler && lang == handler.parser.parser_type
+          pclass = Parser::SourceParser.parser_types[handler.parser.parser_type]
+          pobj = pclass.new(tag.text, handler.parser.file)
+          pobj.parse
+          handler.parser.process(pobj.enumerator)
+        else # initialize a new parse chain
+          src_parser = Parser::SourceParser.new(lang, handler ? handler.globals : nil)
+          src_parser.file = handler.parser.file if handler
+          src_parser.parse(StringIO.new(tag.text))
+        end
+      end
+    end
+    # Modifies the current parsing scope (class or instance). If this
+    # directive is defined on a docstring attached to an object definition,
+    # it is applied only to that object. Otherwise, it applies the scope
+    # to all future objects in the namespace.
+    #
+    # @example Modifying the scope of a DSL method
+    #   # @!scope class
+    #   cattr_accessor :subclasses
+    # @example Modifying the scope of a set of methods
+    #   # @!scope class
+    #
+    #   # Documentation for method1
+    #   def method1; end
+    #
+    #   # Documentation for method2
+    #   def method2; end
+    # @since 0.7.0
+    class ScopeDirective < Directive
+      def call
+        if %w(class instance module).include?(tag.text)
+          if object.is_a?(CodeObjects::MethodObject)
+            object.scope = tag.text.to_sym
+          else
+            parser.state.scope = tag.text.to_sym
+          end
+        end
+      end
+    end
+    # Modifies the current parsing visibility (public, protected, or private).
+    # If this directive is defined on a docstring attached to an object
+    # definition, it is applied only to that object. Otherwise, it applies
+    # the visibility to all future objects in the namespace.
+    #
+    # @example Modifying the visibility of a DSL method
+    #   # @!visibility private
+    #   cattr_accessor :subclasses
+    # @example Modifying the visibility of a set of methods
+    #   # Note that Ruby's "protected" is recommended over this directive
+    #   # @!visibility protected
+    #
+    #   # Documentation for method1
+    #   def method1; end
+    #
+    #   # Documentation for method2
+    #   def method2; end
+    # @since 0.7.0
+    class VisibilityDirective < Directive
+      def call
+        if %w(public protected private).include?(tag.text)
+          if object.is_a?(CodeObjects::Base)
+            object.visibility = tag.text.to_sym
+          elsif handler && !parser.state.inside_directive
+            handler.visibility = tag.text.to_sym
+          else
+            parser.state.visibility = tag.text.to_sym
+          end
+        end
+      end
+    end
+  end
+end