docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/extend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+##
+# A Module extension to a class with \#extend
+#
+#   RDoc::Extend.new 'Enumerable', 'comment ...'
+
+class RDoc::Extend < RDoc::Mixin
+
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/ghost_method.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+##
+# GhostMethod represents a method referenced only by a comment
+
+class RDoc::GhostMethod < RDoc::AnyMethod
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/include.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+##
+# A Module included in a class with \#include
+#
+#   RDoc::Include.new 'Enumerable', 'comment ...'
+
+class RDoc::Include < RDoc::Mixin
+
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/meta_method.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+##
+# MetaMethod represents a meta-programmed method
+
+class RDoc::MetaMethod < RDoc::AnyMethod
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/method_attr.rb

@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+##
+# Abstract class representing either a method or an attribute.
+
+class RDoc::MethodAttr < RDoc::CodeObject
+
+  include Comparable
+
+  ##
+  # Name of this method/attribute.
+
+  attr_accessor :name
+
+  ##
+  # public, protected, private
+
+  attr_accessor :visibility
+
+  ##
+  # Is this a singleton method/attribute?
+
+  attr_accessor :singleton
+
+  ##
+  # Source file token stream
+
+  attr_reader :text
+
+  ##
+  # Array of other names for this method/attribute
+
+  attr_reader :aliases
+
+  ##
+  # The method/attribute we're aliasing
+
+  attr_accessor :is_alias_for
+
+  #--
+  # The attributes below are for AnyMethod only.
+  # They are left here for the time being to
+  # allow ri to operate.
+  # TODO modify ri to avoid calling these on attributes.
+  #++
+
+  ##
+  # Parameters yielded by the called block
+
+  attr_reader :block_params
+
+  ##
+  # Parameters for this method
+
+  attr_accessor :params
+
+  ##
+  # Different ways to call this method
+
+  attr_accessor :call_seq
+
+  ##
+  # The call_seq or the param_seq with method name, if there is no call_seq.
+
+  attr_reader :arglists
+
+  ##
+  # Pretty parameter list for this method
+
+  attr_reader :param_seq
+
+
+  ##
+  # Creates a new MethodAttr from token stream +text+ and method or attribute
+  # name +name+.
+  #
+  # Usually this is called by super from a subclass.
+
+  def initialize text, name
+    super()
+
+    @text = text
+    @name = name
+
+    @aliases      = []
+    @is_alias_for = nil
+    @parent_name  = nil
+    @singleton    = nil
+    @visibility   = :public
+    @see = false
+
+    @arglists     = nil
+    @block_params = nil
+    @call_seq     = nil
+    @param_seq    = nil
+    @params       = nil
+  end
+
+  ##
+  # Resets cached data for the object so it can be rebuilt by accessor methods
+
+  def initialize_copy other # :nodoc:
+    @full_name = nil
+  end
+
+  def initialize_visibility # :nodoc:
+    super
+    @see = nil
+  end
+
+  ##
+  # Order by #singleton then #name
+
+  def <=>(other)
+    return unless other.respond_to?(:singleton) &&
+                  other.respond_to?(:name)
+
+    [@singleton      ? 0 : 1, name_ord_range,       name] <=>
+    [other.singleton ? 0 : 1, other.name_ord_range, other.name]
+  end
+
+  def == other # :nodoc:
+    equal?(other) or self.class == other.class and full_name == other.full_name
+  end
+
+  ##
+  # A method/attribute is documented if any of the following is true:
+  # - it was marked with :nodoc:;
+  # - it has a comment;
+  # - it is an alias for a documented method;
+  # - it has a +#see+ method that is documented.
+
+  def documented?
+    super or
+      (is_alias_for and is_alias_for.documented?) or
+      (see and see.documented?)
+  end
+
+  ##
+  # A method/attribute to look at,
+  # in particular if this method/attribute has no documentation.
+  #
+  # It can be a method/attribute of the superclass or of an included module,
+  # including the Kernel module, which is always appended to the included
+  # modules.
+  #
+  # Returns +nil+ if there is no such method/attribute.
+  # The +#is_alias_for+ method/attribute, if any, is not included.
+  #
+  # Templates may generate a "see also ..." if this method/attribute
+  # has documentation, and "see ..." if it does not.
+
+  def see
+    @see = find_see if @see == false
+    @see
+  end
+
+  ##
+  # Sets the store for this class or module and its contained code objects.
+
+  def store= store
+    super
+
+    @file = @store.add_file @file.full_name if @file
+  end
+
+  def find_see # :nodoc:
+    return nil if singleton || is_alias_for
+
+    # look for the method
+    other = find_method_or_attribute name
+    return other if other
+
+    # if it is a setter, look for a getter
+    return nil unless name =~ /[a-z_]=$/i   # avoid == or ===
+    return find_method_or_attribute name[0..-2]
+  end
+
+  def find_method_or_attribute name # :nodoc:
+    return nil unless parent.respond_to? :ancestors
+
+    searched = parent.ancestors
+    kernel = @store.modules_hash['Kernel']
+
+    searched << kernel if kernel &&
+      parent != kernel && !searched.include?(kernel)
+
+    searched.each do |ancestor|
+      next if String === ancestor
+      next if parent == ancestor
+
+      other = ancestor.find_method_named('#' + name) ||
+              ancestor.find_attribute_named(name)
+
+      return other if other
+    end
+
+    nil
+  end
+
+  ##
+  # Abstract method. Contexts in their building phase call this
+  # to register a new alias for this known method/attribute.
+  #
+  # - creates a new AnyMethod/Attribute named <tt>an_alias.new_name</tt>;
+  # - adds +self+ as an alias for the new method or attribute
+  # - adds the method or attribute to #aliases
+  # - adds the method or attribute to +context+.
+
+  def add_alias(an_alias, context)
+    raise NotImplementedError
+  end
+
+  ##
+  # HTML fragment reference for this method
+
+  def aref
+    type = singleton ? 'c' : 'i'
+    # % characters are not allowed in html names => dash instead
+    "#{aref_prefix}-#{type}-#{html_name}"
+  end
+
+  ##
+  # Prefix for +aref+, defined by subclasses.
+
+  def aref_prefix
+    raise NotImplementedError
+  end
+
+  ##
+  # Attempts to sanitize the content passed by the Ruby parser:
+  # remove outer parentheses, etc.
+
+  def block_params=(value)
+    # 'yield.to_s' or 'assert yield, msg'
+    return @block_params = '' if value =~ /^[\.,]/
+
+    # remove trailing 'if/unless ...'
+    return @block_params = '' if value =~ /^(if|unless)\s/
+
+    value = $1.strip if value =~ /^(.+)\s(if|unless)\s/
+
+    # outer parentheses
+    value = $1 if value =~ /^\s*\((.*)\)\s*$/
+    value = value.strip
+
+    # proc/lambda
+    return @block_params = $1 if value =~ /^(proc|lambda)(\s*\{|\sdo)/
+
+    # surrounding +...+ or [...]
+    value = $1.strip if value =~ /^\+(.*)\+$/
+    value = $1.strip if value =~ /^\[(.*)\]$/
+
+    return @block_params = '' if value.empty?
+
+    # global variable
+    return @block_params = 'str' if value =~ /^\$[&0-9]$/
+
+    # wipe out array/hash indices
+    value.gsub!(/(\w)\[[^\[]+\]/, '\1')
+
+    # remove @ from class/instance variables
+    value.gsub!(/@@?([a-z0-9_]+)/, '\1')
+
+    # method calls => method name
+    value.gsub!(/([A-Z:a-z0-9_]+)\.([a-z0-9_]+)(\s*\(\s*[a-z0-9_.,\s]*\s*\)\s*)?/) do
+      case $2
+      when 'to_s'      then $1
+      when 'const_get' then 'const'
+      when 'new' then
+        $1.split('::').last.  # ClassName => class_name
+          gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+          gsub(/([a-z\d])([A-Z])/, '\1_\2').
+          downcase
+      else
+        $2
+      end
+    end
+
+    # class prefixes
+    value.gsub!(/[A-Za-z0-9_:]+::/, '')
+
+    # simple expressions
+    value = $1 if value =~ /^([a-z0-9_]+)\s*[-*+\/]/
+
+    @block_params = value.strip
+  end
+
+  ##
+  # HTML id-friendly method/attribute name
+
+  def html_name
+    require 'cgi/util'
+
+    CGI.escape(@name.gsub('-', '-2D')).gsub('%', '-').sub(/^-/, '')
+  end
+
+  ##
+  # Full method/attribute name including namespace
+
+  def full_name
+    @full_name ||= "#{parent_name}#{pretty_name}"
+  end
+
+  def inspect # :nodoc:
+    alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
+    visibility = self.visibility
+    visibility = "forced #{visibility}" if force_documentation
+    "#<%s:0x%x %s (%s)%s>" % [
+      self.class, object_id,
+      full_name,
+      visibility,
+      alias_for,
+    ]
+  end
+
+  ##
+  # '::' for a class method/attribute, '#' for an instance method.
+
+  def name_prefix
+    @singleton ? '::' : '#'
+  end
+
+  ##
+  # Name for output to HTML.  For class methods the full name with a "." is
+  # used like +SomeClass.method_name+.  For instance methods the class name is
+  # used if +context+ does not match the parent.
+  #
+  # This is to help prevent people from using :: to call class methods.
+
+  def output_name context
+    return "#{name_prefix}#{@name}" if context == parent
+
+    "#{parent_name}#{@singleton ? '.' : '#'}#{@name}"
+  end
+
+  ##
+  # Method/attribute name with class/instance indicator
+
+  def pretty_name
+    "#{name_prefix}#{@name}"
+  end
+
+  ##
+  # Type of method/attribute (class or instance)
+
+  def type
+    singleton ? 'class' : 'instance'
+  end
+
+  ##
+  # Path to this method for use with HTML generator output.
+
+  def path
+    "#{@parent.path}##{aref}"
+  end
+
+  ##
+  # Name of our parent with special handling for un-marshaled methods
+
+  def parent_name
+    @parent_name || super
+  end
+
+  def pretty_print q # :nodoc:
+    alias_for =
+      if @is_alias_for.respond_to? :name then
+        "alias for #{@is_alias_for.name}"
+      elsif Array === @is_alias_for then
+        "alias for #{@is_alias_for.last}"
+      end
+
+    q.group 2, "[#{self.class.name} #{full_name} #{visibility}", "]" do
+      if alias_for then
+        q.breakable
+        q.text alias_for
+      end
+
+      if text then
+        q.breakable
+        q.text "text:"
+        q.breakable
+        q.pp @text
+      end
+
+      unless comment.empty? then
+        q.breakable
+        q.text "comment:"
+        q.breakable
+        q.pp @comment
+      end
+    end
+  end
+
+  ##
+  # Used by RDoc::Generator::JsonIndex to create a record for the search
+  # engine.
+
+  def search_record
+    [
+      @name,
+      full_name,
+      @name,
+      @parent.full_name,
+      path,
+      params,
+      snippet(@comment),
+    ]
+  end
+
+  def to_s # :nodoc:
+    if @is_alias_for
+      "#{self.class.name}: #{full_name} -> #{is_alias_for}"
+    else
+      "#{self.class.name}: #{full_name}"
+    end
+  end
+
+  def name_ord_range # :nodoc:
+    case name.ord
+    when 0..64 # anything below "A"
+      1
+    when 91..96 # the symbols between "Z" and "a"
+      2
+    when 123..126 # 7-bit symbols above "z": "{", "|", "}", "~"
+      3
+    else # everythig else can be sorted as normal
+      4
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/mixin.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+##
+# A Mixin adds features from a module into another context.  RDoc::Include and
+# RDoc::Extend are both mixins.
+
+class RDoc::Mixin < RDoc::CodeObject
+
+  ##
+  # Name of included module
+
+  attr_accessor :name
+
+  ##
+  # Creates a new Mixin for +name+ with +comment+
+
+  def initialize(name, comment)
+    super()
+    @name = name
+    self.comment = comment
+    @module = nil # cache for module if found
+  end
+
+  ##
+  # Mixins are sorted by name
+
+  def <=> other
+    return unless self.class === other
+
+    name <=> other.name
+  end
+
+  def == other # :nodoc:
+    self.class === other and @name == other.name
+  end
+
+  alias eql? == # :nodoc:
+
+  ##
+  # Full name based on #module
+
+  def full_name
+    m = self.module
+    RDoc::ClassModule === m ? m.full_name : @name
+  end
+
+  def hash # :nodoc:
+    [@name, self.module].hash
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %s.%s %s>" % [
+      self.class,
+      object_id,
+      parent_name, self.class.name.downcase, @name,
+    ]
+  end
+
+  ##
+  # Attempts to locate the included module object.  Returns the name if not
+  # known.
+  #
+  # The scoping rules of Ruby to resolve the name of an included module are:
+  # - first look into the children of the current context;
+  # - if not found, look into the children of included modules,
+  #   in reverse inclusion order;
+  # - if still not found, go up the hierarchy of names.
+  #
+  # This method has <code>O(n!)</code> behavior when the module calling
+  # include is referencing nonexistent modules.  Avoid calling #module until
+  # after all the files are parsed.  This behavior is due to ruby's constant
+  # lookup behavior.
+  #
+  # As of the beginning of October, 2011, no gem includes nonexistent modules.
+
+  def module
+    return @module if @module
+
+    # search the current context
+    return @name unless parent
+    full_name = parent.child_name(@name)
+    @module = @store.modules_hash[full_name]
+    return @module if @module
+    return @name if @name =~ /^::/
+
+    # search the includes before this one, in reverse order
+    searched = parent.includes.take_while { |i| i != self }.reverse
+    searched.each do |i|
+      inc = i.module
+      next if String === inc
+      full_name = inc.child_name(@name)
+      @module = @store.modules_hash[full_name]
+      return @module if @module
+    end
+
+    # go up the hierarchy of names
+    up = parent.parent
+    while up
+      full_name = up.child_name(@name)
+      @module = @store.modules_hash[full_name]
+      return @module if @module
+      up = up.parent
+    end
+
+    @name
+  end
+
+  ##
+  # Sets the store for this class or module and its contained code objects.
+
+  def store= store
+    super
+
+    @file = @store.add_file @file.full_name if @file
+  end
+
+  def to_s # :nodoc:
+    "#{self.class.name.downcase} #@name in: #{parent}"
+  end
+
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/code_object/normal_class.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+##
+# A normal class, neither singleton nor anonymous
+
+class RDoc::NormalClass < RDoc::ClassModule
+
+  ##
+  # The ancestors of this class including modules.  Unlike Module#ancestors,
+  # this class is not included in the result.  The result will contain both
+  # RDoc::ClassModules and Strings.
+
+  def ancestors
+    if String === superclass then
+      super << superclass
+    elsif superclass then
+      ancestors = super
+      ancestors << superclass
+      ancestors.concat superclass.ancestors
+    else
+      super
+    end
+  end
+
+  def aref_prefix # :nodoc:
+    'class'
+  end
+
+  ##
+  # The definition of this class, <tt>class MyClassName</tt>
+
+  def definition
+    "class #{full_name}"
+  end
+
+  def direct_ancestors
+    superclass ? super + [superclass] : super
+  end
+
+  def inspect # :nodoc:
+    superclass = @superclass ? " < #{@superclass}" : nil
+    "<%s:0x%x class %s%s includes: %p extends: %p attributes: %p methods: %p aliases: %p>" % [
+      self.class, object_id,
+      full_name, superclass, @includes, @extends, @attributes, @method_list, @aliases
+    ]
+  end
+
+  def to_s # :nodoc:
+    display = "#{self.class.name} #{self.full_name}"
+    if superclass
+      display += ' < ' + (superclass.is_a?(String) ? superclass : superclass.full_name)
+    end
+    display += ' -> ' + is_alias_for.to_s if is_alias_for
+    display
+  end
+
+  def pretty_print q # :nodoc:
+    superclass = @superclass ? " < #{@superclass}" : nil
+
+    q.group 2, "[class #{full_name}#{superclass}", "]" do
+      q.breakable
+      q.text "includes:"
+      q.breakable
+      q.seplist @includes do |inc| q.pp inc end
+
+      q.breakable
+      q.text "constants:"
+      q.breakable
+      q.seplist @constants do |const| q.pp const end
+
+      q.breakable
+      q.text "attributes:"
+      q.breakable
+      q.seplist @attributes do |attr| q.pp attr end
+
+      q.breakable
+      q.text "methods:"
+      q.breakable
+      q.seplist @method_list do |meth| q.pp meth end
+
+      q.breakable
+      q.text "aliases:"
+      q.breakable
+      q.seplist @aliases do |aliaz| q.pp aliaz end
+
+      q.breakable
+      q.text "comment:"
+      q.breakable
+      q.pp comment
+    end
+  end
+
+end