britt-geminstaller 0.5.2 → 0.5.2.1

data/lib/geminstaller/ruby_gem.rb

@@ -0,0 +1,58 @@
+module GemInstaller
+  class RubyGem
+    include Comparable
+    attr_accessor :name, :version, :platform, :install_options, :check_for_upgrade, :fix_dependencies, :no_autogem, :prefer_binary_platform, :uninstall_options
+
+    def initialize(name, opts={})
+      @name = name
+      #TODO: the following logic could probably be more concise, but I'm not sure right now
+      @version = GemInstaller::RubyGem.default_version
+      if opts[:version] != "" && opts[:version] != nil 
+        @version = opts[:version] 
+      end
+      if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.5')
+        @platform = 'ruby'
+      end
+      if opts[:platform] != "" && opts[:platform] != nil 
+        @platform = opts[:platform]
+      end
+      @install_options = opts[:install_options] ||= []
+      @uninstall_options = opts[:uninstall_options] ||= []
+      @check_for_upgrade = opts[:check_for_upgrade] == true ? true : false
+      @fix_dependencies = opts[:fix_dependencies] == true ? true : false
+      @no_autogem = opts[:no_autogem] == true ? true : false
+      if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+        warn("The 'prefer_binary_platform' option is deprecated on RubyGems >= 0.9.5, and has no effect") unless opts[:prefer_binary_platorm].nil?
+      else
+        @prefer_binary_platform = opts[:prefer_binary_platorm] == false ? false : true
+      end
+    end
+
+    def self.default_version
+      '> 0.0.0'
+    end
+    
+    def self.default_platform
+      if GemInstaller::RubyGemsVersionChecker.matches?('>0.9.5')
+        Gem::Platform::CURRENT
+      else
+        # Not sure if this is actually required for RubyGems <=0.9.5, but it 
+        # was the original value in GemInstaller <=0.3.0, and makes the tests pass
+        'ruby'
+      end
+    end
+
+    def <=>(other)
+      compare = @name <=> other.name
+      return compare if compare != 0
+      compare = @version <=> other.version # TODO: this should use rubygems version comparison, not string comparison
+      return compare if compare != 0
+      return 0 if (@platform == nil && other.platform == nil)
+      return @platform <=> other.platform
+    end
+    
+    def regexp_escaped_name
+      Regexp.escape(@name)
+    end
+  end
+end

data/lib/geminstaller/rubygems_exit.rb

@@ -0,0 +1,5 @@
+module GemInstaller
+  class RubyGemsExit < RuntimeError
+    # This is an exception which helps override the normal (no error) system 'exit' call in RubyGems' terminate_interaction 
+  end
+end

data/lib/geminstaller/rubygems_extensions.rb

@@ -0,0 +1,9 @@
+module Gem
+  class GemRunner
+    public :do_configuration
+  end
+  class CommandManager
+    attr_reader :commands
+  end
+end
+

data/lib/geminstaller/rubygems_version_checker.rb

@@ -0,0 +1,15 @@
+require 'rubygems/rubygems_version'
+
+module GemInstaller
+  class RubyGemsVersionChecker
+    def self.matches?(version_spec, options = {})
+      version_spec = [version_spec] unless version_spec.kind_of?(Array)
+      # TODO: if rubygems has already been initialized before GemInstaller overrides the rubygems version,
+      # (for example, by running rspec), then Gem::RubyGemsVersion could be initialized to the incorrect
+      # system-rubygems version instead of the geminstaller-overridden version.  Need to figure out how
+      # to re-parse 'rubygems/rubygems_version' and let it redefine 'Gem::RubyGemsVersion'
+      rubygems_version = options[:rubygems_version] ||= Gem::RubyGemsVersion
+      Gem::Version::Requirement.new(version_spec).satisfied_by?(Gem::Version.new(rubygems_version))
+    end
+  end
+end

data/lib/geminstaller/rubygems_version_warnings.rb

