isolate 1.10.2 → 2.0.0.pre.0

data/CHANGELOG.rdoc

@@ -1,3 +1,31 @@
+=== 2.0.0.pre.0 / 2010-04-27
+
+* Remove cache thawing until I fix RubyGems.
+* Add deprecation warning for Isolate.gems.
+* Fix now! test to properly disable system gems.
+* Fix failing file installation test.
+* Move Isolate::Test to where it belongs.
+* Require Rake tasks automatically if Rake exists.
+* Make sure it's possible to install a local .gem file.
+* Make additive ENV changes idempotent. [Eric Wong]
+* Isolate is a module now, not a class.
+* Use tmp/isolate as the default, replacing tmp/gems.
+* Sanity updates to README, still needs lots of work.
+* Minimize public API on Isolate.
+* Add isolate:debug task, remove isolate:dotgems.
+* Separate isolated gem homes by ruby executable/version.
+* Allow options changes in Isolate files or blocks.
+* Extract instance bits of Isolate into Isolate::Sandbox.
+* Allow path to be set in blocks/files.
+* Add support for local override files.
+* Make the directory path when enabled, not in the ctor.
+* Clean up tests, provide a helper for default options.
+* Move installation inside Isolate::Entry.
+* Make entries additive. Multiple calls to Isolate#gem is fine.
+* Extract, refactor, and test Isolate::Entry.
+* Lock down required Ruby and RubyGems versions.
+* Move Isolate::Entry to its very own file.
+
 === 1.10.2 / 2010-04-24
 
 Add 'isolate/now' convenience require in prep. for 2.x.

data/Manifest.txt

@@ -5,10 +5,18 @@ README.rdoc
 Rakefile
 lib/hoe/isolate.rb
 lib/isolate.rb
+lib/isolate/entry.rb
 lib/isolate/now.rb
 lib/isolate/rake.rb
+lib/isolate/sandbox.rb
+test/fixtures/blort-0.0.gem
 test/fixtures/isolate.rb
+test/fixtures/override.rb
+test/fixtures/override.rb.local
 test/fixtures/with-hoe/specifications/hoe-2.3.3.gemspec
 test/fixtures/with-hoe/specifications/rake-0.8.7.gemspec
 test/fixtures/with-hoe/specifications/rubyforge-1.0.4.gemspec
+test/isolate/test.rb
 test/test_isolate.rb
+test/test_isolate_entry.rb
+test/test_isolate_sandbox.rb

data/README.rdoc

@@ -37,12 +37,12 @@ same name. Version specifiers are optional.
     require "rubygems"
     require "isolate"
 
-    Isolate.gems "tmp/gems" do
+    Isolate.now! do
       gem "johnson", "~> 1.1" # or maybe...
       gem "jbarnette-johnson"
     end
 
-At the end of the <tt>Isolate.gems</tt> block, you're completely
+At the end of the <tt>Isolate.now!</tt> block, you're completely
 isolated. <tt>GEM_PATH</tt> and <tt>GEM_HOME</tt> are set, and all
 your specified gems have been activated.
 
@@ -60,7 +60,7 @@ Sometimes different sets of gems are appropriate at different
 times. Isolate allows you to restrict gems by 'environment' (which is
 really just a string passed in when things are activated).
 
-    Isolate.gems "tmp/gems" do
+    Isolate.now! do
       gem "intercession"
 
       environment :test, :cucumber do
@@ -75,9 +75,9 @@ your environment.
 
 === Options
 
-Any trailing hash args to <tt>gem</tt> are passed to
-<tt>Gem::DependencyInstaller</tt> as options. There are two special
-exceptions, <tt>:source</tt> and <tt>:args</tt>.
+Any trailing hash args to <tt>gem</tt> are attached to Isolate's gem
+entry as options. There are two well-known keys, <tt>:source</tt>
+and <tt>:args</tt>.
 
     # explicitly specify gem source
     gem "jbarnette-johnson", :source => "http://gems.github.com"
