fdietz-ruby-config 0.2.0

data/README.md

@@ -0,0 +1,64 @@
+# ruby-config
+
+* Website: [http://fdietz.wordpress.com/ruby-config](http://fdietz.wordpress.com/ruby-config)
+* Github: [http://github.com/fdietz/ruby-config](http://github.com/fdietz/ruby-config)
+* Author: fdietz@gmail.com
+
+## Description
+
+Ruby-Config lets you install and switch between various Ruby Runtimes
+
+
+## Prerequisites
+
+### Mac OS X: 
+You need to install [Xcode](http://developer.apple.com/technology/Xcode.html)
+
+### Ubuntu Linux:
+Use apt-get to install the essential packages:
+
+	sudo apt-get install build-essential zlib1g-dev libreadline5-dev libssl-dev
+
+### JRuby:
+
+You need a JDK
+#### OS X: 
+OS X comes with an already installed Java version.
+
+#### Ubuntu Linux:
+Use apt-get to install the essential packages:
+
+ 	sudo apt-get install sun-java6-jre sun-java6-jdk
+
+## Installation
+
+sudo gem install ruby-config
+
+## Kudos
+
+Thanks to [Relevance](http://thinkrelevance.com) for their work on [Ruby Switcher](http://github.com/relevance/etc/blob/3d607c8ac2f76077f27c3cbc0140b04a89f546be/bash/ruby_switcher.sh) which I used as the basis for the installation of various Ruby Runtimes.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2009 Frederik Dietz <fdietz@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/ruby-config

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__) , '..', 'lib')
+require 'ruby_config'
+
+RubyConfig::Runner.new.run

data/lib/ruby_config/config.rb

@@ -0,0 +1,35 @@
+module RubyConfig
+  class Config 
+    
+    attr_accessor :hash
+    
+    DEFAULTS = {'default' => 'ruby-leopard-1.8.6'}
+    
+    def initialize(path)
+      @config_file = File.join(path, "config.yml")
+      File.exist?(@config_file) ? load : @hash = {}.merge(DEFAULTS)      
+
+      #puts "config: #{@hash.inspect}"
+    end
+
+    def get(key)
+      @hash[key] 
+    end
+    
+    def set(key, value)
+      @hash[key] = value
+    end
+        
+    def save
+      RubyConfig::FileHelper.store_yml(@config_file, @hash)
+    end
+    
+    def load
+      @hash = RubyConfig::FileHelper.load_yml(@config_file)
+    end
+        
+    def to_hash
+      @hash
+    end
+  end
+end

data/lib/ruby_config/environment_config.rb

@@ -0,0 +1,43 @@
+# Not used currently
+module RubyConfig
+  class EnvironmentConfig 
+    
+    attr_writer :set_bash_var, :prepend_bash_var, :append_bash_var, :bash_alias
+    
+    def initialize(path)
+      @config_file = File.join(path, "current_env_config")
+    end
+        
+    def save
+      configuration = create_configuration(@set_bash_var, @prepend_bash_var, @append_bash_var, @bash_alias)
+      RubyConfig::FileHelper.write_content_to_file(configuration, @config_file)  
+    end
+
+    private
+
+      def create_configuration(set_bash_var = {}, prepend_bash_var = {}, append_bash_var = {}, bash_alias = {})
+        configuration = ""
+        prepend_bash_var.each { |key,value| configuration << prepend_to_bash_environment_var(key, value) + "\n" }
+        set_bash_var.each { |key,value| configuration << set_bash_environment_var(key, value) + "\n" }
+        bash_alias.each { |key, value| configuration << set_bash_alias(key, value) + "\n"  }
+        configuration
+      end
+      
+      def prepend_to_bash_environment_var(var, path)
+        "export #{var}=#{path}:$#{var}"
+      end
+    
+      def append_to_bash_environment_var(var, path)
+        "export #{var}=$#{var}:#{path}"
+      end
+    
+      def set_bash_environment_var(var, path)
+        "export #{var}=#{path}"
+      end
+    
+      def set_bash_alias(var, script)
+        "alias #{var}=\"#{script}\""
+      end
+    
+  end
+end

data/lib/ruby_config/file_helper.rb

@@ -0,0 +1,28 @@
+module RubyConfig
+  class FileHelper
+        
+    class << self
+      def write_content_to_file(content, path)
+        File.open(path, 'w') { |file| file.write content }
+      end
+    
+      def store_yml(path, data)
+        File.open(path, 'w') { |out| YAML.dump( data, out ) }
+      end
+    
+      def load_yml(path)
+        File.open(path) { |yf| YAML::load( yf ) }
+      end
+    
+      def delete_file(path)
+        File.delete(path) if File.exist?(path)
+      end
+            
+      def set_symlink(target_path, symlink_path)
+        FileUtils.ln_s(target_path, symlink_path)
+      end
+      
+    end
+    
+  end
+end

data/lib/ruby_config/options_parser.rb

@@ -0,0 +1,70 @@
+module RubyConfig
+  class OptionsParser
+    
+    def initialize
+      create_options
+    end
+    
+    def print_help
+      puts @optparse
+    end
+    
+    def create_options
+      @options = OpenStruct.new
+      @options.verbose = false
+      @options.list_available = false
+      @options.list_installed = false
+      @options.use = false
+      @options.runtime = nil
+      @options.install = false
+      @options.help = false
+      
+      @optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: ruby-config [options]"
+
+        opts.on('-a', '--list-available', 'List available Ruby runtimes') do
+          @options.list_available = true
+        end
+
+        opts.on('-l', '--list-installed', 'List installed Ruby runtimes') do
+          @options.list_installed = true
+        end
+
+        opts.on('-u', '--use [HANDLE]', 'Use specific Ruby runtime') do |runtime|
+          @options.use = true
+          @options.runtime = runtime        
+          abort("No Runtime specified") unless runtime
+        end
+
+        opts.on('-i', '--install [HANDLE]', 'Install specific Ruby runtime') do |runtime|
+          @options.install = true
+          @options.runtime = runtime
+          abort("No Runtime specified") unless runtime
+        end
+
+        opts.on('--uninstall [HANDLE]', 'Uninstall specific Ruby runtime') do |runtime|
+          @options.uninstall = true
+          @options.runtime = runtime
+          abort("No Runtime specified") unless runtime
+        end
+
+        opts.on('-v', '--version', 'Display version' ) do
+          puts "ruby-config version: #{RubyConfig.VERSION}"
+          exit
+        end
+
+        opts.on('-h', '--help', 'Display this screen' ) do
+          @options.help = true
+        end
+      end
+      
+    end
+    
+    def parse
+      @optparse.parse!
+      @options
+    end
+      
+  end
+  
+end

data/lib/ruby_config/registry.rb

@@ -0,0 +1,109 @@
+module RubyConfig
+  
+  class Registry
+
+    attr_reader :ruby_config_path
+    
+    def initialize(ruby_config_path)
+      @ruby_config_path = ruby_config_path
+      @runtime_install_path = File.join(ruby_config_path, "runtimes")
+      @tmp_path = File.join(ruby_config_path, "tmp")
+      
+      @config = RubyConfig::Config.new(@ruby_config_path)
+      @environment_config = RubyConfig::EnvironmentConfig.new(@ruby_config_path)
+      
+      @list = []
+      ensure_config_directory_exists
+    end
+
+    def add(runtime_const)
+      @list << runtime_const.new(@runtime_install_path, @tmp_path)
+    end
+    
+    def default?(handle)
+      handle == default_handle
+    end
+        
+    def first
+      @list.first
+    end
+    
+    def exist?(handle)
+      !!get(handle)
+    end
+    
+    def get(handle)
+      handle_int = handle.to_i # returns 0 if no fixnum
+      if handle_int > 0 && handle_int << @list.size
+        @list.values_at(handle_int-1).first
+      else
+        @list.find { |item| item.handle == handle  }
+      end
+    end 
+    
+    def list_available
+      @list
+    end
+
+    def list_installed
+      @list.find_all { |item| item.already_installed?}
+    end
+        
+    def install(runtime)      
+      runtime.do_install unless runtime.already_installed?
+      
+      use(runtime)
+      
+      runtime.do_post_install
+      
+      runtime      
+    end
+        
+    def use(runtime)    
+      set_default_handle(runtime.handle)
+      @config.save
+      
+      set_symlinks_to_runtime(runtime)
+      
+      runtime      
+    end
+
+    private
+    
+    def set_symlinks_to_runtime(runtime)
+      ruby_path = File.join(@ruby_config_path, "ruby")
+      gem_path = File.join(@ruby_config_path, "gem")
+      RubyConfig::FileHelper.delete_file(ruby_path)
+      RubyConfig::FileHelper.delete_file(gem_path)
+      RubyConfig::FileHelper.set_symlink(runtime.ruby_home_path, ruby_path)
+      RubyConfig::FileHelper.set_symlink(runtime.gem_home_path, gem_path)
+    end
+        
+    def default_handle
+      @config.get("default")
+    end
+    
+    def set_default_handle(default_handle)
+      @config.set("default", default_handle)
+    end
+    
+    def ensure_config_directory_exists
+      FileUtils.mkdir_p(@ruby_config_path)
+      FileUtils.mkdir_p(@tmp_path)      
+      FileUtils.mkdir_p(@runtime_install_path)
+    end
+
+    # bash_alias required by jruby nailgun
+    # def update_current_environment_config(ruby_home, gem_home, bash_alias = {})
+    #   set_bash_var = {'GEM_HOME' => gem_home, 'RUBY_HOME' => ruby_home}
+    #   prepend_bash_var = {'PATH' => "#{ruby_home}/bin" }
+    #   
+    #   @environment_config.set_bash_var = set_bash_var
+    #   @environment_config.prepend_bash_var = prepend_bash_var
+    #   @environment_config.bash_alias = bash_alias
+    #   @environment_config.save
+    # end
+
+  end
+  
+end

data/lib/ruby_config/runner.rb

@@ -0,0 +1,165 @@
+module RubyConfig
+
+  class Runner
+
+    RUBY_CONFIG_PATH = File.join(ENV['HOME'], ".ruby-config")
+    
+    def initialize
+      @registry = RubyConfig::Registry.new(RUBY_CONFIG_PATH)
+      load_available_runtimes.each { |runtime| @registry.add(runtime) }
+    end
+    
+    def run
+      options_parser = RubyConfig::OptionsParser.new
+      
+      begin
+        options = options_parser.parse
+
+        if options.list_available
+          list_available  
+        elsif options.list_installed
+          list_installed
+        elsif options.install
+          install_runtime(options.runtime)
+        elsif options.uninstall
+          # TODO
+        elsif options.use
+          use_runtime(options.runtime)
+        elsif options.help
+          help(options_parser)
+        end
+      rescue OptionParser::ParseError => e
+        puts e
+        options_parser.print_help
+      end
+    end
+
+    private 
+    
+    def load_available_runtimes
+      list = []
+      list << RubyConfig::Runtimes::LeopardRuntime
+      list << RubyConfig::Runtimes::RubyEnterpriseEditionRuntime
+      list << RubyConfig::Runtimes::JRubyRuntime
+      list << RubyConfig::Runtimes::Ruby19Runtime
+      list << RubyConfig::Runtimes::Ruby186Runtime
+      list << RubyConfig::Runtimes::Ruby187Runtime
+      list
+    end
+    
+    def help(options_parser)
+      print_info_header
+      options_parser.print_help
+    end
+    
+    def install_runtime(handle)
+      unless @registry.exist?(handle)
+        puts "Unknown ruby runtime: #{handle}"
+        return
+      end
+      
+      runtime = @registry.get(handle)
+            
+      puts "#{runtime} already installed" if runtime.already_installed?
+      
+      @registry.install(runtime)
+      print_use_results(runtime)
+    end
+    
+    def use_runtime(handle)
+      unless @registry.exist?(handle)
+        puts "Unknown ruby runtime: #{handle}"
+        return
+      end
+      
+      runtime = @registry.get(handle)
+      
+      if @registry.use(runtime)
+        #display_ruby_version
+        #print_use_results(runtime)
+        display_ruby_version(runtime)
+      else
+        puts "Unknown Ruby Runtime: #{handle}"
+        puts 
+        list_installed
+        puts
+        puts example_use_usage
+      end
+    end  
+    
+    def example_use_usage
+      puts "Example usage: ruby-config -u #{@registry.first.handle}"
+    end
+    
+    def print_info_header
+      puts "ruby-config (http://github/fdietz/ruby-config)"
+      puts "Author: Frederik Dietz <fdietz@gmail.com>"
+      puts "Version: #{RubyConfig::VERSION}"
+      puts
+    end
+    
+    def list_available
+      puts "Available Ruby Versions:\n"
+      @registry.list_available.each_with_index do |item, index|
+        print_runtime(index, item)      
+      end  
+    end
+    
+    def list_installed
+      puts "Installed Ruby Versions:\n"
+      @registry.list_installed.each_with_index do |item, index|
+        print_runtime(index, item)
+      end      
+    end
+    
+    def print_runtime(index, item)
+      print "#{index+1}) "
+      print @registry.default?(item.handle) ? "*" : " "
+      puts " #{item}"
+    end
+    
+    def print_use_results(runtime)
+      puts "env:"
+      puts " RUBY_HOME=#{runtime.ruby_home_path}"
+      puts " GEM_HOME=#{runtime.gem_home_path}"
+      
+      unless runtime.bash_alias.empty?
+        puts "\nalias:"
+        print_alias(runtime.bash_alias)
+      end
+      
+      puts "\nruby -v:"
+      display_system_ruby_version
+    end
+    
+    def print_alias(hash)
+      hash.each do |key, value|
+        puts " alias #{key}=\"#{value}\""
+      end
+    end
+    
+    def display_ruby_version(runtime)
+      puts "Running: #{runtime}"
+    end
+    
+    def display_system_ruby_version
+      system "ruby -v"
+    end
+    
+    def abort(message)
+      puts message
+      exit
+    end
+
+  end
+end
+
+#RubyConfig::Runner.new.run
+
+
+# require 'fileutils'
+# if ARGV.include?('--dry-run')
+#   include FileUtils::DryRun
+# else
+#   include FileUtils::Verbose
+# end

data/lib/ruby_config/runtime_base.rb

@@ -0,0 +1,159 @@
+module RubyConfig
+
+  class RuntimeBase
+  
+    attr_reader :install_path, :tmp_path
+    
+    def initialize(install_path, tmp_path)
+      @install_path = File.join(install_path, handle)
+      @tmp_path = tmp_path
+    end
+    
+    def do_install
+      create_directory_structure
+      
+      download_file_unless_exists(archive_file_name, archive_download_url)
+      
+      # runtime specific installation part
+      install
+          
+      cleanup_tmp_dir
+    end
+        
+    def install
+      raise "Not implemented yet!"
+    end
+
+    def do_post_install
+      post_install
+      
+      install_rubygems unless File.exists?(gem_executable_path)
+      
+      # install thyselve
+      #install_gem('ruby-config')
+    end
+    
+    # called after install and runtime is enabled
+    def post_install
+    end
+    
+    # name of ruby runtime archive
+    def archive_file_name
+      raise "Not implemented yet!"
+    end
+    
+    # download url of ruby runtime
+    def archive_download_url
+      raise "Not implemented yet!"
+    end
+    
+    # technical name used to select runtime
+    def handle
+      raise "Not implemented yet!"
+    end
+
+    def description
+      raise "Not implemented yet!"
+    end
+
+    # example: 1.8 or 1.9
+    def major_version
+      '1.8'
+    end
+
+    # hash (key: alias name, value: alias bash script)
+    def bash_alias;{};end
+    
+    def ruby_home_path
+      File.join(@install_path, 'ruby')
+    end
+    
+    def ruby_bin_path
+      File.join(ruby_home_path, 'bin')
+    end
+    
+    def gem_home_path
+      File.join(@install_path, 'gem')
+    end
+    
+    def ruby_executable_path
+      File.join(ruby_bin_path, 'ruby')
+    end
+
+    def gem_executable_path
+      File.join(ruby_bin_path, 'gem')
+    end
+    
+    # aka site_ruby
+    def additional_library_path
+      File.join(ruby_home_path, 'lib', 'ruby', 'site_ruby', major_version)
+    end
+    
+    def default_library_path
+      File.join(ruby_home_path, 'lib', 'ruby', major_version)
+    end
+    
+    def to_s
+      "#{description} [#{handle}]"
+    end
+
+    def already_installed?
+       Pathname.new(File.join(ruby_bin_path, 'ruby')).exist?
+    end
+    
+    protected
+
+      def install_rubygems
+        version = "1.3.5"
+        archive_name = "rubygems-#{version}"
+        archive_file_name = "#{archive_name}.tgz"
+        download_url = "http://rubyforge.org/frs/download.php/60718/#{archive_file_name}"
+        
+        download_file_unless_exists(archive_file_name, download_url)
+        
+        extract_tar_gz(File.join(@tmp_path, archive_file_name), @tmp_path)
+        FileUtils.cd(File.join(@tmp_path, archive_name))
+        #system("ruby setup.rb --prefix=#{additional_library_path}")
+        system("ruby setup.rb")
+      end
+      
+      def cleanup_tmp_dir
+        empty_dir(@tmp_path)
+      end
+      
+      def create_directory_structure
+        FileUtils.mkdir_p(@install_path)
+        FileUtils.mkdir_p(@tmp_path)
+        FileUtils.mkdir_p(ruby_home_path)
+        FileUtils.mkdir_p(ruby_bin_path)
+        FileUtils.mkdir_p(gem_home_path)
+      end      
+      
+      def download_file_unless_exists(archive, url)
+        archive_path = File.join(@tmp_path, archive)
+        unless File.exist?(archive_path)
+          path = download_file_wget(url, archive_path)
+          puts "#{archive} downloaded successfully to #{archive_path}"
+        end
+      end
+       
+     def download_file_wget(url, destination_path)
+       system("wget #{url} --output-document=#{destination_path}")
+     end
+
+     def extract_tar_gz(archive_path, destination_path)
+       system("tar xfvz #{archive_path} -C #{destination_path}")
+     end
+      
+     def empty_dir(path)
+       Dir[File.join(path, '*')].each do |file|
+         FileUtils.remove_entry_secure(file) if Pathname.new(file).directory?
+       end
+     end
+     
+     def gem_install(gem_technical_name)
+       system "gem install -q --no-ri --no-rdoc #{gem_technical_name}"
+     end
+  end
+
+  end

data/lib/ruby_config/runtimes/jruby_runtime.rb

@@ -0,0 +1,97 @@
+
+module RubyConfig
+  
+  module Runtimes
+  
+    class JRubyRuntime < RubyConfig::RuntimeBase
+  
+      VERSION = '1.3.1'
+      JRUBY_DIR = "jruby-#{VERSION}"
+      JRUBY_ARCHIVE = "jruby-bin-#{VERSION}.tar.gz"
+      JRUBY_DOWNLOAD_URL = "http://dist.codehaus.org/jruby/#{VERSION}/#{JRUBY_ARCHIVE}"
+      
+      def handle
+        "jruby-#{VERSION}"
+      end
+
+      def description
+        "JRuby #{VERSION}"
+      end
+  
+      def archive_file_name
+        JRUBY_ARCHIVE
+      end
+
+      def archive_download_url
+        JRUBY_DOWNLOAD_URL
+      end
+          
+      # only required for nailgun support
+      # def bash_alias
+      #   {'ruby_ng', 'jruby --ng', 
+      #    'ruby_ng_server', 'jruby --ng-server'}
+      # end
+      
+      def install  
+        extract_tar_gz(File.join(@tmp_path, archive_file_name), @tmp_path)
+        
+        copy_archive_content_to_ruby_directory
+        
+        set_symlinks_for_jruby_commands
+        chmod_executables
+      end
+
+      def post_install
+        # install_nailgun
+        install_jruby_specific_gem
+      end
+  
+      private
+      
+      def copy_archive_content_to_ruby_directory
+        files = Dir.glob(File.join(@tmp_path, JRUBY_DIR, '*'))
+        FileUtils.cp_r(files, ruby_home_path)
+      end
+            
+      # there is already a jgem and gem, therefore no symlink required for gem!
+      def set_symlinks_for_jruby_commands
+        jruby_commands_requiring_symlinks.each do |item|
+          RubyConfig::FileHelper.set_symlink(item.first, bin_path(item.last))
+        end
+      end
+      
+      def jruby_commands_requiring_symlinks
+        [[bin_path('jruby'), 'ruby' ], 
+         [bin_path('jirb') , 'irb'  ]]
+      end
+      
+      # CHECK: can we download an archive which preserves permissions instead?
+      def chmod_executables
+        %w(jruby jgem gem jirb).each { |command| chmod_executable_for_others(bin_path(command)) }  
+      end
+
+      def chmod_executable_for_others(path)
+        FileUtils.chmod(0755, path)
+      end
+      
+      def bin_path(command)
+        File.join(ruby_bin_path, command)
+      end
+      
+      # TODO: "make" does not work correctly
+      def install_nailgun
+        nailgun_path = File.join(ruby_home_path, 'tool', 'nailgun')
+        puts "nailgun_path: #{nailgun_path}"
+        FileUtils.cd(nailgun_path)
+        system "#{nailgun_path}/make"
+      end
+      
+      def install_jruby_specific_gem
+        gem_install("rake")
+        gem_install("jruby-openssl")
+      end
+      
+    end
+  
+  end
+end

data/lib/ruby_config/runtimes/leopard_runtime.rb

@@ -0,0 +1,46 @@
+module RubyConfig
+  module Runtimes
+    class LeopardRuntime < RubyConfig::RuntimeBase
+    
+      def handle
+        'ruby-leopard-1.8.6'
+      end
+
+      def description
+        'Default Leopard Ruby 1.8.6'
+      end
+    
+      def archive_file_name
+        ""
+      end
+
+      def archive_download_url
+        ""
+      end
+      
+      def install
+        # intenionally left empty, since ruby is installed by default on OS X
+      end
+      
+      def already_installed?
+        true
+      end
+      
+      # "/System/Library/Frameworks/Ruby.framework/Versions/Current/usr"
+      def ruby_home_path
+        File.join("/System", "Library", "Frameworks", "Ruby.framework", "Versions", "Current", "usr")
+      end
+      
+      # $ ruby -r rubygems -e "p Gem.path"
+      # ["/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8", "/Library/Ruby/Gems/1.8"]
+      
+      # /System/Library/Frameworks/Ruby.framework/Versions/Current/usr/lib/ruby/gems/1.8
+      # /Library/Ruby/Gems/1.8
+      def gem_home_path
+        File.join(ruby_home_path, "lib", "ruby", "gems", "1.8")
+      end
+    
+    end
+  
+  end
+end

data/lib/ruby_config/runtimes/ruby186_runtime.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'ruby_from_source_helper')
+
+module RubyConfig
+  
+  module Runtimes
+    
+    
+    class Ruby186Runtime < RubyConfig::RuntimeBase      
+      MAJOR_VERSION = '1.8'
+      MINOR_VERSION = '6'
+      PATCH_LEVEL = '383'
+      
+      VERSION_STRING = RubyConfig::Runtimes::RubyFromSourceHelper.ruby_version(MAJOR_VERSION, MINOR_VERSION, PATCH_LEVEL)
+      HANDLE = "ruby-#{VERSION_STRING}"
+      DESCRIPTION = "Ruby #{VERSION_STRING}"
+      ARCHIVE_PATH = "ruby-#{VERSION_STRING}"
+      
+      def handle
+        HANDLE
+      end
+
+      def description
+        DESCRIPTION
+      end
+  
+      def archive_file_name
+        "ruby-#{VERSION_STRING}.tar.gz"
+      end
+
+      def archive_download_url
+        RubyConfig::Runtimes::RubyFromSourceHelper.download_url(MAJOR_VERSION, MINOR_VERSION, PATCH_LEVEL)
+      end
+      
+      def install
+        extract_tar_gz(File.join(@tmp_path, archive_file_name), @tmp_path)
+        
+        RubyConfig::Runtimes::RubyFromSourceHelper.compile(File.join(@tmp_path, ARCHIVE_PATH), ruby_home_path)
+      end
+        
+    end
+  
+  end
+end

data/lib/ruby_config/runtimes/ruby187_runtime.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'ruby_from_source_helper')
+
+module RubyConfig
+  
+  module Runtimes
+    
+    
+    class Ruby187Runtime < RubyConfig::RuntimeBase      
+      MAJOR_VERSION = '1.8'
+      MINOR_VERSION = '7'
+      PATCH_LEVEL = '174'
+      
+      VERSION_STRING = RubyConfig::Runtimes::RubyFromSourceHelper.ruby_version(MAJOR_VERSION, MINOR_VERSION, PATCH_LEVEL)
+      HANDLE = "ruby-#{VERSION_STRING}"
+      DESCRIPTION = "Ruby #{VERSION_STRING}"
+      ARCHIVE_PATH = "ruby-#{VERSION_STRING}"
+      
+      def handle
+        HANDLE
+      end
+
+      def description
+        DESCRIPTION
+      end
+  
+      def archive_file_name
+        "ruby-#{VERSION_STRING}.tar.gz"
+      end
+
+      def archive_download_url
+        RubyConfig::Runtimes::RubyFromSourceHelper.download_url(MAJOR_VERSION, MINOR_VERSION, PATCH_LEVEL)
+      end
+      
+      def install
+        extract_tar_gz(File.join(@tmp_path, archive_file_name), @tmp_path)
+        
+        RubyConfig::Runtimes::RubyFromSourceHelper.compile(File.join(@tmp_path, ARCHIVE_PATH), ruby_home_path)
+      end
+        
+    end
+  
+  end
+end

