redcar 0.4.1 → 0.5

data/lib/plugin_manager/spec/plugin_manager_spec.rb

@@ -1,5 +1,5 @@
 
-require File.join(File.dirname(__FILE__), "spec_helper")
+require "spec_helper"
 
 describe PluginManager do
   before do
@@ -19,7 +19,7 @@ describe PluginManager do
   describe "loading plugin definitions" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures example)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading example)))
     end
     
     it "should find plugin files inside the source" do
@@ -36,8 +36,8 @@ describe PluginManager do
   
   describe "loading plugin definitions with syntax errors in them" do
     before do
-      @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures error_in_definition)))
+      @manager = PluginManager.new(StringIO.new)
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading error_in_definition)))
     end
     
     it "should not die when loading the definition" do
@@ -47,14 +47,14 @@ describe PluginManager do
     it "should report it as an error" do
       @manager.unreadable_definitions.length.should == 1
       @manager.unreadable_definitions.first.should == 
-        File.expand_path(File.join(File.dirname(__FILE__), %w(fixtures error_in_definition core plugin.rb)))
+        File.expand_path(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading error_in_definition core plugin.rb)))
     end
   end
   
   describe "loading plugins" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures example)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading example)))
       @manager.load
     end
     
@@ -73,8 +73,8 @@ describe PluginManager do
   
   describe "loading plugins with errors in them" do
     before do
-      @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures error_in_plugin)))
+      @manager = PluginManager.new(StringIO.new)
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading error_in_plugin)))
     end
     
     it "should not die when loading plugins" do
@@ -91,7 +91,7 @@ describe PluginManager do
   describe "loading plugins with unmet dependencies because the plugin is missing" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures unmet_dependencies1)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading unmet_dependencies1)))
     end
     
     it "should load the rest of the plugins ok" do
@@ -103,7 +103,7 @@ describe PluginManager do
   describe "loading plugins with unmet dependencies because the plugin is not recent enough" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures unmet_dependencies2)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading unmet_dependencies2)))
     end
     
     it "should load the rest of the plugins ok" do
@@ -115,7 +115,7 @@ describe PluginManager do
   describe "reloading plugins" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures example)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading example)))
       @manager.load
     end
     
@@ -128,7 +128,7 @@ describe PluginManager do
   describe "loading when there are multiple versions" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures two_versions1)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading two_versions1)))
       @manager.load
     end
     
@@ -144,16 +144,54 @@ describe PluginManager do
   describe "loading when there are multiple versions and the most recent has unmet deps" do
     before do
       @manager = PluginManager.new
-      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures two_versions2)))
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading two_versions2)))
+    end
+     
+    it "should not load the plugin" do
       @manager.load
+      @manager.loaded_plugins.length.should == 0
+    end
+  end
+  
+  describe "specify which plugin to load and load only that and it's dependencies" do
+    before do
+      @manager = PluginManager.new
+      @manager.add_plugin_source(File.join(File.dirname(__FILE__), %w(fixtures plugin_loading example)))
     end
      
-    it "should only load one version" do
+    it "should only load one plugin if that's right" do
+      @manager.load("Core")
       @manager.loaded_plugins.length.should == 1
+      @manager.loaded_plugins.first.name.should == "Core"
+    end
+    
+    it "should load dependencies of the specified plugin" do
+      @manager.load("Extras")
+      @manager.loaded_plugins.length.should == 2
+      @manager.loaded_plugins.map {|pl| pl.name }.sort.should == ["Core", "Extras"]
+    end
+
+    it "should load dependencies of dependencies" do
+      @manager.load("Debug")
+      @manager.loaded_plugins.length.should == 3
+      @manager.loaded_plugins.map {|pl| pl.name }.sort.should == ["Core", "Debug", "Extras"]
+    end
+    
+    it "should let you specify multiple plugins to load" do
+      @manager.load("Core", "Debug")
+      @manager.loaded_plugins.length.should == 3
+      @manager.loaded_plugins.map {|pl| pl.name }.sort.should == ["Core", "Debug", "Extras"]
+    end
+    
+    it "should let you load more after loading the first batch" do
+      @manager.load("Core")
+      @manager.load("Debug")
+      @manager.loaded_plugins.length.should == 3
+      @manager.loaded_plugins.map {|pl| pl.name }.sort.should == ["Core", "Debug", "Extras"]
     end
     
