rconf 0.10.1 → 1.0.0

data/.gitignore

@@ -1,6 +1,6 @@
 tags
 pkg/*
-.rvmrc
+.ruby-version
 Gemfile.lock
 .idea/
 *.swp

data/CHANGES

@@ -0,0 +1,5 @@
+=== 0.10.2
+
+ - Download RVM directly from GitHub instead of shunting through rvm.io
+ - Allow user to specify nil gemset (e.g. to override project setting)
+ - Don't get fooled by an rconf that is on our path but not in our active gemset

data/Gemfile

@@ -1,7 +1,10 @@
-source :gemcutter
+source 'https://rubygems.org'
+gemspec
+
+gem 'rake',                 ' ~> 0.8.7'
 
 #Gems needed to execute the unit specs.
-group :test do
+group :development do
   gem 'rspec',              '~> 2.5'
   gem 'flexmock',           '~> 0.9'
 end

data/README.rdoc

@@ -7,7 +7,7 @@
 As RightScale systems evolve, developers are faced with having to maintain a
 quickly growing list of applications. Each application requires different tools
 for development and for deployment. Tools may include different versions of
-ruby, rubygems, bundler etc. Being able to setup an environment appropriately
+ruby, bundler etc. Being able to setup an environment appropriately
 for each application is becoming increasingly complex and switching from one
 application to another for development in particular is quickly becoming
 close to impossible.
@@ -19,9 +19,10 @@ and potentially windows).
 
 rconf uses a DSL close to Chef recipes for defining an application configuration.
 Each application must be equipped with a definition that must reside at the top
-level directory of the application and use the '.rconf' file extension. When run
-for the first time rconf sets up a .rvmrc file which gets invoked and sets up
-the environment each time the application directory gets 'cd-ed' into.
+level directory of the application and use the '.rconf' file extension.
+rconf must be invoked manually using the 'rconf' command line utility to setup
+the environment using the rconf file in the current folder or the one contained
+in a parent folder (the closest parent to the current directory will get used).
 
 Internally rconf relies on 'configurators' to configure the machine
 appropriately. There is one configurator per tool that needs configuration.
@@ -47,53 +48,16 @@ rely on.
 
 == INSTALLING
 
-There are two installation cases
-
-a) you've already got a working install of RVM
-b) blank system
-
-=== a) Installing when RVM is already present
-
 It should be as simple as:
 
-  gem install rconf
+>  gem install rconf
 
 and then moving to your repository and running:
 
-  rconf
+>  rconf
 
 to let rconf prepare your environment for the repository.
 
-=== b) Installing on a blank system
-
-If your system fits the requirements listed above, installing rconf will
-require you to make a system install of rconf:
-
-  sudo gem install rconf
-
-then you can go to your repository and run
-
-  rconf
-
-If you do not have a x.rconf equipped directory and you want rconf to install rvm for
-you, you can create a file named dummy.rconf containing:
-
-  ruby do
-    version 'ruby-1.9.2-p290'
-    rubygems '1.8.10'
-  end
-
-and then run rconf against it:
-
-  rconf dummy.rconf
-
-=== rconf and existing .rvmrc files
-
-If you have pre-existing .rvmrc files and they don't play well with your
-.rconf configuration file, don't hesitate to delete them and run rconf.
-rconf will create a new, working, .rvmrc.
-
-
 == WRITING RCONF CONFIGURATION FILES
 
 rconf uses a ruby DSL for configuration files (.rconf). Each configurator is

data/bin/rconf

@@ -44,9 +44,14 @@ where [options] are:
         opt :verbose,'Print debug output'
       end
       if opts[:config].nil? && !opts[:configurators] && !opts[:update] && !opts[:remove]
+        search_dir = File.expand_path('..', Dir.pwd)
         opts[:config] = Dir["./*#{CONFIG_EXTENSION}"]
+        while opts[:config].empty? && search_dir != '/'
+          opts[:config] = Dir[search_dir + "/*#{CONFIG_EXTENSION}"]
+          search_dir = File.expand_path('..', search_dir)
+        end
         if opts[:config].empty?
-          Trollop::die :config, "not used and could not find a '#{CONFIG_EXTENSION}' file in the working directory"
+          Trollop::die :config, "not used and could not find a '#{CONFIG_EXTENSION}' file in the working directory or any parent directory"
         else
           opts[:config] = opts[:config].first
         end
@@ -141,7 +146,7 @@ where [options] are:
     def update
       ProgressReporter.report_to_stdout
       report_check 'Retrieving latest rconf...'
-      json = Command.execute('curl', '-s', 'http://rubygems.org/api/v1/gems/rconf.json').output
+      json = Command.execute('curl', '-s', 'https://rubygems.org/api/v1/gems/rconf.json').output
       json =~ /"version":"([^"]+)"/
         version = Regexp.last_match(1)
       report_fatal 'Failed to retrieve rconf gem information, check network connectivity' unless version
@@ -150,35 +155,19 @@ where [options] are:
       update_rconf(version)
     end
 
-    # Calls given block with all combination of installed rubies/gemsets
+    # Calls given block with all combination of installed rubies
     #
     # === Block
-    # Given block should take two arguments:
+    # Given block should take one argument:
     #   ruby(String):: Ruby version
-    #   gemset(String):: Gemset
     #
     # === Return
     # true:: Always return true
-    def run_in_all_gemsets(&callback)
-      rubies = Command.execute('rvm', 'list').output
-      rubies = rubies.split("\n")[3..-1]
-      report_fatal 'Failed to list install rubies (is rvm in your path?)' unless rubies
-      rubies.each do |ruby|
-        if ruby =~ /^(\s+| =>)((ruby|ree|jruby|rbx)[^ ]*)\s.*/
-          ruby = Regexp.last_match(2)
-          gemsets = Command.execute('rvm', ruby, 'exec', 'rvm', 'gemset', 'list').output.split("\n")
-          i = gemsets.index { |gs| gs =~ /^gemsets for #{ruby} / }
-          if i
-            gemsets = gemsets[i + 1..-1]
-            gemsets.each do |gs|
-              gs = gs.lstrip
-              callback.call(ruby, gs)
-            end
-          else
-            report_fatal "Failed to retrieve installed gemsets for '#{ruby}'"
-          end
-        end
-      end
+    def run_in_all_rubies(&callback)
+      rubies = Command.execute('rbenv', 'versions').output
+      rubies = rubies.split("\n").map { |r| r[2..-1] } if rubies
+      report_fatal 'Failed to list install rubies (is rbenv in your path?)' unless rubies
+      rubies.each { |r| callback.call(r) }
     end
 
     # Update rconf for given rubies if required
@@ -189,34 +178,33 @@ where [options] are:
     # === Return
     # true:: Always return true
     def update_rconf(version)
-      run_in_all_gemsets do |ruby, gs|
-        report_check("Checking rconf for #{ruby}@#{gs}")
-        rconf = Command.execute('rvm', "#{ruby}@#{gs}", 'gem', 'list', 'rconf').output
-        if rconf =~ /rconf \(#{version}/
-                             report_success
-        elsif rconf =~ /^rconf /
+      run_in_all_rubies do |ruby|
+        report_check("Checking rconf for #{ruby}")
+        rconf = Command.execute('gem', 'list', 'rconf', :env => { 'RBENV_VERSION' => ruby }).output
+        if rconf =~ /^rconf / && rconf !~ /rconf \(#{version}/
           report_failure
-          report_check("Updating rconf for #{ruby}@#{gs}")
-          res = Command.execute('rvm', "#{ruby}@#{gs}", 'gem', 'install',
-                                'rconf', '-v', version, '--no-ri', '--no-rdoc')
+          report_check("Updating rconf for #{ruby}")
+          res = Command.execute('gem', 'install', 'rconf', '-v', version,
+                                '--no-ri', '--no-rdoc', :env => { 'RBENV_VERSION' => ruby })
           report_result(res.success?)
+          report('  ' + res.output.red) unless res.success?
         else
-          report('SKIPPED (no rconf)')
+          report_success
         end
       end
     end
 
-    # Remove rconf from all rubies/gemsets
+    # Remove rconf from all rubies
     #
     # === Return
     # true:: Always return true
     def remove
       ProgressReporter.report_to_stdout
-      run_in_all_gemsets do |ruby, gs|
-        rconf = Command.execute('rvm', "#{ruby}@#{gs}", 'gem', 'list', 'rconf').output
+      run_in_all_rubies do |ruby|
+        rconf = Command.execute('gem', 'list', 'rconf', :env => { 'RBENV_VERSION' => ruby }).output
         if rconf =~ /^rconf /
-          report_check("Removing rconf from #{ruby}@#{gs}")
-          res = Command.execute('rvm', "#{ruby}@#{gs}", 'gem', 'uninstall', '-a', '-x', 'rconf')
+          report_check("Removing rconf from #{ruby}")
+          res = Command.execute('gem', 'uninstall', '-a', '-x', 'rconf', :env => { 'RBENV_VERSION' => ruby })
           report_result(res.success?)
         end
       end
@@ -231,11 +219,12 @@ where [options] are:
     # === Return
     # true:: Always return true
     def configure(options)
-      Profile.force_check if options[:force]
-      Profile.force_reconfigure if options[:reconfigure]
       ProgressReporter.report_to_stdout
       ProgressReporter.report_to_file(options[:output]) if options[:output]
+      Profile.force_check if options[:force]
+      Profile.force_reconfigure if options[:reconfigure]
       begin
+        report("rconf file: #{options[:config].blue}")
         lang = Language.load(options[:config])
         report_fatal("Validation of configuration file failed:\n  - #{lang.validation_errors.map(&:red).join("\n  - ")}") unless lang.validation_errors.empty?
         report_error(lang.warnings.join(', ').green) unless lang.warnings.empty?
@@ -271,6 +260,5 @@ where [options] are:
 end
 
 # Yeeeehaaaa!
-ENV['rvm_interactive_flag'] = '0' # Prevent RVM from re-loading rvmrc
 trap("INT") { puts "\nAborted!".red; exit 1 }
 RightConf::Configurer.run

data/lib/rconf/command.rb

@@ -32,10 +32,6 @@ module RightConf
     # === Return
     # result(CommandResult):: Result of execution (output and exit status)
     def execute(command, *args)
-      ENV['rvm_is_not_a_shell_function'] = '0'
-      ENV['rvm_ignore_rvmrc'] = '1'
-      ENV['rvm_reload_flag'] = '0'
-      ENV['rvm_project_rvmrc'] = '0'
       opts = {}
       if !args.empty? && args[-1].is_a?(Hash)
         opts = args[-1]
@@ -66,36 +62,20 @@ module RightConf
     #
     # === Return
     # result(CommandResult):: Result of execution (output and exit status)
-    #   NOTE: This is the result returned by RVM, not the underlying command
-    #   and thus could be successful when the command actually failed...
     def execute_in_ruby(command, *args)
-      report_fatal('Failed to run in ruby context, no ruby specified') unless @rvm_prefix
-      commands = @rvm_prefix + [ 'exec', '--', command ]
-      args = commands + args
-      execute('rvm', *args)
-    end
+      report_fatal('Failed to run in ruby context, no ruby specified') unless @ruby_version
+      opts = {}; env = {}
+      if args[-1].is_a?(Hash)
+        opts = args.pop
+        env = opts[:env] || {}
+      end
+      env.merge!({ 'RBENV_VERSION' => @ruby_version })
+      opts.merge!({ :env => env })
+      args.push(opts)
 
-    # Execute rvm command
-    #
-    # === Parameters
-    # command(String):: rvm command to run
-    # args(Array):: Command arguments
-    #
-    # === Options
-    # abort_on_failure(bool):: Whether to raise an exception in case command
-    #                          returns an error (false by default)
-    # env:: Hash of environment variables keyed by name
-    #
-    # === Return
-    # result(CommandResult):: Result of execution (output and exit status)
-    def execute_rvm(command, *args)
-      report_fatal('Failed to run in ruby context, no ruby specified') unless @rvm_prefix
-      commands = @rvm_prefix + [ command ]
-      args = commands + args
-      execute('rvm', *args)
+      execute(command, *args)
     end
 
-
     # Execute given command with given arguments using 'sudo'
     #
     # === Parameters
@@ -144,13 +124,12 @@ module RightConf
     # Set ruby to be used by 'execute_in_ruby'
     #
     # === Parameters
-    # ruby(String):: RVM ruby
-    # gemset(String):: RVM gemset
+    # version(String):: rbenv ruby version
     #
     # === Return
     # true:: Always return true
-    def set_ruby(ruby, gemset)
-      @rvm_prefix = ["#{ruby}@#{gemset}"]
+    def set_ruby(version)
+      @ruby_version = version
       true
     end
 

data/lib/rconf/configurator.rb

@@ -88,7 +88,7 @@ module RightConf
     # nil:: If settings are valid for this configurator
     # error(String):: Error message otherwise
     def validate
-      @settings_values.merge!(OverridesLanguage.overrides_for(self.class.key.to_s)) unless Profile.force_reconfigure?
+      @settings_values.merge!(OverridesLanguage.overrides_for(self.class.key.to_s))
       if e = OverridesLanguage.parse_error
         error = "Could not load overrides file '#{OverridesLanguage::OVERRIDES_FILE}' (#{e.message})"
       else

data/lib/rconf/configurators/passenger_configurator.rb

@@ -147,8 +147,8 @@ module RightConf
       report_check('Installing passenger+nginx')
       # Grrrrr passenger installer expect rake where it's not... HACK
       ruby_dir = File.dirname(`which ruby`.chomp)
-      if ruby_dir !~ /\.rvm/
-        post_note 'Please enable rvm before passenger is installed by running ' + 'cd ..;cd -'.blue
+      if ruby_dir !~ /\.rbenv/
+        post_note 'Please init rbenv before passenger is installed by running ' + 'cd ..;cd -'.blue
         report_failure
       else
         FileUtils.cp(`which rake`.chomp, ruby_dir) unless rake_exist = File.exist?(File.join(ruby_dir, 'rake'))
@@ -257,21 +257,21 @@ http {
         #####################################################################
         set $is_library_direct "";
 
-        # request is for a library related action      
+        # request is for a library related action
         if ($request_uri ~ ^/library/)
         {
           set $is_library_direct  L;
         }
-      
+
         # request is a POST
         if ($request_method = POST)
         {
-          set $is_library_direct "${is_library_direct}P";       
+          set $is_library_direct "${is_library_direct}P";
         }
-      
+
         # request is an AJAX
         if ($http_x_requested_with = XMLHttpRequest)
-        {      
+        {
           set $is_library_direct "${is_library_direct}A";
         }
 
@@ -313,8 +313,8 @@ http {
             proxy_set_header   X-Core-Site-Domain 'right-site.rightscale.local';
         }
 
-        # library static assets get proxied directly to the library app   
-        location ~ ^/library/(.*)\.(css|js)$ {
+        # library static assets get proxied directly to the library app
+        location ~ ^/library/(.*)\.(css|js|html)$ {
              proxy_pass http://library.rightscale.local:3001/$1.$2;
         }
 
@@ -334,21 +334,21 @@ http {
         #####################################################################
         set $is_global_system_direct "";
 
-        # request is for a library related action      
+        # request is for a library related action
         if ($request_uri ~ ^/global/)
         {
           set $is_global_system_direct  L;
         }
-      
+
         # request is a POST
         if ($request_method = POST)
         {
-          set $is_global_system_direct "${is_global_system_direct}P";       
+          set $is_global_system_direct "${is_global_system_direct}P";
         }
-      
+
         # request is an AJAX
         if ($http_x_requested_with = XMLHttpRequest)
-        {      
+        {
           set $is_global_system_direct "${is_global_system_direct}A";
         }
 

data/lib/rconf/configurators/ruby_configurator.rb

@@ -18,17 +18,9 @@ module RightConf
     register :ruby
 
     description "Installs ruby interpreter and rubygems.\n" +
-                'Installs and uses rvm on supported (i.e. non-Windows) platforms'
+                'Installs and uses rbenv on supported (i.e. non-Windows) platforms'
 
-    setting 'version',  'Ruby version using rvm notation (see "rvm list known")', :required => true
-    setting 'rubygems', 'Rubygems version, e.g. "1.3.7"'
-    setting 'gemset',   'Gemset to be used for platforms supporting rvm'
-
-    # RVM version used to install rubies
-    RVM_VERSION = '1.10.2'
-
-    # RVM releases URL
-    RVM_RELEASES_URL = 'https://rvm.io/releases'
+    setting 'version',  'Ruby version using rbenv notation (see "rbenv versions")', :required => true
 
     # Let configurator run, it is idempotent
     #
@@ -41,78 +33,23 @@ module RightConf
     alias :check_windows :check_linux
 
     # Switch to ruby version defined in settings
-    # Use rvm and install it if needed
+    # Use rbenv and install it if needed
     #
     # === Return
     # true:: Always return true
     def run_linux
-      check_rvm(RVM_VERSION)
-      return true if aborting
-      Command.set_ruby(version, gemset)
-      report_check("Checking whether #{version} is the active ruby")
-      out = Command.execute('rvm', 'current').output
-      if out =~ /^#{version.gsub('.', '\\.')}/
-        report_success
-        check_rvmrc
-      else
-        report_failure
-        report_check("Switching to #{version}")
-        out = Command.execute('rvm', 'use', version).output
-        case out
-        when /is not installed\./
-          report_failure
-          report_fatal "Failed to install #{ruby}" if @tried
-          Platform.dispatch(version) { :install_ruby }
-          @tried = true
-          Command.execute_in_ruby('gem', 'install', 'rconf') unless gemset
-          run
-          return true
-        when /^Using /
-          report_success
-          check_rvmrc
-        else
-          report_fatal("Failed to use #{version}:\n#{out}")
-        end
-      end
-      if gemset
-        report_check("Checking whether gemset #{gemset} exists")
-        res = Command.execute('rvm', version, 'exec', 'rvm', 'gemset', 'list')
-        if res.output =~ /^(\s+|=> )#{gemset}$/
-          report_success
-        else
-          report_failure
-          report_check("Creating gemset #{gemset} for #{version}")
-          Command.execute('rvm', version, 'exec', 'rvm', 'gemset', 'create',  gemset,
-                          :abort_on_failure => "Failed to create gemset '#{gemset}'")
-        end
-        report_check("Switching to gemset #{gemset}")
-        Command.execute('rvm', version, 'exec', 'rvm', 'gemset', 'use',  gemset,
-                        :abort_on_failure => "Failed to switch to gemset '#{gemset}'")
-        report_success
-        report_check("Checking whether rconf is installed")
-        res = Command.execute_in_ruby('rconf', '--version')
-        if res.output =~ /#{RightConf::VERSION}/
-          report_success
-        else
-          report_failure
-          report_check("Installing rconf")
-          Command.execute_in_ruby('gem', 'install', 'rconf', :abort_on_failure => "Failed to install rconf")
-          report_success
-        end
-      end
-      if rubygems
-        report_check("Checking whether rubygems #{rubygems} is installed")
-        res = Command.execute_in_ruby('gem', '--version')
-        if res.success? && res.output =~ /^#{rubygems}$/
-          report_success
-        else
-          report_failure
-          report_check("Installing rubygems #{rubygems}")
-          Command.execute_rvm('rubygems', rubygems, :abort_on_failure => 'Failed to install rubygems')
-          report_success
-        end
+      if Command.execute('rvm').success?
+        report_fatal "rconf detected an installation of RVM, rconf now uses rbenv to configure ruby versions.\n" +
+          "Unfortunately rbenv and RVM cannot be installed together on the same machine (see https://github.com/sstephenson/rbenv/).\n" +
+          "Please uninstall RVM and try again ('rvm implode' will delete RVM and all installed rubies and gems).\n" +
+          "Once RVM is uninstalled please start a new shell (you may also need to remove references to RVM from your ~/.bash_profile)"
+        return true
       end
-      true
+      check_rbenv
+      return true if aborting
+      check_ruby
+      Command.set_ruby(ruby_version)
+     true
     end
     alias :run_darwin :run_linux
 
@@ -124,93 +61,103 @@ module RightConf
     def run_windows
     end
 
-    # Set command prefix when already configured
-    # Re-create .rvmrc if needed
+    protected
+
+    # Make version compatible with RVM
+    def ruby_version
+      @ruby_version ||= version.start_with?('ruby-') ? version[5..-1] : version
+    end
+
+    # Check whether rbenv and ruby-build are installed and installs it/them if not
     #
     # === Return
     # true:: Always return true
-    def post_process
-      Command.set_ruby(version, gemset)
-      check_rvmrc
-      true
+    def check_rbenv
+      res = Command.execute('rbenv')
+      rbenv_in_path = res.success?
+      if rbenv_in_path
+        res.output =~ /^rbenv ([0-9]+)\.([0-9]+)\.([0-9]+)$/
+        maj, min, build = [$1.to_i, $2.to_i, $3.to_i]
+        if maj == 0 && min < 4
+          report_fatal("rconf requires rbenv version 0.4.0 or greater, you have #{maj}.#{min}.#{build} installed, please upgrade (e.g. via brew upgrade rbenv) and try again")
+        end
+        return true
+      end
+      rbenv_present = File.exist?(File.join(ENV['HOME'], '.rbenv', 'bin', 'rbenv'))
+      update_msg  = "You should add 'eval \"$(rbenv init -)\"' to your .bash_profile / .bashrc etc. " +
+                    "so rbenv is properly initialized in new shells, the following assumes ~/.bash_profile is used (Mac OS X):\n\n" +
+                    "echo 'eval \"$(rbenv init -)\"' >> ~/.bash_profile\n\n".blue +
+                    "You should also update your PATH environment variable with:\n\n" +
+                    "echo 'export PATH=\"$HOME/.rbenv/shims:$PATH\" >> ~/.bash_profile'\n".blue
+      if rbenv_present
+        post_note "rconf detected rbenv is installed in #{rbenv_path} but it is not in the PATH.\n" + update_msg
+        aborting(true)
+        return true
+      else
+        opts = { :report => true, :post_install => update_msg }.merge(abort_option('Failed to install rbenv'))
+        PackageInstaller.install('rbenv', opts)
+        opts = { :report => true }.merge(abort_option('Failed to install ruby-build'))
+        PackageInstaller.install('ruby-build', opts) { !Command.execute('ruby-build') }
+        true
+      end
     end
 
-    protected
-
-    # Check whether the right version of RVM is installed and install it if not
-    #
-    # === Parameters
-    # version(String):: Version of RVM to be checked, e.g. '1.2.6'
+    # Check .ruby-version and its content
     #
     # === Return
     # true:: Always return true
-    def check_rvm(version)
-      report_check("Checking that rvm #{version} is installed")
-      out = Command.execute('rvm', '--version').output
-      if out =~ /rvm #{RVM_VERSION.gsub('.', '\\.')}/
-        report_success
-      else
-        report_failure
-        if out =~ /rvm ([^\s]+)/
-          report_error "WARNING!: You have rvm #{Regexp.last_match[1]} installed which may not be compatible with rconf.\n" +
-            "rconf will proceed and try to install rvm #{version}."
-        end
-        report_check("Installing rvm #{version}")
-        rvm_src = File.join(ENV['HOME'] || '/root', '.rvm/src')
-        FileUtils.mkdir_p(rvm_src)
-        Dir.chdir(rvm_src) do
-          Command.execute('curl', '-O', '-f',
-                          "#{RVM_RELEASES_URL}/rvm-#{version}.tar.gz",
-                          :abort_on_failure => "Failed to download rvm #{version}")
-          Command.execute('tar', 'zxf', "rvm-#{version}.tar.gz",
-                          :abort_on_failure => "Failed to extract rvm tgz from #{File.join(Dir.getwd, 'rvm-' + version + '.tar.gz')}")
-        end
-        Dir.chdir(File.join(rvm_src, "rvm-#{version}")) do
-          Command.execute('./install', :abort_on_failure => "Failed to install rvm #{version}")
+    def check_ruby
+      exists = File.exist?('.ruby-version')
+      if exists
+        contents = IO.read('.ruby-version')
+        right_ruby = !!(contents =~ /#{ruby_version}/)
+      end
+
+      unless exists && right_ruby
+        unless Command.execute('rbenv', 'local', ruby_version).success?
+          report_check("Installing ruby #{ruby} (this will take a while, please be patient)")
+          Platform.dispatch(ruby_version) { :install_ruby }
+          Command.execute('rbenv', 'local', ruby_version)
         end
-        post_note "Configuration required installing RVM, please start a new shell to activate it and re-run rconf to finish configuration".green
-        aborting(true)
-        report_success
       end
-      setup_bashrc
       true
     end
 
-    # Install given ruby version using rvm
+    # Install given ruby version using rbenv
+    # Install any prerequesites first
     #
     # === Parameters
-    # ruby(String):: Ruby version compatible with rvm
+    # ruby(String):: Ruby version compatible with rbenv
     #
     # === Return
     # true:: Always return true
     def install_ruby(ruby)
       Platform.dispatch(ruby) { :install_ruby_prerequisites }
-      report_check("Installing #{ruby} (this will take a while, please be patient)")
-      Command.execute('rvm', 'install', ruby, :abort_on_failure => 'Failed to install ruby')
+      # Can't abort on failure rbenv install seems to exist with a non zero error code even when successful :(
+      Command.execute('rbenv', 'install', ruby)
       report_success
       true
     end
 
-    # Install given ruby version using rvm
-    # On Lion, need to setup CC env var before running rvm install
+    # Install given ruby version using rbenv
+    # On Lion, need to setup CC env var before running rbenv install
     #
     # === Parameters
-    # ruby(String):: Ruby version compatible with rvm
+    # ruby(String):: Ruby version compatible with rbenv
     #
     # === Return
     # true:: Always return true
     def install_ruby_darwin(ruby)
-      report_check("Installing #{ruby} (this will take a while, please be patient)")
-      version = `system_profiler SPDeveloperToolsDataType -xml | xpath "//*[text()='_items']/following-sibling::array/dict/child::key[text()='spdevtools_version']/following-sibling::string/text()" 2> /dev/null`
+      c_version = `system_profiler SPDeveloperToolsDataType -xml | xpath "//*[text()='_items']/following-sibling::array/dict/child::key[text()='spdevtools_version']/following-sibling::string/text()" 2> /dev/null`
       env = {}
-      if version =~ /^4\.2\.[0-9]+/
+      if c_version =~ /^4\.2\.[0-9]+/
         if !File.executable?('/usr/bin/gcc-4.2')
-          report_fatal("The C compiler included with Xcode #{version} produces buggy ruby interpreters, please install the C compilers from https://github.com/downloads/kennethreitz/osx-gcc-installer/GCC-10.7-v2.pkg and re-run rconf")
+          report_fatal("The C compiler included with Xcode #{c_version} produces buggy ruby interpreters, please install the C compilers from https://github.com/downloads/kennethreitz/osx-gcc-installer/GCC-10.7-v2.pkg or update your version of Xcode and re-run rconf")
         else
           env['CC'] = '/usr/bin/gcc-4.2'
         end
       end
-      Command.execute('rvm', 'install', ruby, :abort_on_failure => 'Failed to install ruby', :env => env)
+      Command.execute('rbenv', 'install', ruby, :abort_on_failure => 'Failed to install ruby', :env => env)
       report_success
     end
 
@@ -254,80 +201,17 @@ module RightConf
       true
     end
 
-    # Check .rvmrc and its content
-    #
-    # === Return
-    # true:: Always return true
-    def check_rvmrc
-      if !File.exist?('.rvmrc') || IO.read('.rvmrc') !~ /#{version}@#{gemset}/
-        report_check('Setting up .rvmrc')
-        begin
-          File.open('.rvmrc', 'w') do |f|
-            f.puts "environment_id=\"#{version}@#{gemset}\""
-            f.puts RVM_HOOK
-            f.puts "type -P rconf &>/dev/null && { rconf; }"
-            f.puts "type -P rconf &>/dev/null || { echo 'rconf not installed, skipping (see .rvmrc)'; }"
-          end
-          report_success
-          post_note "Configuration required switching the active ruby\nPlease run " + 'cd ..;cd -'.blue + ' to activate it and finish configuration'.green
-          aborting(true)
-        rescue Exception => e
-          report_failure
-          report_error(e.message)
-        end
-      end
-      true
-    end
-
-    # rvm mojo for creating and enabling 'environments'
-    RVM_HOOK = <<-EOF
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-
-  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
-  then
-    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
-  fi
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  if ! rvm --create  "$environment_id"
-  then
-    echo "Failed to create RVM environment '${environment_id}'."
-    return 1
-  fi
-fi
-if [[ $- == *i* ]] # check for interactive shells
-then
-    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
-else
-  echo "Using: $GEM_HOME" # don't use colors in interactive shells
-fi
-    EOF
 
-    # Setup .bashrc for rvm support
+    # Produce abort on failure option
     #
-    # === Return
-    # true:: Always return true
-    def setup_bashrc
-      if EnvironmentUpdater.update(rvm_bash_activation, ['PATH'])
-        post_note '.rvmrc was updated, please reload your shell to activate it and re-run rconf'
-        aborting(true)
-      end
-    end
-
-    # rvm bash activation code
+    # === Parameters
+    # message(String):: Abort message to be used in case abort option should be set
     #
     # === Return
-    # code(String):: Code that needs to be added to bashrc to activate rvm
-    def rvm_bash_activation
-      code = <<EOS
-export rvm_trust_rvmrcs_flag=1
-if [[ -n "$PS1" ]]; then
-  if [[ -s $HOME/.rvm/scripts/rvm ]] ; then source $HOME/.rvm/scripts/rvm ; fi
-fi
-EOS
+    # {}:: Empty hash if 'abort_on_failure' is notset
+    # opts(Hash):: Abort option with give message otherwise
+    def abort_option(message)
+      opts = abort_on_failure && { :abort_on_failure => message } || {}
     end
 
   end

data/lib/rconf/overrides_language.rb

@@ -17,14 +17,18 @@ module RightConf
     # Path to overrides file
     OVERRIDES_FILE = File.join(ENV['HOME'], '.rconf_overrides')
 
+    # Lexical token used to indicate that the value of an overridden configurator attribute should literally
+    # be nil, not the string "nil" or "none".
+    NIL_LITERAL    = /^(nil|none)$/
+
+
     # Return override for given configurator setting if any
     #
     # === Parameters
     # key(String):: Configurator key
-    # setting(String):: Setting name
     #
     # === Return
-    # value(String||Nil):: Override value if any, nil otherwise
+    # value(String||Nil):: Override values if any, nil otherwise
     def self.overrides_for(key)
       self.load unless @overrides
       @overrides && @overrides[key] || {}
@@ -85,11 +89,18 @@ module RightConf
           if operands.size != 2
             raise "Invalid syntax '#{o}', must be of the form 'key.setting=value'"
           end
+
           if operands[1].start_with?('"') || operands[1].start_with?("'")
+            # Quoted string
             value = operands[1]
+          elsif operands[1] =~ NIL_LITERAL
+            # Literal nil
+            value = 'nil'
           else
+            # Anything else: assume unquoted string
             value = "'#{operands[1]}'"
           end
+
           overrides.instance_eval("@#{operands[0]}=#{value}")
         end
       rescue Exception => e
@@ -142,4 +153,3 @@ module RightConf
 
   end
 end
-

data/lib/rconf/support/package_installer.rb

@@ -23,6 +23,7 @@ module RightConf
     # opts[:abort_on_failure](String):: Optional, abort configuration
     #   and display given error message if install fails when set
     # opts[:report](TrueClass|FalseClass):: Whether to report installation
+    # opts[:post_install](String):: Message displayed only when software was installed
     #
     # === Block
     # If a block is given it will get called with no argument prior to the
@@ -47,6 +48,7 @@ module RightConf
         report_check("Installing #{packages.join(', ')}") if report
         Platform.dispatch(packages, opts) { :install }
         report_success if report
+        opts && opts[:post_install] && report('Note: '.blue + opts[:post_install])
       end
       true
     end

data/lib/rconf/version.rb

@@ -11,9 +11,9 @@
 
 module RightConf
 
-  MAJOR = 0
-  MINOR = 10
-  BUILD = 1
+  MAJOR = 1
+  MINOR = 0
+  BUILD = 0
 
   VERSION = [MAJOR, MINOR, BUILD].map(&:to_s).join('.')
 

data/spec/configurators/bundler_configurator_spec.rb

@@ -28,11 +28,11 @@ describe RightConf::BundlerConfigurator do
 
   before(:each) do
     @configurator = create_configurator('bundler { version "0" }')
-    RightConf::Command.instance.instance_variable_set(:@rvm_prefix, 'r@g')
+    RightConf::Command.instance.instance_variable_set(:@ruby_prefix, '0')
   end
 
   after(:each) do
-    RightConf::Command.instance.instance_variable_set(:@rvm_prefix, nil)
+    RightConf::Command.instance.instance_variable_set(:@ruby_prefix, nil)
   end
 
   it 'should succeed when bundler succeeds' do

data/spec/configurators/ruby_configurator_spec.rb

@@ -13,95 +13,65 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 describe RightConf::RubyConfigurator do
 
-  RVM_VERSION = RightConf::RubyConfigurator::RVM_VERSION
-
   def success_result(output=nil)
     flexmock('res', :success? => true, :output => output)
   end
 
-  before(:each) do
-    @configurator = create_configurator('ruby { version "0"; rubygems "1" }')
-    flexmock(File).should_receive(:exist?).with('.rvmrc').and_return(true)
-    flexmock(IO).should_receive(:read).with('.rvmrc').and_return("anything")
-    flexmock(File).should_receive(:open).with('.rvmrc', 'w').and_yield(FlexMock.undefined) # Don't override rconf's .rvmrc...
+  def failure_result(output=nil)
+    flexmock('res', :success? => false, :output => output)
   end
 
-  it 'should succeed on linux when rvm succeeds' do
-    should_execute('rvm', '--version').once.and_return(success_result("rvm #{RVM_VERSION}"))
-    should_execute('rvm', 'current').once.and_return(success_result("0@"))
-    should_execute('rvm', '0@', 'exec', '--', 'gem', '--version').once.and_return(success_result('1'))
-    @configurator.run_linux
+  before(:each) do
+    @configurator = create_configurator('ruby { version "42" }')
   end
 
-  it 'should install rvm if needed' do
-    rvm_tar = "rvm-#{RVM_VERSION}.tar.gz"
-    should_execute('rvm', '--version').once.and_return(success_result("rvm"))
-    should_execute('curl', '-O', '-f', "https://rvm.io/releases/#{rvm_tar}",
-      {:abort_on_failure=>"Failed to download rvm #{RVM_VERSION}"}).once.and_return(success_result)
-    should_execute('tar', 'zxf', rvm_tar,
-      {:abort_on_failure=>"Failed to extract rvm tgz from #{File.expand_path(File.join(File.dirname(__FILE__), '..', '..', "rvm-#{RVM_VERSION}.tar.gz"))}"}).once.and_return(success_result)
-    flexmock(Dir).should_receive(:chdir).and_yield
-    should_execute('./install', {:abort_on_failure=>"Failed to install rvm #{RVM_VERSION}"}).once.and_return(success_result)
-    should_execute('rvm', 'use', '0').never
-    @configurator.run_linux
+  it 'should abort if rvm is present' do
+    should_execute('rvm').once.and_return(success_result)
+    expect { @configurator.run_linux }.to raise_error
   end
 
-  it 'should install rubygems if needed' do
-    should_execute('rvm', '--version').once.and_return(success_result("rvm #{RVM_VERSION}"))
-    should_execute('rvm', 'current').once.and_return(success_result("0@"))
-    should_execute('rvm', '0@', 'exec', '--', 'gem', '--version').once.and_return(success_result('0'))
-    should_execute('rvm', '0@', 'rubygems', '1',
-      {:abort_on_failure=>'Failed to install rubygems'}).once.and_return(success_result)
-    @configurator.run_linux
-  end
-end
+  context "with rbenv installed" do
+    before(:each) do
+      should_execute('rvm').once.and_return(failure_result)
+      flexmock(File).should_receive(:exist?).with('.ruby-version').and_return(true)
+      flexmock(IO).should_receive(:read).with('.ruby-version').and_return("42")
+    end
 
-describe 'bashrc update' do
+    it 'should succeed' do
+      should_execute('rbenv').once.and_return(success_result('rbenv 0.4.0'))
+      @configurator.run_linux
+    end
 
-  before(:each) do
-    flexmock(File).should_receive(:exist?).with(File.join(ENV['HOME'], '.bash_profile')).once.and_return(true)
-    flexmock(File).should_receive(:exist?).with('.rvmrc').and_return(true)
-    flexmock(FileUtils).should_receive(:mv).and_return(true)
-    f = flexmock('f')
-    f.should_receive(:puts).and_return { |c| @bashrc_content = c }
-    flexmock(File).should_receive(:open).and_yield(f)
-    @configurator = create_configurator('ruby { version "0"; rubygems "1" }', :enable_updater => true)
-    @rvm_bash_activation = @configurator.__send__(:rvm_bash_activation)
-  end
+    it 'should check rbenv version' do
+      should_execute('rbenv').once.and_return(success_result('rbenv 0.3.0'))
+      expect { @configurator.run_linux }.to raise_error
+    end
 
-  it 'should install rvm hook in bashrc when not present' do
-    flexmock(IO).should_receive(:read).and_return('test')
-    @configurator.__send__(:setup_bashrc)
-    @bashrc_content.should == "#{@rvm_bash_activation}\ntest"
   end
 
-  it 'should not install rvm hook in bashrc when present' do
-    flexmock(IO).should_receive(:read).and_return('test' + @rvm_bash_activation)
-    @configurator.__send__(:setup_bashrc)
-    @bashrc_content.should be_nil
-  end
+  context "without rbenv installed" do
+    before(:each) do
+      should_execute('rvm').once.and_return(failure_result)
+      should_execute('rbenv').once.and_return(failure_result)
+      flexmock(File).should_receive(:exist?).with('.ruby-version').and_return(false)
+      flexmock(File).should_receive(:exist?).with(File.join(ENV['HOME'], '.rbenv', 'bin', 'rbenv')).and_return(false)
+    end
 
-  it 'should install rvm hook after path is set' do
-    flexmock(IO).should_receive(:read).and_return(<<-EOS
-echo 'zobi la mouche'
-radio killed the radio star
-#PATH=something:should be fine
-this should not:
-PATH=something
-AFTER
-      EOS
-    )
-    @configurator.__send__(:setup_bashrc)
-    @bashrc_content.should == <<-EOS
-echo 'zobi la mouche'
-radio killed the radio star
-#PATH=something:should be fine
-this should not:
-PATH=something
-#{@rvm_bash_activation}
-AFTER
-    EOS
+    it 'should install rbenv and ruby-build' do
+      flexmock(RightConf::PackageInstaller).should_receive(:install).with('rbenv', Hash).once
+      flexmock(RightConf::PackageInstaller).should_receive(:install).with('ruby-build', Hash, Proc).once
+      should_execute('rbenv', 'local', '42').and_return(success_result)
+      @configurator.run_linux
+    end
+
+    it 'should install ruby if needed' do
+      flexmock(RightConf::PackageInstaller).should_receive(:install).with('rbenv', Hash).once
+      flexmock(RightConf::PackageInstaller).should_receive(:install).with('ruby-build', Hash, Proc).once
+      should_execute('rbenv', 'local', '42').and_return(failure_result)
+      flexmock(RightConf::Platform).should_receive(:dispatch).with('42', Proc)
+      should_execute('rbenv', 'local', '42').and_return(success_result)
+      @configurator.run_linux
+    end
   end
 
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rconf
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-27 00:00:00.000000000 Z
+date: 2013-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -66,6 +66,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGES
 - Gemfile
 - LICENSE
 - README.rdoc
@@ -142,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rconf
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Cross platform environment configuration