isolate 2.0.0.pre.1 → 2.0.0.pre.2

data/CHANGELOG.rdoc

@@ -1,3 +1,12 @@
+=== 2.0.0.pre.2 / 2010-05-07
+
+* Update docs.
+* Add event hooks for better extension/integration.
+* Add ISOLATED env var when Isolate is activated.
+* Teach the Hoe plugin to recognize Isolate files.
+* Add `env` as an alias for `environment`.
+* Clean up Rake tasks.
+
 === 2.0.0.pre.1 / 2010-05-02
 
 * Don't provide a special way to set path, options is enough.

data/Manifest.txt

@@ -6,6 +6,7 @@ Rakefile
 lib/hoe/isolate.rb
 lib/isolate.rb
 lib/isolate/entry.rb
+lib/isolate/events.rb
 lib/isolate/now.rb
 lib/isolate/rake.rb
 lib/isolate/sandbox.rb
@@ -19,4 +20,5 @@ 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_events.rb
 test/test_isolate_sandbox.rb

data/README.rdoc

@@ -5,18 +5,13 @@
 == Description
 
 Isolate is a very simple RubyGems sandbox. It provides a way to
-express and install your code's Gem dependencies.
+express and automatically install your project's Gem dependencies.
 
-== How?
+== Wha?
 
 When Isolate runs, it uses GEM_HOME, GEM_PATH, and a few other tricks
-to completely separate your code from the system's RubyGems
-configuration, leaving it free to run in blissful solitude.
-
-While Isolate doesn't make any assumptions about what sort of code
-you're writing, it was extracted from a few Rails apps, so it's
-naturally going to be most useful with stuff like Rails, Merb, or
-Sinatra.
+to separate your code from the system's RubyGems configuration,
+leaving it free to run in blissful solitude.
 
 Isolate is very, very, very stupid simple. For a much more
 full-featured Gem bundler, check out Yehuda Katz and Carl Lerche's
@@ -24,111 +19,116 @@ Bundler[http://github.com/carlhuda/bundler]: It does a lot of fancy
 AOT dependency resolution, supports non-gem (including git) resources,
 and is probably a better fit for you.
 
-YMMV, but I haven't tried Isolate with anything older than RubyGems
-1.3.5.
+== Requirements
+
+RubyGems 1.3.6 or better, Ruby 1.8.7 or better.
 
-== Examples
+== Getting Started
 
-=== Defining Your Isolated Environment
+=== Rails 2
 
-It's pretty easy: <tt>gem</tt> is similar to RubyGems' method of the
-same name. Version specifiers are optional.
+In <tt>config/preinitializer.rb</tt>:
 
     require "rubygems"
-    require "isolate"
+    require "isolate/now"
 
-    Isolate.now! do
-      gem "johnson", "~> 1.1" # or maybe...
-      gem "jbarnette-johnson"
-    end
+In <tt>Isolate</tt>:
 
-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.
+    gem "rails", "2.3.5"
+    gem "aasm",  "2.0.0"
 
-If you need access to the original un-isolated environment for any
-reason, you can temporarily disable Isolate:
+    env :development, :test do
+      gem "sqlite3-ruby", "1.2.5"
+    end
 
-    Isolate.disable { `heroku config` }
+    env :production do
+      gem "memcached", "0.19.2"
+    end
 
-I occasionally use this to call out to gems or tools that don't belong
-in my project.
+Try running <tt>rake environment</tt>. Before anything else happens,
+Isolate will make sure you have copies of every gem you need (extend
+the example above to cover all your dependencies). If they're already
+installed on your system Isolate will use them, otherwise a private
+copy will be installed under <tt>tmp/isolate</tt>.
 
-=== Conditionals
+=== Rails 3
 
-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).
+In <tt>config/boot.rb</tt>:
 
-    Isolate.now! do
-      gem "intercession"
+    require "rubygems"
+    require "isolate/now"
 
-      environment :test, :cucumber do
-        gem "mocha"
-      end
-    end
+Construct your <tt>Isolate</tt> file as above. Be sure to remove any
+references to <tt>Bundler.setup</tt> and <tt>Bundler.require</tt> from
+<tt>config/boot.rb</tt> and <tt>config/application.rb</tt>.
 
