etude_for_ruby 0.1.4 → 0.2.3

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-class YARD::Handlers::C::MixinHandler < YARD::Handlers::C::Base
-  MATCH = /rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/
-  handles MATCH
-  statement_class BodyStatement
-
-  process do
-    statement.source.scan(MATCH) do |klass_var, mixin_var|
-      namespace = namespace_for_variable(klass_var)
-      ensure_loaded!(namespace)
-
-      var = namespace_for_variable(mixin_var)
-      if var
-        namespace.mixins(:instance) << var
-      else
-        raise YARD::Parser::UndocumentableError,
-          "CRuby mixin for unrecognized variable '#{mixin_var}'"
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-class YARD::Handlers::C::ModuleHandler < YARD::Handlers::C::Base
-  MATCH1 = /([\w\.]+)\s* = \s*rb_define_module\s*\(\s*"([\w:]+)"\s*\)/mx
-  MATCH2 = /([\w\.]+)\s* = \s*rb_define_module_under\s*\(\s*(\w+),\s*"(\w+)"\s*\)/mx
-  handles MATCH1
-  handles MATCH2
-  statement_class BodyStatement
-
-  process do
-    statement.source.scan(MATCH1) do |var_name, module_name|
-      handle_module(var_name, module_name)
-    end
-    statement.source.scan(MATCH2) do |var_name, in_module, module_name|
-      handle_module(var_name, module_name, in_module)
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-# Parses comments
-class YARD::Handlers::C::OverrideCommentHandler < YARD::Handlers::C::Base
-  handles(/./)
-  statement_class Comment
-
-  process do
-    return if statement.overrides.empty?
-    statement.overrides.each do |type, name|
-      override_comments << [name, statement]
-      obj = nil
-      case type
-      when :class
-        name, superclass = *name.split(/\s*<\s*/)
-        obj = YARD::CodeObjects::ClassObject.new(:root, name)
-        obj.superclass = "::#{superclass}" if superclass
-      when :module
-        obj = YARD::CodeObjects::ModuleObject.new(:root, name)
-      end
-      register(obj)
-    end
-  end
-
-  def register_docstring(object, docstring = statement.source, stmt = statement)
-    super
-  end
-
-  def register_file_info(object, file = parser.file, line = statement.line, comments = statement.comments)
-    super
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-class YARD::Handlers::C::PathHandler < YARD::Handlers::C::Base
-  MATCH = /([\w\.]+)\s* = \s*rb_path2class\s*\(\s*"([\w:]+)"\)/mx
-  handles MATCH
-
-  process do
-    statement.source.scan(MATCH) do |var_name, path|
-      namespaces[var_name] = P(path)
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-class YARD::Handlers::C::StructHandler < YARD::Handlers::C::Base
-  MATCH = /([\w\.]+)\s*=\s*(?:rb_struct_define_without_accessor)\s*
-           \(\s*"([\w:]+)"\s*,\s*(\w+)\s*/mx
-  handles MATCH
-  statement_class BodyStatement
-
-  process do
-    statement.source.scan(MATCH) do |var_name, class_name, parent|
-      handle_class(var_name, class_name, parent)
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-# Keeps track of function bodies for symbol lookup during Ruby method declarations
-class YARD::Handlers::C::SymbolHandler < YARD::Handlers::C::Base
-  MATCH = /\A\s*(?:(?:\w+)\s+)?(?:intern\s+)?VALUE\s+(\w+)\s*\(/
-  handles MATCH
-  statement_class ToplevelStatement
-  process { symbols[statement.source[MATCH, 1]] = statement }
-end

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

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-
-module YARD
-  module Handlers
-    # Iterates over all statements in a file and delegates them to the
-    # {Handlers::Base} objects that are registered to handle the statement.
-    #
-    # This class is passed to each handler and keeps overall processing state.
-    # For example, if the {#visibility} is set in a handler, all following
-    # statements will have access to this state. This allows "public",
-    # "protected" and "private" statements to be handled in classes and modules.
-    # In addition, the {#namespace} can be set during parsing to control
-    # where objects are being created from. You can also access extra stateful
-    # properties that any handler can set during the duration of the post
-    # processing of a file from {#extra_state}. If you need to access state
-    # across different files, look at {#globals}.
-    #
-    # @see Handlers::Base
-    class Processor
-      class << self
-        # Registers a new namespace for handlers of the given type.
-        # @since 0.6.0
-        def register_handler_namespace(type, ns)
-          namespace_for_handler[type] = ns
-        end
-
-        # @return [Hash] a list of registered parser type extensions
-        # @private
-        # @since 0.6.0
-        attr_reader :namespace_for_handler
-        undef namespace_for_handler
-        def namespace_for_handler; @@parser_type_extensions ||= {} end
-      end
-
-      register_handler_namespace :ruby, Ruby
-      register_handler_namespace :ruby18, Ruby::Legacy
-      register_handler_namespace :c, C
-
-      # @return [String] the filename
-      attr_accessor :file
-
-      # @return [CodeObjects::NamespaceObject] the current namespace
-      attr_accessor :namespace
-
-      # @return [Symbol] the current visibility (public, private, protected)
-      attr_accessor :visibility
-
-      # @return [Symbol] the current scope (class, instance)
-      attr_accessor :scope
-
-      # @return [CodeObjects::Base, nil] unlike the namespace, the owner
-      #   is a non-namespace object that should be stored between statements.
-      #   For instance, when parsing a method body, the {CodeObjects::MethodObject}
-      #   is set as the owner, in case any extra method information is processed.
-      attr_accessor :owner
-
-      # @return [Symbol] the parser type (:ruby, :ruby18, :c)
-      attr_accessor :parser_type
-
-      # Handlers can share state for the entire post processing stage through
-      # this attribute. Note that post processing stage spans multiple files.
-      # To share state only within a single file, use {#extra_state}
-      #
-      # @example Sharing state among two handlers
-      #   class Handler1 < YARD::Handlers::Ruby::Base
-      #     handles :class
-      #     process { globals.foo = :bar }
-      #   end
-      #
-      #   class Handler2 < YARD::Handlers::Ruby::Base
-      #     handles :method
-      #     process { puts globals.foo }
-      #   end
-      # @return [OpenStruct] global shared state for post-processing stage
-      # @see #extra_state
-      attr_accessor :globals
-
-      # Share state across different handlers inside of a file.
-      # This attribute is similar to {#visibility}, {#scope}, {#namespace}
-      # and {#owner}, in that they all maintain state across all handlers
-      # for the entire source file. Use this attribute to store any data
-      # your handler might need to save during the parsing of a file. If
-      # you need to save state across files, see {#globals}.
-      #
-      # @return [OpenStruct] an open structure that can store arbitrary data
-      # @see #globals
-      attr_accessor :extra_state
-
-      # Creates a new Processor for a +file+.
-      # @param [SourceParser] parser the parser used to initialize the processor
-      def initialize(parser)
-        @file = parser.file || "(stdin)"
-        @namespace = YARD::Registry.root
-        @visibility = :public
-        @scope = :instance
-        @owner = @namespace
-        @parser_type = parser.parser_type
-        @handlers_loaded = {}
-        @globals = parser.globals || OpenStruct.new
-        @extra_state = OpenStruct.new
-        load_handlers
-      end
-
-      # Processes a list of statements by finding handlers to process each
-      # one.
-      #
-      # @param [Array] statements a list of statements
-      # @return [void]
-      def process(statements)
-        statements.each_with_index do |stmt, _index|
-          find_handlers(stmt).each do |handler|
-            begin
-              handler.new(self, stmt).process
-            rescue HandlerAborted
-              log.debug "#{handler} cancelled from #{caller.last}"
-              log.debug "\tin file '#{file}':#{stmt.line}:\n\n" + stmt.show + "\n"
-            rescue NamespaceMissingError => missingerr
-              log.warn "The #{missingerr.object.type} #{missingerr.object.path} has not yet been recognized.\n" \
-                       "If this class/method is part of your source tree, this will affect your documentation results.\n" \
-                       "You can correct this issue by loading the source file for this object before `#{file}'\n"
-            rescue Parser::UndocumentableError => undocerr
-              log.warn "in #{handler}: Undocumentable #{undocerr.message}\n" \
-                       "\tin file '#{file}':#{stmt.line}:\n\n" + stmt.show + "\n"
-            rescue => e
-              log.error "Unhandled exception in #{handler}:\n" \
-                        "  in `#{file}`:#{stmt.line}:\n\n#{stmt.show}\n"
-              log.backtrace(e)
-            end
-          end
-        end
-      end
-
-      # Continue parsing the remainder of the files in the +globals.ordered_parser+
-      # object. After the remainder of files are parsed, processing will continue
-      # on the current file.
-      #
-      # @return [void]
-      # @see Parser::OrderedParser
-      def parse_remaining_files
-        if globals.ordered_parser
-          globals.ordered_parser.parse
-          log.debug("Re-processing #{@file}...")
-        end
-      end
-
-      # Searches for all handlers in {Base.subclasses} that match the +statement+
-      #
-      # @param statement the statement object to match.
-      # @return [Array<Base>] a list of handlers to process the statement with.
-      def find_handlers(statement)
-        Base.subclasses.find_all do |handler|
-          handler_base_class > handler &&
-            (handler.namespace_only? ? owner.is_a?(CodeObjects::NamespaceObject) : true) &&
-            handles?(handler, statement)
-        end
-      end
-
-      private
-
-      def handles?(handler, statement)
-        return false unless handler.matches_file?(file)
-        if handler.method(:handles?).arity == 1
-          handler.handles?(statement)
-        elsif [-1, 2].include?(handler.method(:handles?).arity)
-          handler.handles?(statement, self)
-        end
-      end
-
-      # Returns the handler base class
-      # @return [Base] the base class
-      def handler_base_class
-        handler_base_namespace.const_get(:Base)
-      end
-
-      # The module holding the handlers to be loaded
-      #
-      # @return [Module] the module containing the handlers depending on
-      #   {#parser_type}.
-      def handler_base_namespace
-        self.class.namespace_for_handler[parser_type]
-      end
-
-      # Loads handlers from {#handler_base_namespace}. This ensures that
-      # Ruby1.9 handlers are never loaded into 1.8; also lowers the amount
-      # of modules that are loaded
-      # @return [void]
-      def load_handlers
-        return if @handlers_loaded[parser_type]
-        handler_base_namespace.constants.each do |c|
-          const = handler_base_namespace.const_get(c)
-          unless Handlers::Base.subclasses.include?(const)
-            Handlers::Base.subclasses << const
-          end
-        end
-        @handlers_loaded[parser_type] = true
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-# Handles alias and alias_method calls
-class YARD::Handlers::Ruby::AliasHandler < YARD::Handlers::Ruby::Base
-  handles :alias, method_call(:alias_method)
-  namespace_only
-
-  process do
-    names = []
-    if statement.type == :alias
-      names = statement.map {|o| o.jump(:ident, :op, :kw, :const).source }
-    elsif statement.call?
-      statement.parameters(false).each do |obj|
-        case obj.type
-        when :symbol_literal, :dyna_symbol
-          names << obj.jump(:ident, :op, :kw, :const).source
-        when :string_literal
-          names << obj.jump(:string_content).source
-        end
-      end
-    end
-    raise YARD::Parser::UndocumentableError, "alias/alias_method" if names.size != 2
-
-    new_meth = names[0].to_sym
-    old_meth = names[1].to_sym
-    old_obj = namespace.child(:name => old_meth, :scope => scope)
-    new_obj = register MethodObject.new(namespace, new_meth, scope) do |o|
-      o.add_file(parser.file, statement.line)
-    end
-    namespace.aliases[new_obj] = old_meth
-
-    if old_obj
-      new_obj.signature = old_obj.signature
-      new_obj.source = old_obj.source
-      comments = [old_obj.docstring.to_raw, statement.comments].join("\n")
-      doc = YARD::Docstring.parser.parse(comments, new_obj, self)
-      new_obj.docstring = doc.to_docstring
-      new_obj.docstring.line_range = statement.comments_range
-      new_obj.docstring.hash_flag = statement.comments_hash_flag
-      new_obj.docstring.object = new_obj
-    else
-      new_obj.signature = "def #{new_meth}" # this is all we know.
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-# Handles +attr_*+ statements in modules/classes
-class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:attr)
-  handles method_call(:attr_reader)
-  handles method_call(:attr_writer)
-  handles method_call(:attr_accessor)
-  namespace_only
-
-  process do
-    return if statement.type == :var_ref || statement.type == :vcall
-    read = true
-    write = false
-    params = statement.parameters(false).dup
-
-    # Change read/write based on attr_reader/writer/accessor
-    case statement.method_name(true)
-    when :attr
-      # In the case of 'attr', the second parameter (if given) isn't a symbol.
-      if params.size == 2
-        write = true if params.pop == s(:var_ref, s(:kw, "true"))
-      end
-    when :attr_accessor
-      write = true
-    when :attr_reader
-      # change nothing
-    when :attr_writer
-      read = false
-      write = true
-    end
-
-    # Add all attributes
-    validated_attribute_names(params).each do |name|
-      namespace.attributes[scope][name] ||= SymbolHash[:read => nil, :write => nil]
-
-      # Show their methods as well
-      {:read => name, :write => "#{name}="}.each do |type, meth|
-        if type == :read ? read : write
-          o = MethodObject.new(namespace, meth, scope)
-          if type == :write
-            o.parameters = [['value', nil]]
-            src = "def #{meth}(value)"
-            full_src = "#{src}\n  @#{name} = value\nend"
-            doc = "Sets the attribute #{name}\n@param value the value to set the attribute #{name} to."
-          else
-            src = "def #{meth}"
-            full_src = "#{src}\n  @#{name}\nend"
-            doc = "Returns the value of attribute #{name}"
-          end
-          o.source ||= full_src
-          o.signature ||= src
-          register(o)
-          o.docstring = doc if o.docstring.blank?(false)
-
-          # Regsiter the object explicitly
-          namespace.attributes[scope][name][type] = o
-        else
-          obj = namespace.children.find {|other| other.name == meth.to_sym && other.scope == scope }
-
-          # register an existing method as attribute
-          namespace.attributes[scope][name][type] = obj if obj
-        end
-      end
-    end
-  end
-
-  protected
-
-  # Strips out any non-essential arguments from the attr statement.
-  #
-  # @param [Array<Parser::Ruby::AstNode>] params a list of the parameters
-  #   in the attr call.
-  # @return [Array<String>] the validated attribute names
-  # @raise [Parser::UndocumentableError] if the arguments are not valid.
-  def validated_attribute_names(params)
-    params.map do |obj|
-      case obj.type
-      when :symbol_literal
-        obj.jump(:ident, :op, :kw, :const).source
-      when :string_literal
-        obj.jump(:string_content).source
-      else
-        raise YARD::Parser::UndocumentableError, obj.source
-      end
-    end
-  end
-end

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

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  module Handlers
-    module Ruby
-      # To implement a custom handler matcher, subclass this class and implement
-      # {#matches?} to return whether a node matches the handler.
-      #
-      # @example A Custom Handler Matcher Extension
-      #   # Implements a handler that checks for a specific string
-      #   # in the node's source.
-      #   class MyExtension < HandlesExtension
-      #     def matches?(node) node.source.include?(name) end
-      #   end
-      #
-      #   # This handler will handle any node where the source includes 'foo'
-      #   class MyHandler < Handlers::Ruby::Base
-      #     handles MyExtension.new('foo')
-      #   end
-      class HandlesExtension
-        # Creates a new extension with a specific matcher value +name+
-        # @param [Object] name the matcher value to check against {#matches?}
-        def initialize(name) @name = name end
-
-        # Tests if the node matches the handler
-        # @param [Parser::Ruby::AstNode] node a Ruby node
-        # @return [Boolean] whether the +node+ matches the handler
-        def matches?(node) # rubocop:disable Lint/UnusedMethodArgument
-          raise NotImplementedError
-        end
-
-        protected
-
-        # @return [String] the extension matcher value
-        attr_reader :name
-      end
-
-      class MethodCallWrapper < HandlesExtension
-        def matches?(node)
-          case node.type
-          when :var_ref
-            if !node.parent || node.parent.type == :list
-              return true if node[0].type == :ident && (name.nil? || node[0][0] == name)
-            end
-          when :fcall, :command, :vcall
-            return true if name.nil? || node[0][0] == name
-          when :call, :command_call
-            return true if name.nil? || node[2][0] == name
-          end
-          false
-        end
-      end
-
-      class TestNodeWrapper < HandlesExtension
-        def matches?(node) !node.send(name).is_a?(FalseClass) end
-      end
-
-      # This is the base handler class for the new-style (1.9) Ruby parser.
-      # All handlers that subclass this base class will be used when the
-      # new-style parser is used. For implementing legacy handlers, see
-      # {Legacy::Base}.
-      #
-      # @abstract See {Handlers::Base} for subclassing information.
-      # @see Handlers::Base
-      # @see Legacy::Base
-      class Base < Handlers::Base
-        class << self
-          include Parser::Ruby
-
-          # @group Statement Matcher Extensions
-
-          # Matcher for handling any type of method call. Method calls can
-          # be expressed by many {AstNode} types depending on the syntax
-          # with which it is called, so YARD allows you to use this matcher
-          # to simplify matching a method call.
-          #
-          # @example Match the "describe" method call
-          #   handles method_call(:describe)
-          #
-          #   # The following will be matched:
-          #   # describe(...)
-          #   # object.describe(...)
-          #   # describe "argument" do ... end
-          #
-          # @param [#to_s] name matches the method call of this name
-          # @return [void]
-          def method_call(name = nil)
-            MethodCallWrapper.new(name ? name.to_s : nil)
-          end
-
-          # Matcher for handling a node with a specific meta-type. An {AstNode}
-          # has a {AstNode#type} to define its type but can also be associated
-          # with a set of types. For instance, +:if+ and +:unless+ are both
-          # of the meta-type +:condition+.
-          #
-          # A meta-type is any method on the {AstNode} class ending in "?",
-          # though you should not include the "?" suffix in your declaration.
-          # Some examples are: "condition", "call", "literal", "kw", "token",
-          # "ref".
-          #
-          # @example Handling any conditional statement (if, unless)
-          #   handles meta_type(:condition)
-          # @param [Symbol] type the meta-type to match. A meta-type can be
-          #   any method name + "?" that {AstNode} responds to.
-          # @return [void]
-          def meta_type(type)
-            TestNodeWrapper.new(type.to_s + "?")
-          end
-
-          # @group Testing for a Handler
-
-          # @return [Boolean] whether or not an {AstNode} object should be
-          #   handled by this handler
-          def handles?(node)
-            handlers.any? do |a_handler|
-              case a_handler
-              when Symbol
-                a_handler == node.type
-              when String
-                node.source == a_handler
-              when Regexp
-                node.source =~ a_handler
-              when Parser::Ruby::AstNode
-                a_handler == node
-              when HandlesExtension
-                a_handler.matches?(node)
-              end
-            end
-          end
-        end
-
-        include Parser::Ruby
-
-        # @group Parsing an Inner Block
-
-        def parse_block(inner_node, opts = {})
-          push_state(opts) do
-            nodes = inner_node.type == :list ? inner_node.children : [inner_node]
-            parser.process(nodes)
-          end
-        end
-
-        # @group Macro Handling
-
-        def call_params
-          return [] unless statement.respond_to?(:parameters)
-          statement.parameters(false).compact.map do |param|
-            if param.type == :list
-              param.map {|n| n.jump(:ident, :kw, :tstring_content).source }
-            else
-              param.jump(:ident, :kw, :tstring_content).source
-            end
-          end.flatten
-        end
-
-        def caller_method
-          if statement.call? || statement.def?
-            statement.method_name(true).to_s
-          elsif statement.type == :var_ref || statement.type == :vcall
-            statement[0].jump(:ident, :kw).source
-          end
-        end
-      end
-    end
-  end
-end