@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-20

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/writer.rb

@@ -1,419 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class Writer
-    attr_reader :out
-    attr_reader :indentation
-
-    def initialize(out:)
-      @out = out
-      @indentation = []
-      @preserve = false
-    end
-
-    def preserve?
-      @preserve
-    end
-
-    def preserve!(preserve: true)
-      @preserve = preserve
-      self
-    end
-
-    def indent(size = 2)
-      indentation.push(" " * size)
-      yield
-    ensure
-      indentation.pop
-    end
-
-    def prefix
-      indentation.join()
-    end
-
-    def puts(string = "")
-      if string.size > 0
-        @out.puts("#{prefix}#{string}")
-      else
-        @out.puts
-      end
-    end
-
-    def format_annotation(annotation)
-      string = annotation.string
-      case
-      when string !~ /\}/
-        "%a{#{string}}"
-      when string !~ /\)/
-        "%a(#{string})"
-      when string !~ /\]/
-        "%a[#{string}]"
-      when string !~ /\>/
-        "%a<#{string}>"
-      when string !~ /\|/
-        "%a|#{string}|"
-      else
-        raise
-      end
-    end
-
-    def write_annotation(annotations)
-      annotations.each do |annotation|
-        puts format_annotation(annotation)
-      end
-    end
-
-    def write_comment(comment)
-      if comment
-        comment.string.lines.each do |line|
-          line = line.chomp
-          unless line.empty?
-            puts "# #{line}"
-          else
-            puts "#"
-          end
-        end
-      end
-    end
-
-    def write(contents)
-      dirs = contents.select {|c| c.is_a?(AST::Directives::Base) } #: Array[AST::Directives::t]
-      decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
-
-      dirs.each do |dir|
-        write_directive(dir)
-      end
-
-      puts unless dirs.empty?
-
-      [nil, *decls].each_cons(2) do |prev, decl|
-        raise unless decl
-
-        preserve_empty_line(prev, decl)
-        write_decl decl
-      end
-    end
-
-    def write_directive(dir)
-      clauses = dir.clauses.map do |clause|
-        case clause
-        when AST::Directives::Use::SingleClause
-          if clause.new_name
-            "#{clause.type_name} as #{clause.new_name}"
-          else
-            "#{clause.type_name}"
-          end
-        when AST::Directives::Use::WildcardClause
-          "#{clause.namespace}*"
-        end
-      end
-
-      puts "use #{clauses.join(", ")}"
-    end
-
-    def write_decl(decl)
-      case decl
-      when AST::Declarations::Class
-        super_class = if super_class = decl.super_class
-                        " < #{name_and_args(super_class.name, super_class.args)}"
-                      end
-        write_comment decl.comment
-        write_annotation decl.annotations
-        puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
-
-        indent do
-          [nil, *decl.members].each_cons(2) do |prev, member|
-            raise unless member
-
-            preserve_empty_line prev, member
-            write_member member
-          end
-        end
-
-        puts "end"
-
-      when AST::Declarations::Module
-        self_type = unless decl.self_types.empty?
-                      " : #{decl.self_types.join(", ")}"
-                    end
-
-        write_comment decl.comment
-        write_annotation decl.annotations
-
-        puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
-
-        indent do
-          decl.members.each.with_index do |member, index|
-            if index > 0
-              puts
-            end
-            write_member member
-          end
-        end
-
-        puts "end"
-      when AST::Declarations::Constant
-        write_comment decl.comment
-        puts "#{decl.name}: #{decl.type}"
-
-      when AST::Declarations::Global
-        write_comment decl.comment
-        puts "#{decl.name}: #{decl.type}"
-
-      when AST::Declarations::TypeAlias
-        write_comment decl.comment
-        write_annotation decl.annotations
-        write_loc_source(decl) {
-          puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
-        }
-
-      when AST::Declarations::ClassAlias
-        write_comment decl.comment
-        write_loc_source(decl) {
-          puts "class #{decl.new_name} = #{decl.old_name}"
-        }
-
-      when AST::Declarations::ModuleAlias
-        write_comment decl.comment
-        write_loc_source(decl) {
-          puts "module #{decl.new_name} = #{decl.old_name}"
-        }
-
-      when AST::Declarations::Interface
-        write_comment decl.comment
-        write_annotation decl.annotations
-
-        puts "interface #{name_and_params(decl.name, decl.type_params)}"
-
-        indent do
-          decl.members.each.with_index do |member, index|
-            if index > 0
-              puts
-            end
-            write_member member
-          end
-        end
-
-        puts "end"
-
-      end
-    end
-
-    def name_and_params(name, params)
-      if params.empty?
-        "#{name}"
-      else
-        ps = params.each.map do |param|
-          param.to_s
-        end
-
-        "#{name}[#{ps.join(", ")}]"
-      end
-    end
-
-    def name_and_args(name, args)
-      if name && args
-        if args.empty?
-          "#{name}"
-        else
-          "#{name}[#{args.join(", ")}]"
-        end
-      end
-    end
-
-    def put_lines(lines, leading_spaces:)
-      lines.each_line.with_index do |line, index|
-        line.chomp!
-        line.rstrip!
-        line.sub!(/\A( {,#{leading_spaces}})/, '') if index > 0
-
-        puts line
-      end
-    end
-
-    def write_member(member)
-      case member
-      when AST::Members::Include
-        write_comment member.comment
-        write_annotation member.annotations
-        puts "include #{name_and_args(member.name, member.args)}"
-      when AST::Members::Extend
-        write_comment member.comment
-        write_annotation member.annotations
-        puts "extend #{name_and_args(member.name, member.args)}"
-      when AST::Members::Prepend
-        write_comment member.comment
-        write_annotation member.annotations
-        puts "prepend #{name_and_args(member.name, member.args)}"
-      when AST::Members::AttrAccessor
-        write_comment member.comment
-        write_annotation member.annotations
-        puts "#{attribute(:accessor, member)}"
-      when AST::Members::AttrReader
-        write_comment member.comment
-        write_annotation member.annotations
-        puts "#{attribute(:reader, member)}"
-      when AST::Members::AttrWriter
-        write_comment member.comment
-        write_annotation member.annotations
-        puts "#{attribute(:writer, member)}"
-      when AST::Members::Public
-        puts "public"
-      when AST::Members::Private
-        puts "private"
-      when AST::Members::Alias
-        write_comment member.comment
-        write_annotation member.annotations
-        new_name = member.singleton? ? "self.#{method_name(member.new_name)}" : method_name(member.new_name)
-        old_name = member.singleton? ? "self.#{method_name(member.old_name)}" : method_name(member.old_name)
-        puts "alias #{new_name} #{old_name}"
-      when AST::Members::InstanceVariable
-        write_comment member.comment
-        puts "#{member.name}: #{member.type}"
-      when AST::Members::ClassInstanceVariable
-        write_comment member.comment
-        puts "self.#{member.name}: #{member.type}"
-      when AST::Members::ClassVariable
-        write_comment member.comment
-        puts "#{member.name}: #{member.type}"
-      when AST::Members::MethodDefinition
-        write_comment member.comment
-        write_annotation member.annotations
-        write_loc_source(member) { write_def member }
-      else
-        write_decl member
-      end
-    end
-
-    def method_name(name)
-      s = name.to_s
-
-      case s
-      when /\A(_?)[A-Za-z_]\w*(\?|!|=)?\Z/
-        s
-      when *%w(|  ^  &  <=>  ==  ===  =~  >   >=  <   <=   <<  >> +  -  *  /  %   **   ~   +@  -@  []  []=  ` ! != !~)
-        s
-      else
-        "`#{s}`"
-      end
-    end
-
-    def write_loc_source(located)
-      if preserve? && loc = located.location
-        put_lines(loc.source, leading_spaces: loc.start_column)
-      else
-        yield
-      end
-    end
-
-    def write_def(member)
-      visibility =
-        case member.visibility
-        when :public
-          "public "
-        when :private
-          "private "
-        else
-          ""
-        end
-
-      name = case member.kind
-             when :instance
-               "#{method_name(member.name)}"
-             when :singleton_instance
-               "self?.#{method_name(member.name)}"
-             when :singleton
-               "self.#{method_name(member.name)}"
-             end
-
-      string = +""
-
-      prefix = "#{visibility}def #{name}:"
-      padding = " " * (prefix.size-1)
-
-      string << prefix
-
-      member.overloads.each.with_index do |overload, index|
-        if index > 0
-          string << padding
-          string << "|"
-        end
-
-        overload.annotations.each do |annotation|
-          string << " #{format_annotation(annotation)}"
-        end
-        string << " #{overload.method_type}\n"
-      end
-
-      if member.overloading?
-        if member.overloads.size > 0
-          string << padding
-          string << "|"
-        end
-        string << " ...\n"
-      end
-
-      string.each_line do |line|
-        puts line.chomp
-      end
-    end
-
-    def attribute(kind, attr)
-      visibility =
-        case attr.visibility
-        when :public
-          "public "
-        when :private
-          "private "
-        else
-          ""
-        end
-
-      var = case attr.ivar_name
-            when nil
-              ""
-            when false
-              "()"
-            else
-              "(#{attr.ivar_name})"
-            end
-
-      receiver = case attr.kind
-                 when :singleton
-                   "self."
-                 when :instance
-                   ""
-                 end
-
-      "#{visibility}attr_#{kind} #{receiver}#{method_name(attr.name)}#{var}: #{attr.type}"
-    end
-
-    def preserve_empty_line(prev, decl)
-      # @type var decl: _Located
-
-      return unless prev
-
-      if (_ = decl).respond_to?(:comment)
-        if comment = (_ = decl).comment
-          decl = comment
-        end
-      end
-
-      prev_loc = prev.location
-      decl_loc = decl.location
-
-      if prev_loc && decl_loc
-        prev_end_line = prev_loc.end_line
-        start_line = decl_loc.start_line
-
-        if start_line - prev_end_line > 1
-          puts
-        end
-      else
-        # When the signature is not constructed by the parser,
-        # it always inserts an empty line.
-        puts
-      end
-    end
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require "rbs/version"
-
-require "set"
-require "json"
-require "pathname"
-require "pp"
-require "ripper"
-require "logger"
-require "tsort"
-
-require "rbs/errors"
-require "rbs/buffer"
-require "rbs/namespace"
-require "rbs/type_name"
-require "rbs/types"
-require "rbs/method_type"
-require "rbs/file_finder"
-require "rbs/ast/type_param"
-require "rbs/ast/directives"
-require "rbs/ast/declarations"
-require "rbs/ast/members"
-require "rbs/ast/annotation"
-require "rbs/ast/visitor"
-require "rbs/environment"
-require "rbs/environment/use_map"
-require "rbs/environment_loader"
-require "rbs/builtin_names"
-require "rbs/definition"
-require "rbs/definition_builder"
-require "rbs/definition_builder/ancestor_builder"
-require "rbs/definition_builder/method_builder"
-require "rbs/diff"
-require "rbs/variance_calculator"
-require "rbs/substitution"
-require "rbs/constant"
-require "rbs/resolver/constant_resolver"
-require "rbs/resolver/type_name_resolver"
-require "rbs/ast/comment"
-require "rbs/writer"
-require "rbs/prototype/helpers"
-require "rbs/prototype/rbi"
-require "rbs/prototype/rb"
-require "rbs/prototype/runtime"
-require "rbs/prototype/node_usage"
-require "rbs/environment_walker"
-require "rbs/vendorer"
-require "rbs/validator"
-require "rbs/factory"
-require "rbs/repository"
-require "rbs/subtractor"
-require "rbs/ancestor_graph"
-require "rbs/locator"
-require "rbs/type_alias_dependency"
-require "rbs/type_alias_regularity"
-require "rbs/collection"
-
-require "rbs_extension"
-require "rbs/parser_aux"
-require "rbs/location_aux"
-
-module RBS
-  class <<self
-    attr_reader :logger_level
-    attr_reader :logger_output
-
-    def logger
-      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || Logger::WARN, progname: "rbs")
-    end
-
-    def logger_output=(val)
-      @logger = nil
-      @logger_output = val
-    end
-
-    def logger_level=(level)
-      @logger_level = level
-      @logger = nil
-    end
-
-    def print_warning()
-      @warnings ||= Set[]
-
-      message = yield()
-
-      unless @warnings.include?(message)
-        @warnings << message
-        logger.warn { message }
-      end
-    end
-  end
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rdoc/discover.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  gem 'rdoc', '~> 6.4'
-  require 'rdoc_plugin/parser'
-  module RDoc
-    class Parser
-      class RBS < Parser
-        parse_files_matching(/\.rbs$/)
-        def scan
-          ::RBS::RDocPlugin::Parser.new(@top_level, @content).scan
-        end
-      end
-    end
-  end
-rescue Gem::LoadError
-    # Error :sad:
-rescue Exception
-    # Exception :sad:
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rdoc_plugin/parser.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-require 'rbs'
-
-module RBS
-  module RDocPlugin
-    class Parser
-
-      attr_accessor :top_level, :content
-
-      def initialize(top_level, content)
-        @top_level = top_level
-        @content = content
-      end
-
-      def scan
-        _, _, decls = ::RBS::Parser.parse_signature(@content)
-        decls.each do |decl|
-          parse_member(decl: decl, context: @top_level)
-        end
-        @top_level
-      end
-
-      def parse_member(decl:, context:, outer_name: nil)
-        case decl
-        when ::RBS::AST::Declarations::Class
-          parse_class_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Declarations::Module
-          parse_module_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Declarations::Constant
-          context = @top_level.find_class_or_module outer_name.to_s if outer_name
-          parse_constant_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Declarations::Interface
-          parse_module_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Members::MethodDefinition
-          context = @top_level.find_class_or_module outer_name.to_s if outer_name
-          parse_method_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Members::Alias
-          context = @top_level.find_class_or_module outer_name.to_s if outer_name
-          parse_method_alias_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Members::AttrReader, ::RBS::AST::Members::AttrWriter, ::RBS::AST::Members::AttrAccessor
-          context = @top_level.find_class_or_module outer_name.to_s if outer_name
-          parse_attr_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Members::Include
-          context = @top_level.find_class_or_module outer_name.to_s if outer_name
-          parse_include_decl(decl: decl, context: context, outer_name: outer_name)
-        when ::RBS::AST::Members::Extend
-          context = @top_level.find_class_or_module outer_name.to_s if outer_name
-          parse_extend_decl(decl: decl, context: context, outer_name: outer_name)
-        end
-      end
-
-      def parse_class_decl(decl:, context:, outer_name: nil)
-        full_name = fully_qualified_name(outer_name: outer_name, decl: decl)
-        klass = context.add_class(RDoc::NormalClass, full_name.to_s, decl.super_class&.name&.to_s || "::Object")
-        klass.add_comment(construct_comment(context: context, comment: comment_string(decl)), context) if decl.comment
-        decl.members.each { |member| parse_member(decl: member, context: context, outer_name: full_name) }
-      end
-
-      def parse_module_decl(decl:, context:, outer_name: nil)
-        full_name = fully_qualified_name(outer_name: outer_name, decl: _ = decl)
-        kmodule = context.add_module(RDoc::NormalModule, full_name.to_s)
-        kmodule.add_comment(construct_comment(context: context, comment: comment_string(decl)), context) if decl.comment
-        decl.members.each { |member| parse_member(decl: member, context: context, outer_name: full_name) }
-      end
-
-      def parse_constant_decl(decl:, context:, outer_name: nil)
-        comment = decl.comment ? construct_comment(context: context, comment: comment_string(decl)) : nil
-        constant = RDoc::Constant.new(decl.name.to_s, decl.type.to_s, comment)
-        context.add_constant(constant)
-      end
-
-      def parse_method_decl(decl:, context:, outer_name: nil)
-        method = RDoc::AnyMethod.new(nil, decl.name.to_s)
-        method.singleton = decl.singleton?
-        method.visibility = decl.visibility
-        method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
-        if loc = decl.location
-          method.start_collecting_tokens
-          method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })
-          method.add_token({ line_no: 1, char_no: 1, text: loc.source })
-          method.line = loc.start_line
-        end
-        method.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
-        context.add_method(method)
-      end
-
-      def parse_method_alias_decl(decl:, context:, outer_name: nil)
-        alias_def = RDoc::Alias.new(nil, decl.old_name.to_s, decl.new_name.to_s, nil, decl.kind == :singleton)
-        alias_def.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
-        context.add_alias(alias_def)
-      end
-
-      def parse_attr_decl(decl:, context:, outer_name: nil)
-        rw = case decl
-             when ::RBS::AST::Members::AttrReader
-               'R'
-             when ::RBS::AST::Members::AttrWriter
-               'W'
-             when ::RBS::AST::Members::AttrAccessor
-               'RW'
-             end
-        attribute = RDoc::Attr.new(nil, decl.name.to_s, rw, nil, decl.kind == :singleton)
-        attribute.visibility = decl.visibility
-        attribute.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
-        context.add_attribute(attribute)
-      end
-
-      def parse_include_decl(decl:, context:, outer_name: nil)
-        name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
-        qualified_name = ''
-        outer_names.each do |namespace|
-          qualified_name += namespace
-          if (module_name = @top_level.find_module_named((qualified_name += "::") + name))
-            name = module_name.full_name
-            break
-          end
-        end
-        include_decl = RDoc::Include.new(name, nil)
-        include_decl.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
-        context.add_include(include_decl)
-      end
-
-      def parse_extend_decl(decl:, context:, outer_name: nil)
-        name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
-        qualified_name = ''
-        outer_names.each do |namespace|
-          qualified_name += namespace
-          if (module_name = @top_level.find_module_named((qualified_name += "::") + name))
-            name = module_name.full_name
-            break
-          end
-        end
-        extend_decl = RDoc::Extend.new(name, nil)
-        extend_decl.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
-        context.add_extend(extend_decl)
-      end
-
-      private
-
-      def construct_comment(context:, comment:)
-        comment = RDoc::Comment.new(comment, context)
-        comment.format = "markdown"
-        comment
-      end
-
-      def comment_string(with_comment)
-        comment = with_comment.comment or raise "Object with `#comment` returning a object is expected"
-        comment.string
-      end
-
-      def fully_qualified_name(outer_name:, decl:)
-        if outer_name
-          (outer_name + decl.name)
-        else
-          decl.name
-        end
-      end
-    end
-  end
-end