-Unsurprisingly, the <tt>mocha</tt> gem will only be activated in the
-<tt>test</tt> and <tt>cucumber</tt> environments. See the Rails
-example below for an example of how to use <tt>RAILS_ENV</tt> to set
-your environment.
+=== Sinatra, Rack, and Anything Else
 
-=== Options
+There's nothing special about Rails, it's just an easy first
+example. You can use Isolate with any library or framework by simply
+putting an <tt>Isolate</tt> file in the root of your project and
+requiring <tt>isolate/now</tt> as early as possible in the startup
+process.
 
-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>.
+When you're starting up, Isolate tries to determine its environment by
+looking at the <tt>ISOLATE_ENV</tt>, <tt>RACK_ENV</tt>, and
+<tt>RAILS_ENV</tt> env vars. If none are set, it defaults to
+<tt>development</tt>.
 
-    # explicitly specify gem source
-    gem "jbarnette-johnson", :source => "http://gems.github.com"
+=== Library Development
 
-    # pass gem install args (the part after the '--')
-    gem "agem", :args => "--no-blah"
+If you're using Hoe[http://blog.zenspider.com/hoe] to manage your
+library, you can use Isolate's Hoe plugin to automatically install
+your lib's development, runtime, and test dependencies without
+polluting your system RubyGems, and run your tests/specs in total
+isolation.
 
-=== An External File
+Assuming you have a recent Hoe and isolate's installed, it's as simple
+as putting:
 
-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:
+    Hoe.plugin :isolate
 
-    Isolate.now!
+before the <tt>Hoe.spec</tt> call in your <tt>Rakefile</tt>.
 
-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.
+If you're not using Hoe, you can use an <tt>Isolate.now!</tt> block at
+the top of your Rakefile. See the RDoc for details.
 
-=== Installing Isolated Gems
+== Rake
 
-By default, Isolate will install and clean up your gems
-automatically. You can pass the <tt>:cleanup</tt>, <tt>:install</tt>,
-and <tt>:verbose</tt> options to control things:
+Isolate provides a few useful Rake tasks.
 
-    # don't remove unnecesary gems
-    Isolate.now!, :cleanup => false
+=== isolate:env
 
-    # install, but quietly
-    Isolate.now! :verbose => false
+This task shows you the current Isolate settings and gems.
 
-    # don't install
-    Isolate.now! :install => false
+    $ rake isolate:env
 
-All of these options can be set inside your `Isolate` file, too:
+         path: tmp/isolate/ruby-1.8
+          env: development
+        files: Isolate
 
-    options :cleanup => false, :verbose => false
+      cleanup? true
+      enabled? true
+      install? true
+    multiruby? true
+       system? true
+      verbose? true
 
-=== Interaction and Rake
+    [all environments]
+    gem rails, = 2.3.5
+    gem aasm, = 2.0.0
 
-You don't strictly need them, but Isolate provides a set of Rake tasks
-that make a few common thing easier. To use them, just drop a
-<tt>require</tt> in your <tt>Rakefile</tt>:
+    [development, test]
+    gem sqlite3-ruby, = 1.2.5
 
-    require "isolate/rake"
+    [production]
+    gem memcached, = 0.19.2
 
-==== Running Shell Commands
+=== isolate:sh
 
-When you're in an isolated subshell, the command-line tools provided
-by any of your gems are available on your PATH.
+This task allows you to run a subshell or a command in the isolated
+environment, making any command-line tools available on your
+<tt>PATH</tt>.
 
     # run a single command in an isolated subshell
     $ rake isolate:sh['gem list']
@@ -136,92 +136,37 @@ by any of your gems are available on your PATH.
     # run a new isolated subshell
     $ rake isolate:sh
 
-==== What's up?
-
-    $ rake isolate:debug
-
-=== 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).
-
-Let's edit <tt>config/preinitializer.rb</tt>:
-
-    require "rubygems"
-    require "isolate"
-
-    Isolate.now!
-
-In <tt>config/isolate.rb</tt>:
-
-    gem "rails", "= 2.2.2"
+=== isolate:stale
 