@@ -0,0 +1,38 @@
+module GemInstaller
+  class RubyGemsVersionWarnings
+    def self.outdated_warning(options = {})
+      return nil if allow_unsupported?
+      return nil if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5', options)
+      return "\n\n----------------------------------------------------------------\n" + 
+                  "WARNING: You are using RubyGems version #{Gem::RubyGemsVersion}.\n" +
+                  "You should update to RubyGems version 1.0.1 or above,\n" +
+                  "because gems created for newer RubyGems versions\n" +
+                  "might be incompatible.\n" +
+                  "To update rubygems (recommended), use 'gem update --system'.\n" +
+                  "----------------------------------------------------------------\n\n"
+    end
+
+    def self.incompatible_warning(options = {})
+      return nil if allow_unsupported?
+      return nil unless (
+        GemInstaller::RubyGemsVersionChecker.matches?('=0.9.5', options) or
+        GemInstaller::RubyGemsVersionChecker.matches?('=1.1.0', options)
+      )
+      return "\n\n----------------------------------------------------------------\n" + 
+                  "WARNING: You are using RubyGems version #{Gem::RubyGemsVersion}.\n" +
+                  "This version is known to have bugs and/or compatibility issues\n" +
+                  "with GemInstaller.  Update RubyGems, or continue at your risk.\n" +
+                  "To update rubygems (recommended), use 'gem update --system'.\n" +
+                  "----------------------------------------------------------------\n\n"
+    end
+
+    def self.allow_unsupported?
+      defined? ALLOW_UNSUPPORTED_RUBYGEMS_VERSION
+    end
+    
+    def self.print_warnings(options = {})
+      warnings = [self.outdated_warning, self.incompatible_warning].compact!
+      warnings.each {|warning| print warning}
+    end
+  end
+end

data/lib/geminstaller/source_index_search_adapter.rb

@@ -0,0 +1,41 @@
+module GemInstaller
+  class SourceIndexSearchAdapter
+    attr_writer :gem_source_index_proxy
+    
+    def all_local_specs
+      if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+        search_less_than_or_equal_0_9_4('',GemInstaller::RubyGem.default_version)
+      else
+        dependency = Gem::Dependency.new('', GemInstaller::RubyGem.default_version)
+        @gem_source_index_proxy.refresh!
+        @gem_source_index_proxy.search(dependency, false)
+      end
+    end
+
+    def search(gem, version_requirement, platform_only = false)
+      if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+        gem_pattern = /^#{gem.regexp_escaped_name}$/
+        search_less_than_or_equal_0_9_4(gem_pattern, version_requirement)
+      else
+        search_greater_than_0_9_4(gem, version_requirement, platform_only)
+      end
+    end
+    
+    def search_less_than_or_equal_0_9_4(gem_pattern, version_requirement)
+      @gem_source_index_proxy.refresh!
+      @gem_source_index_proxy.search(gem_pattern, version_requirement)
+    end
+    
+    def search_greater_than_0_9_4(gem, version_requirement, platform_only = false)
+      dependency = Gem::Dependency.new(gem.name, version_requirement)
+      @gem_source_index_proxy.refresh!
+      @gem_source_index_proxy.search(dependency, platform_only)
+    end
+
+  end
+end
+
+
+
+
+

data/lib/geminstaller/unauthorized_dependency_prompt_error.rb

@@ -0,0 +1,4 @@
+module GemInstaller
+  class UnauthorizedDependencyPromptError < GemInstaller::GemInstallerError
+  end
+end

data/lib/geminstaller/unexpected_prompt_error.rb

@@ -0,0 +1,4 @@
+module GemInstaller
+  class UnexpectedPromptError < GemInstaller::GemInstallerError
+  end
+end

data/lib/geminstaller/valid_platform_selector.rb

