@appthreat/atom 2.1.10 → 2.1.11

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/resolver/candidate.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "spec_group"
-
-module Bundler
-  class Resolver
-    #
-    # This class is a PubGrub compatible "Version" class that takes Bundler
-    # resolution complexities into account.
-    #
-    # Each Resolver::Candidate has a underlying `Gem::Version` plus a set of
-    # platforms. For example, 1.1.0-x86_64-linux is a different resolution candidate
-    # from 1.1.0 (generic). This is because different platform variants of the
-    # same gem version can bring different dependencies, so they need to be
-    # considered separately.
-    #
-    # Some candidates may also keep some information explicitly about the
-    # package they refer to. These candidates are referred to as "canonical" and
-    # are used when materializing resolution results back into RubyGems
-    # specifications that can be installed, written to lock files, and so on.
-    #
-    class Candidate
-      include Comparable
-
-      attr_reader :version
-
-      def initialize(version, group: nil, priority: -1)
-        @spec_group = group || SpecGroup.new([])
-        @version = Gem::Version.new(version)
-        @priority = priority
-      end
-
-      def dependencies
-        @spec_group.dependencies
-      end
-
-      def to_specs(package, most_specific_locked_platform)
-        return [] if package.meta?
-
-        @spec_group.to_specs(package.force_ruby_platform?, most_specific_locked_platform)
-      end
-
-      def prerelease?
-        @version.prerelease?
-      end
-
-      def segments
-        @version.segments
-      end
-
-      def sort_obj
-        [@version, @priority]
-      end
-
-      def <=>(other)
-        return unless other.is_a?(self.class)
-
-        sort_obj <=> other.sort_obj
-      end
-
-      def ==(other)
-        return unless other.is_a?(self.class)
-
-        sort_obj == other.sort_obj
-      end
-
-      def eql?(other)
-        return unless other.is_a?(self.class)
-
-        sort_obj.eql?(other.sort_obj)
-      end
-
-      def hash
-        sort_obj.hash
-      end
-
-      def to_s
-        @version.to_s
-      end
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/resolver/incompatibility.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Resolver
-    class Incompatibility < PubGrub::Incompatibility
-      attr_reader :extended_explanation
-
-      def initialize(terms, cause:, custom_explanation: nil, extended_explanation: nil)
-        @extended_explanation = extended_explanation
-
-        super(terms, cause: cause, custom_explanation: custom_explanation)
-      end
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/resolver/package.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Resolver
-    #
-    # Represents a gem being resolved, in a format PubGrub likes.
-    #
-    # The class holds the following information:
-    #
-    # * Platforms this gem will be resolved on.
-    # * The locked version of this gem resolution should favor (if any).
-    # * Whether the gem should be unlocked to its latest version.
-    # * The dependency explicit set in the Gemfile for this gem (if any).
-    #
-    class Package
-      attr_reader :name, :platforms, :dependency, :locked_version
-
-      def initialize(name, platforms, locked_specs:, unlock:, prerelease: false, prefer_local: false, dependency: nil)
-        @name = name
-        @platforms = platforms
-        @locked_version = locked_specs[name].first&.version
-        @unlock = unlock
-        @dependency = dependency || Dependency.new(name, @locked_version)
-        @top_level = !dependency.nil?
-        @prerelease = @dependency.prerelease? || @locked_version&.prerelease? || prerelease ? :consider_first : :ignore
-        @prefer_local = prefer_local
-      end
-
-      def platform_specs(specs)
-        platforms.map {|platform| GemHelpers.select_best_platform_match(specs, platform, prefer_locked: !unlock?) }
-      end
-
-      def to_s
-        @name.delete("\0")
-      end
-
-      def root?
-        false
-      end
-
-      def top_level?
-        @top_level
-      end
-
-      def meta?
-        @name.end_with?("\0")
-      end
-
-      def ==(other)
-        self.class == other.class && @name == other.name
-      end
-
-      def hash
-        @name.hash
-      end
-
-      def unlock?
-        @unlock.empty? || @unlock.include?(name)
-      end
-
-      def ignores_prereleases?
-        @prerelease == :ignore
-      end
-
-      def prerelease_specified?
-        @prerelease == :consider_first
-      end
-
-      def consider_prereleases!
-        @prerelease = :consider_last
-      end
-
-      def prefer_local?
-        @prefer_local
-      end
-
-      def consider_remote_versions!
-        @prefer_local = false
-      end
-
-      def force_ruby_platform?
-        @dependency.force_ruby_platform
-      end
-
-      def current_platform?
-        @dependency.current_platform?
-      end
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/resolver/root.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "package"
-
-module Bundler
-  class Resolver
-    #
-    # Represents the Gemfile from the resolver's perspective. It's the root
-    # package and Gemfile entries depend on it.
-    #
-    class Root < Package
-      def initialize(name)
-        @name = name
-      end
-
-      def meta?
-        true
-      end
-
-      def root?
-        true
-      end
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/resolver/spec_group.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Resolver
-    class SpecGroup
-      attr_reader :specs
-
-      def initialize(specs)
-        @specs = specs
-      end
-
-      def empty?
-        @specs.empty?
-      end
-
-      def name
-        @name ||= exemplary_spec.name
-      end
-
-      def version
-        @version ||= exemplary_spec.version
-      end
-
-      def source
-        @source ||= exemplary_spec.source
-      end
-
-      def to_specs(force_ruby_platform, most_specific_locked_platform)
-        @specs.map do |s|
-          lazy_spec = LazySpecification.from_spec(s)
-          lazy_spec.force_ruby_platform = force_ruby_platform
-          lazy_spec.most_specific_locked_platform = most_specific_locked_platform
-          lazy_spec
-        end
-      end
-
-      def to_s
-        sorted_spec_names.join(", ")
-      end
-
-      def dependencies
-        @dependencies ||= @specs.flat_map do |spec|
-          __dependencies(spec) + metadata_dependencies(spec)
-        end.uniq.sort
-      end
-
-      def ==(other)
-        sorted_spec_names == other.sorted_spec_names
-      end
-
-      def merge(other)
-        return false unless equivalent?(other)
-
-        @specs |= other.specs
-
-        true
-      end
-
-      protected
-
-      def sorted_spec_names
-        @specs.map(&:full_name).sort
-      end
-
-      private
-
-      def equivalent?(other)
-        name == other.name && version == other.version && source == other.source && dependencies == other.dependencies
-      end
-
-      def exemplary_spec
-        @specs.first
-      end
-
-      def __dependencies(spec)
-        dependencies = []
-        spec.dependencies.each do |dep|
-          next if dep.type == :development
-          dependencies << Dependency.new(dep.name, dep.requirement)
-        end
-        dependencies
-      end
-
-      def metadata_dependencies(spec)
-        [
-          metadata_dependency("Ruby", spec.required_ruby_version),
-          metadata_dependency("RubyGems", spec.required_rubygems_version),
-        ].compact
-      end
-
-      def metadata_dependency(name, requirement)
-        return if requirement.nil? || requirement.none?
-
-        Dependency.new("#{name}\0", requirement)
-      end
-    end
-  end
-end