qiita_org 0.1.24 → 0.1.25

data/gems/ruby/2.7.0/gems/yard-0.9.25/lib/yard/code_objects/method_object.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+module YARD::CodeObjects
+  register_separator CSEP, :method
+  register_separator ISEP, :method
+
+  # Represents a Ruby method in source
+  class MethodObject < Base
+    # The scope of the method (+:class+ or +:instance+)
+    #
+    # @return [Symbol] the scope
+    attr_reader :scope
+
+    # Whether the object is explicitly defined in source or whether it was
+    # inferred by a handler. For instance, attribute methods are generally
+    # inferred and therefore not explicitly defined in source.
+    #
+    # @return [Boolean] whether the object is explicitly defined in source.
+    attr_accessor :explicit
+
+    # Returns the list of parameters parsed out of the method signature
+    # with their default values.
+    #
+    # @return [Array<Array(String, String)>] a list of parameter names followed
+    #   by their default values (or nil)
+    attr_accessor :parameters
+
+    # Creates a new method object in +namespace+ with +name+ and an instance
+    # or class +scope+
+    #
+    # If scope is +:module+, this object is instantiated as a public
+    # method in +:class+ scope, but also creates a new (empty) method
+    # as a private +:instance+ method on the same class or module.
+    #
+    # @param [NamespaceObject] namespace the namespace
+    # @param [String, Symbol] name the method name
+    # @param [Symbol] scope +:instance+, +:class+, or +:module+
+    def initialize(namespace, name, scope = :instance, &block)
+      @module_function = false
+      @scope = nil
+
+      # handle module function
+      if scope == :module
+        other = self.class.new(namespace, name, &block)
+        other.visibility = :private
+        scope = :class
+        @module_function = true
+      end
+
+      @visibility = :public
+      self.scope = scope
+      self.parameters = []
+
+      super
+    end
+
+    # Changes the scope of an object from :instance or :class
+    # @param [Symbol] v the new scope
+    def scope=(v)
+      reregister = @scope ? true : false
+
+      # handle module function
+      if v == :module
+        other = self.class.new(namespace, name)
+        other.visibility = :private
+        @visibility = :public
+        @module_function = true
+        @path = nil
+      end
+
+      YARD::Registry.delete(self)
+      @path = nil
+      @scope = v.to_sym
+      @scope = :class if @scope == :module
+      YARD::Registry.register(self) if reregister
+    end
+
+    # @return whether or not the method is the #initialize constructor method
+    def constructor?
+      name == :initialize && scope == :instance && namespace.is_a?(ClassObject)
+    end
+
+    # @return [Boolean] whether or not this method was created as a module
+    #   function
+    # @since 0.8.0
+    def module_function?
+      @module_function
+    end
+
+    # Returns the read/writer info for the attribute if it is one
+    # @return [SymbolHash] if there is information about the attribute
+    # @return [nil] if the method is not an attribute
+    # @since 0.5.3
+    def attr_info
+      return nil unless namespace.is_a?(NamespaceObject)
+      namespace.attributes[scope][name.to_s.gsub(/=$/, '')]
+    end
+
+    # @return [Boolean] whether the method is a writer attribute
+    # @since 0.5.3
+    def writer?
+      info = attr_info
+      info && info[:write] == self ? true : false
+    end
+
+    # @return [Boolean] whether the method is a reader attribute
+    # @since 0.5.3
+    def reader?
+      info = attr_info
+      info && info[:read] == self ? true : false
+    end
+
+    # Tests if the object is defined as an attribute in the namespace
+    # @return [Boolean] whether the object is an attribute
+    def is_attribute?
+      info = attr_info
+      if info
+        read_or_write = name.to_s =~ /=$/ ? :write : :read
+        info[read_or_write] ? true : false
+      else
+        false
+      end
+    end
+
+    # Tests if the object is defined as an alias of another method
+    # @return [Boolean] whether the object is an alias
+    def is_alias?
+      return false unless namespace.is_a?(NamespaceObject)
+      namespace.aliases.key? self
+    end
+
+    # Tests boolean {#explicit} value.
+    #
+    # @return [Boolean] whether the method is explicitly defined in source
+    def is_explicit?
+      explicit ? true : false
+    end
+
+    # @return [MethodObject] the object that this method overrides
+    # @return [nil] if it does not override a method
+    # @since 0.6.0
+    def overridden_method
+      return nil if namespace.is_a?(Proxy)
+      meths = namespace.meths(:all => true)
+      meths.find {|m| m.path != path && m.name == name && m.scope == scope }
+    end
+
+    # Returns all alias names of the object
+    # @return [Array<Symbol>] the alias names
+    def aliases
+      list = []
+      return list unless namespace.is_a?(NamespaceObject)
+      namespace.aliases.each do |o, aname|
+        list << o if aname == name && o.scope == scope
+      end
+      list
+    end
+
+    # Override path handling for instance methods in the root namespace
+    # (they should still have a separator as a prefix).
+    # @return [String] the path of a method
+    def path
+      @path ||= !namespace || namespace.path == "" ? sep + super : super
+    end
+
+    # Returns the name of the object.
+    #
+    # @example The name of an instance method (with prefix)
+    #   an_instance_method.name(true) # => "#mymethod"
+    # @example The name of a class method (with prefix)
+    #   a_class_method.name(true) # => "mymethod"
+    # @param [Boolean] prefix whether or not to show the prefix
+    # @return [String] returns {#sep} + +name+ for an instance method if
+    #   prefix is true
+    # @return [Symbol] the name without {#sep} if prefix is set to false
+    def name(prefix = false)
+      prefix ? (sep == ISEP ? "#{sep}#{super}" : super.to_s) : super
+    end
+
+    # Override separator to differentiate between class and instance
+    # methods.
+    # @return [String] "#" for an instance method, "." for class
+    def sep
+      if scope == :class
+        namespace && namespace != YARD::Registry.root ? CSEP : NSEP
+      else
+        ISEP
+      end
+    end
+
+    protected
+
+    def copyable_attributes
+      super - %w(scope module_function)
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/yard-0.9.25/lib/yard/code_objects/module_object.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module YARD::CodeObjects
+  register_separator NSEP, :module
+
+  # Represents a Ruby module.
+  class ModuleObject < NamespaceObject
+    # Returns the inheritance tree of mixins.
+    #
+    # @param [Boolean] include_mods if true, will include mixed in
+    #   modules (which is likely what is wanted).
+    # @return [Array<NamespaceObject>] a list of namespace objects
+    def inheritance_tree(include_mods = false)
+      return [self] unless include_mods
+      [self] + mixins(:instance, :class).map do |m|
+        next if m == self
+        next m unless m.respond_to?(:inheritance_tree)
+        m.inheritance_tree(true)
+      end.compact.flatten.uniq
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/yard-0.9.25/lib/yard/code_objects/namespace_mapper.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+module YARD
+  module CodeObjects
+    # This module controls registration and accessing of namespace separators
+    # for {Registry} lookup.
+    #
+    # @since 0.9.1
+    module NamespaceMapper
+      # @!group Registering a Separator for a Namespace
+
+      # Registers a separator with an optional set of valid types that
+      # must follow the separator lexically.
+      #
+      # Calls all callbacks defined by {NamespaceMapper.on_invalidate} after
+      # the separator is registered.
+      #
+      # @param sep [String] the separator string for the namespace
+      # @param valid_types [Array<Symbol>] a list of object types that
+      #   must follow the separator. If the list is empty, any type can
+      #   follow the separator.
+      # @example Registering separators for a method object
+      #   # Anything after a "#" denotes a method object
+      #   register_separator "#", :method
+      #   # Anything after a "." denotes a method object
+      #   register_separator ".", :method
+      # @see .on_invalidate
+      def register_separator(sep, *valid_types)
+        NamespaceMapper.invalidate
+
+        valid_types.each do |t|
+          NamespaceMapper.rev_map[t] ||= []
+          NamespaceMapper.rev_map[t] << sep
+        end
+
+        NamespaceMapper.map[sep] ||= []
+        NamespaceMapper.map[sep] += valid_types
+      end
+
+      # Unregisters a separator by a type.
+      #
+      # @param type [Symbol] the type to unregister
+      # @see #register_separator
+      def unregister_separator_by_type(type)
+        seps = NamespaceMapper.rev_map[type]
+        return unless seps
+        
+        seps.each {|s| NamespaceMapper.map.delete(s) }
+        NamespaceMapper.rev_map.delete(type)
+        NamespaceMapper.invalidate
+      end
+
+      # Clears the map of separators.
+      #
+      # @return [void]
+      def clear_separators
+        NamespaceMapper.invalidate
+        NamespaceMapper.map = {}
+        NamespaceMapper.rev_map = {}
+      end
+
+      # Gets or sets the default separator value to use when no
+      # separator for the namespace can be determined.
+      #
+      # @param value [String, nil] the default separator, or nil to return the
+      #   value
+      # @example
+      #   default_separator "::"
+      def default_separator(value = nil)
+        if value
+          NamespaceMapper.invalidate
+          NamespaceMapper.default_separator = Regexp.quote value
+        else
+          NamespaceMapper.default_separator
+        end
+      end
+
+      # @!group Separator and Type Lookup Helpers
+
+      # @return [Array<String>] all of the registered separators
+      def separators
+        NamespaceMapper.map.keys
+      end
+
+      # @return [Regexp] the regexp match of all separators
+      def separators_match
+        NamespaceMapper.map_match
+      end
+
+      # @param sep [String] the separator to return types for
+      # @return [Array<Symbol>] a list of types registered to a separator
+      def types_for_separator(sep)
+        NamespaceMapper.map[sep] || []
+      end
+
+      # @param type [String] the type to return separators for
+      # @return [Array<Symbol>] a list of separators registered to a type
+      def separators_for_type(type)
+        NamespaceMapper.rev_map[type] || []
+      end
+
+      # Internal methods to act as a singleton registry
+      class << self
+        # @!group Invalidation callbacks
+
+        # Adds a callback that triggers when a new separator is registered or
+        # the cache is cleared by invalidation.
+        def on_invalidate(&block)
+          (@invalidation_callbacks ||= []).push(block)
+        end
+
+        # @!visibility private
+
+        # @return [Hash] a mapping of types to separators
+        def map
+          @map ||= {}
+        end
+
+        # @return [Hash] a reverse mapping of separators to types
+        def rev_map
+          @rev_map ||= {}
+        end
+
+        # Invalidates all separators
+        # @return [void]
+        def invalidate
+          @map_match = nil
+          (@invalidation_callbacks || []).each(&:call)
+        end
+
+        # @return [Regexp] the full list of separators as a regexp match
+        def map_match
+          @map_match ||= map.keys.map {|k| Regexp.quote k }.join('|')
+        end
+
+        # @return [String] the default separator when no separator can begin
+        #   determined.
+        attr_accessor :default_separator
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/yard-0.9.25/lib/yard/code_objects/namespace_object.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+module YARD::CodeObjects
+  register_separator NSEP, :namespace
+  default_separator NSEP
+
+  # A "namespace" is any object that can store other objects within itself.
+  # The two main Ruby objects that can act as namespaces are modules
+  # ({ModuleObject}) and classes ({ClassObject}).
+  class NamespaceObject < Base
+    # @return [Array<String>] a list of ordered group names inside the namespace
+    # @since 0.6.0
+    attr_accessor :groups
+
+    # The list of objects defined in this namespace
+    # @return [Array<Base>] a list of objects
+    attr_reader :children
+
+    # A hash containing two keys, class and instance, each containing
+    # the attribute name with a { :read, :write } hash for the read and
+    # write objects respectively.
+    #
+    # @example The attributes of an object
+    #   >> Registry.at('YARD::Docstring').attributes
+    #   => {
+    #         :class => { },
+    #         :instance => {
+    #           :ref_tags => {
+    #             :read => #<yardoc method YARD::Docstring#ref_tags>,
+    #             :write => nil
+    #           },
+    #           :object => {
+    #             :read => #<yardoc method YARD::Docstring#object>,
+    #             :write => #<yardoc method YARD::Docstring#object=>
+    #            },
+    #            ...
+    #         }
+    #       }
+    # @return [Hash] a list of methods
+    attr_reader :attributes
+
+    # A hash containing two keys, :class and :instance, each containing
+    # a hash of objects and their alias names.
+    # @return [Hash] a list of methods
+    attr_reader :aliases
+
+    # Class mixins
+    # @return [Array<ModuleObject>] a list of mixins
+    attr_reader :class_mixins
+
+    # Instance mixins
+    # @return [Array<ModuleObject>] a list of mixins
+    attr_reader :instance_mixins
+
+    # Creates a new namespace object inside +namespace+ with +name+.
+    # @see Base#initialize
+    def initialize(namespace, name, *args, &block)
+      @children = CodeObjectList.new(self)
+      @class_mixins = CodeObjectList.new(self)
+      @instance_mixins = CodeObjectList.new(self)
+      @attributes = SymbolHash[:class => SymbolHash.new, :instance => SymbolHash.new]
+      @aliases = {}
+      @groups = []
+      super
+    end
+
+    # Only the class attributes
+    # @return [Hash] a list of method names and their read/write objects
+    # @see #attributes
+    def class_attributes
+      attributes[:class]
+    end
+
+    # Only the instance attributes
+    # @return [Hash] a list of method names and their read/write objects
+    # @see #attributes
+    def instance_attributes
+      attributes[:instance]
+    end
+
+    # Looks for a child that matches the attributes specified by +opts+.
+    #
+    # @example Finds a child by name and scope
+    #   namespace.child(:name => :to_s, :scope => :instance)
+    #   # => #<yardoc method MyClass#to_s>
+    # @return [Base, nil] the first matched child object, or nil
+    def child(opts = {})
+      if !opts.is_a?(Hash)
+        children.find {|o| o.name == opts.to_sym }
+      else
+        opts = SymbolHash[opts]
+        children.find do |obj|
+          opts.each do |meth, value|
+            break false unless value.is_a?(Array) ? value.include?(obj[meth]) : obj[meth] == value
+          end
+        end
+      end
+    end
+
+    # Returns all methods that match the attributes specified by +opts+. If
+    # no options are provided, returns all methods.
+    #
+    # @example Finds all private and protected class methods
+    #   namespace.meths(:visibility => [:private, :protected], :scope => :class)
+    #   # => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>]
+    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,
+    #   :protected]) the visibility of the methods to list. Can be an array or
+    #   single value.
+    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the
+    #   scope of the methods to list. Can be an array or single value.
+    # @option opts [Boolean] :included (true) whether to include mixed in
+    #   methods in the list.
+    # @return [Array<MethodObject>] a list of method objects
+    def meths(opts = {})
+      opts = SymbolHash[
+        :visibility => [:public, :private, :protected],
+        :scope => [:class, :instance],
+        :included => true
+      ].update(opts)
+
+      opts[:visibility] = [opts[:visibility]].flatten
+      opts[:scope] = [opts[:scope]].flatten
+
+      ourmeths = children.select do |o|
+        o.is_a?(MethodObject) &&
+          opts[:visibility].include?(o.visibility) &&
+          opts[:scope].include?(o.scope)
+      end
+
+      ourmeths + (opts[:included] ? included_meths(opts) : [])
+    end
+
+    # Returns methods included from any mixins that match the attributes
+    # specified by +opts+. If no options are specified, returns all included
+    # methods.
+    #
+    # @option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,
+    #   :protected]) the visibility of the methods to list. Can be an array or
+    #   single value.
+    # @option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the
+    #   scope of the methods to list. Can be an array or single value.
+    # @option opts [Boolean] :included (true) whether to include mixed in
+    #   methods in the list.
+    # @see #meths
+    def included_meths(opts = {})
+      opts = SymbolHash[:scope => [:instance, :class]].update(opts)
+      [opts[:scope]].flatten.map do |scope|
+        mixins(scope).inject([]) do |list, mixin|
+          next list if mixin.is_a?(Proxy)
+          arr = mixin.meths(opts.merge(:scope => :instance)).reject do |o|
+            next false if opts[:all]
+            child(:name => o.name, :scope => scope) || list.find {|o2| o2.name == o.name }
+          end
+          arr.map! {|o| ExtendedMethodObject.new(o) } if scope == :class
+          list + arr
+        end
+      end.flatten
+    end
+
+    # Returns all constants in the namespace
+    #
+    # @option opts [Boolean] :included (true) whether or not to include
+    #   mixed in constants in list
+    # @return [Array<ConstantObject>] a list of constant objects
+    def constants(opts = {})
+      opts = SymbolHash[:included => true].update(opts)
+      consts = children.select {|o| o.is_a? ConstantObject }
+      consts + (opts[:included] ? included_constants : [])
+    end
+
+    # Returns constants included from any mixins
+    # @return [Array<ConstantObject>] a list of constant objects
+    def included_constants
+      instance_mixins.inject([]) do |list, mixin|
+        if mixin.respond_to? :constants
+          list += mixin.constants.reject do |o|
+            child(:name => o.name) || list.find {|o2| o2.name == o.name }
+          end
+        else
+          list
+        end
+      end
+    end
+
+    # Returns class variables defined in this namespace.
+    # @return [Array<ClassVariableObject>] a list of class variable objects
+    def cvars
+      children.select {|o| o.is_a? ClassVariableObject }
+    end
+
+    # Returns for specific scopes. If no scopes are provided, returns all mixins.
+    # @param [Array<Symbol>] scopes a list of scopes (:class, :instance) to
+    #   return mixins for. If this is empty, all scopes will be returned.
+    # @return [Array<ModuleObject>] a list of mixins
+    def mixins(*scopes)
+      return class_mixins if scopes == [:class]
+      return instance_mixins if scopes == [:instance]
+      class_mixins | instance_mixins
+    end
+  end
+end