From 6794f8cf928ab8c009b301ec49a5a81e97e6eb2f Mon Sep 17 00:00:00 2001 From: Hiroshi SHIBATA Date: Wed, 2 Feb 2022 16:57:34 +0900 Subject: Merge pull request #5482 from hsbt/rubygems-3-3-bundler-2-3 Merge RubyGems 3.3.x and Bundler 2.3.x --- common.mk | 8 +- gems/bundled_gems | 2 +- lib/bundler/cli.rb | 13 +- lib/bundler/cli/doctor.rb | 10 +- lib/bundler/cli/gem.rb | 12 +- lib/bundler/cli/platform.rb | 2 +- lib/bundler/cli/update.rb | 8 +- lib/bundler/compact_index_client.rb | 6 - lib/bundler/compact_index_client/cache.rb | 9 - lib/bundler/definition.rb | 11 +- lib/bundler/endpoint_specification.rb | 24 +- lib/bundler/env.rb | 2 +- lib/bundler/fetcher.rb | 13 +- lib/bundler/fetcher/compact_index.rb | 10 - lib/bundler/fetcher/index.rb | 26 --- lib/bundler/gem_helper.rb | 4 +- lib/bundler/lazy_specification.rb | 4 +- lib/bundler/lockfile_generator.rb | 2 +- lib/bundler/remote_specification.rb | 7 + lib/bundler/resolver.rb | 19 +- lib/bundler/resolver/spec_group.rb | 2 +- lib/bundler/ruby_version.rb | 2 +- lib/bundler/self_manager.rb | 120 ++++++++-- lib/bundler/templates/newgem/newgem.gemspec.tt | 2 +- lib/bundler/templates/newgem/standard.yml.tt | 1 + .../newgem/test/minitest/test_newgem.rb.tt | 2 +- .../thor/lib/thor/actions/inject_into_file.rb | 5 +- lib/bundler/vendor/thor/lib/thor/version.rb | 2 +- lib/bundler/version.rb | 2 +- lib/rubygems.rb | 28 +-- lib/rubygems/basic_specification.rb | 16 +- lib/rubygems/bundler_version_finder.rb | 6 +- lib/rubygems/command.rb | 8 +- lib/rubygems/commands/cleanup_command.rb | 12 +- lib/rubygems/commands/dependency_command.rb | 50 ++-- lib/rubygems/commands/fetch_command.rb | 35 ++- lib/rubygems/commands/list_command.rb | 2 +- lib/rubygems/commands/pristine_command.rb | 24 +- lib/rubygems/commands/push_command.rb | 16 +- lib/rubygems/commands/query_command.rb | 2 +- lib/rubygems/commands/rdoc_command.rb | 12 +- lib/rubygems/commands/search_command.rb | 2 +- lib/rubygems/commands/setup_command.rb | 16 +- lib/rubygems/commands/specification_command.rb | 8 +- lib/rubygems/commands/update_command.rb | 19 +- lib/rubygems/config_file.rb | 8 +- lib/rubygems/doctor.rb | 10 +- lib/rubygems/gem_runner.rb | 10 +- lib/rubygems/install_update_options.rb | 8 +- lib/rubygems/installer.rb | 63 ++++- lib/rubygems/package.rb | 22 +- lib/rubygems/package/old.rb | 2 +- lib/rubygems/platform.rb | 84 +++---- lib/rubygems/psych_additions.rb | 2 +- lib/rubygems/query_utils.rb | 34 ++- lib/rubygems/remote_fetcher.rb | 8 +- lib/rubygems/request_set/lockfile.rb | 8 +- lib/rubygems/resolver/installer_set.rb | 18 +- lib/rubygems/safe_yaml.rb | 16 +- lib/rubygems/security.rb | 2 +- lib/rubygems/source.rb | 12 +- lib/rubygems/source_list.rb | 14 +- lib/rubygems/spec_fetcher.rb | 50 ++-- lib/rubygems/specification.rb | 101 ++++---- lib/rubygems/specification_policy.rb | 32 +-- lib/rubygems/stub_specification.rb | 35 ++- lib/rubygems/uninstaller.rb | 14 +- lib/rubygems/user_interaction.rb | 24 +- lib/rubygems/version.rb | 16 +- spec/bundler/bundler/cli_spec.rb | 4 +- .../bundler/bundler/endpoint_specification_spec.rb | 7 +- spec/bundler/bundler/gem_helper_spec.rb | 15 ++ spec/bundler/commands/binstubs_spec.rb | 22 +- spec/bundler/commands/cache_spec.rb | 16 +- spec/bundler/commands/doctor_spec.rb | 6 +- spec/bundler/commands/install_spec.rb | 19 +- spec/bundler/commands/lock_spec.rb | 3 +- spec/bundler/commands/newgem_spec.rb | 24 +- spec/bundler/commands/remove_spec.rb | 4 +- spec/bundler/commands/update_spec.rb | 258 +++++++++++++++++++-- spec/bundler/install/gemfile/gemspec_spec.rb | 73 +++++- spec/bundler/install/gemfile/git_spec.rb | 11 +- spec/bundler/install/gemfile/platform_spec.rb | 10 +- spec/bundler/install/gemfile/ruby_spec.rb | 32 ++- spec/bundler/install/gemfile/sources_spec.rb | 53 +++++ spec/bundler/install/gems/dependency_api_spec.rb | 11 - spec/bundler/install/gems/resolving_spec.rb | 39 +++- spec/bundler/lock/lockfile_spec.rb | 38 ++- spec/bundler/other/platform_spec.rb | 8 +- spec/bundler/runtime/inline_spec.rb | 2 +- spec/bundler/runtime/platform_spec.rb | 14 ++ spec/bundler/runtime/self_management_spec.rb | 62 +++-- .../support/artifice/endpoint_api_missing.rb | 18 -- spec/bundler/support/artifice/vcr.rb | 2 +- spec/bundler/support/hax.rb | 10 - spec/bundler/support/helpers.rb | 10 - spec/bundler/support/rubygems_ext.rb | 2 +- test/rubygems/helper.rb | 20 +- test/rubygems/test_gem.rb | 2 + test/rubygems/test_gem_command_manager.rb | 2 +- test/rubygems/test_gem_commands_fetch_command.rb | 97 ++++++++ test/rubygems/test_gem_commands_install_command.rb | 16 ++ test/rubygems/test_gem_commands_update_command.rb | 59 +++++ test/rubygems/test_gem_installer.rb | 228 +++++++++++++----- test/rubygems/test_gem_package.rb | 4 +- test/rubygems/test_gem_stream_ui.rb | 2 +- test/rubygems/test_gem_stub_specification.rb | 16 -- test/rubygems/test_gem_version.rb | 4 + test/rubygems/utilities.rb | 8 +- tool/bundler/dev_gems.rb | 24 ++ tool/bundler/dev_gems.rb.lock | 73 ++++++ tool/bundler/rubocop_gems.rb.lock | 22 +- tool/bundler/standard_gems.rb.lock | 30 +-- tool/bundler/test_gems.rb.lock | 2 +- tool/sync_default_gems.rb | 1 + 115 files changed, 1687 insertions(+), 875 deletions(-) delete mode 100644 spec/bundler/support/artifice/endpoint_api_missing.rb create mode 100644 tool/bundler/dev_gems.rb create mode 100644 tool/bundler/dev_gems.rb.lock diff --git a/common.mk b/common.mk index 664f750a16..e7a63fea5d 100644 --- a/common.mk +++ b/common.mk @@ -1407,8 +1407,12 @@ yes-test-bundler-precheck: main no-test-bundler-prepare: no-test-bundler-precheck yes-test-bundler-prepare: yes-test-bundler-precheck $(ACTIONS_GROUP) - $(XRUBY) -C "$(srcdir)" bin/gem install --no-document \ - --install-dir .bundle --conservative "rspec:~> 3.8" "rake:~> 13.0" "parallel_tests:~> 2.29" + $(XRUBY) -C $(srcdir) -Ilib \ + -e 'ENV["GEM_HOME"] = File.expand_path(".bundle")' \ + -e 'ENV["BUNDLE_APP_CONFIG"] = File.expand_path(".bundle")' \ + -e 'ENV["BUNDLE_PATH__SYSTEM"] = "true"' \ + -e 'ENV["BUNDLE_WITHOUT"] = "lint doc"' \ + -e 'load "spec/bundler/support/bundle.rb"' -- install --gemfile=tool/bundler/dev_gems.rb $(ACTIONS_ENDGROUP) RSPECOPTS = diff --git a/gems/bundled_gems b/gems/bundled_gems index 0d5cddae80..875910dc7f 100644 --- a/gems/bundled_gems +++ b/gems/bundled_gems @@ -11,6 +11,6 @@ net-pop 0.1.1 https://github.com/ruby/net-pop net-smtp 0.3.1 https://github.com/ruby/net-smtp matrix 0.4.2 https://github.com/ruby/matrix prime 0.1.2 https://github.com/ruby/prime -rbs 2.0.0 https://github.com/ruby/rbs +rbs 2.1.0 https://github.com/ruby/rbs typeprof 0.21.1 https://github.com/ruby/typeprof debug 1.4.0 https://github.com/ruby/debug diff --git a/lib/bundler/cli.rb b/lib/bundler/cli.rb index f6e20e7c67..16651dfad9 100644 --- a/lib/bundler/cli.rb +++ b/lib/bundler/cli.rb @@ -809,17 +809,10 @@ module Bundler current = Gem::Version.new(VERSION) return if current >= latest - latest_installed = Bundler.rubygems.find_name("bundler").map(&:version).max - installation = "To install the latest version, run `gem install bundler#{" --pre" if latest.prerelease?}`" - if latest_installed && latest_installed > current - suggestion = "To update to the most recent installed version (#{latest_installed}), run `bundle update --bundler`" - suggestion = "#{installation}\n#{suggestion}" if latest_installed < latest - else - suggestion = installation - end - - Bundler.ui.warn "The latest bundler is #{latest}, but you are currently running #{current}.\n#{suggestion}" + Bundler.ui.warn \ + "The latest bundler is #{latest}, but you are currently running #{current}.\n" \ + "To update to the most recent version, run `bundle update --bundler`" rescue RuntimeError nil end diff --git a/lib/bundler/cli/doctor.rb b/lib/bundler/cli/doctor.rb index 43f1ca92e2..74444ad0ce 100644 --- a/lib/bundler/cli/doctor.rb +++ b/lib/bundler/cli/doctor.rb @@ -2,6 +2,7 @@ require "rbconfig" require "shellwords" +require "fiddle" module Bundler class CLI::Doctor @@ -71,7 +72,14 @@ module Bundler definition.specs.each do |spec| bundles_for_gem(spec).each do |bundle| - bad_paths = dylibs(bundle).select {|f| !File.exist?(f) } + bad_paths = dylibs(bundle).select do |f| + begin + Fiddle.dlopen(f) + false + rescue Fiddle::DLError + true + end + end if bad_paths.any? broken_links[spec] ||= [] broken_links[spec].concat(bad_paths) diff --git a/lib/bundler/cli/gem.rb b/lib/bundler/cli/gem.rb index 31e3af5580..c4c76d1b69 100644 --- a/lib/bundler/cli/gem.rb +++ b/lib/bundler/cli/gem.rb @@ -38,6 +38,7 @@ module Bundler namespaced_path = name.tr("-", "/") constant_name = name.gsub(/-[_-]*(?![_-]|$)/) { "::" }.gsub(/([_-]+|(::)|^)(.|$)/) { $2.to_s + $3.upcase } constant_array = constant_name.split("::") + minitest_constant_name = constant_array.clone.tap {|a| a[-1] = "Test#{a[-1]}" }.join("::") # Foo::Bar => Foo::TestBar use_git = Bundler.git_present? && options[:git] @@ -69,6 +70,7 @@ module Bundler :git => use_git, :github_username => github_username.empty? ? "[USERNAME]" : github_username, :required_ruby_version => required_ruby_version, + :minitest_constant_name => minitest_constant_name, } ensure_safe_gem_name(name, constant_array) @@ -104,9 +106,17 @@ module Bundler ) config[:test_task] = :spec when "minitest" + # Generate path for minitest target file (FileList["test/**/test_*.rb"]) + # foo => test/test_foo.rb + # foo-bar => test/foo/test_bar.rb + # foo_bar => test/test_foo_bar.rb + paths = namespaced_path.rpartition("/") + paths[2] = "test_#{paths[2]}" + minitest_namespaced_path = paths.join("") + templates.merge!( "test/minitest/test_helper.rb.tt" => "test/test_helper.rb", - "test/minitest/test_newgem.rb.tt" => "test/test_#{namespaced_path}.rb" + "test/minitest/test_newgem.rb.tt" => "test/#{minitest_namespaced_path}.rb" ) config[:test_task] = :test when "test-unit" diff --git a/lib/bundler/cli/platform.rb b/lib/bundler/cli/platform.rb index e97cad49a4..068c765aad 100644 --- a/lib/bundler/cli/platform.rb +++ b/lib/bundler/cli/platform.rb @@ -23,7 +23,7 @@ module Bundler output << "No ruby version specified" end else - output << "Your platform is: #{RUBY_PLATFORM}" + output << "Your platform is: #{Gem::Platform.local}" output << "Your app has gems that work on these platforms:\n#{platforms.join("\n")}" if ruby_version diff --git a/lib/bundler/cli/update.rb b/lib/bundler/cli/update.rb index 95a8886ea5..b49182655b 100644 --- a/lib/bundler/cli/update.rb +++ b/lib/bundler/cli/update.rb @@ -11,12 +11,16 @@ module Bundler def run Bundler.ui.level = "warn" if options[:quiet] + update_bundler = options[:bundler] + + Bundler.self_manager.update_bundler_and_restart_with_it_if_needed(update_bundler) if update_bundler + Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins? sources = Array(options[:source]) groups = Array(options[:group]).map(&:to_sym) - full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !options[:bundler] + full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !update_bundler if full_update && !options[:all] if Bundler.feature_flag.update_requires_all_flag? @@ -49,7 +53,7 @@ module Bundler Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby], :conservative => conservative, - :bundler => options[:bundler]) + :bundler => update_bundler) end Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options) diff --git a/lib/bundler/compact_index_client.rb b/lib/bundler/compact_index_client.rb index d5dbeb3b10..127a50e810 100644 --- a/lib/bundler/compact_index_client.rb +++ b/lib/bundler/compact_index_client.rb @@ -73,12 +73,6 @@ module Bundler end.flatten(1) end - def spec(name, version, platform = nil) - Bundler::CompactIndexClient.debug { "spec(name = #{name}, version = #{version}, platform = #{platform})" } - update_info(name) - @cache.specific_dependency(name, version, platform) - end - def update_and_parse_checksums! Bundler::CompactIndexClient.debug { "update_and_parse_checksums!" } return @info_checksums_by_name if @parsed_checksums diff --git a/lib/bundler/compact_index_client/cache.rb b/lib/bundler/compact_index_client/cache.rb index c2cd069ec1..2d83777139 100644 --- a/lib/bundler/compact_index_client/cache.rb +++ b/lib/bundler/compact_index_client/cache.rb @@ -76,15 +76,6 @@ module Bundler end end - def specific_dependency(name, version, platform) - pattern = [version, platform].compact.join("-") - return nil if pattern.empty? - - gem_lines = info_path(name).read - gem_line = gem_lines[/^#{Regexp.escape(pattern)}\b.*/, 0] - gem_line ? parse_gem(gem_line) : nil - end - private def lines(path) diff --git a/lib/bundler/definition.rb b/lib/bundler/definition.rb index 5cde1285a6..fbe6b2c872 100644 --- a/lib/bundler/definition.rb +++ b/lib/bundler/definition.rb @@ -265,7 +265,7 @@ module Bundler else # Run a resolve against the locally available gems Bundler.ui.debug("Found changes from the lockfile, re-resolving dependencies because #{change_reason}") - expanded_dependencies = expand_dependencies(dependencies + metadata_dependencies, @remote) + expanded_dependencies = expand_dependencies(dependencies + metadata_dependencies, true) Resolver.resolve(expanded_dependencies, source_requirements, last_resolve, gem_version_promoter, additional_base_requirements_for_resolve, platforms) end end @@ -309,14 +309,6 @@ module Bundler end end - def locked_bundler_version - if @locked_bundler_version && @locked_bundler_version < Gem::Version.new(Bundler::VERSION) - new_version = Bundler::VERSION - end - - new_version || @locked_bundler_version || Bundler::VERSION - end - def locked_ruby_version return unless ruby_version if @unlock[:ruby] || !@locked_ruby_version @@ -503,6 +495,7 @@ module Bundler def current_ruby_platform_locked? return false unless generic_local_platform == Gem::Platform::RUBY + return false if Bundler.settings[:force_ruby_platform] && !@platforms.include?(Gem::Platform::RUBY) current_platform_locked? end diff --git a/lib/bundler/endpoint_specification.rb b/lib/bundler/endpoint_specification.rb index 6cf597b943..f3260a38e6 100644 --- a/lib/bundler/endpoint_specification.rb +++ b/lib/bundler/endpoint_specification.rb @@ -5,14 +5,15 @@ module Bundler class EndpointSpecification < Gem::Specification include MatchPlatform - attr_reader :name, :version, :platform, :required_rubygems_version, :required_ruby_version, :checksum + attr_reader :name, :version, :platform, :checksum attr_accessor :source, :remote, :dependencies - def initialize(name, version, platform, dependencies, metadata = nil) + def initialize(name, version, platform, spec_fetcher, dependencies, metadata = nil) super() @name = name @version = Gem::Version.create version @platform = platform + @spec_fetcher = spec_fetcher @dependencies = dependencies.map {|dep, reqs| build_dependency(dep, reqs) } @loaded_from = nil @@ -21,6 +22,14 @@ module Bundler parse_metadata(metadata) end + def required_ruby_version + @required_ruby_version ||= _remote_specification.required_ruby_version + end + + def required_rubygems_version + @required_rubygems_version ||= _remote_specification.required_rubygems_version + end + def fetch_platform @platform end @@ -105,12 +114,21 @@ module Bundler private + def _remote_specification + @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform]) + end + def local_specification_path "#{base_dir}/specifications/#{full_name}.gemspec" end def parse_metadata(data) - return unless data + unless data + @required_ruby_version = nil + @required_rubygems_version = nil + return + end + data.each do |k, v| next unless v case k.to_s diff --git a/lib/bundler/env.rb b/lib/bundler/env.rb index 00d4ef2196..1763035a8a 100644 --- a/lib/bundler/env.rb +++ b/lib/bundler/env.rb @@ -71,7 +71,7 @@ module Bundler def self.ruby_version str = String.new(RUBY_VERSION) str << "p#{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL - str << " (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION}) [#{RUBY_PLATFORM}]" + str << " (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION}) [#{Gem::Platform.local}]" end def self.git_version diff --git a/lib/bundler/fetcher.rb b/lib/bundler/fetcher.rb index a453157e68..89103fe1ec 100644 --- a/lib/bundler/fetcher.rb +++ b/lib/bundler/fetcher.rb @@ -129,17 +129,15 @@ module Bundler specs = fetchers.last.specs(gem_names) else specs = [] - fetchers.shift until fetchers.first.available? || fetchers.empty? - fetchers.dup.each do |f| - break unless f.api_fetcher? && !gem_names || !specs = f.specs(gem_names) - fetchers.delete(f) + @fetchers = fetchers.drop_while do |f| + !f.available? || (f.api_fetcher? && !gem_names) || !specs = f.specs(gem_names) end @use_api = false if fetchers.none?(&:api_fetcher?) end specs.each do |name, version, platform, dependencies, metadata| spec = if dependencies - EndpointSpecification.new(name, version, platform, dependencies, metadata) + EndpointSpecification.new(name, version, platform, self, dependencies, metadata) else RemoteSpecification.new(name, version, platform, self) end @@ -272,8 +270,7 @@ module Bundler # cached gem specification path, if one exists def gemspec_cached_path(spec_file_name) paths = Bundler.rubygems.spec_cache_dirs.map {|dir| File.join(dir, spec_file_name) } - paths = paths.select {|path| File.file? path } - paths.first + paths.find {|path| File.file? path } end HTTP_ERRORS = [ @@ -301,8 +298,6 @@ module Bundler store end - private - def remote_uri @remote.uri end diff --git a/lib/bundler/fetcher/compact_index.rb b/lib/bundler/fetcher/compact_index.rb index aa828af6b1..b23176588f 100644 --- a/lib/bundler/fetcher/compact_index.rb +++ b/lib/bundler/fetcher/compact_index.rb @@ -57,16 +57,6 @@ module Bundler gem_info end - def fetch_spec(spec) - spec -= [nil, "ruby", ""] - contents = compact_index_client.spec(*spec) - return nil if contents.nil? - contents.unshift(spec.first) - contents[3].map! {|d| Gem::Dependency.new(*d) } - EndpointSpecification.new(*contents) - end - compact_index_request :fetch_spec - def available? unless SharedHelpers.md5_available? Bundler.ui.debug("FIPS mode is enabled, bundler can't use the CompactIndex API") diff --git a/lib/bundler/fetcher/index.rb b/lib/bundler/fetcher/index.rb index 0d14c47aa7..6bb9fcc193 100644 --- a/lib/bundler/fetcher/index.rb +++ b/lib/bundler/fetcher/index.rb @@ -21,32 +21,6 @@ module Bundler raise HTTPError, "Could not fetch specs from #{display_uri} due to underlying error <#{e.message}>" end end - - def fetch_spec(spec) - spec -= [nil, "ruby", ""] - spec_file_name = "#{spec.join "-"}.gemspec" - - uri = Bundler::URI.parse("#{remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}.rz") - if uri.scheme == "file" - path = Bundler.rubygems.correct_for_windows_path(uri.path) - Bundler.load_marshal Bundler.rubygems.inflate(Gem.read_binary(path)) - elsif cached_spec_path = gemspec_cached_path(spec_file_name) - Bundler.load_gemspec(cached_spec_path) - else - Bundler.load_marshal Bundler.rubygems.inflate(downloader.fetch(uri).body) - end - rescue MarshalError - raise HTTPError, "Gemspec #{spec} contained invalid data.\n" \ - "Your network or your gem server is probably having issues right now." - end - - private - - # cached gem specification path, if one exists - def gemspec_cached_path(spec_file_name) - paths = Bundler.rubygems.spec_cache_dirs.map {|dir| File.join(dir, spec_file_name) } - paths.find {|path| File.file? path } - end end end end diff --git a/lib/bundler/gem_helper.rb b/lib/bundler/gem_helper.rb index 034f2e5960..0bbd2d9b75 100644 --- a/lib/bundler/gem_helper.rb +++ b/lib/bundler/gem_helper.rb @@ -107,9 +107,9 @@ module Bundler 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.new.hexdigest(built_gem_path.to_s) + checksum = ::Digest::SHA512.file(built_gem_path).hexdigest target = File.join(base, "checksums", file_name) - File.write(target, checksum) + File.write(target, checksum + "\n") Bundler.ui.confirm "#{name} #{version} checksum written to checksums/#{file_name}." end diff --git a/lib/bundler/lazy_specification.rb b/lib/bundler/lazy_specification.rb index 4eb228f314..fd7c8defdc 100644 --- a/lib/bundler/lazy_specification.rb +++ b/lib/bundler/lazy_specification.rb @@ -90,11 +90,11 @@ module Bundler MatchPlatform.platforms_match?(spec.platform, platform_object) end installable_candidates = same_platform_candidates.select do |spec| - !spec.is_a?(EndpointSpecification) || + spec.is_a?(StubSpecification) || (spec.required_ruby_version.satisfied_by?(Gem.ruby_version) && spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version)) end - search = installable_candidates.last || same_platform_candidates.last + search = installable_candidates.last search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification)) search end diff --git a/lib/bundler/lockfile_generator.rb b/lib/bundler/lockfile_generator.rb index 3bc6bd7339..0578a93fdc 100644 --- a/lib/bundler/lockfile_generator.rb +++ b/lib/bundler/lockfile_generator.rb @@ -71,7 +71,7 @@ module Bundler end def add_bundled_with - add_section("BUNDLED WITH", definition.locked_bundler_version.to_s) + add_section("BUNDLED WITH", Bundler::VERSION) end def add_section(name, value) diff --git a/lib/bundler/remote_specification.rb b/lib/bundler/remote_specification.rb index 89b69e1045..4e966b820a 100644 --- a/lib/bundler/remote_specification.rb +++ b/lib/bundler/remote_specification.rb @@ -27,6 +27,13 @@ module Bundler @platform = _remote_specification.platform end + # A fallback is included because the original version of the specification + # API didn't include that field, so some marshalled specs in the index have it + # set to +nil+. + def required_rubygems_version + @required_rubygems_version ||= _remote_specification.required_rubygems_version || Gem::Requirement.default + end + def full_name if platform == Gem::Platform::RUBY || platform.nil? "#{@name}-#{@version}" diff --git a/lib/bundler/resolver.rb b/lib/bundler/resolver.rb index 22d61fba36..be0751d9d2 100644 --- a/lib/bundler/resolver.rb +++ b/lib/bundler/resolver.rb @@ -249,10 +249,11 @@ module Bundler end def verify_gemfile_dependencies_are_found!(requirements) - requirements.each do |requirement| + requirements.map! do |requirement| name = requirement.name - next if name == "bundler" - next unless search_for(requirement).empty? + next requirement if name == "bundler" + next requirement unless search_for(requirement).empty? + next unless requirement.current_platform? if (base = @base[name]) && !base.empty? version = base.first.version @@ -266,7 +267,7 @@ module Bundler message = gem_not_found_message(name, requirement, source_for(name)) end raise GemNotFound, message - end + end.compact! end def gem_not_found_message(name, requirement, source, extra_message = "") @@ -358,24 +359,18 @@ module Bundler o << "\n" o << %(Running `bundle update` will rebuild your snapshot from scratch, using only\n) o << %(the gems in your Gemfile, which may resolve the conflict.\n) - elsif !conflict.existing + elsif !conflict.existing && !name.end_with?("\0") o << "\n" relevant_source = conflict.requirement.source || source_for(name) - metadata_requirement = name.end_with?("\0") - extra_message = if conflict.requirement_trees.first.size > 1 ", which is required by gem '#{SharedHelpers.pretty_dependency(conflict.requirement_trees.first[-2])}'," else "" end - if metadata_requirement - o << "#{SharedHelpers.pretty_dependency(conflict.requirement)}#{extra_message} is not available in #{relevant_source}" - else - o << gem_not_found_message(name, conflict.requirement, relevant_source, extra_message) - end + o << gem_not_found_message(name, conflict.requirement, relevant_source, extra_message) end end, :version_for_spec => lambda {|spec| spec.version }, diff --git a/lib/bundler/resolver/spec_group.rb b/lib/bundler/resolver/spec_group.rb index 8f4fd18c46..232520de77 100644 --- a/lib/bundler/resolver/spec_group.rb +++ b/lib/bundler/resolver/spec_group.rb @@ -95,7 +95,7 @@ module Bundler def metadata_dependencies(platform) spec = @specs[platform].first - return [] unless spec.is_a?(Gem::Specification) + return [] if spec.is_a?(LazySpecification) dependencies = [] if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none? dependencies << DepProxy.get_proxy(Gem::Dependency.new("Ruby\0", spec.required_ruby_version), platform) diff --git a/lib/bundler/ruby_version.rb b/lib/bundler/ruby_version.rb index 491f8c55a4..d3b7963920 100644 --- a/lib/bundler/ruby_version.rb +++ b/lib/bundler/ruby_version.rb @@ -103,7 +103,7 @@ module Bundler def self.system ruby_engine = RUBY_ENGINE.dup - ruby_version = ENV.fetch("BUNDLER_SPEC_RUBY_VERSION") { RUBY_VERSION }.dup + ruby_version = RUBY_VERSION.dup ruby_engine_version = RUBY_ENGINE_VERSION.dup patchlevel = RUBY_PATCHLEVEL.to_s diff --git a/lib/bundler/self_manager.rb b/lib/bundler/self_manager.rb index d62ef6ca12..827f3f9222 100644 --- a/lib/bundler/self_manager.rb +++ b/lib/bundler/self_manager.rb @@ -9,7 +9,7 @@ module Bundler def restart_with_locked_bundler_if_needed return unless needs_switching? && installed? - restart_with_locked_bundler + restart_with(lockfile_version) end def install_locked_bundler_and_restart_with_it_if_needed @@ -19,23 +19,48 @@ module Bundler "Bundler #{current_version} is running, but your lockfile was generated with #{lockfile_version}. " \ "Installing Bundler #{lockfile_version} and restarting using that version." - install_and_restart_with_locked_bundler + install_and_restart_with(lockfile_version) + end + + def update_bundler_and_restart_with_it_if_needed(target) + return unless autoswitching_applies? + + spec = resolve_update_version_from(target) + return unless spec + + version = spec.version + + Bundler.ui.info "Updating bundler to #{version}." + + install(spec) + + restart_with(version) end private - def install_and_restart_with_locked_bundler - bundler_dep = Gem::Dependency.new("bundler", lockfile_version) + def install_and_restart_with(version) + requirement = Gem::Requirement.new(version) + spec = find_latest_matching_spec(requirement) - Gem.install(bundler_dep) + if spec.nil? + Bundler.ui.warn "Your lockfile is locked to a version of bundler (#{lockfile_version}) that doesn't exist at https://rubygems.org/. Going on using #{current_version}" + return + end + + install(spec) rescue StandardError => e Bundler.ui.trace e Bundler.ui.warn "There was an error installing the locked bundler version (#{lockfile_version}), rerun with the `--verbose` flag for more details. Going on using bundler #{current_version}." else - restart_with_locked_bundler + restart_with(version) + end + + def install(spec) + spec.source.install(spec) end - def restart_with_locked_bundler + def restart_with(version) configured_gem_home = ENV["GEM_HOME"] configured_gem_path = ENV["GEM_PATH"] @@ -44,33 +69,100 @@ module Bundler Bundler.with_original_env do Kernel.exec( - { "GEM_HOME" => configured_gem_home, "GEM_PATH" => configured_gem_path, "BUNDLER_VERSION" => lockfile_version }, + { "GEM_HOME" => configured_gem_home, "GEM_PATH" => configured_gem_path, "BUNDLER_VERSION" => version.to_s }, *cmd ) end end def needs_switching? + autoswitching_applies? && + released?(lockfile_version) && + !running?(lockfile_version) && + !updating? + end + + def autoswitching_applies? ENV["BUNDLER_VERSION"].nil? && Bundler.rubygems.supports_bundler_trampolining? && SharedHelpers.in_bundle? && - lockfile_version && - !lockfile_version.end_with?(".dev") && - lockfile_version != current_version + lockfile_version + end + + def resolve_update_version_from(target) + requirement = Gem::Requirement.new(target) + update_candidate = find_latest_matching_spec(requirement) + + if update_candidate.nil? + raise InvalidOption, "The `bundle update --bundler` target version (#{target}) does not exist" + end + + resolved_version = update_candidate.version + needs_update = requirement.specific? ? !running?(resolved_version) : running_older_than?(resolved_version) + + return unless needs_update + + update_candidate + end + + def local_specs + @local_specs ||= Bundler::Source::Rubygems.new("allow_local" => true).specs.select {|spec| spec.name == "bundler" } + end + + def remote_specs + @remote_specs ||= begin + source = Bundler::Source::Rubygems.new("remotes" => "https://rubygems.org") + source.remote! + source.add_dependency_names("bundler") + source.specs + end + end + + def find_latest_matching_spec(requirement) + local_result = find_latest_matching_spec_from_collection(local_specs, requirement) + return local_result if local_result && requirement.specific? + + remote_result = find_latest_matching_spec_from_collection(remote_specs, requirement) + return remote_result if local_result.nil? + + [local_result, remote_result].max + end + + def find_latest_matching_spec_from_collection(specs, requirement) + specs.sort.reverse_each.find {|spec| requirement.satisfied_by?(spec.version) } + end + + def running?(version) + version == current_version + end + + def running_older_than?(version) + current_version < version + end + + def released?(version) + !version.to_s.end_with?(".dev") + end + + def updating? + "update".start_with?(ARGV.first || " ") && ARGV[1..-1].any? {|a| a.start_with?("--bundler") } end def installed? Bundler.configure - Bundler.rubygems.find_bundler(lockfile_version) + Bundler.rubygems.find_bundler(lockfile_version.to_s) end def current_version - @current_version ||= Bundler::VERSION + @current_version ||= Gem::Version.new(Bundler::VERSION) end def lockfile_version - @lockfile_version ||= Bundler::LockfileParser.bundled_with + return @lockfile_version if defined?(@lockfile_version) + + parsed_version = Bundler::LockfileParser.bundled_with + @lockfile_version = parsed_version ? Gem::Version.new(parsed_version) : nil end end end diff --git a/lib/bundler/templates/newgem/newgem.gemspec.tt b/lib/bundler/templates/newgem/newgem.gemspec.tt index e07ec5867d..546a28b78a 100644 --- a/lib/bundler/templates/newgem/newgem.gemspec.tt +++ b/lib/bundler/templates/newgem/newgem.gemspec.tt @@ -26,7 +26,7 @@ Gem::Specification.new do |spec| # The `git ls-files -z` loads the files in the RubyGem that have been added into git. spec.files = Dir.chdir(File.expand_path(__dir__)) do `git ls-files -z`.split("\x0").reject do |f| - (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}) + (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}) end end spec.bindir = "exe" diff --git a/lib/bundler/templates/newgem/standard.yml.tt b/lib/bundler/templates/newgem/standard.yml.tt index 9e88fbbe8b..934b0b2c37 100644 --- a/lib/bundler/templates/newgem/standard.yml.tt +++ b/lib/bundler/templates/newgem/standard.yml.tt @@ -1,2 +1,3 @@ # For available configuration options, see: # https://github.com/testdouble/standard +ruby_version: <%= ::Gem::Version.new(config[:required_ruby_version]).segments[0..1].join(".") %> diff --git a/lib/bundler/templates/newgem/test/minitest/test_newgem.rb.tt b/lib/bundler/templates/newgem/test/minitest/test_newgem.rb.tt index 5eb8fcbf9d..4b35a63071 100644 --- a/lib/bundler/templates/newgem/test/minitest/test_newgem.rb.tt +++ b/lib/bundler/templates/newgem/test/minitest/test_newgem.rb.tt @@ -2,7 +2,7 @@ require "test_helper" -class Test<%= config[:constant_name] %> < Minitest::Test +class <%= config[:minitest_constant_name] %> < Minitest::Test def test_that_it_has_a_version_number refute_nil ::<%= config[:constant_name] %>::VERSION end diff --git a/lib/bundler/vendor/thor/lib/thor/actions/inject_into_file.rb b/lib/bundler/vendor/thor/lib/thor/actions/inject_into_file.rb index f52ced2bcd..bf013307f1 100644 --- a/lib/bundler/vendor/thor/lib/thor/actions/inject_into_file.rb +++ b/lib/bundler/vendor/thor/lib/thor/actions/inject_into_file.rb @@ -107,10 +107,7 @@ class Bundler::Thor # def replace!(regexp, string, force) content = File.read(destination) - before, after = content.split(regexp, 2) - snippet = (behavior == :after ? after : before).to_s - - if force || !snippet.include?(replacement) + if force || !content.include?(replacement) success = content.gsub!(regexp, string) File.open(destination, "wb") { |file| file.write(content) } unless pretend? diff --git a/lib/bundler/vendor/thor/lib/thor/version.rb b/lib/bundler/vendor/thor/lib/thor/version.rb index a3efa9f762..48a4788b3b 100644 --- a/lib/bundler/vendor/thor/lib/thor/version.rb +++ b/lib/bundler/vendor/thor/lib/thor/version.rb @@ -1,3 +1,3 @@ class Bundler::Thor - VERSION = "1.1.0" + VERSION = "1.2.1" end diff --git a/lib/bundler/version.rb b/lib/bundler/version.rb index a7d32cb0a1..99bceb5afd 100644 --- a/lib/bundler/version.rb +++ b/lib/bundler/version.rb @@ -1,7 +1,7 @@ # frozen_string_literal: false module Bundler - VERSION = "2.3.3".freeze + VERSION = "2.3.6".freeze def self.bundler_major_version @bundler_major_version ||= VERSION.split(".").first.to_i diff --git a/lib/rubygems.rb b/lib/rubygems.rb index e24580c5b8..e96a418f9f 100644 --- a/lib/rubygems.rb +++ b/lib/rubygems.rb @@ -8,7 +8,7 @@ require 'rbconfig' module Gem - VERSION = "3.3.3".freeze + VERSION = "3.3.6".freeze end # Must be first since it unloads the prelude from 1.9.2 @@ -606,17 +606,10 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} def self.load_yaml return if @yaml_loaded - begin - # Try requiring the gem version *or* stdlib version of psych. - require 'psych' - rescue ::LoadError - # If we can't load psych, that's fine, go on. - else - require_relative 'rubygems/psych_additions' - require_relative 'rubygems/psych_tree' - end + require 'psych' + require_relative 'rubygems/psych_additions' + require_relative 'rubygems/psych_tree' - require 'yaml' require_relative 'rubygems/safe_yaml' @yaml_loaded = true @@ -766,11 +759,11 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} # Safely read a file in binary mode on all platforms. def self.read_binary(path) - open_with_flock(path, 'rb+') do |io| + open_file(path, 'rb+') do |io| io.read end rescue Errno::EACCES, Errno::EROFS - open_with_flock(path, 'rb') do |io| + open_file(path, 'rb') do |io| io.read end end @@ -778,17 +771,17 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} ## # Safely write a file in binary mode on all platforms. def self.write_binary(path, data) - open_with_flock(path, 'wb') do |io| + open_file(path, 'wb') do |io| io.write data end end ## - # Open a file with given flags, and protect access with flock + # Open a file with given flags, and on Windows protect access with flock - def self.open_with_flock(path, flags, &block) + def self.open_file(path, flags, &block) File.open(path, flags) do |io| - if !java_platform? && !solaris_platform? + if !java_platform? && win_platform? begin io.flock(File::LOCK_EX) rescue Errno::ENOSYS, Errno::ENOTSUP @@ -1316,6 +1309,7 @@ An Array (#{env.inspect}) was passed in from #{caller[3]} autoload :Source, File.expand_path('rubygems/source', __dir__) autoload :SourceList, File.expand_path('rubygems/source_list', __dir__) autoload :SpecFetcher, File.expand_path('rubygems/spec_fetcher', __dir__) + autoload :SpecificationPolicy, File.expand_path('rubygems/specification_policy', __dir__) autoload :Util, File.expand_path('rubygems/util', __dir__) autoload :Version, File.expand_path('rubygems/version', __dir__) end diff --git a/lib/rubygems/basic_specification.rb b/lib/rubygems/basic_specification.rb index 665b87fc0e..b3b63b51aa 100644 --- a/lib/rubygems/basic_specification.rb +++ b/lib/rubygems/basic_specification.rb @@ -289,14 +289,14 @@ class Gem::BasicSpecification def lib_dirs_glob dirs = if self.raw_require_paths - if self.raw_require_paths.size > 1 - "{#{self.raw_require_paths.join(',')}}" - else - self.raw_require_paths.first - end - else - "lib" # default value for require_paths for bundler/inline - end + if self.raw_require_paths.size > 1 + "{#{self.raw_require_paths.join(',')}}" + else + self.raw_require_paths.first + end + else + "lib" # default value for require_paths for bundler/inline + end "#{self.full_gem_path}/#{dirs}".dup.tap(&Gem::UNTAINT) end diff --git a/lib/rubygems/bundler_version_finder.rb b/lib/rubygems/bundler_version_finder.rb index 14179aebf3..f6fad0bd83 100644 --- a/lib/rubygems/bundler_version_finder.rb +++ b/lib/rubygems/bundler_version_finder.rb @@ -65,9 +65,9 @@ module Gem::BundlerVersionFinder return unless gemfile lockfile = case gemfile - when "gems.rb" then "gems.locked" - else "#{gemfile}.lock" - end.dup.tap(&Gem::UNTAINT) + when "gems.rb" then "gems.locked" + else "#{gemfile}.lock" + end.dup.tap(&Gem::UNTAINT) return unless File.file?(lockfile) diff --git a/lib/rubygems/command.rb b/lib/rubygems/command.rb index abdaa8e7c6..f74cb419f9 100644 --- a/lib/rubygems/command.rb +++ b/lib/rubygems/command.rb @@ -398,10 +398,10 @@ class Gem::Command version_to_expire = deprecation["rg_version_to_expire"] deprecate_option_msg = if version_to_expire - "The \"#{option}\" option has been deprecated and will be removed in Rubygems #{version_to_expire}." - else - "The \"#{option}\" option has been deprecated and will be removed in future versions of Rubygems." - end + "The \"#{option}\" option has been deprecated and will be removed in Rubygems #{version_to_expire}." + else + "The \"#{option}\" option has been deprecated and will be removed in future versions of Rubygems." + end extra_msg = deprecation["extra_msg"] diff --git a/lib/rubygems/commands/cleanup_command.rb b/lib/rubygems/commands/cleanup_command.rb index c965085880..dc181e4de0 100644 --- a/lib/rubygems/commands/cleanup_command.rb +++ b/lib/rubygems/commands/cleanup_command.rb @@ -117,12 +117,12 @@ If no gems are named all gems in GEM_HOME are cleaned. def get_candidate_gems @candidate_gems = unless options[:args].empty? - options[:args].map do |gem_name| - Gem::Specification.find_all_by_name gem_name - end.flatten - else - Gem::Specification.to_a - end + options[:args].map do |gem_name| + Gem::Specification.find_all_by_name gem_name + end.flatten + else + Gem::Specification.to_a + end end def get_gems_to_cleanup diff --git a/lib/rubygems/commands/dependency_command.rb b/lib/rubygems/commands/dependency_command.rb index 7d217076a5..d2fed022fe 100644 --- a/lib/rubygems/commands/dependency_command.rb +++ b/lib/rubygems/commands/dependency_command.rb @@ -53,41 +53,41 @@ use with other commands. "#{program_name} REGEXP" end - def fetch_remote_specs(dependency) # :nodoc: + def fetch_remote_specs(name, requirement, prerelease) # :nodoc: fetcher = Gem::SpecFetcher.fetcher - ss, = fetcher.spec_for_dependency dependency + specs_type = prerelease ? :complete : :released - ss.map {|spec, _| spec } + ss = if name.nil? + fetcher.detect(specs_type) { true } + else + fetcher.detect(specs_type) do |name_tuple| + name === name_tuple.name && requirement.satisfied_by?(name_tuple.version) + end + end + + ss.map {|tuple, source| source.fetch_spec(tuple) } end - def fetch_specs(name_pattern, dependency) # :nodoc: + def fetch_specs(name_pattern, requirement, prerelease) # :nodoc: specs = [] if local? specs.concat Gem::Specification.stubs.find_all {|spec| - name_pattern =~ spec.name and - dependency.requirement.satisfied_by? spec.version + name_matches = name_pattern ? name_pattern =~ spec.name : true + version_matches = requirement.satisfied_by?(spec.version) + + name_matches and version_matches }.map(&:to_spec) end - specs.concat fetch_remote_specs dependency if remote? + specs.concat fetch_remote_specs name_pattern, requirement, prerelease if remote? ensure_specs specs specs.uniq.sort end - def gem_dependency(pattern, version, prerelease) # :nodoc: - dependency = Gem::Deprecate.skip_during do - Gem::Dependency.new pattern, version - end - - dependency.prerelease = prerelease - - dependency - end - def display_pipe(specs) # :nodoc: specs.each do |spec| unless spec.dependencies.empty? @@ -119,11 +119,9 @@ use with other commands. ensure_local_only_reverse_dependencies pattern = name_pattern options[:args] + requirement = Gem::Requirement.new options[:version] - dependency = - gem_dependency pattern, options[:version], options[:prerelease] - - specs = fetch_specs pattern, dependency + specs = fetch_specs pattern, requirement, options[:prerelease] reverse = reverse_dependencies specs @@ -162,14 +160,6 @@ use with other commands. response end - def remote_specs(dependency) # :nodoc: - fetcher = Gem::SpecFetcher.fetcher - - ss, _ = fetcher.spec_for_dependency dependency - - ss.map {|s,o| s } - end - def reverse_dependencies(specs) # :nodoc: reverse = Hash.new {|h, k| h[k] = [] } @@ -205,7 +195,7 @@ use with other commands. private def name_pattern(args) - args << '' if args.empty? + return if args.empty? if args.length == 1 and args.first =~ /\A(.*)(i)?\z/m flags = $2 ? Regexp::IGNORECASE : nil diff --git a/lib/rubygems/commands/fetch_command.rb b/lib/rubygems/commands/fetch_command.rb index 373851643d..c8ecb0d48c 100644 --- a/lib/rubygems/commands/fetch_command.rb +++ b/lib/rubygems/commands/fetch_command.rb @@ -8,7 +8,12 @@ class Gem::Commands::FetchCommand < Gem::Command include Gem::VersionOption def initialize - super 'fetch', 'Download a gem and place it in the current directory' + defaults = { + :suggest_alternate => true, + :version => Gem::Requirement.default, + } + + super 'fetch', 'Download a gem and place it in the current directory', defaults add_bulk_threshold_option add_proxy_option @@ -18,6 +23,10 @@ class Gem::Commands::FetchCommand < Gem::Command add_version_option add_platform_option add_prerelease_option + + add_option '--[no-]suggestions', 'Suggest alternates when gems are not found' do |value, options| + options[:suggest_alternate] = value + end end def arguments # :nodoc: @@ -42,15 +51,27 @@ then repackaging it. "#{program_name} GEMNAME [GEMNAME ...]" end + def check_version # :nodoc: + if options[:version] != Gem::Requirement.default and + get_all_gem_names.size > 1 + alert_error "Can't use --version with multiple gems. You can specify multiple gems with" \ + " version requirements using `gem fetch 'my_gem:1.0.0' 'my_other_gem:~>2.0.0'`" + terminate_interaction 1 + end + end + def execute - version = options[:version] || Gem::Requirement.default + check_version + version = options[:version] platform = Gem.platforms.last - gem_names = get_all_gem_names + gem_names = get_all_gem_names_and_versions - gem_names.each do |gem_name| - dep = Gem::Dependency.new gem_name, version + gem_names.each do |gem_name, gem_version| + gem_version ||= version + dep = Gem::Dependency.new gem_name, gem_version dep.prerelease = options[:prerelease] + suppress_suggestions = !options[:suggest_alternate] specs_and_sources, errors = Gem::SpecFetcher.fetcher.spec_for_dependency dep @@ -63,12 +84,10 @@ then repackaging it. spec, source = specs_and_sources.max_by {|s,| s } if spec.nil? - show_lookup_failure gem_name, version, errors, options[:domain] + show_lookup_failure gem_name, gem_version, errors, suppress_suggestions, options[:domain] next end - source.download spec - say "Downloaded #{spec.full_name}" end end diff --git a/lib/rubygems/commands/list_command.rb b/lib/rubygems/commands/list_command.rb index dea11111c9..010d968f9c 100644 --- a/lib/rubygems/commands/list_command.rb +++ b/lib/rubygems/commands/list_command.rb @@ -10,7 +10,7 @@ class Gem::Commands::ListCommand < Gem::Command def initialize super 'list', 'Display local gems whose name matches REGEXP', - :name => //, :domain => :local, :details => false, :versions => true, + :domain => :local, :details => false, :versions => true, :installed => nil, :version => Gem::Requirement.default add_query_options diff --git a/lib/rubygems/commands/pristine_command.rb b/lib/rubygems/commands/pristine_command.rb index 13979b0a59..3cf496ba5b 100644 --- a/lib/rubygems/commands/pristine_command.rb +++ b/lib/rubygems/commands/pristine_command.rb @@ -98,20 +98,20 @@ extensions will be restored. def execute specs = if options[:all] - Gem::Specification.map + Gem::Specification.map - # `--extensions` must be explicitly given to pristine only gems - # with extensions. - elsif options[:extensions_set] and + # `--extensions` must be explicitly given to pristine only gems + # with extensions. + elsif options[:extensions_set] and options[:extensions] and options[:args].empty? - Gem::Specification.select do |spec| - spec.extensions and not spec.extensions.empty? - end - else - get_all_gem_names.sort.map do |gem_name| - Gem::Specification.find_all_by_name(gem_name, options[:version]).reverse - end.flatten - end + Gem::Specification.select do |spec| + spec.extensions and not spec.extensions.empty? + end + else + get_all_gem_names.sort.map do |gem_name| + Gem::Specification.find_all_by_name(gem_name, options[:version]).reverse + end.flatten + end specs = specs.select{|spec| RUBY_ENGINE == spec.platform || Gem::Platform.local === spec.platform || spec.platform == Gem::Platform::RUBY } diff --git a/lib/rubygems/commands/push_command.rb b/lib/rubygems/commands/push_command.rb index 1864b4b095..4d0d5a9f4b 100644 --- a/lib/rubygems/commands/push_command.rb +++ b/lib/rubygems/commands/push_command.rb @@ -52,14 +52,14 @@ The push command will use ~/.gem/credentials to authenticate to a server, but yo default_gem_server, push_host = get_hosts_for(gem_name) @host = if @user_defined_host - options[:host] - elsif default_gem_server - default_gem_server - elsif push_host - push_host - else - options[:host] - end + options[:host] + elsif default_gem_server + default_gem_server + elsif push_host + push_host + else + options[:host] + end sign_in @host, scope: get_push_scope diff --git a/lib/rubygems/commands/query_command.rb b/lib/rubygems/commands/query_command.rb index 5896bec44e..442c4b19bb 100644 --- a/lib/rubygems/commands/query_command.rb +++ b/lib/rubygems/commands/query_command.rb @@ -20,7 +20,7 @@ class Gem::Commands::QueryCommand < Gem::Command def initialize(name = 'query', summary = 'Query gem information in local or remote repositories') super name, summary, - :name => //, :domain => :local, :details => false, :versions => true, + :domain => :local, :details => false, :versions => true, :installed => nil, :version => Gem::Requirement.default add_option('-n', '--name-matches REGEXP', diff --git a/lib/rubygems/commands/rdoc_command.rb b/lib/rubygems/commands/rdoc_command.rb index 305c80ccfe..7c5d6212f5 100644 --- a/lib/rubygems/commands/rdoc_command.rb +++ b/lib/rubygems/commands/rdoc_command.rb @@ -61,12 +61,12 @@ Use --overwrite to force rebuilding of documentation. def execute specs = if options[:all] - Gem::Specification.to_a - else - get_all_gem_names.map do |name| - Gem::Specification.find_by_name name, options[:version] - end.flatten.uniq - end + Gem::Specification.to_a + else + get_all_gem_names.map do |name| + Gem::Specification.find_by_name name, options[:version] + end.flatten.uniq + end if specs.empty? alert_error 'No matching gems found' diff --git a/lib/rubygems/commands/search_command.rb b/lib/rubygems/commands/search_command.rb index 488d777939..75d99986f9 100644 --- a/lib/rubygems/commands/search_command.rb +++ b/lib/rubygems/commands/search_command.rb @@ -7,7 +7,7 @@ class Gem::Commands::SearchCommand < Gem::Command def initialize super 'search', 'Display remote gems whose name matches REGEXP', - :name => //, :domain => :remote, :details => false, :versions => true, + :domain => :remote, :details => false, :versions => true, :installed => nil, :version => Gem::Requirement.default add_query_options diff --git a/lib/rubygems/commands/setup_command.rb b/lib/rubygems/commands/setup_command.rb index 0601dccb07..01714f0342 100644 --- a/lib/rubygems/commands/setup_command.rb +++ b/lib/rubygems/commands/setup_command.rb @@ -54,10 +54,10 @@ class Gem::Commands::SetupCommand < Gem::Command 'List the documentation types you wish to', 'generate. For example: rdoc,ri' do |value, options| options[:document] = case value - when nil then %w[rdoc ri] - when false then [] - else value - end + when nil then %w[rdoc ri] + when false then [] + else value + end end add_option '--[no-]rdoc', @@ -666,10 +666,10 @@ abort "#{deprecation_message}" def target_bin_path(bin_dir, bin_file) bin_file_formatted = if options[:format_executable] - Gem.default_exec_format % bin_file - else - bin_file - end + Gem.default_exec_format % bin_file + else + bin_file + end File.join bin_dir, bin_file_formatted end diff --git a/lib/rubygems/commands/specification_command.rb b/lib/rubygems/commands/specification_command.rb index 473b6e7b19..6f24787962 100644 --- a/lib/rubygems/commands/specification_command.rb +++ b/lib/rubygems/commands/specification_command.rb @@ -140,10 +140,10 @@ Specific fields in the specification can be extracted in YAML format: s = s.send field if field say case options[:format] - when :ruby then s.to_ruby - when :marshal then Marshal.dump s - else s.to_yaml - end + when :ruby then s.to_ruby + when :marshal then Marshal.dump s + else s.to_yaml + end say "\n" end diff --git a/lib/rubygems/commands/update_command.rb b/lib/rubygems/commands/update_command.rb index 513351d303..42d6f6046b 100644 --- a/lib/rubygems/commands/update_command.rb +++ b/lib/rubygems/commands/update_command.rb @@ -233,10 +233,10 @@ command to remove old versions. up_ver = gems_to_update.first.version target = if update_latest - up_ver - else - version - end + up_ver + else + version + end return target, requirement end @@ -286,10 +286,11 @@ command to remove old versions. check_oldest_rubygems version - update_gem 'rubygems-update', version - installed_gems = Gem::Specification.find_all_by_name 'rubygems-update', requirement - version = installed_gems.first.version + installed_gems = update_gem('rubygems-update', version) if installed_gems.empty? || installed_gems.first.version != version + return if installed_gems.empty? + + version = installed_gems.first.version install_rubygems version end @@ -335,7 +336,9 @@ command to remove old versions. # def oldest_supported_version @oldest_supported_version ||= - if Gem.ruby_version > Gem::Version.new("3.0.a") + if Gem.ruby_version > Gem::Version.new("3.1.a") + Gem::Version.new("3.3.3") + elsif Gem.ruby_version > Gem::Version.new("3.0.a") Gem::Version.new("3.2.3") elsif Gem.ruby_version > Gem::Version.new("2.7.a") Gem::Version.new("3.1.2") diff --git a/lib/rubygems/config_file.rb b/lib/rubygems/config_file.rb index 60c1d50ba9..5dd2bfe88d 100644 --- a/lib/rubygems/config_file.rb +++ b/lib/rubygems/config_file.rb @@ -281,10 +281,10 @@ if you believe they were disclosed to a third party. check_credentials_permissions @api_keys = if File.exist? credentials_path - load_file(credentials_path) - else - @hash - end + load_file(credentials_path) + else + @hash + end if @api_keys.key? :rubygems_api_key @rubygems_api_key = @api_keys[:rubygems_api_key] diff --git a/lib/rubygems/doctor.rb b/lib/rubygems/doctor.rb index 41bcda9804..d14c64a166 100644 --- a/lib/rubygems/doctor.rb +++ b/lib/rubygems/doctor.rb @@ -117,11 +117,11 @@ class Gem::Doctor type = File.directory?(child) ? 'directory' : 'file' action = if @dry_run - 'Extra' - else - FileUtils.rm_r(child) - 'Removed' - end + 'Extra' + else + FileUtils.rm_r(child) + 'Removed' + end say "#{action} #{type} #{sub_directory}/#{File.basename(child)}" end diff --git a/lib/rubygems/gem_runner.rb b/lib/rubygems/gem_runner.rb index 55b5a7d067..89b23b26aa 100644 --- a/lib/rubygems/gem_runner.rb +++ b/lib/rubygems/gem_runner.rb @@ -42,11 +42,11 @@ class Gem::GemRunner cmd.command_names.each do |command_name| config_args = Gem.configuration[command_name] config_args = case config_args - when String - config_args.split ' ' - else - Array(config_args) - end + when String + config_args.split ' ' + else + Array(config_args) + end Gem::Command.add_specific_extra_args command_name, config_args end diff --git a/lib/rubygems/install_update_options.rb b/lib/rubygems/install_update_options.rb index 2203b17f8e..454104435d 100644 --- a/lib/rubygems/install_update_options.rb +++ b/lib/rubygems/install_update_options.rb @@ -35,10 +35,10 @@ module Gem::InstallUpdateOptions 'List the documentation types you wish to', 'generate. For example: rdoc,ri') do |value, options| options[:document] = case value - when nil then %w[ri] - when false then [] - else value - end + when nil then %w[ri] + when false then [] + else value + end end add_option(:"Install/Update", '--build-root DIR', diff --git a/lib/rubygems/installer.rb b/lib/rubygems/installer.rb index ab09c18280..4cda09f200 100644 --- a/lib/rubygems/installer.rb +++ b/lib/rubygems/installer.rb @@ -201,8 +201,8 @@ class Gem::Installer # # If +@force+ is set +filename+ is overwritten. # - # If +filename+ exists and is a RubyGems wrapper for different gem the user - # is consulted. + # If +filename+ exists and it is a RubyGems wrapper for a different gem, then + # the user is consulted. # # If +filename+ exists and +@bin_dir+ is Gem.default_bindir (/usr/local) the # user is consulted. @@ -220,7 +220,17 @@ class Gem::Installer existing = nil File.open generated_bin, 'rb' do |io| - next unless io.gets =~ /^#!/ # shebang + line = io.gets + shebang = /^#!.*ruby/ + + if load_relative_enabled? + until line.nil? || line =~ shebang do + line = io.gets + end + end + + next unless line =~ shebang + io.gets # blankline # TODO detect a specially formatted comment instead of trying @@ -585,7 +595,6 @@ class Gem::Installer # def shebang(bin_file_name) - ruby_name = RbConfig::CONFIG['ruby_install_name'] if @env_shebang path = File.join gem_dir, spec.bindir, bin_file_name first_line = File.open(path, "rb") {|file| file.gets } || "" @@ -598,7 +607,7 @@ class Gem::Installer if which = Gem.configuration[:custom_shebang] # replace bin_file_name with "ruby" to avoid endless loops - which = which.gsub(/ #{bin_file_name}$/," #{RbConfig::CONFIG['ruby_install_name']}") + which = which.gsub(/ #{bin_file_name}$/," #{ruby_install_name}") which = which.gsub(/\$(\w+)/) do case $1 @@ -614,14 +623,12 @@ class Gem::Installer end "#!#{which}" - elsif not ruby_name - "#!#{Gem.ruby}#{opts}" - elsif opts - "#!/bin/sh\n'exec' #{ruby_name.dump} '-x' \"$0\" \"$@\"\n#{shebang}" - else + elsif @env_shebang # Create a plain shebang line. @env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path } - "#!#{@env_path} #{ruby_name}" + "#!#{@env_path} #{ruby_install_name}" + else + "#{bash_prolog_script}#!#{Gem.ruby}#{opts}" end end @@ -805,7 +812,6 @@ TEXT # return the stub script text used to launch the true Ruby script def windows_stub_script(bindir, bin_file_name) - rb_config = RbConfig::CONFIG rb_topdir = RbConfig::TOPDIR || File.dirname(rb_config["bindir"]) # get ruby executable file name from RbConfig @@ -973,4 +979,37 @@ TEXT Gem::Command.build_args end end + + def rb_config + RbConfig::CONFIG + end + + def ruby_install_name + rb_config["ruby_install_name"] + end + + def load_relative_enabled? + rb_config["LIBRUBY_RELATIVE"] == 'yes' + end + + def bash_prolog_script + if load_relative_enabled? + script = +<<~EOS + bindir="${0%/*}" + EOS + + script << %Q(exec "$bindir/#{ruby_install_name}" "-x" "$0" "$@"\n) + + <<~EOS + #!/bin/sh + # -*- ruby -*- + _=_\\ + =begin + #{script.chomp} + =end + EOS + else + "" + end + end end diff --git a/lib/rubygems/package.rb b/lib/rubygems/package.rb index 94705914af..a81c5f307c 100644 --- a/lib/rubygems/package.rb +++ b/lib/rubygems/package.rb @@ -146,12 +146,12 @@ class Gem::Package def self.new(gem, security_policy = nil) gem = if gem.is_a?(Gem::Package::Source) - gem - elsif gem.respond_to? :read - Gem::Package::IOSource.new gem - else - Gem::Package::FileSource.new gem - end + gem + elsif gem.respond_to? :read + Gem::Package::IOSource.new gem + else + Gem::Package::FileSource.new gem + end return super unless Gem::Package == self return super unless gem.present? @@ -230,7 +230,7 @@ class Gem::Package tar.add_file_signed 'checksums.yaml.gz', 0444, @signer do |io| gzip_to io do |gz_io| - YAML.dump checksums_by_algorithm, gz_io + Psych.dump checksums_by_algorithm, gz_io end end end @@ -353,10 +353,10 @@ EOM def digest(entry) # :nodoc: algorithms = if @checksums - @checksums.keys - else - [Gem::Security::DIGEST_NAME].compact - end + @checksums.keys + else + [Gem::Security::DIGEST_NAME].compact + end algorithms.each do |algorithm| digester = Gem::Security.create_digest(algorithm) diff --git a/lib/rubygems/package/old.rb b/lib/rubygems/package/old.rb index 25317ef23f..301d403411 100644 --- a/lib/rubygems/package/old.rb +++ b/lib/rubygems/package/old.rb @@ -145,7 +145,7 @@ class Gem::Package::Old < Gem::Package begin @spec = Gem::Specification.from_yaml yaml - rescue YAML::SyntaxError + rescue Psych::SyntaxError raise Gem::Exception, "Failed to parse gem specification out of gem file" end rescue ArgumentError diff --git a/lib/rubygems/platform.rb b/lib/rubygems/platform.rb index a5e65f9243..f48f4bdc76 100644 --- a/lib/rubygems/platform.rb +++ b/lib/rubygems/platform.rb @@ -78,9 +78,9 @@ class Gem::Platform cpu = arch.shift @cpu = case cpu - when /i\d86/ then 'x86' - else cpu - end + when /i\d86/ then 'x86' + else cpu + end if arch.length == 2 and arch.last =~ /^\d+(\.\d+)?$/ # for command-line @os, @version = arch @@ -91,32 +91,32 @@ class Gem::Platform @cpu, os = nil, cpu if os.nil? # legacy jruby @os, @version = case os - when /aix(\d+)?/ then [ 'aix', $1 ] - when /cygwin/ then [ 'cygwin', nil ] - when /darwin(\d+)?/ then [ 'darwin', $1 ] - when /^macruby$/ then [ 'macruby', nil ] - when /freebsd(\d+)?/ then [ 'freebsd', $1 ] - when /hpux(\d+)?/ then [ 'hpux', $1 ] - when /^java$/, /^jruby$/ then [ 'java', nil ] - when /^java([\d.]*)/ then [ 'java', $1 ] - when /^dalvik(\d+)?$/ then [ 'dalvik', $1 ] - when /^dotnet$/ then [ 'dotnet', nil ] - when /^dotnet([\d.]*)/ then [ 'dotnet', $1 ] - when /linux-?((?!gnu)\w+)?/ then [ 'linux', $1 ] - when /mingw32/ then [ 'mingw32', nil ] - when /mingw-?(\w+)?/ then [ 'mingw', $1 ] - when /(mswin\d+)(\_(\d+))?/ then - os, version = $1, $3 - @cpu = 'x86' if @cpu.nil? and os =~ /32$/ - [os, version] - when /netbsdelf/ then [ 'netbsdelf', nil ] - when /openbsd(\d+\.\d+)?/ then [ 'openbsd', $1 ] - when /bitrig(\d+\.\d+)?/ then [ 'bitrig', $1 ] - when /solaris(\d+\.\d+)?/ then [ 'solaris', $1 ] - # test - when /^(\w+_platform)(\d+)?/ then [ $1, $2 ] - else [ 'unknown', nil ] - end + when /aix(\d+)?/ then [ 'aix', $1 ] + when /cygwin/ then [ 'cygwin', nil ] + when /darwin(\d+)?/ then [ 'darwin', $1 ] + when /^macruby$/ then [ 'macruby', nil ] + when /freebsd(\d+)?/ then [ 'freebsd', $1 ] + when /hpux(\d+)?/ then [ 'hpux', $1 ] + when /^java$/, /^jruby$/ then [ 'java', nil ] + when /^java([\d.]*)/ then [ 'java', $1 ] + when /^dalvik(\d+)?$/ then [ 'dalvik', $1 ] + when /^dotnet$/ then [ 'dotnet', nil ] + when /^dotnet([\d.]*)/ then [ 'dotnet', $1 ] + when /linux-?((?!gnu)\w+)?/ then [ 'linux', $1 ] + when /mingw32/ then [ 'mingw32', nil ] + when /mingw-?(\w+)?/ then [ 'mingw', $1 ] + when /(mswin\d+)(\_(\d+))?/ then + os, version = $1, $3 + @cpu = 'x86' if @cpu.nil? and os =~ /32$/ + [os, version] + when /netbsdelf/ then [ 'netbsdelf', nil ] + when /openbsd(\d+\.\d+)?/ then [ 'openbsd', $1 ] + when /bitrig(\d+\.\d+)?/ then [ 'bitrig', $1 ] + when /solaris(\d+\.\d+)?/ then [ 'solaris', $1 ] + # test + when /^(\w+_platform)(\d+)?/ then [ $1, $2 ] + else [ 'unknown', nil ] + end when Gem::Platform then @cpu = arch.cpu @os = arch.os @@ -180,19 +180,19 @@ class Gem::Platform when String then # This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007 other = case other - when /^i686-darwin(\d)/ then ['x86', 'darwin', $1 ] - when /^i\d86-linux/ then ['x86', 'linux', nil ] - when 'java', 'jruby' then [nil, 'java', nil ] - when /^dalvik(\d+)?$/ then [nil, 'dalvik', $1 ] - when /dotnet(\-(\d+\.\d+))?/ then ['universal','dotnet', $2 ] - when /mswin32(\_(\d+))?/ then ['x86', 'mswin32', $2 ] - when /mswin64(\_(\d+))?/ then ['x64', 'mswin64', $2 ] - when 'powerpc-darwin' then ['powerpc', 'darwin', nil ] - when /powerpc-darwin(\d)/ then ['powerpc', 'darwin', $1 ] - when /sparc-solaris2.8/ then ['sparc', 'solaris', '2.8' ] - when /universal-darwin(\d)/ then ['universal', 'darwin', $1 ] - else other - end + when /^i686-darwin(\d)/ then ['x86', 'darwin', $1 ] + when /^i\d86-linux/ then ['x86', 'linux', nil ] + when 'java', 'jruby' then [nil, 'java', nil ] + when /^dalvik(\d+)?$/ then [nil, 'dalvik', $1 ] + when /dotnet(\-(\d+\.\d+))?/ then ['universal','dotnet', $2 ] + when /mswin32(\_(\d+))?/ then ['x86', 'mswin32', $2 ] + when /mswin64(\_(\d+))?/ then ['x64', 'mswin64', $2 ] + when 'powerpc-darwin' then ['powerpc', 'darwin', nil ] + when /powerpc-darwin(\d)/ then ['powerpc', 'darwin', $1 ] + when /sparc-solaris2.8/ then ['sparc', 'solaris', '2.8' ] + when /universal-darwin(\d)/ then ['universal', 'darwin', $1 ] + else other + end other = Gem::Platform.new other else diff --git a/lib/rubygems/psych_additions.rb b/lib/rubygems/psych_additions.rb index 1ddd74421c..a13c1ec676 100644 --- a/lib/rubygems/psych_additions.rb +++ b/lib/rubygems/psych_additions.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true # This exists just to satisfy bugs in marshal'd gemspecs that -# contain a reference to YAML::PrivateType. We prune these out +# contain a reference to Psych::PrivateType. We prune these out # in Specification._load, but if we don't have the constant, Marshal # blows up. diff --git a/lib/rubygems/query_utils.rb b/lib/rubygems/query_utils.rb index 0acd5bf9c8..f4cfea3087 100644 --- a/lib/rubygems/query_utils.rb +++ b/lib/rubygems/query_utils.rb @@ -54,14 +54,14 @@ module Gem::QueryUtils end def defaults_str # :nodoc: - "--local --name-matches // --no-details --versions --no-installed" + "--local --no-details --versions --no-installed" end def execute - gem_names = Array(options[:name]) - - if !args.empty? - gem_names = options[:exact] ? args.map{|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map{|arg| /#{arg}/i } + gem_names = if args.empty? + [options[:name]] + else + options[:exact] ? args.map{|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map{|arg| /#{arg}/i } end terminate_interaction(check_installed_gems(gem_names)) if check_installed_gems? @@ -96,7 +96,7 @@ module Gem::QueryUtils end def gem_name? - !options[:name].source.empty? + !options[:name].nil? end def prerelease @@ -129,12 +129,10 @@ module Gem::QueryUtils display_header("LOCAL") specs = Gem::Specification.find_all do |s| - s.name =~ name and req =~ s.version - end + name_matches = name ? s.name =~ name : true + version_matches = show_prereleases? || !s.version.prerelease? - dep = Gem::Deprecate.skip_during { Gem::Dependency.new name, req } - specs.select! do |s| - dep.match?(s.name, s.version, show_prereleases?) + name_matches and version_matches end spec_tuples = specs.map do |spec| @@ -149,13 +147,13 @@ module Gem::QueryUtils fetcher = Gem::SpecFetcher.fetcher - spec_tuples = if name.respond_to?(:source) && name.source.empty? - fetcher.detect(specs_type) { true } - else - fetcher.detect(specs_type) do |name_tuple| - name === name_tuple.name - end - end + spec_tuples = if name.nil? + fetcher.detect(specs_type) { true } + else + fetcher.detect(specs_type) do |name_tuple| + name === name_tuple.name + end + end output_query_results(spec_tuples) end diff --git a/lib/rubygems/remote_fetcher.rb b/lib/rubygems/remote_fetcher.rb index bd8165e3c7..b8f9f90cee 100644 --- a/lib/rubygems/remote_fetcher.rb +++ b/lib/rubygems/remote_fetcher.rb @@ -172,10 +172,10 @@ class Gem::RemoteFetcher when nil then # TODO test for local overriding cache source_path = if Gem.win_platform? && source_uri.scheme && !source_uri.path.include?(':') - "#{source_uri.scheme}:#{source_uri.path}" - else - source_uri.path - end + "#{source_uri.scheme}:#{source_uri.path}" + else + source_uri.path + end source_path = Gem::UriFormatter.new(source_path).unescape diff --git a/lib/rubygems/request_set/lockfile.rb b/lib/rubygems/request_set/lockfile.rb index bec29ef1b9..684d3fc7fe 100644 --- a/lib/rubygems/request_set/lockfile.rb +++ b/lib/rubygems/request_set/lockfile.rb @@ -56,10 +56,10 @@ class Gem::RequestSet::Lockfile deps[name] = if [Gem::Resolver::VendorSpecification, Gem::Resolver::GitSpecification].include? spec.class - Gem::Requirement.source_set - else - requirement - end + Gem::Requirement.source_set + else + requirement + end end deps diff --git a/lib/rubygems/resolver/installer_set.rb b/lib/rubygems/resolver/installer_set.rb index 237bc3f782..45252ed241 100644 --- a/lib/rubygems/resolver/installer_set.rb +++ b/lib/rubygems/resolver/installer_set.rb @@ -76,21 +76,21 @@ class Gem::Resolver::InstallerSet < Gem::Resolver::Set newest = found.last + unless newest + exc = Gem::UnsatisfiableDependencyError.new request + exc.errors = errors + + raise exc + end + unless @force found_matching_metadata = found.reverse.find do |spec| metadata_satisfied?(spec) end if found_matching_metadata.nil? - if newest - ensure_required_ruby_version_met(newest.spec) - ensure_required_rubygems_version_met(newest.spec) - else - exc = Gem::UnsatisfiableDependencyError.new request - exc.errors = errors - - raise exc - end + ensure_required_ruby_version_met(newest.spec) + ensure_required_rubygems_version_met(newest.spec) else newest = found_matching_metadata end diff --git a/lib/rubygems/safe_yaml.rb b/lib/rubygems/safe_yaml.rb index e905052e1c..81f99ee26e 100644 --- a/lib/rubygems/safe_yaml.rb +++ b/lib/rubygems/safe_yaml.rb @@ -24,33 +24,33 @@ module Gem runtime ].freeze - if ::YAML.respond_to? :safe_load + if ::Psych.respond_to? :safe_load def self.safe_load(input) if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0.pre1') - ::YAML.safe_load(input, permitted_classes: PERMITTED_CLASSES, permitted_symbols: PERMITTED_SYMBOLS, aliases: true) + ::Psych.safe_load(input, permitted_classes: PERMITTED_CLASSES, permitted_symbols: PERMITTED_SYMBOLS, aliases: true) else - ::YAML.safe_load(input, PERMITTED_CLASSES, PERMITTED_SYMBOLS, true) + ::Psych.safe_load(input, PERMITTED_CLASSES, PERMITTED_SYMBOLS, true) end end def self.load(input) if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0.pre1') - ::YAML.safe_load(input, permitted_classes: [::Symbol]) + ::Psych.safe_load(input, permitted_classes: [::Symbol]) else - ::YAML.safe_load(input, [::Symbol]) + ::Psych.safe_load(input, [::Symbol]) end end else unless Gem::Deprecate.skip - warn "YAML safe loading is not available. Please upgrade psych to a version that supports safe loading (>= 2.0)." + warn "Psych safe loading is not available. Please upgrade psych to a version that supports safe loading (>= 2.0)." end def self.safe_load(input, *args) - ::YAML.load input + ::Psych.load input end def self.load(input) - ::YAML.load input + ::Psych.load input end end end diff --git a/lib/rubygems/security.rb b/lib/rubygems/security.rb index f21c175642..fc23c1c481 100644 --- a/lib/rubygems/security.rb +++ b/lib/rubygems/security.rb @@ -261,7 +261,7 @@ require_relative 'openssl' # 2. Grab the public key from the gemspec # # gem spec some_signed_gem-1.0.gem cert_chain | \ -# ruby -ryaml -e 'puts YAML.load($stdin)' > public_key.crt +# ruby -rpsych -e 'puts Psych.load($stdin)' > public_key.crt # # 3. Generate a SHA1 hash of the data.tar.gz # diff --git a/lib/rubygems/source.rb b/lib/rubygems/source.rb index f03e09872c..85c300a8f8 100644 --- a/lib/rubygems/source.rb +++ b/lib/rubygems/source.rb @@ -81,12 +81,12 @@ class Gem::Source return Gem::Resolver::IndexSet.new self if 'file' == uri.scheme fetch_uri = if uri.host == "rubygems.org" - index_uri = uri.dup - index_uri.host = "index.rubygems.org" - index_uri - else - uri - end + index_uri = uri.dup + index_uri.host = "index.rubygems.org" + index_uri + else + uri + end bundler_api_uri = enforce_trailing_slash(fetch_uri) diff --git a/lib/rubygems/source_list.rb b/lib/rubygems/source_list.rb index 13b25b63dc..16e90e1ef7 100644 --- a/lib/rubygems/source_list.rb +++ b/lib/rubygems/source_list.rb @@ -51,13 +51,13 @@ class Gem::SourceList require "uri" src = case obj - when URI - Gem::Source.new(obj) - when Gem::Source - obj - else - Gem::Source.new(URI.parse(obj)) - end + when URI + Gem::Source.new(obj) + when Gem::Source + obj + else + Gem::Source.new(URI.parse(obj)) + end @sources << src unless @sources.include?(src) src diff --git a/lib/rubygems/spec_fetcher.rb b/lib/rubygems/spec_fetcher.rb index b97bd49692..15bfbb6f8d 100644 --- a/lib/rubygems/spec_fetcher.rb +++ b/lib/rubygems/spec_fetcher.rb @@ -191,10 +191,10 @@ class Gem::SpecFetcher end matches = if matches.empty? && type != :prerelease - suggest_gems_from_name gem_name, :prerelease - else - matches.uniq.sort_by {|name, dist| dist } - end + suggest_gems_from_name gem_name, :prerelease + else + matches.uniq.sort_by {|name, dist| dist } + end matches.map {|name, dist| name }.uniq.first(num_results) end @@ -216,27 +216,27 @@ class Gem::SpecFetcher @sources.each_source do |source| begin names = case type - when :latest - tuples_for source, :latest - when :released - tuples_for source, :released - when :complete - names = - tuples_for(source, :prerelease, true) + - tuples_for(source, :released) - - names.sort - when :abs_latest - names = - tuples_for(source, :prerelease, true) + - tuples_for(source, :latest) - - names.sort - when :prerelease - tuples_for(source, :prerelease) - else - raise Gem::Exception, "Unknown type - :#{type}" - end + when :latest + tuples_for source, :latest + when :released + tuples_for source, :released + when :complete + names = + tuples_for(source, :prerelease, true) + + tuples_for(source, :released) + + names.sort + when :abs_latest + names = + tuples_for(source, :prerelease, true) + + tuples_for(source, :latest) + + names.sort + when :prerelease + tuples_for(source, :prerelease) + else + raise Gem::Exception, "Unknown type - :#{type}" + end rescue Gem::RemoteFetcher::FetchError => e errors << Gem::SourceFetchProblem.new(source, e) else diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb index 031a37f775..43ab917d19 100644 --- a/lib/rubygems/specification.rb +++ b/lib/rubygems/specification.rb @@ -11,7 +11,6 @@ require_relative 'basic_specification' require_relative 'stub_specification' require_relative 'platform' require_relative 'requirement' -require_relative 'specification_policy' require_relative 'util/list' ## @@ -163,15 +162,15 @@ class Gem::Specification < Gem::BasicSpecification @@default_value.each do |k,v| INITIALIZE_CODE_FOR_DEFAULTS[k] = case v - when [], {}, true, false, nil, Numeric, Symbol - v.inspect - when String - v.dump - when Numeric - "default_value(:#{k})" - else - "default_value(:#{k}).dup" - end + when [], {}, true, false, nil, Numeric, Symbol + v.inspect + when String + v.dump + when Numeric + "default_value(:#{k})" + else + "default_value(:#{k}).dup" + end end @@attributes = @@default_value.keys.sort_by {|s| s.to_s } @@ -226,7 +225,7 @@ class Gem::Specification < Gem::BasicSpecification attr_reader :version ## - # A short summary of this gem's description. Displayed in `gem list -d`. + # A short summary of this gem's description. Displayed in gem list -d. # # The #description should be more detailed than the summary. # @@ -272,7 +271,7 @@ class Gem::Specification < Gem::BasicSpecification # A list of authors for this gem. # # Alternatively, a single author can be specified by assigning a string to - # `spec.author` + # +spec.author+ # # Usage: # @@ -1116,7 +1115,7 @@ class Gem::Specification < Gem::BasicSpecification file = file.dup.tap(&Gem::UNTAINT) return unless File.file?(file) - code = Gem.open_with_flock(file, 'r:UTF-8:-', &:read) + code = Gem.open_file(file, 'r:UTF-8:-', &:read) code.tap(&Gem::UNTAINT) @@ -1269,21 +1268,21 @@ class Gem::Specification < Gem::BasicSpecification current_version = CURRENT_SPECIFICATION_VERSION field_count = if spec.specification_version > current_version - spec.instance_variable_set :@specification_version, - current_version - MARSHAL_FIELDS[current_version] - else - MARSHAL_FIELDS[spec.specification_version] - end + spec.instance_variable_set :@specification_version, + current_version + MARSHAL_FIELDS[current_version] + else + MARSHAL_FIELDS[spec.specification_version] + end if array.size < field_count raise TypeError, "invalid Gem::Specification format #{array.inspect}" end - # Cleanup any YAML::PrivateType. They only show up for an old bug + # Cleanup any Psych::PrivateType. They only show up for an old bug # where nil => null, so just convert them to nil based on the type. - array.map! {|e| e.kind_of?(YAML::PrivateType) ? nil : e } + array.map! {|e| e.kind_of?(Psych::PrivateType) ? nil : e } spec.instance_variable_set :@rubygems_version, array[0] # spec version @@ -1474,10 +1473,10 @@ class Gem::Specification < Gem::BasicSpecification def add_dependency_with_type(dependency, type, requirements) requirements = if requirements.empty? - Gem::Requirement.default - else - requirements.flatten - end + Gem::Requirement.default + else + requirements.flatten + end unless dependency.respond_to?(:name) && dependency.respond_to?(:requirement) @@ -1685,18 +1684,18 @@ class Gem::Specification < Gem::BasicSpecification # This is the cleanest, most-readable, faster-than-using-Date # way to do it. @date = case date - when String then - if DateTimeFormat =~ date - Time.utc($1.to_i, $2.to_i, $3.to_i) - else - raise(Gem::InvalidSpecificationException, - "invalid date format in specification: #{date.inspect}") - end - when Time, DateLike then - Time.utc(date.year, date.month, date.day) - else - TODAY - end + when String then + if DateTimeFormat =~ date + Time.utc($1.to_i, $2.to_i, $3.to_i) + else + raise(Gem::InvalidSpecificationException, + "invalid date format in specification: #{date.inspect}") + end + when Time, DateLike then + Time.utc(date.year, date.month, date.day) + else + TODAY + end end ## @@ -1802,13 +1801,13 @@ class Gem::Specification < Gem::BasicSpecification coder.add 'name', @name coder.add 'version', @version platform = case @original_platform - when nil, '' then - 'ruby' - when String then - @original_platform - else - @original_platform.to_s - end + when nil, '' then + 'ruby' + when String then + @original_platform + else + @original_platform.to_s + end coder.add 'platform', platform attributes = @@attributes.map(&:to_s) - %w[name version platform] @@ -2025,10 +2024,10 @@ class Gem::Specification < Gem::BasicSpecification def base_dir return Gem.dir unless loaded_from @base_dir ||= if default_gem? - File.dirname File.dirname File.dirname loaded_from - else - File.dirname File.dirname loaded_from - end + File.dirname File.dirname File.dirname loaded_from + else + File.dirname File.dirname loaded_from + end end ## @@ -2655,9 +2654,9 @@ class Gem::Specification < Gem::BasicSpecification default = self.default_value attribute value = case default - when Time, Numeric, Symbol, true, false, nil then default - else default.dup - end + when Time, Numeric, Symbol, true, false, nil then default + else default.dup + end instance_variable_set "@#{attribute}", value end diff --git a/lib/rubygems/specification_policy.rb b/lib/rubygems/specification_policy.rb index 73bd31970c..002b3c20c4 100644 --- a/lib/rubygems/specification_policy.rb +++ b/lib/rubygems/specification_policy.rb @@ -199,17 +199,17 @@ duplicate dependency on #{dep}, (#{prev.requirement}) use: base = segments.first 2 recommendation = if (op == '>' || op == '>=') && segments == [0] - " use a bounded requirement, such as '~> x.y'" - else - bugfix = if op == '>' - ", '> #{dep_version}'" - elsif op == '>=' and base != segments - ", '>= #{dep_version}'" - end - - " if #{dep.name} is semantically versioned, use:\n" \ - " add_#{dep.type}_dependency '#{dep.name}', '~> #{base.join '.'}'#{bugfix}" - end + " use a bounded requirement, such as '~> x.y'" + else + bugfix = if op == '>' + ", '> #{dep_version}'" + elsif op == '>=' and base != segments + ", '>= #{dep_version}'" + end + + " if #{dep.name} is semantically versioned, use:\n" \ + " add_#{dep.type}_dependency '#{dep.name}', '~> #{base.join '.'}'#{bugfix}" + end warning_messages << ["open-ended dependency on #{dep} is not recommended", recommendation].join("\n") + "\n" end @@ -332,11 +332,11 @@ duplicate dependency on #{dep}, (#{prev.requirement}) use: def validate_array_attribute(field) val = @specification.send(field) klass = case field - when :dependencies then - Gem::Dependency - else - String - end + when :dependencies then + Gem::Dependency + else + String + end unless Array === val and val.all? {|x| x.kind_of?(klass) } error "#{field} must be an Array of #{klass}" diff --git a/lib/rubygems/stub_specification.rb b/lib/rubygems/stub_specification.rb index 47fe7da695..b1dd7397ae 100644 --- a/lib/rubygems/stub_specification.rb +++ b/lib/rubygems/stub_specification.rb @@ -36,18 +36,18 @@ class Gem::StubSpecification < Gem::BasicSpecification parts = data[PREFIX.length..-1].split(" ".freeze, 4) @name = parts[0].freeze @version = if Gem::Version.correct?(parts[1]) - Gem::Version.new(parts[1]) - else - Gem::Version.new(0) - end + Gem::Version.new(parts[1]) + else + Gem::Version.new(0) + end @platform = Gem::Platform.new parts[2] @extensions = extensions @full_name = if platform == Gem::Platform::RUBY - "#{name}-#{version}" - else - "#{name}-#{version}-#{platform}" - end + "#{name}-#{version}" + else + "#{name}-#{version}-#{platform}" + end path_list = parts.last @require_paths = REQUIRE_PATH_LIST[path_list] || path_list.split("\0".freeze).map! do |x| @@ -110,16 +110,16 @@ class Gem::StubSpecification < Gem::BasicSpecification begin saved_lineno = $. - Gem.open_with_flock loaded_from, OPEN_MODE do |file| + Gem.open_file loaded_from, OPEN_MODE do |file| begin file.readline # discard encoding line stubline = file.readline.chomp if stubline.start_with?(PREFIX) extensions = if /\A#{PREFIX}/ =~ file.readline.chomp - $'.split "\0" - else - StubLine::NO_EXTENSIONS - end + $'.split "\0" + else + StubLine::NO_EXTENSIONS + end @data = StubLine.new stubline, extensions end @@ -185,14 +185,11 @@ class Gem::StubSpecification < Gem::BasicSpecification def to_spec @spec ||= if @data - loaded = Gem.loaded_specs[name] - loaded if loaded && loaded.version == version - end + loaded = Gem.loaded_specs[name] + loaded if loaded && loaded.version == version + end @spec ||= Gem::Specification.load(loaded_from) - @spec.ignored = @ignored if @spec - - @spec end ## diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb index 11fb611329..a36c5cbe2b 100644 --- a/lib/rubygems/uninstaller.rb +++ b/lib/rubygems/uninstaller.rb @@ -200,13 +200,13 @@ class Gem::Uninstaller executables = executables.map {|exec| formatted_program_filename exec } remove = if @force_executables.nil? - ask_yes_no("Remove executables:\n" + - "\t#{executables.join ', '}\n\n" + - "in addition to the gem?", - true) - else - @force_executables - end + ask_yes_no("Remove executables:\n" + + "\t#{executables.join ', '}\n\n" + + "in addition to the gem?", + true) + else + @force_executables + end if remove bin_dir = @bin_dir || Gem.bindir(spec.base_dir) diff --git a/lib/rubygems/user_interaction.rb b/lib/rubygems/user_interaction.rb index 0ab44fbf6c..e632f418a9 100644 --- a/lib/rubygems/user_interaction.rb +++ b/lib/rubygems/user_interaction.rb @@ -258,23 +258,23 @@ class Gem::StreamUI end default_answer = case default - when nil - 'yn' - when true - 'Yn' - else - 'yN' - end + when nil + 'yn' + when true + 'Yn' + else + 'yN' + end result = nil while result.nil? do result = case ask "#{question} [#{default_answer}]" - when /^y/i then true - when /^n/i then false - when /^$/ then default - else nil - end + when /^y/i then true + when /^n/i then false + when /^$/ then default + else nil + end end return result diff --git a/lib/rubygems/version.rb b/lib/rubygems/version.rb index 42e0f23505..d8aeb6f278 100644 --- a/lib/rubygems/version.rb +++ b/lib/rubygems/version.rb @@ -310,12 +310,12 @@ class Gem::Version def release @@release[self] ||= if prerelease? - segments = self.segments - segments.pop while segments.any? {|s| String === s } - self.class.new segments.join('.') - else - self - end + segments = self.segments + segments.pop while segments.any? {|s| String === s } + self.class.new segments.join('.') + else + self + end end def segments # :nodoc: @@ -341,9 +341,11 @@ class Gem::Version # Compares this version with +other+ returning -1, 0, or 1 if the # other version is larger, the same, or smaller than this # one. Attempts to compare to something that's not a - # Gem::Version return +nil+. + # Gem::Version or a valid version String return +nil+. def <=>(other) + return self <=> self.class.new(other) if (String === other) && self.class.correct?(other) + return unless Gem::Version === other return 0 if @version == other._version || canonical_segments == other.canonical_segments diff --git a/spec/bundler/bundler/cli_spec.rb b/spec/bundler/bundler/cli_spec.rb index c5de12c211..28ade90138 100644 --- a/spec/bundler/bundler/cli_spec.rb +++ b/spec/bundler/bundler/cli_spec.rb @@ -170,7 +170,7 @@ RSpec.describe "bundle executable" do bundle "fail", :env => { "BUNDLER_VERSION" => bundler_version }, :raise_on_error => false expect(err).to start_with(<<-EOS.strip) The latest bundler is #{latest_version}, but you are currently running #{bundler_version}. -To install the latest version, run `gem install bundler` +To update to the most recent version, run `bundle update --bundler` EOS end @@ -195,7 +195,7 @@ To install the latest version, run `gem install bundler` bundle "fail", :env => { "BUNDLER_VERSION" => bundler_version }, :raise_on_error => false expect(err).to start_with(<<-EOS.strip) The latest bundler is #{latest_version}, but you are currently running #{bundler_version}. -To install the latest version, run `gem install bundler --pre` +To update to the most recent version, run `bundle update --bundler` EOS end end diff --git a/spec/bundler/bundler/endpoint_specification_spec.rb b/spec/bundler/bundler/endpoint_specification_spec.rb index 2e2c16ec44..02a90d507a 100644 --- a/spec/bundler/bundler/endpoint_specification_spec.rb +++ b/spec/bundler/bundler/endpoint_specification_spec.rb @@ -5,9 +5,10 @@ RSpec.describe Bundler::EndpointSpecification do let(:version) { "1.0.0" } let(:platform) { Gem::Platform::RUBY } let(:dependencies) { [] } + let(:spec_fetcher) { double(:spec_fetcher) } let(:metadata) { nil } - subject(:spec) { described_class.new(name, version, platform, dependencies, metadata) } + subject(:spec) { described_class.new(name, version, platform, spec_fetcher, dependencies, metadata) } describe "#build_dependency" do let(:name) { "foo" } @@ -48,7 +49,9 @@ RSpec.describe Bundler::EndpointSpecification do end it "supports equality comparison" do - other_spec = described_class.new("bar", version, platform, dependencies, metadata) + remote_spec = double(:remote_spec, :required_ruby_version => nil, :required_rubygems_version => nil) + allow(spec_fetcher).to receive(:fetch_spec).and_return(remote_spec) + other_spec = described_class.new("bar", version, platform, spec_fetcher, dependencies, metadata) expect(spec).to eql(spec) expect(spec).to_not eql(other_spec) end diff --git a/spec/bundler/bundler/gem_helper_spec.rb b/spec/bundler/bundler/gem_helper_spec.rb index 2c43719aa1..5cd79de620 100644 --- a/spec/bundler/bundler/gem_helper_spec.rb +++ b/spec/bundler/bundler/gem_helper_spec.rb @@ -66,6 +66,10 @@ RSpec.describe Bundler::GemHelper do mock_confirm_message message end + def sha512_hexdigest(path) + Digest::SHA512.file(path).hexdigest + end + subject! { Bundler::GemHelper.new(app_path) } let(:app_version) { "0.1.0" } let(:app_gem_dir) { app_path.join("pkg") } @@ -169,12 +173,21 @@ RSpec.describe Bundler::GemHelper do end describe "#build_checksum" do + it "calculates SHA512 of the content" do + FileUtils.mkdir_p(app_gem_dir) + File.write(app_gem_path, "") + mock_checksum_message app_name, app_version + subject.build_checksum(app_gem_path) + expect(File.read(app_sha_path).chomp).to eql(Digest::SHA512.hexdigest("")) + end + context "when build was successful" do it "creates .sha512 file" do mock_build_message app_name, app_version mock_checksum_message app_name, app_version subject.build_checksum expect(app_sha_path).to exist + expect(File.read(app_sha_path).chomp).to eql(sha512_hexdigest(app_gem_path)) end end context "when building in the current working directory" do @@ -185,6 +198,7 @@ RSpec.describe Bundler::GemHelper do Bundler::GemHelper.new.build_checksum end expect(app_sha_path).to exist + expect(File.read(app_sha_path).chomp).to eql(sha512_hexdigest(app_gem_path)) end end context "when building in a location relative to the current working directory" do @@ -195,6 +209,7 @@ RSpec.describe Bundler::GemHelper do Bundler::GemHelper.new(File.basename(app_path)).build_checksum end expect(app_sha_path).to exist + expect(File.read(app_sha_path).chomp).to eql(sha512_hexdigest(app_gem_path)) end end end diff --git a/spec/bundler/commands/binstubs_spec.rb b/spec/bundler/commands/binstubs_spec.rb index ceef07d36b..198226207b 100644 --- a/spec/bundler/commands/binstubs_spec.rb +++ b/spec/bundler/commands/binstubs_spec.rb @@ -182,30 +182,26 @@ RSpec.describe "bundle binstubs " do end context "and the version is older and the same major" do - let(:system_bundler_version) { "55.1" } + let(:system_bundler_version) { "2.999.999" } before do - lockfile lockfile.gsub(/BUNDLED WITH\n .*$/m, "BUNDLED WITH\n 55.0") - - update_repo2 do - with_built_bundler("55.0") {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) } - end + lockfile lockfile.gsub(/BUNDLED WITH\n .*$/m, "BUNDLED WITH\n 2.3.0") end it "installs and runs the exact version of bundler", :rubygems => ">= 3.3.0.dev" do - sys_exec "bin/bundle install --verbose", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s, "RUBYOPT" => "-r#{spec_dir}/support/hax.rb" } + sys_exec "bin/bundle install --verbose", :artifice => "vcr" expect(exitstatus).not_to eq(42) - expect(out).to include("Bundler 55.1 is running, but your lockfile was generated with 55.0. Installing Bundler 55.0 and restarting using that version.") - expect(out).to include("Using bundler 55.0") - expect(err).not_to include("Activating bundler (~> 55.0) failed:") + expect(out).to include("Bundler 2.999.999 is running, but your lockfile was generated with 2.3.0. Installing Bundler 2.3.0 and restarting using that version.") + expect(out).to include("Using bundler 2.3.0") + expect(err).not_to include("Activating bundler (~> 2.3.0) failed:") end it "runs the available version of bundler", :rubygems => "< 3.3.0.dev" do sys_exec "bin/bundle install --verbose" expect(exitstatus).not_to eq(42) - expect(out).not_to include("Bundler 55.1 is running, but your lockfile was generated with 55.0. Installing Bundler 55.0 and restarting using that version.") - expect(out).to include("Using bundler 55.1") - expect(err).not_to include("Activating bundler (~> 55.0) failed:") + expect(out).not_to include("Bundler 2.999.999 is running, but your lockfile was generated with 2.3.0. Installing Bundler 2.3.0 and restarting using that version.") + expect(out).to include("Using bundler 2.999.999") + expect(err).not_to include("Activating bundler (~> 2.3.0) failed:") end end diff --git a/spec/bundler/commands/cache_spec.rb b/spec/bundler/commands/cache_spec.rb index 4f9c1c26c4..356a658e7c 100644 --- a/spec/bundler/commands/cache_spec.rb +++ b/spec/bundler/commands/cache_spec.rb @@ -403,14 +403,14 @@ RSpec.describe "bundle install with gem sources" do simulate_new_machine - simulate_platform "ruby" do - install_gemfile <<-G - source "#{file_uri_for(gem_repo1)}" - gem "platform_specific" - G - run "require 'platform_specific' ; puts PLATFORM_SPECIFIC" - expect(out).to eq("1.0.0 RUBY") - end + bundle "config set --local force_ruby_platform true" + + install_gemfile <<-G + source "#{file_uri_for(gem_repo1)}" + gem "platform_specific" + G + run "require 'platform_specific' ; puts PLATFORM_SPECIFIC" + expect(out).to eq("1.0.0 RUBY") end it "does not update the cache if --no-cache is passed" do diff --git a/spec/bundler/commands/doctor_spec.rb b/spec/bundler/commands/doctor_spec.rb index 860b638f06..1eeb276105 100644 --- a/spec/bundler/commands/doctor_spec.rb +++ b/spec/bundler/commands/doctor_spec.rb @@ -49,8 +49,8 @@ RSpec.describe "bundle doctor" do doctor = Bundler::CLI::Doctor.new({}) expect(doctor).to receive(:bundles_for_gem).exactly(2).times.and_return ["/path/to/rack/rack.bundle"] expect(doctor).to receive(:dylibs).exactly(2).times.and_return ["/usr/lib/libSystem.dylib"] - allow(File).to receive(:exist?).with("/usr/lib/libSystem.dylib").and_return(true) - expect { doctor.run }.not_to(raise_error, @stdout.string) + allow(Fiddle).to receive(:dlopen).with("/usr/lib/libSystem.dylib").and_return(true) + expect { doctor.run }.not_to raise_error expect(@stdout.string).to be_empty end @@ -58,7 +58,7 @@ RSpec.describe "bundle doctor" do doctor = Bundler::CLI::Doctor.new({}) expect(doctor).to receive(:bundles_for_gem).exactly(2).times.and_return ["/path/to/rack/rack.bundle"] expect(doctor).to receive(:dylibs).exactly(2).times.and_return ["/usr/local/opt/icu4c/lib/libicui18n.57.1.dylib"] - allow(File).to receive(:exist?).with("/usr/local/opt/icu4c/lib/libicui18n.57.1.dylib").and_return(false) + allow(Fiddle).to receive(:dlopen).with("/usr/local/opt/icu4c/lib/libicui18n.57.1.dylib").and_raise(Fiddle::DLError) expect { doctor.run }.to raise_error(Bundler::ProductionError, strip_whitespace(<<-E).strip), @stdout.string The following gems are missing OS dependencies: * bundler: /usr/local/opt/icu4c/lib/libicui18n.57.1.dylib diff --git a/spec/bundler/commands/install_spec.rb b/spec/bundler/commands/install_spec.rb index e00caa5315..ec1d9bcd02 100644 --- a/spec/bundler/commands/install_spec.rb +++ b/spec/bundler/commands/install_spec.rb @@ -499,20 +499,17 @@ RSpec.describe "bundle install with gem sources" do context "and using an unsupported Ruby version" do it "prints an error" do install_gemfile <<-G, :raise_on_error => false - ::RUBY_VERSION = '2.0.1' - ruby '~> 2.2' + ruby '~> 1.2' source "#{file_uri_for(gem_repo1)}" G - expect(err).to include("Your Ruby version is 2.0.1, but your Gemfile specified ~> 2.2") + expect(err).to include("Your Ruby version is #{RUBY_VERSION}, but your Gemfile specified ~> 1.2") end end context "and using a supported Ruby version" do before do install_gemfile <<-G - ::RUBY_VERSION = '2.1.3' - ::RUBY_PATCHLEVEL = 100 - ruby '~> 2.1.0' + ruby '~> #{RUBY_VERSION}' source "#{file_uri_for(gem_repo1)}" G end @@ -529,18 +526,16 @@ RSpec.describe "bundle install with gem sources" do DEPENDENCIES RUBY VERSION - ruby 2.1.3p100 + #{Bundler::RubyVersion.system} BUNDLED WITH #{Bundler::VERSION} L end - it "updates Gemfile.lock with updated incompatible ruby version" do + it "updates Gemfile.lock with updated yet still compatible ruby version" do install_gemfile <<-G - ::RUBY_VERSION = '2.2.3' - ::RUBY_PATCHLEVEL = 100 - ruby '~> 2.2.0' + ruby '~> #{RUBY_VERSION[0..2]}' source "#{file_uri_for(gem_repo1)}" G @@ -555,7 +550,7 @@ RSpec.describe "bundle install with gem sources" do DEPENDENCIES RUBY VERSION - ruby 2.2.3p100 + #{Bundler::RubyVersion.system} BUNDLED WITH #{Bundler::VERSION} diff --git a/spec/bundler/commands/lock_spec.rb b/spec/bundler/commands/lock_spec.rb index 22709f4528..fd1446af0e 100644 --- a/spec/bundler/commands/lock_spec.rb +++ b/spec/bundler/commands/lock_spec.rb @@ -337,7 +337,8 @@ RSpec.describe "bundle lock" do #{Bundler::VERSION} G - simulate_platform(rb) { bundle :lock } + bundle "config set --local force_ruby_platform true" + bundle :lock expect(lockfile).to eq <<~G GEM diff --git a/spec/bundler/commands/newgem_spec.rb b/spec/bundler/commands/newgem_spec.rb index ddefe0ba25..55a04b69c5 100644 --- a/spec/bundler/commands/newgem_spec.rb +++ b/spec/bundler/commands/newgem_spec.rb @@ -28,6 +28,10 @@ RSpec.describe "bundle gem" do let(:require_path) { "mygem" } + let(:minitest_test_file_path) { "test/test_mygem.rb" } + + let(:minitest_test_class_name) { "class TestMygem < Minitest::Test" } + before do sys_exec("git config --global user.name 'Bundler User'") sys_exec("git config --global user.email user@example.com") @@ -702,7 +706,7 @@ RSpec.describe "bundle gem" do end it "builds spec skeleton" do - expect(bundled_app("#{gem_name}/test/test_#{require_path}.rb")).to exist + expect(bundled_app("#{gem_name}/#{minitest_test_file_path}")).to exist expect(bundled_app("#{gem_name}/test/test_helper.rb")).to exist end end @@ -722,7 +726,7 @@ RSpec.describe "bundle gem" do end it "builds spec skeleton" do - expect(bundled_app("#{gem_name}/test/test_#{require_path}.rb")).to exist + expect(bundled_app("#{gem_name}/#{minitest_test_file_path}")).to exist expect(bundled_app("#{gem_name}/test/test_helper.rb")).to exist end @@ -731,11 +735,15 @@ RSpec.describe "bundle gem" do end it "requires 'test_helper'" do - expect(bundled_app("#{gem_name}/test/test_#{require_path}.rb").read).to include(%(require "test_helper")) + expect(bundled_app("#{gem_name}/#{minitest_test_file_path}").read).to include(%(require "test_helper")) + end + + it "defines valid test class name" do + expect(bundled_app("#{gem_name}/#{minitest_test_file_path}").read).to include(minitest_test_class_name) end it "creates a default test which fails" do - expect(bundled_app("#{gem_name}/test/test_#{require_path}.rb").read).to include("assert false") + expect(bundled_app("#{gem_name}/#{minitest_test_file_path}").read).to include("assert false") end end @@ -1300,6 +1308,10 @@ RSpec.describe "bundle gem" do let(:require_relative_path) { "test_gem" } + let(:minitest_test_file_path) { "test/test_test_gem.rb" } + + let(:minitest_test_class_name) { "class TestTestGem < Minitest::Test" } + let(:flags) { nil } it "does not nest constants" do @@ -1355,6 +1367,10 @@ RSpec.describe "bundle gem" do let(:require_relative_path) { "gem" } + let(:minitest_test_file_path) { "test/test/test_gem.rb" } + + let(:minitest_test_class_name) { "class Test::TestGem < Minitest::Test" } + it "nests constants so they work" do bundle "gem #{gem_name}" expect(bundled_app("#{gem_name}/lib/#{require_path}/version.rb").read).to match(/module Test\n module Gem/) diff --git a/spec/bundler/commands/remove_spec.rb b/spec/bundler/commands/remove_spec.rb index 70dc09c9b6..95d6e75e9f 100644 --- a/spec/bundler/commands/remove_spec.rb +++ b/spec/bundler/commands/remove_spec.rb @@ -48,12 +48,14 @@ RSpec.describe "bundle remove" do context "when gem is specified in multiple lines" do it "shows success for removed gem" do + build_git "rack" + gemfile <<-G source '#{file_uri_for(gem_repo1)}' gem 'git' gem 'rack', - git: 'https://github.com/rack/rack', + git: "#{lib_path("rack-1.0")}", branch: 'master' gem 'nokogiri' G diff --git a/spec/bundler/commands/update_spec.rb b/spec/bundler/commands/update_spec.rb index 403a48a508..ee5d53c527 100644 --- a/spec/bundler/commands/update_spec.rb +++ b/spec/bundler/commands/update_spec.rb @@ -980,20 +980,14 @@ RSpec.describe "bundle update when a gem depends on a newer version of bundler" end RSpec.describe "bundle update --ruby" do - before do - install_gemfile <<-G - ::RUBY_VERSION = '2.1.3' - ::RUBY_PATCHLEVEL = 100 - ruby '~> 2.1.0' - source "#{file_uri_for(gem_repo1)}" - G - end - context "when the Gemfile removes the ruby" do before do + install_gemfile <<-G + ruby '~> #{RUBY_VERSION}' + source "#{file_uri_for(gem_repo1)}" + G + gemfile <<-G - ::RUBY_VERSION = '2.1.4' - ::RUBY_PATCHLEVEL = 222 source "#{file_uri_for(gem_repo1)}" G end @@ -1018,10 +1012,13 @@ RSpec.describe "bundle update --ruby" do context "when the Gemfile specified an updated Ruby version" do before do + install_gemfile <<-G + ruby '~> #{RUBY_VERSION}' + source "#{file_uri_for(gem_repo1)}" + G + gemfile <<-G - ::RUBY_VERSION = '2.1.4' - ::RUBY_PATCHLEVEL = 222 - ruby '~> 2.1.0' + ruby '~> #{RUBY_VERSION[0..2]}' source "#{file_uri_for(gem_repo1)}" G end @@ -1039,7 +1036,7 @@ RSpec.describe "bundle update --ruby" do DEPENDENCIES RUBY VERSION - ruby 2.1.4p222 + #{Bundler::RubyVersion.system} BUNDLED WITH #{Bundler::VERSION} @@ -1049,9 +1046,12 @@ RSpec.describe "bundle update --ruby" do context "when a different Ruby is being used than has been versioned" do before do + install_gemfile <<-G + ruby '~> #{RUBY_VERSION}' + source "#{file_uri_for(gem_repo1)}" + G + gemfile <<-G - ::RUBY_VERSION = '2.2.2' - ::RUBY_PATCHLEVEL = 505 ruby '~> 2.1.0' source "#{file_uri_for(gem_repo1)}" G @@ -1059,16 +1059,31 @@ RSpec.describe "bundle update --ruby" do it "shows a helpful error message" do bundle "update --ruby", :raise_on_error => false - expect(err).to include("Your Ruby version is 2.2.2, but your Gemfile specified ~> 2.1.0") + expect(err).to include("Your Ruby version is #{Bundler::RubyVersion.system.gem_version}, but your Gemfile specified ~> 2.1.0") end end context "when updating Ruby version and Gemfile `ruby`" do before do + lockfile <<~L + GEM + remote: #{file_uri_for(gem_repo1)}/ + specs: + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + + RUBY VERSION + ruby 2.1.4p222 + + BUNDLED WITH + #{Bundler::VERSION} + L + gemfile <<-G - ::RUBY_VERSION = '1.8.3' - ::RUBY_PATCHLEVEL = 55 - ruby '~> 1.8.0' + ruby '~> #{RUBY_VERSION}' source "#{file_uri_for(gem_repo1)}" G end @@ -1086,7 +1101,7 @@ RSpec.describe "bundle update --ruby" do DEPENDENCIES RUBY VERSION - ruby 1.8.3p55 + #{Bundler::RubyVersion.system} BUNDLED WITH #{Bundler::VERSION} @@ -1105,15 +1120,208 @@ RSpec.describe "bundle update --bundler" do source "#{file_uri_for(gem_repo4)}" gem "rack" G - allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile) lockfile lockfile.sub(/(^\s*)#{Bundler::VERSION}($)/, '\11.0.0\2') FileUtils.rm_r gem_repo4 - bundle :update, :bundler => true, :verbose => true + bundle :update, :bundler => true, :artifice => "compact_index", :verbose => true + expect(out).to include("Using bundler #{Bundler::VERSION}") + + expect(lockfile).to eq <<~L + GEM + remote: #{file_uri_for(gem_repo4)}/ + specs: + rack (1.0) + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + rack + + BUNDLED WITH + #{Bundler::VERSION} + L + + expect(the_bundle).to include_gem "rack 1.0" + end + + it "updates the bundler version in the lockfile without re-resolving if the highest version is already installed" do + system_gems "bundler-2.3.3" + + build_repo4 do + build_gem "rack", "1.0" + end + + install_gemfile <<-G + source "#{file_uri_for(gem_repo4)}" + gem "rack" + G + lockfile lockfile.sub(/(^\s*)#{Bundler::VERSION}($)/, "2.3.3") + + bundle :update, :bundler => true, :artifice => "compact_index", :verbose => true + expect(out).to include("Using bundler #{Bundler::VERSION}") + + expect(lockfile).to eq <<~L + GEM + remote: #{file_uri_for(gem_repo4)}/ + specs: + rack (1.0) + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + rack + + BUNDLED WITH + #{Bundler::VERSION} + L + expect(the_bundle).to include_gem "rack 1.0" + end + + it "updates the bundler version in the lockfile even if the latest version is not installed", :ruby_repo, :realworld do + pristine_system_gems "bundler-2.3.3" + + build_repo4 do + build_gem "rack", "1.0" + end + + install_gemfile <<-G + source "#{file_uri_for(gem_repo4)}" + gem "rack" + G + lockfile lockfile.sub(/(^\s*)#{Bundler::VERSION}($)/, "2.3.3") + + bundle :update, :bundler => true, :artifice => "vcr", :verbose => true + + # Only updates properly on modern RubyGems. + + if Gem.rubygems_version >= Gem::Version.new("3.3.0.dev") + expect(out).to include("Updating bundler to 2.3.4") + expect(out).to include("Using bundler 2.3.4") + expect(out).not_to include("Installing Bundler 2.3.3 and restarting using that version.") + + expect(lockfile).to eq <<~L + GEM + remote: #{file_uri_for(gem_repo4)}/ + specs: + rack (1.0) + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + rack + + BUNDLED WITH + 2.3.4 + L + + expect(the_bundle).to include_gems "bundler 2.3.4" + end + + expect(the_bundle).to include_gems "rack 1.0" + end + + it "errors if the explicit target version does not exist", :realworld do + pristine_system_gems "bundler-2.3.3" + + build_repo4 do + build_gem "rack", "1.0" + end + + install_gemfile <<-G + source "#{file_uri_for(gem_repo4)}" + gem "rack" + G + lockfile lockfile.sub(/(^\s*)#{Bundler::VERSION}($)/, "2.3.3") + + bundle :update, :bundler => "999.999.999", :artifice => "vcr", :raise_on_error => false - expect(the_bundle.locked_gems.bundler_version).to eq v(Bundler::VERSION) + # Only gives a meaningful error message on modern RubyGems. + + if Gem.rubygems_version >= Gem::Version.new("3.3.0.dev") + expect(last_command).to be_failure + expect(err).to include("The `bundle update --bundler` target version (999.999.999) does not exist") + end + end + + it "allows updating to development versions if already installed locally" do + system_gems "bundler-2.3.0.dev" + + build_repo4 do + build_gem "rack", "1.0" + end + + install_gemfile <<-G + source "#{file_uri_for(gem_repo4)}" + gem "rack" + G + + bundle :update, :bundler => "2.3.0.dev" + + # Only updates properly on modern RubyGems. + + if Gem.rubygems_version >= Gem::Version.new("3.3.0.dev") + expect(lockfile).to eq <<~L + GEM + remote: #{file_uri_for(gem_repo4)}/ + specs: + rack (1.0) + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + rack + + BUNDLED WITH + 2.3.0.dev + L + + expect(out).to include("Using bundler 2.3.0.dev") + end + end + + it "does not touch the network if not necessary" do + system_gems "bundler-2.3.3" + + build_repo4 do + build_gem "rack", "1.0" + end + + install_gemfile <<-G + source "#{file_uri_for(gem_repo4)}" + gem "rack" + G + + bundle :update, :bundler => "2.3.3", :raise_on_error => false + + expect(out).not_to include("Fetching gem metadata from https://rubygems.org/") + + # Only updates properly on modern RubyGems. + + if Gem.rubygems_version >= Gem::Version.new("3.3.0.dev") + expect(lockfile).to eq <<~L + GEM + remote: #{file_uri_for(gem_repo4)}/ + specs: + rack (1.0) + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + rack + + BUNDLED WITH + 2.3.3 + L + + expect(out).to include("Using bundler 2.3.3") + end end end diff --git a/spec/bundler/install/gemfile/gemspec_spec.rb b/spec/bundler/install/gemfile/gemspec_spec.rb index 6d9cd2daff..6bcfadab7e 100644 --- a/spec/bundler/install/gemfile/gemspec_spec.rb +++ b/spec/bundler/install/gemfile/gemspec_spec.rb @@ -179,7 +179,7 @@ RSpec.describe "bundle install from an existing gemspec" do gemspec :path => '#{tmp.join("foo")}' G - bundle "update --bundler", :verbose => true + bundle "update --bundler", :artifice => "compact_index", :verbose => true expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 JAVA" end @@ -429,13 +429,16 @@ RSpec.describe "bundle install from an existing gemspec" do gemspec G - simulate_platform("ruby") { bundle "install" } + bundle "config set --local force_ruby_platform true" + bundle "install" + + simulate_new_machine simulate_platform("jruby") { bundle "install" } end context "on ruby" do before do - simulate_platform("ruby") + bundle "config set --local force_ruby_platform true" bundle :install end @@ -546,7 +549,7 @@ RSpec.describe "bundle install from an existing gemspec" do end it "installs the ruby platform gemspec" do - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" install_gemfile <<-G source "#{file_uri_for(gem_repo1)}" @@ -557,7 +560,7 @@ RSpec.describe "bundle install from an existing gemspec" do end it "installs the ruby platform gemspec and skips dev deps with `without development` configured" do - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" bundle "config set --local without development" install_gemfile <<-G @@ -622,4 +625,64 @@ RSpec.describe "bundle install from an existing gemspec" do expect(lockfile).to eq initial_lockfile end end + + context "with multiple locked platforms" do + before do + build_lib("activeadmin", :path => tmp.join("activeadmin")) do |s| + s.version = "2.9.0" + s.add_dependency "railties", ">= 5.2", "< 6.2" + end + + build_repo4 do + build_gem "railties", "6.1.4" + + build_gem "jruby-openssl", "0.10.7" do |s| + s.platform = "java" + end + end + + install_gemfile <<-G + source "#{file_uri_for(gem_repo4)}" + gemspec :path => "../activeadmin" + gem "jruby-openssl", :platform => :jruby + G + + bundle "lock --add-platform java" + end + + it "does not remove the platform specific specs from the lockfile when re-resolving due to gemspec changes" do + expect(lockfile).to eq <<~L + PATH + remote: ../activeadmin + specs: + activeadmin (2.9.0) + railties (>= 5.2, < 6.2) + + GEM + remote: #{file_uri_for(gem_repo4)}/ + specs: + jruby-openssl (0.10.7-java) + railties (6.1.4) + + PLATFORMS + #{lockfile_platforms_for(["java"] + local_platforms)} + + DEPENDENCIES + activeadmin! + jruby-openssl + + BUNDLED WITH + #{Bundler::VERSION} + L + + gemspec = tmp.join("activeadmin/activeadmin.gemspec") + File.write(gemspec, File.read(gemspec).sub(">= 5.2", ">= 6.0")) + + previous_lockfile = lockfile + + bundle "install --local" + + expect(lockfile).to eq(previous_lockfile.sub(">= 5.2", ">= 6.0")) + end + end end diff --git a/spec/bundler/install/gemfile/git_spec.rb b/spec/bundler/install/gemfile/git_spec.rb index a0fb4a3cea..365a84f39e 100644 --- a/spec/bundler/install/gemfile/git_spec.rb +++ b/spec/bundler/install/gemfile/git_spec.rb @@ -92,9 +92,7 @@ RSpec.describe "bundle install with git sources" do expect(err).to include("The source contains the following gems matching 'foo':\n * foo-1.0") end - it "complains with version and platform if pinned specs don't exist in the git repo" do - simulate_platform "java" - + it "complains with version and platform if pinned specs don't exist in the git repo", :jruby do build_git "only_java" do |s| s.platform = "java" end @@ -109,9 +107,7 @@ RSpec.describe "bundle install with git sources" do expect(err).to include("The source contains the following gems matching 'only_java':\n * only_java-1.0-java") end - it "complains with multiple versions and platforms if pinned specs don't exist in the git repo" do - simulate_platform "java" - + it "complains with multiple versions and platforms if pinned specs don't exist in the git repo", :jruby do build_git "only_java", "1.0" do |s| s.platform = "java" end @@ -418,9 +414,6 @@ RSpec.describe "bundle install with git sources" do describe "when specifying local override" do it "uses the local repository instead of checking a new one out" do - # We don't generate it because we actually don't need it - # build_git "rack", "0.8" - build_git "rack", "0.8", :path => lib_path("local-rack") do |s| s.write "lib/rack.rb", "puts :LOCAL" end diff --git a/spec/bundler/install/gemfile/platform_spec.rb b/spec/bundler/install/gemfile/platform_spec.rb index 35a3872c03..839db0089e 100644 --- a/spec/bundler/install/gemfile/platform_spec.rb +++ b/spec/bundler/install/gemfile/platform_spec.rb @@ -86,13 +86,13 @@ RSpec.describe "bundle install across platforms" do expect(the_bundle).to include_gems "nokogiri 1.4.2 JAVA", "weakling 0.0.3" simulate_new_machine - - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" bundle "install" expect(the_bundle).to include_gems "nokogiri 1.4.2" expect(the_bundle).not_to include_gems "weakling" + simulate_new_machine simulate_platform "java" bundle "install" @@ -453,7 +453,7 @@ RSpec.describe "bundle install with platform conditionals" do end it "does not attempt to install gems from :rbx when using --local" do - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" gemfile <<-G source "#{file_uri_for(gem_repo1)}" @@ -465,7 +465,7 @@ RSpec.describe "bundle install with platform conditionals" do end it "does not attempt to install gems from other rubies when using --local" do - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" other_ruby_version_tag = RUBY_VERSION =~ /^1\.8/ ? :ruby_19 : :ruby_18 gemfile <<-G @@ -478,7 +478,7 @@ RSpec.describe "bundle install with platform conditionals" do end it "does not print a warning when a dependency is unused on a platform different from the current one" do - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" gemfile <<-G source "#{file_uri_for(gem_repo1)}" diff --git a/spec/bundler/install/gemfile/ruby_spec.rb b/spec/bundler/install/gemfile/ruby_spec.rb index fd4300c042..ba250acfdd 100644 --- a/spec/bundler/install/gemfile/ruby_spec.rb +++ b/spec/bundler/install/gemfile/ruby_spec.rb @@ -46,18 +46,16 @@ RSpec.describe "ruby requirement" do it "allows changing the ruby version requirement to something compatible" do install_gemfile <<-G source "#{file_uri_for(gem_repo1)}" - ruby ">= 1.0.0" + ruby ">= #{RUBY_VERSION[0..2]}.0" gem "rack" G allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile) expect(locked_ruby_version).to eq(Bundler::RubyVersion.system) - simulate_ruby_version "5100" - install_gemfile <<-G source "#{file_uri_for(gem_repo1)}" - ruby ">= 1.0.1" + ruby ">= #{RUBY_VERSION}" gem "rack" G @@ -72,19 +70,35 @@ RSpec.describe "ruby requirement" do gem "rack" G - allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile) - expect(locked_ruby_version).to eq(Bundler::RubyVersion.system) + lockfile <<~L + GEM + remote: #{file_uri_for(gem_repo1)}/ + specs: + rack (1.0.0) + + PLATFORMS + #{lockfile_platforms} - simulate_ruby_version "5100" + DEPENDENCIES + rack + + RUBY VERSION + ruby 2.1.4p422 + + BUNDLED WITH + #{Bundler::VERSION} + L + + allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile) install_gemfile <<-G source "#{file_uri_for(gem_repo1)}" - ruby ">= 5000.0" + ruby ">= #{RUBY_VERSION[0..2]}.0" gem "rack" G expect(the_bundle).to include_gems "rack 1.0.0" - expect(locked_ruby_version.versions).to eq(["5100"]) + expect(locked_ruby_version).to eq(Bundler::RubyVersion.system) end it "allows requirements with trailing whitespace" do diff --git a/spec/bundler/install/gemfile/sources_spec.rb b/spec/bundler/install/gemfile/sources_spec.rb index 5456e95f33..26ecb840c7 100644 --- a/spec/bundler/install/gemfile/sources_spec.rb +++ b/spec/bundler/install/gemfile/sources_spec.rb @@ -1443,4 +1443,57 @@ RSpec.describe "bundle install with gems on multiple sources" do L end end + + context "when default source includes old gems with nil required_rubygems_version" do + before do + build_repo2 do + build_gem "ruport", "1.7.0.3" do |s| + s.add_dependency "pdf-writer", "1.1.8" + end + end + + build_repo gem_repo4 do + build_gem "pdf-writer", "1.1.8" + end + + path = "#{gem_repo4}/#{Gem::MARSHAL_SPEC_DIR}/pdf-writer-1.1.8.gemspec.rz" + spec = Marshal.load(Bundler.rubygems.inflate(File.binread(path))) + spec.instance_variable_set(:@required_rubygems_version, nil) + File.open(path, "wb") do |f| + f.write Gem.deflate(Marshal.dump(spec)) + end + + gemfile <<~G + source "https://localgemserver.test" + + gem "ruport", "= 1.7.0.3", :source => "https://localgemserver.test/extra" + G + end + + it "handles that fine" do + bundle "install", :artifice => "compact_index_extra", :env => { "BUNDLER_SPEC_GEM_REPO" => gem_repo4.to_s } + + expect(lockfile).to eq <<~L + GEM + remote: https://localgemserver.test/ + specs: + pdf-writer (1.1.8) + + GEM + remote: https://localgemserver.test/extra/ + specs: + ruport (1.7.0.3) + pdf-writer (= 1.1.8) + + PLATFORMS + #{specific_local_platform} + + DEPENDENCIES + ruport (= 1.7.0.3)! + + BUNDLED WITH + #{Bundler::VERSION} + L + end + end end diff --git a/spec/bundler/install/gems/dependency_api_spec.rb b/spec/bundler/install/gems/dependency_api_spec.rb index 9738a75474..79317a7fad 100644 --- a/spec/bundler/install/gems/dependency_api_spec.rb +++ b/spec/bundler/install/gems/dependency_api_spec.rb @@ -402,17 +402,6 @@ RSpec.describe "gemcutter's dependency API" do expect(the_bundle).to include_gems "back_deps 1.0" end - it "uses the endpoint if all sources support it" do - gemfile <<-G - source "#{source_uri}" - - gem 'foo' - G - - bundle :install, :artifice => "endpoint_api_missing" - expect(the_bundle).to include_gems "foo 1.0" - end - it "fetches again when more dependencies are found in subsequent sources using deployment mode", :bundler => "< 3" do build_repo2 do build_gem "back_deps" do |s| diff --git a/spec/bundler/install/gems/resolving_spec.rb b/spec/bundler/install/gems/resolving_spec.rb index 94fac0052c..b0209489b9 100644 --- a/spec/bundler/install/gems/resolving_spec.rb +++ b/spec/bundler/install/gems/resolving_spec.rb @@ -101,8 +101,6 @@ RSpec.describe "bundle install with install-time dependencies" do end it "installs gems with a dependency with no type" do - skip "incorrect data check error" if Gem.win_platform? - build_repo2 path = "#{gem_repo2}/#{Gem::MARSHAL_SPEC_DIR}/actionpack-2.3.2.gemspec.rz" @@ -110,7 +108,7 @@ RSpec.describe "bundle install with install-time dependencies" do spec.dependencies.each do |d| d.instance_variable_set(:@type, :fail) end - File.open(path, "w") do |f| + File.open(path, "wb") do |f| f.write Gem.deflate(Marshal.dump(spec)) end @@ -226,6 +224,27 @@ RSpec.describe "bundle install with install-time dependencies" do expect(the_bundle).to include_gems("rack 1.2") end + it "installs the older version when using servers not implementing the compact index API" do + build_repo2 do + build_gem "rack", "1.2" do |s| + s.executables = "rackup" + end + + build_gem "rack", "9001.0.0" do |s| + s.required_ruby_version = "> 9000" + end + end + + install_gemfile <<-G, :artifice => "endpoint", :env => { "BUNDLER_SPEC_GEM_REPO" => gem_repo2.to_s } + ruby "#{RUBY_VERSION}" + source "http://localgemserver.test/" + gem 'rack' + G + + expect(out).to_not include("rack-9001.0.0 requires ruby version > 9000") + expect(the_bundle).to include_gems("rack 1.2") + end + it "installs the older version under rate limiting conditions" do build_repo4 do build_gem "rack", "9001.0.0" do |s| @@ -286,8 +305,6 @@ RSpec.describe "bundle install with install-time dependencies" do shared_examples_for "ruby version conflicts" do it "raises an error during resolution" do - skip "ruby requirement includes platform and it shouldn't" if Gem.win_platform? - install_gemfile <<-G, :artifice => "compact_index", :env => { "BUNDLER_SPEC_GEM_REPO" => gem_repo2.to_s }, :raise_on_error => false source "http://localgemserver.test/" ruby #{ruby_requirement} @@ -303,8 +320,6 @@ RSpec.describe "bundle install with install-time dependencies" do require_ruby was resolved to 1.0, which depends on Ruby\0 (> 9000) - - Ruby\0 (> 9000), which is required by gem 'require_ruby', is not available in the local ruby installation E expect(err).to end_with(nice_error) end @@ -343,7 +358,15 @@ RSpec.describe "bundle install with install-time dependencies" do G expect(err).to_not include("Gem::InstallError: require_rubygems requires RubyGems version > 9000") - expect(err).to include("require_rubygems-1.0 requires rubygems version > 9000, which is incompatible with the current version, #{Gem::VERSION}") + nice_error = strip_whitespace(<<-E).strip + Bundler found conflicting requirements for the RubyGems\0 version: + In Gemfile: + RubyGems\0 (= #{Gem::VERSION}) + + require_rubygems was resolved to 1.0, which depends on + RubyGems\0 (> 9000) + E + expect(err).to end_with(nice_error) end end end diff --git a/spec/bundler/lock/lockfile_spec.rb b/spec/bundler/lock/lockfile_spec.rb index b9ef6e885a..561de9f3bc 100644 --- a/spec/bundler/lock/lockfile_spec.rb +++ b/spec/bundler/lock/lockfile_spec.rb @@ -1,18 +1,8 @@ # frozen_string_literal: true RSpec.describe "the lockfile format" do - include Bundler::GemHelpers - before do - build_repo2 do - # Capistrano did this (at least until version 2.5.10) - # RubyGems 2.2 doesn't allow the specifying of a dependency twice - # See https://github.com/rubygems/rubygems/commit/03dbac93a3396a80db258d9bc63500333c25bd2f - build_gem "double_deps", "1.0", :skip_validation => true do |s| - s.add_dependency "net-ssh", ">= 1.0.0" - s.add_dependency "net-ssh" - end - end + build_repo2 end it "generates a simple lockfile for a single source, gem" do @@ -90,12 +80,8 @@ RSpec.describe "the lockfile format" do G end - it "does not update the lockfile's bundler version if nothing changed during bundle install, but uses the locked version", :rubygems => ">= 3.3.0.a" do - version = "#{Bundler::VERSION.split(".").first}.0.0.a" - - update_repo2 do - with_built_bundler(version) {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) } - end + it "does not update the lockfile's bundler version if nothing changed during bundle install, but uses the locked version", :rubygems => ">= 3.3.0.a", :realworld => true do + version = "2.3.0" lockfile <<-L GEM @@ -113,7 +99,7 @@ RSpec.describe "the lockfile format" do #{version} L - install_gemfile <<-G, :verbose => true, :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s } + install_gemfile <<-G, :verbose => true, :artifice => "vcr" source "#{file_uri_for(gem_repo2)}" gem "rack" @@ -142,10 +128,6 @@ RSpec.describe "the lockfile format" do it "does not update the lockfile's bundler version if nothing changed during bundle install, and uses the latest version", :rubygems => "< 3.3.0.a" do version = "#{Bundler::VERSION.split(".").first}.0.0.a" - update_repo2 do - with_built_bundler(version) {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) } - end - lockfile <<-L GEM remote: #{file_uri_for(gem_repo2)}/ @@ -162,7 +144,7 @@ RSpec.describe "the lockfile format" do #{version} L - install_gemfile <<-G, :verbose => true, :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s } + install_gemfile <<-G, :verbose => true source "#{file_uri_for(gem_repo2)}" gem "rack" @@ -761,6 +743,16 @@ RSpec.describe "the lockfile format" do end it "orders dependencies by version" do + update_repo2 do + # Capistrano did this (at least until version 2.5.10) + # RubyGems 2.2 doesn't allow the specifying of a dependency twice + # See https://github.com/rubygems/rubygems/commit/03dbac93a3396a80db258d9bc63500333c25bd2f + build_gem "double_deps", "1.0", :skip_validation => true do |s| + s.add_dependency "net-ssh", ">= 1.0.0" + s.add_dependency "net-ssh" + end + end + install_gemfile <<-G source "#{file_uri_for(gem_repo2)}/" gem 'double_deps' diff --git a/spec/bundler/other/platform_spec.rb b/spec/bundler/other/platform_spec.rb index 5693d6bce6..bf38a05646 100644 --- a/spec/bundler/other/platform_spec.rb +++ b/spec/bundler/other/platform_spec.rb @@ -17,7 +17,7 @@ RSpec.describe "bundle platform" do bundle "platform" expect(out).to eq(<<-G.chomp) -Your platform is: #{RUBY_PLATFORM} +Your platform is: #{Gem::Platform.local} Your app has gems that work on these platforms: #{bundle_platform_platforms_string} @@ -40,7 +40,7 @@ G bundle "platform" expect(out).to eq(<<-G.chomp) -Your platform is: #{RUBY_PLATFORM} +Your platform is: #{Gem::Platform.local} Your app has gems that work on these platforms: #{bundle_platform_platforms_string} @@ -61,7 +61,7 @@ G bundle "platform" expect(out).to eq(<<-G.chomp) -Your platform is: #{RUBY_PLATFORM} +Your platform is: #{Gem::Platform.local} Your app has gems that work on these platforms: #{bundle_platform_platforms_string} @@ -81,7 +81,7 @@ G bundle "platform" expect(out).to eq(<<-G.chomp) -Your platform is: #{RUBY_PLATFORM} +Your platform is: #{Gem::Platform.local} Your app has gems that work on these platforms: #{bundle_platform_platforms_string} diff --git a/spec/bundler/runtime/inline_spec.rb b/spec/bundler/runtime/inline_spec.rb index 2ffadebf55..24df758619 100644 --- a/spec/bundler/runtime/inline_spec.rb +++ b/spec/bundler/runtime/inline_spec.rb @@ -309,7 +309,7 @@ RSpec.describe "bundler/inline#gemfile" do end it "skips platform warnings" do - simulate_platform "ruby" + bundle "config set --local force_ruby_platform true" script <<-RUBY gemfile(true) do diff --git a/spec/bundler/runtime/platform_spec.rb b/spec/bundler/runtime/platform_spec.rb index b937de8059..f7159635e6 100644 --- a/spec/bundler/runtime/platform_spec.rb +++ b/spec/bundler/runtime/platform_spec.rb @@ -232,6 +232,20 @@ RSpec.describe "Bundler.setup with multi platform stuff" do expect(the_bundle).to include_gems "nokogiri 1.4.2", "platform_specific 1.0 RUBY" end + it "allows specifying only-ruby-platform even if the lockfile is locked to a specific compatible platform" do + install_gemfile <<-G + source "#{file_uri_for(gem_repo1)}" + gem "nokogiri" + gem "platform_specific" + G + + bundle "config set force_ruby_platform true" + + bundle "install" + + expect(the_bundle).to include_gems "nokogiri 1.4.2", "platform_specific 1.0 RUBY" + end + it "doesn't pull platform specific gems on truffleruby", :truffleruby do install_gemfile <<-G source "#{file_uri_for(gem_repo1)}" diff --git a/spec/bundler/runtime/self_management_spec.rb b/spec/bundler/runtime/self_management_spec.rb index 7746a6ffa9..0032c6aef6 100644 --- a/spec/bundler/runtime/self_management_spec.rb +++ b/spec/bundler/runtime/self_management_spec.rb @@ -1,15 +1,13 @@ # frozen_string_literal: true -RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do +RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev", :realworld => true do describe "auto switching" do - let(:next_minor) do - Bundler::VERSION.split(".").map.with_index {|s, i| i == 1 ? s.to_i + 1 : s }[0..2].join(".") + let(:previous_minor) do + "2.3.0" end before do - build_repo2 do - with_built_bundler(next_minor) {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) } - end + build_repo2 gemfile <<-G source "#{file_uri_for(gem_repo2)}" @@ -19,11 +17,11 @@ RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do end it "installs locked version when using system path and uses it" do - lockfile_bundled_with(next_minor) + lockfile_bundled_with(previous_minor) bundle "config set --local path.system true" - bundle "install", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s } - expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.") + bundle "install", :artifice => "vcr" + expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{previous_minor}. Installing Bundler #{previous_minor} and restarting using that version.") # It uninstalls the older system bundler bundle "clean --force" @@ -31,21 +29,21 @@ RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do # App now uses locked version bundle "-v" - expect(out).to end_with(next_minor[0] == "2" ? "Bundler version #{next_minor}" : next_minor) + expect(out).to end_with(previous_minor[0] == "2" ? "Bundler version #{previous_minor}" : previous_minor) # Subsequent installs use the locked version without reinstalling bundle "install --verbose" - expect(out).to include("Using bundler #{next_minor}") - expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.") + expect(out).to include("Using bundler #{previous_minor}") + expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{previous_minor}. Installing Bundler #{previous_minor} and restarting using that version.") end it "installs locked version when using local path and uses it" do - lockfile_bundled_with(next_minor) + lockfile_bundled_with(previous_minor) bundle "config set --local path vendor/bundle" - bundle "install", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s } - expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.") - expect(vendored_gems("gems/bundler-#{next_minor}")).to exist + bundle "install", :artifice => "vcr" + expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{previous_minor}. Installing Bundler #{previous_minor} and restarting using that version.") + expect(vendored_gems("gems/bundler-#{previous_minor}")).to exist # It does not uninstall the locked bundler bundle "clean" @@ -53,21 +51,21 @@ RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do # App now uses locked version bundle "-v" - expect(out).to end_with(next_minor[0] == "2" ? "Bundler version #{next_minor}" : next_minor) + expect(out).to end_with(previous_minor[0] == "2" ? "Bundler version #{previous_minor}" : previous_minor) # Subsequent installs use the locked version without reinstalling bundle "install --verbose" - expect(out).to include("Using bundler #{next_minor}") - expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.") + expect(out).to include("Using bundler #{previous_minor}") + expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{previous_minor}. Installing Bundler #{previous_minor} and restarting using that version.") end it "installs locked version when using deployment option and uses it" do - lockfile_bundled_with(next_minor) + lockfile_bundled_with(previous_minor) bundle "config set --local deployment true" - bundle "install", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s } - expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.") - expect(vendored_gems("gems/bundler-#{next_minor}")).to exist + bundle "install", :artifice => "vcr" + expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{previous_minor}. Installing Bundler #{previous_minor} and restarting using that version.") + expect(vendored_gems("gems/bundler-#{previous_minor}")).to exist # It does not uninstall the locked bundler bundle "clean" @@ -75,16 +73,16 @@ RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do # App now uses locked version bundle "-v" - expect(out).to end_with(next_minor[0] == "2" ? "Bundler version #{next_minor}" : next_minor) + expect(out).to end_with(previous_minor[0] == "2" ? "Bundler version #{previous_minor}" : previous_minor) # Subsequent installs use the locked version without reinstalling bundle "install --verbose" - expect(out).to include("Using bundler #{next_minor}") - expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.") + expect(out).to include("Using bundler #{previous_minor}") + expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{previous_minor}. Installing Bundler #{previous_minor} and restarting using that version.") end it "does not try to install a development version" do - lockfile_bundled_with("#{next_minor}.dev") + lockfile_bundled_with("#{previous_minor}.dev") bundle "install --verbose" expect(out).not_to match(/restarting using that version/) @@ -93,17 +91,13 @@ RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do expect(out).to eq(Bundler::VERSION[0] == "2" ? "Bundler version #{Bundler::VERSION}" : Bundler::VERSION) end - it "shows a discreet message if locked bundler does not exist, and something more complete in `--verbose` mode" do + it "shows a discreet message if locked bundler does not exist" do missing_minor ="#{Bundler::VERSION[0]}.999.999" lockfile_bundled_with(missing_minor) - bundle "install" - expect(err).to eq("There was an error installing the locked bundler version (#{missing_minor}), rerun with the `--verbose` flag for more details. Going on using bundler #{Bundler::VERSION}.") - - bundle "install --verbose" - expect(err).to include("There was an error installing the locked bundler version (#{missing_minor}), rerun with the `--verbose` flag for more details. Going on using bundler #{Bundler::VERSION}.") - expect(err).to include("Gem::UnsatisfiableDependencyError") + bundle "install", :artifice => "vcr" + expect(err).to eq("Your lockfile is locked to a version of bundler (#{missing_minor}) that doesn't exist at https://rubygems.org/. Going on using #{Bundler::VERSION}") bundle "-v" expect(out).to eq(Bundler::VERSION[0] == "2" ? "Bundler version #{Bundler::VERSION}" : Bundler::VERSION) diff --git a/spec/bundler/support/artifice/endpoint_api_missing.rb b/spec/bundler/support/artifice/endpoint_api_missing.rb deleted file mode 100644 index 755c42e836..0000000000 --- a/spec/bundler/support/artifice/endpoint_api_missing.rb +++ /dev/null @@ -1,18 +0,0 @@ -# frozen_string_literal: true - -require_relative "endpoint" - -Artifice.deactivate - -class EndpointApiMissing < Endpoint - get "/fetch/actual/gem/:id" do - warn params[:id] - if params[:id] == "rack-1.0.gemspec.rz" - halt 404 - else - File.binread("#{gem_repo2}/quick/Marshal.4.8/#{params[:id]}") - end - end -end - -Artifice.activate_with(EndpointApiMissing) diff --git a/spec/bundler/support/artifice/vcr.rb b/spec/bundler/support/artifice/vcr.rb index 0d51201bef..ceb133346f 100644 --- a/spec/bundler/support/artifice/vcr.rb +++ b/spec/bundler/support/artifice/vcr.rb @@ -69,7 +69,7 @@ class BundlerVCRHTTP < Net::HTTP end def file_name_for_key(key) - key.join("/").gsub(/[\:*?"<>|]/, "-") + File.join(*key).gsub(/[\:*?"<>|]/, "-") end def request_pair_paths diff --git a/spec/bundler/support/hax.rb b/spec/bundler/support/hax.rb index 4a49ffb49f..3d97b93c5a 100644 --- a/spec/bundler/support/hax.rb +++ b/spec/bundler/support/hax.rb @@ -19,16 +19,6 @@ module Gem @local = new(ENV["BUNDLER_SPEC_PLATFORM"]) end @platforms = [Gem::Platform::RUBY, Gem::Platform.local] - - if ENV["BUNDLER_SPEC_PLATFORM"] == "ruby" - class << self - remove_method :finish_resolve - - def finish_resolve - [] - end - end - end end if ENV["BUNDLER_SPEC_GEM_SOURCES"] diff --git a/spec/bundler/support/helpers.rb b/spec/bundler/support/helpers.rb index 99baec24d4..c27096a0cf 100644 --- a/spec/bundler/support/helpers.rb +++ b/spec/bundler/support/helpers.rb @@ -88,7 +88,6 @@ module Spec requires = options.delete(:requires) || [] realworld = RSpec.current_example.metadata[:realworld] - options[:verbose] = true if options[:verbose].nil? && realworld artifice = options.delete(:artifice) do if realworld @@ -448,15 +447,6 @@ module Spec ENV["BUNDLER_SPEC_PLATFORM"] = old if block_given? end - def simulate_ruby_version(version) - return if version == RUBY_VERSION - old = ENV["BUNDLER_SPEC_RUBY_VERSION"] - ENV["BUNDLER_SPEC_RUBY_VERSION"] = version - yield if block_given? - ensure - ENV["BUNDLER_SPEC_RUBY_VERSION"] = old if block_given? - end - def simulate_windows(platform = mswin) simulate_platform platform do simulate_bundler_version_when_missing_prerelease_default_gem_activation do diff --git a/spec/bundler/support/rubygems_ext.rb b/spec/bundler/support/rubygems_ext.rb index 62ba4d56c4..fd5f06b14f 100644 --- a/spec/bundler/support/rubygems_ext.rb +++ b/spec/bundler/support/rubygems_ext.rb @@ -119,7 +119,7 @@ module Spec ENV["BUNDLE_PATH__SYSTEM"] = "true" end - output = `#{Gem.ruby} #{File.expand_path("support/bundle.rb", Path.spec_dir)} install` + output = `#{Gem.ruby} #{File.expand_path("support/bundle.rb", Path.spec_dir)} install --verbose` raise "Error when installing gems in #{gemfile}: #{output}" unless $?.success? ensure if path diff --git a/test/rubygems/helper.rb b/test/rubygems/helper.rb index f321b02e48..d97d930476 100644 --- a/test/rubygems/helper.rb +++ b/test/rubygems/helper.rb @@ -339,10 +339,10 @@ class Gem::TestCase < Test::Unit::TestCase ENV["GEM_SPEC_CACHE"] = File.join @tempdir, 'spec_cache' @orig_ruby = if ENV['RUBY'] - ruby = Gem.ruby - Gem.ruby = ENV['RUBY'] - ruby - end + ruby = Gem.ruby + Gem.ruby = ENV['RUBY'] + ruby + end @git = ENV['GIT'] || (win_platform? ? 'git.exe' : 'git') @@ -685,10 +685,10 @@ class Gem::TestCase < Test::Unit::TestCase # Load a YAML string, the psych 3 way def load_yaml(yaml) - if YAML.respond_to?(:unsafe_load) - YAML.unsafe_load(yaml) + if Psych.respond_to?(:unsafe_load) + Psych.unsafe_load(yaml) else - YAML.load(yaml) + Psych.load(yaml) end end @@ -696,10 +696,10 @@ class Gem::TestCase < Test::Unit::TestCase # Load a YAML file, the psych 3 way def load_yaml_file(file) - if YAML.respond_to?(:unsafe_load_file) - YAML.unsafe_load_file(file) + if Psych.respond_to?(:unsafe_load_file) + Psych.unsafe_load_file(file) else - YAML.load_file(file) + Psych.load_file(file) end end diff --git a/test/rubygems/test_gem.rb b/test/rubygems/test_gem.rb index 970b3b70dd..cc4772a0c6 100644 --- a/test/rubygems/test_gem.rb +++ b/test/rubygems/test_gem.rb @@ -2022,6 +2022,8 @@ You may need to `bundle install` to install missing gems ENV['SOURCE_DATE_EPOCH'] = old_epoch end + private + def ruby_install_name(name) with_clean_path_to_ruby do orig_RUBY_INSTALL_NAME = RbConfig::CONFIG['ruby_install_name'] diff --git a/test/rubygems/test_gem_command_manager.rb b/test/rubygems/test_gem_command_manager.rb index c2e11d2002..ff1f955c6c 100644 --- a/test/rubygems/test_gem_command_manager.rb +++ b/test/rubygems/test_gem_command_manager.rb @@ -252,7 +252,7 @@ class TestGemCommandManager < Gem::TestCase Gem::Deprecate.skip_during do @command_manager.process_args %w[query] end - assert_equal(//, check_options[:name]) + assert_nil(check_options[:name]) assert_equal :local, check_options[:domain] assert_equal false, check_options[:details] diff --git a/test/rubygems/test_gem_commands_fetch_command.rb b/test/rubygems/test_gem_commands_fetch_command.rb index c745648d56..7d4c77afaa 100644 --- a/test/rubygems/test_gem_commands_fetch_command.rb +++ b/test/rubygems/test_gem_commands_fetch_command.rb @@ -157,4 +157,101 @@ class TestGemCommandsFetchCommand < Gem::TestCase assert_path_exist(File.join(@tempdir, a1.file_name), "#{a1.full_name} not fetched") end + + def test_execute_version_specified_by_colon + specs = spec_fetcher do |fetcher| + fetcher.gem 'a', 1 + end + + @cmd.options[:args] = %w[a:1] + + use_ui @ui do + Dir.chdir @tempdir do + @cmd.execute + end + end + + a1 = specs['a-1'] + + assert_path_exist(File.join(@tempdir, a1.file_name), + "#{a1.full_name} not fetched") + end + + def test_execute_two_version + @cmd.options[:args] = %w[a b] + @cmd.options[:version] = Gem::Requirement.new '1' + + use_ui @ui do + assert_raise Gem::MockGemUi::TermError, @ui.error do + @cmd.execute + end + end + + msg = "ERROR: Can't use --version with multiple gems. You can specify multiple gems with" \ + " version requirements using `gem fetch 'my_gem:1.0.0' 'my_other_gem:~>2.0.0'`" + + assert_empty @ui.output + assert_equal msg, @ui.error.chomp + end + + def test_execute_two_version_specified_by_colon + specs = spec_fetcher do |fetcher| + fetcher.gem 'a', 1 + fetcher.gem 'b', 1 + end + + @cmd.options[:args] = %w[a:1 b:1] + + use_ui @ui do + Dir.chdir @tempdir do + @cmd.execute + end + end + + a1 = specs['a-1'] + b1 = specs['b-1'] + + assert_path_exist(File.join(@tempdir, a1.file_name), + "#{a1.full_name} not fetched") + assert_path_exist(File.join(@tempdir, b1.file_name), + "#{b1.full_name} not fetched") + end + + def test_execute_version_nonexistent + spec_fetcher do |fetcher| + fetcher.spec 'foo', 1 + end + + @cmd.options[:args] = %w[foo:2] + + use_ui @ui do + @cmd.execute + end + + expected = <<-EXPECTED +ERROR: Could not find a valid gem 'foo' (2) in any repository +ERROR: Possible alternatives: foo + EXPECTED + + assert_equal expected, @ui.error + end + + def test_execute_nonexistent_hint_disabled + spec_fetcher do |fetcher| + fetcher.spec 'foo', 1 + end + + @cmd.options[:args] = %w[foo:2] + @cmd.options[:suggest_alternate] = false + + use_ui @ui do + @cmd.execute + end + + expected = <<-EXPECTED +ERROR: Could not find a valid gem 'foo' (2) in any repository + EXPECTED + + assert_equal expected, @ui.error + end end diff --git a/test/rubygems/test_gem_commands_install_command.rb b/test/rubygems/test_gem_commands_install_command.rb index 0365b2c408..47a97dae4b 100644 --- a/test/rubygems/test_gem_commands_install_command.rb +++ b/test/rubygems/test_gem_commands_install_command.rb @@ -277,6 +277,22 @@ ERROR: Could not find a valid gem 'bar' (= 0.5) (required by 'foo' (>= 0)) in a assert_match(/ould not find a valid gem 'nonexistent'/, @ui.error) end + def test_execute_nonexistent_force + spec_fetcher + + @cmd.options[:args] = %w[nonexistent] + @cmd.options[:force] = true + + use_ui @ui do + e = assert_raise Gem::MockGemUi::TermError do + @cmd.execute + end + assert_equal 2, e.exit_code + end + + assert_match(/ould not find a valid gem 'nonexistent'/, @ui.error) + end + def test_execute_dependency_nonexistent spec_fetcher do |fetcher| fetcher.spec 'foo', 2, 'bar' => '0.5' diff --git a/test/rubygems/test_gem_commands_update_command.rb b/test/rubygems/test_gem_commands_update_command.rb index e9264f6d14..c765e9a8df 100644 --- a/test/rubygems/test_gem_commands_update_command.rb +++ b/test/rubygems/test_gem_commands_update_command.rb @@ -106,6 +106,31 @@ class TestGemCommandsUpdateCommand < Gem::TestCase assert_empty out end + def test_execute_system_when_latest_does_not_support_your_ruby + spec_fetcher do |fetcher| + fetcher.download 'rubygems-update', 9 do |s| + s.files = %w[setup.rb] + s.required_ruby_version = '> 9' + end + end + + @cmd.options[:args] = [] + @cmd.options[:system] = true + + use_ui @ui do + @cmd.execute + end + + out = @ui.output.split "\n" + assert_equal "Updating rubygems-update", out.shift + assert_empty out + + err = @ui.error.split "\n" + assert_equal "ERROR: Error installing rubygems-update:", err.shift + assert_equal "\trubygems-update-9 requires Ruby version > 9. The current ruby version is #{Gem.ruby_version}.", err.shift + assert_empty err + end + def test_execute_system_multiple spec_fetcher do |fetcher| fetcher.download 'rubygems-update', 8 do |s| @@ -132,6 +157,40 @@ class TestGemCommandsUpdateCommand < Gem::TestCase assert_empty out end + def test_execute_system_update_installed + spec_fetcher do |fetcher| + fetcher.download 'rubygems-update', 8 do |s| + s.files = %w[setup.rb] + end + end + + @cmd.options[:args] = [] + @cmd.options[:system] = true + + @cmd.execute + + spec_fetcher do |fetcher| + fetcher.download 'rubygems-update', 9 do |s| + s.files = %w[setup.rb] + end + end + + @cmd = Gem::Commands::UpdateCommand.new + @cmd.options[:args] = [] + @cmd.options[:system] = true + + use_ui @ui do + @cmd.execute + end + + out = @ui.output.split "\n" + assert_equal "Updating rubygems-update", out.shift + assert_equal "Installing RubyGems 9", out.shift + assert_equal "RubyGems system software updated", out.shift + + assert_empty out + end + def test_execute_system_specific spec_fetcher do |fetcher| fetcher.download 'rubygems-update', 8 do |s| diff --git a/test/rubygems/test_gem_installer.rb b/test/rubygems/test_gem_installer.rb index 8874577aa8..c90fdab283 100644 --- a/test/rubygems/test_gem_installer.rb +++ b/test/rubygems/test_gem_installer.rb @@ -18,11 +18,12 @@ class TestGemInstaller < Gem::InstallerTestCase end def test_app_script_text - installer = setup_base_installer + load_relative "no" do + installer = setup_base_installer - util_make_exec @spec, '' + util_make_exec @spec, '' - expected = <<-EOF + expected = <<-EOF #!#{Gem.ruby} # # This file was generated by RubyGems. @@ -52,10 +53,11 @@ else gem "a", version load Gem.bin_path("a", "executable", version) end - EOF + EOF - wrapper = installer.app_script_text 'executable' - assert_equal expected, wrapper + wrapper = installer.app_script_text 'executable' + assert_equal expected, wrapper + end end def test_check_executable_overwrite @@ -724,17 +726,19 @@ gem 'other', version def test_generate_bin_uses_default_shebang pend "Symlinks not supported or not enabled" unless symlink_supported? - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - installer.wrappers = true - util_make_exec + installer.wrappers = true + util_make_exec - installer.generate_bin + installer.generate_bin - default_shebang = Gem.ruby - shebang_line = File.open("#{@gemhome}/bin/executable") {|f| f.readlines.first } - assert_match(/\A#!/, shebang_line) - assert_match(/#{default_shebang}/, shebang_line) + default_shebang = Gem.ruby + shebang_line = File.open("#{@gemhome}/bin/executable") {|f| f.readlines.first } + assert_match(/\A#!/, shebang_line) + assert_match(/#{default_shebang}/, shebang_line) + end end def test_generate_bin_with_dangling_symlink @@ -1804,13 +1808,15 @@ gem 'other', version end def test_shebang - installer = setup_base_installer + load_relative "no" do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/ruby" + util_make_exec @spec, "#!/usr/bin/ruby" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby}", shebang + assert_equal "#!#{Gem.ruby}", shebang + end end def test_process_options @@ -1844,42 +1850,80 @@ gem 'other', version end def test_shebang_arguments - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/ruby -ws" + util_make_exec @spec, "#!/usr/bin/ruby -ws" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby} -ws", shebang + assert_equal "#!#{Gem.ruby} -ws", shebang + end + end + + def test_shebang_arguments_with_load_relative + load_relative 'yes' do + installer = setup_base_installer + + util_make_exec @spec, "#!/usr/bin/ruby -ws" + + shebang = installer.shebang 'executable' + + shebang_lines = shebang.split "\n" + + assert_equal "#!/bin/sh", shebang_lines.shift + assert_includes shebang_lines, "#!#{Gem.ruby} -ws" + end end def test_shebang_empty - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, '' + util_make_exec @spec, '' - shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby}", shebang + shebang = installer.shebang 'executable' + assert_equal "#!#{Gem.ruby}", shebang + end end def test_shebang_env - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/env ruby" + util_make_exec @spec, "#!/usr/bin/env ruby" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby}", shebang + assert_equal "#!#{Gem.ruby}", shebang + end end def test_shebang_env_arguments - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/env ruby -ws" + util_make_exec @spec, "#!/usr/bin/env ruby -ws" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby} -ws", shebang + assert_equal "#!#{Gem.ruby} -ws", shebang + end + end + + def test_shebang_env_arguments_with_load_relative + load_relative 'yes' do + installer = setup_base_installer + + util_make_exec @spec, "#!/usr/bin/env ruby -ws" + + shebang = installer.shebang 'executable' + + shebang_lines = shebang.split "\n" + + assert_equal "#!/bin/sh", shebang_lines.shift + assert_includes shebang_lines, "#!#{Gem.ruby} -ws" + end end def test_shebang_env_shebang @@ -1897,63 +1941,120 @@ gem 'other', version end def test_shebang_nested - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/opt/local/ruby/bin/ruby" + util_make_exec @spec, "#!/opt/local/ruby/bin/ruby" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby}", shebang + assert_equal "#!#{Gem.ruby}", shebang + end end def test_shebang_nested_arguments - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws" + util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' + + assert_equal "#!#{Gem.ruby} -ws", shebang + end + end - assert_equal "#!#{Gem.ruby} -ws", shebang + def test_shebang_nested_arguments_with_load_relative + load_relative 'yes' do + installer = setup_base_installer + + util_make_exec @spec, "#!/opt/local/ruby/bin/ruby -ws" + + shebang = installer.shebang 'executable' + + shebang_lines = shebang.split "\n" + + assert_equal "#!/bin/sh", shebang_lines.shift + assert_includes shebang_lines, "#!#{Gem.ruby} -ws" + end end def test_shebang_version - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/ruby18" + util_make_exec @spec, "#!/usr/bin/ruby18" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby}", shebang + assert_equal "#!#{Gem.ruby}", shebang + end end def test_shebang_version_arguments - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/ruby18 -ws" + util_make_exec @spec, "#!/usr/bin/ruby18 -ws" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' + + assert_equal "#!#{Gem.ruby} -ws", shebang + end + end + + def test_shebang_version_arguments_with_load_relative + load_relative 'yes' do + installer = setup_base_installer + + util_make_exec @spec, "#!/usr/bin/ruby18 -ws" - assert_equal "#!#{Gem.ruby} -ws", shebang + shebang = installer.shebang 'executable' + + shebang_lines = shebang.split "\n" + + assert_equal "#!/bin/sh", shebang_lines.shift + assert_includes shebang_lines, "#!#{Gem.ruby} -ws" + end end def test_shebang_version_env - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/env ruby18" + util_make_exec @spec, "#!/usr/bin/env ruby18" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby}", shebang + assert_equal "#!#{Gem.ruby}", shebang + end end def test_shebang_version_env_arguments - installer = setup_base_installer + load_relative 'no' do + installer = setup_base_installer - util_make_exec @spec, "#!/usr/bin/env ruby18 -ws" + util_make_exec @spec, "#!/usr/bin/env ruby18 -ws" - shebang = installer.shebang 'executable' + shebang = installer.shebang 'executable' - assert_equal "#!#{Gem.ruby} -ws", shebang + assert_equal "#!#{Gem.ruby} -ws", shebang + end + end + + def test_shebang_version_env_arguments_with_load_relative + load_relative 'yes' do + installer = setup_base_installer + + util_make_exec @spec, "#!/usr/bin/env ruby18 -ws" + + shebang = installer.shebang 'executable' + + shebang_lines = shebang.split "\n" + + assert_equal "#!/bin/sh", shebang_lines.shift + assert_includes shebang_lines, "#!#{Gem.ruby} -ws" + end end def test_shebang_custom @@ -2259,6 +2360,8 @@ gem 'other', version assert_kind_of(String, installer.gem) end + private + def util_execless @spec = util_spec 'z' util_build_gem @spec @@ -2281,4 +2384,13 @@ gem 'other', version def mask 0100755 end + + def load_relative(value) + orig_LIBRUBY_RELATIVE = RbConfig::CONFIG['LIBRUBY_RELATIVE'] + RbConfig::CONFIG['LIBRUBY_RELATIVE'] = value + + yield + ensure + RbConfig::CONFIG['LIBRUBY_RELATIVE'] = orig_LIBRUBY_RELATIVE + end end diff --git a/test/rubygems/test_gem_package.rb b/test/rubygems/test_gem_package.rb index 48dcbee9f1..9172b7eef5 100644 --- a/test/rubygems/test_gem_package.rb +++ b/test/rubygems/test_gem_package.rb @@ -822,7 +822,7 @@ class TestGemPackage < Gem::Package::TarTestCase } tar.add_file 'checksums.yaml.gz', 0444 do |io| Zlib::GzipWriter.wrap io do |gz_io| - gz_io.write YAML.dump bogus_checksums + gz_io.write Psych.dump bogus_checksums end end end @@ -868,7 +868,7 @@ class TestGemPackage < Gem::Package::TarTestCase tar.add_file 'checksums.yaml.gz', 0444 do |io| Zlib::GzipWriter.wrap io do |gz_io| - gz_io.write YAML.dump checksums + gz_io.write Psych.dump checksums end end diff --git a/test/rubygems/test_gem_stream_ui.rb b/test/rubygems/test_gem_stream_ui.rb index 2071526dfa..04de6dd36a 100644 --- a/test/rubygems/test_gem_stream_ui.rb +++ b/test/rubygems/test_gem_stream_ui.rb @@ -5,7 +5,7 @@ require 'timeout' class TestGemStreamUI < Gem::TestCase # increase timeout with MJIT for --jit-wait testing - mjit_enabled = defined?(RubyVM::MJIT) ? RubyVM::MJIT.enabled? : defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? + mjit_enabled = defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? SHORT_TIMEOUT = (RUBY_ENGINE == "ruby" && !mjit_enabled) ? 0.1 : 1.0 module IsTty diff --git a/test/rubygems/test_gem_stub_specification.rb b/test/rubygems/test_gem_stub_specification.rb index e008391ef7..e01d5cad8c 100644 --- a/test/rubygems/test_gem_stub_specification.rb +++ b/test/rubygems/test_gem_stub_specification.rb @@ -180,22 +180,6 @@ class TestStubSpecification < Gem::TestCase assert bar.to_spec end - def test_to_spec_activated - assert @foo.to_spec.is_a?(Gem::Specification) - assert_equal "foo", @foo.to_spec.name - refute @foo.to_spec.instance_variable_get :@ignored - end - - def test_to_spec_missing_extensions - stub = stub_with_extension - - capture_output do - stub.contains_requirable_file? 'nonexistent' - end - - assert stub.to_spec.instance_variable_get :@ignored - end - def stub_with_version spec = File.join @gemhome, 'specifications', 'stub_e-2.gemspec' File.open spec, 'w' do |io| diff --git a/test/rubygems/test_gem_version.rb b/test/rubygems/test_gem_version.rb index 422e1ee86c..f8066ecbb8 100644 --- a/test/rubygems/test_gem_version.rb +++ b/test/rubygems/test_gem_version.rb @@ -154,6 +154,10 @@ class TestGemVersion < Gem::TestCase assert_equal(-1, v("5.a") <=> v("5.0.0.rc2")) assert_equal(1, v("5.x") <=> v("5.0.0.rc2")) + assert_equal(0, v("1.9.3") <=> "1.9.3") + assert_equal(1, v("1.9.3") <=> "1.9.2.99") + assert_equal(-1, v("1.9.3") <=> "1.9.3.1") + assert_nil v("1.0") <=> "whatever" end diff --git a/test/rubygems/utilities.rb b/test/rubygems/utilities.rb index 20416fe70b..613cf6c0ee 100644 --- a/test/rubygems/utilities.rb +++ b/test/rubygems/utilities.rb @@ -135,10 +135,10 @@ class Gem::FakeFetcher def download(spec, source_uri, install_dir = Gem.dir) name = File.basename spec.cache_file path = if Dir.pwd == install_dir # see fetch_command - install_dir - else - File.join install_dir, "cache" - end + install_dir + else + File.join install_dir, "cache" + end path = File.join path, name diff --git a/tool/bundler/dev_gems.rb b/tool/bundler/dev_gems.rb new file mode 100644 index 0000000000..20a9594f4f --- /dev/null +++ b/tool/bundler/dev_gems.rb @@ -0,0 +1,24 @@ +# frozen_string_literal: true + +source "https://rubygems.org" + +gem "rdoc", "6.2.0" # 6.2.1 is required > Ruby 2.3 +gem "test-unit", "~> 3.0" +gem "rake", "~> 13.0" + +group :lint do + gem "rubocop", "~> 0.80.1" + gem "rubocop-performance", "~> 1.5.2" +end + +gem "webrick", "~> 1.6" +gem "parallel_tests", "~> 2.29" +gem "parallel", "1.19.2" # 1.20+ is required > Ruby 2.3 +gem "rspec-core", "~> 3.8" +gem "rspec-expectations", "~> 3.8" +gem "rspec-mocks", "~> 3.8" +gem "uri", "~> 0.10.1" + +group :doc do + gem "ronn", "~> 0.7.3", :platform => :ruby +end diff --git a/tool/bundler/dev_gems.rb.lock b/tool/bundler/dev_gems.rb.lock new file mode 100644 index 0000000000..2465b8ea49 --- /dev/null +++ b/tool/bundler/dev_gems.rb.lock @@ -0,0 +1,73 @@ +GEM + remote: https://rubygems.org/ + specs: + ast (2.4.2) + diff-lcs (1.5.0) + hpricot (0.8.6) + jaro_winkler (1.5.4) + jaro_winkler (1.5.4-java) + mustache (1.1.1) + parallel (1.19.2) + parallel_tests (2.32.0) + parallel + parser (3.1.0.0) + ast (~> 2.4.1) + power_assert (2.0.1) + rainbow (3.1.1) + rdiscount (2.2.0.2) + rdoc (6.2.0) + rexml (3.2.5) + ronn (0.7.3) + hpricot (>= 0.8.2) + mustache (>= 0.7.0) + rdiscount (>= 1.5.8) + rspec-core (3.10.1) + rspec-support (~> 3.10.0) + rspec-expectations (3.10.1) + diff-lcs (>= 1.2.0, < 2.0) + rspec-support (~> 3.10.0) + rspec-mocks (3.10.2) + diff-lcs (>= 1.2.0, < 2.0) + rspec-support (~> 3.10.0) + rspec-support (3.10.3) + rubocop (0.80.1) + jaro_winkler (~> 1.5.1) + parallel (~> 1.10) + parser (>= 2.7.0.1) + rainbow (>= 2.2.2, < 4.0) + rexml + ruby-progressbar (~> 1.7) + unicode-display_width (>= 1.4.0, < 1.7) + rubocop-performance (1.5.2) + rubocop (>= 0.71.0) + ruby-progressbar (1.11.0) + test-unit (3.5.3) + power_assert + unicode-display_width (1.6.1) + uri (0.10.1) + webrick (1.7.0) + +PLATFORMS + java + ruby + universal-java-11 + x64-mingw32 + x86_64-darwin-20 + x86_64-linux + +DEPENDENCIES + parallel (= 1.19.2) + parallel_tests (~> 2.29) + rdoc (= 6.2.0) + ronn (~> 0.7.3) + rspec-core (~> 3.8) + rspec-expectations (~> 3.8) + rspec-mocks (~> 3.8) + rubocop (~> 0.80.1) + rubocop-performance (~> 1.5.2) + test-unit (~> 3.0) + uri (~> 0.10.1) + webrick (~> 1.6) + +BUNDLED WITH + 2.3.6 diff --git a/tool/bundler/rubocop_gems.rb.lock b/tool/bundler/rubocop_gems.rb.lock index 8c74c71d7d..b3ee29e2e6 100644 --- a/tool/bundler/rubocop_gems.rb.lock +++ b/tool/bundler/rubocop_gems.rb.lock @@ -2,17 +2,17 @@ GEM remote: https://rubygems.org/ specs: ast (2.4.2) - diff-lcs (1.4.4) - minitest (5.14.4) + diff-lcs (1.5.0) + minitest (5.15.0) parallel (1.21.0) - parser (3.0.2.0) + parser (3.1.0.0) ast (~> 2.4.1) power_assert (2.0.1) - rainbow (3.0.0) + rainbow (3.1.1) rake (13.0.6) - rake-compiler (1.1.1) + rake-compiler (1.1.7) rake - regexp_parser (2.1.1) + regexp_parser (2.2.0) rexml (3.2.5) rspec (3.10.0) rspec-core (~> 3.10.0) @@ -27,19 +27,19 @@ GEM diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.10.0) rspec-support (3.10.3) - rubocop (1.23.0) + rubocop (1.24.1) parallel (~> 1.10) parser (>= 3.0.0.0) rainbow (>= 2.2.2, < 4.0) regexp_parser (>= 1.8, < 3.0) rexml - rubocop-ast (>= 1.12.0, < 2.0) + rubocop-ast (>= 1.15.1, < 2.0) ruby-progressbar (~> 1.7) unicode-display_width (>= 1.4.0, < 3.0) - rubocop-ast (1.13.0) + rubocop-ast (1.15.1) parser (>= 3.0.1.1) ruby-progressbar (1.11.0) - test-unit (3.5.1) + test-unit (3.5.3) power_assert unicode-display_width (2.1.0) @@ -60,4 +60,4 @@ DEPENDENCIES test-unit BUNDLED WITH - 2.3.3 + 2.3.6 diff --git a/tool/bundler/standard_gems.rb.lock b/tool/bundler/standard_gems.rb.lock index 4201bfd7a0..1120c70259 100644 --- a/tool/bundler/standard_gems.rb.lock +++ b/tool/bundler/standard_gems.rb.lock @@ -2,17 +2,17 @@ GEM remote: https://rubygems.org/ specs: ast (2.4.2) - diff-lcs (1.4.4) - minitest (5.14.4) + diff-lcs (1.5.0) + minitest (5.15.0) parallel (1.21.0) - parser (3.0.2.0) + parser (3.1.0.0) ast (~> 2.4.1) power_assert (2.0.1) - rainbow (3.0.0) + rainbow (3.1.1) rake (13.0.6) - rake-compiler (1.1.1) + rake-compiler (1.1.7) rake - regexp_parser (2.1.1) + regexp_parser (2.2.0) rexml (3.2.5) rspec (3.10.0) rspec-core (~> 3.10.0) @@ -27,25 +27,25 @@ GEM diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.10.0) rspec-support (3.10.3) - rubocop (1.22.3) + rubocop (1.24.1) parallel (~> 1.10) parser (>= 3.0.0.0) rainbow (>= 2.2.2, < 4.0) regexp_parser (>= 1.8, < 3.0) rexml - rubocop-ast (>= 1.12.0, < 2.0) + rubocop-ast (>= 1.15.1, < 2.0) ruby-progressbar (~> 1.7) unicode-display_width (>= 1.4.0, < 3.0) - rubocop-ast (1.13.0) + rubocop-ast (1.15.1) parser (>= 3.0.1.1) - rubocop-performance (1.11.5) + rubocop-performance (1.13.1) rubocop (>= 1.7.0, < 2.0) rubocop-ast (>= 0.4.0) ruby-progressbar (1.11.0) - standard (1.4.0) - rubocop (= 1.22.3) - rubocop-performance (= 1.11.5) - test-unit (3.5.1) + standard (1.6.0) + rubocop (= 1.24.1) + rubocop-performance (= 1.13.1) + test-unit (3.5.3) power_assert unicode-display_width (2.1.0) @@ -66,4 +66,4 @@ DEPENDENCIES test-unit BUNDLED WITH - 2.3.3 + 2.3.6 diff --git a/tool/bundler/test_gems.rb.lock b/tool/bundler/test_gems.rb.lock index 8a06010025..bc3c56b824 100644 --- a/tool/bundler/test_gems.rb.lock +++ b/tool/bundler/test_gems.rb.lock @@ -41,4 +41,4 @@ DEPENDENCIES webrick (= 1.7.0) BUNDLED WITH - 2.3.3 + 2.3.6 diff --git a/tool/sync_default_gems.rb b/tool/sync_default_gems.rb index 18771085b5..ca5283d2c3 100755 --- a/tool/sync_default_gems.rb +++ b/tool/sync_default_gems.rb @@ -101,6 +101,7 @@ def sync_default_gems(gem) File.write("lib/bundler/bundler.gemspec", gemspec_content) cp_r("#{upstream}/bundler/spec", "spec/bundler") + cp_r(Dir.glob("#{upstream}/bundler/tool/bundler/dev_gems*"), "tool/bundler") cp_r(Dir.glob("#{upstream}/bundler/tool/bundler/test_gems*"), "tool/bundler") cp_r(Dir.glob("#{upstream}/bundler/tool/bundler/rubocop_gems*"), "tool/bundler") cp_r(Dir.glob("#{upstream}/bundler/tool/bundler/standard_gems*"), "tool/bundler") -- cgit v1.2.3