@appthreat/atom-parsetools 1.0.4 → 1.0.5

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/source_list.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Bundler
+  class SourceList
+    attr_reader :path_sources,
+      :git_sources,
+      :plugin_sources,
+      :global_path_source,
+      :metadata_source
+
+    def global_rubygems_source
+      @global_rubygems_source ||= rubygems_aggregate_class.new("allow_local" => true)
+    end
+
+    def initialize
+      @path_sources           = []
+      @git_sources            = []
+      @plugin_sources         = []
+      @global_rubygems_source = nil
+      @global_path_source     = nil
+      @rubygems_sources       = []
+      @metadata_source        = Source::Metadata.new
+
+      @merged_gem_lockfile_sections = false
+      @local_mode = true
+    end
+
+    def merged_gem_lockfile_sections?
+      @merged_gem_lockfile_sections
+    end
+
+    def merged_gem_lockfile_sections!(replacement_source)
+      @merged_gem_lockfile_sections = true
+      @global_rubygems_source = replacement_source
+    end
+
+    def aggregate_global_source?
+      global_rubygems_source.multiple_remotes?
+    end
+
+    def implicit_global_source?
+      global_rubygems_source.no_remotes?
+    end
+
+    def add_path_source(options = {})
+      if options["gemspec"]
+        add_source_to_list Source::Gemspec.new(options), path_sources
+      else
+        path_source = add_source_to_list Source::Path.new(options), path_sources
+        @global_path_source ||= path_source if options["global"]
+        path_source
+      end
+    end
+
+    def add_git_source(options = {})
+      add_source_to_list(Source::Git.new(options), git_sources).tap do |source|
+        warn_on_git_protocol(source)
+      end
+    end
+
+    def add_rubygems_source(options = {})
+      new_source = Source::Rubygems.new(options)
+      return @global_rubygems_source if @global_rubygems_source == new_source
+
+      add_source_to_list new_source, @rubygems_sources
+    end
+
+    def add_plugin_source(source, options = {})
+      add_source_to_list Plugin.source(source).new(options), @plugin_sources
+    end
+
+    def add_global_rubygems_remote(uri)
+      global_rubygems_source.add_remote(uri)
+      global_rubygems_source
+    end
+
+    def local_mode?
+      @local_mode
+    end
+
+    def default_source
+      global_path_source || global_rubygems_source
+    end
+
+    def rubygems_sources
+      non_global_rubygems_sources + [global_rubygems_source]
+    end
+
+    def non_global_rubygems_sources
+      @rubygems_sources
+    end
+
+    def rubygems_remotes
+      rubygems_sources.flat_map(&:remotes).uniq
+    end
+
+    def all_sources
+      path_sources + git_sources + plugin_sources + rubygems_sources + [metadata_source]
+    end
+
+    def non_default_explicit_sources
+      all_sources - [default_source, metadata_source]
+    end
+
+    def get(source)
+      source_list_for(source).find {|s| equivalent_source?(source, s) }
+    end
+
+    def lock_sources
+      lock_other_sources + lock_rubygems_sources
+    end
+
+    def lock_other_sources
+      (path_sources + git_sources + plugin_sources).sort_by(&:identifier)
+    end
+
+    def lock_rubygems_sources
+      if merged_gem_lockfile_sections?
+        [combine_rubygems_sources]
+      else
+        rubygems_sources.sort_by(&:identifier)
+      end
+    end
+
+    # Returns true if there are changes
+    def replace_sources!(replacement_sources)
+      return false if replacement_sources.empty?
+
+      @rubygems_sources, @path_sources, @git_sources, @plugin_sources = map_sources(replacement_sources)
+      @global_rubygems_source = global_replacement_source(replacement_sources)
+
+      different_sources?(lock_sources, replacement_sources)
+    end
+
+    # Returns true if there are changes
+    def expired_sources?(replacement_sources)
+      return false if replacement_sources.empty?
+
+      lock_sources = dup_with_replaced_sources(replacement_sources).lock_sources
+
+      different_sources?(lock_sources, replacement_sources)
+    end
+
+    def prefer_local!
+      all_sources.each(&:prefer_local!)
+    end
+
+    def local_only!
+      all_sources.each(&:local_only!)
+    end
+
+    def local!
+      all_sources.each(&:local!)
+    end
+
+    def cached!
+      all_sources.each(&:cached!)
+    end
+
+    def remote!
+      @local_mode = false
+
+      all_sources.each(&:remote!)
+    end
+
+    private
+
+    def dup_with_replaced_sources(replacement_sources)
+      new_source_list = dup
+      new_source_list.replace_sources!(replacement_sources)
+      new_source_list
+    end
+
+    def map_sources(replacement_sources)
+      rubygems = @rubygems_sources.map do |source|
+        replace_rubygems_source(replacement_sources, source)
+      end
+
+      git, plugin = [@git_sources, @plugin_sources].map do |sources|
+        sources.map do |source|
+          replace_source(replacement_sources, source)
+        end
+      end
+
+      path = @path_sources.map do |source|
+        replace_path_source(replacement_sources, source)
+      end
+
+      [rubygems, path, git, plugin]
+    end
+
+    def global_replacement_source(replacement_sources)
+      replace_rubygems_source(replacement_sources, global_rubygems_source, &:local!)
+    end
+
+    def replace_rubygems_source(replacement_sources, gemfile_source)
+      replace_source(replacement_sources, gemfile_source) do |replacement_source|
+        # locked sources never include credentials so always prefer remotes from the gemfile
+        replacement_source.remotes = gemfile_source.remotes
+
+        yield replacement_source if block_given?
+
+        replacement_source
+      end
+    end
+
+    def replace_source(replacement_sources, gemfile_source)
+      replacement_source = replacement_sources.find {|s| s == gemfile_source }
+      return gemfile_source unless replacement_source
+
+      replacement_source = yield(replacement_source) if block_given?
+
+      replacement_source
+    end
+
+    def replace_path_source(replacement_sources, gemfile_source)
+      replace_source(replacement_sources, gemfile_source) do |replacement_source|
+        if gemfile_source.is_a?(Source::Gemspec)
+          gemfile_source.checksum_store = replacement_source.checksum_store
+          gemfile_source
+        else
+          replacement_source
+        end
+      end
+    end
+
+    def different_sources?(lock_sources, replacement_sources)
+      !equivalent_sources?(lock_sources, replacement_sources)
+    end
+
+    def rubygems_aggregate_class
+      Source::Rubygems
+    end
+
+    def add_source_to_list(source, list)
+      list.unshift(source).uniq!
+      source
+    end
+
+    def source_list_for(source)
+      case source
+      when Source::Git          then git_sources
+      when Source::Path         then path_sources
+      when Source::Rubygems     then rubygems_sources
+      when Plugin::API::Source  then plugin_sources
+      else raise ArgumentError, "Invalid source: #{source.inspect}"
+      end
+    end
+
+    def combine_rubygems_sources
+      Source::Rubygems.new("remotes" => rubygems_remotes)
+    end
+
+    def warn_on_git_protocol(source)
+      return if Bundler.settings["git.allow_insecure"]
+
+      if /^git\:/.match?(source.uri)
+        Bundler.ui.warn "The git source `#{source.uri}` uses the `git` protocol, " \
+          "which transmits data without encryption. Disable this warning with " \
+          "`bundle config set --local git.allow_insecure true`, or switch to the `https` " \
+          "protocol to keep your data secure."
+      end
+    end
+
+    def equivalent_sources?(lock_sources, replacement_sources)
+      lock_sources.sort_by(&:identifier) == replacement_sources.sort_by(&:identifier)
+    end
+
+    def equivalent_source?(source, other_source)
+      source == other_source
+    end
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/source_map.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Bundler
+  class SourceMap
+    attr_reader :sources, :dependencies, :locked_specs
+
+    def initialize(sources, dependencies, locked_specs)
+      @sources = sources
+      @dependencies = dependencies
+      @locked_specs = locked_specs
+    end
+
+    def pinned_spec_names(skip = nil)
+      direct_requirements.reject {|_, source| source == skip }.keys
+    end
+
+    def all_requirements
+      requirements = direct_requirements.dup
+
+      unmet_deps = sources.non_default_explicit_sources.map do |source|
+        (source.spec_names - pinned_spec_names).each do |indirect_dependency_name|
+          previous_source = requirements[indirect_dependency_name]
+          if previous_source.nil?
+            requirements[indirect_dependency_name] = source
+          else
+            no_ambiguous_sources = Bundler.feature_flag.bundler_3_mode?
+
+            msg = ["The gem '#{indirect_dependency_name}' was found in multiple relevant sources."]
+            msg.concat [previous_source, source].map {|s| "  * #{s}" }.sort
+            msg << "You #{no_ambiguous_sources ? :must : :should} add this gem to the source block for the source you wish it to be installed from."
+            msg = msg.join("\n")
+
+            raise SecurityError, msg if no_ambiguous_sources
+            Bundler.ui.warn "Warning: #{msg}"
+          end
+        end
+
+        source.unmet_deps
+      end
+
+      sources.default_source.add_dependency_names(unmet_deps.flatten - requirements.keys)
+
+      requirements
+    end
+
+    def direct_requirements
+      @direct_requirements ||= begin
+        requirements = {}
+        default = sources.default_source
+        dependencies.each do |dep|
+          dep_source = dep.source || default
+          dep_source.add_dependency_names(dep.name)
+          requirements[dep.name] = dep_source
+        end
+        requirements
+      end
+    end
+
+    def locked_requirements
+      @locked_requirements ||= begin
+        requirements = {}
+        locked_specs.each do |locked_spec|
+          source = locked_spec.source
+          source.add_dependency_names(locked_spec.name)
+          requirements[locked_spec.name] = source
+        end
+        requirements
+      end
+    end
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/spec_set.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require_relative "vendored_tsort"
+
+module Bundler
+  class SpecSet
+    include Enumerable
+    include TSort
+
+    def initialize(specs)
+      @specs = specs
+    end
+
+    def for(dependencies, platforms_or_legacy_check = [nil], legacy_platforms = [nil], skips: [])
+      platforms = if [true, false].include?(platforms_or_legacy_check)
+        Bundler::SharedHelpers.major_deprecation 2,
+          "SpecSet#for received a `check` parameter, but that's no longer used and deprecated. " \
+          "SpecSet#for always implicitly performs validation. Please remove this parameter",
+          print_caller_location: true
+
+        legacy_platforms
+      else
+        platforms_or_legacy_check
+      end
+
+      materialize_dependencies(dependencies, platforms, skips: skips)
+
+      @materializations.flat_map(&:specs).uniq
+    end
+
+    def normalize_platforms!(deps, platforms)
+      complete_platforms = add_extra_platforms!(platforms)
+
+      complete_platforms.map do |platform|
+        next platform if platform == Gem::Platform::RUBY
+
+        begin
+          Integer(platform.version)
+        rescue ArgumentError, TypeError
+          next platform
+        end
+
+        less_specific_platform = Gem::Platform.new([platform.cpu, platform.os, nil])
+        next platform if incomplete_for_platform?(deps, less_specific_platform)
+
+        less_specific_platform
+      end.uniq
+    end
+
+    def add_originally_invalid_platforms!(platforms, originally_invalid_platforms)
+      originally_invalid_platforms.each do |originally_invalid_platform|
+        platforms << originally_invalid_platform if complete_platform(originally_invalid_platform)
+      end
+    end
+
+    def add_extra_platforms!(platforms)
+      if @specs.empty?
+        platforms.concat([Gem::Platform::RUBY]).uniq
+        return
+      end
+
+      new_platforms = all_platforms.select do |platform|
+        next if platforms.include?(platform)
+        next unless GemHelpers.generic(platform) == Gem::Platform::RUBY
+
+        complete_platform(platform)
+      end
+      return if new_platforms.empty?
+
+      platforms.concat(new_platforms)
+
+      less_specific_platform = new_platforms.find {|platform| platform != Gem::Platform::RUBY && Bundler.local_platform === platform && platform === Bundler.local_platform }
+      platforms.delete(Bundler.local_platform) if less_specific_platform
+    end
+
+    def validate_deps(s)
+      s.runtime_dependencies.each do |dep|
+        next if dep.name == "bundler"
+
+        return :missing unless names.include?(dep.name)
+        return :invalid if none? {|spec| dep.matches_spec?(spec) }
+      end
+
+      :valid
+    end
+
+    def [](key)
+      key = key.name if key.respond_to?(:name)
+      lookup[key]&.reverse || []
+    end
+
+    def []=(key, value)
+      delete_by_name(key)
+
+      add_spec(value)
+    end
+
+    def delete(specs)
+      Array(specs).each {|spec| remove_spec(spec) }
+    end
+
+    def sort!
+      self
+    end
+
+    def to_a
+      sorted.dup
+    end
+
+    def to_hash
+      lookup.dup
+    end
+
+    def materialize(deps)
+      materialize_dependencies(deps)
+
+      SpecSet.new(materialized_specs)
+    end
+
+    # Materialize for all the specs in the spec set, regardless of what platform they're for
+    # @return [Array<Gem::Specification>]
+    def materialized_for_all_platforms
+      @specs.map do |s|
+        next s unless s.is_a?(LazySpecification)
+        spec = s.materialize_for_cache
+        raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
+        spec
+      end
+    end
+
+    def incomplete_for_platform?(deps, platform)
+      return false if @specs.empty?
+
+      validation_set = self.class.new(@specs)
+      validation_set.for(deps, [platform])
+
+      validation_set.incomplete_specs.any?
+    end
+
+    def missing_specs_for(deps)
+      materialize_dependencies(deps)
+
+      missing_specs
+    end
+
+    def missing_specs
+      @materializations.flat_map(&:completely_missing_specs)
+    end
+
+    def partially_missing_specs
+      @materializations.flat_map(&:partially_missing_specs)
+    end
+
+    def incomplete_specs
+      @materializations.flat_map(&:incomplete_specs)
+    end
+
+    def insecurely_materialized_specs
+      materialized_specs.select(&:insecurely_materialized?)
+    end
+
+    def -(other)
+      SpecSet.new(to_a - other.to_a)
+    end
+
+    def find_by_name_and_platform(name, platform)
+      @specs.detect {|spec| spec.name == name && spec.match_platform(platform) }
+    end
+
+    def specs_with_additional_variants_from(other)
+      sorted | additional_variants_from(other)
+    end
+
+    def delete_by_name(name)
+      @specs.reject! {|spec| spec.name == name }
+      @sorted&.reject! {|spec| spec.name == name }
+      return if @lookup.nil?
+
+      @lookup[name] = nil
+    end
+
+    def version_for(name)
+      self[name].first&.version
+    end
+
+    def what_required(spec)
+      unless req = find {|s| s.runtime_dependencies.any? {|d| d.name == spec.name } }
+        return [spec]
+      end
+      what_required(req) << spec
+    end
+
+    def <<(spec)
+      @specs << spec
+    end
+
+    def length
+      @specs.length
+    end
+
+    def size
+      @specs.size
+    end
+
+    def empty?
+      @specs.empty?
+    end
+
+    def each(&b)
+      sorted.each(&b)
+    end
+
+    def names
+      lookup.keys
+    end
+
+    def valid?(s)
+      s.matches_current_metadata? && valid_dependencies?(s)
+    end
+
+    def to_s
+      map(&:full_name).to_s
+    end
+
+    private
+
+    def materialize_dependencies(dependencies, platforms = [nil], skips: [])
+      handled = ["bundler"].product(platforms).map {|k| [k, true] }.to_h
+      deps = dependencies.product(platforms)
+      @materializations = []
+
+      loop do
+        break unless dep = deps.shift
+
+        dependency = dep[0]
+        platform = dep[1]
+        name = dependency.name
+
+        key = [name, platform]
+        next if handled.key?(key)
+
+        handled[key] = true
+
+        materialization = Materialization.new(dependency, platform, candidates: lookup[name])
+
+        deps.concat(materialization.dependencies) if materialization.complete?
+
+        @materializations << materialization unless skips.include?(name)
+      end
+
+      @materializations
+    end
+
+    def materialized_specs
+      @materializations.filter_map(&:materialized_spec)
+    end
+
+    def complete_platform(platform)
+      new_specs = []
+
+      valid_platform = lookup.all? do |_, specs|
+        spec = specs.first
+        matching_specs = spec.source.specs.search([spec.name, spec.version])
+        platform_spec = GemHelpers.select_best_platform_match(matching_specs, platform).find do |s|
+          valid?(s)
+        end
+
+        if platform_spec
+          new_specs << LazySpecification.from_spec(platform_spec) unless specs.include?(platform_spec)
+          true
+        else
+          false
+        end
+      end
+
+      if valid_platform && new_specs.any?
+        new_specs.each {|spec| add_spec(spec) }
+      end
+
+      valid_platform
+    end
+
+    def all_platforms
+      @specs.flat_map {|spec| spec.source.specs.search([spec.name, spec.version]).map(&:platform) }.uniq
+    end
+
+    def additional_variants_from(other)
+      other.select do |spec|
+        version_for(spec.name) == spec.version && valid_dependencies?(spec)
+      end
+    end
+
+    def valid_dependencies?(s)
+      validate_deps(s) == :valid
+    end
+
+    def sorted
+      @sorted ||= ([@specs.find {|s| s.name == "rake" }] + tsort).compact.uniq
+    rescue TSort::Cyclic => error
+      cgems = extract_circular_gems(error)
+      raise CyclicDependencyError, "Your bundle requires gems that depend" \
+        " on each other, creating an infinite loop. Please remove either" \
+        " gem '#{cgems[0]}' or gem '#{cgems[1]}' and try again."
+    end
+
+    def extract_circular_gems(error)
+      error.message.scan(/@name="(.*?)"/).flatten
+    end
+
+    def lookup
+      @lookup ||= begin
+        lookup = {}
+        @specs.each do |s|
+          index_spec(lookup, s.name, s)
+        end
+        lookup
+      end
+    end
+
+    def tsort_each_node
+      # MUST sort by name for backwards compatibility
+      @specs.sort_by(&:name).each {|s| yield s }
+    end
+
+    def tsort_each_child(s)
+      s.dependencies.sort_by(&:name).each do |d|
+        next if d.type == :development
+
+        specs_for_name = lookup[d.name]
+        next unless specs_for_name
+
+        specs_for_name.each {|s2| yield s2 }
+      end
+    end
+
+    def add_spec(spec)
+      @specs << spec
+
+      name = spec.name
+
+      @sorted&.insert(@sorted.bsearch_index {|s| s.name >= name } || @sorted.size, spec)
+      return if @lookup.nil?
+
+      index_spec(@lookup, name, spec)
+    end
+
+    def remove_spec(spec)
+      @specs.delete(spec)
+      @sorted&.delete(spec)
+      return if @lookup.nil?
+
+      indexed_specs = @lookup[spec.name]
+      return unless indexed_specs
+
+      if indexed_specs.size > 1
+        @lookup[spec.name].delete(spec)
+      else
+        @lookup[spec.name] = nil
+      end
+    end
+
+    def index_spec(hash, key, value)
+      hash[key] ||= []
+      hash[key] << value
+    end
+  end
+end