-    it "should load the most recent version with met dependencies" do
-      @manager.loaded_plugins.first.version.should == "1.0"
+    it "should raise an error if you try to load a plugin that doesn't exist" do
+      lambda { @manager.load("AFOSIJ") }.should raise_error
     end
   end
     

data/lib/redcar/installer.rb

@@ -9,232 +9,113 @@ end
 
 module Redcar
   class Installer
-  	def initialize
-  	  if ENV['http_proxy']
-  	    proxy = URI.parse(ENV['http_proxy'])
+    def initialize
+      if ENV['http_proxy']
+        proxy = URI.parse(ENV['http_proxy'])
         @connection = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
       else
-  	    @connection = Net::HTTP
+        @connection = Net::HTTP
       end
       puts "found latest XULRunner release version: #{xulrunner_version}" if Redcar.platform == :windows
     end
-    
-  	def install
-      unless File.writable?(JRUBY_JAR_DIR)
-  	    puts "Don't have permission to write to #{JRUBY_JAR_DIR}. Please rerun with sudo."
-  	    exit 1
-  	  end
+      
+    def install
       Redcar.environment = :user
-  	  puts "Downloading >10MB of jar files. This may take a while."
-  	  grab_jruby
-  	  grab_common_jars
-  	  grab_platform_dependencies
-  	  grab_redcar_jars
-      puts "Building textmate bundle cache"
-      s = Time.now
-      load_textmate_bundles
-      puts "... took #{Time.now - s}s"
-      fix_user_dir_permissions
-  	  puts
-  	  puts "Done! You're ready to run Redcar."
-  	end
-  
-    def associate_with_any_right_click
-      raise 'this is currently only for windows' unless Redcar.platform == :windows  	  
-      require 'rbconfig'
-      require 'win32/registry'
-      # associate it with the current rubyw.exe
-      rubyw_bin = File.join([Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']]) << 'w' << Config::CONFIG['EXEEXT']
-      if rubyw_bin.include? 'file'
-        raise 'this must be run from a ruby exe, not a java -cpjruby.jar command'
-      end
-      rubyw_bin.gsub!('/', '\\') # executable names wants back slashes
-      for type, english_text  in {'*' => 'Open with Redcar', 'Directory' => 'Open with Redcar (dir)'}
-        name = Win32::Registry::HKEY_LOCAL_MACHINE.create "Software\\classes\\#{type}\\shell\\open_with_redcar"
-        name.write_s nil, english_text
-        dir = Win32::Registry::HKEY_LOCAL_MACHINE.create "Software\\classes\\#{type}\\shell\\open_with_redcar\\command"
-        command = %!"#{rubyw_bin}" "#{File.expand_path($0)}" "%1"!
-        dir.write_s nil, command
-      end
-      puts 'Associated.'
+      puts "Downloading >10MB of binary assets. This may take a while the first time."
+      fetch_all_assets
+      precache_textmate_bundles
+      puts "Done! You're ready to run Redcar."
     end
-
+  
     def plugins_dir
       File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. plugins)))
     end
     
