ruby-virtualenv 0.5.0 → 0.5.1

data/lib/sandbox/version.rb

@@ -1,3 +1,3 @@
 module Sandbox
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/ruby-virtualenv.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["nkryptic@gmail.com", "francesc.esplugas@gmail.com"]
   gem.description   = %q{Create virtual ruby/rubygems environments.}
   gem.summary       = %q{Create virtual ruby/rubygems environments.}
-  gem.homepage      = "http://github.com/fesplugas/ruby-virtualenv"
+  gem.homepage      = "https://github.com/fesplugas/ruby-virtualenv"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")

data/spec/sandbox/cli_spec.rb

@@ -2,233 +2,231 @@ require 'spec_helper'
 require 'sandbox/cli'
 
 describe Sandbox::CLI do
-  
+
   it "should raise an error when running from a loaded sandbox" do
     begin
       ENV[ 'SANDBOX' ] = 'something'
-      lambda { Sandbox::CLI.verify_environment! }.should raise_error( Sandbox::LoadedSandboxError )
+      lambda { Sandbox::CLI.verify_environment! }.should raise_error(Sandbox::LoadedSandboxError)
     ensure
       ENV[ 'SANDBOX' ] = nil
     end
   end
-  
+
   describe "calling execute" do
-    before( :each ) do
+    before(:each) do
       @instance = stub_everything()
     end
-    
+
     it "should handle all errors" do
-      Sandbox::CLI.stubs( :new ).raises( StandardError )
-      Sandbox::CLI.expects( :handle_error ).with( instance_of( StandardError ) )
+      Sandbox::CLI.stubs(:new).raises(StandardError)
+      Sandbox::CLI.expects(:handle_error).with(instance_of(StandardError))
       Sandbox::CLI.execute
     end
-    
+
     it "should attempt to parse ARGV by default" do
-      Sandbox::CLI.expects( :parse ).with( ARGV ).returns( @instance )
+      Sandbox::CLI.expects(:parse).with(ARGV).returns(@instance)
       Sandbox::CLI.execute
     end
-    
+
     it "should create a new instance" do
-      Sandbox::CLI.expects( :new ).returns( @instance )
+      Sandbox::CLI.expects(:new).returns(@instance)
       Sandbox::CLI.execute
     end
-    
+
     it "should call parse_args! on the new instance" do
-      @instance.expects( :parse_args! )
-      Sandbox::CLI.expects( :new ).returns( @instance )
+      @instance.expects(:parse_args!)
+      Sandbox::CLI.expects(:new).returns(@instance)
       Sandbox::CLI.execute
     end
-    
+
     it "should run the instance" do
-      @instance.expects( :execute! )
-      Sandbox::CLI.expects( :parse ).returns( @instance )
+      @instance.expects(:execute!)
+      Sandbox::CLI.expects(:parse).returns(@instance)
       Sandbox::CLI.execute
     end
   end
-  
+
   describe "handling errors" do
     it "should just print Sandbox::Error message" do
-      err = Sandbox::Error.new( "spec test msg" )
-      Sandbox::CLI.expects( :tell_unless_really_quiet ).once.with( regexp_matches( /^Sandbox error: spec test msg/ ) )
-      Sandbox::CLI.handle_error( err )
+      err = Sandbox::Error.new("spec test msg")
+      Sandbox::CLI.expects(:tell_unless_really_quiet).once.with(regexp_matches(/^spec test msg/))
+      Sandbox::CLI.handle_error(err)
     end
-    
+
     it "should just print wrapped StandardError message" do
-      err = StandardError.new( "spec test msg" )
-      Sandbox::CLI.expects( :tell_unless_really_quiet ).once.with( regexp_matches( /^Error: spec test msg/ ) )
-      Sandbox::CLI.handle_error( err )
+      err = StandardError.new("spec test msg")
+      Sandbox::CLI.expects(:tell_unless_really_quiet).once.with(regexp_matches(/^Error: spec test msg/))
+      Sandbox::CLI.handle_error(err)
     end
-    
+
     it "should have simple message for Interrupt" do
-      err = Interrupt.new( "spec test msg" )
-      Sandbox::CLI.expects( :tell_unless_really_quiet ).once.with( 'Interrupted' )
-      Sandbox::CLI.handle_error( err )
+      err = Interrupt.new("spec test msg")
+      Sandbox::CLI.expects(:tell_unless_really_quiet).once.with('Interrupted')
+      Sandbox::CLI.handle_error(err)
     end
