@appthreat/atom 2.1.10 → 2.1.11

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Cache
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      Bundler.ui.level = "warn" if options[:quiet]
-      Bundler.settings.set_command_option_if_given :path, options[:path]
-      Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]
-
-      setup_cache_all
-      install
-
-      # TODO: move cache contents here now that all bundles are locked
-      custom_path = Bundler.settings[:path] if options[:path]
-
-      Bundler.settings.temporary(cache_all_platforms: options["all-platforms"]) do
-        Bundler.load.cache(custom_path)
-      end
-    end
-
-    private
-
-    def install
-      require_relative "install"
-      options = self.options.dup
-      options["local"] = false if Bundler.settings[:cache_all_platforms]
-      options["no-cache"] = true
-      Bundler::CLI::Install.new(options).run
-    end
-
-    def setup_cache_all
-      all = options.fetch(:all, Bundler.feature_flag.cache_all? || nil)
-
-      Bundler.settings.set_command_option_if_given :cache_all, all
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Check
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      Bundler.settings.set_command_option_if_given :path, options[:path]
-
-      definition = Bundler.definition
-      definition.validate_runtime!
-
-      begin
-        definition.check!
-        not_installed = definition.missing_specs
-      rescue GemNotFound, GitError, SolveFailure
-        Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."
-        Bundler.ui.warn "Install missing gems with `bundle install`."
-        exit 1
-      end
-
-      if not_installed.any?
-        Bundler.ui.error "The following gems are missing"
-        not_installed.each {|s| Bundler.ui.error " * #{s.name} (#{s.version})" }
-        Bundler.ui.warn "Install missing gems with `bundle install`"
-        exit 1
-      elsif !Bundler.default_lockfile.file? && Bundler.frozen_bundle?
-        Bundler.ui.error "This bundle has been frozen, but there is no #{SharedHelpers.relative_lockfile_path} present"
-        exit 1
-      else
-        definition.lock(true) unless options[:"dry-run"]
-        Bundler.ui.info "The Gemfile's dependencies are satisfied"
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Clean
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      require_path_or_force unless options[:"dry-run"]
-      Bundler.load.clean(options[:"dry-run"])
-    end
-
-    protected
-
-    def require_path_or_force
-      return unless Bundler.use_system_gems? && !options[:force]
-      raise InvalidOption, "Cleaning all the gems on your system is dangerous! " \
-        "If you're sure you want to remove every system gem not in this " \
-        "bundle, run `bundle clean --force`."
-    end
-  end
-end

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module CLI::Common
-    def self.output_post_install_messages(messages)
-      return if Bundler.settings["ignore_messages"]
-      messages.to_a.each do |name, msg|
-        print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
-      end
-    end
-
-    def self.print_post_install_message(name, msg)
-      Bundler.ui.confirm "Post-install message from #{name}:"
-      Bundler.ui.info msg
-    end
-
-    def self.output_fund_metadata_summary
-      return if Bundler.settings["ignore_funding_requests"]
-      definition = Bundler.definition
-      current_dependencies = definition.requested_dependencies
-      current_specs = definition.specs
-
-      count = current_dependencies.count {|dep| current_specs[dep.name].first.metadata.key?("funding_uri") }
-
-      return if count.zero?
-
-      intro = count > 1 ? "#{count} installed gems you directly depend on are" : "#{count} installed gem you directly depend on is"
-      message = "#{intro} looking for funding.\n  Run `bundle fund` for details"
-      Bundler.ui.info message
-    end
-
-    def self.output_without_groups_message(command)
-      return if Bundler.settings[:without].empty?
-      Bundler.ui.confirm without_groups_message(command)
-    end
-
-    def self.without_groups_message(command)
-      command_in_past_tense = command == :install ? "installed" : "updated"
-      groups = Bundler.settings[:without]
-      "Gems in the #{verbalize_groups(groups)} were not #{command_in_past_tense}."
-    end
-
-    def self.verbalize_groups(groups)
-      groups.map! {|g| "'#{g}'" }
-      group_list = [groups[0...-1].join(", "), groups[-1..-1]].
-        reject {|s| s.to_s.empty? }.join(" and ")
-      group_str = groups.size == 1 ? "group" : "groups"
-      "#{group_str} #{group_list}"
-    end
-
-    def self.select_spec(name, regex_match = nil)
-      specs = []
-      regexp = Regexp.new(name) if regex_match
-
-      Bundler.definition.specs.each do |spec|
-        return spec if spec.name == name
-        specs << spec if regexp && spec.name.match?(regexp)
-      end
-
-      default_spec = default_gem_spec(name)
-      specs << default_spec if default_spec
-
-      case specs.count
-      when 0
-        dep_in_other_group = Bundler.definition.current_dependencies.find {|dep|dep.name == name }
-
-        if dep_in_other_group
-          raise GemNotFound, "Could not find gem '#{name}', because it's in the #{verbalize_groups(dep_in_other_group.groups)}, configured to be ignored."
-        else
-          raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
-        end
-      when 1
-        specs.first
-      else
-        ask_for_spec_from(specs)
-      end
-    rescue RegexpError
-      raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
-    end
-
-    def self.default_gem_spec(name)
-      gem_spec = Gem::Specification.find_all_by_name(name).last
-      gem_spec if gem_spec&.default_gem?
-    end
-
-    def self.ask_for_spec_from(specs)
-      specs.each_with_index do |spec, index|
-        Bundler.ui.info "#{index.succ} : #{spec.name}", true
-      end
-      Bundler.ui.info "0 : - exit -", true
-
-      num = Bundler.ui.ask("> ").to_i
-      num > 0 ? specs[num - 1] : nil
-    end
-
-    def self.gem_not_found_message(missing_gem_name, alternatives)
-      require_relative "../similarity_detector"
-      message = "Could not find gem '#{missing_gem_name}'."
-      alternate_names = alternatives.map {|a| a.respond_to?(:name) ? a.name : a }
-      suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
-      message += "\nDid you mean #{suggestions}?" if suggestions
-      message
-    end
-
-    def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
-      return unless locked_gems
-
-      locked_names = locked_gems.specs.map(&:name).uniq
-      names.-(locked_names).each do |g|
-        raise GemNotFound, gem_not_found_message(g, locked_names)
-      end
-    end
-
-    def self.configure_gem_version_promoter(definition, options)
-      patch_level = patch_level_options(options)
-      patch_level << :patch if patch_level.empty? && Bundler.settings[:prefer_patch]
-      raise InvalidOption, "Provide only one of the following options: #{patch_level.join(", ")}" unless patch_level.length <= 1
-
-      definition.gem_version_promoter.tap do |gvp|
-        gvp.level = patch_level.first || :major
-        gvp.strict = options[:strict] || options["filter-strict"]
-        gvp.pre = options[:pre]
-      end
-    end
-
-    def self.patch_level_options(options)
-      [:major, :minor, :patch].select {|v| options.keys.include?(v.to_s) }
-    end
-
-    def self.clean_after_install?
-      clean = Bundler.settings[:clean]
-      return clean unless clean.nil?
-      clean ||= Bundler.feature_flag.auto_clean_without_path? && Bundler.settings[:path].nil?
-      clean &&= !Bundler.use_system_gems?
-      clean
-    end
-  end
-end

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

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Config < Thor
-    class_option :parseable, type: :boolean, banner: "Use minimal formatting for more parseable output"
-
-    def self.scope_options
-      method_option :global, type: :boolean, banner: "Only change the global config"
-      method_option :local, type: :boolean, banner: "Only change the local config"
-    end
-    private_class_method :scope_options
-
-    desc "base NAME [VALUE]", "The Bundler 1 config interface", hide: true
-    scope_options
-    method_option :delete, type: :boolean, banner: "delete"
-    def base(name = nil, *value)
-      new_args =
-        if ARGV.size == 1
-          ["config", "list"]
-        elsif ARGV.include?("--delete")
-          ARGV.map {|arg| arg == "--delete" ? "unset" : arg }
-        elsif ARGV.include?("--global") || ARGV.include?("--local") || ARGV.size == 3
-          ["config", "set", *ARGV[1..-1]]
-        else
-          ["config", "get", ARGV[1]]
-        end
-
-      message = "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
-      removed_message = "Using the `config` command without a subcommand [list, get, set, unset] is has been removed. Use `bundle #{new_args.join(" ")}` instead."
-      SharedHelpers.major_deprecation 3, message, removed_message: removed_message
-
-      Base.new(options, name, value, self).run
-    end
-
-    desc "list", "List out all configured settings"
-    def list
-      Base.new(options, nil, nil, self).run
-    end
-
-    desc "get NAME", "Returns the value for the given key"
-    def get(name)
-      Base.new(options, name, nil, self).run
-    end
-
-    desc "set NAME VALUE", "Sets the given value for the given key"
-    scope_options
-    def set(name, value, *value_)
-      Base.new(options, name, value_.unshift(value), self).run
-    end
-
-    desc "unset NAME", "Unsets the value for the given key"
-    scope_options
-    def unset(name)
-      options[:delete] = true
-      Base.new(options, name, nil, self).run
-    end
-
-    default_task :base
-
-    class Base
-      attr_reader :name, :value, :options, :scope, :thor
-
-      def initialize(options, name, value, thor)
-        @options = options
-        @name = name
-        value = Array(value)
-        @value = value.empty? ? nil : value.join(" ")
-        @thor = thor
-        validate_scope!
-      end
-
-      def run
-        unless name
-          warn_unused_scope "Ignoring --#{scope}"
-          confirm_all
-          return
-        end
-
-        if options[:delete]
-          if !explicit_scope? || scope != "global"
-            Bundler.settings.set_local(name, nil)
-          end
-          if !explicit_scope? || scope != "local"
-            Bundler.settings.set_global(name, nil)
-          end
-          return
-        end
-
-        if value.nil?
-          warn_unused_scope "Ignoring --#{scope} since no value to set was given"
-
-          if options[:parseable]
-            if value = Bundler.settings[name]
-              Bundler.ui.info("#{name}=#{value}")
-            end
-            return
-          end
-
-          confirm(name)
-          return
-        end
-
-        Bundler.ui.info(message) if message
-        Bundler.settings.send("set_#{scope}", name, new_value)
-      end
-
-      def confirm_all
-        if @options[:parseable]
-          thor.with_padding do
-            Bundler.settings.all.each do |setting|
-              val = Bundler.settings[setting]
-              Bundler.ui.info "#{setting}=#{val}"
-            end
-          end
-        else
-          Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
-          Bundler.settings.all.each do |setting|
-            Bundler.ui.confirm setting
-            show_pretty_values_for(setting)
-            Bundler.ui.confirm ""
-          end
-        end
-      end
-
-      def confirm(name)
-        Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
-        show_pretty_values_for(name)
-      end
-
-      def new_value
-        pathname = Pathname.new(value)
-        if name.start_with?("local.") && pathname.directory?
-          pathname.expand_path.to_s
-        else
-          value
-        end
-      end
-
-      def message
-        locations = Bundler.settings.locations(name)
-        if @options[:parseable]
-          "#{name}=#{new_value}" if new_value
-        elsif scope == "global"
-          if !locations[:local].nil?
-            "Your application has set #{name} to #{locations[:local].inspect}. " \
-              "This will override the global value you are currently setting"
-          elsif locations[:env]
-            "You have a bundler environment variable for #{name} set to " \
-              "#{locations[:env].inspect}. This will take precedence over the global value you are setting"
-          elsif !locations[:global].nil? && locations[:global] != value
-            "You are replacing the current global value of #{name}, which is currently " \
-              "#{locations[:global].inspect}"
-          end
-        elsif scope == "local" && !locations[:local].nil? && locations[:local] != value
-          "You are replacing the current local value of #{name}, which is currently " \
-            "#{locations[:local].inspect}"
-        end
-      end
-
-      def show_pretty_values_for(setting)
-        thor.with_padding do
-          Bundler.settings.pretty_values_for(setting).each do |line|
-            Bundler.ui.info line
-          end
-        end
-      end
-
-      def explicit_scope?
-        @explicit_scope
-      end
-
-      def warn_unused_scope(msg)
-        return unless explicit_scope?
-        return if options[:parseable]
-
-        Bundler.ui.warn(msg)
-      end
-
-      def validate_scope!
-        @explicit_scope = true
-        scopes = %w[global local].select {|s| options[s] }
-        case scopes.size
-        when 0
-          @scope = inside_app? ? "local" : "global"
-          @explicit_scope = false
-        when 1
-          @scope = scopes.first
-        else
-          raise InvalidOption,
-            "The options #{scopes.join " and "} were specified. Please only use one of the switches at a time."
-        end
-      end
-
-      private
-
-      def inside_app?
-        Bundler.root
-        true
-      rescue GemfileNotFound
-        false
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Console
-    attr_reader :options, :group
-    def initialize(options, group)
-      @options = options
-      @group = group
-    end
-
-    def run
-      group ? Bundler.require(:default, *group.split(" ").map!(&:to_sym)) : Bundler.require
-      ARGV.clear
-
-      console = get_console(Bundler.settings[:console] || "irb")
-      console.start
-    end
-
-    def get_console(name)
-      require name
-      get_constant(name)
-    rescue LoadError
-      Bundler.ui.error "Couldn't load console #{name}, falling back to irb"
-      require "irb"
-      get_constant("irb")
-    end
-
-    def get_constant(name)
-      const_name = {
-        "pry" => :Pry,
-        "ripl" => :Ripl,
-        "irb" => :IRB,
-      }[name]
-      Object.const_get(const_name)
-    rescue NameError
-      Bundler.ui.error "Could not find constant #{const_name}"
-      exit 1
-    end
-  end
-end

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

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-require "rbconfig"
-require "shellwords"
-require "fiddle"
-
-module Bundler
-  class CLI::Doctor
-    DARWIN_REGEX = /\s+(.+) \(compatibility /
-    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/
-
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def otool_available?
-      Bundler.which("otool")
-    end
-
-    def ldd_available?
-      Bundler.which("ldd")
-    end
-
-    def dylibs_darwin(path)
-      output = `/usr/bin/otool -L #{path.shellescape}`.chomp
-      dylibs = output.split("\n")[1..-1].map {|l| l.match(DARWIN_REGEX).captures[0] }.uniq
-      # ignore @rpath and friends
-      dylibs.reject {|dylib| dylib.start_with? "@" }
-    end
-
-    def dylibs_ldd(path)
-      output = `/usr/bin/ldd #{path.shellescape}`.chomp
-      output.split("\n").filter_map do |l|
-        match = l.match(LDD_REGEX)
-        next if match.nil?
-        match.captures[0]
-      end
-    end
-
-    def dylibs(path)
-      case RbConfig::CONFIG["host_os"]
-      when /darwin/
-        return [] unless otool_available?
-        dylibs_darwin(path)
-      when /(linux|solaris|bsd)/
-        return [] unless ldd_available?
-        dylibs_ldd(path)
-      else # Windows, etc.
-        Bundler.ui.warn("Dynamic library check not supported on this platform.")
-        []
-      end
-    end
-
-    def bundles_for_gem(spec)
-      Dir.glob("#{spec.full_gem_path}/**/*.bundle")
-    end
-
-    def check!
-      require_relative "check"
-      Bundler::CLI::Check.new({}).run
-    end
-
-    def run
-      Bundler.ui.level = "warn" if options[:quiet]
-      Bundler.settings.validate!
-      check!
-
-      definition = Bundler.definition
-      broken_links = {}
-
-      definition.specs.each do |spec|
-        bundles_for_gem(spec).each do |bundle|
-          bad_paths = dylibs(bundle).select do |f|
-            Fiddle.dlopen(f)
-            false
-          rescue Fiddle::DLError
-            true
-          end
-          if bad_paths.any?
-            broken_links[spec] ||= []
-            broken_links[spec].concat(bad_paths)
-          end
-        end
-      end
-
-      permissions_valid = check_home_permissions
-
-      if broken_links.any?
-        message = "The following gems are missing OS dependencies:"
-        broken_links.flat_map do |spec, paths|
-          paths.uniq.map do |path|
-            "\n * #{spec.name}: #{path}"
-          end
-        end.sort.each {|m| message += m }
-        raise ProductionError, message
-      elsif !permissions_valid
-        Bundler.ui.info "No issues found with the installed bundle"
-      end
-    end
-
-    private
-
-    def check_home_permissions
-      require "find"
-      files_not_readable_or_writable = []
-      files_not_rw_and_owned_by_different_user = []
-      files_not_owned_by_current_user_but_still_rw = []
-      broken_symlinks = []
-      Find.find(Bundler.bundle_path.to_s).each do |f|
-        if !File.exist?(f)
-          broken_symlinks << f
-        elsif !File.writable?(f) || !File.readable?(f)
-          if File.stat(f).uid != Process.uid
-            files_not_rw_and_owned_by_different_user << f
-          else
-            files_not_readable_or_writable << f
-          end
-        elsif File.stat(f).uid != Process.uid
-          files_not_owned_by_current_user_but_still_rw << f
-        end
-      end
-
-      ok = true
-
-      if broken_symlinks.any?
-        Bundler.ui.warn "Broken links exist in the Bundler home. Please report them to the offending gem's upstream repo. These files are:\n - #{broken_symlinks.join("\n - ")}"
-
-        ok = false
-      end
-
-      if files_not_owned_by_current_user_but_still_rw.any?
-        Bundler.ui.warn "Files exist in the Bundler home that are owned by another " \
-          "user, but are still readable/writable. These files are:\n - #{files_not_owned_by_current_user_but_still_rw.join("\n - ")}"
-
-        ok = false
-      end
-
-      if files_not_rw_and_owned_by_different_user.any?
-        Bundler.ui.warn "Files exist in the Bundler home that are owned by another " \
-          "user, and are not readable/writable. These files are:\n - #{files_not_rw_and_owned_by_different_user.join("\n - ")}"
-
-        ok = false
-      end
-
-      if files_not_readable_or_writable.any?
-        Bundler.ui.warn "Files exist in the Bundler home that are not " \
-          "readable/writable by the current user. These files are:\n - #{files_not_readable_or_writable.join("\n - ")}"
-
-        ok = false
-      end
-
-      ok
-    end
-  end
-end