-    # async emails!
-    gem "ar_mailer", "~> 1.3", '>= 1.3.3'
+This task lists gems that have a more recent released version than the
+one you're using.
 
-    # Facebook integration
-    gem "facebooker", ">= 1.0.31"
+    $ rake isolate:stale
+    aasm (2.0.0 < 2.1.5)
 
-    # Google contacts integration
-    gem "gmail_contacts", "~> 1.7"
+== Further Reading
 
-    # View templates
-    gem "haml", "~> 2.0"
+<tt>require "isolate/now"</tt> is sugar for <tt>Isolate.now!</tt>,
+which creates, configures, and activates a singleton version of
+Isolate's sandbox. <tt>Isolate.now!</tt> takes a few useful options,
+and lets you define an entire environment inline without using an
+external file.
 
-    # Session as model
-    gem "intercession", "~> 1.0"
-
-    # XML/HTML parsing in Facebooker and tests
-    gem "nokogiri", ">= 1.2.3"
-
-    # Twitter authentication
-    gem "oauth", "~> 0.3"
-
-    environment :cucumber, :development, :test do
-      gem "cucumber"     # stories!
-      gem "modelizer"    # easy model factories
-      gem "sqlite3-ruby" # database support
-      gem "vlad"         # deployment
-      gem "webrat"       # integration tests
-    end
-
-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
-determined by looking at the <tt>ISOLATE_ENV</tt>, <tt>RAILS_ENV</tt>,
-or <tt>RACK_ENV</tt> environment variable. If none are set,
-<tt>"development"</tt> is the default.
-
-Pow. Isolated!
-
-=== A Library Example
-
-If you're using Hoe[http://blog.zenspider.com/hoe] to manage your
-library, you can use Isolate's Hoe plugin to automatically install
-your lib's development, runtime, and test dependencies without
-polluting your system RubyGems, and run your tests/specs in total
-isolation.
-
-Assuming you have a recent Hoe and isolate's installed, it's as simple
-as putting:
-
-    Hoe.plugin :isolate
-
-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.now!</tt> block at the top of your Rakefile.
+For detailed information on <tt>Isolate.now!</tt> and the rest of the
+public API, please see the RDoc.
 
 == Installation
 
     $ gem install isolate
 
+== Meta
+
+Bugs::  http://github.com/jbarnette/isolate/issues
+Email:: isolate@librelist.com
+
 == License
 
-Copyright 2009 John Barnette, et al. (jbarnette@rubyforge.org)
+Copyright 2009-2010 John Barnette, et al. (code@jbarnette.com)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -15,5 +15,5 @@ Hoe.spec "isolate" do
   self.readme_file      = "README.rdoc"
   self.testlib          = :minitest
 
-  extra_dev_deps << ["minitest", "~> 1.4"]
+  extra_dev_deps << ["minitest", "~> 1.6"]
 end

data/lib/hoe/isolate.rb

@@ -19,23 +19,39 @@ class Hoe # :nodoc:
   module Isolate
 
     # Where should Isolate, um, isolate? [default: <tt>"tmp/isolate"</tt>]
+    # FIX: consider removing this and allowing +isolate_options+ instead.
 
     attr_accessor :isolate_dir
 
-    def initialize_isolate # :nodoc:
+    def initialize_isolate
       # Tee hee! Move ourselves to the front to beat out :test.
       Hoe.plugins.unshift Hoe.plugins.delete(:isolate)
+
       self.isolate_dir ||= "tmp/isolate"
+      @sandbox = ::Isolate::Sandbox.new
+
+      @sandbox.entries.each do |entry|
+        dep = [entry.name, *entry.requirement.as_list]
+
+        if entry.environments.include? "development"
+          extra_dev_deps << dep
+        elsif entry.environments.empty?
+          extra_deps << dep
+        end
+      end
     end
 
     def define_isolate_tasks # HACK
-      i = ::Isolate::Sandbox.new :path => isolate_dir
 
