RubyGems - mango - Versions diffs - 0.8.0 → 0.9.0 - Mend

mango 0.8.0 → 0.9.0

Files changed (2510) hide show

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

@@ -1,8 +0,0 @@
-<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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/default/layout/html/setup.rb DELETED

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

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

@@ -1,4 +0,0 @@
-<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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/default/method_details/html/setup.rb DELETED

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

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

@@ -1,13 +0,0 @@
-<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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/headers.erb DELETED

@@ -1,26 +0,0 @@
-<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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/library_list.erb DELETED

@@ -1,12 +0,0 @@
-<!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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/library_list/html/setup.rb DELETED

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

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

	@@ -1,2 +0,0 @@
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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/processing/html/processing.erb DELETED

@@ -1,51 +0,0 @@
-<!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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/processing/html/setup.rb DELETED

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

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

@@ -1,18 +0,0 @@
-<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.1.0/gems/yard-0.8.7.3/lib/yard/server/templates/doc_server/search/html/setup.rb DELETED

@@ -1,8 +0,0 @@
-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.1.0/gems/yard-0.8.7.3/lib/yard/server/webrick_adapter.rb DELETED

@@ -1,43 +0,0 @@
-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.1.0/gems/yard-0.8.7.3/lib/yard/tags/default_factory.rb DELETED

@@ -1,176 +0,0 @@
-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.1.0/gems/yard-0.8.7.3/lib/yard/tags/default_tag.rb DELETED

@@ -1,12 +0,0 @@
-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.1.0/gems/yard-0.8.7.3/lib/yard/tags/directives.rb DELETED

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