@@ -87,16 +87,16 @@ exceptions, <tt>:source</tt> and <tt>:args</tt>.
 
 === An External File
 
-If you'd like to have a separate file that *just* has your +gem+ and
-+environment+ calls in it, you can pass an optional <tt>:file</tt>
-option instead of (or in addition to) providing a block.
+It's nice to play use <tt>Isolate.now!</tt> inline, but it's better to
+keep all your stuff in an external file. This is supported by default:
 
-    # keepin' things clean
-    Isolate.gems "tmp/gems", :file => "config/isolate.rb"
+    Isolate.now!
 
-If you pass <tt>:file => true</tt> instead, Isolate will try to load
-from <tt>./Isolate</tt> and <tt>./config/isolate.rb</tt>, in that
-order.
+This will look for `Isolate` and `config/isolate.rb` files relative to
+the current directory, and `instance_eval` the first one it finds. If
+there's another matching file with a `.local` extension, Isolate will
+grab that one too. This makes it easy to have additional config that's
+specific to a deployment or developer.
 
 === Installing Isolated Gems
 
@@ -105,19 +105,17 @@ automatically. You can pass the <tt>:cleanup</tt>, <tt>:install</tt>,
 and <tt>:verbose</tt> options to control things:
 
     # don't remove unnecesary gems
-    Isolate.gems "tmp/gems", :cleanup => false do
-      ...
-    end
+    Isolate.now!, :cleanup => false
 
     # install, but quietly
-    Isolate.gems "tmp/gems", :verbose => false do
-      ...
-    end
+    Isolate.now! :verbose => false
 
     # don't install
-    Isolate.gems "tmp/gems", :install => false do
-      ...
-    end
+    Isolate.now! :install => false
+
+All of these options can be set inside your `Isolate` file, too:
+
+    options :cleanup => false, :verbose => false
 
 === Interaction and Rake
 
@@ -138,29 +136,22 @@ by any of your gems are available on your PATH.
     # run a new isolated subshell
     $ rake isolate:sh
 
-==== Exporting
-
-Isolate can generate a <tt>.gems</tt> manifest file in the root
-directory of your project. <tt>.gems</tt> is used (among other things)
-to specify project dependencies on Heroku.
+==== What's up?
 
-    $ rake isolate:dotgems
+    $ rake isolate:debug
 
-=== A Rails Example
+=== A Rails 2 Example
 
 Here's a quick example (extracted from a real project) of how to use
 Isolate with Rails. This project doesn't use vendored Rails, and
 doesn't want to depend on any system gems (except isolate, of course).
 
-Gem dependencies are defined in <tt>config/preinitializer.rb</tt>. If
-you want, you could just as easily put them in
-<tt>config/{gems,deps,isolate}.rb</tt>, just make sure it's loaded in
-the preinitializer:
+Let's edit <tt>config/preinitializer.rb</tt>:
 
     require "rubygems"
     require "isolate"
 
-    Isolate.gems "tmp/gems", :file => "config/isolate.rb"
+    Isolate.now!
 
 In <tt>config/isolate.rb</tt>:
 
@@ -195,9 +186,8 @@ In <tt>config/isolate.rb</tt>:
       gem "webrat"       # integration tests
     end
 
-You could specify all this inside an <tt>Isolate.gems</tt> block in
-<tt>config/preinitializer.rb</tt>, of course, but sometimes it's nicer
-to have an external file that's just your dependency manifest.
+You could specify all this inside the <tt>Isolate.now!</tt> block, of
+course, but keeping everything in an external file is nicer.
 
 Since this is loaded in the preinitializer, Isolate will install and
 activate the all gems before Rails loads. The current environment is
@@ -223,7 +213,7 @@ as putting:
 before the <tt>Hoe.spec</tt> call in your <tt>Rakefile</tt>.
 
 If you're not using Hoe, you can just do a regular
-<tt>Isolate.gems</tt> block at the top of your Rakefile.
+<tt>Isolate.now!</tt> block at the top of your Rakefile.
 
 == Installation
 