data/lib/ruby_config/runtimes/ruby19_runtime.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), 'ruby_from_source_helper')
+
+module RubyConfig
+  
+  module Runtimes
+     
+    class Ruby19Runtime < RubyConfig::RuntimeBase      
+      MAJOR_VERSION = '1.9'
+      MINOR_VERSION = '1'
+      PATCH_LEVEL = '243'
+      
+      VERSION_STRING = RubyConfig::Runtimes::RubyFromSourceHelper.ruby_version(MAJOR_VERSION, MINOR_VERSION, PATCH_LEVEL)
+      HANDLE = "ruby-#{VERSION_STRING}"
+      DESCRIPTION = "Ruby #{VERSION_STRING}"
+      ARCHIVE_PATH = "ruby-#{VERSION_STRING}"
+      
+      def handle
+        HANDLE
+      end
+
+      def description
+        DESCRIPTION
+      end
+      
+      def major_version
+        MAJOR_VERSION
+      end
+  
+      def archive_file_name
+        "ruby-#{VERSION_STRING}.tar.gz"
+      end
+
+      def archive_download_url
+        RubyConfig::Runtimes::RubyFromSourceHelper.download_url(MAJOR_VERSION, MINOR_VERSION, PATCH_LEVEL)
+      end
+      
+      def install
+        extract_tar_gz(File.join(@tmp_path, archive_file_name), @tmp_path)
+        
+        RubyConfig::Runtimes::RubyFromSourceHelper.compile(File.join(@tmp_path, ARCHIVE_PATH), ruby_home_path)
+      end
+        
+    end
+  
+  end
+end