-    
+
     it "should reraise other errors" do
-      err = NotImplementedError.new( 'you should have implemented it, dummy' )
-      Sandbox::CLI.expects( :raise ).once.with( err )
-      Sandbox::CLI.handle_error( err )
+      err = NotImplementedError.new('you should have implemented it, dummy')
+      Sandbox::CLI.expects(:raise).once.with(err)
+      Sandbox::CLI.handle_error(err)
     end
   end
-  
+
   describe "a new instance" do
-    
-    before( :each ) do
+
+    before(:each) do
       @cli = Sandbox::CLI.new
     end
-    
+
     it "should have no default 'gems to install'" do
-      @cli.options[ :gems ].should == []
+      @cli.options[:gems].should == []
     end
-    
+
     describe "instance calling parse_args!" do
-      def processor( *args ); lambda { @cli.parse_args!( args ) }; end
-      def process( *args ); processor( *args ).call; end
-  
+      def processor(*args); lambda { @cli.parse_args!(args) }; end
+      def process(*args); processor(*args).call; end
+
       describe "using NO arguments" do
         it "should use raise nothing" do
-          process()
-          @cli.options[ :original_args ].should == []
-          @cli.options[ :args ].should == []
+          process
+          @cli.options[:original_args].should == []
+          @cli.options[:args].should == []
         end
       end
-  
+
       describe "using VALID arguments" do
         [ '-V', '--version' ].each do |arg|
           it "should print the version for switch '#{arg}'" do