data/Rakefile

@@ -7,6 +7,9 @@ Hoe.spec "isolate" do
   developer "John Barnette", "jbarnette@rubyforge.org"
   developer "Ryan Davis",    "ryand-ruby@zenspider.com"
 
+  require_ruby_version     ">= 1.8.7"
+  require_rubygems_version ">= 1.3.6"
+
   self.extra_rdoc_files = Dir["*.rdoc"]
   self.history_file     = "CHANGELOG.rdoc"
   self.readme_file      = "README.rdoc"

data/lib/hoe/isolate.rb

@@ -18,18 +18,18 @@ class Hoe # :nodoc:
 
   module Isolate
 
-    # Where should Isolate, um, isolate? [default: <tt>"tmp/gems"</tt>]
+    # Where should Isolate, um, isolate? [default: <tt>"tmp/isolate"</tt>]
 
     attr_accessor :isolate_dir
 
     def initialize_isolate # :nodoc:
       # Tee hee! Move ourselves to the front to beat out :test.
       Hoe.plugins.unshift Hoe.plugins.delete(:isolate)
-      self.isolate_dir ||= "tmp/gems"
+      self.isolate_dir ||= "tmp/isolate"
     end
 
     def define_isolate_tasks # HACK
-      i = ::Isolate.new self.isolate_dir, :cleanup => true
+      i = ::Isolate::Sandbox.new :path => isolate_dir
 
       (self.extra_deps + self.extra_dev_deps).each do |name, version|
         i.gem name, *Array(version)

data/lib/isolate.rb

@@ -1,71 +1,46 @@
-require "rubygems/dependency_installer"
-require "rubygems/uninstaller"
-require "rubygems/requirement"
+require "isolate/sandbox"
 
 # Restricts +GEM_PATH+ and +GEM_HOME+ and provides a DSL for
 # expressing your code's runtime Gem dependencies. See README.rdoc for
 # rationale, limitations, and examples.
 
-class Isolate
+module Isolate
 
-  VERSION = "1.10.2" # :nodoc:
+  # Duh.
 
-  # An isolated Gem, with requirement, environment restrictions, and
-  # installation options. Internal use only.
-
-  class Entry < Struct.new(:name, :requirement, :environments, :options)
-    def matches? environment # :nodoc:
-      environments.empty? || environments.include?(environment)
-    end
-
-    def matches_spec? spec
-      name == spec.name and requirement.satisfied_by? spec.version
-    end
-  end
-
-  attr_reader :entries # :nodoc:
-  attr_reader :path # :nodoc:
+  VERSION = "2.0.0.pre.0"
 
   # Disable Isolate. If a block is provided, isolation will be
   # disabled for the scope of the block.
 
   def self.disable &block
-    instance.disable(&block)
+    sandbox.disable(&block)
   end
 