@@ -0,0 +1,49 @@
+module GemInstaller
+  class ValidPlatformSelector
+    attr_writer :options, :ruby_platform, :output_filter
+    
+    def select(gem_platform = nil, exact_platform_match = false)
+      if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+        # valid_platform_selector is not used for RubyGems >= 0.9.5
+        raise RuntimeError.new("Internal GemInstaller Error: ValidPlatformSelector should not be used for RubyGems >= 0.9.5")
+      end
+
+      @ruby_platform ||= RUBY_PLATFORM
+      return [@ruby_platform] if gem_platform == Gem::Platform::CURRENT
+      return [gem_platform] if exact_platform_match
+      valid_platforms = []
+      valid_platforms += binary_platform_substring if binary_platform_substring
+      if @options[:prefer_binary_platform] == false
+        # put ruby first if prefer_binary_platform is false
+        valid_platforms.unshift('ruby')
+      else
+        # leave binary platform first if prefer_binary_platform is false or nil
+        valid_platforms << 'ruby'
+      end
+      if gem_platform and 
+        !valid_platforms.include?(gem_platform)
+        # only prepend the gem_platform as the first choice if
+        # 1. it is not nil
+        # 2. it is not already in the list
+        # 3. it is not 'ruby'
+        valid_platforms.unshift(gem_platform)
+      end
+      message = "Selecting valid platform(s): @ruby_platform='#{@ruby_platform}', gem_platform='#{gem_platform}', valid_platforms='#{valid_platforms.inspect}'"
+      @output_filter.geminstaller_output(:debug,"#{message}\n")
+      valid_platforms
+    end
+    
+    def binary_platform_substring
+      return ['686-darwin'] if @ruby_platform =~ /686-darwin/
+      return ['cygwin'] if @ruby_platform =~ /cygwin/
+      return ['powerpc'] if @ruby_platform =~ /powerpc/
+      return ['i386-mswin32','mswin32'] if @ruby_platform =~ /mswin/
+      return ['386-linux'] if @ruby_platform =~ /386-linux/
+      return ['486-linux'] if @ruby_platform =~ /486-linux/
+      return ['586-linux'] if @ruby_platform =~ /586-linux/
+      return ['686-linux'] if @ruby_platform =~ /686-linux/
+      return ['solaris'] if @ruby_platform =~ /solaris/
+      return nil
+    end
+  end
+end

data/lib/geminstaller/version_specifier.rb

@@ -0,0 +1,24 @@
+module GemInstaller
+  class VersionSpecifier
+    # NOTE: available_versions should be sorted in descending order (highest versions first)
+    # This method will return the first matching version
+    def specify(version_requirement, available_versions, gem_name = nil)
+      rubygems_version_requirement = Gem::Version::Requirement.new [version_requirement]
+      if available_versions.respond_to? :to_str
+        available_versions = available_versions.split(', ')
+      end
+      available_versions.each do |available_version_string|
+        available_version = Gem::Version.new(available_version_string)
+        if rubygems_version_requirement.satisfied_by?(available_version)
+          return available_version.to_s
+        end
+      end
+      gem_name_msg = ''
+      if gem_name
+        gem_name_msg = "for gem '#{gem_name}' "
+      end
+      error_msg = "The specified version requirement '#{version_requirement}' #{gem_name_msg}is not met by any of the available versions: #{available_versions.join(', ')}."
+      raise GemInstaller::GemInstallerError.new(error_msg)
+    end
+  end
+end

data/lib/geminstaller/yaml_loader.rb

@@ -0,0 +1,22 @@
+module GemInstaller
+  class YamlLoader
+    def load(yaml_text)
+      yaml = nil
+      begin
+        yaml = YAML.load(yaml_text)
+      rescue Exception => e
+        message = e.message
+        error = <<-STRING_END
+Error: Received error while attempting to parse YAML from yaml text:
+  #{message}
+Please ensure this is valid YAML:
+
+#{yaml_text}\n\n"
+STRING_END
+
+        raise GemInstaller::GemInstallerError.new(error)
+      end
+      return yaml
+    end
+  end
+end

data/lib/geminstaller_rails_preinitializer.rb

