nkryptic-sandbox 0.2.0

data/lib/sandbox/installer.rb

@@ -0,0 +1,156 @@
+
+require 'fileutils'
+require 'erb'
+
+module Sandbox
+  
+  class Installer
+    
+    ## CLASS METHODS
+    class << self
+    end
+    ## END CLASS METHODS
+    
+    attr_accessor :options
+    
+    ## PUBLIC INSTANCE METHODS
+    public
+    
+    def initialize( options={} )
+      @options = options.dup
+      @target = nil
+    end
+    
+    def target
+      return @target unless @target.nil?
+      @target = resolve_target( options[ :target ] )
+    end
+    
+    def populate
+      puts "creating sandbox at: #{target}" if Sandbox.verbose?
+      create_directories
+      install_scripts
+      install_gems
+    end
+    
+    def create_directories
+      bin = File.join( target, 'bin' )
+      gembin = File.join( target, 'rubygems', 'bin' )
+      
+      # mkdir /path/to/sandbox/
+      # mkdir /path/to/sandbox/rubygems
+      # mkdir /path/to/sandbox/rubygems/bin
+      FileUtils.mkdir_p( gembin )
+      
+      # ln -s /path/to/sandbox/rubygems/bin /path/to/sandbox/bin
+      # symlink the bin directory, because when gems are installed, binaries are
+      # installed in GEM_HOME/bin
+      FileUtils.ln_s( gembin, bin )
+    end
+    
+    def install_scripts
+      filename = File.join( target, 'bin', 'activate_sandbox' )
+      template = File.read( File.dirname( __FILE__ ) + '/templates/activate_sandbox.erb' )
+      script = ERB.new( template )
+      output = script.result( binding )
+      File.open( filename, 'w' ) do |f|
+        f.write output
+      end
+    end
+    
+    def install_gems
+      # gem = `which gem`.chomp
+      # return if gem.empty?
+      puts "installing gems" if Sandbox.verbose?
+      begin
+        setup_sandbox_env
+        options[ :gems ].each do |gem|
+          puts "  gem: #{gem}" if Sandbox.verbose?
+          cmd = "gem install #{gem}"
+          # cmd = cmd + ' -V' if Sandbox.really_verbose?
+          status, output = shell_out( cmd )
+          unless status
+            warn "failed to install gem: #{gem}"
+          end
+        end
+      ensure
+        restore_sandbox_env
+      end
+    end
+    
+    def shell_out( cmd )
+      # err_capture = Sandbox.really_verbose? '2>&1' : '2>/dev/null'
+      # out = `#{cmd} #{err_capture}`
+      out = `#{cmd} 2>/dev/null`
+      result = $?.exitstatus == 0
+      [ result, out ]
+    end
+    
+    def setup_sandbox_env
+      @old_env = Hash[ *ENV.select { |k,v| ['HOME','GEM_HOME','GEM_PATH'].include?( k ) }.flatten ]
+      # @old_env = {}
+      # @old_env[ 'HOME' ]      = ENV[ 'HOME' ]
+      # @old_env[ 'GEM_HOME' ]  = ENV[ 'GEM_HOME' ]
+      # @old_env[ 'GEM_PATH' ]  = ENV[ 'GEM_PATH' ]
+      
+      ENV[ 'HOME' ]     = target
+      ENV[ 'GEM_HOME' ] = "#{target}/rubygems"
+      ENV[ 'GEM_PATH' ] = "#{target}/rubygems"
+    end
+    
+    def restore_sandbox_env
+      ENV.update( @old_env )
+      # ENV[ 'HOME' ]     = @old_env[ 'HOME' ]
+      # ENV[ 'GEM_HOME' ] = @old_env[ 'GEM_HOME' ]
+      # ENV[ 'GEM_PATH' ] = @old_env[ 'GEM_PATH' ]
+    end
+    
+    def resolve_target( path )
+      # should consider replacing with 'pathname' => Pathname.new( path )
+      path = fix_path( path )
+      if File.exists?( path )
+        raise Sandbox::Error, "target '#{path}' exists"
+      end
+      
+      base = path
+      while base = File.dirname( base )
+        if check_path!( base )
+          break
+        elsif base == '/'
+          break
+        end
+      end
+      return path
+    end
+    
+    def check_path!( path )
+      if File.directory?( path )
+        if File.writable?( path )
+          return true
+        else
+          raise Sandbox::Error, "path '#{path}' has a permission problem"
+        end
+      elsif File.exists?( path )
+        raise Sandbox::Error, "path '#{path}' is not a directory"
+      end
+      false
+    end
+    
+    def fix_path( path )
+      unless path.index( '/' ) == 0
+        path = File.join( FileUtils.pwd, path )
+      end
+      path
+    end
+
+    ## END PUBLIC INSTANCE METHODS
+
+
+    ## PRIVATE INSTANCE METHODS
+    private
+
+    ## END PRIVATE INSTANCE METHODS
+  
+  end
+  
+end

