jwhitmire-geminstaller 0.5.4

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,21 @@
+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
+      
+      # Manually check here in addition to backward_compatibility.rb, to avoid circular dependency
+      if defined?(Gem::Requirement)
+        requirement_class = Gem::Requirement
+      else
+        requirement_class = Gem::Version::Requirement
+      end
+      
+      requirement_class.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 = GemInstaller::REQUIREMENT_CLASS.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.rb

@@ -0,0 +1,103 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/geminstaller/requires.rb")
+
+module GemInstaller
+  def self.install(args = [], geminstaller_executable = nil)
+    args_copy = args.dup
+    args_copy = args_copy.split(' ') unless args.respond_to? :join
+    # recursively call script with sudo, if --sudo option is specified
+    if platform_supports_sudo? and (args_copy.include?("-s") or args_copy.include?("--sudo"))
+      result = reinvoke_with_sudo(args_copy, geminstaller_executable)
+      if result != 0 and (args_copy.include?("-e") or args_copy.include?("--exceptions"))
+        message = "Error: GemInstaller failed while being invoked with --sudo option.  See prior output for error, and use '--geminstaller-output=all --rubygems-output=all' options to get more details."
+        raise GemInstaller::GemInstallerError.new(message)
+      end
+      return result
+    else
+      app = create_application(args_copy)
+      app.install
+    end
+  end
+  
+  def self.run(args = [], geminstaller_executable = nil)
+    # run is now an alias for install
+    install(args, geminstaller_executable)
+  end
+  
+  def self.autogem(args = [])
+    args_copy = args.dup
+    args_copy = args_copy.split(' ') unless args.respond_to? :join
+    # TODO: should explicitly remove all args not applicable to autogem (anything but config, silent, and geminstaller_output)
+    args_without_sudo = strip_sudo(args_copy)
+    app = create_application(args_without_sudo)
+    app.autogem
+  end
+
+  def self.version
+    "0.5.4"
+  end
+
+  def self.create_application(args = [], registry = nil)
+    registry ||= create_registry
+    app = registry.app
+    app.args = args
+    app
+  end
+  
+  def self.create_registry
+    GemInstaller::Registry.new
+  end
+  
+  def self.parse_config_paths(config_paths)
+    return nil unless config_paths
+    return config_paths unless config_paths.respond_to? :join
+    return config_paths.join(',')
+  end
+  
+  def self.platform_supports_sudo?
+    return true unless RUBY_PLATFORM =~ /mswin/
+    return false
+  end
+  
+  def self.reinvoke_with_sudo(args, geminstaller_executable)
+    # Sudo support is a hack, better to use other alternatives.
+    geminstaller_executable ||= find_geminstaller_executable
+    args_without_sudo = strip_sudo(args)
+    args_without_sudo << '--redirect-stderr-to-stdout'
+    cmd = "sudo ruby #{geminstaller_executable} #{args_without_sudo.join(' ')}"
+    # TODO: this eats any output.  There currently is no standard way to get a return code AND stdin AND stdout.
+    # Some non-standard packages like Open4 handle this, but not synchronously.  The Simplest Thing That Could
+    # Possibly Work is to have a command line option which will cause all stderr output to be redirected to stdout.
+    result = system(cmd)
+    return 1 unless result
+    return $?.exitstatus
+  end
+  
+  def self.strip_sudo(args)
+    return args.reject {|arg| arg == "-s" || arg == "--sudo"}
+  end
+  
+  def self.find_geminstaller_executable
+    possible_locations = [
+      'ruby -S geminstaller',
+      'ruby /usr/local/bin/geminstaller',
+      'ruby /usr/bin/geminstaller',
+      'ruby ./bin/geminstaller'
+      ]
+    path_key = 'geminstaller_exec_path='
+    possible_locations.each do |possible_location|
+      cmd = "#{possible_location} --geminstaller-exec-path"
+
+      $stderr_backup = $stderr.dup
+      $stderr.reopen("/dev/null", "w")
+      io = IO.popen(cmd)
+      $stderr.reopen($stderr_backup)
+      STDERR.reopen($stderr_backup) # Why are these not the same?  It is an old question: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/47596
+      output = io.read
+      next unless output =~ /#{path_key}/
+      path = output.sub(path_key,'')
+      return path
+    end
+    raise GemInstaller::GemInstallerError.new("Error: Unable to locate the geminstaller executable.  Specify it explicitly, or don't use the sudo option.")
+  end
+end