@@ -0,0 +1,46 @@
+############# GemInstaller Rails Preinitializer - see http://geminstaller.rubyforge.org
+
+# This file should be required in your Rails config/preinitializer.rb for Rails >= 2.0,
+# or required in config/boot.rb before initialization for Rails < 2.0.  For example:
+#   require 'geminstaller_rails_preinitializer'
+#
+# If you require different geminstaller command options, copy this file into your Rails app,
+# modify it, and require your customized version.  For example:
+#   require "#{File.expand_path(RAILS_ROOT)}/config/custom_geminstaller_rails_preinitializer.rb"
+
+require "rubygems" 
+require "geminstaller" 
+
+module GemInstallerRailsPreinitializer
+  class << self
+    def preinitialize
+      args = ''
+
+      # Specify --geminstaller-output=all and --rubygems-output=all for maximum debug logging
+      # args += ' --geminstaller-output=all --rubygems-output=all'
+
+      # The 'exceptions' flag determines whether errors encountered while running GemInstaller
+      # should raise exceptions (and abort Rails), or just return a nonzero return code
+      args += " --exceptions" 
+
+      # This will use sudo by default on all non-windows platforms, but requires an entry in your
+      # sudoers file to avoid having to type a password.  It can be omitted if you don't want to use sudo.
+      # See http://geminstaller.rubyforge.org/documentation/documentation.html#dealing_with_sudo
+      # Note that environment variables will NOT be passed via sudo!
+      #args += " --sudo" unless RUBY_PLATFORM =~ /mswin/
+
+      # The 'install' method will auto-install gems as specified by the args and config
+      # IMPORTANT NOTE:  Under recent RubyGems versions, this will install to ~/.gem
+      GemInstaller.install(args)
+
+      # The 'autogem' method will automatically add all gems in the GemInstaller config to your load path,
+      # using the rubygems 'gem' method.  Note that only the *first* version of any given gem will be loaded.
+      GemInstaller.autogem(args)
+    end
+  end
+end
+
+# Attempt to prevent GemInstaller from running twice, but won't work if it is executed
+# in a separate interpreter (like rake tests)
+GemInstallerRailsPreinitializer.preinitialize unless $geminstaller_initialized
+$geminstaller_initialized = true

data/start_local_gem_server.sh

@@ -0,0 +1 @@
+gem server --dir=./spec/fixture/gems --port=9909

data/test/test_all.rb

@@ -0,0 +1,36 @@
+print "\nRunning all GemInstaller Tests, ENV['RUBYGEMS_VERSION'] == '#{ENV['RUBYGEMS_VERSION']}'\n\n"
+
+dir = File.dirname(__FILE__)
+specdir = File.expand_path("#{dir}/../spec")
+require File.expand_path("#{specdir}/helper/spec_helper")
+
+spec_files = Dir.glob("#{specdir}/**/*_spec.rb")
+
+# put test_gem_home_spec first so we only have to perform the install once
+test_gem_home_path = Dir.glob("#{specdir}/functional/test_gem_home_spec.rb")[0]
+spec_files.delete(test_gem_home_path)
+spec_files.unshift(test_gem_home_path)
+spec_files.uniq
+
+args = spec_files
+args << "--color"
+args << "--format"
+args << "specdoc"
+args << "--diff"
+args << "unified"
+
+# append generated args to ARGV.  THis may break if incompatible args are specified, 
+# but I don't know a better way to invoke Rspec 1.1.1 programatically and check the return value
+ARGV.concat(args)
+
+success = false
+begin
+  require 'spec'
+  success = ::Spec::Runner::CommandLine.run
+ensure
+  GemInstaller::TestGemHome.reset
+end
+# not sure what Spec::Runner::CommandLine.run can return, but fail if it's not boolean as expected
+raise "unexpected non-boolean return value from Spec::Runner::CommandLine.run(rspec_options)" unless success == true || success == false
+
+raise "Specs failed" unless success

data/test/test_all_smoketests.rb

@@ -0,0 +1,21 @@
+print "\nRunning all GemInstaller SmokeTests, ENV['RUBYGEMS_VERSION'] == '#{ENV['RUBYGEMS_VERSION']}'\n\n"
+
+dir = File.dirname(__FILE__)
+smoketest_dir = File.expand_path("#{dir}/../spec/smoketest")
+
+test_files = Dir.glob("#{smoketest_dir}/**/*_smoketest.rb")
+
+test_files.each do |test_file|
+  raise "#{test_file} failed" unless system("ruby #{test_file}")
+end
+# 
+# class SmokeTestSuite
+#   def self.suite
+#     suite = Test::Unit::TestSuite.new
+#     suite << GemInstaller::AutoGemSmokeTest.suite
+# #    suite << GemInstaller::InstallSmokeTest.suite
+# #    suite << GemInstaller::RailsSmokeTest.suite
+#     return suite
+#   end
+# end
+# Test::Unit::UI::Console::TestRunner.run(SmokeTestSuite)

data/website/config.yaml

@@ -0,0 +1,11 @@
+# Configuration file for webgen
+# Used to set the parameters of the plugins
+default_meta_info:
+  Page:
+    blocks:
+      default: {pipeline: tags,redcloth,blocks}
+  Template:
+    blocks:
+      default: {pipeline: tags,redcloth,blocks}
+tag.menu.show_current_subtree_only: true
+tag.menu.nested: false

