ruby-virtualenv 0.5.0

data/features/steps/env.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/../../lib/sandbox"
+
+begin
+  require 'cucumber'
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'cucumber'
+  require 'spec'
+end

data/lib/sandbox.rb

@@ -0,0 +1,41 @@
+$:.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/output'
+require 'sandbox/installer'

data/lib/sandbox/cli.rb

@@ -0,0 +1,173 @@
+require 'optparse'
+require 'sandbox'
+
+module Sandbox
+  class CLI
+    include Sandbox::Output
+    extend Sandbox::Output
+
+    DEFAULTS = {
+      :gems => []
+    }
+
+    ## CLASS METHODS
+    class << self
+
+      # invokes sandbox via command-line ARGV as the options
+      def execute(args = ARGV)
+        verify_environment!
+        parse(args).execute!
+      rescue Exception => error
+        handle_error(error)
+      end
+
+      # returns a new CLI instance which has parsed the given arguments.
+      # will load the command to execute based upon the arguements.
+      # if an error occurs, it will print out simple error message and exit.
+      def parse(args)
+        cli = new
+        cli.parse_args!(args)
+        cli
+      end
+
+      def verify_environment!
+        raise LoadedSandboxError if ENV['SANDBOX']
+      end
+
+      # pretty error handling
+      def handle_error(error)
+        case error
+          when Sandbox::Error
+            tell_unless_really_quiet(error.message)
+          when StandardError #, Timeout::Error
+            tell_unless_really_quiet("Error: #{error.message}")
+            tell_when_really_verbose(error.backtrace.collect { |bt| "    #{bt}" }.join( "\n" )) if error.backtrace
+          when Interrupt
+            tell_unless_really_quiet("Interrupted")
+        else
+          raise error
+        end
+      end
+
+    end
+    ## END CLASS METHODS
+
+    ## PUBLIC INSTANCE METHODS
+    public
+
+    # The options for this execution.
+    attr_reader :options
+
+    # setup of a new CLI instance
+    def initialize
+      @options = DEFAULTS.dup
+      @parser = nil
+    end
+
+    # perform the sandbox creation
+    def execute!
+      targets = options.delete(:args)
+
+      if targets.size < 1
+        raise Sandbox::Error.new('no target specified - see `ruby-virtualenv --help` for assistance')
+      elsif targets.size > 1
+        raise Sandbox::Error.new('multiple targets specified - see `ruby-virtualenv --help` for assistance')
+      end
+
+      options[ :target ] = targets[0]
+
+      Sandbox::Installer.new(options).populate
+    end
+
+    # processes +args+ to:
+    #
+    # * load global option for the application
+    # * determine command name to lookup in CommandManager
+    # * load command and have it process any add't options
+    # * catches exceptions for unknown switches or commands
+    def parse_args!( args )
+      options[:original_args] = args.dup
+      parser.parse!(args)
+    rescue OptionParser::ParseError => ex
+      raise_parse_error(ex.reason, ex.args)
+    else
+      options[:args] = args
+    end
+
+    def parser
+      @parser ||= create_parser
+    end
+
+    def create_parser
+      OptionParser.new do |o|
+        o.set_summary_indent('  ')
+        o.program_name = 'ruby-virtualenv TARGET'
+        o.define_head "Create virtual ruby/rubygems environments."
+        o.separator ""
+
+        o.separator "ARGUMENTS:"
+        o.separator "  TARGET      Target path to new virtualenv. Must not exist beforehand."
+        o.separator ""
+
+        o.separator "OPTIONS"
+        o.on('-g', '--gems gem1,gem2', Array, 'Gems to install after virtualenv is created.') { |gems| @options[:gems] = gems }
+        o.on('-n', '--no-gems', 'Do not install any gems after virtualenv is created.') { @options[:gems] = [] }
+        o.on('-q', '--quiet', 'Show less output. (multiple allowed)') { |f| Sandbox.decrease_verbosity }
+        o.on('-v', '--verbose', 'Show more output. (multiple allowed)') { |f| Sandbox.increase_verbosity }
+        o.on_tail('-h', '--help', 'Show this help message and exit.') { tell_unless_really_quiet( o ); exit }
+        o.on_tail('-H', '--long-help', 'Show the full description about the program.') { tell_unless_really_quiet( long_help ); exit }
+        o.on_tail('-V', '--version', 'Display the program version and exit.' ) { tell_unless_really_quiet( Sandbox::VERSION ); exit }
+        o.separator ""
+      end
+    end
+
+    def long_help
+      <<-HELP
+Sandbox is a utility to create sandboxed Ruby/Rubygems environments.
+
+It is meant to address the following issues:
+
+  1. Conflicts with unspecified gem dependency versions.
+  2. Applications can have their own gem repositories.
+  3. Permissions for installing your own gems.
+  4. Ability to try gems out without installing into your global repository.
+  5. A Simple way to enable this.
+
+Running from your own gem repositories is fairly straight-forward, but 
+managing the necessary environment is a pain.  This utility will create a new
+environment which may be activated by the script `bin/activate` in
+your sandbox directory.
+
+Run the script with the following to enable your new environment:
+
+  $ source bin/activate
+
+When you want to leave the environment:
+
+  $ deactivate
+
+NOTES:
+
+  1. It creates an environment that has its own installation directory for Gems.
+  2. It doesn't share gems with other sandbox environments.
+  3. It (optionally) doesn't use the globally installed gems either.
+  4. It will use a local to the sandbox .gemrc file
+
+WARNINGS:
+
+  Activating your sandbox environment will change your HOME directory
+  temporarily to the sandbox directory. Other environment variables are set to
+  enable this funtionality, so if you may experience odd behavior. Everything
+  should be reset when you deactivate the virtualenv.
+
+      HELP
+    end
+
+    private
+
+    def raise_parse_error(reason, args=[])
+      raise Sandbox::ParseError.new(reason, args)
+    end
+
+  end
+end

