@appthreat/atom 2.1.10 → 2.1.11

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

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../bundler"
-require "shellwords"
-
-module Bundler
-  class GemHelper
-    include Rake::DSL if defined? Rake::DSL
-
-    class << self
-      # set when install'd.
-      attr_accessor :instance
-
-      def install_tasks(opts = {})
-        new(opts[:dir], opts[:name]).install
-      end
-
-      def tag_prefix=(prefix)
-        instance.tag_prefix = prefix
-      end
-
-      def gemspec(&block)
-        gemspec = instance.gemspec
-        block&.call(gemspec)
-        gemspec
-      end
-    end
-
-    attr_reader :spec_path, :base, :gemspec
-
-    attr_writer :tag_prefix
-
-    def initialize(base = nil, name = nil)
-      @base = File.expand_path(base || SharedHelpers.pwd)
-      gemspecs = name ? [File.join(@base, "#{name}.gemspec")] : Gem::Util.glob_files_in_dir("{,*}.gemspec", @base)
-      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
-      @spec_path = gemspecs.first
-      @gemspec = Bundler.load_gemspec(@spec_path)
-      @tag_prefix = ""
-    end
-
-    def install
-      built_gem_path = nil
-
-      desc "Build #{name}-#{version}.gem into the pkg directory."
-      task "build" do
-        built_gem_path = build_gem
-      end
-
-      desc "Generate SHA512 checksum of #{name}-#{version}.gem into the checksums directory."
-      task "build:checksum" => "build" do
-        build_checksum(built_gem_path)
-      end
-
-      desc "Build and install #{name}-#{version}.gem into system gems."
-      task "install" => "build" do
-        install_gem(built_gem_path)
-      end
-
-      desc "Build and install #{name}-#{version}.gem into system gems without network access."
-      task "install:local" => "build" do
-        install_gem(built_gem_path, :local)
-      end
-
-      desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to #{gem_push_host}\n" \
-           "To prevent publishing in RubyGems use `gem_push=no rake release`"
-      task "release", [:remote] => ["build", "release:guard_clean",
-                                    "release:source_control_push", "release:rubygem_push"] do
-      end
-
-      task "release:guard_clean" do
-        guard_clean
-      end
-
-      task "release:source_control_push", [:remote] do |_, args|
-        tag_version { git_push(args[:remote]) } unless already_tagged?
-      end
-
-      task "release:rubygem_push" => "build" do
-        rubygem_push(built_gem_path) if gem_push?
-      end
-
-      GemHelper.instance = self
-    end
-
-    def build_gem
-      file_name = nil
-      sh([*gem_command, "build", "-V", spec_path]) do
-        file_name = File.basename(built_gem_path)
-        SharedHelpers.filesystem_access(File.join(base, "pkg")) {|p| FileUtils.mkdir_p(p) }
-        FileUtils.mv(built_gem_path, "pkg")
-        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}."
-      end
-      File.join(base, "pkg", file_name)
-    end
-
-    def install_gem(built_gem_path = nil, local = false)
-      built_gem_path ||= build_gem
-      cmd = [*gem_command, "install", built_gem_path.to_s]
-      cmd << "--local" if local
-      sh(cmd)
-      Bundler.ui.confirm "#{name} (#{version}) installed."
-    end
-
-    def build_checksum(built_gem_path = nil)
-      built_gem_path ||= build_gem
-      SharedHelpers.filesystem_access(File.join(base, "checksums")) {|p| FileUtils.mkdir_p(p) }
-      file_name = "#{File.basename(built_gem_path)}.sha512"
-      require "digest/sha2"
-      checksum = ::Digest::SHA512.file(built_gem_path).hexdigest
-      target = File.join(base, "checksums", file_name)
-      File.write(target, checksum + "\n")
-      Bundler.ui.confirm "#{name} #{version} checksum written to checksums/#{file_name}."
-    end
-
-    protected
-
-    def rubygem_push(path)
-      cmd = [*gem_command, "push", path]
-      cmd << "--key" << gem_key if gem_key
-      cmd << "--host" << allowed_push_host if allowed_push_host
-      sh_with_input(cmd)
-      Bundler.ui.confirm "Pushed #{name} #{version} to #{gem_push_host}"
-    end
-
-    def built_gem_path
-      Gem::Util.glob_files_in_dir("#{name}-*.gem", base).sort_by {|f| File.mtime(f) }.last
-    end
-
-    def git_push(remote = nil)
-      remote ||= default_remote
-      sh("git push #{remote} refs/heads/#{current_branch}".shellsplit)
-      sh("git push #{remote} refs/tags/#{version_tag}".shellsplit)
-      Bundler.ui.confirm "Pushed git commits and release tag."
-    end
-
-    def default_remote
-      remote_for_branch, status = sh_with_status(%W[git config --get branch.#{current_branch}.remote])
-      return "origin" unless status.success?
-
-      remote_for_branch.strip
-    end
-
-    def current_branch
-      # We can replace this with `git branch --show-current` once we drop support for git < 2.22.0
-      sh(%w[git rev-parse --abbrev-ref HEAD]).gsub(%r{\Aheads/}, "").strip
-    end
-
-    def allowed_push_host
-      @gemspec.metadata["allowed_push_host"] if @gemspec.respond_to?(:metadata)
-    end
-
-    def gem_push_host
-      env_rubygems_host = ENV["RUBYGEMS_HOST"]
-      env_rubygems_host = nil if env_rubygems_host&.empty?
-
-      allowed_push_host || env_rubygems_host || "rubygems.org"
-    end
-
-    def already_tagged?
-      return false unless sh(%w[git tag]).split(/\n/).include?(version_tag)
-      Bundler.ui.confirm "Tag #{version_tag} has already been created."
-      true
-    end
-
-    def guard_clean
-      clean? && committed? || raise("There are files that need to be committed first.")
-    end
-
-    def clean?
-      sh_with_status(%w[git diff --exit-code])[1].success?
-    end
-
-    def committed?
-      sh_with_status(%w[git diff-index --quiet --cached HEAD])[1].success?
-    end
-
-    def tag_version
-      sh %W[git tag -m Version\ #{version} #{version_tag}]
-      Bundler.ui.confirm "Tagged #{version_tag}."
-      yield if block_given?
-    rescue RuntimeError
-      Bundler.ui.error "Untagging #{version_tag} due to error."
-      sh_with_status %W[git tag -d #{version_tag}]
-      raise
-    end
-
-    def version
-      gemspec.version
-    end
-
-    def version_tag
-      "#{@tag_prefix}v#{version}"
-    end
-
-    def name
-      gemspec.name
-    end
-
-    def sh_with_input(cmd)
-      Bundler.ui.debug(cmd)
-      SharedHelpers.chdir(base) do
-        abort unless Kernel.system(*cmd)
-      end
-    end
-
-    def sh(cmd, &block)
-      out, status = sh_with_status(cmd, &block)
-      unless status.success?
-        raise("Running `#{cmd.shelljoin}` failed with the following output:\n\n#{out}\n")
-      end
-      out
-    end
-
-    def sh_with_status(cmd, &block)
-      Bundler.ui.debug(cmd)
-      SharedHelpers.chdir(base) do
-        outbuf = IO.popen(cmd, err: [:child, :out], &:read)
-        status = $?
-        block&.call(outbuf) if status.success?
-        [outbuf, status]
-      end
-    end
-
-    def gem_key
-      Bundler.settings["gem.push_key"].to_s.downcase if Bundler.settings["gem.push_key"]
-    end
-
-    def gem_push?
-      !%w[n no nil false off 0].include?(ENV["gem_push"].to_s.downcase)
-    end
-
-    def gem_command
-      ENV["GEM_COMMAND"]&.shellsplit || ["gem"]
-    end
-  end
-end

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

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module GemHelpers
-    GENERIC_CACHE = { Gem::Platform::RUBY => Gem::Platform::RUBY } # rubocop:disable Style/MutableConstant
-    GENERICS = [
-      [Gem::Platform.new("java"), Gem::Platform.new("java")],
-      [Gem::Platform.new("mswin32"), Gem::Platform.new("mswin32")],
-      [Gem::Platform.new("mswin64"), Gem::Platform.new("mswin64")],
-      [Gem::Platform.new("universal-mingw32"), Gem::Platform.new("universal-mingw32")],
-      [Gem::Platform.new("x64-mingw32"), Gem::Platform.new("x64-mingw32")],
-      [Gem::Platform.new("x86_64-mingw32"), Gem::Platform.new("x64-mingw32")],
-      [Gem::Platform.new("x64-mingw-ucrt"), Gem::Platform.new("x64-mingw-ucrt")],
-      [Gem::Platform.new("mingw32"), Gem::Platform.new("x86-mingw32")],
-    ].freeze
-
-    def generic(p)
-      GENERIC_CACHE[p] ||= begin
-        _, found = GENERICS.find do |match, _generic|
-          p.os == match.os && (!match.cpu || p.cpu == match.cpu)
-        end
-        found || Gem::Platform::RUBY
-      end
-    end
-    module_function :generic
-
-    def generic_local_platform
-      generic(local_platform)
-    end
-    module_function :generic_local_platform
-
-    def local_platform
-      Bundler.local_platform
-    end
-    module_function :local_platform
-
-    def generic_local_platform_is_ruby?
-      generic_local_platform == Gem::Platform::RUBY
-    end
-    module_function :generic_local_platform_is_ruby?
-
-    def platform_specificity_match(spec_platform, user_platform)
-      spec_platform = Gem::Platform.new(spec_platform)
-
-      PlatformMatch.specificity_score(spec_platform, user_platform)
-    end
-    module_function :platform_specificity_match
-
-    def select_all_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
-      matching = if force_ruby
-        specs.select {|spec| spec.match_platform(Gem::Platform::RUBY) && spec.force_ruby_platform! }
-      else
-        specs.select {|spec| spec.match_platform(platform) }
-      end
-
-      if prefer_locked
-        locked_originally = matching.select {|spec| spec.is_a?(LazySpecification) }
-        return locked_originally if locked_originally.any?
-      end
-
-      matching
-    end
-    module_function :select_all_platform_match
-
-    def select_best_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
-      matching = select_all_platform_match(specs, platform, force_ruby: force_ruby, prefer_locked: prefer_locked)
-
-      sort_and_filter_best_platform_match(matching, platform)
-    end
-    module_function :select_best_platform_match
-
-    def select_best_local_platform_match(specs, force_ruby: false)
-      matching = select_all_platform_match(specs, local_platform, force_ruby: force_ruby).filter_map(&:materialized_for_installation)
-
-      sort_best_platform_match(matching, local_platform)
-    end
-    module_function :select_best_local_platform_match
-
-    def sort_and_filter_best_platform_match(matching, platform)
-      return matching if matching.one?
-
-      exact = matching.select {|spec| spec.platform == platform }
-      return exact if exact.any?
-
-      sorted_matching = sort_best_platform_match(matching, platform)
-      exemplary_spec = sorted_matching.first
-
-      sorted_matching.take_while {|spec| same_specificity(platform, spec, exemplary_spec) && same_deps(spec, exemplary_spec) }
-    end
-    module_function :sort_and_filter_best_platform_match
-
-    def sort_best_platform_match(matching, platform)
-      matching.sort_by {|spec| platform_specificity_match(spec.platform, platform) }
-    end
-    module_function :sort_best_platform_match
-
-    class PlatformMatch
-      def self.specificity_score(spec_platform, user_platform)
-        return -1 if spec_platform == user_platform
-        return 1_000_000 if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
-
-        os_match(spec_platform, user_platform) +
-          cpu_match(spec_platform, user_platform) * 10 +
-          platform_version_match(spec_platform, user_platform) * 100
-      end
-
-      def self.os_match(spec_platform, user_platform)
-        if spec_platform.os == user_platform.os
-          0
-        else
-          1
-        end
-      end
-
-      def self.cpu_match(spec_platform, user_platform)
-        if spec_platform.cpu == user_platform.cpu
-          0
-        elsif spec_platform.cpu == "arm" && user_platform.cpu.to_s.start_with?("arm")
-          0
-        elsif spec_platform.cpu.nil? || spec_platform.cpu == "universal"
-          1
-        else
-          2
-        end
-      end
-
-      def self.platform_version_match(spec_platform, user_platform)
-        if spec_platform.version == user_platform.version
-          0
-        elsif spec_platform.version.nil?
-          1
-        else
-          2
-        end
-      end
-    end
-
-    def same_specificity(platform, spec, exemplary_spec)
-      platform_specificity_match(spec.platform, platform) == platform_specificity_match(exemplary_spec.platform, platform)
-    end
-    module_function :same_specificity
-
-    def same_deps(spec, exemplary_spec)
-      same_runtime_deps = spec.dependencies.sort == exemplary_spec.dependencies.sort
-      same_metadata_deps = spec.required_ruby_version == exemplary_spec.required_ruby_version && spec.required_rubygems_version == exemplary_spec.required_rubygems_version
-      same_runtime_deps && same_metadata_deps
-    end
-    module_function :same_deps
-  end
-end

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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/clean"
-CLOBBER.include "pkg"
-
-require_relative "gem_helper"
-Bundler::GemHelper.install_tasks

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

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # This class contains all of the logic for determining the next version of a
-  # Gem to update to based on the requested level (patch, minor, major).
-  # Primarily designed to work with Resolver which will provide it the list of
-  # available dependency versions as found in its index, before returning it to
-  # to the resolution engine to select the best version.
-  class GemVersionPromoter
-    attr_reader :level
-    attr_accessor :pre
-
-    # By default, strict is false, meaning every available version of a gem
-    # is returned from sort_versions. The order gives preference to the
-    # requested level (:patch, :minor, :major) but in complicated requirement
-    # cases some gems will by necessity be promoted past the requested level,
-    # or even reverted to older versions.
-    #
-    # If strict is set to true, the results from sort_versions will be
-    # truncated, eliminating any version outside the current level scope.
-    # This can lead to unexpected outcomes or even VersionConflict exceptions
-    # that report a version of a gem not existing for versions that indeed do
-    # existing in the referenced source.
-    attr_accessor :strict
-
-    # Creates a GemVersionPromoter instance.
-    #
-    # @return [GemVersionPromoter]
-    def initialize
-      @level = :major
-      @strict = false
-      @pre = false
-    end
-
-    # @param value [Symbol] One of three Symbols: :major, :minor or :patch.
-    def level=(value)
-      v = case value
-          when String, Symbol
-            value.to_sym
-      end
-
-      raise ArgumentError, "Unexpected level #{v}. Must be :major, :minor or :patch" unless [:major, :minor, :patch].include?(v)
-      @level = v
-    end
-
-    # Given a Resolver::Package and an Array of Specifications of available
-    # versions for a gem, this method will return the Array of Specifications
-    # sorted in an order to give preference to the current level (:major, :minor
-    # or :patch) when resolution is deciding what versions best resolve all
-    # dependencies in the bundle.
-    # @param package [Resolver::Package] The package being resolved.
-    # @param specs [Specification] An array of Specifications for the package.
-    # @return [Specification] A new instance of the Specification Array sorted.
-    def sort_versions(package, specs)
-      locked_version = package.locked_version
-
-      result = specs.sort do |a, b|
-        unless package.prerelease_specified? || pre?
-          a_pre = a.prerelease?
-          b_pre = b.prerelease?
-
-          next 1 if a_pre && !b_pre
-          next -1 if b_pre && !a_pre
-        end
-
-        if major? || locked_version.nil?
-          b <=> a
-        elsif either_version_older_than_locked?(a, b, locked_version)
-          b <=> a
-        elsif segments_do_not_match?(a, b, :major)
-          a <=> b
-        elsif !minor? && segments_do_not_match?(a, b, :minor)
-          a <=> b
-        else
-          b <=> a
-        end
-      end
-      post_sort(result, package.unlock?, locked_version)
-    end
-
-    # @return [bool] Convenience method for testing value of level variable.
-    def major?
-      level == :major
-    end
-
-    # @return [bool] Convenience method for testing value of level variable.
-    def minor?
-      level == :minor
-    end
-
-    # @return [bool] Convenience method for testing value of pre variable.
-    def pre?
-      pre == true
-    end
-
-    # Given a Resolver::Package and an Array of Specifications of available
-    # versions for a gem, this method will truncate the Array if strict
-    # is true. That means filtering out downgrades from the version currently
-    # locked, and filtering out upgrades that go past the selected level (major,
-    # minor, or patch).
-    # @param package [Resolver::Package] The package being resolved.
-    # @param specs [Specification] An array of Specifications for the package.
-    # @return [Specification] A new instance of the Specification Array
-    #   truncated.
-    def filter_versions(package, specs)
-      return specs unless strict
-
-      locked_version = package.locked_version
-      return specs if locked_version.nil? || major?
-
-      specs.select do |spec|
-        gsv = spec.version
-
-        must_match = minor? ? [0] : [0, 1]
-
-        all_match = must_match.all? {|idx| gsv.segments[idx] == locked_version.segments[idx] }
-        all_match && gsv >= locked_version
-      end
-    end
-
-    private
-
-    def either_version_older_than_locked?(a, b, locked_version)
-      a.version < locked_version || b.version < locked_version
-    end
-
-    def segments_do_not_match?(a, b, level)
-      index = [:major, :minor].index(level)
-      a.segments[index] != b.segments[index]
-    end
-
-    # Specific version moves can't always reliably be done during sorting
-    # as not all elements are compared against each other.
-    def post_sort(result, unlock, locked_version)
-      # default :major behavior in Bundler does not do this
-      return result if major?
-      if unlock || locked_version.nil?
-        result
-      else
-        move_version_to_beginning(result, locked_version)
-      end
-    end
-
-    def move_version_to_beginning(result, version)
-      move, keep = result.partition {|s| s.version.to_s == version.to_s }
-      move.concat(keep)
-    end
-  end
-end

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

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-module Bundler
-  class Graph
-    GRAPH_NAME = :Gemfile
-
-    def initialize(env, output_file, show_version = false, show_requirements = false, output_format = "png", without = [])
-      @env               = env
-      @output_file       = output_file
-      @show_version      = show_version
-      @show_requirements = show_requirements
-      @output_format     = output_format
-      @without_groups    = without.map(&:to_sym)
-
-      @groups            = []
-      @relations         = Hash.new {|h, k| h[k] = Set.new }
-      @node_options      = {}
-      @edge_options      = {}
-
-      _populate_relations
-    end
-
-    attr_reader :groups, :relations, :node_options, :edge_options, :output_file, :output_format
-
-    def viz
-      GraphVizClient.new(self).run
-    end
-
-    private
-
-    def _populate_relations
-      parent_dependencies = _groups.values.to_set.flatten
-      loop do
-        break if parent_dependencies.empty?
-
-        tmp = Set.new
-        parent_dependencies.each do |dependency|
-          child_dependencies = spec_for_dependency(dependency).runtime_dependencies.to_set
-          @relations[dependency.name] += child_dependencies.map(&:name).to_set
-          tmp += child_dependencies
-
-          @node_options[dependency.name] = _make_label(dependency, :node)
-          child_dependencies.each do |c_dependency|
-            @edge_options["#{dependency.name}_#{c_dependency.name}"] = _make_label(c_dependency, :edge)
-          end
-        end
-        parent_dependencies = tmp
-      end
-    end
-
-    def _groups
-      relations = Hash.new {|h, k| h[k] = Set.new }
-      @env.current_dependencies.each do |dependency|
-        dependency.groups.each do |group|
-          next if @without_groups.include?(group)
-
-          relations[group.to_s].add(dependency)
-          @relations[group.to_s].add(dependency.name)
-
-          @node_options[group.to_s] ||= _make_label(group, :node)
-          @edge_options["#{group}_#{dependency.name}"] = _make_label(dependency, :edge)
-        end
-      end
-      @groups = relations.keys
-      relations
-    end
-
-    def _make_label(symbol_or_string_or_dependency, element_type)
-      case element_type.to_sym
-      when :node
-        if symbol_or_string_or_dependency.is_a?(Gem::Dependency)
-          label = symbol_or_string_or_dependency.name.dup
-          label << "\n#{spec_for_dependency(symbol_or_string_or_dependency).version}" if @show_version
-        else
-          label = symbol_or_string_or_dependency.to_s
-        end
-      when :edge
-        label = nil
-        if symbol_or_string_or_dependency.respond_to?(:requirements_list) && @show_requirements
-          tmp = symbol_or_string_or_dependency.requirements_list.join(", ")
-          label = tmp if tmp != ">= 0"
-        end
-      else
-        raise ArgumentError, "2nd argument is invalid"
-      end
-      label.nil? ? {} : { label: label }
-    end
-
-    def spec_for_dependency(dependency)
-      @env.requested_specs.find {|s| s.name == dependency.name }
-    end
-
-    class GraphVizClient
-      def initialize(graph_instance)
-        @graph_name    = graph_instance.class::GRAPH_NAME
-        @groups        = graph_instance.groups
-        @relations     = graph_instance.relations
-        @node_options  = graph_instance.node_options
-        @edge_options  = graph_instance.edge_options
-        @output_file   = graph_instance.output_file
-        @output_format = graph_instance.output_format
-      end
-
-      def g
-        @g ||= ::GraphViz.digraph(@graph_name, concentrate: true, normalize: true, nodesep: 0.55) do |g|
-          g.edge[:weight]   = 2
-          g.edge[:fontname] = g.node[:fontname] = "Arial, Helvetica, SansSerif"
-          g.edge[:fontsize] = 12
-        end
-      end
-
-      def run
-        @groups.each do |group|
-          g.add_nodes(
-            group, {
-              style: "filled",
-              fillcolor: "#B9B9D5",
-              shape: "box3d",
-              fontsize: 16,
-            }.merge(@node_options[group])
-          )
-        end
-
-        @relations.each do |parent, children|
-          children.each do |child|
-            if @groups.include?(parent)
-              g.add_nodes(child, { style: "filled", fillcolor: "#B9B9D5" }.merge(@node_options[child]))
-              g.add_edges(parent, child, { constraint: false }.merge(@edge_options["#{parent}_#{child}"]))
-            else
-              g.add_nodes(child, @node_options[child])
-              g.add_edges(parent, child, @edge_options["#{parent}_#{child}"])
-            end
-          end
-        end
-
-        if @output_format.to_s == "debug"
-          $stdout.puts g.output none: String
-          Bundler.ui.info "debugging bundle viz..."
-        else
-          begin
-            g.output @output_format.to_sym => "#{@output_file}.#{@output_format}"
-            Bundler.ui.info "#{@output_file}.#{@output_format}"
-          rescue ArgumentError => e
-            warn "Unsupported output format. See Ruby-Graphviz/lib/graphviz/constants.rb"
-            raise e
-          end
-        end
-      end
-    end
-  end
-end