etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/docstring_parser.rb

@@ -1,345 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-
-module YARD
-  # Parses text and creates a {Docstring} object to represent documentation
-  # for a {CodeObjects::Base}. To create a new docstring, you should initialize
-  # the parser and call {#parse} followed by {#to_docstring}.
-  #
-  # == Subclassing Notes
-  #
-  # The DocstringParser can be subclassed and subtituted during parsing by
-  # setting the {Docstring.default_parser} attribute with the name of the
-  # subclass. This allows developers to change the way docstrings are
-  # parsed, allowing for completely different docstring syntaxes.
-  #
-  # @example Creating a Docstring with a DocstringParser
-  #   DocstringParser.new.parse("text here").to_docstring
-  # @example Creating a Custom DocstringParser
-  #   # Parses docstrings backwards!
-  #   class ReverseDocstringParser
-  #     def parse_content(content)
-  #       super(content.reverse)
-  #     end
-  #   end
-  #
-  #   # Set the parser as default when parsing
-  #   YARD::Docstring.default_parser = ReverseDocstringParser
-  # @see #parse_content
-  # @since 0.8.0
-  class DocstringParser
-    # @return [String] the parsed text portion of the docstring,
-    #   with tags removed.
-    attr_accessor :text
-
-    # @return [String] the complete input string to the parser.
-    attr_accessor :raw_text
-
-    # @return [Array<Tag>] the list of meta-data tags identified
-    #   by the parser
-    attr_accessor :tags
-
-    # @return [Array<Directive>] a list of directives identified
-    #   by the parser. This list will not be passed on to the
-    #   Docstring object.
-    attr_accessor :directives
-
-    # @return [OpenStruct] any arbitrary state to be passed between
-    #   tags during parsing. Mainly used by directives to coordinate
-    #   behaviour (so that directives can be aware of other directives
-    #   used in a docstring).
-    attr_accessor :state
-
-    # @return [CodeObjects::Base, nil] the object associated with
-    #   the docstring being parsed. May be nil if the docstring is
-    #   not attached to any object.
-    attr_accessor :object
-
-    # @return [CodeObjects::Base, nil] the object referenced by
-    #   the docstring being parsed. May be nil if the docstring doesn't
-    #   refer to any object.
-    attr_accessor :reference
-
-    # @return [Handlers::Base, nil] the handler parsing this
-    #   docstring. May be nil if this docstring parser is not
-    #   initialized through
-    attr_accessor :handler
-
-    # @return [Tags::Library] the tag library being used to
-    #   identify registered tags in the docstring.
-    attr_accessor :library
-
-    # The regular expression to match the tag syntax
-    META_MATCH = /^@(!)?((?:\w\.?)+)(?:\s+(.*))?$/i
-
-    # @!group Creation and Conversion Methods
-
-    # Creates a new parser to parse docstring data
-    #
-    # @param [Tags::Library] library a tag library for recognizing
-    #   tags.
-    def initialize(library = Tags::Library.instance)
-      @text = ""
-      @raw_text = ""
-      @tags = []
-      @directives = []
-      @library = library
-      @object = nil
-      @reference = nil
-      @handler = nil
-      @state = OpenStruct.new
-    end
-
-    # @return [Docstring] translates parsed text into
-    #   a Docstring object.
-    def to_docstring
-      Docstring.new!(text, tags, object, raw_text, reference)
-    end
-
-    # @!group Parsing Methods
-
-    # Parses all content and returns itself.
-    #
-    # @param [String] content the docstring text to parse
-    # @param [CodeObjects::Base] object the object that the docstring
-    #   is attached to. Will be passed to directives to act on
-    #   this object.
-    # @param [Handlers::Base, nil] handler the handler object that is
-    #   parsing this object. May be nil if this parser is not being
-    #   called from a {Parser::SourceParser} context.
-    # @return [self] the parser object. To get the docstring,
-    #   call {#to_docstring}.
-    # @see #to_docstring
-    def parse(content, object = nil, handler = nil)
-      @object = object
-      @handler = handler
-      @reference, @raw_text = detect_reference(content)
-      text = parse_content(@raw_text)
-      # Remove trailing/leading whitespace / newlines
-      @text = text.gsub(/\A[\r\n\s]+|[\r\n\s]+\Z/, '')
-      call_directives_after_parse
-      post_process
-      self
-    end
-
-    # Parses a given block of text.
-    #
-    # @param [String] content the content to parse
-    # @note Subclasses can override this method to perform custom
-    #   parsing of content data.
-    def parse_content(content)
-      content = content.split(/\r?\n/) if content.is_a?(String)
-      return '' if !content || content.empty?
-      docstring = String.new("")
-
-      indent = content.first[/^\s*/].length
-      last_indent = 0
-      orig_indent = 0
-      directive = false
-      last_line = ""
-      tag_name = nil
-      tag_buf = []
-
-      (content + ['']).each_with_index do |line, index|
-        indent = line[/^\s*/].length
-        empty = (line =~ /^\s*$/ ? true : false)
-        done = content.size == index
-
-        if tag_name && (((indent < orig_indent && !empty) || done ||
-            (indent == 0 && !empty)) || (indent <= last_indent && line =~ META_MATCH))
-          buf = tag_buf.join("\n")
-          if directive || tag_is_directive?(tag_name)
-            directive = create_directive(tag_name, buf)
-            if directive
-              docstring << parse_content(directive.expanded_text).chomp
-            end
-          else
-            create_tag(tag_name, buf)
-          end
-          tag_name = nil
-          tag_buf = []
-          directive = false
-          orig_indent = 0
-        end
-
-        # Found a meta tag
-        if line =~ META_MATCH
-          directive = $1
-          tag_name = $2
-          tag_buf = [($3 || '')]
-        elsif tag_name && indent >= orig_indent && !empty
-          orig_indent = indent if orig_indent == 0
-          # Extra data added to the tag on the next line
-          last_empty = last_line =~ /^[ \t]*$/ ? true : false
-
-          tag_buf << '' if last_empty
-          tag_buf << line.gsub(/^[ \t]{#{orig_indent}}/, '')
-        elsif !tag_name
-          # Regular docstring text
-          docstring << line
-          docstring << "\n"
-        end
-
-        last_indent = indent
-        last_line = line
-      end
-
-      docstring
-    end
-
-    # @!group Parser Callback Methods
-
-    # Call post processing callbacks on parser.
-    # This is called implicitly by parser. Use this when
-    # manually configuring a {Docstring} object.
-    #
-    # @return [void]
-    def post_process
-      call_after_parse_callbacks
-    end
-
-    # @!group Tag Manipulation Methods
-
-    # Creates a tag from the {Tags::DefaultFactory tag factory}.
-    #
-    # To add an already created tag object, append it to {#tags}.
-    #
-    # @param [String] tag_name the tag name
-    # @param [String] tag_buf the text attached to the tag with newlines removed.
-    # @return [Tags::Tag, Tags::RefTag] a tag
-    def create_tag(tag_name, tag_buf = '')
-      if tag_buf =~ /\A\s*(?:(\S+)\s+)?\(\s*see\s+(\S+)\s*\)\s*\Z/
-        return create_ref_tag(tag_name, $1, $2)
-      end
-
-      if library.has_tag?(tag_name)
-        @tags += [library.tag_create(tag_name, tag_buf)].flatten
-      else
-        log.warn "Unknown tag @#{tag_name}" +
-                 (object ? " in file `#{object.file}` near line #{object.line}" : "")
-      end
-    rescue Tags::TagFormatError
-      log.warn "Invalid tag format for @#{tag_name}" +
-               (object ? " in file `#{object.file}` near line #{object.line}" : "")
-    end
-
-    # Creates a {Tags::RefTag}
-    def create_ref_tag(tag_name, name, object_name)
-      @tags << Tags::RefTagList.new(tag_name, P(object, object_name), name)
-    end
-
-    # Creates a new directive using the registered {#library}
-    # @return [Directive] the directive object that is created
-    def create_directive(tag_name, tag_buf)
-      if library.has_directive?(tag_name)
-        dir = library.directive_create(tag_name, tag_buf, self)
-        if dir.is_a?(Tags::Directive)
-          @directives << dir
-          dir
-        end
-      else
-        log.warn "Unknown directive @!#{tag_name}" +
-                 (object ? " in file `#{object.file}` near line #{object.line}" : "")
-        nil
-      end
-    rescue Tags::TagFormatError
-      log.warn "Invalid directive format for @!#{tag_name}" +
-               (object ? " in file `#{object.file}` near line #{object.line}" : "")
-      nil
-    end
-
-    # Backward compatibility to detect old tags that should be specified
-    # as directives in 0.8 and onward.
-    def tag_is_directive?(tag_name)
-      list = %w(attribute endgroup group macro method scope visibility)
-      list.include?(tag_name)
-    end
-
-    # Creates a callback that is called after a docstring is successfully
-    # parsed. Use this method to perform sanity checks on a docstring's
-    # tag data, or add any extra tags automatically to a docstring.
-    #
-    # @yield [parser] a block to be called after a docstring is parsed
-    # @yieldparam [DocstringParser] parser the docstring parser object
-    #   with all directives and tags created.
-    # @yieldreturn [void]
-    # @return [void]
-    def self.after_parse(&block)
-      after_parse_callbacks << block
-    end
-
-    # @return [Array<Proc>] the {after_parse} callback proc objects
-    def self.after_parse_callbacks
-      @after_parse_callbacks ||= []
-    end
-
-    # Define a callback to check that @param tags are properly named
-    after_parse do |parser|
-      next unless parser.object
-      next unless parser.object.is_a?(CodeObjects::MethodObject)
-      next if parser.object.is_alias?
-      names = parser.object.parameters.map {|l| l.first.gsub(/\W/, '') }
-      seen_names = []
-      infile_info = "\n    in file `#{parser.object.file}' " \
-                    "near line #{parser.object.line}"
-      parser.tags.each do |tag|
-        next if tag.is_a?(Tags::RefTagList) # we don't handle this yet
-        next unless tag.tag_name == "param"
-        if seen_names.include?(tag.name)
-          log.warn "@param tag has duplicate parameter name: " \
-                   "#{tag.name} #{infile_info}"
-        elsif names.include?(tag.name)
-          seen_names << tag.name
-        else
-          log.warn "@param tag has unknown parameter name: " \
-                   "#{tag.name} #{infile_info}"
-        end
-      end
-    end
-
-    private
-
-    def namespace
-      object && object.namespace
-    end
-
-    def detect_reference(content)
-      if content =~ /\A\s*\(see (\S+)\s*\)(?:\s|$)/
-        path = $1
-        extra = $'
-        [CodeObjects::Proxy.new(namespace, path), extra]
-      else
-        [nil, content]
-      end
-    end
-
-    # @!group Parser Callback Methods
-
-    # Calls the {Tags::Directive#after_parse} callback on all the
-    # created directives.
-    def call_directives_after_parse
-      directives.each(&:after_parse)
-    end
-
-    # Calls all {after_parse} callbacks
-    def call_after_parse_callbacks
-      self.class.after_parse_callbacks.each do |cb|
-        cb.call(self)
-      end
-    end
-
-    # Define a callback to check that @see tags do not use {}.
-    after_parse do |parser|
-      next unless parser.object
-
-      parser.tags.each_with_index do |tag, i|
-        next unless tag.tag_name == "see"
-        next unless "#{tag.name}#{tag.text}" =~ /\A\{.*\}\Z/
-        infile_info = "\n    in file `#{parser.object.file}' " \
-                      "near line #{parser.object.line}"
-        log.warn "@see tag (##{i + 1}) should not be wrapped in {} " \
-                 "(causes rendering issues): #{infile_info}"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/gem_index.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# Backward compatability for gem specification lookup
-# @see Gem::SourceIndex
-module YARD
-  module GemIndex
-    module_function
-
-    def find_all_by_name(*args)
-      if defined?(Gem::Specification) && Gem::Specification.respond_to?(:find_all_by_name)
-        Gem::Specification.find_all_by_name(*args)
-      else
-        Gem.source_index.find_name(*args)
-      end
-    end
-
-    def each(&block)
-      if defined?(Gem::Specification) && Gem::Specification.respond_to?(:each)
-        Gem::Specification.each(&block)
-      else
-        Gem.source_index.find_name('').each(&block)
-      end
-    end
-
-    def all
-      each.to_a
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/globals.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-# @group Global Convenience Methods
-
-# Shortcut for creating a YARD::CodeObjects::Proxy via a path
-#
-# @see YARD::CodeObjects::Proxy
-# @see YARD::Registry.resolve
-def P(namespace, name = nil, type = nil) # rubocop:disable Style/MethodName
-  if name.nil?
-    name = namespace
-    namespace = nil
-  end
-  YARD::Registry.resolve(namespace, name, false, true, type)
-end
-
-# The global {YARD::Logger} instance
-#
-# @return [YARD::Logger] the global {YARD::Logger} instance
-# @see YARD::Logger
-def log
-  YARD::Logger.instance
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/lib/yard/handlers/base.rb

@@ -1,595 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  module Handlers
-    # Raise this error when a handler should exit before completing.
-    # The exception will be silenced, allowing the next handler(s) in the
-    # queue to be executed.
-    # @since 0.8.4
-    class HandlerAborted < ::RuntimeError; end
-
-    # Raised during processing phase when a handler needs to perform
-    # an operation on an object's namespace but the namespace could
-    # not be resolved.
-    class NamespaceMissingError < Parser::UndocumentableError
-      # The object the error occurred on
-      # @return [CodeObjects::Base] a code object
-      attr_accessor :object
-
-      def initialize(object) @object = object end
-    end
-
-    # Handlers are pluggable semantic parsers for YARD's code generation
-    # phase. They allow developers to control what information gets
-    # generated by YARD, giving them the ability to, for instance, document
-    # any Ruby DSLs that a customized framework may use. A good example
-    # of this would be the ability to document and generate meta data for
-    # the 'describe' declaration of the RSpec testing framework by simply
-    # adding a handler for such a keyword. Similarly, any Ruby API that
-    # takes advantage of class level declarations could add these to the
-    # documentation in a very explicit format by treating them as first-
-    # class objects in any outputted documentation.
-    #
-    # == Overview of a Typical Handler Scenario
-    #
-    # Generally, a handler class will declare a set of statements which
-    # it will handle using the {handles} class declaration. It will then
-    # implement the {#process} method to do the work. The processing would
-    # usually involve the manipulation of the {#namespace}, {#owner}
-    # {CodeObjects::Base code objects} or the creation of new ones, in
-    # which case they should be registered by {#register}, a method that
-    # sets some basic attributes for the new objects.
-    #
-    # Handlers are usually simple and take up to a page of code to process
-    # and register a new object or add new attributes to the current +namespace+.
-    #
-    # == Setting up a Handler for Use
-    #
-    # A Handler is automatically registered when it is subclassed from the
-    # base class. The only other thing that needs to be done is to specify
-    # which statement the handler will process. This is done with the +handles+
-    # declaration, taking either a {Parser::Ruby::Legacy::RubyToken}, {String} or `Regexp`.
-    # Here is a simple example which processes module statements.
-    #
-    #   class MyModuleHandler < YARD::Handlers::Base
-    #     handles TkMODULE
-    #
-    #     def process
-    #       # do something
-    #     end
-    #   end
-    #
-    # == Processing Handler Data
-    #
-    # The goal of a specific handler is really up to the developer, and as
-    # such there is no real guideline on how to process the data. However,
-    # it is important to know where the data is coming from to be able to use
-    # it.
-    #
-    # === +statement+ Attribute
-    #
-    # The +statement+ attribute pertains to the {Parser::Ruby::Legacy::Statement} object
-    # containing a set of tokens parsed in by the parser. This is the main set
-    # of data to be analyzed and processed. The comments attached to the statement
-    # can be accessed by the {Parser::Ruby::Legacy::Statement#comments} method, but generally
-    # the data to be processed will live in the +tokens+ attribute. This list
-    # can be converted to a +String+ using +#to_s+ to parse the data with
-    # regular expressions (or other text processing mechanisms), if needed.
-    #
-    # === +namespace+ Attribute
-    #
-    # The +namespace+ attribute is a {CodeObjects::NamespaceObject namespace object}
-    # which represents the current namespace that the parser is in. For instance:
-    #
-    #   module SomeModule
-    #     class MyClass
-    #       def mymethod; end
-    #     end
-    #   end
-    #
-    # If a handler was to parse the 'class MyClass' statement, it would
-    # be necessary to know that it belonged inside the SomeModule module.
-    # This is the value that +namespace+ would return when processing such
-    # a statement. If the class was then entered and another handler was
-    # called on the method, the +namespace+ would be set to the 'MyClass'
-    # code object.
-    #
-    # === +owner+ Attribute
-    #
-    # The +owner+ attribute is similar to the +namespace+ attribute in that
-    # it also follows the scope of the code during parsing. However, a namespace
-    # object is loosely defined as a module or class and YARD has the ability
-    # to parse beyond module and class blocks (inside methods, for instance),
-    # so the +owner+ attribute would not be limited to modules and classes.
-    #
-    # To put this into context, the example from above will be used. If a method
-    # handler was added to the mix and decided to parse inside the method body,
-    # the +owner+ would be set to the method object but the namespace would remain
-    # set to the class. This would allow the developer to process any method
-    # definitions set inside a method (def x; def y; 2 end end) by adding them
-    # to the correct namespace (the class, not the method).
-    #
-    # In summary, the distinction between +namespace+ and +owner+ can be thought
-    # of as the difference between first-class Ruby objects (namespaces) and
-    # second-class Ruby objects (methods).
-    #
-    # === +visibility+ and +scope+ Attributes
-    #
-    # Mainly needed for parsing methods, the +visibility+ and +scope+ attributes
-    # refer to the public/protected/private and class/instance values (respectively)
-    # of the current parsing position.
-    #
-    # == Parsing Blocks in Statements
-    #
-    # In addition to parsing a statement and creating new objects, some
-    # handlers may wish to continue parsing the code inside the statement's
-    # block (if there is one). In this context, a block means the inside
-    # of any statement, be it class definition, module definition, if
-    # statement or classic 'Ruby block'.
-    #
-    # For example, a class statement would be "class MyClass" and the block
-    # would be a list of statements including the method definitions inside
-    # the class. For a class handler, the programmer would execute the
-    # {#parse_block} method to continue parsing code inside the block, with
-    # the +namespace+ now pointing to the class object the handler created.
-    #
-    # YARD has the ability to continue into any block: class, module, method,
-    # even if statements. For this reason, the block parsing method must be
-    # invoked explicitly out of efficiency sake.
-    #
-    # @abstract Subclass this class to provide a handler for YARD to use
-    #   during the processing phase.
-    #
-    # @see CodeObjects::Base
-    # @see CodeObjects::NamespaceObject
-    # @see handles
-    # @see #namespace
-    # @see #owner
-    # @see #register
-    # @see #parse_block
-    class Base
-      # For accessing convenience, eg. "MethodObject"
-      # instead of the full qualified namespace
-      include YARD::CodeObjects
-
-      include Parser
-
-      class << self
-        # Clear all registered subclasses. Testing purposes only
-        # @return [void]
-        def clear_subclasses
-          @@subclasses = []
-        end
-
-        # Returns all registered handler subclasses.
-        # @return [Array<Base>] a list of handlers
-        def subclasses
-          @@subclasses ||= []
-        end
-
-        def inherited(subclass)
-          @@subclasses ||= []
-          @@subclasses << subclass
-        end
-
-        # Declares the statement type which will be processed
-        # by this handler.
-        #
-        # A match need not be unique to a handler. Multiple
-        # handlers can process the same statement. However,
-        # in this case, care should be taken to make sure that
-        # {#parse_block} would only be executed by one of
-        # the handlers, otherwise the same code will be parsed
-        # multiple times and slow YARD down.
-        #
-        # @param [Parser::RubyToken, Symbol, String, Regexp] matches
-        #   statements that match the declaration will be
-        #   processed by this handler. A {String} match is
-        #   equivalent to a +/\Astring/+ regular expression
-        #   (match from the beginning of the line), and all
-        #   token matches match only the first token of the
-        #   statement.
-        #
-        def handles(*matches)
-          (@handlers ||= []).concat(matches)
-        end
-
-        # This class is implemented by {Ruby::Base} and {Ruby::Legacy::Base}.
-        # To implement a base handler class for another language, implement
-        # this method to return true if the handler should process the given
-        # statement object. Use {handlers} to enumerate the matchers declared
-        # for the handler class.
-        #
-        # @param statement a statement object or node (depends on language type)
-        # @return [Boolean] whether or not this handler object should process
-        #   the given statement
-        def handles?(statement) # rubocop:disable Lint/UnusedMethodArgument
-          raise NotImplementedError, "override #handles? in a subclass"
-        end
-
-        # @return [Array] a list of matchers for the handler object.
-        # @see handles?
-        def handlers
-          @handlers ||= []
-        end
-
-        # Declares that the handler should only be called when inside a
-        # {CodeObjects::NamespaceObject}, not a method body.
-        #
-        # @return [void]
-        def namespace_only
-          @namespace_only = true
-        end
-
-        # @return [Boolean] whether the handler should only be processed inside
-        #   a namespace.
-        def namespace_only?
-          @namespace_only ||= false
-        end
-
-        # Declares that a handler should only be called when inside a filename
-        # by its basename or a regex match for the full path.
-        #
-        # @param [String, Regexp] filename a matching filename or regex
-        # @return [void]
-        # @since 0.6.2
-        def in_file(filename)
-          (@in_files ||= []) << filename
-        end
-
-        # @return [Boolean] whether the filename matches the declared file
-        #   match for a handler. If no file match is specified, returns true.
-        # @since 0.6.2
-        def matches_file?(filename)
-          @in_files ||= nil # avoid ruby warnings
-          return true unless @in_files
-          @in_files.any? do |in_file|
-            case in_file
-            when String
-              File.basename(filename) == in_file
-            when Regexp
-              filename =~ in_file
-            else
-              true
-            end
-          end
-        end
-
-        # Generates a +process+ method, equivalent to +def process; ... end+.
-        # Blocks defined with this syntax will be wrapped inside an anonymous
-        # module so that the handler class can be extended with mixins that
-        # override the +process+ method without alias chaining.
-        #
-        # @!macro yard.handlers.process
-        #   @!method process
-        #   Main processing callback
-        #   @return [void]
-        # @see #process
-        # @return [void]
-        # @since 0.5.4
-        def process(&block)
-          mod = Module.new
-          mod.send(:define_method, :process, &block)
-          include mod
-        end
-      end
-
-      def initialize(source_parser, stmt)
-        @parser = source_parser
-        @statement = stmt
-      end
-
-      # The main handler method called by the parser on a statement
-      # that matches the {handles} declaration.
-      #
-      # Subclasses should override this method to provide the handling
-      # functionality for the class.
-      #
-      # @return [Array<CodeObjects::Base>, CodeObjects::Base, Object]
-      #   If this method returns a code object (or a list of them),
-      #   they are passed to the +#register+ method which adds basic
-      #   attributes. It is not necessary to return any objects and in
-      #   some cases you may want to explicitly avoid the returning of
-      #   any objects for post-processing by the register method.
-      #
-      # @see handles
-      # @see #register
-      #
-      def process
-        raise NotImplementedError, "#{self} did not implement a #process method for handling."
-      end
-
-      # Parses the semantic "block" contained in the statement node.
-      #
-      # @abstract Subclasses should call {Processor#process parser.process}
-      def parse_block(*)
-        raise NotImplementedError, "#{self} did not implement a #parse_block method for handling"
-      end
-
-      # @return [Processor] the processor object that manages all global state
-      #   during handling.
-      attr_reader :parser
-
-      # @return [Object] the statement object currently being processed. Usually
-      #   refers to one semantic language statement, though the strict definition
-      #   depends on the parser used.
-      attr_reader :statement
-
-      # (see Processor#owner)
-      attr_accessor :owner
-
-      # (see Processor#namespace)
-      attr_accessor :namespace
-
-      # (see Processor#visibility)
-      attr_accessor :visibility
-
-      # (see Processor#scope)
-      attr_accessor :scope
-
-      # (see Processor#globals)
-      attr_reader :globals
-
-      # (see Processor#extra_state)
-      attr_reader :extra_state
-
-      undef owner, owner=, namespace, namespace=
-      undef visibility, visibility=, scope, scope=
-      undef globals, extra_state
-
-      def owner; parser.owner end
-      def owner=(v) parser.owner = v end
-      def namespace; parser.namespace end
-      def namespace=(v); parser.namespace = v end
-      def visibility; parser.visibility end
-      def visibility=(v); parser.visibility = v end
-      def scope; parser.scope end
-      def scope=(v); parser.scope = v end
-      def globals; parser.globals end
-      def extra_state; parser.extra_state end
-
-      # Aborts a handler by raising {Handlers::HandlerAborted}.
-      # An exception will only be logged in debugging mode for
-      # this kind of handler exit.
-      #
-      # @since 0.8.4
-      def abort!
-        raise Handlers::HandlerAborted
-      end
-
-      # Executes a given block with specific state values for {#owner},
-      # {#namespace} and {#scope}.
-      #
-      # @option opts [CodeObjects::NamespaceObject] :namespace (value of #namespace)
-      #   the namespace object that {#namespace} will be equal to for the
-      #   duration of the block.
-      # @option opts [Symbol] :scope (:instance)
-      #   the scope for the duration of the block.
-      # @option opts [CodeObjects::Base] :owner (value of #owner)
-      #   the owner object (method) for the duration of the block
-      # @yield a block to execute with the given state values.
-      def push_state(opts = {})
-        opts = {
-          :namespace => namespace,
-          :scope => :instance,
-          :owner => owner || namespace,
-          :visibility => nil
-        }.update(opts)
-
-        ns = namespace
-        vis = visibility
-        sc = scope
-        oo = owner
-        self.namespace = opts[:namespace]
-        self.visibility = opts[:visibility] || :public
-        self.scope = opts[:scope]
-        self.owner = opts[:owner]
-
-        yield
-
-        self.namespace = ns
-        self.visibility = vis
-        self.scope = sc
-        self.owner = oo
-      end
-
-      # Do some post processing on a list of code objects.
-      # Adds basic attributes to the list of objects like
-      # the filename, line number, {CodeObjects::Base#dynamic},
-      # source code and {CodeObjects::Base#docstring},
-      # but only if they don't exist.
-      #
-      # @param [Array<CodeObjects::Base>] objects
-      #   the list of objects to post-process.
-      #
-      # @return [CodeObjects::Base, Array<CodeObjects::Base>]
-      #   returns whatever is passed in, for chainability.
-      #
-      def register(*objects)
-        objects.flatten.each do |object|
-          next unless object.is_a?(CodeObjects::Base)
-          register_ensure_loaded(object)
-          yield(object) if block_given?
-          register_file_info(object)
-          register_source(object)
-          register_visibility(object)
-          register_docstring(object)
-          register_group(object)
-          register_dynamic(object)
-          register_module_function(object)
-        end
-        objects.size == 1 ? objects.first : objects
-      end
-
-      # Ensures that the object's namespace is loaded before attaching it
-      # to the namespace.
-      #
-      # @param [CodeObjects::Base] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_ensure_loaded(object)
-        ensure_loaded!(object.namespace)
-        object.namespace.children << object
-      rescue NamespaceMissingError
-        nil # noop
-      end
-
-      # Registers the file/line of the declaration with the object
-      #
-      # @param [CodeObjects::Base] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_file_info(object, file = parser.file, line = statement.line, comments = statement.comments)
-        object.add_file(file, line, comments)
-      end
-
-      # Registers any docstring found for the object and expands macros
-      #
-      # @param [CodeObjects::Base] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_docstring(object, docstring = statement.comments, stmt = statement)
-        docstring = docstring.join("\n") if Array === docstring
-        parser = Docstring.parser
-        parser.parse(docstring || "", object, self)
-
-        if object && docstring
-          object.docstring = parser.to_docstring
-
-          # Add hash_flag/line_range
-          if stmt
-            object.docstring.hash_flag = stmt.comments_hash_flag
-            object.docstring.line_range = stmt.comments_range
-          end
-        end
-
-        register_transitive_tags(object)
-      end
-
-      # Registers the object as being inside a specific group
-      #
-      # @param [CodeObjects::Base] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_group(object, group = extra_state.group)
-        if group
-          unless object.namespace.is_a?(Proxy)
-            object.namespace.groups |= [group]
-          end
-          object.group = group
-        end
-      end
-
-      # Registers any transitive tags from the namespace on the object
-      #
-      # @param [CodeObjects::Base, nil] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_transitive_tags(object)
-        return unless object && !object.namespace.is_a?(Proxy)
-        Tags::Library.transitive_tags.each do |tag|
-          next unless object.namespace.has_tag?(tag)
-          next if object.has_tag?(tag)
-          object.add_tag(*object.namespace.tags(tag))
-        end
-      end
-
-      # @param [CodeObjects::Base] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_source(object, source = statement, type = parser.parser_type)
-        return unless object.is_a?(MethodObject)
-        object.source ||= source
-        object.source_type = type
-      end
-
-      # Registers visibility on a method object. If the object does not
-      # respond to setting visibility, nothing is done.
-      #
-      # @param [#visibility=] object the object to register
-      # @param [Symbol] visibility the visibility to set on the object
-      # @since 0.8.0
-      def register_visibility(object, visibility = self.visibility)
-        return unless object.respond_to?(:visibility=)
-        return if object.is_a?(NamespaceObject)
-        object.visibility = visibility
-      end
-
-      # Registers the same method information on the module function, if
-      # the object was defined as a module function.
-      #
-      # @param [CodeObjects::Base] object the possible module function object
-      #   to copy data for
-      # @since 0.8.0
-      def register_module_function(object)
-        return unless object.is_a?(MethodObject)
-        return unless object.module_function?
-        modobj = MethodObject.new(object.namespace, object.name)
-        object.copy_to(modobj)
-        modobj.visibility = :private # rubocop:disable Lint/UselessSetterCall
-      end
-
-      # Registers the object as dynamic if the object is defined inside
-      # a method or block (owner != namespace)
-      #
-      # @param [CodeObjects::Base] object the object to register
-      # @return [void]
-      # @since 0.8.0
-      def register_dynamic(object)
-        object.dynamic = true if owner != namespace
-      end
-
-      # Ensures that a specific +object+ has been parsed and loaded into the
-      # registry. This is necessary when adding data to a namespace, for instance,
-      # since the namespace may not have been processed yet (it can be located
-      # in a file that has not been handled).
-      #
-      # Calling this method defers the handler until all other files have been
-      # processed. If the object gets resolved, the rest of the handler continues,
-      # otherwise an exception is raised.
-      #
-      # @example Adding a mixin to the String class programmatically
-      #   ensure_loaded! P('String')
-      #   # "String" is now guaranteed to be loaded
-      #   P('String').mixins << P('MyMixin')
-      #
-      # @param [Proxy, CodeObjects::Base] object the object to resolve.
-      # @param [Integer] max_retries the number of times to defer the handler
-      #   before raising a +NamespaceMissingError+.
-      # @raise [NamespaceMissingError] if the object is not resolved within
-      #   +max_retries+ attempts, this exception is raised and the handler
-      #   finishes processing.
-      def ensure_loaded!(object, max_retries = 1)
-        return if object.root?
-        return object unless object.is_a?(Proxy)
-
-        retries = 0
-        while object.is_a?(Proxy)
-          raise NamespaceMissingError, object if retries > max_retries
-          log.debug "Missing object #{object} in file `#{parser.file}', moving it to the back of the line."
-          parser.parse_remaining_files
-          retries += 1
-        end
-        object
-      end
-
-      # @group Macro Support
-
-      # @abstract Implement this method to return the parameters in a method call
-      #   statement. It should return an empty list if the statement is not a
-      #   method call.
-      # @return [Array<String>] a list of argument names
-      def call_params
-        raise NotImplementedError
-      end
-
-      # @abstract Implement this method to return the method being called in
-      #   a method call. It should return nil if the statement is not a method
-      #   call.
-      # @return [String] the method name being called
-      # @return [nil] if the statement is not a method call
-      def caller_method
-        raise NotImplementedError
-      end
-    end
-  end
-end