data/lib/sandbox/templates/activate_sandbox.erb

@@ -0,0 +1,91 @@
+
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate_sandbox () {
+    if [ -n "$_OLD_SANDBOX_PATH" ] ; then
+        PATH="$_OLD_SANDBOX_PATH"
+        export PATH
+        unset _OLD_SANDBOX_PATH
+    fi
+    
+    if [ -n "$_OLD_SANDBOX_HOME" ] ; then
+        HOME="$_OLD_SANDBOX_HOME"
+        export HOME
+        unset _OLD_SANDBOX_HOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then
+        hash -r
+    fi
+    
+    if [ -n "$_OLD_SANDBOX_GEM_HOME" ] ; then
+        GEM_HOME="$_OLD_SANDBOX_GEM_HOME"
+        export GEM_HOME
+        unset _OLD_SANDBOX_GEM_HOME
+    fi
+    
+    if [ -n "$_OLD_SANDBOX_GEM_PATH" ] ; then
+        GEM_PATH="$_OLD_SANDBOX_GEM_PATH"
+        export GEM_PATH
+        unset _OLD_SANDBOX_GEM_PATH
+    fi
+    
+    if [ -n "$_OLD_SANDBOX_PS1" ] ; then
+        PS1="$_OLD_SANDBOX_PS1"
+        export PS1
+        unset _OLD_SANDBOX_PS1
+    fi
+    
+    # unset again, in case they were missed because they were blank
+    unset _OLD_SANDBOX_GEM_HOME
+    unset _OLD_SANDBOX_GEM_PATH
+    
+    unset SANDBOX_ENV
+    if [ ! "$1" = "nondestructive" ] ; then
+        # Self destruct!
+        unset deactivate_sandbox
+    fi
+}
+
+# unset irrelavent variables
+deactivate_sandbox nondestructive
+
+SANDBOX_ENV="<%= target %>"
+export SANDBOX_ENV
+
+_OLD_SANDBOX_PATH="$PATH"
+PATH="$SANDBOX_ENV/bin:$PATH"
+export PATH
+
+_OLD_SANDBOX_HOME="$HOME"
+HOME="$SANDBOX_ENV"
+export HOME
+
+_OLD_SANDBOX_GEM_HOME="$GEM_HOME"
+GEM_HOME="$SANDBOX_ENV/rubygems"
+export GEM_HOME
+
+_OLD_SANDBOX_GEM_PATH="$GEM_PATH"
+GEM_PATH="$GEM_HOME"
+export GEM_PATH
+
+_OLD_SANDBOX_PS1="$PS1"
+if [ "`basename \"$SANDBOX_ENV\"`" = "__" ] ; then
+    # special case for Aspen magic directories
+    # see http://www.zetadev.com/software/aspen/
+    PS1="[sandbox:`basename \`dirname \"$SANDBOX_ENV\"\``] $PS1"
+else
+    PS1="(sandbox:`basename \"$SANDBOX_ENV\"`)$PS1"
+fi
+export PS1
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then
+    hash -r
+fi

data/lib/sandbox/version.rb

@@ -0,0 +1,15 @@
+
+module Sandbox
+  
+  class Version #:nodoc:
+    
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [ MAJOR, MINOR, TINY ].join( '.' )
+    
+  end
+  
+end
+

data/lib/sandbox.rb

@@ -0,0 +1,33 @@
+$:.unshift(File.dirname(__FILE__)) unless \
+    $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+module Sandbox
+  
+  class << self
+    
+    def verbosity
+      @verbosity ||= 0
+    end
+    
+    def increase_verbosity
+      @verbosity = verbosity + 1
+    end
+    
+    def decrease_verbosity
+      @verbosity = verbosity - 1
+    end
+    
+    def quiet?() verbosity < 0 end
+    def really_quiet?() verbosity < 1 end
+    def verbose?() verbosity > 0 end
+    def really_verbose?() verbosity > 1 end
+    
+  end
+  
+end
+
+require 'sandbox/version'
+require 'sandbox/errors'
+require 'sandbox/installer'
+

