isolate 1.10.2 → 2.0.0.pre.0

data/lib/isolate/entry.rb

@@ -0,0 +1,107 @@
+require "rubygems"
+require "rubygems/command"
+require "rubygems/dependency_installer"
+require "rubygems/requirement"
+require "rubygems/version"
+
+module Isolate
+
+  # An isolated Gem, with requirement, environment restrictions, and
+  # installation options. Internal use only.
+
+  class Entry
+
+    # Which environments does this entry care about? Generally an
+    # Array of Strings. An empty array means "all", not "none".
+
+    attr_reader :environments
+
+    # What's the name of this entry? Generally the name of a gem.
+
+    attr_reader :name
+
+    # Extra information or hints for installation. See +initialize+
+    # for well-known keys.
+
+    attr_reader :options
+
+    # What version of this entry is required? Expressed as a
+    # Gem::Requirement, which see.
+
+    attr_reader :requirement
+
+    # Create a new entry. Takes +sandbox+ (currently an instance of
+    # Isolate), +name+ (as above), and any number of optional version
+    # requirements (generally Strings). Options can be passed as a
+    # trailing hash. FIX: document well-known keys.
+
+    def initialize sandbox, name, *requirements
+      @environments = []
+      @file         = nil
+      @name         = name
+      @options      = {}
+      @requirement  = Gem::Requirement.default
+      @sandbox      = sandbox
+
+      if /\.gem$/ =~ @name && File.file?(@name)
+        @file = File.expand_path @name
+
+        @name = File.basename(@file, ".gem").
+          gsub(/-#{Gem::Version::VERSION_PATTERN}$/, "")
+      end
+
+      update(*requirements)
+    end
+
+    def activate
+      Gem.activate name, *requirement.as_list
+    end
+
+    # Install this entry in the sandbox.
+
+    def install
+      old = Gem.sources.dup
+
+      begin
+        cache = File.join @sandbox.path, "cache"
+
+        installer = Gem::DependencyInstaller.new :development => false,
+          :generate_rdoc => false, :generate_ri => false,
+          :install_dir => @sandbox.path
+
+        Gem.sources += Array(options[:source]) if options[:source]
+        Gem::Command.build_args = Array(options[:args]) if options[:args]
+
+        installer.install @file || name, requirement
+      ensure
+        Gem.sources = old
+        Gem::Command.build_args = nil
+      end
+    end
+
+    # Is this entry interested in +environment+?
+
+    def matches? environment
+      environments.empty? || environments.include?(environment)
+    end
+
+    # Is this entry satisfied by +spec+ (generally a
+    # Gem::Specification)?
+
+    def matches_spec? spec
+      name == spec.name and requirement.satisfied_by? spec.version
+    end
+
+    # Updates this entry's environments, options, and
+    # requirement. Environments and options are merged, requirement is
+    # replaced.
+
+    def update *reqs
+      @environments |= @sandbox.environments
+      @options.merge! reqs.pop if Hash === reqs.last
+      @requirement = Gem::Requirement.new reqs unless reqs.empty?
+
+      self
+    end
+  end
+end

data/lib/isolate/now.rb

@@ -1,2 +1,4 @@
 require "isolate"
+require "isolate/rake" if defined?(Rake)
+
 Isolate.now!

data/lib/isolate/rake.rb

@@ -1,18 +1,43 @@
 namespace :isolate do
-  desc "Generate a .gems manifest for your isolated gems."
-  task :dotgems, [:env] do |_, args|
-    env = args.env || Isolate.env
+  desc "Show current isolated environment."
+  task :debug do
+    require "pathname"
 
-    File.open ".gems", "wb" do |f|
-      Isolate.instance.entries.each do |entry|
-        next unless entry.matches? env
+    sandbox = Isolate.sandbox
+    here    = Pathname Dir.pwd
+    path    = Pathname(sandbox.path).relative_path_from here
+    files   = sandbox.files.map { |f| Pathname(f) }
 
-        gems  = [entry.name]
-        gems << "--version '#{entry.requirement}'"
-        gems << "--source #{entry.options[:source]}" if entry.options[:source]
+    puts
+    puts "  sandbox: #{path}"
+    puts "      env: #{Isolate.env}"
 
-        f.puts gems.join(" ")
+    files.collect! { |f| f.absolute? ? f.relative_path_from(here) : f }
+    puts "    files: #{files.join ', '}"
+    puts
+
+    %w(cleanup? enabled? install? multiruby? system? verbose?).each do |flag|
+      printf "%10s %s\n", flag, sandbox.send(flag)
+    end
+
+    grouped = Hash.new { |h, k| h[k] = [] }
+    sandbox.entries.each { |e| grouped[e.environments] << e }
+
+    puts
+
+    grouped.keys.sort.each do |envs|
+      title   = "all environments" if envs.empty?
+      title ||= envs.join ", "
+
+      puts "[#{title}]"
+
+      grouped[envs].each do |e|
+        gem = "gem #{e.name}, #{e.requirement}"
+        gem << ", #{e.options.inspect}" unless e.options.empty?
+        puts gem
       end
+
+      puts
     end
   end
 

data/lib/isolate/sandbox.rb

@@ -0,0 +1,256 @@
+require "fileutils"
+require "isolate/entry"
+require "rbconfig"
+require "rubygems/uninstaller"
+
+module Isolate
+  class Sandbox
+    attr_reader :entries # :nodoc:
+    attr_reader :environments # :nodoc:
+    attr_reader :files # :nodoc:
+
+    # Create a new Isolate instance. See Isolate.gems for the public
+    # API. You probably don't want to use this constructor directly.
+
+    def initialize options = {}, &block
+      @enabled      = false
+      @entries      = []
+      @environments = []
+      @files        = []
+      @options      = options
+
+      path options.fetch(:path, "tmp/isolate")
+
+      file, local = nil
+
+      unless FalseClass === options[:file]
+        file  = options[:file] || Dir["{Isolate,config/isolate.rb}"].first
+        local = "#{file}.local" if file
+      end
+
+      load file if file
+
+      if block_given?
+        block.to_s =~ /\@([^:]+):/
+        files << ($1 || "inline block")
+        instance_eval(&block)
+      end
+
+      load local if local && File.exist?(local)
+    end
+
+    # Activate this set of isolated entries, respecting an optional
+    # +environment+. Points RubyGems to a separate repository, messes
+    # with paths, auto-installs gems (if necessary), activates
+    # everything, and removes any superfluous gem (again, if
+    # necessary). If +environment+ isn't specified, +ISOLATE_ENV+,
+    # +RAILS_ENV+, and +RACK_ENV+ are checked before falling back to
+    # <tt>"development"</tt>.
+
+    def activate environment = nil
+      enable unless enabled?
+
+      env = (environment || Isolate.env).to_s
+
+      install env if install?
+
+      entries.each do |e|
+        e.activate if e.matches? env
+      end
+
+      cleanup if cleanup?
+
+      self
+    end
+
+    def cleanup # :nodoc:
+      activated = Gem.loaded_specs.values.map { |s| s.full_name }
+      available = Gem.source_index.gems.values.sort
+
+      extra = available.reject do |spec|
+        active = activated.include? spec.full_name
+        entry  = entries.detect { |e| e.matches_spec? spec }
+        system = !spec.loaded_from.include?(path)
+
+        active or entry or system
+      end
+
+      return if extra.empty?
+
+      padding = Math.log10(extra.size).to_i + 1
+      format  = "[%0#{padding}d/%s] Nuking %s."
+
+      extra.each_with_index do |e, i|
+        log format % [i + 1, extra.size, e.full_name]
+
+        Gem::DefaultUserInteraction.use_ui Gem::SilentUI.new do
+          Gem::Uninstaller.new(e.name,
+                               :version     => e.version,
+                               :ignore      => true,
+                               :executables => true,
+                               :install_dir => path).uninstall
+        end
+      end
+    end
+
+    def cleanup?
+      install? and @options.fetch(:cleanup, true)
+    end
+
+    def disable &block
+      return self if not enabled?
+
+      ENV["GEM_PATH"] = @old_gem_path
+      ENV["GEM_HOME"] = @old_gem_home
+      ENV["PATH"]     = @old_path
+      ENV["RUBYOPT"]  = @old_ruby_opt
+
+      $LOAD_PATH.replace @old_load_path
+
+      @enabled = false
+
+      Isolate.refresh
+      begin; return yield ensure enable end if block_given?
+
+      self
+    end
+
+    def enable # :nodoc:
+      return self if enabled?
+
+      @old_gem_path  = ENV["GEM_PATH"]
+      @old_gem_home  = ENV["GEM_HOME"]
+      @old_path      = ENV["PATH"]
+      @old_ruby_opt  = ENV["RUBYOPT"]
+      @old_load_path = $LOAD_PATH.dup
+
+      FileUtils.mkdir_p path
+      ENV["GEM_HOME"] = path
+
+      unless system?
+        $LOAD_PATH.reject! do |p|
+          p != File.dirname(__FILE__) &&
+            Gem.path.any? { |gp| p.include?(gp) }
+        end
+
+        # HACK: Gotta keep isolate explicitly in the LOAD_PATH in
+        # subshells, and the only way I can think of to do that is by
+        # abusing RUBYOPT.
+
+        dirname = Regexp.escape File.dirname(__FILE__)
+
+        unless ENV["RUBYOPT"] =~ /\s+-I\s*#{dirname}\b/
+          ENV["RUBYOPT"] = "#{ENV['RUBYOPT']} -I#{File.dirname(__FILE__)}"
+        end
+
+        ENV["GEM_PATH"] = path
+      end
+
+      bin = File.join path, "bin"
+
+      unless ENV["PATH"].split(File::PATH_SEPARATOR).include? bin
+        ENV["PATH"] = [bin, ENV["PATH"]].join File::PATH_SEPARATOR
+      end
+
+      Isolate.refresh
+      Gem.path.unshift path if system?
+
+      @enabled = true
+
+      self
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    # Restricts +gem+ calls inside +block+ to a set of +environments+.
+
+    def environment *environments, &block
+      old = @environments
+      @environments = @environments.dup.concat environments.map { |e| e.to_s }
+
+      instance_eval(&block)
+    ensure
+      @environments = old
+    end
+
+    # Express a gem dependency. Works pretty much like RubyGems' +gem+
+    # method, but respects +environment+ and doesn't activate 'til
+    # later.
+
+    def gem name, *requirements
+      entry = entries.detect { |e| e.name == name }
+      return entry.update(*requirements) if entry
+
+      entries << entry = Entry.new(self, name, *requirements)
+      entry
+    end
+
+    def install environment # :nodoc:
+      installable = entries.select do |e|
+        !Gem.available?(e.name, *e.requirement.as_list) &&
+          e.matches?(environment)
+      end
+
+      return self if installable.empty?
+
+      padding = Math.log10(installable.size).to_i + 1
+      format  = "[%0#{padding}d/%s] Isolating %s (%s)."
+
+      installable.each_with_index do |entry, i|
+        log format % [i + 1, installable.size, entry.name, entry.requirement]
+        entry.install
+      end
+
+      Gem.source_index.refresh!
+
+      self
+    end
+
+    def install? # :nodoc:
+      @options.fetch :install, true
+    end
+
+    def load file # :nodoc:
+      files << file
+      instance_eval IO.read(file), file, 1
+    end
+
+    def log s # :nodoc:
+      $stderr.puts s if verbose?
+    end
+
+
+    def multiruby?
+      @options.fetch :multiruby, true
+    end
+    def options options = nil
+      @options.merge! options if options
+      @options
+    end
+
+    def path path = nil
+      if path
+        unless @options.key?(:multiruby) && @options[:multiruby] == false
+          suffix = RbConfig::CONFIG.
+            values_at("ruby_install_name", "ruby_version").join "-"
+
+          path = File.join(path, suffix) unless path =~ /#{suffix}/
+        end
+
+        @path = File.expand_path path
+      end
+
+      @path
+    end
+
+    def system?
+      @options.fetch :system, true
+    end
+
+    def verbose?
+      @options.fetch :verbose, true
+    end
+  end
+end

data/test/fixtures/override.rb

@@ -0,0 +1 @@
+gem "monkey", :args => "--threaten"

data/test/fixtures/override.rb.local

@@ -0,0 +1,3 @@
+environment :bar do
+  gem "monkey", :args  => "--asplode"
+end

data/test/isolate/test.rb

@@ -0,0 +1,53 @@
+require "isolate"
+require "minitest/autorun"
+
+module Isolate
+  class Test < MiniTest::Unit::TestCase
+    def setup
+      Isolate.refresh
+
+      @env = ENV.to_hash
+      @lp  = $LOAD_PATH.dup
+      @lf  = $LOADED_FEATURES.dup
+    end
+
+    def teardown
+      Gem::DependencyInstaller.reset_value
+      Gem::Uninstaller.reset_value
+
+      ENV.replace @env
+      $LOAD_PATH.replace @lp
+      $LOADED_FEATURES.replace @lf
+
+      FileUtils.rm_rf "tmp/isolate"
+    end
+  end
+end
+
+module BrutalStub
+  @@value = []
+  def value; @@value end
+  def reset_value; value.clear end
+end
+
+class Gem::DependencyInstaller
+  extend BrutalStub
+
+  alias old_install install
+  def install name, requirement
+    self.class.value << [name, requirement]
+  end
+end
+
+class Gem::Uninstaller
+  extend BrutalStub
+
+  attr_reader :gem, :version, :gem_home
+  alias old_uninstall uninstall
+
+  def uninstall
+    self.class.value << [self.gem,
+                         self.version.to_s,
+                         self.gem_home.sub(Dir.pwd + "/", '')]
+  end
+end