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

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

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module UnitTest
-    module WithAliases
-      include Convertibles
-
-      class WithEnum
-        include Enumerable
-
-        def initialize(enum) = @enum = enum
-
-        def each(&block) = @enum.each(&block)
-
-        def and_nil(&block)
-          self.and(nil, &_ = block)
-        end
-
-        def but(*cases, &block)
-          return WithEnum.new to_enum(__method__ || raise, *cases) unless block
-
-          each do |arg|
-            yield arg unless cases.any? { (_ = _1) === arg }
-          end
-        end
-
-        def and(*args, &block)
-          return WithEnum.new to_enum(__method__ || raise, *args) unless block
-
-          each(&block)
-          args.each do |arg|
-            if WithEnum === arg # use `===` as `arg` might not have `.is_a?` on it
-              arg.each(&block)
-            else
-              block.call(_ = arg)
-            end
-          end
-        end
-      end
-
-      def with(*args, &block)
-        return WithEnum.new to_enum(__method__ || raise, *args) unless block
-        args.each(&block)
-      end
-
-      def with_int(value = 3, &block)
-        return WithEnum.new to_enum(__method__ || raise, value) unless block
-        yield value
-        yield ToInt.new(value)
-      end
-
-      def with_float(value = 0.1)
-        return WithEnum.new to_enum(__method__ || raise, value) unless block_given?
-        yield value
-        yield ToF.new(value)
-      end
-
-      def with_string(value = '')
-        return WithEnum.new to_enum(__method__ || raise, value) unless block_given?
-        yield value
-        yield ToStr.new(value)
-      end
-
-      def with_array(*elements)
-        return WithEnum.new to_enum(__method__ || raise, *elements) unless block_given?
-
-        yield _ = elements
-        yield ToArray.new(*elements)
-      end
-
-      def with_hash(hash = {})
-        return WithEnum.new to_enum(__method__ || raise, hash) unless block_given?
-
-        yield _ = hash
-        yield ToHash.new(hash)
-      end
-
-      def with_io(io = $stdout)
-        return WithEnum.new to_enum(__method__ || raise, io) unless block_given?
-        yield io
-        yield ToIO.new(io)
-      end
-
-      def with_path(path = "/tmp/foo.txt", &block)
-        return WithEnum.new to_enum(__method__ || raise, path) unless block
-
-        with_string(path, &block)
-        block.call ToPath.new(path)
-      end
-
-      def with_encoding(encoding = Encoding::UTF_8, &block)
-        return WithEnum.new to_enum(__method__ || raise, encoding) unless block
-
-        block.call encoding
-        with_string(encoding.to_s, &block)
-      end
-
-      def with_interned(value = :&, &block)
-        return WithEnum.new to_enum(__method__ || raise, value) unless block
-
-        with_string(value.to_s, &block)
-        block.call value.to_sym
-      end
-
-      def with_bool(&block)
-        return WithEnum.new to_enum(__method__ || raise) unless block
-        yield true
-        yield false
-      end
-
-      def with_boolish(&block)
-        return WithEnum.new to_enum(__method__ || raise) unless block
-        with_bool(&block)
-        [nil, 1, Object.new, BlankSlate.new, "hello, world!"].each(&block)
-      end
-
-      alias with_untyped with_boolish
-
-      def with_range(start, stop, exclude_end = false)
-        # If you need fixed starting and stopping points, you can just do `with_range with(1), with(2)`.
-        raise ArgumentError, '`start` must be from a `with` method' unless start.is_a? WithEnum
-        raise ArgumentError, '`stop` must be from a `with` method' unless stop.is_a? WithEnum
-
-        start.each do |lower|
-          stop.each do |upper|
-            yield CustomRange.new(lower, upper, exclude_end)
-
-            # `Range` requires `begin <=> end` to return non-nil, but doesn't actually
-            # end up using the return value of it. This is to add that in when needed.
-            def lower.<=>(rhs) = :not_nil unless defined? lower.<=>
-
-            # If `lower <=> rhs` is defined but nil, then that means we're going to be constructing
-            # an illegal range (eg `3..ToInt.new(4)`). So, we need to skip yielding an invalid range
-            # in that case.
-            next if defined?(lower.<=>) && nil == (lower <=> upper)
-
-            yield Range.new(lower, upper, exclude_end)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-require "rbs/test"
-require "rbs/unit_test/spy"
-require "rbs/unit_test/type_assertions"
-require "rbs/unit_test/convertibles"
-require "rbs/unit_test/with_aliases"

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

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class Validator
-    attr_reader :env
-    attr_reader :resolver
-    attr_reader :definition_builder
-
-    def initialize(env:, resolver: nil)
-      @env = env
-      @resolver = resolver
-      @definition_builder = DefinitionBuilder.new(env: env)
-    end
-
-    def absolute_type(type, context:, &block)
-      return type unless resolver
-
-      type.map_type_name do |type_name, _, type|
-        resolver.resolve(type_name, context: context) || (block ? yield(type) : type_name)
-      end
-    end
-
-    # Validates presence of the relative type, and application arity match.
-    def validate_type(type, context:)
-      case type
-      when Types::ClassInstance, Types::Interface, Types::Alias
-        type = absolute_type(type, context: context) #: Types::ClassInstance | Types::Interface | Types::Alias
-
-        definition_builder.validate_type_name(type.name, type.location)
-
-        normalized_type_name = env.normalize_type_name?(type.name)
-
-        if normalized_type_name
-          type_params =
-            case type
-            when Types::ClassInstance
-              entry = env.class_decls[normalized_type_name] or raise
-              entry.type_params
-            when Types::Interface
-              env.interface_decls[normalized_type_name].decl.type_params
-            when Types::Alias
-              env.type_alias_decls[normalized_type_name].decl.type_params
-            end
-
-          InvalidTypeApplicationError.check!(
-            type_name: type.name,
-            args: type.args,
-            params: type_params,
-            location: type.location
-          )
-        end
-
-      when Types::ClassSingleton
-        type = absolute_type(type, context: context) #: Types::ClassSingleton
-        definition_builder.validate_type_presence(type)
-      end
-
-      type.each_type do |type|
-        validate_type(type, context: context)
-      end
-    end
-
-    def validate_type_alias(entry:)
-      type_name = entry.decl.name
-
-      if type_alias_dependency.circular_definition?(type_name)
-        location = entry.decl.location or raise
-        raise RecursiveTypeAliasError.new(alias_names: [type_name], location: location)
-      end
-
-      if diagnostic = type_alias_regularity.nonregular?(type_name)
-        location = entry.decl.location or raise
-        raise NonregularTypeAliasError.new(diagnostic: diagnostic, location: location)
-      end
-
-      unless entry.decl.type_params.empty?
-        calculator = VarianceCalculator.new(builder: definition_builder)
-        result = calculator.in_type_alias(name: type_name)
-        if set = result.incompatible?(entry.decl.type_params)
-          set.each do |param_name|
-            param = entry.decl.type_params.find {|param| param.name == param_name } or raise
-            next if param.unchecked?
-
-            raise InvalidVarianceAnnotationError.new(
-              type_name: type_name,
-              param: param,
-              location: entry.decl.type.location
-            )
-          end
-        end
-
-        validate_type_params(
-          entry.decl.type_params,
-          type_name: type_name,
-          location: entry.decl.location&.aref(:type_params)
-        )
-      end
-
-      if block_given?
-        yield entry.decl.type
-      end
-    end
-
-    def validate_method_definition(method_def, type_name:)
-      method_def.overloads.each do |overload|
-        method_type = overload.method_type
-        unless method_type.type_params.empty?
-          loc = method_type.location&.aref(:type_params)
-
-          validate_type_params(
-            method_type.type_params,
-            type_name: type_name,
-            method_name: method_def.name,
-            location: loc
-          )
-        end
-      end
-    end
-
-    def validate_type_params(params, type_name: , method_name: nil, location:)
-      # @type var each_node: ^() { (Symbol) -> void } -> void
-      each_node = -> (&block) do
-        params.each do |param|
-          block[param.name]
-        end
-      end
-      # @type var each_child: ^(Symbol) { (Symbol) -> void } -> void
-      each_child = -> (name, &block) do
-        if param = params.find {|p| p.name == name }
-          if b = param.upper_bound_type
-            b.free_variables.each do |tv|
-              block[tv]
-            end
-          end
-        end
-      end
-
-      TSort.each_strongly_connected_component(each_node, each_child) do |names|
-        if names.size > 1
-          params = names.map do |name|
-            params.find {|param| param.name == name} or raise
-          end
-
-          raise CyclicTypeParameterBound.new(
-            type_name: type_name,
-            method_name: method_name,
-            params: params,
-            location: location
-          )
-        end
-      end
-    end
-
-    def validate_class_alias(entry:)
-      case env.normalize_module_name?(entry.decl.new_name)
-      when nil
-        raise NoTypeFoundError.new(type_name: entry.decl.old_name, location: entry.decl.location&.[](:old_name))
-      when false
-        raise CyclicClassAliasDefinitionError.new(entry)
-      end
-
-      case entry
-      when Environment::ClassAliasEntry
-        unless env.class_entry(entry.decl.old_name)
-          raise InconsistentClassModuleAliasError.new(entry)
-        end
-      when Environment::ModuleAliasEntry
-        unless env.module_entry(entry.decl.old_name)
-          raise InconsistentClassModuleAliasError.new(entry)
-        end
-      end
-    end
-
-    def type_alias_dependency
-      @type_alias_dependency ||= TypeAliasDependency.new(env: env)
-    end
-
-    def type_alias_regularity
-      @type_alias_regularity ||= TypeAliasRegularity.validate(env: env)
-    end
-  end
-end

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

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class VarianceCalculator
-    class Result
-      attr_reader :result
-
-      def initialize(variables:)
-        @result = {}
-        variables.each do |x|
-          result[x] = :unused
-        end
-      end
-
-      def covariant(x)
-        case result[x]
-        when :unused
-          result[x] = :covariant
-        when :contravariant
-          result[x] = :invariant
-        end
-      end
-
-      def contravariant(x)
-        case result[x]
-        when :unused
-          result[x] = :contravariant
-        when :covariant
-          result[x] = :invariant
-        end
-      end
-
-      def invariant(x)
-        result[x] = :invariant
-      end
-
-      def each(&block)
-        result.each(&block)
-      end
-
-      def include?(name)
-        result.key?(name)
-      end
-
-      def compatible?(var, with_annotation:)
-        variance = result[var]
-
-        case
-        when variance == :unused
-          true
-        when with_annotation == :invariant
-          true
-        when variance == with_annotation
-          true
-        else
-          false
-        end
-      end
-
-      def incompatible?(params)
-        # @type set: Hash[Symbol]
-        set = Set[]
-
-        params.each do |param|
-          unless compatible?(param.name, with_annotation: param.variance)
-            set << param.name
-          end
-        end
-
-        unless set.empty?
-          set
-        end
-      end
-    end
-
-    attr_reader :builder
-
-    def initialize(builder:)
-      @builder = builder
-    end
-
-    def env
-      builder.env
-    end
-
-    def in_method_type(method_type:, variables:)
-      result = Result.new(variables: variables)
-
-      function(method_type.type, result: result, context: :covariant)
-
-      if block = method_type.block
-        function(block.type, result: result, context: :contravariant)
-      end
-
-      result
-    end
-
-    def in_inherit(name:, args:, variables:)
-      type = if name.class?
-               Types::ClassInstance.new(name: name, args: args, location: nil)
-             else
-               Types::Interface.new(name: name, args: args, location: nil)
-             end
-
-      Result.new(variables: variables).tap do |result|
-        type(type, result: result, context: :covariant)
-      end
-    end
-
-    def in_type_alias(name:)
-      env.normalized_type_name!(name)
-
-      decl = env.type_alias_decls[name].decl or raise
-      variables = decl.type_params.each.map(&:name)
-
-      Result.new(variables: variables).tap do |result|
-        type(decl.type, result: result, context: :covariant)
-      end
-    end
-
-    def type(type, result:, context:)
-      case type
-      when Types::Variable
-        if result.include?(type.name)
-          case context
-          when :covariant
-            result.covariant(type.name)
-          when :contravariant
-            result.contravariant(type.name)
-          when :invariant
-            result.invariant(type.name)
-          end
-        end
-      when Types::ClassInstance, Types::Interface, Types::Alias
-        if type_name = env.normalize_type_name?(type.name)
-          type_params = case type
-                        when Types::ClassInstance
-                          env.class_decls[type_name].type_params
-                        when Types::Interface
-                          env.interface_decls[type_name].decl.type_params
-                        when Types::Alias
-                          env.type_alias_decls[type_name].decl.type_params
-                        end
-
-          type.args.each.with_index do |ty, i|
-            if var = type_params[i]
-              case var.variance
-              when :invariant
-                type(ty, result: result, context: :invariant)
-              when :covariant
-                type(ty, result: result, context: context)
-              when :contravariant
-                type(ty, result: result, context: negate(context))
-              end
-            end
-          end
-        else
-          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
-        end
-      when Types::Proc
-        function(type.type, result: result, context: context)
-      else
-        type.each_type do |ty|
-          type(ty, result: result, context: context)
-        end
-      end
-    end
-
-    def function(type, result:, context:)
-      type.each_param do |param|
-        type(param.type, result: result, context: negate(context))
-      end
-      type(type.return_type, result: result, context: context)
-    end
-
-    def negate(variance)
-      case variance
-      when :invariant
-        :invariant
-      when :covariant
-        :contravariant
-      when :contravariant
-        :covariant
-      else
-        raise
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class Vendorer
-    attr_reader :vendor_dir
-    attr_reader :loader
-
-    def initialize(vendor_dir:, loader:)
-      @vendor_dir = vendor_dir
-      @loader = loader
-    end
-
-    def ensure_dir
-      unless vendor_dir.directory?
-        vendor_dir.mkpath
-      end
-
-      yield
-    end
-
-    def clean!
-      ensure_dir do
-        RBS.logger.info "Cleaning vendor root: #{vendor_dir}..."
-        vendor_dir.rmtree
-      end
-    end
-
-    def copy!
-      # @type var paths: Set[[Pathname, Pathname]]
-      paths = Set[]
-
-      if core_root = loader.core_root
-        RBS.logger.info "Vendoring core RBSs in #{vendor_dir + "core"}..."
-        FileFinder.each_file(core_root, skip_hidden: true) do |file_path|
-          paths << [file_path, Pathname("core") + file_path.relative_path_from(core_root)]
-        end
-      end
-
-      loader.libs.each do |lib|
-        case
-        when (spec, path = EnvironmentLoader.gem_sig_path(lib.name, lib.version))
-          dest_dir = Pathname("#{lib.name}-#{spec.version}")
-
-          RBS.logger.info "Vendoring #{lib.name}(#{spec.version}) RBSs in #{vendor_dir + dest_dir}..."
-
-          FileFinder.each_file(path, skip_hidden: true) do |file_path|
-            paths << [file_path, dest_dir + file_path.relative_path_from(path)]
-          end
-
-        when (rbs, path = loader.repository.lookup_path(lib.name, lib.version))
-          dest_dir = Pathname("#{rbs.name}-#{path.version}")
-
-          RBS.logger.info "Vendoring #{lib.name}(#{path.version}) RBSs in #{vendor_dir + dest_dir}..."
-
-          FileFinder.each_file(path.path, skip_hidden: true) do |file_path|
-            paths << [file_path, dest_dir + file_path.relative_path_from(path.path)]
-          end
-        else
-          RBS.logger.error "Couldn't find RBSs for #{lib.name} (#{lib.version}); skipping..."
-        end
-      end
-
-      paths.each do |from, to|
-        dest = vendor_dir + to
-        dest.parent.mkpath unless dest.parent.directory?
-
-        FileUtils.copy_file(from.to_s, dest.to_s)
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  VERSION = "3.8.0"
-end