+      # reset, now that they've had a chance to change it
+      @sandbox.options :path => isolate_dir
+
+      # allows traditional extra{_dev}_deps calls to override
       (self.extra_deps + self.extra_dev_deps).each do |name, version|
-        i.gem name, *Array(version)
+        @sandbox.gem name, *Array(version)
       end
 
-      i.activate
+      @sandbox.activate
     end
   end
 end

data/lib/isolate.rb

@@ -8,7 +8,7 @@ module Isolate
 
   # Duh.
 
-  VERSION = "2.0.0.pre.1"
+  VERSION = "2.0.0.pre.2"
 
   # Disable Isolate. If a block is provided, isolation will be
   # disabled for the scope of the block.
@@ -17,10 +17,17 @@ module Isolate
     sandbox.disable(&block)
   end
 
+  # What environment should be isolated? Consults environment
+  # variables <tt>ISOLATE_ENV</tt>, <tt>RAILS_ENV</tt>, and
+  # <tt>RACK_ENV</tt>. Defaults to <tt>development"/tt> if none are
+  # set.
+
   def self.env
     ENV["ISOLATE_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
   end
 
+  # Deprecated. See Isolate.now!
+
   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."
@@ -28,6 +35,8 @@ module Isolate
     now! options.merge(:path => path), &block
   end
 
+  # Deprecated. See Isolate.sandbox.
+
   def self.instance
     warn "Isolate.instance is deprecated, use Isolate.sandbox instead.\n" +
          "Isolate.instance will be removed in v3.0."
@@ -37,21 +46,49 @@ module Isolate
 
   @@sandbox = nil
 
+  # A singleton instance of Isolate::Sandbox.
+
   def self.sandbox
     @@sandbox
   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.
+  # block given will be <tt>instance_eval</tt>ed, see
+  # Isolate::Sandbox#gem and Isolate::Sandbox#environment for the sort
+  # of stuff you can do.
+  #
+  # Valid options:
+  #
+  # :cleanup:: Should obsolete gems be removed? Default is +true+.
+  #
+  # :file:: Specify an Isolate file to +instance_eval+. Default is
+  #         <tt>Isolate</tt> or <tt>config/isolate.rb</tt>, whichever
+  #         is found first. Passing <tt>false</tt> disables file
+  #         loading.
+  #
+  # :install:: Should missing gems be installed? Default is +true+.
+  #
+  # :multiruby:: Should Isolate assume that multiple Ruby versions
+  #              will be used simultaneously? If so, gems will be
+  #              segregated by Ruby version. Default is +true+.
+  #
+  # :path:: Where should isolated gems be kept? Default is
+  #         <tt>tmp/isolate"</tt>, and a Ruby version specifier suffix
+  #         will be added if <tt>:multiruby</tt> is +true+.
+  #
+  # :system:: Should system gems be allowed to satisfy dependencies?
+  #           Default is +true+.
+  #
+  # :verbose:: Should Isolate be chatty during installs and nukes?
+  #            Default is +true+.
 
   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
-  # suchlike. Clears paths, loaded specs, and source indexes.
+  # Poke RubyGems, since we've probably monkeyed with a bunch of paths
+  # and suchlike. Clears paths, loaded specs, and source indexes.
 
   def self.refresh # :nodoc:
     Gem.loaded_specs.clear

data/lib/isolate/entry.rb

@@ -1,3 +1,4 @@
+require "isolate/events"
 require "rubygems"
 require "rubygems/command"
 require "rubygems/dependency_installer"
@@ -7,9 +8,12 @@ require "rubygems/version"
 module Isolate
 
   # An isolated Gem, with requirement, environment restrictions, and
-  # installation options. Internal use only.
+  # installation options. Generally intended for internal use. This
+  # class exposes lifecycle events for extension, see Isolate::Events
+  # for more information.
 
   class Entry
+    include Events
 
     # Which environments does this entry care about? Generally an
     # Array of Strings. An empty array means "all", not "none".
@@ -31,9 +35,14 @@ module Isolate
     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.
+    # Isolate::Sandbox), +name+ (as above), and any number of optional
+    # version requirements (generally strings). Options can be passed
+    # as a trailing hash. Well-known keys:
+    #
+    # :args:: Command-line build arguments. Passed to the gem at
+    #         installation time.
+    #
+    # :source:: An alternative RubyGems source for this gem.
 
     def initialize sandbox, name, *requirements
       @environments = []
@@ -53,26 +62,32 @@ module Isolate
       update(*requirements)
     end
 
+    # Activate this entry. Fires <tt>:activating</tt> and
+    # <tt>:activated</tt>.
+
     def activate
-      Gem.activate name, *requirement.as_list
+      fire :activating, :activated do
+        Gem.activate name, *requirement.as_list
+      end
     end
 
-    # Install this entry in the sandbox.
+    # Install this entry in the sandbox. Fires <tt>:installing</tt>
+    # and <tt>:installed</tt>.
 
     def install
       old = Gem.sources.dup
 
       begin
-        cache = File.join @sandbox.path, "cache"
+        fire :installing, :installed do
+          installer = Gem::DependencyInstaller.new :development => false,
+            :generate_rdoc => false, :generate_ri => false,
+            :install_dir => @sandbox.path
 
-        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]
 