data/lib/ruby_config/runtimes/ruby_enterprise_edition_runtime.rb

@@ -0,0 +1,46 @@
+module RubyConfig
+  
+  module Runtimes
+  
+    class RubyEnterpriseEditionRuntime < RubyConfig::RuntimeBase
+  
+      VERSION = '1.8.6'
+      HANDLE = "ruby-enterprise-#{VERSION}"
+      TIMESTAMP = '20090421'
+      DESCRIPTION = "Ruby Enterprise Edition #{VERSION}-#{TIMESTAMP}"
+      RUBY_ENTERPRISE_EDITION_DIR = "ruby-enterprise-#{VERSION}-#{TIMESTAMP}"
+      RUBY_ENTERPRISE_EDITION_ARCHIVE = "#{RUBY_ENTERPRISE_EDITION_DIR}.tar.gz"
+      RUBY_ENTERPRISE_EDITION_DOWNLOAD_URL = "http://rubyforge.org/frs/download.php/55511/#{RUBY_ENTERPRISE_EDITION_ARCHIVE}"
+    
+      def handle
+        HANDLE
+      end
+
+      def description
+        DESCRIPTION
+      end
+  
+      def archive_file_name
+        RUBY_ENTERPRISE_EDITION_ARCHIVE
+      end
+
+      def archive_download_url
+        RUBY_ENTERPRISE_EDITION_DOWNLOAD_URL
+      end
+      
+      def install
+        extract_tar_gz(File.join(@tmp_path, archive_file_name), @tmp_path)
+        
+        ree_installer
+      end
+      
+      private
+        def ree_installer
+          FileUtils.cd(File.join(@tmp_path, RUBY_ENTERPRISE_EDITION_DIR))
+          system("./installer -a #{@install_path}/ruby --dont-install-useful-gems")
+        end
+  
+    end
+  
+  end
+end