data/sandbox.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sandbox}
+  
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jacob Radford"]
+  s.date = %q{2008-12-01}
+  s.default_executable = %q{sandbox}
+  s.description = %q{Create virtual ruby/rubygems sandboxes.}
+  s.email = %q{nkryptic@gmail.com}
+  s.executables = ["sandbox"]
+  s.extra_rdoc_files = ["CHANGELOG", "TODO", "README.rdoc", "tasks/rspec.rake", "tasks/cucumber.rake", "tasks/gem.rake", "tasks/dcov.rake", "lib/sandbox.rb", "lib/sandbox/installer.rb", "lib/sandbox/cli.rb", "lib/sandbox/templates/activate_sandbox.erb", "lib/sandbox/version.rb", "lib/sandbox/errors.rb", "bin/sandbox"]
+  s.files = ["sandbox.gemspec", "CHANGELOG", "TODO", "spec/sandbox/cli_spec.rb", "spec/sandbox/installer_spec.rb", "spec/sandbox_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "Manifest", "features/steps/common.rb", "features/steps/env.rb", "features/development.feature", "README.rdoc", "tasks/rspec.rake", "tasks/cucumber.rake", "tasks/gem.rake", "tasks/dcov.rake", "Rakefile", "lib/sandbox.rb", "lib/sandbox/installer.rb", "lib/sandbox/cli.rb", "lib/sandbox/templates/activate_sandbox.erb", "lib/sandbox/version.rb", "lib/sandbox/errors.rb", "bin/sandbox"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/nkryptic/sandbox}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sandbox", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{sandbox}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Create virtual ruby/rubygems sandboxes.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<echoe>, ["~> 0", "= 3.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 0", "= 1.1.0"])
+      s.add_development_dependency(%q<mocha>, ["~> 0", "= 0.9"])
+    else
+      s.add_dependency(%q<echoe>, ["~> 0", "= 3.0"])
+      s.add_dependency(%q<rspec>, ["~> 0", "= 1.1.0"])
+      s.add_dependency(%q<mocha>, ["~> 0", "= 0.9"])
+    end
+  else
+    s.add_dependency(%q<echoe>, ["~> 0", "= 3.0"])
+    s.add_dependency(%q<rspec>, ["~> 0", "= 1.1.0"])
+    s.add_dependency(%q<mocha>, ["~> 0", "= 0.9"])
+  end
+end

data/spec/sandbox/cli_spec.rb

@@ -0,0 +1,199 @@
+
+require File.dirname( __FILE__ ) + '/../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 )
+    ensure
+      ENV[ 'SANDBOX' ] = nil
+    end
+  end
+  
+  describe "calling execute" 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.execute
+    end
+    
+    it "should attempt to parse ARGV by default" do
+      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.execute
+    end
+    
+    it "should call parse_args! on the new instance" do
+      @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 )
+      Sandbox::CLI.execute
+    end
+  end
+  
+  describe "a new instance" do
+    
+    before( :each ) do
+      @cli = Sandbox::CLI.new
+    end
+    
+    it "should have default 'gems to install'" do
+      @cli.options[ :gems ] = [ 'rake' ]
+    end
+    
+    describe "instance calling parse_args!" do
+      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 == []
+        end
+      end
+  
+      describe "using VALID arguments" do
+        [ '-V', '--version' ].each do |arg|
+          it "should print the version for switch '#{arg}'" do
+            @cli.expects( :puts ).with( Sandbox::Version::STRING )
+            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( :puts ).with( Sandbox::Version::STRING ).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( :puts ).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( :puts ).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( :puts )
+            @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 == []
+          end
+        end
+        
+        [ [ '-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 == []
+          end
+        end
+        
+        it "should require additional arguments with switch '-g'" do
+          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' ]
+        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 == []
+        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
+        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 ]
+        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/ }
+        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 ] = []
+        processor.should raise_error
+      end
+      
+      it "should raise error with more than one target" do
+        @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 )
+        process
+      end
+      
+    end
+    
+  end
+  
+end
+