-        Gem.sources += Array(options[:source]) if options[:source]
-        Gem::Command.build_args = Array(options[:args]) if options[:args]
-
-        installer.install @file || name, requirement
+          installer.install @file || name, requirement
+        end
       ensure
         Gem.sources = old
         Gem::Command.build_args = nil
@@ -92,14 +107,22 @@ module Isolate
       name == spec.name and requirement.satisfied_by? spec.version
     end
 
+    # The Gem::Specification for this entry.
+
+    def specification
+      Gem.source_index.find_name(name, requirement).first
+    end
+
     # Updates this entry's environments, options, and
     # requirement. Environments and options are merged, requirement is
-    # replaced.
+    # replaced. Fires <tt>:updating</tt> and <tt>:updated</tt>.
 
     def update *reqs
-      @environments |= @sandbox.environments
-      @options.merge! reqs.pop if Hash === reqs.last
-      @requirement = Gem::Requirement.new reqs unless reqs.empty?
+      fire :updating, :updated do
+        @environments |= @sandbox.environments
+        @options.merge! reqs.pop if Hash === reqs.last
+        @requirement = Gem::Requirement.new reqs unless reqs.empty?
+      end
 
       self
     end

data/lib/isolate/events.rb

@@ -0,0 +1,42 @@
+module Isolate
+
+  # A simple way to watch and extend the Isolate lifecycle.
+  #
+  # Isolate::Events.watch Isolate::Sandbox, :initialized do |sandbox|
+  #   puts "A sandbox just got initialized: #{sandbox}"
+  # end
+  #
+  # Read the source for Isolate::Sandbox and Isolate::Entry to see
+  # what sort of events are fired.
+
+  module Events
+
+    # Watch for an event called +name+ from an instance of
+    # +klass+. +block+ will be called when the event occurs. Block
+    # args vary by event, but usually an instance of the relevant
+    # class is passed.
+
+    def self.watch klass, name, &block
+      watchers[[klass, name]] << block
+    end
+
+    def self.fire klass, name, *args #:nodoc:
+      watchers[[klass, name]].each do |block|
+        block[*args]
+      end
+    end
+
+    def self.watchers #:nodoc:
+      @watchers ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def fire name, after = nil, *args, &block #:nodoc:
+      Isolate::Events.fire self.class, name, *args
+
+      if after && block_given?
+        yield self
+        Isolate::Events.fire self.class, after, *args
+      end
+    end
+  end
+end

data/lib/isolate/rake.rb

@@ -1,6 +1,6 @@
 namespace :isolate do
   desc "Show current isolated environment."
-  task :debug do
+  task :env do
     require "pathname"
 
     sandbox = Isolate.sandbox
@@ -9,10 +9,10 @@ namespace :isolate do
     files   = sandbox.files.map { |f| Pathname(f) }
 
     puts
-    puts "  sandbox: #{path}"
+    puts "     path: #{path}"
     puts "      env: #{Isolate.env}"
 