data/website/src/analytics.page

@@ -0,0 +1,6 @@
+<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
+</script>
+<script type="text/javascript">
+_uacct = "UA-2845076-1";
+urchinTracker();
+</script>

data/website/src/code/ci.virtual

@@ -0,0 +1,5 @@
+ci.html:
+  title: CI
+  url: http://ci.thewoolleyweb.com
+  in_menu: true
+  sort_info: 20

data/website/src/code/coverage/index.virtual

@@ -0,0 +1,5 @@
+index.html:
+  title: Coverage
+  url: index.html
+  in_menu: true
+  sort_info: 40

data/website/src/code/index.page

@@ -0,0 +1,88 @@
+---
+title: Design
+---
+h1. Design Notes
+
+These are some notes on the underlying design of GemInstaller, and the current state of development:
+
+* GemInstaller was developed from nothing but a concept, using "Behavior-Driven Development":http://behaviour-driven.org and "Rspec":http://rspec.rubyforge.org/.
+* GemInstaller uses "Dependency Injection", an architecture which has many benefits, including testability and enabling "loose coupling and high cohesion":http://www.c2.com/cgi/wiki?CouplingAndCohesion.  I originally started with "Needle":http://rubyforge.org/projects/needle/, a Ruby Dependency Injection framework, but switched to a simple home-grown approach in order to not have a dependency on the Needle gem.  Read more about Dependency Injection here:
+** "http://onestepback.org/index.cgi/Tech/Ruby/DependencyInjectionInRuby.rdoc":http://onestepback.org/index.cgi/Tech/Ruby/DependencyInjectionInRuby.rdoc
+** "http://onestepback.org/articles/depinj/":http://onestepback.org/articles/depinj/
+** "http://martinfowler.com/bliki/InversionOfControl.html":http://martinfowler.com/bliki/InversionOfControl.html 
+** "http://martinfowler.com/articles/injection.html":http://martinfowler.com/articles/injection.html
+** "http://www.theserverside.com/tt/articles/article.tss?l=IOCBeginners":http://www.theserverside.com/tt/articles/article.tss?l=IOCBeginners
+** "http://www.ibm.com/developerworks/edu/j-dw-java-springswing-i.html":http://www.ibm.com/developerworks/edu/j-dw-java-springswing-i.html
+* A lot of effort has gone into supporting isolated functional testing.  Every run of a functional spec or the spec suite creates a new "Test Gem Home" sandbox installation of RubyGems.  This creates a new GEM_HOME on the fly for each run.  This allows me to test actual gem installation without being connected to a network, and avoid mucking with (or having false failures due to) my actual local RubyGems gem repository.  Unfortunately, the Ruby load path still uses the executables from the system installation of RubyGems.  I plan on fixing that too (which will allow me to test multiple RubyGems versions), but that seems to be a much trickier task than just having a different GEM_HOME.
+* Spec/Test Philosophy:
+** GemInstaller's specs are grouped into distinct categories.  This and other testing approaches I use are heavily influenced by this fine article at GroboUtils: "Naming Your Junit Tests":http://groboutils.sourceforge.net/testing-junit/art_naming.html 
+** Unit vs. Functional: Many classes have two identically-named spec files associated with them, under unit and functional.  
+*** Unit Specs:  The Unit specs for the most part test only a single class in isolation, usually using mock objects, so they run very fast.  Many of them are vestiges of my initial BDD approach when I started from nothing.  I incur a little bit of overhead cost to maintain them as the app evolves, but I don't mind that as much as some people :).  They also come in very handy when I want to BDD some new behavior and don't want to have the high "Test Gem Home" fixture creation overhead that the functional specs have.
+*** Functional Specs:  These also have a one-to-one relationship with classes for the most part - geminstaller_spec is an exception.  Most of these test how groups of classes interact together at various levels.  Most of them use the "Test Gem Home" fixture approach.  This is effective, but adds several seconds to the startup of each run.  There is also overlap between some of them, especially at high levels of the API, which adds some maintenance overhead, but is worth it to me since it helps catch integration bugs.
+*** Smoke Tests: There are some tests under /spec/smoketests which are not part of the main spec suite.  These are really coarse grained scripts.  They hit the live rubygems.org gem repository, and install/uninstall actual gems, and exercise my sample rails app which uses GemInstaller.  They are used as a check to ensure that my "Test Gem Home" fixture approach is not masking any real-life bugs.
+* I'm a proponent of high code coverage.  I check periodically to ensure I maintain close to 100% code coverage, not counting platform- and version-specific code blocks (and I'll get around to those some day).  Also, the sudo recursive invocation stuff still needs some tests, but that's a bit tricky to automate.
+* The tests are "harder" on Windows (but run fine on mac/linux).  The app should work fine, but testing is pretty tricky.  I have all tests working against the latest rubygems (1.0.1).  Here's what does and doesn't work with tests against latest rubygems on windows:
+  * install_smoketest.rb and autogem_smoketest.rb work
+  * ruby test/test_all.rb works
+  * rake default test task does not work (this seems to be a problem with hoe on windows)
+  * Sometimes test suite still hangs after a while, this is probably some orphaned EmbeddedGemServer process somewhere.  A reboot should fix it - this is windows, after all!
+* One of my motivations for creating GemInstaller was as an exercise to help me learn Ruby better.  If you see me doing anything obviously dumb or inefficient in the code or design, please let me know. Some of them I already know about, but haven't fixed, most I'm probably not aware of :)
+
+<span id="rubygems_compatibility"/>
+
+h1. Maintaining forward and backward compatibility with multiple RubyGems versions
+
+* I've put a lot of effort into ensuring that GemInstaller works with older versions of RubyGems, and run automated tests against several recent versions on Continuous Integration.
+
+* This wasn't as hard as it seems.  The hardest part was figuring out what was different between versions.  Once you understand that, you can add switch statements to perform different logic or tests depending on the version (which is easy if you use rubygems built in Version Requirement support - see GemInstaller::RubygemsVersionChecker).
+
+* To run against different RubyGems versions, I have a RUBYGEMS_VERSION environment variable which causes the correct version or RubyGems in spec/fixture/rubygems_dist to be put on the load path and used for the test run.
+
+* RubyGems 0.9.5 was a major upgrade, the preview release for 1.0.  It introduced support for platforms, auto-install of missing dependencies, and many other things that GemInstaller already did.
+
+* Here are the main differences in GemInstaller when running on RubyGems >=0.9.5:
+** Don't use missing dependency finder (auto-install of missing dependencies is now built in)
+** Don't use valid platform selector, use --platform option (auto-selection of platform is now built in)
+** GemInteractionHandler should throw error on any interactive prompt (since dependencies and platforms are now handled automatically by default)
+** The "<code>prefer_binary_platform</code> config property":../documentation/documentation.html#prefer_binary_platform_config_property no longer applies, and has no effect.
+
+<span id="release_process"/>
+
+h1. Release Process
+
+Yeah, it's too manual.  Notes for improvement below.
+
+* Add section and entries for new release to History.txt
+* Add same history info to history section on homepage.
+* Update version in geminstaller.rb (if it was not done immediately after last publish, which it should have been)
+* rake update_manifest
+* Run tests:
+** CI should be green for all versions
+** install_smoketest.rb and autogem_smoketest.rb should pass for all RubyGems versions on mac/linux
+** test_all, install_smoketest.rb and autogem_smoketest.rb should pass for latest RubyGems version on windows
+* Make sure everything is checked in
+* Make a tag in svn
+* rake clean package
+* Upload gem to rubyforge
+* rake publish_website
+* Bump the version in geminstaller.rb to the expected next release version.
+
+Here's the improvements I need to make to the release process:
+
+* Avoid duplication of history file to display on home page
+* Make CI automatically build and tag a gem/package with next version + revision: x.y.z.<svn revision>
+* Rake task to automatically tag and release latest build from CI and tag
+
+<span id="rubygems_upgrade_process"/>
+
+h1. Rubygems Upgrade Process
+
+Process to test against new rubygems release.
+
+<pre><code>
+svn export http://rubygems.rubyforge.org/svn/tags/REL_X_Y_Z spec/fixture/rubygems_dist/rubygems-X.Y.Z
+</code></pre>
+
+* add spec/fixture/rubygems_dist/rubytems-X.Y.Z
+* checkin
+* Add project for that release on CI