-    ASSET_HOST = "http://redcar.s3.amazonaws.com"
-    
-    JFACE = %w(
-      /jface/org.eclipse.core.commands.jar
-      /jface/org.eclipse.core.runtime_3.5.0.v20090525.jar
-      /jface/org.eclipse.equinox.common.jar
-      /jface/org.eclipse.jface.databinding_1.3.0.I20090525-2000.jar
-      /jface/org.eclipse.jface.jar
-      /jface/org.eclipse.jface.text_3.5.0.jar
-      /jface/org.eclipse.osgi.jar
-      /jface/org.eclipse.text_3.5.0.v20090513-2000.jar
-      /jface/org.eclipse.core.resources.jar
-      /jface/org.eclipse.core.jobs.jar
-    )
-    
-    def redcar_jars_dir
-      File.expand_path(File.join(Redcar.user_dir, "jars"))
-    end
-    
-    JRUBY_JAR_DIR = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-    
-    JRUBY = [
-      "/jruby/jcodings.jar",
-      "/jruby/jdom.jar",
-      "/jruby/joni.jar"
-    ]
-
-    JRUBY << "http://jruby.org.s3.amazonaws.com/downloads/1.5.2/jruby-complete-1.5.2.jar"
-    
-    JOPENSSL_DIR = File.expand_path(File.join(File.dirname(__FILE__), "..", "openssl/lib/")) 
-    JOPENSSL = {
-      "/jruby/bcmail-jdk14-139-redcar1.jar" => "bcmail-jdk14-139.jar",
-      "/jruby/bcprov-jdk14-139-redcar1.jar" => "bcprov-jdk14-139.jar",
-      "/jruby/jopenssl-redcar1.jar"         => "jopenssl.jar",
-    }
-
-    REDCAR_JARS = {
-      "/java-mateview-#{Redcar::VERSION}.jar" => "plugins/edit_view_swt/vendor/java-mateview.jar",
-      "/application_swt-#{Redcar::VERSION}.jar" => "plugins/application_swt/lib/dist/application_swt.jar",
-      "/clojure-1.2beta1.jar" => "plugins/repl/vendor/clojure.jar",
-      "/clojure-contrib-1.2beta1.jar" => "plugins/repl/vendor/clojure-contrib.jar",
-      "/org-enclojure-repl-server.jar" => "plugins/repl/vendor/org-enclojure-repl-server.jar"
-      
-    }
-    
-    def xulrunner_uri
-      "http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/#{xulrunner_version}/runtimes/xulrunner-#{xulrunner_version}.en-US.win32.zip"
-    end
-
-    SWT_JARS = {
-      :osx     => {
-        "/swt/osx.jar"     => "osx/swt.jar",
-        "/swt/osx64.jar"   => "osx64/swt.jar"
-      },
-      :linux   => {
-        "/swt/linux.jar"   => "linux/swt.jar",
-        "/swt/linux64.jar" => "linux64/swt.jar"
-      },
-      :windows => {
-        "/swt/win32.jar"   => "win32/swt.jar",
+    def fetch_all_assets
+      assets = assets_by_platform[:all].merge(assets_by_platform[Redcar.platform])
+      assets.each {|source, target| fetch_asset(source, target) }
+    end
+    
+    def assets_by_platform
+      { :all => {
+          "http://jruby.org.s3.amazonaws.com/downloads/1.5.2/jruby-complete-1.5.2.jar" => "/jruby-complete-1.5.2.jar",
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.core.commands.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.core.runtime_3.5.0.v20090525.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.equinox.common.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.jface.databinding_1.3.0.I20090525-2000.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.jface.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.jface.text_3.5.0.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.osgi.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.text_3.5.0.v20090513-2000.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.core.resources.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jface/org.eclipse.core.jobs.jar" => nil,
+          "http://redcar.s3.amazonaws.com/jruby/jcodings.jar" => "/jcodings.jar",
+          "http://redcar.s3.amazonaws.com/jruby/jdom.jar" => "/jdom.jar",
+          "http://redcar.s3.amazonaws.com/jruby/joni.jar" => "/joni.jar",
+          "http://redcar.s3.amazonaws.com/jruby/bcmail-jdk14-139-redcar1.jar" => "/bcmail-jdk14-139.jar",
+          "http://redcar.s3.amazonaws.com/jruby/bcprov-jdk14-139-redcar1.jar" => "/bcprov-jdk14-139.jar",
+          "http://redcar.s3.amazonaws.com/jruby/jopenssl-redcar1.jar"         => "/jopenssl.jar",
+          "http://redcar.s3.amazonaws.com/java-mateview-#{Redcar::VERSION}.jar" => nil,
+          "http://redcar.s3.amazonaws.com/application_swt-#{Redcar::VERSION}.jar" => nil,
+          "http://redcar.s3.amazonaws.com/clojure-1.2beta1.jar" => nil,
+          "http://redcar.s3.amazonaws.com/clojure-contrib-1.2beta1.jar" => nil,
+          "http://redcar.s3.amazonaws.com/org-enclojure-repl-server.jar" => nil
+        },
+        :windows => {
+          "http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/#{xulrunner_version}/runtimes/xulrunner-#{xulrunner_version}.en-US.win32.zip" => "xulrunner-#{xulrunner_version}.en-US.win32.zip",
+          "http://redcar.s3.amazonaws.com/swt/win32.jar"   => nil,
+        },
+        :linux => {
+          "http://redcar.s3.amazonaws.com/swt/linux.jar"     => nil,
+          "http://redcar.s3.amazonaws.com/swt/linux64.jar"   => nil
+        },
+        :osx => {
+          "http://redcar.s3.amazonaws.com/swt/osx.jar"     => nil,
+          "http://redcar.s3.amazonaws.com/swt/osx64.jar"   => nil
+        }
       }
-    }
-    
-    def grab_jruby
-      puts "* Checking JRuby dependencies"
-      
-      setup "jruby",    :resources => JRUBY,    :path => JRUBY_JAR_DIR
-      setup "jopenssl", :resources => JOPENSSL, :path => JOPENSSL_DIR
     end
     
-    def grab_common_jars
-      puts "* Checking common jars"
-      
-      setup "jface", :resources => JFACE, :path => File.join(plugins_dir, %w(application_swt vendor jface))
+    def fetch_asset(source, target)
+      relative_target   = target || implicit_target(source)
+      absolute_target   = File.join(Redcar.asset_dir, relative_target)
+      return if File.exist?(absolute_target)
+      download_file_to(source, absolute_target)
+      unzip_file(absolute_target) if absolute_target =~ /\.zip$/
     end
     
-    def grab_platform_dependencies
-      puts "* Checking platform-specific SWT jars"
-      case Config::CONFIG["host_os"]
-      when /darwin/i
-        setup "swt", :resources => SWT_JARS[:osx],     :path => File.join(plugins_dir, %w(application_swt vendor swt))
-
-      when /linux/i
-        setup "swt", :resources => SWT_JARS[:linux],   :path => File.join(plugins_dir, %w(application_swt vendor swt))
-
-      when /windows|mswin|mingw/i
-        setup "swt", :resources => SWT_JARS[:windows], :path => File.join(plugins_dir, %w(application_swt vendor swt))
-        setup "swt", :resources => [xulrunner_uri],    :path => File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. vendor)))
-        link( File.join(redcar_jars_dir, "xulrunner"),
-              File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. vendor xulrunner))))
-      end
+    def implicit_target(source)
+      URI.parse(source).path.gsub(/^\//, "")
     end
     
-    def grab_redcar_jars
-      puts "* Checking Redcar jars"
-      setup "redcar", :resources => REDCAR_JARS, :path => File.join(File.dirname(__FILE__), "..", "..")
-    end
-    
-    def download(uri, path)
-      if uri =~ /^\//
-        uri = ASSET_HOST + uri
-      end
+    def download_file_to(uri, destination_file)
       print "  downloading #{uri}... "; $stdout.flush
-      FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, "wb") do |write_out|
+      temporary_target  = destination_file + ".part"
+      FileUtils.mkdir_p(File.dirname(destination_file))
+      File.open(temporary_target, "wb") do |write_out|
         write_out.print @connection.get(URI.parse(uri))
       end
       