-    files.collect! { |f| f.absolute? ? f.relative_path_from(here) : f }
+    files.map! { |f| f.absolute? ? f.relative_path_from(here) : f }
     puts "    files: #{files.join ', '}"
     puts
 
@@ -45,4 +45,26 @@ namespace :isolate do
   task :sh, [:command] do |t, args|
     exec args.command || ENV["SHELL"]
   end
+
+  desc "Which isolated gems have updates available?"
+  task :stale do
+    require "rubygems/source_index"
+    require "rubygems/spec_fetcher"
+
+    index = Gem::SourceIndex.new
+    index.add_specs *Isolate.sandbox.entries.map { |e| e.specification }
+
+    outdated = index.outdated.map do |n|
+      Isolate.sandbox.entries.find { |e| e.name == n }
+    end
+
+    outdated.sort_by { |e| e.name }.each do |entry|
+      local   = entry.specification.version
+      dep     = Gem::Dependency.new entry.name, ">= #{local}"
+      remotes = Gem::SpecFetcher.fetcher.fetch dep
+      remote  = remotes.last.first.version
+
+      puts "#{entry.name} (#{local} < #{remote})"
+    end
+  end
 end

data/lib/isolate/sandbox.rb

@@ -1,17 +1,26 @@
 require "fileutils"
 require "isolate/entry"
+require "isolate/events"
 require "rbconfig"
 require "rubygems/defaults"
 require "rubygems/uninstaller"
 
 module Isolate
+
+  # An isolated environment. This class exposes lifecycle events for
+  # extension, see Isolate::Events for more information.
+
   class Sandbox
+    include Events
+
     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.
+    # Create a new Isolate::Sandbox instance. See Isolate.now! for the
+    # most common use of the API. You probably don't want to use this
+    # constructor directly.  Fires <tt>:initializing</tt> and
+    # <tt>:initialized</tt>.
 
     def initialize options = {}, &block
       @enabled      = false
@@ -22,6 +31,8 @@ module Isolate
 
       file, local = nil
 
+      fire :initializing
+
       unless FalseClass === options[:file]
         file  = options[:file] || Dir["{Isolate,config/isolate.rb}"].first
         local = "#{file}.local" if file
@@ -36,6 +47,7 @@ module Isolate
       end
 
       load local if local && File.exist?(local)
+      fire :initialized
     end
 
     # Activate this set of isolated entries, respecting an optional
@@ -44,10 +56,12 @@ module Isolate
     # 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>.
+    # <tt>"development"</tt>. Fires <tt>:activating</tt> and
+    # <tt>:activated</tt>.
 
     def activate environment = nil
       enable unless enabled?
+      fire :activating
 
       env = (environment || Isolate.env).to_s
 
@@ -58,38 +72,43 @@ module Isolate
       end
 
       cleanup if cleanup?
+      fire :activated
 
       self
     end
 
     def cleanup # :nodoc:
+      fire :cleaning
+
       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 }
+        entry  = entries.find { |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."
+      unless 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]
+        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
+          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
+
+      fire :cleaned
     end
 
     def cleanup?
@@ -98,9 +117,11 @@ module Isolate
 
     def disable &block
       return self if not enabled?
+      fire :disabling
 
       ENV["GEM_PATH"] = @old_gem_path
       ENV["GEM_HOME"] = @old_gem_home
+      ENV["ISOLATED"] = @old_isolated
       ENV["PATH"]     = @old_path
       ENV["RUBYOPT"]  = @old_ruby_opt
 
@@ -109,6 +130,8 @@ module Isolate
       @enabled = false
 
       Isolate.refresh
+      fire :disabled
+
       begin; return yield ensure enable end if block_given?
 
       self
@@ -116,9 +139,11 @@ module Isolate
 
     def enable # :nodoc:
       return self if enabled?
+      fire :enabling
 
       @old_gem_path  = ENV["GEM_PATH"]
       @old_gem_home  = ENV["GEM_HOME"]
+      @old_isolated  = ENV["ISOLATED"]
       @old_path      = ENV["PATH"]
       @old_ruby_opt  = ENV["RUBYOPT"]
       @old_load_path = $LOAD_PATH.dup