data/lib/ruby_config/runtimes/ruby_from_source_helper.rb

@@ -0,0 +1,24 @@
+module RubyConfig
+  module Runtimes
+    
+    module RubyFromSourceHelper
+      
+      def self.download_url(major_version, minor_version, patch_level)
+        version = ruby_version(major_version, minor_version, patch_level)
+        "ftp://ftp.ruby-lang.org/pub/ruby/#{major_version}/ruby-#{version}.tar.gz"
+      end
+    
+      def self.ruby_version(major_version, minor_version, patch_level)
+        "#{major_version}.#{minor_version}-p#{patch_level}"
+      end
+    
+      def self.compile(source_path, installation_path)
+        FileUtils.cd(source_path)
+        system("./configure --prefix=#{installation_path} --enable-shared")
+        system("make")
+        system("make install")
+      end
+    end
+    
+  end
+end

data/lib/ruby_config.rb

@@ -0,0 +1,15 @@
+#puts Dir.glob(File.join(File.dirname(__FILE__), 'ruby_config/**/*.rb'))
+Dir.glob(File.join(File.dirname(__FILE__), 'ruby_config/**/*.rb')).each {|f| require f }
+
+module RubyConfig
+  VERSION = '1.0.0'
+end
+
+require 'fileutils'
+require 'open-uri'
+require 'tempfile'
+require 'pathname'
+require 'ostruct'
+require 'optparse'
+require "yaml"
+