data/lib/geminstaller_rails_preinitializer.rb

@@ -0,0 +1,54 @@
+############# 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
+      # The forking is a workaround to 'check_for_upgrade' in the configuration file, which causes
+      # script/console crashes on Mac OS X. See http://www.ruby-forum.com/topic/101243 for details
+      # It is probably best not to install from preinitializer - it has known problems
+      # under Passenger, and you should be installing your gems before you initialize rails anyway,
+      # via capistrano, chef, or some other mechanism.  So, it is commented for now.
+      # pid = fork do
+      #   GemInstaller.install(args)
+      # end
+      # Process.wait(pid)
+
+      # 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/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,92 @@
+---
+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_suites/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
+
+* BACKWARD COMPATIBILITY UPDATE: As of July 2009, I had to give up on being able to keep the test suite running against all old versions of RubyGems back to 0.8.11, and I've had to drop test support for some of the old versions.  The world moves on, and changes in Rspec, Rake, Hoe, Ruby, and Rubygems itself make it hard to make the tests themselves run under old versions of Rubygems.  GemInstaller ITSELF should still run against these versions, I just can't run the automated tests for them.  
+
+* FORWARD COMPATIBILITY UPDATE: Between my move to git (no more automagically-updating svn:externals, just lame manual git submodules), and RubyGems' refusal to allow incrementing of the RubyGems trunk version ([refusal](http://rubyforge.org/pipermail/rubygems-developers/2009-June/004749.html), [explanation](http://rubyforge.org/pipermail/rubygems-developers/2009-June/004750.html)), maintaining automated tests and version checks against the latest RubyGems trunk presented some challenges.  However, I have it working again, in an ugly Rube-Goldbergesque kind of way.  More details later...
+
+* 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 latest version and as many old versions as possible
+** install_smoketest.rb and autogem_smoketest.rb should pass for all RubyGems versions on mac/linux (if they are in a working state)
+** test_all, install_smoketest.rb and autogem_smoketest.rb should pass for latest RubyGems version on windows (if they are in a working state)
+* Make sure everything is checked in
+* Make a tag in git (git tag x.y.z; git push origin x.y.z)
+* 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

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

@@ -0,0 +1,6 @@
+index.html:
+  title: Rdoc
+  url: index.html
+  in_menu: true
+  sort_info: 30
+

data/website/src/community/index.page

@@ -0,0 +1,14 @@
+---
+title: Feedback
+---
+h1. Feedback, Bugs, and Source Code
+
+h2. Rubyforge Bug/Feature Tracker and Mailing Lists
+
+* "RubyForge Page":http://rubyforge.org/projects/geminstaller/
+* "Bug/Feature Tracker":http://thewoolleyweb.lighthouseapp.com/projects/11580-geminstaller/overview
+* "Mailing Lists":http://rubyforge.org/mail/?group_id=1902
+
+h2. Source Code
+
+* Subversion Repository:  "http://geminstaller.rubyforge.org/svn/trunk":http://geminstaller.rubyforge.org/svn/trunk

data/website/src/community/links.page

@@ -0,0 +1,11 @@
+
+h1. Links
+
+* Chad's links:
+** "Chad's Home Page":http://www.thewoolleyweb.com
+** "Pivotal Labs":http://pivotallabs.com - where Chad works
+** "DiabeticMommy.com":http://www.diabeticmommy.com - Support site for women with diabetes, created and edited by Chad's wife
+* RubyGems
+** "RubyGems Homepage":http://rubygems.org
+* RSpec
+** "RSpec Homepage":http://rspec.info/

data/website/src/community/rubyforge.virtual

@@ -0,0 +1,4 @@
+rubyforge.html:
+  title: Rubyforge
+  url: http://rubyforge.org/projects/geminstaller
+  in_menu: true