@@ -151,10 +176,13 @@ module Isolate
         ENV["PATH"] = [bin, ENV["PATH"]].join File::PATH_SEPARATOR
       end
 
+      ENV["ISOLATED"] = path
+
       Isolate.refresh
       Gem.path.unshift path if system?
 
       @enabled = true
+      fire :enabled
 
       self
     end
@@ -174,12 +202,14 @@ module Isolate
       @environments = old
     end
 
+    alias_method :env, :environment
+
     # 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 }
+      entry = entries.find { |e| e.name == name }
       return entry.update(*requirements) if entry
 
       entries << entry = Entry.new(self, name, *requirements)
@@ -187,22 +217,26 @@ module Isolate
     end
 
     def install environment # :nodoc:
+      fire :installing
+
       installable = entries.select do |e|
         !Gem.available?(e.name, *e.requirement.as_list) &&
           e.matches?(environment)
       end
 
-      return self if installable.empty?
+      unless installable.empty?
+        padding = Math.log10(installable.size).to_i + 1
+        format  = "[%0#{padding}d/%s] Isolating %s (%s)."
 
-      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
 
-      installable.each_with_index do |entry, i|
-        log format % [i + 1, installable.size, entry.name, entry.requirement]
-        entry.install
+        Gem.source_index.refresh!
       end
 
-      Gem.source_index.refresh!
+      fire :installed
 
       self
     end

data/test/test_isolate_events.rb

@@ -0,0 +1,44 @@
+require "isolate/events"
+require "isolate/test"
+
+class TestIsolateEvents < Isolate::Test
+  include Isolate::Events
+
+  def setup
+    Isolate::Events.watchers.clear
+    super
+  end
+
+  def test_self_watch
+    b = lambda {}
+    Isolate::Events.watch String, :foo, &b
+    assert_equal [b], Isolate::Events.watchers[[String, :foo]]
+  end
+
+  def test_fire
+    count = 0
+
+    Isolate::Events.watch self.class, :increment do
+      count += 1
+    end
+
+    fire :increment
+    assert_equal 1, count
+  end
+
+  def test_fire_block
+    count = 0
+
+    [:increment, :incremented].each do |name|
+      Isolate::Events.watch self.class, name do
+        count += 1
+      end
+    end
+
+    fire :increment, :incremented do |x|
+      assert_same self, x
+    end
+
+    assert_equal 2, count
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: isolate
 version: !ruby/object:Gem::Version 
-  hash: 1923832043
+  hash: 1923832045
   prerelease: true
   segments: 
   - 2
   - 0
   - 0
   - pre
-  - 1
-  version: 2.0.0.pre.1
+  - 2
+  version: 2.0.0.pre.2
 platform: ruby
 authors: 
 - John Barnette
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-02 00:00:00 -07:00
+date: 2010-05-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,11 +45,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
         - 1
-        - 4
-        version: "1.4"
+        - 6
+        version: "1.6"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -70,7 +70,7 @@ dependencies:
   version_requirements: *id003
 description: |-
   Isolate is a very simple RubyGems sandbox. It provides a way to
-  express and install your code's Gem dependencies.
+  express and automatically install your project's Gem dependencies.
 email: 
 - jbarnette@rubyforge.org
 - ryand-ruby@zenspider.com
@@ -91,6 +91,7 @@ files:
 - lib/hoe/isolate.rb
 - lib/isolate.rb
 - lib/isolate/entry.rb
+- lib/isolate/events.rb
 - lib/isolate/now.rb
 - lib/isolate/rake.rb
 - lib/isolate/sandbox.rb
@@ -104,6 +105,7 @@ files:
 - test/isolate/test.rb
 - test/test_isolate.rb
 - test/test_isolate_entry.rb
+- test/test_isolate_events.rb
 - test/test_isolate_sandbox.rb
 has_rdoc: true
 homepage: http://github.com/jbarnette/isolate
@@ -147,4 +149,5 @@ summary: Isolate is a very simple RubyGems sandbox
 test_files: 
 - test/test_isolate.rb
 - test/test_isolate_entry.rb
+- test/test_isolate_events.rb
 - test/test_isolate_sandbox.rb