data/test/unit/registry_test.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+  
+class RegistryInitializeTest < Test::Unit::TestCase
+  def setup
+    @root = File.join("/tmp", "test")
+    @registry = RubyConfig::Registry.new(@root)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@root)
+  end
+  
+  test "should ensure config directories exist" do
+    assert File.exist?(@root)
+    assert File.exist?(File.join(@root,"runtimes"))
+    assert File.exist?(File.join(@root,"tmp"))
+  end
+      
+end
+
+
+class RegistryInstallTest < Test::Unit::TestCase
+  
+  def setup
+    @root = File.join("/tmp", "test")
+    @registry = RubyConfig::Registry.new(@root)
+    @registry.add(RegistryTestHelper::RuntimeBaseStub)
+    @runtime = @registry.get("handle")
+  end
+
+  def teardown
+    FileUtils.rm_rf(@root)
+  end
+  
+  test "should install using specific runtime implementation" do
+    @registry.install(@runtime)
+
+    assert File.exist?(@runtime.ruby_home_path)
+    assert File.exist?(@runtime.gem_home_path)
+    assert File.exist?(File.join(@runtime.ruby_bin_path, "ruby"))
+    assert File.exist?(File.join(@runtime.ruby_bin_path, "gem"))
+    assert File.exist?(File.join(@runtime.ruby_bin_path, "irb"))
+  end
+  
+  test "should make use of installed runtime" do
+    @registry.expects(:use).with(@runtime)
+    @registry.install(@runtime)
+  end
+  
+  test "should call post install methods" do
+    @runtime.expects(:post_install)
+    @registry.install(@runtime)
+  end
+end
+
+
+class RegistryUseTest < Test::Unit::TestCase
+  
+  def setup
+    @root = File.join("/tmp", "test")
+    @registry = RubyConfig::Registry.new(@root)
+    @registry.add(RegistryTestHelper::RuntimeBaseStub)
+    @runtime = @registry.get("handle")
+    @registry.install(@runtime)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@root)
+  end
+  
+  test "should set default handle in config file" do
+    @registry.use(@runtime)
+    
+    config = File.open(File.join(@registry.ruby_config_path, "config.yml")) { |yf| YAML::load( yf ) }
+    assert_equal @runtime.handle, config["default"]
+  end
+  
+  test "should create symlinks to installed runtime" do
+    @registry.use(@runtime)
+    assert Pathname.new(File.join(@registry.ruby_config_path, "ruby")).symlink?
+    assert Pathname.new(File.join(@registry.ruby_config_path, "gem")).symlink?
+  end
+end
+
+module RegistryTestHelper
+  
+  class RuntimeBaseStub < RubyConfig::RuntimeBase
+    # create fake ruby and gem executables
+    def install
+      FileUtils.touch(File.join(ruby_bin_path, "ruby"))
+      FileUtils.touch(File.join(ruby_bin_path, "gem"))
+      FileUtils.touch(File.join(ruby_bin_path, "irb"))
+    end
+  
+    def archive_file_name;"archive.zip";end
+    def archive_download_url;"http://download.com/archive.zip";end
+    def handle;"handle";end
+    def description;"description";end
+    # no download for tests
+    def download_file_unless_exists(archive, url);end;
+  end
+  
+end

