npm - @appthreat/atom - Versions diffs - 2.1.10 → 2.1.12 - Mend

@appthreat/atom 2.1.10 → 2.1.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (658) hide show

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/source_list.rb DELETED Viewed

@@ -1,251 +0,0 @@
-# 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 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) || source
-      end
-      git, plugin = [@git_sources, @plugin_sources].map do |sources|
-        sources.map do |source|
-          replacement_sources.find {|s| s == source } || source
-        end
-      end
-      path = @path_sources.map do |source|
-        replacement_sources.find {|s| s == (source.is_a?(Source::Gemspec) ? source.as_path_source : source) } || source
-      end
-      [rubygems, path, git, plugin]
-    end
-    def global_replacement_source(replacement_sources)
-      replacement_source = replace_rubygems_source(replacement_sources, global_rubygems_source)
-      return global_rubygems_source unless replacement_source
-      replacement_source.local!
-      replacement_source
-    end
-    def replace_rubygems_source(replacement_sources, gemfile_source)
-      replacement_source = replacement_sources.find {|s| s == gemfile_source }
-      return unless replacement_source
-      # locked sources never include credentials so always prefer remotes from the gemfile
-      replacement_source.remotes = gemfile_source.remotes
-      replacement_source
-    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/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/source_map.rb DELETED Viewed

@@ -1,71 +0,0 @@
-# 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/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/spec_set.rb DELETED Viewed

@@ -1,323 +0,0 @@
-# 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_extra_platforms!(platforms)
-      return platforms.concat([Gem::Platform::RUBY]).uniq if @specs.empty?
-      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 platforms 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
-      platforms
-    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)
-      @specs << value
-      reset!
-    end
-    def delete(specs)
-      Array(specs).each {|spec| @specs.delete(spec) }
-      reset!
-    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)
-        s.source.remote!
-        spec = s.materialize_strictly
-        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(dependencies)
-      materialize_dependencies(dependencies)
-      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 delete_by_name(name)
-      @specs.reject! {|spec| spec.name == name }
-      reset!
-    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
-    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 reset!
-      @sorted = nil
-      @lookup = nil
-    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?
-        @specs.concat(new_specs)
-        reset!
-      end
-      valid_platform
-    end
-    def all_platforms
-      @specs.flat_map {|spec| spec.source.specs.search([spec.name, spec.version]).map(&:platform) }.uniq
-    end
-    def valid_dependencies?(s)
-      validate_deps(s) == :valid
-    end
-    def sorted
-      rake = @specs.find {|s| s.name == "rake" }
-      begin
-        @sorted ||= ([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
-    end
-    def extract_circular_gems(error)
-      error.message.scan(/@name="(.*?)"/).flatten
-    end
-    def lookup
-      @lookup ||= begin
-        lookup = {}
-        @specs.each do |s|
-          lookup[s.name] ||= []
-          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
-  end
-end