-
-
Save indirect/51452cf46b7fbf1d0f1a to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| [andre ✘ ~/sw/gems/bundler](master⚡)$ rake spec | |
| /Users/andre/.rvm/rubies/rbx-head/bin/rbx -S ronn --roff --pipe man/bundle-exec.ronn > lib/bundler/man/bundle-exec | |
| groff -Wall -mtty-char -mandoc -Tascii lib/bundler/man/bundle-exec | col -b > lib/bundler/man/bundle-exec.txt | |
| /Users/andre/.rvm/rubies/rbx-head/bin/rbx -S ronn --roff --pipe man/bundle.ronn > lib/bundler/man/bundle | |
| groff -Wall -mtty-char -mandoc -Tascii lib/bundler/man/bundle | col -b > lib/bundler/man/bundle.txt | |
| /Users/andre/.rvm/rubies/rbx-head/bin/rbx -w -S rspec ./spec/bundler/bundler_spec.rb ./spec/bundler/definition_spec.rb ./spec/bundler/dsl_spec.rb ./spec/bundler/gem_helper_spec.rb ./spec/bundler/psyched_yaml_spec.rb ./spec/bundler/source_spec.rb ./spec/cache/gems_spec.rb ./spec/cache/git_spec.rb ./spec/cache/path_spec.rb ./spec/cache/platform_spec.rb ./spec/install/deploy_spec.rb ./spec/install/gems/c_ext_spec.rb ./spec/install/gems/dependency_api_spec.rb ./spec/install/gems/env_spec.rb ./spec/install/gems/flex_spec.rb ./spec/install/gems/groups_spec.rb ./spec/install/gems/packed_spec.rb ./spec/install/gems/platform_spec.rb ./spec/install/gems/post_install_spec.rb ./spec/install/gems/resolving_spec.rb ./spec/install/gems/simple_case_spec.rb ./spec/install/gems/standalone_spec.rb ./spec/install/gems/sudo_spec.rb ./spec/install/gems/win32_spec.rb ./spec/install/gemspec_spec.rb ./spec/install/git_spec.rb ./spec/install/invalid_spec.rb ./spec/install/path_spec.rb ./spec/install/upgrade_spec.rb ./spec/lock/git_spec.rb ./spec/lock/lockfile_spec.rb ./spec/other/check_spec.rb ./spec/other/clean_spec.rb ./spec/other/config_spec.rb ./spec/other/console_spec.rb ./spec/other/exec_spec.rb ./spec/other/ext_spec.rb ./spec/other/help_spec.rb ./spec/other/init_spec.rb ./spec/other/newgem_spec.rb ./spec/other/open_spec.rb ./spec/other/outdated_spec.rb ./spec/other/platform_spec.rb ./spec/other/show_spec.rb ./spec/quality_spec.rb ./spec/realworld/dependency_api_spec.rb ./spec/realworld/edgecases_spec.rb ./spec/resolver/basic_spec.rb ./spec/resolver/platform_spec.rb ./spec/runtime/executable_spec.rb ./spec/runtime/load_spec.rb ./spec/runtime/platform_spec.rb ./spec/runtime/require_spec.rb ./spec/runtime/setup_spec.rb ./spec/runtime/with_clean_env_spec.rb ./spec/update/gems_spec.rb ./spec/update/git_spec.rb ./spec/update/source_spec.rb -fs --color | |
| Run options: | |
| include {:focused=>true} | |
| exclude {:ruby=>"1.9", :sudo=>true, :realworld=>true} | |
| All examples were filtered out; ignoring {:focused=>true} | |
| Bundler | |
| #load_gemspec_uncached | |
| should catch Psych syntax errors | |
| Bundler::Definition | |
| #lock | |
| when it's not possible to write to the file | |
| raises an InstallError with explanation (FAILED - 1) | |
| Bundler::Dsl | |
| #_normalize_options | |
| should convert :github to :git | |
| should convert 'rails' to 'rails/rails' | |
| should interpret slashless 'github:' value as account name | |
| #method_missing | |
| should raise an error for unknown DSL methods | |
| #eval_gemfile | |
| handles syntax errors with a useful message | |
| syntax errors | |
| should raise a Bundler::GemfileError | |
| Bundler::GemHelper tasks | |
| determining gemspec | |
| interpolates the name when there is only one gemspec | |
| interpolates the name for a hidden gemspec | |
| should fail when there is no gemspec | |
| should fail when there are two gemspecs and the name isn't specified | |
| handles namespaces and converting to CamelCase | |
| gem management | |
| uses a shell UI for output | |
| install_tasks | |
| defines Rake tasks | |
| provides a way to access the gemspec object | |
| build | |
| builds | |
| raises an appropriate error when the build fails | |
| install | |
| installs | |
| raises an appropriate error when the install fails | |
| release | |
| shouldn't push if there are uncommitted files | |
| raises an appropriate error if there is no git remote | |
| releases | |
| releases even if tag already exists | |
| ArgumentError | |
| is raised on YAML parse errors | |
| Bundler::Source::Rubygems | |
| caches | |
| should include Bundler.app_cache | |
| should include GEM_PATH entries | |
| should be an array of strings or pathnames | |
| bundle cache | |
| when there are only gemsources | |
| copies the .gem file to vendor/cache | |
| uses the cache as a source when installing gems | |
| uses the cache as a source when installing gems with --local | |
| does not reinstall gems from the cache if they exist on the system | |
| does not reinstall gems from the cache if they exist in the bundle | |
| creates a lockfile | |
| when there are also git sources | |
| still works | |
| should not explode if the lockfile is not present | |
| when previously cached | |
| re-caches during install | |
| adds and removes when gems are updated | |
| adds new gems and dependencies | |
| removes .gems for removed gems and dependencies | |
| removes .gems when gem changes to git source | |
| doesn't remove gems that are for another platform (FAILED - 2) | |
| doesn't remove gems with mismatched :rubygems_version or :date | |
| handles directories and non .gem files in the cache | |
| does not say that it is removing gems when it isn't actually doing so | |
| does not warn about all if it doesn't have any git/path dependency | |
| should install gems with the name bundler in them (that aren't bundler) | |
| git base name | |
| base_name should strip private repo uris | |
| base_name should strip network share paths | |
| bundle cache with git | |
| copies repository to vendor cache and uses it | |
| copies repository to vendor cache and uses it even when installed with bundle --path | |
| runs twice without exploding | |
| tracks updates | |
| uses the local repository to generate the cache | |
| copies repository to vendor cache, including submodules | |
| displays warning message when detecting git repo in Gemfile | |
| does not display warning message if cache_all is set in bundle config | |
| bundle package with git | |
| copies repository to vendor cache and uses it | |
| copies repository to vendor cache and uses it even when installed with bundle --path | |
| runs twice without exploding | |
| tracks updates | |
| uses the local repository to generate the cache | |
| copies repository to vendor cache, including submodules | |
| displays warning message when detecting git repo in Gemfile | |
| does not display warning message if cache_all is set in bundle config | |
| bundle cache with path | |
| is no-op when the path is within the bundle | |
| copies when the path is outside the bundle | |
| updates the path on each cache | |
| removes stale entries cache | |
| raises a warning without --all | |
| stores the given flag | |
| can rewind chosen configuration | |
| bundle package with path | |
| is no-op when the path is within the bundle | |
| copies when the path is outside the bundle | |
| updates the path on each cache | |
| removes stale entries cache | |
| raises a warning without --all | |
| stores the given flag | |
| can rewind chosen configuration | |
| bundle cache with multiple platforms | |
| ensures that bundle install does not delete gems for other platforms | |
| ensures that bundle update does not delete gems for other platforms | |
| install with --deployment or --frozen | |
| fails without a lockfile and says that --deployment requires a lock | |
| fails without a lockfile and says that --frozen requires a lock | |
| works after you try to deploy without a lock | |
| still works if you are not in the app directory and specify --gemfile | |
| works if you exclude a group with a git gem | |
| works when you bundle exec bundle | |
| works when using path gems from the same path and the version is specified | |
| with an existing lockfile | |
| works with the --deployment flag if you didn't change anything | |
| works with the --frozen flag if you didn't change anything | |
| explodes with the --deployment flag if you make a change and don't check in the lockfile | |
| can have --frozen set via an environment variable | |
| explodes with the --frozen flag if you make a change and don't check in the lockfile | |
| explodes if you remove a gem and don't check in the lockfile | |
| explodes if you add a source | |
| explodes if you unpin a source | |
| explodes if you unpin a source, leaving it pinned somewhere else | |
| remembers that the bundle is frozen at runtime | |
| installing a gem with C extensions | |
| installs | |
| gemcutter's dependency API | |
| should use the API | |
| should URI encode gem names | |
| should handle nested dependencies | |
| should handle multiple gem dependencies on the same gem | |
| should use the endpoint when using --deployment | |
| handles git dependencies that are in rubygems | |
| handles git dependencies that are in rubygems using --deployment | |
| An exception occurred evaluating command line code | |
| no such file to load -- rcov.rb (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| falls back when the API errors out (FAILED - 3) | |
| falls back when hitting the Gemcutter Dependency Limit | |
| falls back when Gemcutter API doesn't return proper Marshal format | |
| timeouts when Bundler::Fetcher redirects too much | |
| fetches again when more dependencies are found in subsequent sources | |
| prints API output properly with back deps | |
| does not fetch every specs if the index of gems is large when doing back deps | |
| uses the endpoint if all sources support it | |
| fetches again when more dependencies are found in subsequent sources using --deployment | |
| does not refetch if the only unmet dependency is bundler | |
| installs the binstubs | |
| installs the bins when using --path and uses autoclean | |
| installs the bins when using --path and uses bundle clean | |
| prints post_install_messages | |
| should display the post install message for a dependency | |
| when --full-index is specified | |
| should use the modern index for install | |
| should use the modern index for update | |
| when using basic authentication | |
| passes basic authentication details and strips out creds | |
| strips http basic authentication creds for modern index | |
| strips http basic auth creds when it can't reach the server | |
| when ruby is compiled without openssl | |
| explains what to do to get it | |
| bundle install with ENV conditionals | |
| when just setting an ENV key as a string | |
| excludes the gems when the ENV variable is not set | |
| includes the gems when the ENV variable is set | |
| when just setting an ENV key as a symbol | |
| excludes the gems when the ENV variable is not set | |
| includes the gems when the ENV variable is set | |
| when setting a string to match the env | |
| excludes the gems when the ENV variable is not set | |
| excludes the gems when the ENV variable is set but does not match the condition | |
| includes the gems when the ENV variable is set and matches the condition | |
| when setting a regex to match the env | |
| excludes the gems when the ENV variable is not set | |
| excludes the gems when the ENV variable is set but does not match the condition | |
| includes the gems when the ENV variable is set and matches the condition | |
| bundle flex_install | |
| installs the gems as expected | |
| installs even when the lockfile is invalid | |
| keeps child dependencies at the same version | |
| adding new gems | |
| installs added gems without updating previously installed gems | |
| keeps child dependencies pinned | |
| removing gems | |
| removes gems without changing the versions of remaining gems | |
| removes top level dependencies when removed from the Gemfile while leaving other dependencies intact | |
| removes child dependencies | |
| when Gemfile conflicts with lockfile | |
| does not install gems whose dependencies are not met | |
| suggests bundle update when the Gemfile requires different versions than the lock | |
| subtler cases | |
| does something | |
| should work when you update | |
| when adding a new source | |
| updates the lockfile | |
| bundle install with gem sources | |
| with groups | |
| installing with no options | |
| installs gems in the default group | |
| installs gems in a group block into that group | |
| installs gems with inline :groups into those groups | |
| sets up everything if Bundler.setup is used with no groups | |
| removes old groups when new groups are set up | |
| sets up old groups when they have previously been removed | |
| installing --without | |
| with gems assigned to a single group | |
| installs gems in the default group | |
| does not install gems from the excluded group | |
| does not install gems from the previously excluded group | |
| does not say it installed gems from the excluded group | |
| allows Bundler.setup for specific groups | |
| does not effect the resolve | |
| still works on a different machine and excludes gems | |
| still works when BUNDLE_WITHOUT is set | |
| clears without when passed an empty list | |
| doesn't clear without when nothing is passed | |
| with gems assigned to multiple groups | |
| installs gems in the default group | |
| installs the gem if any of its groups are installed | |
| An exception occurred running /Users/andre/sw/gems/bundler/bin/bundle | |
| undefined method `lock' on an instance of Bundler::CLI. (NoMethodError) | |
| Backtrace: | |
| Kernel(Bundler::CLI)#method_missing at kernel/delta/kernel.rb:81 | |
| Thor::Task(Thor::DynamicTask)#run at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor/task.rb:29 | |
| Thor::DynamicTask#run at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor/task.rb:126 | |
| Thor::Invocation(Bundler::CLI)#invoke_task at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor | |
| /invocation.rb:120 | |
| Thor.dispatch at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor.rb:344 | |
| Thor::Base::ClassMethods(Class)#start at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor/base.rb:434 | |
| { } in Object#__script__ at /Users/andre/sw/gems/bundler/bin | |
| /bundle:14 | |
| Bundler.with_friendly_errors at /Users/andre/sw/gems/bundler/lib | |
| /bundler/friendly_errors.rb:4 | |
| Object#__script__ at /Users/andre/sw/gems/bundler/bin | |
| /bundle:14 | |
| Rubinius::CodeLoader#load_script at kernel/delta/codeloader.rb:68 | |
| Rubinius::CodeLoader.load_script at kernel/delta/codeloader.rb:118 | |
| Rubinius::Loader#script at kernel/loader.rb:614 | |
| Rubinius::Loader#main at kernel/loader.rb:815 | |
| works when locked as well | |
| with a gem defined multiple times in different groups | |
| installs the gem w/ option --without emo | |
| installs the gem w/ option --without lolercoaster | |
| does not install the gem w/ option --without emo lolercoaster | |
| does not install the gem w/ option --without 'emo lolercoaster' | |
| nesting groups | |
| installs gems in the default group | |
| installs the gem if any of its groups are installed | |
| An exception occurred running /Users/andre/sw/gems/bundler/bin/bundle | |
| undefined method `lock' on an instance of Bundler::CLI. (NoMethodError) | |
| Backtrace: | |
| Kernel(Bundler::CLI)#method_missing at kernel/delta/kernel.rb:81 | |
| Thor::Task(Thor::DynamicTask)#run at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor/task.rb:29 | |
| Thor::DynamicTask#run at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor/task.rb:126 | |
| Thor::Invocation(Bundler::CLI)#invoke_task at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor | |
| /invocation.rb:120 | |
| Thor.dispatch at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor.rb:344 | |
| Thor::Base::ClassMethods(Class)#start at /Users/andre/sw/gems/bundler/lib | |
| /bundler/vendor/thor/base.rb:434 | |
| { } in Object#__script__ at /Users/andre/sw/gems/bundler/bin | |
| /bundle:14 | |
| Bundler.with_friendly_errors at /Users/andre/sw/gems/bundler/lib | |
| /bundler/friendly_errors.rb:4 | |
| Object#__script__ at /Users/andre/sw/gems/bundler/bin | |
| /bundle:14 | |
| Rubinius::CodeLoader#load_script at kernel/delta/codeloader.rb:68 | |
| Rubinius::CodeLoader.load_script at kernel/delta/codeloader.rb:118 | |
| Rubinius::Loader#script at kernel/loader.rb:614 | |
| Rubinius::Loader#main at kernel/loader.rb:815 | |
| works when locked as well | |
| bundle install with gem sources | |
| when cached and locked | |
| does not hit the remote at all | |
| does not hit the remote at all | |
| does not reinstall already-installed gems | |
| ignores cached gems for the wrong platform (FAILED - 4) | |
| does not update the cache if --no-cache is passed | |
| bundle install across platforms | |
| maintains the same lockfile if all gems are compatible across platforms | |
| An exception occurred evaluating command line code | |
| no such file to load -- platform_specific.rb (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| pulls in the correct platform specific gem (FAILED - 5) | |
| An exception occurred evaluating command line code | |
| no such file to load -- nokogiri.rb (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| works with gems that have different dependencies (FAILED - 6) | |
| An exception occurred evaluating command line code | |
| no such file to load -- nokogiri.rb (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| works the other way with gems that have different dependencies (FAILED - 7) | |
| fetches gems again after changing the version of Ruby | |
| works after switching Rubies | |
| bundle install with platform conditionals | |
| installs gems tagged w/ the current platforms | |
| does not install gems tagged w/ another platforms | |
| installs gems tagged w/ the current platforms inline | |
| does not install gems tagged w/ another platforms inline | |
| installs gems tagged w/ the current platform inline | |
| doesn't install gems tagged w/ another platform inline | |
| does not blow up on sources with all platform-excluded specs | |
| when a gem has an architecture in its platform | |
| An exception occurred evaluating command line code | |
| no such file to load -- rcov.rb (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| still installs correctly (FAILED - 8) | |
| bundle install with gem sources | |
| when gems include post install messages | |
| should display the post-install messages after installing | |
| when gems do not include post install messages | |
| should not display any post-install messages | |
| when a dependecy includes a post install message | |
| should display the post install message | |
| bundle install with gem sources | |
| install time dependencies | |
| installs gems with implicit rake dependencies | |
| installs gems with a dependency with no type | |
| with crazy rubygem plugin stuff | |
| installs plugins | |
| installs plugins depended on by other plugins | |
| installs multiple levels of dependencies | |
| bundle install with gem sources | |
| the simple case | |
| prints output and returns if no dependencies are specified | |
| does not make a lockfile if the install fails | |
| creates a Gemfile.lock | |
| creates lock files based on the Gemfile name | |
| doesn't delete the lockfile if one already exists | |
| does not touch the lockfile if nothing changed | |
| fetches gems | |
| fetches gems when multiple versions are specified | |
| fetches gems when multiple versions are specified take 2 | |
| raises an appropriate error when gems are specified using symbols | |
| pulls in dependencies | |
| does the right version | |
| does not install the development dependency | |
| resolves correctly | |
| activates gem correctly according to the resolved gems | |
| does not reinstall any gem that is already available locally | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| works when the gemfile specifies gems that only exist in the system | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| prioritizes local gems over remote gems | |
| finds gems in multiple sources | |
| gives a useful error if no sources are set | |
| creates a Gemfile.lock on a blank Gemfile | |
| gracefully handles error when rubygems server is unavailable | |
| doesn't blow up when the local .bundle/config is empty | |
| doesn't blow up when the global .bundle/config is empty | |
| with a gem that installs multiple platforms | |
| installs gems for the local platform as first choice | |
| falls back on plain ruby (FAILED - 9) | |
| An exception occurred evaluating command line code | |
| no such file to load -- platform_specific (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| installs gems for java (FAILED - 10) | |
| An exception occurred evaluating command line code | |
| no such file to load -- platform_specific (LoadError) | |
| Backtrace: | |
| Rubinius::CodeLoader#load_error at kernel/common/codeloader.rb:389 | |
| Rubinius::CodeLoader#resolve_require_path at kernel/common/codeloader.rb:376 | |
| { } in Rubinius::CodeLoader#require at kernel/common/codeloader.rb:104 | |
| Rubinius.synchronize at kernel/bootstrap/rubinius.rb:150 | |
| Rubinius::CodeLoader#require at kernel/common/codeloader.rb:103 | |
| Rubinius::CodeLoader.require at kernel/common/codeloader.rb:206 | |
| Kernel(Object)#require at kernel/common/kernel.rb:631 | |
| { } in Object#__script__ at -e:2 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| installs gems for windows (FAILED - 11) | |
| doing bundle install foo | |
| works | |
| allows running bundle install --system without deleting foo | |
| allows running bundle install --system after deleting foo | |
| when Bundler root contains regex chars | |
| doesn't blow up | |
| when prerelease gems are available | |
| finds prereleases | |
| uses regular releases if available | |
| uses prereleases if requested | |
| when prerelease gems are not available | |
| still works | |
| when BUNDLE_PATH or the global path config is set | |
| installs gems to a path if one is specified | |
| installs gems to BUNDLE_PATH with env | |
| installs gems to BUNDLE_PATH relative to root when relative | |
| installs gems to a path if one is specified | |
| installs gems to BUNDLE_PATH with global | |
| installs gems to BUNDLE_PATH relative to root when relative | |
| installs gems to BUNDLE_PATH from .bundle/config | |
| sets BUNDLE_PATH as the first argument to bundle install | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| disables system gems when passing a path to install | |
| when passing in a Gemfile via --gemfile | |
| finds the gemfile | |
| when requesting a quiet install via --quiet | |
| should be quiet if there are no warnings | |
| should still display warnings | |
| when disabling system gems | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| behaves like bundle install vendor/bundle with --deployment | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| does not use available system gems with bundle --path vendor/bundle | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| handles paths with regex characters in them | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| prints a warning to let the user know what has happened with bundle --path vendor/bundle | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| disallows --path vendor/bundle --system | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| remembers to disable system gems after the first time with bundle --path vendor/bundle | |
| when loading only the default group | |
| should not load all groups | |
| when a gem has a YAML gemspec | |
| still installs correctly | |
| still installs correctly when using path | |
| bundler dependencies | |
| are forced to the current bundler version | |
| are not added if not already present | |
| causes a conflict if explicitly requesting a different version | |
| works for gems with multiple versions in its dependencies | |
| includes bundler in the bundle when it's a child dependency | |
| allows gem 'bundler' when Bundler is not in the Gemfile or its dependencies | |
| causes a conflict if child dependencies conflict | |
| causes a conflict if a child dependency conflicts with the Gemfile | |
| can install dependencies even if | |
| when locked and installed with --without | |
| uses the correct versions even if --without was used on the original | |
| does not hit the remote a second time | |
| when system_bindir is set | |
| overrides Gem.bindir | |
| bundle install --standalone | |
| with simple gems | |
| still makes the gems available to normal bundler | |
| generates a bundle/bundler/setup.rb | |
| makes the gems available without bundler | |
| works on a different system | |
| with a combination of gems and git repos | |
| still makes the gems available to normal bundler | |
| generates a bundle/bundler/setup.rb | |
| makes the gems available without bundler | |
| with groups | |
| makes the gems available without bundler | |
| allows creating a standalone file with limited groups | |
| allows --without to limit the groups used in a standalone | |
| allows --path to change the location of the standalone bundle | |
| allows remembered --without to limit the groups used in a standalone | |
| with gemcutter's dependency API | |
| simple gems | |
| should run without errors | |
| still makes the gems available to normal bundler | |
| generates a bundle/bundler/setup.rb | |
| makes the gems available without bundler | |
| works on a different system | |
| with --binstubs | |
| creates stubs that use the standalone load path | |
| creates stubs that can be executed from anywhere | |
| bundle install with win32-generated lockfile | |
| should read lockfile | |
| bundle install from an existing gemspec | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should install runtime and development dependencies | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| that is hidden should install runtime and development dependencies | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should handle a list of requirements | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should raise if there are no gemspecs available | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should raise if there are too many gemspecs available | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should pick a specific gemspec | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should use a specific group for development dependencies | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should match a lockfile even if the gemspec defines development dependencies | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should evaluate the gemspec in its directory | |
| when child gemspecs conflict with a released gemspec | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should install the child gemspec's deps | |
| bundle install with git sources | |
| uses a ref if specified | |
| correctly handles cases with invalid gemspecs | |
| runs the gemspec in the context of its parent directory | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| installs from git even if a rubygems gem is present | |
| fakes the gem out if there is no gemspec | |
| catches git errors and spits out useful output | |
| works when the gem path has spaces in it | |
| handles repos that have been force-pushed | |
| ignores submodules if :submodule is not passed | |
| handles repos with submodules | |
| handles implicit updates when modifying the source info | |
| does not to a remote fetch if the revision is cached locally | |
| doesn't blow up if bundle install is run twice in a row | |
| does not duplicate git gem sources | |
| when floating on master | |
| fetches gems | |
| caches the git repo | |
| does not update the git source implicitly | |
| setups executables | |
| complains if pinned specs don't exist in the git repo | |
| still works after moving the application directory | |
| can still install after moving the application directory | |
| with an empty git block | |
| does not explode | |
| when specifying a revision | |
| works | |
| works when the revision is a symbol | |
| when specifying local override | |
| uses the local repository instead of checking a new one out | |
| chooses the local repository on runtime | |
| updates specs on runtime | |
| updates ref on install | |
| explodes if given path does not exist on install | |
| explodes if branch is not given on install | |
| does not explode if disable_local_branch_check is given | |
| explodes on different branches on install | |
| explodes on invalid revision on install | |
| specified inline | |
| installs from git even if a newer gem is available elsewhere | |
| installs dependencies from git even if a newer gem is available elsewhere | |
| correctly unlocks when changing to a git source | |
| correctly unlocks when changing to a git source without versions | |
| block syntax | |
| pulls all gems from a git block | |
| switching sources | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| doesn't explode when switching Path to Git sources | |
| doesn't explode when switching Gem to Git source | |
| bundle install after the remote has been updated | |
| installs | |
| bundle install --deployment with git sources | |
| works | |
| gem install hooks | |
| runs pre-install hooks | |
| runs post-install hooks | |
| complains if the install hook fails | |
| bundle install with deprecated features | |
| reports that lib is an invalid option | |
| bundle install to a dead symlink | |
| reports the symlink is dead | |
| bundle install with explicit source paths | |
| fetches gems | |
| supports pinned paths | |
| supports relative paths | |
| expands paths | |
| expands paths relative to Bundler.root | |
| expands paths when comparing locked paths to Gemfile paths | |
| installs dependencies from the path even if a newer gem is available elsewhere | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| works | |
| supports gemspec syntax | |
| supports gemspec syntax with an alternative path | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| doesn't automatically unlock dependencies when using the gemspec syntax | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| doesn't automatically unlock dependencies when using the gemspec syntax and the gem has development dependencies | |
| raises if there are multiple gemspecs | |
| allows :name to be specified to resolve ambiguity | |
| sets up executables | |
| handles directories in bin/ | |
| removes the .gem file after installing | |
| keeps source pinning | |
| works when the path does not have a gemspec | |
| installs executable stubs | |
| block syntax | |
| pulls all gems from a path block | |
| when the gem version in the path is updated | |
| unlocks all gems when the top level gem is updated | |
| unlocks all gems when a child dependency gem is updated | |
| when dependencies in the path are updated | |
| gets dependencies that are updated in the path | |
| switching sources | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| doesn't switch pinned git sources to rubygems when pinning the parent gem to a path source | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| switches the source when the gem existed in rubygems and the path was already being used for another gem | |
| bundle install for the first time with v1.0 | |
| removes lockfiles in 0.9 YAML format | |
| removes env.rb if it exists | |
| bundle lock with git gems | |
| doesn't break right after running lock | |
| locks a git source to the current ref | |
| provides correct #full_gem_path | |
| the lockfile format | |
| generates a simple lockfile for a single source, gem | |
| generates a simple lockfile for a single source, gem with dependencies | |
| generates a simple lockfile for a single source, gem with a version requirement | |
| generates lockfiles with multiple requirements | |
| generates a simple lockfile for a single pinned source, gem with a version requirement | |
| does not assplode when a platform specific dependency is present and the Gemfile has not been resolved on that platform | |
| serializes global git sources | |
| generates a lockfile with a ref for a single pinned source, git gem with a branch requirement | |
| generates a lockfile with a ref for a single pinned source, git gem with a tag requirement | |
| serializes pinned path sources to the lockfile | |
| lists gems alphabetically | |
| order dependencies of dependencies in alphabetical order | |
| orders dependencies according to version | |
| does not add the :require option to the lockfile | |
| does not add the :group option to the lockfile | |
| stores relative paths when the path is provided in a relative fashion and in Gemfile dir | |
| stores relative paths when the path is provided in a relative fashion and is above Gemfile dir | |
| stores relative paths when the path is provided in an absolute fashion but is relative | |
| keeps existing platforms in the lockfile | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| persists the spec's platform to the lockfile (FAILED - 12) | |
| does not add duplicate gems | |
| does not add duplicate dependencies | |
| does not add duplicate dependencies with versions | |
| does not add duplicate dependencies in different groups | |
| raises if two different versions are used | |
| raises if two different versions are used | |
| works correctly with multiple version dependencies | |
| fix corrupted lockfiles | |
| line endings | |
| generates Gemfile.lock with \n line endings | |
| during updates | |
| preserves Gemfile.lock \n line endings | |
| preserves Gemfile.lock \n\r line endings | |
| when nothing changes | |
| preserves Gemfile.lock \n line endings | |
| preserves Gemfile.lock \n\r line endings | |
| bundle check | |
| returns success when the Gemfile is satisfied | |
| works with the --gemfile flag when not in the directory | |
| creates a Gemfile.lock by default if one did not exist | |
| does not create a Gemfile.lock if --dry-run was passed | |
| prints a generic error if the missing gems are unresolvable | |
| prints a generic error if a Gemfile.lock does not exist and a toplevel dependency does not exist | |
| prints a generic message if you changed your lockfile | |
| remembers --without option from install | |
| ensures that gems are actually installed and not just cached | |
| ignores missing gems restricted to other platforms | |
| works with env conditionals | |
| outputs an error when the default Gemfile is not found | |
| does not output fatal error message | |
| should not crash when called multiple times on a new machine | |
| fails when there's no lock file and frozen is set | |
| --path | |
| returns success | |
| should write to .bundle/config | |
| when locked | |
| returns success when the Gemfile is satisfied | |
| shows what is missing with the current Gemfile if it is not satisfied | |
| bundle clean | |
| removes unused gems that are different | |
| removes old version of gem if unused | |
| removes new version of gem if unused | |
| remove gems in bundle without groups | |
| does not remove cached git dir if it's being used | |
| removes unused git gems | |
| removes old git gems | |
| does not remove nested gems in a git repo | |
| does not remove git sources that are in without groups | |
| does not blow up when using without groups | |
| displays an error when used without --path | |
| removes .gem/.gemspec file even if there's no corresponding gem dir is already moved | |
| does not call clean automatically when using system gems | |
| --clean should override the bundle setting on install | |
| --clean should override the bundle setting on update | |
| does not clean automatically on --path | |
| does not clean on bundle update with --path | |
| does not clean on bundle update when using --system | |
| cleans system gems when --force is used | |
| cleans git gems with a 7 length git revision | |
| when using --force on system gems, it doesn't remove binaries | |
| doesn't blow up on path gems without a .gempsec | |
| .bundle/config | |
| BUNDLE_APP_CONFIG | |
| can be moved with an environment variable | |
| can provide a relative path with the environment variable | |
| removes environment.rb from BUNDLE_APP_CONFIG's path | |
| global | |
| is the default | |
| can also be set explicitly | |
| has lower precedence than local | |
| has lower precedence than env | |
| can be deleted | |
| warns when overriding | |
| local | |
| can also be set explicitly | |
| has higher precedence than env | |
| can be deleted | |
| warns when overriding | |
| bundle console | |
| starts IRB with the default group loaded | |
| doesn't load any other groups | |
| when given a group | |
| loads the given group | |
| loads the default group | |
| doesn't load other groups | |
| bundle exec | |
| activates the correct gem | |
| works when the bins are in ~/.bundle | |
| works when running from a random directory | |
| works when exec'ing something else | |
| accepts --verbose | |
| passes --verbose to command if it is given after the command | |
| can run a command named --verbose | |
| handles different versions in different bundles | |
| handles gems installed with --without | |
| should not duplicate already exec'ed RUBYOPT or PATH | |
| errors nicely when the argument doesn't exist | |
| errors nicely when the argument is not executable | |
| errors nicely when no arguments are passed | |
| with gem executables | |
| run from a random directory | |
| works when unlocked | |
| works when locked | |
| from gems bundled via :path | |
| works when unlocked | |
| works when locked | |
| from gems bundled via :git | |
| works when unlocked | |
| works when locked | |
| from gems bundled via :git with no gemspec | |
| works when unlocked | |
| works when locked | |
| Gem::Specification#match_platform | |
| does not match platforms other than the gem platform | |
| Bundler::GemHelpers#generic | |
| converts non-windows platforms into ruby | |
| Gem::SourceIndex#refresh! | |
| NOTE: Gem.source_index is deprecated, use Specification. It will be removed on or after 2011-11-01. | |
| Gem.source_index called from -e:2. | |
| NOTE: Gem::SourceIndex#refresh! is deprecated with no replacement. It will be removed on or after 2011-11-01. | |
| Gem::SourceIndex#refresh! called from -e:2. | |
| NOTE: Gem::SourceIndex#load_gems_in is deprecated with no replacement. It will be removed on or after 2011-11-01. | |
| Gem::SourceIndex#load_gems_in called from /Users/andre/.rvm/rubies/rbx-head/lib/rubygems/source_index.rb:322. | |
| NOTE: Gem::SourceIndex#add_spec is deprecated, use Specification.add_spec. It will be removed on or after 2011-11-01. | |
| Gem::SourceIndex#add_spec called from /Users/andre/.rvm/rubies/rbx-head/lib/rubygems/source_index.rb:127. | |
| NOTE: Gem::SourceIndex#refresh! is deprecated with no replacement. It will be removed on or after 2011-11-01. | |
| Gem::SourceIndex#refresh! called from -e:2. | |
| NOTE: Gem::SourceIndex#load_gems_in is deprecated with no replacement. It will be removed on or after 2011-11-01. | |
| Gem::SourceIndex#load_gems_in called from /Users/andre/.rvm/rubies/rbx-head/lib/rubygems/source_index.rb:322. | |
| does not explode when called | |
| bundle help | |
| uses groff when available | |
| prefixes bundle commands with bundle- when finding the groff files | |
| simply outputs the txt file when there is no groff on the path | |
| still outputs the old help for commands that do not have man pages yet | |
| bundle init | |
| generates a Gemfile | |
| does not change existing Gemfiles | |
| should generate from an existing gemspec | |
| bundle gem | |
| generates a gem skeleton | |
| starts with version 0.0.1 | |
| nests constants so they work | |
| sets gemspec license to MIT by default | |
| requires the version file | |
| runs rake without problems | |
| git config user.{name,email} present | |
| sets gemspec author to git user.name if available | |
| sets gemspec email to git user.email if available | |
| git config user.{name,email} is not set | |
| sets gemspec author to default message if git user.name is not set or empty | |
| sets gemspec email to default message if git user.email is not set or empty | |
| --bin parameter set | |
| builds bin skeleton | |
| requires 'test-gem' | |
| --test parameter set to rspec | |
| builds spec skeleton | |
| requires 'test-gem' | |
| creates a default test which fails | |
| bundle open | |
| opens the gem with BUNDLER_EDITOR as highest priority | |
| opens the gem with VISUAL as 2nd highest priority | |
| opens the gem with EDITOR as 3rd highest priority | |
| complains if no EDITOR is set | |
| complains if gem not in bundle | |
| suggests alternatives for similar-sounding gems | |
| bundle outdated | |
| with no arguments | |
| returns list of outdated gems | |
| with --local option | |
| doesn't hit repo2 | |
| with specified gems | |
| returns list of outdated gems | |
| pre-release gems | |
| without the --pre option | |
| ignores pre-release versions | |
| with the --pre option | |
| includes pre-release versions | |
| when current gem is a pre-release | |
| includes the gem | |
| bundle platform | |
| without flags | |
| returns all the output (FAILED - 13) | |
| doesn't print ruby version requirement if it isn't specified | |
| doesn't match the ruby version requirement (FAILED - 14) | |
| --ruby | |
| returns ruby version when explicit | |
| engine defaults to MRI | |
| handles jruby | |
| handles rbx | |
| raises an error if engine is used but engine version is not | |
| raises an error if engine_version is used but engine is not | |
| raises an error if engine version doesn't match ruby version for mri | |
| should print if no ruby version is specified | |
| bundle install | |
| installs fine when the ruby version matches | |
| installs fine with any engine | |
| doesn't install when the ruby version doesn't match | |
| doesn't install when engine doesn't match | |
| doesn't install when engine version doesn't match | |
| bundle check | |
| checks fine when the ruby version matches | |
| checks fine with any engine | |
| fails when ruby version doesn't match | |
| fails when engine doesn't match | |
| fails when engine version doesn't match (FAILED - 15) | |
| bundle update | |
| updates successfully when the ruby version matches | |
| updates fine with any engine | |
| fails when ruby version doesn't match | |
| fails when ruby engine doesn't match | |
| fails when ruby engine version doesn't match | |
| bundle show | |
| prints path if ruby version is correct | |
| prints path if ruby version is correct for any engine | |
| fails if ruby version doesn't match | |
| fails if engine doesn't match | |
| fails if engine version doesn't match | |
| bundle cache | |
| copies the .gem file to vendor/cache when ruby version matches | |
| copies the .gem file to vendor/cache when ruby version matches for any engine | |
| fails if the ruby version doesn't match | |
| fails if the engine doesn't match | |
| fails if the engine version doesn't match | |
| bundle pack | |
| copies the .gem file to vendor/cache when ruby version matches | |
| copies the .gem file to vendor/cache when ruby version matches any engine | |
| fails if the ruby version doesn't match | |
| fails if the engine doesn't match | |
| fails if the engine version doesn't match | |
| bundle exec | |
| activates the correct gem when ruby version matches | |
| activates the correct gem when ruby version matches any engine | |
| fails when the ruby version doesn't match | |
| fails when the engine doesn't match | |
| fails when the engine version doesn't match | |
| bundle console | |
| starts IRB with the default group loaded when ruby version matches | |
| starts IRB with the default group loaded when ruby version matches any engine | |
| fails when ruby version doesn't match | |
| fails when engine doesn't match | |
| fails when engine version doesn't match | |
| Bundler.setup | |
| makes a Gemfile.lock if setup succeeds | |
| makes a Gemfile.lock if setup succeeds for any engine | |
| fails when ruby version doesn't match | |
| fails when engine doesn't match | |
| fails when engine version doesn't match | |
| bundle outdated | |
| returns list of outdated gems when the ruby version matches | |
| returns list of outdated gems when the ruby version matches for any engine | |
| fails when the ruby version doesn't match | |
| fails when the engine doesn't match | |
| fails when the engine version doesn't match | |
| bundle show | |
| creates a Gemfile.lock if one did not exist | |
| creates a Gemfile.lock when invoked with a gem name | |
| prints path if gem exists in bundle | |
| prints the path to the running bundler | |
| complains if gem not in bundle | |
| prints path of all gems in bundle | |
| bundle show with a git repo | |
| prints out git info | |
| prints out branch names other than master | |
| doesn't print the branch when tied to a ref | |
| The library itself | |
| has no malformed whitespace | |
| can still be built | |
| Resolving | |
| resolves a single gem (FAILED - 16) | |
| resolves a gem with dependencies (FAILED - 17) | |
| Resolving platform craziness | |
| with cross-platform gems | |
| resolves a simple multi platform gem (FAILED - 18) | |
| doesn't pull gems that don't exist for the current platform (FAILED - 19) | |
| doesn't pull gems when the version is available for all requested platforms (FAILED - 20) | |
| with mingw32 | |
| finds mswin gems (FAILED - 21) | |
| finds mingw gems (FAILED - 22) | |
| with conflicting cases | |
| reports on the conflict (FAILED - 23) | |
| Running bin/* commands | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| runs the bundled command when in the bundle | |
| allows the location of the gem stubs to be specified | |
| allows absolute paths as a specification of where to install bin stubs | |
| uses the default ruby install name when shebang is not specified | |
| allows the name of the shebang executable to be specified | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| runs the bundled command when out of the bundle | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| works with gems in path | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| don't bundle da bundla | |
| does not generate bin stubs if the option was not specified | |
| remembers that the option was specified | |
| Bundler.load | |
| with a gemfile | |
| provides a list of the env dependencies (FAILED - 24) | |
| provides a list of the resolved gems (FAILED - 25) | |
| ignores blank BUNDLE_GEMFILEs | |
| without a gemfile | |
| raises an exception if the default gemfile is not found | |
| raises an exception if a specified gemfile is not found | |
| does not find a Gemfile above the testing directory | |
| when called twice | |
| doesn't try to load the runtime twice | |
| not hurting brittle rubygems | |
| does not inject #source into the generated YAML of the gem specs (FAILED - 26) | |
| Bundler.setup with multi platform stuff | |
| raises a friendly error when gems are missing locally | |
| will resolve correctly on the current platform when the lockfile was targetted for a different one | |
| An exception occurred evaluating command line code | |
| Could not find platform_specific-1.0 in any of the sources (Bundler::GemNotFound) | |
| Backtrace: | |
| { } in Bundler::SpecSet#materialize at /Users/andre/sw/gems/bundler/lib | |
| /bundler/spec_set.rb:90 | |
| Array#map! at kernel/bootstrap/array.rb:87 | |
| Bundler::SpecSet#materialize at /Users/andre/sw/gems/bundler/lib | |
| /bundler/spec_set.rb:83 | |
| Bundler::Definition#specs at /Users/andre/sw/gems/bundler/lib | |
| /bundler/definition.rb:114 | |
| Bundler::Definition#specs_for at /Users/andre/sw/gems/bundler/lib | |
| /bundler/definition.rb:159 | |
| Bundler::Definition#requested_specs at /Users/andre/sw/gems/bundler/lib | |
| /bundler/definition.rb:148 | |
| Bundler::Environment(Bundler::Runtime)#requested_specs at /Users/andre/sw/gems | |
| /bundler/lib/bundler | |
| /environment.rb:18 | |
| Bundler::Runtime#setup at /Users/andre/sw/gems/bundler/lib | |
| /bundler/runtime.rb:11 | |
| Bundler.setup at /Users/andre/sw/gems/bundler/lib | |
| /bundler.rb:117 | |
| { } in Object#__script__ at -e:1 | |
| Rubinius::BlockEnvironment#call_on_instance at kernel/common | |
| /block_environment.rb:75 | |
| Kernel(Rubinius::Loader)#eval at kernel/common/eval.rb:75 | |
| Rubinius::Loader#evals at kernel/loader.rb:583 | |
| Rubinius::Loader#main at kernel/loader.rb:814 | |
| will add the resolve for the current platform (FAILED - 27) | |
| Bundler.require | |
| requires the gems | |
| allows requiring gems with non standard names explicitly | |
| raises an exception if a require is specified but the file does not exist | |
| with namespaced gems | |
| requires gem names that are namespaced | |
| silently passes if the require fails | |
| does not mangle explictly given requires | |
| handles the case where regex fails | |
| using bundle exec | |
| requires the locked gems | |
| order | |
| works when the gems are in the Gemfile in the correct order | |
| fails when the gems are in the Gemfile in the wrong order | |
| a gem with different requires for different envs | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| requires both with Bundler.require(both) | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| requires one with Bundler.require(:one) | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| requires :two with Bundler.require(:two) | |
| with busted gems | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| should be busted | |
| Bundler.require with platform specific dependencies | |
| does not require the gems that are pinned to other platforms | |
| requires gems pinned to multiple platforms, including the current one | |
| Bundler.setup | |
| raises if the Gemfile was not yet installed | |
| doesn't create a Gemfile.lock if the setup fails | |
| doesn't change the Gemfile.lock if the setup fails | |
| makes a Gemfile.lock if setup succeeds | |
| uses BUNDLE_GEMFILE to locate the gemfile if present | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| prioritizes gems in BUNDLE_PATH over gems in GEM_HOME | |
| has loaded_from as a string on all specs | |
| ignores empty gem paths | |
| should prepend gemspec require paths to $LOAD_PATH in order | |
| ignores Gem.refresh | |
| with no arguments | |
| makes all groups available | |
| when called with groups | |
| doesn't make all groups available | |
| leaves all groups available if they were already | |
| leaves :default available if setup is called twice | |
| integrate with rubygems | |
| by replacing #gem | |
| replaces #gem but raises when the gem is missing | |
| version_requirement is now deprecated in rubygems 1.4.0+ when gem is missing | |
| replaces #gem but raises when the version is wrong | |
| version_requirement is now deprecated in rubygems 1.4.0+ when the version is wrong | |
| by hiding system gems | |
| removes system gems from Gem.source_index | |
| when the ruby stdlib is a substring of Gem.path | |
| does not reject the stdlib from $LOAD_PATH (FAILED - 28) | |
| with paths | |
| activates the gems in the path source | |
| with git | |
| provides a useful exception when the git repo is not checked out yet | |
| does not hit the git binary if the lockfile is available and up to date | |
| provides a good exception if the lockfile is unavailable | |
| works even when the cache directory has been deleted | |
| does not randomly change the path when specifying --path and the bundle directory becomes read only | |
| when specifying local override | |
| explodes if given path does not exist on runtime | |
| explodes if branch is not given on runtime | |
| explodes on different branches on runtime | |
| explodes on refs with different branches on runtime | |
| when excluding groups | |
| doesn't change the resolve if --without is used | |
| remembers --without and does not bail on bare Bundler.setup | |
| remembers --without and does not include groups passed to Bundler.setup | |
| preactivated gems | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| raises an exception if a pre activated gem conflicts with the bundle | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| version_requirement is now deprecated in rubygems 1.4.0+ | |
| when a vendored gem specification uses the :path option | |
| should resolve paths relative to the Gemfile | |
| should make sure the Bundler.root is really included in the path relative to the Gemfile | |
| with git gems that don't have gemspecs | |
| loads the library via a virtual spec | |
| with bundled and system gems | |
| does not pull in system gems | |
| provides a gem method | |
| raises an exception if gem is used to invoke a system gem not in the bundle | |
| sets GEM_HOME appropriately | |
| with system gems in the bundle | |
| sets GEM_PATH appropriately | |
| with a gemspec that requires other files | |
| evals each gemspec in the context of its parent directory | |
| error intelligently if the gemspec has a LoadError | |
| evals each gemspec with a binding from the top level | |
| when Bundler is bundled | |
| doesn't blow up | |
| Bundler.with_env helpers | |
| Bundler.with_clean_env | |
| should keep the original GEM_PATH even in sub processes | |
| should not pass any bundler environment variables | |
| should not pass RUBYOPT changes | |
| should not change ORIGINAL_ENV | |
| it should behave like Bundler.with_*_env | |
| should reset and restore the environment | |
| Bundler.with_original_env | |
| should pass bundler environment variables set before Bundler was run | |
| it should behave like Bundler.with_*_env | |
| should reset and restore the environment | |
| Bundler.clean_system | |
| runs system inside with_clean_env | |
| Bundler.clean_exec | |
| runs exec inside with_clean_env | |
| bundle update | |
| with no arguments | |
| updates the entire bundle | |
| doesn't delete the Gemfile.lock file if something goes wrong | |
| --quiet argument | |
| shows UI messages without --quiet argument | |
| does not show UI messages with --quiet argument | |
| with a top level dependency | |
| unlocks all child dependencies that are unrelated to other locked dependencies | |
| with a unknown dependency | |
| should inform the user | |
| should suggest alternatives | |
| with --local option | |
| doesn't hit repo2 | |
| bundle update in more complicated situations | |
| will eagerly unlock dependencies of a specified gem | |
| bundle update without a Gemfile.lock | |
| should not explode | |
| bundle update when a gem depends on a newer version of bundler | |
| should not explode | |
| should explain that bundler conflicted | |
| bundle update | |
| git sources | |
| floats on a branch when :branch is used | |
| updates correctly when you have like craziness | |
| floats on a branch when :branch is used and the source is specified in the update | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| floats on master when updating all gems that are pinned to the source even if you have child dependencies | |
| notices when you change the repo url in the Gemfile | |
| fetches tags from the remote | |
| errors with a message when the .git repo is gone | |
| with submodules | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| it unlocks the source when submodules is added to a git source | |
| ERROR: While executing gem ... (Gem::DocumentError) | |
| ERROR: RDoc documentation generator not installed: no such file to load -- rdoc/rdoc | |
| it unlocks the source when submodules is removed from git source (PENDING: This would require actually removing the submodule from the clone) | |
| bundle update | |
| git sources | |
| updates the source | |
| unlocks gems that were originally pulled in by the source | |
| leaves all other gems frozen | |
| Pending: | |
| bundle update git sources with submodules it unlocks the source when submodules is removed from git source | |
| # This would require actually removing the submodule from the clone | |
| # ./spec/update/git_spec.rb:160 | |
| Failures: | |
| 1) Bundler::Definition#lock when it's not possible to write to the file raises an InstallError with explanation | |
| Failure/Error: expect{ subject.lock("Gemfile.lock") }. | |
| expected Bundler::InstallError, got #<Rubinius::CompileError: Error trying to compile /Users/andre/sw/gems/bundler/lib/bundler/spec_set.rb> with backtrace: | |
| # /Users/andre/.rvm/rubies/rbx-head/runtime/18/compiler/compiler.rbc:13:in `compiler_error' | |
| # /Users/andre/.rvm/rubies/rbx-head/runtime/18/compiler/compiler.rbc:92:in `compile' | |
| # kernel/delta/codeloader.rb:181:in `compile_file' | |
| # kernel/delta/codeloader.rb:155:in `load_file' | |
| # kernel/common/codeloader.rb:129:in `require' | |
| # kernel/common/codeloader.rb:206:in `require' | |
| # kernel/common/autoload.rb:46:in `resolve' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 2) bundle cache when previously cached doesn't remove gems that are for another platform | |
| Failure/Error: expect(cached_gem("platform_specific-1.0-java")).to exist | |
| expected #<Pathname:/Users/andre/sw/gems/bundler/tmp/bundled_app/vendor/cache/platform_specific-1.0-java.gem> to exist | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 3) gemcutter's dependency API falls back when the API errors out | |
| Failure/Error: should_be_installed "rcov 1.0.0" | |
| expected: #<Gem::Version "1.0.0"> | |
| got: #<Gem::Version ""> | |
| (compared using ==) | |
| Diff: | |
| @@ -1,2 +1,2 @@ | |
| -Gem::Version.new("1.0.0") | |
| +Gem::Version.new("") | |
| # kernel/bootstrap/array.rb:68:in `each' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 4) bundle install with gem sources when cached and locked ignores cached gems for the wrong platform | |
| Failure/Error: expect(out).to eq("1.0.0 RUBY") | |
| expected: "1.0.0 RUBY" | |
| got: "1.0.0 x86_64-darwin-12" | |
| (compared using ==) | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 5) bundle install across platforms pulls in the correct platform specific gem | |
| Failure/Error: should_be_installed "platform_specific 1.0 JAVA" | |
| expected: #<Gem::Version "1.0"> | |
| got: #<Gem::Version ""> | |
| (compared using ==) | |
| Diff: | |
| @@ -1,2 +1,2 @@ | |
| -Gem::Version.new("1.0") | |
| +Gem::Version.new("") | |
| # kernel/bootstrap/array.rb:68:in `each' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 6) bundle install across platforms works with gems that have different dependencies | |
| Failure/Error: should_be_installed "nokogiri 1.4.2 JAVA", "weakling 0.0.3" | |
| expected: #<Gem::Version "1.4.2"> | |
| got: #<Gem::Version ""> | |
| (compared using ==) | |
| Diff: | |
| @@ -1,2 +1,2 @@ | |
| -Gem::Version.new("1.4.2") | |
| +Gem::Version.new("") | |
| # kernel/bootstrap/array.rb:68:in `each' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 7) bundle install across platforms works the other way with gems that have different dependencies | |
| Failure/Error: should_be_installed "nokogiri 1.4.2 JAVA", "weakling 0.0.3" | |
| expected: #<Gem::Version "1.4.2"> | |
| got: #<Gem::Version ""> | |
| (compared using ==) | |
| Diff: | |
| @@ -1,2 +1,2 @@ | |
| -Gem::Version.new("1.4.2") | |
| +Gem::Version.new("") | |
| # kernel/bootstrap/array.rb:68:in `each' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 8) when a gem has an architecture in its platform still installs correctly | |
| Failure/Error: should_be_installed "rcov 1.0.0" | |
| expected: #<Gem::Version "1.0.0"> | |
| got: #<Gem::Version ""> | |
| (compared using ==) | |
| Diff: | |
| @@ -1,2 +1,2 @@ | |
| -Gem::Version.new("1.0.0") | |
| +Gem::Version.new("") | |
| # kernel/bootstrap/array.rb:68:in `each' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 9) bundle install with gem sources the simple case with a gem that installs multiple platforms falls back on plain ruby | |
| Failure/Error: expect(out).to eq("1.0.0 RUBY") | |
| expected: "1.0.0 RUBY" | |
| got: "1.0.0 x86_64-darwin-12" | |
| (compared using ==) | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 10) bundle install with gem sources the simple case with a gem that installs multiple platforms installs gems for java | |
| Failure/Error: expect(out).to eq("1.0.0 JAVA") | |
| expected: "1.0.0 JAVA" | |
| got: "" | |
| (compared using ==) | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 11) bundle install with gem sources the simple case with a gem that installs multiple platforms installs gems for windows | |
| Failure/Error: expect(out).to eq("1.0.0 MSWIN") | |
| expected: "1.0.0 MSWIN" | |
| got: "" | |
| (compared using ==) | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 12) the lockfile format persists the spec's platform to the lockfile | |
| Failure/Error: lockfile_should_be <<-G | |
| expected: "GEM\n remote: file:/Users/andre/sw/gems/bundler/tmp/gems/remote1/\n specs:\n platform_specific (1.0-java)\n\nPLATFORMS\n java\n\nDEPENDENCIES\n platform_specific\n" | |
| got: "GEM\n remote: file:/Users/andre/sw/gems/bundler/tmp/gems/remote1/\n specs:\n platform_specific (1.0)\n\nPLATFORMS\n ruby\n\nDEPENDENCIES\n platform_specific\n" | |
| (compared using ==) | |
| Diff: | |
| @@ -1,10 +1,10 @@ | |
| GEM | |
| remote: file:/Users/andre/sw/gems/bundler/tmp/gems/remote1/ | |
| specs: | |
| - platform_specific (1.0-java) | |
| + platform_specific (1.0) | |
| PLATFORMS | |
| - java | |
| + ruby | |
| DEPENDENCIES | |
| platform_specific | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 13) bundle platform without flags returns all the output | |
| Failure/Error: expect(out).to eq(<<-G.chomp) | |
| expected: "Your platform is: x86_64-apple-darwin12.2.0\n\nYour app has gems that work on these platforms:\n* ruby\n\nYour Gemfile specifies a Ruby version requirement:\n* ruby 1.8.7\n\nYour current platform satisfies the Ruby version requirement." | |
| got: "Your platform is: x86_64-apple-darwin12.2.0\n\nYour app has gems that work on these platforms:\n* ruby\n\nYour Gemfile specifies a Ruby version requirement:\n* ruby 1.8.7 (rbx 2.0.0dev)\n\nYour current platform satisfies the Ruby version requirement." | |
| (compared using ==) | |
| Diff: | |
| @@ -4,7 +4,7 @@ | |
| * ruby | |
| Your Gemfile specifies a Ruby version requirement: | |
| -* ruby 1.8.7 | |
| +* ruby 1.8.7 (rbx 2.0.0dev) | |
| Your current platform satisfies the Ruby version requirement. | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 14) bundle platform without flags doesn't match the ruby version requirement | |
| Failure/Error: expect(out).to eq(<<-G.chomp) | |
| expected: "Your platform is: x86_64-apple-darwin12.2.0\n\nYour app has gems that work on these platforms:\n* ruby\n\nYour Gemfile specifies a Ruby version requirement:\n* ruby 1.12\n\nYour Ruby version is 1.8.7, but your Gemfile specified 1.12" | |
| got: "Your platform is: x86_64-apple-darwin12.2.0\n\nYour app has gems that work on these platforms:\n* ruby\n\nYour Gemfile specifies a Ruby version requirement:\n* ruby 1.12 (rbx 1.12)\n\nYour Ruby version is 1.8.7, but your Gemfile specified 1.12" | |
| (compared using ==) | |
| Diff: | |
| @@ -4,7 +4,7 @@ | |
| * ruby | |
| Your Gemfile specifies a Ruby version requirement: | |
| -* ruby 1.12 | |
| +* ruby 1.12 (rbx 1.12) | |
| Your Ruby version is 1.8.7, but your Gemfile specified 1.12 | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 15) bundle platform bundle check fails when engine version doesn't match | |
| Failure/Error: expect(exitstatus).to eq(18) if opts[:exitstatus] | |
| expected: 18 | |
| got: 4 | |
| (compared using ==) | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 16) Resolving resolves a single gem | |
| Failure/Error: should_resolve_as %w(rack-1.1) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 17) Resolving resolves a gem with dependencies | |
| Failure/Error: should_resolve_as %w(actionpack-2.3.5 activesupport-2.3.5 rack-1.0) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 18) Resolving platform craziness with cross-platform gems resolves a simple multi platform gem | |
| Failure/Error: should_resolve_as %w(nokogiri-1.4.2 nokogiri-1.4.2-java weakling-0.0.3) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 19) Resolving platform craziness with cross-platform gems doesn't pull gems that don't exist for the current platform | |
| Failure/Error: should_resolve_as %w(nokogiri-1.4.2) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 20) Resolving platform craziness with cross-platform gems doesn't pull gems when the version is available for all requested platforms | |
| Failure/Error: should_resolve_as %w(nokogiri-1.4.2.1-x86-mswin32) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 21) Resolving platform craziness with mingw32 finds mswin gems | |
| Failure/Error: should_resolve_as %w(thin-1.2.7-x86-mswin32) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 22) Resolving platform craziness with mingw32 finds mingw gems | |
| Failure/Error: should_resolve_as %w(thin-1.2.7-x86-mingw32) | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 23) Resolving platform craziness with conflicting cases reports on the conflict | |
| Failure/Error: should_conflict_on "baz" | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Resolver::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 24) Bundler.load with a gemfile provides a list of the env dependencies | |
| Failure/Error: expect(Bundler.load.dependencies).to have_dep("rack", ">= 0") | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Definition::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 25) Bundler.load with a gemfile provides a list of the resolved gems | |
| Failure/Error: expect(Bundler.load.gems).to have_gem("rack-1.0.0", "bundler-#{Bundler::VERSION}") | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Definition::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 26) Bundler.load not hurting brittle rubygems does not inject #source into the generated YAML of the gem specs | |
| Failure/Error: Bundler.load.specs.each do |spec| | |
| NameError: | |
| Missing or uninitialized constant: Bundler::Definition::SpecSet | |
| # kernel/common/module.rb:472:in `rake_original_const_missing (const_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 27) Bundler.setup with multi platform stuff will add the resolve for the current platform | |
| Failure/Error: should_be_installed "nokogiri 1.4.2", "platform_specific 1.0 x86-darwin-100" | |
| expected: #<Gem::Version "1.4.2"> | |
| got: #<Gem::Version ""> | |
| (compared using ==) | |
| Diff: | |
| @@ -1,2 +1,2 @@ | |
| -Gem::Version.new("1.4.2") | |
| +Gem::Version.new("") | |
| # kernel/bootstrap/array.rb:68:in `each' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| 28) Bundler.setup integrate with rubygems by hiding system gems when the ruby stdlib is a substring of Gem.path does not reject the stdlib from $LOAD_PATH | |
| Failure/Error: substring = "/" + $LOAD_PATH.find{|p| p =~ /vendor_ruby/ }.split("/")[2] | |
| NoMethodError: | |
| private method `split' called on nil:NilClass. | |
| # kernel/delta/kernel.rb:81:in `split (method_missing)' | |
| # kernel/common/eval18.rb:45:in `instance_eval' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/bootstrap/array18.rb:18:in `map' | |
| # kernel/loader.rb:696:in `run_at_exits' | |
| # kernel/loader.rb:716:in `epilogue' | |
| # kernel/loader.rb:849:in `main' | |
| Finished in 44 minutes 55.07 seconds | |
| 727 examples, 28 failures, 1 pending | |
| Failed examples: | |
| rspec ./spec/bundler/definition_spec.rb:18 # Bundler::Definition#lock when it's not possible to write to the file raises an InstallError with explanation | |
| rspec ./spec/cache/gems_spec.rb:170 # bundle cache when previously cached doesn't remove gems that are for another platform | |
| rspec ./spec/install/gems/dependency_api_spec.rb:102 # gemcutter's dependency API falls back when the API errors out | |
| rspec ./spec/install/gems/packed_spec.rb:51 # bundle install with gem sources when cached and locked ignores cached gems for the wrong platform | |
| rspec ./spec/install/gems/platform_spec.rb:27 # bundle install across platforms pulls in the correct platform specific gem | |
| rspec ./spec/install/gems/platform_spec.rb:53 # bundle install across platforms works with gems that have different dependencies | |
| rspec ./spec/install/gems/platform_spec.rb:76 # bundle install across platforms works the other way with gems that have different dependencies | |
| rspec ./spec/install/gems/platform_spec.rb:195 # when a gem has an architecture in its platform still installs correctly | |
| rspec ./spec/install/gems/simple_case_spec.rb:210 # bundle install with gem sources the simple case with a gem that installs multiple platforms falls back on plain ruby | |
| rspec ./spec/install/gems/simple_case_spec.rb:221 # bundle install with gem sources the simple case with a gem that installs multiple platforms installs gems for java | |
| rspec ./spec/install/gems/simple_case_spec.rb:232 # bundle install with gem sources the simple case with a gem that installs multiple platforms installs gems for windows | |
| rspec ./spec/lock/lockfile_spec.rb:512 # the lockfile format persists the spec's platform to the lockfile | |
| rspec ./spec/other/platform_spec.rb:5 # bundle platform without flags returns all the output | |
| rspec ./spec/other/platform_spec.rb:46 # bundle platform without flags doesn't match the ruby version requirement | |
| rspec ./spec/other/platform_spec.rb:334 # bundle platform bundle check fails when engine version doesn't match | |
| rspec ./spec/resolver/basic_spec.rb:9 # Resolving resolves a single gem | |
| rspec ./spec/resolver/basic_spec.rb:15 # Resolving resolves a gem with dependencies | |
| rspec ./spec/resolver/platform_spec.rb:9 # Resolving platform craziness with cross-platform gems resolves a simple multi platform gem | |
| rspec ./spec/resolver/platform_spec.rb:16 # Resolving platform craziness with cross-platform gems doesn't pull gems that don't exist for the current platform | |
| rspec ./spec/resolver/platform_spec.rb:23 # Resolving platform craziness with cross-platform gems doesn't pull gems when the version is available for all requested platforms | |
| rspec ./spec/resolver/platform_spec.rb:41 # Resolving platform craziness with mingw32 finds mswin gems | |
| rspec ./spec/resolver/platform_spec.rb:48 # Resolving platform craziness with mingw32 finds mingw gems | |
| rspec ./spec/resolver/platform_spec.rb:75 # Resolving platform craziness with conflicting cases reports on the conflict | |
| rspec ./spec/runtime/load_spec.rb:23 # Bundler.load with a gemfile provides a list of the env dependencies | |
| rspec ./spec/runtime/load_spec.rb:27 # Bundler.load with a gemfile provides a list of the resolved gems | |
| rspec ./spec/runtime/load_spec.rb:94 # Bundler.load not hurting brittle rubygems does not inject #source into the generated YAML of the gem specs | |
| rspec ./spec/runtime/platform_spec.rb:62 # Bundler.setup with multi platform stuff will add the resolve for the current platform | |
| rspec ./spec/runtime/setup_spec.rb:265 # Bundler.setup integrate with rubygems by hiding system gems when the ruby stdlib is a substring of Gem.path does not reject the stdlib from $LOAD_PATH | |
| rake aborted! | |
| /Users/andre/.rvm/rubies/rbx-head/bin/rbx -w -S rspec ./spec/bundler/bundler_spec.rb ./spec/bundler/definition_spec.rb ./spec/bundler/dsl_spec.rb ./spec/bundler/gem_helper_spec.rb ./spec/bundler/psyched_yaml_spec.rb ./spec/bundler/source_spec.rb ./spec/cache/gems_spec.rb ./spec/cache/git_spec.rb ./spec/cache/path_spec.rb ./spec/cache/platform_spec.rb ./spec/install/deploy_spec.rb ./spec/install/gems/c_ext_spec.rb ./spec/install/gems/dependency_api_spec.rb ./spec/install/gems/env_spec.rb ./spec/install/gems/flex_spec.rb ./spec/install/gems/groups_spec.rb ./spec/install/gems/packed_spec.rb ./spec/install/gems/platform_spec.rb ./spec/install/gems/post_install_spec.rb ./spec/install/gems/resolving_spec.rb ./spec/install/gems/simple_case_spec.rb ./spec/install/gems/standalone_spec.rb ./spec/install/gems/sudo_spec.rb ./spec/install/gems/win32_spec.rb ./spec/install/gemspec_spec.rb ./spec/install/git_spec.rb ./spec/install/invalid_spec.rb ./spec/install/path_spec.rb ./spec/install/upgrade_spec.rb ./spec/lock/git_spec.rb ./spec/lock/lockfile_spec.rb ./spec/other/check_spec.rb ./spec/other/clean_spec.rb ./spec/other/config_spec.rb ./spec/other/console_spec.rb ./spec/other/exec_spec.rb ./spec/other/ext_spec.rb ./spec/other/help_spec.rb ./spec/other/init_spec.rb ./spec/other/newgem_spec.rb ./spec/other/open_spec.rb ./spec/other/outdated_spec.rb ./spec/other/platform_spec.rb ./spec/other/show_spec.rb ./spec/quality_spec.rb ./spec/realworld/dependency_api_spec.rb ./spec/realworld/edgecases_spec.rb ./spec/resolver/basic_spec.rb ./spec/resolver/platform_spec.rb ./spec/runtime/executable_spec.rb ./spec/runtime/load_spec.rb ./spec/runtime/platform_spec.rb ./spec/runtime/require_spec.rb ./spec/runtime/setup_spec.rb ./spec/runtime/with_clean_env_spec.rb ./spec/update/gems_spec.rb ./spec/update/git_spec.rb ./spec/update/source_spec.rb -fs --color failed | |
| Tasks: TOP => spec | |
| (See full trace by running task with --trace) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment