@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-5

package/lib/ruby/3.4.11/bundler/dependency.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-require "rubygems/dependency"
-require_relative "shared_helpers"
-
-module Bundler
-  class Dependency < Gem::Dependency
-    def initialize(name, version, options = {}, &blk)
-      type = options["type"] || :runtime
-      super(name, version, type)
-
-      @options = options
-    end
-
-    def groups
-      @groups ||= Array(@options["group"] || :default).map(&:to_sym)
-    end
-
-    def source
-      return @source if defined?(@source)
-
-      @source = @options["source"]
-    end
-
-    def path
-      return @path if defined?(@path)
-
-      @path = @options["path"]
-    end
-
-    def git
-      return @git if defined?(@git)
-
-      @git = @options["git"]
-    end
-
-    def github
-      return @github if defined?(@github)
-
-      @github = @options["github"]
-    end
-
-    def branch
-      return @branch if defined?(@branch)
-
-      @branch = @options["branch"]
-    end
-
-    def ref
-      return @ref if defined?(@ref)
-
-      @ref = @options["ref"]
-    end
-
-    def glob
-      return @glob if defined?(@glob)
-
-      @glob = @options["glob"]
-    end
-
-    def platforms
-      @platforms ||= Array(@options["platforms"])
-    end
-
-    def env
-      return @env if defined?(@env)
-
-      @env = @options["env"]
-    end
-
-    def should_include
-      @should_include ||= @options.fetch("should_include", true)
-    end
-
-    def gemfile
-      return @gemfile if defined?(@gemfile)
-
-      @gemfile = @options["gemfile"]
-    end
-
-    def force_ruby_platform
-      return @force_ruby_platform if defined?(@force_ruby_platform)
-
-      @force_ruby_platform = @options["force_ruby_platform"]
-    end
-
-    def autorequire
-      return @autorequire if defined?(@autorequire)
-
-      @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| CurrentRuby::PLATFORM_MAP[pl] }.flatten.uniq
-    end
-
-    def should_include?
-      should_include && current_env? && current_platform?
-    end
-
-    def gemspec_dev_dep?
-      @gemspec_dev_dep ||= @options.fetch("gemspec_dev_dep", false)
-    end
-
-    def gemfile_dep?
-      !gemspec_dev_dep?
-    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/lib/ruby/3.4.11/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/lib/ruby/3.4.11/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/lib/ruby/3.4.11/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