@appthreat/atom 2.1.10 → 2.1.11

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require "rubygems/dependency"
-require_relative "shared_helpers"
-require_relative "rubygems_ext"
-
-module Bundler
-  class Dependency < Gem::Dependency
-    attr_reader :autorequire
-    attr_reader :groups, :platforms, :gemfile, :path, :git, :github, :branch, :ref, :glob
-
-    ALL_RUBY_VERSIONS = (18..27).to_a.concat((30..34).to_a).freeze
-    PLATFORM_MAP = {
-      ruby: [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
-      mri: [Gem::Platform::RUBY, ALL_RUBY_VERSIONS],
-      rbx: [Gem::Platform::RUBY],
-      truffleruby: [Gem::Platform::RUBY],
-      jruby: [Gem::Platform::JAVA, [18, 19]],
-      windows: [Gem::Platform::WINDOWS, ALL_RUBY_VERSIONS],
-      # deprecated
-      mswin: [Gem::Platform::MSWIN, ALL_RUBY_VERSIONS],
-      mswin64: [Gem::Platform::MSWIN64, ALL_RUBY_VERSIONS - [18]],
-      mingw: [Gem::Platform::MINGW, ALL_RUBY_VERSIONS],
-      x64_mingw: [Gem::Platform::X64_MINGW, ALL_RUBY_VERSIONS - [18, 19]],
-    }.each_with_object({}) do |(platform, spec), hash|
-      hash[platform] = spec[0]
-      spec[1]&.each {|version| hash[:"#{platform}_#{version}"] = spec[0] }
-    end.freeze
-
-    def initialize(name, version, options = {}, &blk)
-      type = options["type"] || :runtime
-      super(name, version, type)
-
-      @autorequire    = nil
-      @groups         = Array(options["group"] || :default).map(&:to_sym)
-      @source         = options["source"]
-      @path           = options["path"]
-      @git            = options["git"]
-      @github         = options["github"]
-      @branch         = options["branch"]
-      @ref            = options["ref"]
-      @glob           = options["glob"]
-      @platforms      = Array(options["platforms"])
-      @env            = options["env"]
-      @should_include = options.fetch("should_include", true)
-      @gemfile        = options["gemfile"]
-      @force_ruby_platform = options["force_ruby_platform"] if options.key?("force_ruby_platform")
-
-      @autorequire = Array(options["require"] || []) if options.key?("require")
-    end
-
-    RUBY_PLATFORM_ARRAY = [Gem::Platform::RUBY].freeze
-    private_constant :RUBY_PLATFORM_ARRAY
-
-    # Returns the platforms this dependency is valid for, in the same order as
-    # passed in the `valid_platforms` parameter
-    def gem_platforms(valid_platforms)
-      return RUBY_PLATFORM_ARRAY if force_ruby_platform
-      return valid_platforms if @platforms.empty?
-
-      valid_platforms.select {|p| expanded_platforms.include?(GemHelpers.generic(p)) }
-    end
-
-    def expanded_platforms
-      @expanded_platforms ||= @platforms.filter_map {|pl| PLATFORM_MAP[pl] }.flatten.uniq
-    end
-
-    def should_include?
-      @should_include && current_env? && current_platform?
-    end
-
-    def gemspec_dev_dep?
-      type == :development
-    end
-
-    def current_env?
-      return true unless @env
-      if @env.is_a?(Hash)
-        @env.all? do |key, val|
-          ENV[key.to_s] && (val.is_a?(String) ? ENV[key.to_s] == val : ENV[key.to_s] =~ val)
-        end
-      else
-        ENV[@env.to_s]
-      end
-    end
-
-    def current_platform?
-      return true if @platforms.empty?
-      @platforms.any? do |p|
-        Bundler.current_ruby.send("#{p}?")
-      end
-    end
-
-    def to_lock
-      out = super
-      out << "!" if source
-      out
-    end
-
-    def specific?
-      super
-    rescue NoMethodError
-      requirement != ">= 0"
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "shared_helpers"
-Bundler::SharedHelpers.major_deprecation 2, "Bundler no longer integrates with " \
-  "Capistrano, but Capistrano provides its own integration with " \
-  "Bundler via the capistrano-bundler gem. Use it instead."
-
-module Bundler
-  class Deployment
-    def self.define_task(context, task_method = :task, opts = {})
-      if defined?(Capistrano) && context.is_a?(Capistrano::Configuration)
-        context_name = "capistrano"
-        role_default = "{:except => {:no_release => true}}"
-        error_type = ::Capistrano::CommandError
-      else
-        context_name = "vlad"
-        role_default = "[:app]"
-        error_type = ::Rake::CommandFailedError
-      end
-
-      roles = context.fetch(:bundle_roles, false)
-      opts[:roles] = roles if roles
-
-      context.send :namespace, :bundle do
-        send :desc, <<-DESC
-          Install the current Bundler environment. By default, gems will be \
-          installed to the shared/bundle path. Gems in the development and \
-          test group will not be installed. The install command is executed \
-          with the --deployment and --quiet flags. If the bundle cmd cannot \
-          be found then you can override the bundle_cmd variable to specify \
-          which one it should use. The base path to the app is fetched from \
-          the :latest_release variable. Set it for custom deploy layouts.
-
-          You can override any of these defaults by setting the variables shown below.
-
-          N.B. bundle_roles must be defined before you require 'bundler/#{context_name}' \
-          in your deploy.rb file.
-
-            set :bundle_gemfile,  "Gemfile"
-            set :bundle_dir,      File.join(fetch(:shared_path), 'bundle')
-            set :bundle_flags,    "--deployment --quiet"
-            set :bundle_without,  [:development, :test]
-            set :bundle_with,     [:mysql]
-            set :bundle_cmd,      "bundle" # e.g. "/opt/ruby/bin/bundle"
-            set :bundle_roles,    #{role_default} # e.g. [:app, :batch]
-        DESC
-        send task_method, :install, opts do
-          bundle_cmd     = context.fetch(:bundle_cmd, "bundle")
-          bundle_flags   = context.fetch(:bundle_flags, "--deployment --quiet")
-          bundle_dir     = context.fetch(:bundle_dir, File.join(context.fetch(:shared_path), "bundle"))
-          bundle_gemfile = context.fetch(:bundle_gemfile, "Gemfile")
-          bundle_without = [*context.fetch(:bundle_without, [:development, :test])].compact
-          bundle_with    = [*context.fetch(:bundle_with, [])].compact
-          app_path = context.fetch(:latest_release)
-          if app_path.to_s.empty?
-            raise error_type.new("Cannot detect current release path - make sure you have deployed at least once.")
-          end
-          args = ["--gemfile #{File.join(app_path, bundle_gemfile)}"]
-          args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
-          args << bundle_flags.to_s
-          args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
-          args << "--with #{bundle_with.join(" ")}" unless bundle_with.empty?
-
-          run "cd #{app_path} && #{bundle_cmd} install #{args.join(" ")}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "rubygems/deprecate"
-rescue LoadError
-  # it's fine if it doesn't exist on the current RubyGems...
-  nil
-end
-
-module Bundler
-  # If Bundler::Deprecate is an autoload constant, we need to define it
-  if defined?(Bundler::Deprecate) && !autoload?(:Deprecate)
-    # nothing to do!
-  elsif defined? ::Deprecate
-    Deprecate = ::Deprecate
-  elsif defined? Gem::Deprecate
-    Deprecate = Gem::Deprecate
-  else
-    class Deprecate
-    end
-  end
-
-  unless Deprecate.respond_to?(:skip_during)
-    def Deprecate.skip_during
-      original = skip
-      self.skip = true
-      yield
-    ensure
-      self.skip = original
-    end
-  end
-
-  unless Deprecate.respond_to?(:skip)
-    def Deprecate.skip
-      @skip ||= false
-    end
-  end
-
-  unless Deprecate.respond_to?(:skip=)
-    def Deprecate.skip=(skip)
-      @skip = skip
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# This code was extracted from https://github.com/Solistra/ruby-digest which is under public domain
-module Bundler
-  module Digest
-    # The initial constant values for the 32-bit constant words A, B, C, D, and
-    # E, respectively.
-    SHA1_WORDS = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0].freeze
-
-    # The 8-bit field used for bitwise `AND` masking. Defaults to `0xFFFFFFFF`.
-    SHA1_MASK = 0xFFFFFFFF
-
-    class << self
-      def sha1(string)
-        unless string.is_a?(String)
-          raise TypeError, "can't convert #{string.class.inspect} into String"
-        end
-
-        buffer = string.b
-
-        words = SHA1_WORDS.dup
-        generate_split_buffer(buffer) do |chunk|
-          w = []
-          chunk.each_slice(4) do |a, b, c, d|
-            w << (((a << 8 | b) << 8 | c) << 8 | d)
-          end
-          a, b, c, d, e = *words
-          (16..79).each do |i|
-            w[i] = SHA1_MASK & rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1)
-          end
-          0.upto(79) do |i|
-            case i
-            when  0..19
-              f = ((b & c) | (~b & d))
-              k = 0x5A827999
-            when 20..39
-              f = (b ^ c ^ d)
-              k = 0x6ED9EBA1
-            when 40..59
-              f = ((b & c) | (b & d) | (c & d))
-              k = 0x8F1BBCDC
-            when 60..79
-              f = (b ^ c ^ d)
-              k = 0xCA62C1D6
-            end
-            t = SHA1_MASK & rotate(a, 5) + f + e + k + w[i]
-            a, b, c, d, e = t, a, SHA1_MASK & rotate(b, 30), c, d # rubocop:disable Style/ParallelAssignment
-          end
-          mutated = [a, b, c, d, e]
-          words.map!.with_index {|word, index| SHA1_MASK & (word + mutated[index]) }
-        end
-
-        words.pack("N*").unpack1("H*")
-      end
-
-      private
-
-      def generate_split_buffer(string, &block)
-        size   = string.bytesize * 8
-        buffer = string.bytes << 128
-        buffer << 0 while buffer.size % 64 != 56
-        buffer.concat([size].pack("Q>").bytes)
-        buffer.each_slice(64, &block)
-      end
-
-      def rotate(value, spaces)
-        value << spaces | value >> (32 - spaces)
-      end
-    end
-  end
-end