data/test/unit/runtime_base_test.rb

@@ -0,0 +1,120 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class RuntimeBaseInitializeTest < Test::Unit::TestCase
+  
+  test "should set install path" do
+    r = RuntimeBaseTestHelper::RuntimeBaseStub.new("/install", "/tmp_path")
+    assert_equal "/install/handle", r.install_path
+  end  
+end
+
+class RuntimeBaseDoInstallTest < Test::Unit::TestCase
+  
+  def setup
+    @root = "/tmp/test"
+    FileUtils.mkdir(@root)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@root)
+  end
+  
+  test "should create directory structure" do
+    r = RuntimeBaseTestHelper::RuntimeBaseStub.new(File.join(@root, "install"), File.join(@root, "tmp"))
+    r.stubs(:download_file_unless_exists)
+    r.stubs(:already_installed?).returns(true)
+    r.do_install
+    
+    assert File.exist?(r.install_path)
+    assert File.exist?(r.tmp_path)
+    assert File.exist?(File.join(r.install_path,"gem"))
+  end  
+  
+  test "should install runtime and cleanup tmp unless installed already" do
+    r = RuntimeBaseTestHelper::RuntimeBaseStub.new(File.join(@root, "install"), File.join(@root, "tmp"))
+    r.stubs(:download_file_unless_exists)
+    r.stubs(:already_installed?).returns(false)
+    
+    r.expects(:install).once
+    r.expects(:cleanup_tmp_dir).once  
+    r.do_install
+  end
+  
+  test "should NOT install runtime if installed already" do
+    r = RuntimeBaseTestHelper::RuntimeBaseStub.new(File.join(@root, "install"), File.join(@root, "tmp"))
+    r.stubs(:download_file_unless_exists)
+    r.stubs(:already_installed?).returns(true)
+    
+    r.expects(:install).never
+    r.expects(:cleanup_tmp_dir).never
+    r.do_install
+  end
+  
+end
+
+class RuntimeBaseDownloadFileUnlessExists < Test::Unit::TestCase
+  
+  def setup
+    @root = "/tmp/test"
+    FileUtils.mkdir(@root)
+    
+    @runtime = RuntimeBaseTestHelper::RuntimeBaseStub.new(File.join(@root, "install"), File.join(@root, "tmp"))
+    @runtime.send(:create_directory_structure)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@root)
+  end
+  
+  test "should download file unless it exist already" do
+    @runtime.expects(:download_file_wget).once    
+    @runtime.send(:download_file_unless_exists, "archive.zip", "url")    
+  end
+  
+  test "should NOT download file if it exists already" do
+    archive_path = File.join(@runtime.tmp_path, "archive.zip")
+    FileUtils.touch(archive_path)
+    @runtime.expects(:download_file_wget).never
+    
+    @runtime.send(:download_file_unless_exists, "archive.zip", "url")
+  end
+
+end
+
+class RuntimeBaseIfAlreadyInstalledTest < Test::Unit::TestCase
+  
+  def setup
+    @root = "/tmp/test"
+    FileUtils.mkdir(@root)
+    
+    @runtime = RuntimeBaseTestHelper::RuntimeBaseStub.new(File.join(@root, "install"), File.join(@root, "tmp"))
+    @runtime.send(:create_directory_structure)
+    FileUtils.mkdir_p(@runtime.ruby_bin_path)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@root)
+  end
+  
+  test "should return true if ruby bin found" do
+    bin_path = File.join(@runtime.ruby_bin_path, "ruby")
+    FileUtils.touch(bin_path)
+    
+    assert_equal true, @runtime.already_installed?
+  end
+    
+  test "should return false if ruby bin NOT found" do
+    assert_equal false, @runtime.already_installed?
+  end
+  
+end
+
+module RuntimeBaseTestHelper
+  class RuntimeBaseStub < RubyConfig::RuntimeBase
+    def install;end
+    def archive_file_name;"filename";end
+    def archive_download_url;"http://download.com";end
+    def handle;"handle";end
+    def description;"description";end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: fdietz-ruby-config
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Frederik Dietz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-24 00:00:00 -07:00
+default_executable: ruby-config
+dependencies: []
+
+description: ruby-config lets one easily install and switch between various Ruby Runtimes
+email: fdietz@gmail.com
+executables: 
+- ruby-config
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- bin/ruby-config
+- lib/ruby_config.rb
+- lib/ruby_config/config.rb
+- lib/ruby_config/environment_config.rb
+- lib/ruby_config/file_helper.rb
+- lib/ruby_config/options_parser.rb
+- lib/ruby_config/registry.rb
+- lib/ruby_config/runner.rb
+- lib/ruby_config/runtime_base.rb
+- lib/ruby_config/runtimes/jruby_runtime.rb
+- lib/ruby_config/runtimes/leopard_runtime.rb
+- lib/ruby_config/runtimes/ruby186_runtime.rb
+- lib/ruby_config/runtimes/ruby187_runtime.rb
+- lib/ruby_config/runtimes/ruby19_runtime.rb
+- lib/ruby_config/runtimes/ruby_enterprise_edition_runtime.rb
+- lib/ruby_config/runtimes/ruby_from_source_helper.rb
+- README.md
+has_rdoc: false
+homepage: http://github.com/fdietz/ruby-config
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Install and Switch between various Ruby Runtimes easily
+test_files: 
+- test/unit/registry_test.rb
+- test/unit/runtime_base_test.rb