-      if File.open(path).read(200) =~ /Access Denied/
+      if File.open(temporary_target).read(200) =~ /Access Denied/
         puts "\n\n*** Error downloading #{uri}, got Access Denied from S3."
-        FileUtils.rm_rf(path)
+        FileUtils.rm_rf(temporary_target)
         exit
       end
       
-      if path =~ /.*\.zip$/
-      	print "done!\n  unzipping  #{path}..."; $stdout.flush
-      	Installer.unzip_file(path)
-      end
+      FileUtils.cp(temporary_target, destination_file)
+      FileUtils.rm_rf(temporary_target)
       puts "done!"
     end
     
-    def setup(name, options)
-      resources   = options.delete(:resources)
-      target_dir  = options.delete(:path)
-      
-      if resources.is_a?(Array)
-        resources.each do |resource|
-          setup_resource(name, target_dir, resource, File.basename(resource))
-        end
-      else
-        resources.each do |url_path, target_path|
-          setup_resource(name, target_dir, url_path, target_path)
-        end
-      end
-    end
-    
-    def setup_resource(name, target_dir, url_path, target_path)
-      target_file = File.join(target_dir, target_path)
-      return if File.exist?(target_file)
-      
-      cached = File.join(redcar_jars_dir, File.basename(url_path))
-      unless File.exists?(cached)
-        download(url_path, cached)
-      end
-
-      FileUtils.mkdir_p File.dirname(target_file)
-      link(cached, target_file)
-    end
-
-    def link(cached, target)
-      # Windoze doesn't support FileUtils.ln_sf, so we copy the files
-      if Config::CONFIG["host_os"] =~ /windows|mswin|mingw/i
-        print "  copying #{File.basename(cached)}... "
-        $stdout.flush
-        FileUtils.cp_r cached, target
-        puts "done"
-      else
-        print "  linking #{File.basename(cached)}... "
-        $stdout.flush
-        FileUtils.ln_sf cached, target
-        puts "done"
-      end
-    end
-    
     # unzip a .zip file into the directory it is located