-  def self.env # :nodoc:
+  def self.env
     ENV["ISOLATE_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
   end
 
-  # Declare an isolated RubyGems environment, installed in +path+. Any
-  # block given will be <tt>instance_eval</tt>ed, see Isolate#gem and
-  # Isolate#environment for the sort of stuff you can do.
-  #
-  # If you'd like to specify gems and environments in a separate file,
-  # you can pass an optional <tt>:file</tt> option.
-  #
-  # Option defaults:
-  #
-  #    {
-  #      :cleanup => true,
-  #      :install => true,
-  #      :system  => false,
-  #      :verbose => true
-  #    }
+  def self.gems path, options = {}, &block # :nodoc:
+    warn "Isolate.gems is deprecated, use Isolate.now! instead.\n" +
+         "Isolate.gems will be removed in v3.0."
 
-  def self.gems path, options = {}, &block
-    @@instance = new path, options, &block
-    @@instance.activate
+    now! options.merge(:path => path), &block
   end
 
-  @@instance = nil
+  @@sandbox = nil
 
-  def self.instance # :nodoc:
-    @@instance
+  def self.sandbox
+    @@sandbox
   end
 
-  def self.now! #:nodoc:
-    gems "tmp/gems", :file => true, :system => true
+  # Declare an isolated RubyGems environment, installed in +path+. Any
+  # block given will be <tt>instance_eval</tt>ed, see Isolate#gem and
+  # Isolate#environment for the sort of stuff you can do.
+
+  def self.now! options = {}, &block
+    @@sandbox = Isolate::Sandbox.new options, &block
+    @@sandbox.activate
   end
 
   # Poke RubyGems, we've probably monkeyed with a bunch of paths and
@@ -76,220 +51,4 @@ class Isolate
     Gem.clear_paths
     Gem.source_index.refresh!
   end
-
-  # Create a new Isolate instance. See Isolate.gems for the public
-  # API. You probably don't want to use this constructor directly.
-
-  def initialize path, options = {}, &block
-    @enabled      = false
-    @entries      = []
-    @environments = []
-    @path         = File.expand_path path
-
-    @install      = options.fetch :install, true
-    @system       = options.fetch :system,  false
-    @verbose      = options.fetch :verbose, true
-    @cleanup      = @install && options.fetch(:cleanup, true)
-
-    file = options[:file]
-    file = Dir["{Isolate,config/isolate.rb}"].first if TrueClass === file
-
-    instance_eval IO.read(file), file if file
-    instance_eval(&block) if block_given?
-  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 || self.class.env).to_s
-
-    install env if install?
-
-    entries.each do |e|
-      Gem.activate e.name, *e.requirement.as_list if e.matches? env
-    end
-
-    cleanup if cleanup?
-
-    self
-  end
-
-  def cleanup # :nodoc:
-    activated = Gem.loaded_specs.values.map { |s| s.full_name }
-
-    extra = Gem.source_index.gems.values.sort.reject { |spec|
-      !spec.loaded_from.include?(path) or
-        activated.include? spec.full_name or
-          entries.any? { |e| e.matches_spec? spec }
-    }
-
-    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? # :nodoc:
-    @cleanup
-  end
-
-  def disable &block # :nodoc:
-    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
-
-    self.class.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
-
-    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.
-
-      ENV["RUBYOPT"]  = "#{ENV['RUBYOPT']} -I#{File.dirname(__FILE__)}"
-      ENV["GEM_PATH"] = path
-    end
-
-    bin = File.join path, "bin"
-    ENV["PATH"] = [bin, ENV["PATH"]].join File::PATH_SEPARATOR
-
-    self.class.refresh
-    Gem.path.unshift path if system?
-
-    @enabled = true
-
-    self
-  end
-
-  def enabled? # :nodoc:
-    @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
-    options = Hash === requirements.last ? requirements.pop : {}
-
-    requirement = if requirements.empty? then
-                    Gem::Requirement.default
-                  else
-                    Gem::Requirement.new requirements
-                  end
-
-    entry = Entry.new name, requirement, @environments,  options
-
-    entries << entry
-
-    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 |e, i|
-      log format % [i + 1, installable.size, e.name, e.requirement]
-
-      old         = Gem.sources.dup
-      options     = e.options.merge(:development   => false,
-                                    :generate_rdoc => false,
-                                    :generate_ri   => false,
-                                    :install_dir   => path)
-      source      = options.delete :source
-      args        = options.delete :args
-      Gem.sources += Array(source) if source
-      installer   = Gem::DependencyInstaller.new options
-
-      Gem::Command.build_args = Array(args) if args
-      installer.install e.name, e.requirement
-
-      Gem.sources = old
-      Gem::Command.build_args = nil if args
-    end
-
-    Gem.source_index.refresh!
-
-    self
-  end
-
-  def install? # :nodoc:
-    @install
-  end
-
-  def log s # :nodoc:
-    $stderr.puts s if verbose?
-  end
-
-  def system? # :nodoc:
-    @system
-  end
-
-  def verbose? # :nodoc:
-    @verbose
-  end
 end