-            @cli.expects( :tell_unless_really_quiet ).with( Sandbox::VERSION )
-            processor( arg ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            @cli.expects(:tell_unless_really_quiet).with(Sandbox::VERSION)
+            processor(arg).should raise_error(SystemExit) { |error| error.status.should == 0 }
           end
         end
-          
+
         [ '-V', '--version' ].each do |arg|
           it "should ignore additional arguments after '#{arg}'" do
-            # @cli.stubs(:puts)
-            @cli.expects( :tell_unless_really_quiet ).with( Sandbox::VERSION ).times(2)
-            processor( arg, '-x' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
-            processor( arg, 'unknown' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            @cli.expects(:tell_unless_really_quiet).with(Sandbox::VERSION).times(2)
+            processor(arg, '-x').should raise_error(SystemExit) { |error| error.status.should == 0 }
+            processor(arg, 'unknown').should raise_error(SystemExit) { |error| error.status.should == 0 }
           end
         end
-          
+
         [ '-h', '--help' ].each do |arg|
           it "should show help for '#{arg}'" do
-            @cli.expects( :tell_unless_really_quiet ).with( instance_of( OptionParser ) )
-            processor( arg ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            @cli.expects(:tell_unless_really_quiet).with(instance_of(OptionParser))
+            processor(arg).should raise_error(SystemExit) { |error| error.status.should == 0 }
           end
         end
-          
+
         [ '-h', '--help' ].each do |arg|
           it "should ignore additional arguments after '#{arg}'" do
-            @cli.expects( :tell_unless_really_quiet ).with( instance_of( OptionParser ) ).times(2)
-            processor( arg, '-x' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
-            processor( arg, 'unknown' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            @cli.expects(:tell_unless_really_quiet).with(instance_of(OptionParser)).times(2)
+            processor(arg, '-x').should raise_error(SystemExit) { |error| error.status.should == 0 }
+            processor(arg, 'unknown').should raise_error(SystemExit) { |error| error.status.should == 0 }
           end
         end
-        
+
         [ '-H', '--long-help' ].each do |arg|
           it "should show long help for '#{arg}'" do
-            @cli.expects( :tell_unless_really_quiet )
-            @cli.expects( :long_help )
-            processor( arg ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            @cli.expects(:tell_unless_really_quiet)
+            @cli.expects(:long_help)
+            processor(arg).should raise_error(SystemExit) { |error| error.status.should == 0 }
           end
         end
-          
+
         [ '-v', '--verbose' ].each do |arg|
           it "should increase verbosity with '#{arg}'" do
-            Sandbox.expects( :increase_verbosity )
-            process( arg )
-            @cli.options[ :original_args ].should == [ arg ]
-            @cli.options[ :args ].should == []
+            Sandbox.expects(:increase_verbosity)
+            process(arg)
+            @cli.options[:original_args].should == [arg]
+            @cli.options[:args].should == []
           end
         end
-        
-        [ [ '-v', '-v' ], [ '--verbose', '--verbose' ] ].each do |args|
+
+        [['-v', '-v'], ['--verbose', '--verbose'] ].each do |args|
           it "should increase verbosity twice with '#{args.join(' ')}'" do
-            Sandbox.expects( :increase_verbosity ).times(2)
-            process( *args )
-            @cli.options[ :original_args ].should == args
-            @cli.options[ :args ].should == []
+            Sandbox.expects(:increase_verbosity).times(2)
+            process(*args)
+            @cli.options[:original_args].should == args
+            @cli.options[:args].should == []
           end
         end
-        
+
         it "should require additional arguments with switch '-g'" do
-          processor( '-g' ).should raise_error( Sandbox::ParseError )
+          processor('-g').should raise_error(Sandbox::ParseError)
         end
-        
+
         it "should set 'gems to install' with switch '-g'" do
-          args = [ '-g', 'somegem,anothergem' ]
-          process( *args )
-          @cli.options[ :original_args ].should == args
-          @cli.options[ :args ].should == []
-          @cli.options[ :gems ].should == [ 'somegem', 'anothergem' ]
+          args = ['-g', 'somegem,anothergem']
+          process(*args)
+          @cli.options[:original_args].should == args
+          @cli.options[:args].should == []
+          @cli.options[:gems].should == ['somegem', 'anothergem']
         end
-        
+
         it "should clear 'gems to install' with switch '-n'" do
-          process( '-n' )
-          @cli.options[ :original_args ].should == [ '-n' ]
-          @cli.options[ :args ].should == []
-          @cli.options[ :gems ].should == []
+          process('-n')
+          @cli.options[:original_args].should == ['-n']
+          @cli.options[:args].should == []
+          @cli.options[:gems].should == []
         end
-        
+
         it "should store leftover arguments in options for arguments '/path/to/somewhere'" do
-          args = [ '/path/to/somewhere' ]
-          process( *args )
-          @cli.options[ :original_args ].should == args
-          @cli.options[ :args ].should == args
+          args = ['/path/to/somewhere']
+          process(*args)
+          @cli.options[:original_args].should == args
+          @cli.options[:args].should == args
         end
         
         it "should store leftover arguments in options for arguments '-v /path/to/somewhere'" do
-          args = [ '-v', '/path/to/somewhere' ]
-          process( *args )
-          @cli.options[ :original_args ].should == args
-          @cli.options[ :args ].should == [ args.last ]
+          args = ['-v', '/path/to/somewhere']
+          process(*args)
+          @cli.options[:original_args].should == args
+          @cli.options[:args].should == [args.last]
         end
       end
-  
+
       describe "using INVALID arguments" do
         it "should exit with message for invalid switch '-x'" do
-          processor( '-x' ).
-              should raise_error( Sandbox::ParseError ) { |error| error.message.should =~ /-x\b/ }
+          processor('-x').
+              should raise_error(Sandbox::ParseError) { |error| error.message.should =~ /-x\b/ }
         end
       end
     end
-    
+
     describe "instance calling execute!" do
       def processor; lambda { @cli.execute! }; end
       def process; processor.call; end
-      
+
       it "should raise error with no target specified" do
-        @cli.options[ :args ] = []
+        @cli.options[:args] = []
         processor.should raise_error
       end
-      
+
       it "should raise error with more than one target" do
-        @cli.options[ :args ] = [ 'one', 'two' ]
+        @cli.options[:args] = ['one', 'two']
         processor.should raise_error
       end
-      
+
       it "should instantiate an Installer and call populate with one target" do
-        @cli.options.delete( :gems )
-        @cli.options[ :args ] = [ 'one' ]
-        installer = mock( 'Installer', :populate )
-        Sandbox::Installer.expects( :new ).with( { :target => 'one' } ).returns( installer )
+        @cli.options.delete(:gems)
+        @cli.options[:args] = ['one']
+        installer = mock('Installer', :populate)
+        Sandbox::Installer.expects(:new).with({:target=>'one'}).returns(installer)
         process
       end
-      
+
     end
-    
+
     describe "instance calling long_help" do
       it "should return a long descriptive string" do
-        @cli.long_help.split( "\n" ).size.should be > 20
+        @cli.long_help.split("\n").size.should be > 20
         @cli.long_help.should =~ /activate/
         @cli.long_help.should =~ /deactivate/
         @cli.long_help.should =~ /NOTES:/
         @cli.long_help.should =~ /WARNINGS:/
       end
     end
-    
+
   end
-  
-end
 
+end

data/spec/sandbox/errors_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe 'new', Sandbox::Error do
   it "should wrap it's message with 'Sandbox error'" do
-    Sandbox::Error.new( 'msg' ).message.should == 'Sandbox error: msg'
+    Sandbox::Error.new('msg').message.should == 'msg'
   end
 end
 
@@ -14,19 +14,15 @@ end
 
 describe 'new', Sandbox::ParseError do
   it "should accept reason with array" do
-    Sandbox::ParseError.new( 'testing', [ 1, 2, 3, 4 ] ).
-        message.should =~ /testing => 1 2 3 4/
+    Sandbox::ParseError.new('testing', [1, 2, 3, 4]).message.should =~ /testing => 1 2 3 4/
   end
 
   it "should accept reason with string" do
-    Sandbox::ParseError.new( 'testing', "1, 2, 3, 4" ).
-        message.should =~ /testing => 1, 2, 3, 4/
+    Sandbox::ParseError.new('testing', "1, 2, 3, 4").message.should =~ /testing => 1, 2, 3, 4/
   end
 
   it "should fall back to reason alone" do
-    Sandbox::ParseError.new( 'testing', [] ).
-        message.should =~ /testing$/
-    Sandbox::ParseError.new( 'testing', '' ).
-        message.should =~ /testing$/
+    Sandbox::ParseError.new('testing', []).message.should =~ /testing$/
+    Sandbox::ParseError.new('testing', '').message.should =~ /testing$/
   end
 end

data/spec/sandbox/installer_spec.rb

@@ -1,259 +1,249 @@
 require 'spec_helper'
 
 describe Sandbox::Installer, "(mocked)" do
-  
-  before( :each ) do
+
+  before(:each) do
     Sandbox.instance_eval { instance_variables.each { |v| remove_instance_variable v } }
   end
-  
+
   describe "creating an instance" do
-    # initialize( options={} )
     it "should set it's options" do
       opts = { :somewhere => true, :nowhere => false }
-      installer = Sandbox::Installer.new( opts )
-      installer.options[ :somewhere ].should be_true
-      installer.options[ :nowhere ].should be_false
+      installer = Sandbox::Installer.new(opts)
+      installer.options[:somewhere].should be_true
+      installer.options[:nowhere].should be_false
     end
   end
-  
+
   describe "instance" do
-    # target
     describe "when target called" do
       it "should validate target directory once" do
         path = '/some/new/target'
         opts = { :target => path }
-        @installer = Sandbox::Installer.new( opts )
-        @installer.expects( :resolve_target ).with( path ).once.then.returns( path )
+        @installer = Sandbox::Installer.new(opts)
+        @installer.expects(:resolve_target).with(path).once.then.returns(path)
         @installer.target.should == path
         @installer.target.should == path
       end
     end
 
-    # populate
     describe "when populate called" do
       it "should call all steps of populate process" do
         @installer = Sandbox::Installer.new
-        @installer.stubs( :tell )
-        @installer.stubs( :target ).returns( '/tmp/sandbox' )
-        @installer.expects( :create_directories )
-        @installer.expects( :install_scripts )
-        @installer.expects( :install_gemrc )
-        @installer.expects( :install_gems )
+        @installer.stubs(:tell)
+        @installer.stubs(:target).returns('/tmp/sandbox')
+        @installer.expects(:create_directories)
+        @installer.expects(:install_scripts)
+        @installer.expects(:install_gemrc)
+        @installer.expects(:install_gems)
         @installer.populate
       end
     end
 
-    # create_directories
     describe "when create_directories called" do
-      before( :each ) do
+      before(:each) do
         @path = '/some/new/target'
         @installer = Sandbox::Installer.new
-        @installer.stubs( :target ).returns( @path )
+        @installer.stubs(:target).returns(@path)
       end
       it "should create sandbox directory structure" do
-        FileUtils.expects( :mkdir_p ).with( @path + '/rubygems/bin' )
-        FileUtils.stubs( :ln_s )
+        FileUtils.expects(:mkdir_p).with(@path + '/rubygems/bin')
+        FileUtils.stubs(:ln_s)
         @installer.create_directories
       end
       
       it "should symlink gem bin directory" do
-        FileUtils.stubs( :mkdir_p )
-        FileUtils.expects( :ln_s ).with( @path + '/rubygems/bin', @path + '/bin' )
+        FileUtils.stubs(:mkdir_p)
+        FileUtils.expects(:ln_s).with(@path + '/rubygems/bin', @path + '/bin')
         @installer.create_directories
       end
     end
 
-    # install_scripts
     describe "when install_scripts called" do
-      before( :each ) do
+      before(:each) do
         @path = '/some/new/target'
         @installer = Sandbox::Installer.new
-        @installer.stubs( :target ).returns( @path )
+        @installer.stubs(:target).returns(@path)
       end
-      
+
       it "should read template file" do
-        File.expects( :read ).with( regexp_matches( /templates\/activate\.erb/ ) ).returns( '<%= target %>' )
-        File.stubs( :open )
+        File.expects(:read).with(regexp_matches(/templates\/activate\.erb/)).returns('<%= target %>')
+        File.stubs(:open)
         @installer.install_scripts
       end
-      
+
       it "should write out activate script to SANDBOX/bin/activate" do
         file = StringIO.new
-        File.stubs( :read ).returns( '<%= target %>' )
-        File.expects( :open ).with( @path + '/bin/activate', 'w' ).yields( file )
+        File.stubs(:read).returns('<%= target %>')
+        File.expects(:open).with(@path + '/bin/activate', 'w').yields(file)
         @installer.install_scripts
         file.string.should == @path
       end
     end
-    
-    # install_gemrc
+
     describe "when install_gemrc called" do
-      before( :each ) do
+      before(:each) do
         @path = '/some/new/target'
         @installer = Sandbox::Installer.new
-        @installer.stubs( :target ).returns( @path )
+        @installer.stubs(:target).returns(@path)
       end
-      
+
       it "should read template file" do
-        File.expects( :read ).with( regexp_matches( /templates\/gemrc\.erb/ ) ).returns( '' )
-        File.stubs( :open )
+        File.expects(:read).with(regexp_matches(/templates\/gemrc\.erb/)).returns('')
+        File.stubs(:open)
         @installer.install_gemrc
       end
-      
+
       it "should write out gemrc to SANDBOX/.gemrc" do
         file = StringIO.new
-        File.stubs( :read ).returns( 'gemrc' )
-        File.expects( :open ).with( @path + '/.gemrc', 'w' ).yields( file )
+        File.stubs(:read).returns('gemrc')
+        File.expects(:open).with(@path + '/.gemrc', 'w').yields(file)
         @installer.install_gemrc
         file.string.should == 'gemrc'
       end
     end
 
-    # install_gems
     describe "when install_gems called" do
-      before( :each ) do
-        @installer = Sandbox::Installer.new( :gems => [ 'mygem' ] )
-        @installer.stubs( :setup_sandbox_env )
-        @installer.stubs( :restore_sandbox_env )
-        @installer.stubs( :tell )
-        @installer.stubs( :tell_unless_really_quiet )
+      before(:each) do
+        @installer = Sandbox::Installer.new(:gems => [ 'mygem' ])
+        @installer.stubs(:setup_sandbox_env)
+        @installer.stubs(:restore_sandbox_env)
+        @installer.stubs(:tell)
+        @installer.stubs(:tell_unless_really_quiet)
       end
-      
-      # it "should skip install when network is not available" do
-      #   Ping.expects( :pingecho ).with( 'gems.rubyforge.org' ).returns( false )
-      #   @installer.install_gems.should be_false
-      # end
-      
+
+      xit "should skip install when network is not available" do
+        Ping.expects(:pingecho).with('gems.rubyforge.org').returns(false)
+        @installer.install_gems.should be_false
+      end
+
       it "should install a good gem" do
-        @installer.expects( :shell_out ).with( 'gem install mygem' ).returns( [ true, 'blah' ] )
+        @installer.expects(:shell_out).with('gem install mygem').returns([ true, 'blah' ])
         @installer.install_gems
       end
-      
+
       it "should gracefully handle a bad gem" do
-        @installer.expects( :shell_out ).with( 'gem install mygem' ).returns( [ false, 'blah' ] )
-        @installer.expects( :tell_unless_really_quiet ).with( regexp_matches( /failed/ ) )
+        @installer.expects(:shell_out).with('gem install mygem').returns([ false, 'blah' ])
+        @installer.expects(:tell_unless_really_quiet).with(regexp_matches(/failed/))
         @installer.install_gems
       end
     end
 
-    # resolve_target( path )
     describe "when resolve_target called" do
-      before( :each ) do
+      before(:each) do
         @path = '/absolute/path/to/parent'
         @installer = Sandbox::Installer.new
-        @installer.stubs( :fix_path ).returns( @path )
+        @installer.stubs(:fix_path).returns(@path)
       end
-      
+
       it "should raise error when it path exists" do
-        File.expects( :exists? ).with( @path ).returns( true )
-        lambda { @installer.resolve_target( @path ) }.should raise_error( Sandbox::Error )
+        File.expects(:exists?).with(@path).returns(true)
+        lambda { @installer.resolve_target(@path) }.should raise_error(Sandbox::Error)
       end
-      
+
       it "should return path when parent directory passes check_path!" do
-        File.expects( :exists? ).with( @path ).returns( false )
-        @installer.expects( :check_path! ).with( '/absolute/path/to' ).returns( true )
-        @installer.resolve_target( @path ).should == @path
+        File.expects(:exists?).with(@path).returns(false)
+        @installer.expects(:check_path!).with('/absolute/path/to').returns(true)
+        @installer.resolve_target(@path).should == @path
       end
-      
+
       it "should return path when any parent directory passes check_path!" do
-        File.expects( :exists? ).with( @path ).returns( false )
-        @installer.expects( :check_path! ).with( '/absolute/path/to' ).returns( false )
-        @installer.expects( :check_path! ).with( '/absolute/path' ).returns( false )
-        @installer.expects( :check_path! ).with( '/absolute' ).returns( true )
-        @installer.resolve_target( @path ).should == @path
+        File.expects(:exists?).with(@path).returns(false)
+        @installer.expects(:check_path!).with('/absolute/path/to').returns(false)
+        @installer.expects(:check_path!).with('/absolute/path').returns(false)
+        @installer.expects(:check_path!).with('/absolute').returns(true)
+        @installer.resolve_target(@path).should == @path
       end
-      
+
       it "should have emergency safeguard for dirname on root" do
-        @installer.stubs( :fix_path ).returns( '/absolute' )
-        @installer.expects( :check_path! ).with( '/' ).returns( false )
-        lambda { @installer.resolve_target( '/absolute' ) }.should raise_error( RuntimeError )
+        @installer.stubs(:fix_path).returns('/absolute')
+        @installer.expects(:check_path!).with('/').returns(false)
+        lambda { @installer.resolve_target('/absolute') }.should raise_error(RuntimeError)
       end
     end
 
-    # check_path!( path )
     describe "when check_path! called" do
-      before( :each ) do
+      before(:each) do
         @path = '/absolute/path/to/parent'
         @installer = Sandbox::Installer.new
       end
-      
+
       it "should raise error when it is not writable" do
-        File.expects( :directory? ).with( @path ).returns( true )
-        File.expects( :writable? ).with( @path ).returns( false )
-        lambda { @installer.check_path!( @path ) }.should raise_error( Sandbox::Error )
+        File.expects(:directory?).with(@path).returns(true)
+        File.expects(:writable?).with(@path).returns(false)
+        lambda { @installer.check_path!(@path) }.should raise_error(Sandbox::Error)
       end
-      
+
       it "should raise error when it is not a directory" do
-        File.expects( :directory? ).with( @path ).returns( false )
-        File.expects( :exists? ).with( @path ).returns( true )
-        lambda { @installer.check_path!( @path ) }.should raise_error( Sandbox::Error )
+        File.expects(:directory?).with(@path).returns(false)
+        File.expects(:exists?).with(@path).returns(true)
+        lambda { @installer.check_path!(@path) }.should raise_error(Sandbox::Error)
       end
-      
+
       it "should return false when it doesn't exist" do
-        File.expects( :directory? ).with( @path ).returns( false )
-        File.expects( :exists? ).with( @path ).returns( false )
-        @installer.check_path!( @path ).should be_false
+        File.expects(:directory?).with(@path).returns(false)
+        File.expects(:exists?).with(@path).returns(false)
+        @installer.check_path!(@path).should be_false
       end
-      
+
       it "should return true when it can be created" do
-        File.expects( :directory? ).with( @path ).returns( true )
-        File.expects( :writable? ).with( @path ).returns( true )
-        @installer.check_path!( @path ).should == true
+        File.expects(:directory?).with(@path).returns(true)
+        File.expects(:writable?).with(@path).returns(true)
+        @installer.check_path!(@path).should == true
       end
     end
 
-    # fix_path( path )
     describe "when fix_path called" do
       it "should not change absolute path" do
         path = '/absolute/path/to/target'
         @installer = Sandbox::Installer.new
-        @installer.fix_path( path ).should == path
+        @installer.fix_path(path).should == path
       end
-      
+
       it "should make relative into absolute path" do
         abs_path = '/absolute/working/directory'
         path = 'relative/path/to/target'
-        FileUtils.expects( :pwd ).returns( abs_path )
+        FileUtils.expects(:pwd).returns(abs_path)
         @installer = Sandbox::Installer.new
-        @installer.fix_path( path ).should == abs_path + '/' + path
+        @installer.fix_path(path).should == abs_path + '/' + path
       end
     end
-    
-    # shell_out( cmd )
+
+
     describe "when shell_out called" do
       it "should record true when successful" do
         @installer = Sandbox::Installer.new
-        result = @installer.shell_out( 'true' )
+        result = @installer.shell_out('true')
         result.first.should be_true
       end
-      
+
       it "should record false when unsuccessful" do
         @installer = Sandbox::Installer.new
-        result = @installer.shell_out( 'false' )
+        result = @installer.shell_out('false')
         result.first.should_not be_true
       end
-      
+
       it "should record std output" do
         @installer = Sandbox::Installer.new
-        result = @installer.shell_out( 'ls -d /' )
+        result = @installer.shell_out('ls -d /')
         result.last.chomp.should == '/'
       end
-      
+
       it "should ignore std error" do
         @installer = Sandbox::Installer.new
-        result = @installer.shell_out( 'ls -d / 1>/dev/null' )
+        result = @installer.shell_out('ls -d / 1>/dev/null')
         result.last.chomp.should == ''
       end
     end
-    
+
     describe "setup and restore sandbox env called" do
       it "should set and restore the environment" do
         orig_home = ENV[ 'HOME' ]
         orig_gem_home = ENV[ 'GEM_HOME' ]
         orig_gem_path = ENV[ 'GEM_PATH' ]
         @installer = Sandbox::Installer.new
-        @installer.stubs( :target ).returns( 'dummypath' )
-        
+        @installer.stubs(:target).returns('dummypath')
+
         @installer.setup_sandbox_env
         ENV[ 'HOME' ].should == 'dummypath'
         ENV[ 'GEM_HOME' ].should == 'dummypath/rubygems'
@@ -264,40 +254,48 @@ describe Sandbox::Installer, "(mocked)" do
         ENV[ 'GEM_PATH' ].should == orig_gem_path
       end
     end
+
   end
 end
 
 describe Sandbox::Installer, "(using tmpdir)" do
-  def tmppath() File.join( Dir.tmpdir, "sandbox_testing" ) end
-  def rmtmppath() FileUtils.rm_rf( tmppath ) end
-  def mktmppath() FileUtils.mkdir_p( tmppath ) end
 
-  def in_dir( dir = tmppath )
+  def tmppath
+    File.join(Dir.tmpdir, "sandbox_testing")
+  end
+
+  def rmtmppath
+    FileUtils.rm_rf(tmppath)
+  end
+
+  def mktmppath
+    FileUtils.mkdir_p(tmppath)
+  end
+
+  def in_dir(dir = tmppath)
     old_pwd = Dir.pwd
     begin
-      Dir.chdir( dir )
+      Dir.chdir(dir)
       yield
     ensure
-      Dir.chdir( old_pwd )
+      Dir.chdir(old_pwd)
     end
   end
-  
-  before( :each ) do
+
+  before(:each) do
     mktmppath
   end
-  
-  after( :each ) do
+
+  after(:each) do
     rmtmppath
   end
-  
+
   it "should create target directory structure" do
     target = tmppath + '/target'
-    @installer = Sandbox::Installer.new( :target => target )
+    @installer = Sandbox::Installer.new(:target => target)
     @installer.create_directories
-    File.directory?( target + '/rubygems/bin' ).should be_true
-    File.symlink?( target + '/bin' ).should be_true
+    File.directory?(target + '/rubygems/bin').should be_true
+    File.symlink?(target + '/bin').should be_true
   end
-end
-
 
-  
+end