data/lib/sandbox/errors.rb

@@ -0,0 +1,38 @@
+module Sandbox
+  class Error < StandardError
+
+    def initialize(msg=nil)
+      super(msg)
+    end
+
+    def message
+      out = ["Sandbox error: #{super}"]
+      out.concat(backtrace.collect { |bt| "    #{bt}" }) if Sandbox.really_verbose?
+      out.join("\n")
+    end
+
+  end
+
+  class LoadedSandboxError < Sandbox::Error
+    def initialize(msg="You cannot run sandbox from a loaded sandbox environment")
+      super(msg)
+    end
+  end
+
+  class ParseError < Sandbox::Error
+
+    def initialize(reason=nil, args=[])
+      msg = if args.is_a?(Array) && args.size > 0
+        "#{reason} => #{args.join( ' ' )}"
+      elsif args.is_a?(String) && args.length > 0
+        "#{reason} => #{args}"
+      else
+        reason
+      end
+
+      super(msg)
+    end
+
+  end
+
+end

data/lib/sandbox/installer.rb

@@ -0,0 +1,175 @@
+require 'fileutils'
+require 'erb'
+
+module Sandbox
+  class Installer
+    include Sandbox::Output
+    extend Sandbox::Output
+
+    class << self
+    end
+
+    attr_accessor :options
+
+    def initialize(options={})
+      @options = options.dup
+      @target = nil
+    end
+
+    def target
+      return @target unless @target.nil?
+      @target = resolve_target(options[:target])
+    end
+
+    def populate
+      tell("creating sandbox at: #{target}")
+      create_directories
+      tell("installing activation script")
+      install_scripts
+      tell("installing .gemrc")
+      install_gemrc
+      tell("installing gems")
+      install_gems
+    end
+
+    ##
+    # Create folders:
+    #
+    #     mkdir -p /path/to/sandbox/rubygems/bin
+    #
+    # Symlink the bin directory, because when gems are installed, binaries
+    # are installed in GEM_HOME/bin:
+    #
+    #     $ ln -s /path/to/sandbox/rubygems/bin /path/to/sandbox/bin
+    #
+    def create_directories
+      gembin = File.join(target, 'rubygems', 'bin')
+      FileUtils.mkdir_p(gembin)
+
+      bin = File.join(target, 'bin')
+      FileUtils.ln_s( gembin, bin )
+    end
+
+    def install_gemrc
+      filename = File.join(target, '.gemrc')
+      template = File.read(File.dirname( __FILE__ ) + '/templates/gemrc.erb')
+      script = ERB.new(template)
+      output = script.result(binding)
+
+      File.open(filename, 'w') do |f|
+        f.write output
+      end
+    end
+
+    def install_scripts
+      filename = File.join(target, 'bin', 'activate')
+      template = File.read(File.dirname( __FILE__ ) + '/templates/activate.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?
+      gems = options[ :gems ] || []
+      if gems.size == 0
+        tell( "  nothing to install" )
+        return
+      end
+      
+      begin
+        setup_sandbox_env
+        gems.each do |gem|
+          tell_unless_really_quiet( "  gem: #{gem}" )
+          cmd = "gem install #{gem}"
+          # cmd = cmd + ' -V' if Sandbox.really_verbose?
+          status, output = shell_out( cmd )
+          unless status
+            tell_unless_really_quiet( "    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 == '/'
+          raise "something is seriously wrong; we should never get here"
+        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/output.rb

@@ -0,0 +1,25 @@
+module Sandbox
+  module Output
+
+    def tell(msg)
+      tell_unless_quiet(msg)
+    end
+
+    def tell_when_verbose(msg)
+      puts msg if Sandbox.verbose?
+    end
+
+    def tell_when_really_verbose(msg)
+      puts msg if Sandbox.really_verbose?
+    end
+
+    def tell_unless_quiet(msg)
+      puts msg unless Sandbox.quiet?
+    end
+
+    def tell_unless_really_quiet(msg)
+      puts msg unless Sandbox.really_quiet?
+    end
+
+  end
+end