-    def self.unzip_file(source)
-      source = File.expand_path(source)
+    def unzip_file(path)
+      print "unzipping #{path}..."; $stdout.flush
+      source = File.expand_path(path)
       Dir.chdir(File.dirname(source)) do
         Zip::ZipFile.open(source) do |zipfile|
           zipfile.entries.each do |entry|
             FileUtils.mkdir_p(File.dirname(entry.name))
-          	begin
+            begin
               entry.extract
             rescue Zip::ZipDestinationFileExistsError
             end
@@ -243,22 +124,15 @@ module Redcar
       end
     end
     
-    def load_textmate_bundles
-      $:.unshift("#{File.dirname(__FILE__)}/../../plugins/core/lib")
-      $:.unshift("#{File.dirname(__FILE__)}/../../plugins/textmate/lib")
-      require 'core'
-      Redcar.environment = :user
-      Core.loaded
-      require 'textmate'
-      Redcar::Textmate.all_bundles
-    end
-    
-    def fix_user_dir_permissions
-      desired_uid = File.stat(Redcar.home_dir).uid
-      desired_gid = File.stat(Redcar.home_dir).gid
-      FileUtils.chown_R(desired_uid, desired_gid.to_s, Redcar.user_dir)
+    def precache_textmate_bundles
+      puts "Precaching textmate bundles..."
+      Runner.new.construct_command(["--no-gui", "--compute-textmate-cache-and-quit", "--multiple-instance"]) do |cmd|
+        %x{#{cmd.join(' ')}}
+      end
     end
     
+    # Xulrunner releases don't hang around very long, so we scrape their site to figure out 
+    # which one to download this time.
     def xulrunner_version
       @xulrunner_version ||= begin
         html = @connection.get(URI.parse("http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/"))

data/lib/redcar/jvm_options_probe.rb

@@ -0,0 +1,33 @@
+require "open3"
+ 
+class JvmOptionsProbe
+ 
+  def initialize
+    @d32 = @d64 = @client = false
+
+    if Redcar.platform == :windows
+      @help = `java -h`
+      @d32 = (@help == `java -d32`) ? true : false
+      @d64 = (@help == `java -d64`) ? true : false
+      @client = (@help == `java -client`) ? true : false
+    else
+      @help = Open3.popen3("java -h")[2].readlines
+      @d32 = (@help == Open3.popen3("java -d32")[2].readlines) ? true : false
+      @d64 = (@help == Open3.popen3("java -d64")[2].readlines) ? true : false
+      @client = (@help == Open3.popen3("java -client")[2].readlines) ? true : false
+    end
+  end
+ 
+  def can_use_d32?
+    @d32
+  end
+ 
+  def can_use_d64?
+    @d64
+  end
+ 
+  def can_use_client?
+    @client
+  end
+end
+

data/lib/redcar/runner.rb

@@ -1,33 +1,94 @@
 module Redcar
   # Cribbed from ruby-processing. Many thanks!
   class Runner
+    def run
+      forking = ARGV.include?("--fork")
+      no_runner = ARGV.include?("--no-sub-jruby")
+      jruby = Config::CONFIG["RUBY_INSTALL_NAME"] == "jruby"
+      osx = (not [:linux, :windows].include?(Redcar.platform))
+      begin
+        if forking and not jruby
+          # jRuby doesn't support fork() because of the runtime stuff...
+          forking = false
+          puts 'Forking failed, attempting to start anyway...' if (pid = fork) == -1
+          exit unless pid.nil? # kill the parent process
+          
+          if pid.nil?
+            # reopen the standard pipes to nothingness
+            STDIN.reopen Redcar.null_device
+            STDOUT.reopen Redcar.null_device, 'a'
+            STDERR.reopen STDOUT
+          end
+        elsif forking and SPOON_AVAILABLE and ::Spoon.supported?
+          # so we need to try something different...
+          
+          forking = false
+          construct_command do |command|
+            command.push('--silent')
+            ::Spoon.spawnp(*command)
+          end
+          exit 0
+        elsif forking
+          raise NotImplementedError, "Something weird has happened. Please contact us."
+        end
+      rescue NotImplementedError
+        puts $!.class.name + ": " + $!.message
+        puts "Forking isn't supported on this system. Sorry."
+        puts "Starting normally..."
+      end
+      
+      return if no_runner
+      return if jruby and not osx
+      
+      construct_command do |command|
+        exec(command.join(" "))
+      end
+    end
+    
     # Trade in this Ruby instance for a JRuby instance, loading in a 
     # starter script and passing it some arguments.
     # If --jruby is passed, use the installed version of jruby, instead of 
     # our vendored jarred one (useful for gems).
-    def spin_up
-      bin = "#{File.dirname(__FILE__)}/../../bin/redcar"
-      jruby_complete = File.expand_path(File.join(File.dirname(__FILE__), "..", "jruby-complete-1.5.2.jar"))
+    def construct_command(args="")
+      bin = File.expand_path(File.join(File.dirname(__FILE__), %w{.. .. bin redcar}))
+      jruby_complete = File.expand_path(File.join(Redcar.asset_dir, "jruby-complete-1.5.2.jar"))
       unless File.exist?(jruby_complete)
         puts "\nCan't find jruby jar at #{jruby_complete}, did you run 'redcar install' ?"
         exit 1
       end
       ENV['RUBYOPT'] = nil # disable other native args
-      # add -d32 -client for faster startup if the jvm is defaulting to server/64bit mode
-      command = "java #{java_args} -Xmx500m -Xss1024k -Djruby.memory.max=500m -Djruby.stack.max=1024k -cp \"#{jruby_complete}\" org.jruby.Main #{"--debug" if debug_mode?} \"#{bin}\" #{cleaned_args} --no-sub-jruby --ignore-stdin"
-      puts command
-      exec(command)
+
+      # Windows XP updates
+      if [:windows].include?(Redcar.platform)
+	bin = "\"#{bin}\""
+	jruby_complete = "\"#{jruby_complete}\""
+      end      
+
+      # unfortuanately, ruby doesn't support [a, *b, c]
+      command = ["java"]
+      command.push(*java_args)
+      command.push("-Xmx500m", "-Xss1024k", "-Djruby.memory.max=500m", "-Djruby.stack.max=1024k", "-cp", jruby_complete, "org.jruby.Main")
+      command.push "--debug" if debug_mode?
+      command.push(bin)
+      command.push(*cleaned_args)
+      command.push("--no-sub-jruby", "--ignore-stdin")
+      command.push(*args)
+      
+      puts command.join(' ')
+      yield command
     end
     
     def cleaned_args
       # We should never pass --fork to a subprocess
-      ARGV.find_all {|arg| arg != '--fork'}.map do |arg|
+      result = ARGV.find_all {|arg| arg != '--fork'}.map do |arg|
         if arg =~ /--(.+)=(.+)/
           "--" + $1 + "=\"" + $2 + "\""
         else
           arg
         end
-      end.join(' ')
+      end
+      result.delete("install")
+      result
     end
     
     def debug_mode?
@@ -35,18 +96,22 @@ module Redcar
     end
     
     def java_args
-      str = ""
+      str = []
       if Config::CONFIG["host_os"] =~ /darwin/
-        str <<"-XstartOnFirstThread"
+        str.push "-XstartOnFirstThread"
       end
       
       if ARGV.include?("--load-timings")
-        str << " -Djruby.debug.loadService.timing=true"
+        str.push "-Djruby.debug.loadService.timing=true"
       end
+
+      require 'redcar/jvm_options_probe'
+      
+      jvm_options_probe = JvmOptionsProbe.new
+      
+      str.push "-d32" if jvm_options_probe.can_use_d32?
+      str.push "-client" if jvm_options_probe.can_use_client?
       
-      if ARGV.include?("--quick")
-        str << " -d32 -client"
-      end
       str
     end
   end