merb-gen 0.9.8 → 0.9.9

data/lib/generators/templates/application/common/merb.thor

@@ -4,29 +4,10 @@ require 'thor'
 require 'fileutils'
 require 'yaml'
 
-# TODO
-# - pulling a specific UUID/Tag (gitspec hash) with clone/update
-# - a 'deploy' task (in addition to 'redeploy' ?)
-# - add merb:gems:refresh to refresh all gems (from specifications)
-# - merb:gems:uninstall should remove local bin/ entries
+# Important - don't change this line or its position
+MERB_THOR_VERSION = '0.0.5'
 
 ##############################################################################
-#
-# GemManagement
-#
-# The following code is also used by Merb core, but we can't rely on it as a
-# dependency, since merb.thor should be completely selfcontained (except for
-# Thor itself). Therefore, the code below is copied here. Should you work on
-# this code, be sure to edit the original code to keep them in sync.
-#
-# You can find the original here: merb-core/tasks/gem_management.rb
-#
-##############################################################################
-
-require 'rubygems'
-require 'rubygems/dependency_installer'
-require 'rubygems/uninstaller'
-require 'rubygems/dependency'
 
 module ColorfulMessages
   
@@ -47,12 +28,28 @@ module ColorfulMessages
   
   alias_method :message, :success
   
+  # magenta
+  def note(*messages)
+    puts messages.map { |msg| "\033[1;35m#{msg}\033[0m" }
+  end
+  
+  # blue
+  def info(*messages)
+    puts messages.map { |msg| "\033[1;34m#{msg}\033[0m" }
+  end
+  
 end
 
+##############################################################################
+
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+require 'rubygems/dependency'
+
 module GemManagement
   
   include ColorfulMessages
-  
+    
   # Install a gem - looks remotely and local gem cache;
   # won't process rdoc or ri options.
   def install_gem(gem, options = {})
@@ -64,13 +61,13 @@ module GemManagement
       version = options.delete(:version)
       Gem.configuration.update_sources = false
 
+      # Limit source index to install dir
       update_source_index(options[:install_dir]) if options[:install_dir]
 
       installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
       
-      # Exclude gems to refresh from index - force (re)install of new version
-      # def installer.source_index; @source_index; end
-      unless refresh.empty?
+      # Force-refresh certain gems by excluding them from the current index
+      if !options[:ignore_dependencies] && refresh.respond_to?(:include?) && !refresh.empty?
         source_index = installer.instance_variable_get(:@source_index)
         source_index.gems.each do |name, spec| 
           source_index.gems.delete(name) if refresh.include?(spec.name)
@@ -93,7 +90,7 @@ module GemManagement
         exception = e
       end
       if installer.installed_gems.empty? && exception
-        error "Failed to install gem '#{gem} (#{version})' (#{exception.message})"
+        error "Failed to install gem '#{gem} (#{version || 'any version'})' (#{exception.message})"
       end
       installer.installed_gems.each do |spec|
         success "Successfully installed #{spec.full_name}"
@@ -128,81 +125,73 @@ module GemManagement
   end
 
   # Install a gem from source - builds and packages it first then installs.
-  def install_gem_from_src(gem_src_dir, options = {})
-    if !File.directory?(gem_src_dir)
-      raise "Missing rubygem source path: #{gem_src_dir}"
-    end
-    if options[:install_dir] && !File.directory?(options[:install_dir])
-      raise "Missing rubygems path: #{options[:install_dir]}"
-    end
-
-    gem_name = File.basename(gem_src_dir)
-    gem_pkg_dir = File.expand_path(File.join(gem_src_dir, 'pkg'))
-
-    # We need to use local bin executables if available.
-    thor = "#{Gem.ruby} -S #{which('thor')}"
-    rake = "#{Gem.ruby} -S #{which('rake')}"
-
-    # Handle pure Thor installation instead of Rake
-    if File.exists?(File.join(gem_src_dir, 'Thorfile'))
-      # Remove any existing packages.
-      FileUtils.rm_rf(gem_pkg_dir) if File.directory?(gem_pkg_dir)
-      # Create the package.
-      FileUtils.cd(gem_src_dir) { system("#{thor} :package") }
-      # Install the package using rubygems.
-      if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
-        FileUtils.cd(File.dirname(package)) do
-          install_gem(File.basename(package), options.dup)
-          return true
-        end
+  # 
+  # Examples:
+  # install_gem_from_source(source_dir, :install_dir => ...)
+  # install_gem_from_source(source_dir, gem_name)
+  # install_gem_from_source(source_dir, :skip => [...])
+  def install_gem_from_source(source_dir, *args)
+    installed_gems = []
+    Dir.chdir(source_dir) do
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      gem_name     = args[0] || File.basename(source_dir)
+      gem_pkg_dir  = File.join(source_dir, 'pkg')
+      gem_pkg_glob = File.join(gem_pkg_dir, "#{gem_name}-*.gem")
+      skip_gems    = opts.delete(:skip) || []
+
+      # Cleanup what's already there
+      clobber(source_dir)
+      FileUtils.mkdir_p(gem_pkg_dir) unless File.directory?(gem_pkg_dir)
+
+      # Recursively process all gem packages within the source dir
+      skip_gems << gem_name
+      packages = package_all(source_dir, skip_gems)
+      
+      if packages.length == 1
+        # The are no subpackages for the main package
+        refresh = [gem_name]
       else
-        raise Gem::InstallError, "No package found for #{gem_name}"
-      end
-    # Handle elaborate installation through Rake
-    else
-      # Clean and regenerate any subgems for meta gems.
-      Dir[File.join(gem_src_dir, '*', 'Rakefile')].each do |rakefile|
-        FileUtils.cd(File.dirname(rakefile)) do 
-          system("#{rake} clobber_package; #{rake} package")
-        end
-      end
-
-      # Handle the main gem install.
-      if File.exists?(File.join(gem_src_dir, 'Rakefile'))
-        subgems = []
-        # Remove any existing packages.
-        FileUtils.cd(gem_src_dir) { system("#{rake} clobber_package") }
-        # Create the main gem pkg dir if it doesn't exist.
-        FileUtils.mkdir_p(gem_pkg_dir) unless File.directory?(gem_pkg_dir)
-        # Copy any subgems to the main gem pkg dir.
-        Dir[File.join(gem_src_dir, '*', 'pkg', '*.gem')].each do |subgem_pkg|
-          if name = File.basename(subgem_pkg, '.gem')[/^(.*?)-([\d\.]+)$/, 1]
-            subgems << name
-          end
-          dest = File.join(gem_pkg_dir, File.basename(subgem_pkg))
-          FileUtils.copy_entry(subgem_pkg, dest, true, false, true)          
+        # Gather all packages into the top-level pkg directory
+        packages.each do |pkg|
+          FileUtils.copy_entry(pkg, File.join(gem_pkg_dir, File.basename(pkg)))
         end
-
-        # Finally generate the main package and install it; subgems
-        # (dependencies) are local to the main package.
-        FileUtils.cd(gem_src_dir) do         
-          system("#{rake} package")
-          FileUtils.cd(gem_pkg_dir) do
-            if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
-              # If the (meta) gem has it's own package, install it.
-              install_gem(File.basename(package), options.merge(:refresh => subgems))
-            else
-              # Otherwise install each package seperately.
-              Dir["*.gem"].each { |gem| install_gem(gem, options.dup) }
-            end
+        
+        # Finally package the main gem - without clobbering the already copied pkgs
+        package(source_dir, false)
+        
+        # Gather subgems to refresh during installation of the main gem
+        refresh = packages.map do |pkg|
+          File.basename(pkg, '.gem')[/^(.*?)-([\d\.]+)$/, 1] rescue nil
+        end.compact
+        
+        # Install subgems explicitly even if ignore_dependencies is set
+        if opts[:ignore_dependencies]
+          refresh.each do |name| 
+            gem_pkg = Dir[File.join(gem_pkg_dir, "#{name}-*.gem")][0]
+            install_pkg(gem_pkg, opts)
           end
-          return true
         end
       end
+      
+      # Finally install the main gem
+      if install_pkg(Dir[gem_pkg_glob][0], opts.merge(:refresh => refresh))
+        installed_gems = refresh
+      else
+        installed_gems = []
+      end
     end
-    raise Gem::InstallError, "No Rakefile found for #{gem_name}"
+    installed_gems
   end
-
+  
+  def install_pkg(gem_pkg, opts = {})
+    if (gem_pkg && File.exists?(gem_pkg))
+      # Needs to be executed from the directory that contains all packages
+      Dir.chdir(File.dirname(gem_pkg)) { install_gem(gem_pkg, opts) }
+    else
+      false
+    end
+  end
+  
   # Uninstall a gem.
   def uninstall_gem(gem, options = {})
     if options[:version] && !options[:version].is_a?(Gem::Requirement)
@@ -212,6 +201,45 @@ module GemManagement
     Gem::Uninstaller.new(gem, options).uninstall
   end
 
+  def clobber(source_dir)
+    Dir.chdir(source_dir) do 
+      system "#{Gem.ruby} -S rake -s clobber" unless File.exists?('Thorfile')
+    end
+  end
+
+  def package(source_dir, clobber = true)
+    Dir.chdir(source_dir) do 
+      if File.exists?('Thorfile')
+        thor ":package"
+      elsif File.exists?('Rakefile')
+        rake "clobber" if clobber
+        rake "package"
+      end
+    end
+    Dir[File.join(source_dir, 'pkg/*.gem')]
+  end
+
+  def package_all(source_dir, skip = [], packages = [])
+    if Dir[File.join(source_dir, '{Rakefile,Thorfile}')][0]
+      name = File.basename(source_dir)
+      Dir[File.join(source_dir, '*', '{Rakefile,Thorfile}')].each do |taskfile|
+        package_all(File.dirname(taskfile), skip, packages)
+      end
+      packages.push(*package(source_dir)) unless skip.include?(name)
+    end
+    packages.uniq
+  end
+  
+  def rake(cmd)
+    cmd << " >/dev/null" if $SILENT && !Gem.win_platform?
+    system "#{Gem.ruby} -S #{which('rake')} -s #{cmd} >/dev/null"
+  end
+  
+  def thor(cmd)
+    cmd << " >/dev/null" if $SILENT && !Gem.win_platform?
+    system "#{Gem.ruby} -S #{which('thor')} #{cmd}"
+  end
+
   # Use the local bin/* executables if available.
   def which(executable)
     if File.executable?(exec = File.join(Dir.pwd, 'bin', executable))
@@ -221,17 +249,43 @@ module GemManagement
     end
   end
   
+  # Partition gems into system, local and missing gems
+  def partition_dependencies(dependencies, gem_dir)
+    system_specs, local_specs, missing_deps = [], [], []
+    if gem_dir && File.directory?(gem_dir)
+      gem_dir = File.expand_path(gem_dir)
+      ::Gem.clear_paths; ::Gem.path.unshift(gem_dir)
+      ::Gem.source_index.refresh!
+      dependencies.each do |dep|
+        gemspecs = ::Gem.source_index.search(dep)
+        local = gemspecs.reverse.find { |s| s.loaded_from.index(gem_dir) == 0 }
+        if local
+          local_specs  << local
+        elsif gemspecs.last
+          system_specs << gemspecs.last
+        else
+          missing_deps << dep
+        end
+      end
+      ::Gem.clear_paths
+    end
+    [system_specs, local_specs, missing_deps]
+  end
+  
   # Create a modified executable wrapper in the specified bin directory.
   def ensure_bin_wrapper_for(gem_dir, bin_dir, *gems)
+    options = gems.last.is_a?(Hash) ? gems.last : {}
+    options[:no_minigems] ||= []
     if bin_dir && File.directory?(bin_dir)
       gems.each do |gem|
         if gemspec_path = Dir[File.join(gem_dir, 'specifications', "#{gem}-*.gemspec")].last
           spec = Gem::Specification.load(gemspec_path)
+          enable_minigems = !options[:no_minigems].include?(spec.name)
           spec.executables.each do |exec|
             executable = File.join(bin_dir, exec)
             message "Writing executable wrapper #{executable}"
             File.open(executable, 'w', 0755) do |f|
-              f.write(executable_wrapper(spec, exec))
+              f.write(executable_wrapper(spec, exec, enable_minigems))
             end
           end
         end
@@ -241,7 +295,10 @@ module GemManagement
 
   private
 
-  def executable_wrapper(spec, bin_file_name)
+  def executable_wrapper(spec, bin_file_name, minigems = true)
+    requirements = ['minigems', 'rubygems']
+    requirements.reverse! unless minigems
+    try_req, then_req = requirements
     <<-TEXT
 #!/usr/bin/env ruby
 #
@@ -251,9 +308,9 @@ module GemManagement
 # this file is here to facilitate running it.
 
 begin 
-  require 'minigems'
+  require '#{try_req}'
 rescue LoadError 
-  require 'rubygems'
+  require '#{then_req}'
 end
 
 if File.directory?(gems_dir = File.join(Dir.pwd, 'gems')) ||
@@ -288,44 +345,241 @@ TEXT
   def update_source_index(dir)
     Gem.source_index.load_gems_in(File.join(dir, 'specifications'))
   end
-  
+    
 end
 
-
 ##############################################################################
 
-module MerbThorHelper
-
+class SourceManager
+  
   include ColorfulMessages
+  
+  attr_accessor :source_dir
+  
+  def initialize(source_dir)
+    self.source_dir = source_dir
+  end
+  
+  def clone(name, url)
+    FileUtils.cd(source_dir) do
+      raise "destination directory already exists" if File.directory?(name)
+      system("git clone --depth 1 #{url} #{name}")
+    end
+  rescue => e
+    error "Unable to clone #{name} repository (#{e.message})"
+  end
+  
+  def update(name, url)
+    if File.directory?(repository_dir = File.join(source_dir, name))
+      FileUtils.cd(repository_dir) do
+        repos = existing_repos(name)
+        fork_name = url[/.com\/+?(.+)\/.+\.git/u, 1]
+        if url == repos["origin"]
+          # Pull from the original repository - no branching needed
+          info "Pulling from origin: #{url}"
+          system "git fetch; git checkout master; git rebase origin/master"
+        elsif repos.values.include?(url) && fork_name
+          # Update and switch to a remote branch for a particular github fork
+          info "Switching to remote branch: #{fork_name}"
+          system "git checkout -b #{fork_name} #{fork_name}/master"   
+          system "git rebase #{fork_name}/master"
+        elsif fork_name
+          # Create a new remote branch for a particular github fork
+          info "Adding a new remote branch: #{fork_name}"
+          system "git remote add -f #{fork_name} #{url}"
+          system "git checkout -b #{fork_name} #{fork_name}/master"
+        else
+          warning "No valid repository found for: #{name}"
+        end
+      end
+      return true
+    else
+      warning "No valid repository found at: #{repository_dir}"
+    end
+  rescue => e
+    error "Unable to update #{name} repository (#{e.message})"
+    return false
+  end
+  
+  def existing_repos(name)
+    repos = []
+    FileUtils.cd(File.join(source_dir, name)) do
+      repos = %x[git remote -v].split("\n").map { |branch| branch.split(/\s+/) }
+    end
+    Hash[*repos.flatten]
+  end
+  
+end
 
-  DO_ADAPTERS = %w[mysql postgres sqlite3]
+##############################################################################
 
-  private
+module MerbThorHelper
+  
+  attr_accessor :include_dependencies
+  
+  def self.included(base)
+    base.send(:include, ColorfulMessages)
+    base.extend ColorfulMessages
+  end
+
+  def install_dependency(dependency, opts = {})
+    opts[:version] ||= dependency.version_requirements.to_s
+    Merb::Gem.install(dependency.name, default_install_options.merge(opts))
+  end
+  
+  def source_manager
+    @_source_manager ||= SourceManager.new(source_dir)
+  end
+  
+  def extract_repositories(names)
+    repos = []
+    names.each do |name|
+      if repo_url = Merb::Source.repo(name, options[:sources])
+        # A repository entry for this dependency exists
+        repo = [name, repo_url]
+        repos << repo unless repos.include?(repo) 
+      elsif (repo_name = Merb::Stack.lookup_repository_name(name)) &&
+        (repo_url = Merb::Source.repo(repo_name, options[:sources]))
+        # A parent repository entry for this dependency exists
+        repo = [repo_name, repo_url]
+        unless repos.include?(repo)
+          puts "Found #{repo_name}/#{name} at #{repo_url}"
+          repos << repo 
+        end
+      end
+    end
+    repos
+  end
+  
+  def update_dependency_repositories(dependencies)
+    repos = extract_repositories(dependencies.map { |d| d.name })
+    update_repositories(repos)
+  end
+  
+  def update_repositories(repos)
+    repos.each do |(name, url)|
+      if File.directory?(repository_dir = File.join(source_dir, name))
+        message "Updating or branching #{name}..."
+        source_manager.update(name, url)
+      else
+        message "Cloning #{name} repository from #{url}..."
+        source_manager.clone(name, url)
+      end
+    end
+  end
 
+  def install_dependency_from_source(dependency, opts = {})
+    matches = Dir[File.join(source_dir, "**", dependency.name, "{Rakefile,Thorfile}")]
+    matches.reject! { |m| File.basename(m) == 'Thorfile' }
+    if matches.length == 1 && matches[0]
+      if File.directory?(gem_src_dir = File.dirname(matches[0]))
+        begin
+          Merb::Gem.install_gem_from_source(gem_src_dir, default_install_options.merge(opts))
+          puts "Installed #{dependency.name}"
+          return true
+        rescue => e
+          warning "Unable to install #{dependency.name} from source (#{e.message})"
+        end
+      else
+        msg = "Unknown directory: #{gem_src_dir}"
+        warning "Unable to install #{dependency.name} from source (#{msg})"
+      end
+    elsif matches.length > 1
+      error "Ambigous source(s) for dependency: #{dependency.name}"
+      matches.each { |m| puts "- #{m}" }
+    end
+    return false
+  end
+  
+  def clobber_dependencies!
+    if options[:force] && gem_dir && File.directory?(gem_dir)
+      # Remove all existing local gems by clearing the gems directory
+      if dry_run?
+        note 'Clearing existing local gems...'
+      else
+        message 'Clearing existing local gems...'
+        FileUtils.rm_rf(gem_dir) && FileUtils.mkdir_p(default_gem_dir)
+      end
+    elsif !local.empty? 
+      # Uninstall all local versions of the gems to install
+      if dry_run?
+        note 'Uninstalling existing local gems:'
+        local.each { |gemspec| note "Uninstalled #{gemspec.name}" }
+      else
+        message 'Uninstalling existing local gems:' 
+        local.each do |gemspec|
+          Merb::Gem.uninstall(gemspec.name, default_uninstall_options)
+        end
+      end
+    end
+  end
+    
+  def display_gemspecs(gemspecs)
+    if gemspecs.empty?
+      puts "- none"
+    else
+      gemspecs.each do |spec| 
+        if hint = Dir[File.join(spec.full_gem_path, '*.strategy')][0]
+          strategy = File.basename(hint, '.strategy')
+          puts "- #{spec.full_name} (#{strategy})"
+        else
+          puts "~ #{spec.full_name}" # unknown strategy
+        end
+      end
+    end
+  end
+  
+  def display_dependencies(dependencies)
+    if dependencies.empty?
+      puts "- none"
+    else
+      dependencies.each { |d| puts "- #{d.name} (#{d.version_requirements})" }
+    end
+  end
+  
+  def default_install_options
+    { :install_dir => gem_dir, :ignore_dependencies => ignore_dependencies? }
+  end
+  
+  def default_uninstall_options
+    { :install_dir => gem_dir, :ignore => true, :all => true, :executables => true }
+  end
+  
+  def dry_run?
+    options[:"dry-run"]
+  end
+  
+  def ignore_dependencies?
+    options[:"ignore-dependencies"] || !include_dependencies?
+  end
+  
+  def include_dependencies?
+    options[:"include-dependencies"] || self.include_dependencies
+  end
+  
   # The current working directory, or Merb app root (--merb-root option).
   def working_dir
     @_working_dir ||= File.expand_path(options['merb-root'] || Dir.pwd)
   end
-
+  
   # We should have a ./src dir for local and system-wide management.
   def source_dir
     @_source_dir  ||= File.join(working_dir, 'src')
     create_if_missing(@_source_dir)
     @_source_dir
   end
-
-  # If a local ./gems dir is found, it means we are in a Merb app.
-  def application?
-    gem_dir
-  end
-
+    
   # If a local ./gems dir is found, return it.
   def gem_dir
-    if File.directory?(dir = File.join(working_dir, 'gems'))
+    if File.directory?(dir = default_gem_dir)
       dir
     end
   end
-
+  
+  def default_gem_dir
+    File.join(working_dir, 'gems')
+  end
+  
   # If we're in a Merb app, we can have a ./bin directory;
   # create it if it's not there.
   def bin_dir
@@ -338,884 +592,1319 @@ module MerbThorHelper
     end
   end
   
-  def config_dir
-    @_config_dir ||= File.join(working_dir, 'config')
-  end
-  
-  def config_file
-    @_config_file ||= File.join(config_dir, 'dependencies.yml')
-  end
-  
-  # Find the latest merb-core and gather its dependencies.
-  # We check for 0.9.8 as a minimum release version.
-  def core_dependencies
-    @_core_dependencies ||= begin
-      if gem_dir
-        Gem.clear_paths; Gem.path.unshift(gem_dir)
-      end
-      deps = []
-      merb_core = Gem::Dependency.new('merb-core', '>= 0.9.8')
-      if gemspec = Gem.source_index.search(merb_core).last
-        deps << Gem::Dependency.new('merb-core', gemspec.version)
-        deps += gemspec.dependencies
-      end
-      Gem.clear_paths
-      deps
-    end
-  end
-  
-  # Find local gems and return matched version numbers.
-  def find_dependency_versions(dependency)
-    versions = []
-    specs = Dir[File.join(gem_dir, 'specifications', "#{dependency.name}-*.gemspec")]
-    unless specs.empty?
-      specs.inject(versions) do |versions, gemspec_path|
-        versions << gemspec_path[/-([\d\.]+)\.gemspec$/, 1]
-      end
-    end
-    versions.sort.reverse
-  end
-  
   # Helper to create dir unless it exists.
   def create_if_missing(path)
     FileUtils.mkdir(path) unless File.exists?(path)
   end
-  
-  def neutralise_sudo_for(dir)
-    if ENV['SUDO_UID'] && ENV['SUDO_GID']
-      FileUtils.chown_R(ENV['SUDO_UID'], ENV['SUDO_GID'], dir)
-    end
+
+  def ensure_bin_wrapper_for(*gems)
+    Merb::Gem.ensure_bin_wrapper_for(gem_dir, bin_dir, *gems)
   end
   
-  def ensure_bin_wrapper_for(*gems)
-    Merb.ensure_bin_wrapper_for(gem_dir, bin_dir, *gems)
+  def sudo
+    ENV['THOR_SUDO'] ||= "sudo"
+    sudo = Gem.win_platform? ? "" : ENV['THOR_SUDO']
   end
   
-  def ensure_bin_wrapper_for_core_components
-    ensure_bin_wrapper_for('merb-core', 'rake', 'rspec', 'thor', 'merb-gen')
+  def local_gemspecs(directory = gem_dir)
+    if File.directory?(specs_dir = File.join(directory, 'specifications'))
+      Dir[File.join(specs_dir, '*.gemspec')].map do |gemspec_path|
+        gemspec = Gem::Specification.load(gemspec_path)
+        gemspec.loaded_from = gemspec_path
+        gemspec
+      end
+    else
+      []
+    end
   end
   
 end
 
 ##############################################################################
 
-class Merb < Thor
-  
-  extend GemManagement
-  
-  # Default Git repositories
-  def self.default_repos
-    @_default_repos ||= { 
-      'merb-core'     => "git://github.com/wycats/merb-core.git",
-      'merb-more'     => "git://github.com/wycats/merb-more.git",
-      'merb-plugins'  => "git://github.com/wycats/merb-plugins.git",
-      'extlib'        => "git://github.com/sam/extlib.git",
-      'dm-core'       => "git://github.com/sam/dm-core.git",
-      'dm-more'       => "git://github.com/sam/dm-more.git",
-      'do'            => "git://github.com/sam/do.git",
-      'thor'          => "git://github.com/wycats/thor.git",
-      'minigems'      => "git://github.com/fabien/minigems.git"
-    }
-  end
+$SILENT = true # don't output all the mess some rake package tasks spit out
 
-  # Git repository sources - pass source_config option to load a yaml 
-  # configuration file - defaults to ./config/git-sources.yml and
-  # ~/.merb/git-sources.yml - which need to create yourself if desired. 
-  #
-  # Example of contents:
-  #
-  # merb-core: git://github.com/myfork/merb-core.git
-  # merb-more: git://github.com/myfork/merb-more.git
-  def self.repos(source_config = nil)
-    source_config ||= begin
-      local_config = File.join(Dir.pwd, 'config', 'git-sources.yml')
-      user_config  = File.join(ENV["HOME"] || ENV["APPDATA"], '.merb', 'git-sources.yml')
-      File.exists?(local_config) ? local_config : user_config
-    end
-    if source_config && File.exists?(source_config)
-      default_repos.merge(YAML.load(File.read(source_config)))
-    else
-      default_repos
-    end
-  end
-  
+module Merb
+    
   class Dependencies < Thor
-
+    
+    # The Dependencies tasks will install dependencies based on actual application
+    # dependencies. For this, the application is queried for any dependencies.
+    # All operations will be performed within this context.
+    
+    attr_accessor :system, :local, :missing
+    
     include MerbThorHelper
     
-    # List all dependencies by extracting them from the actual application; 
-    # will differentiate between locally available gems and system gems. 
-    # Local gems will be shown with the installed gem version numbers.
-    
-    desc 'list', 'List all application dependencies'
-    method_options "--merb-root" => :optional,
-                   "--local"     => :boolean,
-                   "--system"    => :boolean
-    def list
-      partitioned = { :local => [], :system => [] }
-      (core_dependencies + extract_dependencies).each do |dependency|
-        if gem_dir && !(versions = find_dependency_versions(dependency)).empty?
-          partitioned[:local]  << "#{dependency} [#{versions.join(', ')}]"
-        else
-          partitioned[:system] << "#{dependency}"
-        end
-      end
-      none = options[:system].nil? && options[:local].nil?
-      if (options[:system] || none) && !partitioned[:system].empty?
-        message "System dependencies:"
-        partitioned[:system].each { |str| puts "- #{str}" }
-      end
-      if (options[:local] || none) && !partitioned[:local].empty?
-        message "Local dependencies:"
-        partitioned[:local].each  { |str| puts "- #{str}" }
-      end
-    end
+    global_method_options = {
+      "--merb-root"            => :optional,  # the directory to operate on
+      "--include-dependencies" => :boolean,   # gather sub-dependencies
+      "--stack"                => :boolean,   # gather only stack dependencies
+      "--no-stack"             => :boolean,   # gather only non-stack dependencies
+      "--config"               => :boolean,   # gather dependencies from yaml config
+      "--config-file"          => :optional,  # gather from the specified yaml config
+      "--version"              => :optional   # gather specific version of framework
+    }
     
-    # Install the gems listed in dependencies.yml from RubyForge (stable).
-    # Will also install local bin wrappers for known components.
+    method_options global_method_options
+    def initialize(*args); super; end
     
-    desc 'install', 'Install the gems listed in ./config/dependencies.yml'
-    method_options "--merb-root" => :optional,
-                   "--cache"     => :boolean,
-                   "--binaries"  => :boolean
-    def install
-      if File.exists?(config_file)
-        dependencies = parse_dependencies_yaml(File.read(config_file))
-        gems = Gems.new
-        gems.options = options
-        dependencies.each do |dependency|
-          v = dependency.version_requirements
-          gems.install_gem(dependency.name, :version => v, :cache => options[:cache])
+    # List application dependencies.
+    #
+    # By default all dependencies are listed, partitioned into system, local and
+    # currently missing dependencies. The first argument allows you to filter
+    # on any of the partitionings. A second argument can be used to filter on
+    # a set of known components, like all merb-more gems for example.
+    # 
+    # Examples:
+    #
+    # merb:dependencies:list                                    # list all dependencies - the default
+    # merb:dependencies:list local                              # list only local gems
+    # merb:dependencies:list all merb-more                      # list only merb-more related dependencies
+    # merb:dependencies:list --stack                            # list framework dependencies
+    # merb:dependencies:list --no-stack                         # list 3rd party dependencies
+    # merb:dependencies:list --config                           # list dependencies from the default config
+    # merb:dependencies:list --config-file file.yml             # list from the specified config file
+       
+    desc 'list [all|local|system|missing] [comp]', 'Show application dependencies'
+    def list(filter = 'all', comp = nil)
+      deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
+      self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      case filter
+      when 'all'
+        message 'Installed system gem dependencies:' 
+        display_gemspecs(system)
+        message 'Installed local gem dependencies:'
+        display_gemspecs(local)
+        unless missing.empty?
+          error 'Missing gem dependencies:'
+          display_dependencies(missing)
         end
-        # if options[:binaries] is set this is already taken care of - skip it
-        ensure_bin_wrapper_for_core_components unless options[:binaries]
+      when 'system'
+        message 'Installed system gem dependencies:'
+        display_gemspecs(system)
+      when 'local'
+        message 'Installed local gem dependencies:'
+        display_gemspecs(local)
+      when 'missing'
+        error 'Missing gem dependencies:'
+        display_dependencies(missing)
       else
-        error "No configuration file found at #{config_file}"
-        error "Please run merb:dependencies:configure first."
+        warning "Invalid listing filter '#{filter}'"
+      end
+      if missing.size > 0
+        info "Some dependencies are currently missing!"
+      elsif local.size == deps.size
+        info "All dependencies have been bundled with the application."
+      elsif local.size > system.size
+        info "Most dependencies have been bundled with the application."
+      elsif system.size > 0 && local.size > 0
+        info "Some dependencies have been bundled with the application."  
+      elsif local.empty? && system.size == deps.size
+        info "All dependencies are available on the system."
       end
     end
     
-    # Retrieve all application dependencies and store them in a local
-    # configuration file at ./config/dependencies.yml
+    # Install application dependencies.
+    #
+    # By default all required dependencies are installed. The first argument 
+    # specifies which strategy to use: stable or edge. A second argument can be 
+    # used to filter on a set of known components.
+    #
+    # Existing dependencies will be clobbered; when :force => true then all gems
+    # will be cleared first, otherwise only existing local dependencies of the
+    # gems to be installed will be removed.
     # 
-    # The format of this YAML file is as follows:
-    # - merb_helpers (>= 0, runtime)
-    # - merb-slices (> 0.9.4, runtime)
-    
-    desc 'configure', 'Retrieve and store dependencies in ./config/dependencies.yml'
-    method_options "--merb-root" => :optional,
-                   "--force"     => :boolean
-    def configure
-      entries = (core_dependencies + extract_dependencies).map { |d| d.to_s }
-      FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
-      config = YAML.dump(entries)
-      puts "#{config}\n"
-      if File.exists?(config_file) && !options[:force]
-        error "File already exists! Use --force to overwrite."
-      else
-        File.open(config_file, 'w') { |f| f.write config }
-        success "Written #{config_file}:"
-      end
-    rescue  
-      error "Failed to write to #{config_file}"  
-    end
+    # Examples:
+    #
+    # merb:dependencies:install                                 # install all dependencies using stable strategy
+    # merb:dependencies:install stable --version 0.9.8          # install a specific version of the framework
+    # merb:dependencies:install stable missing                  # install currently missing gems locally
+    # merb:dependencies:install stable merb-more                # install only merb-more related dependencies
+    # merb:dependencies:install stable --stack                  # install framework dependencies
+    # merb:dependencies:install stable --no-stack               # install 3rd party dependencies
+    # merb:dependencies:install stable --config                 # read dependencies from the default config
+    # merb:dependencies:install stable --config-file file.yml   # read from the specified config file
+    #
+    # In addition to the options above, edge install uses the following: 
+    #
+    # merb:dependencies:install edge                            # install all dependencies using edge strategy
+    # merb:dependencies:install edge --sources file.yml         # install edge from the specified git sources config
     
-    protected
+    desc 'install [stable|edge] [comp]', 'Install application dependencies'
+    method_options "--sources" => :optional, # only for edge strategy
+                   "--local"   => :boolean,  # force local install
+                   "--dry-run" => :boolean, 
+                   "--force"   => :boolean                   
+    def install(strategy = 'stable', comp = nil)
+      if strategy?(strategy)
+        # Force local dependencies by creating ./gems before proceeding
+        create_if_missing(default_gem_dir) if options[:local]
+        
+        where = gem_dir ? 'locally' : 'system-wide'
         
-    # Extract the runtime dependencies by starting the application in runner mode.
-    def extract_dependencies
-      FileUtils.cd(working_dir) do
-        cmd = ["require 'yaml';"]
-        cmd << "dependencies = Merb::BootLoader::Dependencies.dependencies"
-        cmd << "entries = dependencies.map { |d| d.to_s }"
-        cmd << "puts YAML.dump(entries)"
-        output = `merb -r "#{cmd.join("\n")}"`
-        if index = (lines = output.split(/\n/)).index('--- ')
-          yaml = lines.slice(index, lines.length - 1).join("\n")
-          return parse_dependencies_yaml(yaml)
+        # When comp == 'missing' then filter on missing dependencies
+        if only_missing = comp == 'missing'
+          message "Preparing to install missing gems #{where} using #{strategy} strategy..."
+          comp = nil
+        else
+          message "Preparing to install #{where} using #{strategy} strategy..."
         end
-      end
-      return []
-    end
-    
-    # Parse the basic YAML config data, and process Gem::Dependency output.
-    # Formatting example: merb_helpers (>= 0.9.8, runtime)
-    def parse_dependencies_yaml(yaml)
-      dependencies = []
-      entries = YAML.load(yaml) rescue []
-      entries.each do |entry|
-        if matches = entry.match(/^(\S+) \(([^,]+)?, ([^\)]+)\)/)
-          name, version_req, type = matches.captures
-          dependencies << Gem::Dependency.new(name, version_req, type.to_sym)
+        
+        # If comp given, filter on known stack components
+        deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
+        self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+        
+        # Only install currently missing gems (for comp == missing)
+        if only_missing
+          deps.reject! { |dep| not missing.include?(dep) }
+        end
+        
+        if deps.empty?
+          warning "No dependencies to install..."
         else
-          error "Invalid entry: #{entry}"
+          puts "#{deps.length} dependencies to install..."
+          install_dependencies(strategy, deps)
         end
-      end
-      dependencies
+        
+        # Show current dependency info now that we're done
+        puts # Seperate output
+        list('local', comp)
+      else
+        warning "Invalid install strategy '#{strategy}'"
+        puts
+        message "Please choose one of the following installation strategies: stable or edge:"
+        puts "$ thor merb:dependencies:install stable"
+        puts "$ thor merb:dependencies:install edge"
+      end      
     end
     
-  end  
-
-  # Install a Merb stack from stable RubyForge gems. Optionally install a
-  # suitable Rack adapter/server when setting --adapter to one of the
-  # following: mongrel, emongrel, thin or ebb. Or with --orm, install a
-  # supported ORM: datamapper, activerecord or sequel 
-
-  desc 'stable', 'Install extlib, merb-core and merb-more from rubygems'
-  method_options "--merb-root" => :optional,
-                 "--adapter"   => :optional,
-                 "--orm"       => :optional
-  def stable
-    adapters = { 
-      'mongrel'       => ['mongrel'], 
-      'emongrel'      => ['emongrel'],
-      'thin'          => ['thin'], 
-      'ebb'           => ['ebb']
-    }
-    orms = {
-      'datamapper'    => ['dm-core'], 
-      'activerecord'  => ['activerecord'],
-      'sequel'        => ['sequel']
-    }
-    stable = Stable.new
-    stable.options = options
-    if stable.core && stable.more
-      success "Installed extlib, merb-core and merb-more"
-      if options[:adapter] && adapters[options[:adapter]]
-        stable.refresh_from_gems(*adapters[options[:adapter]])
-        success "Installed #{options[:adapter]}"
-      elsif options[:adapter]
-        error "Please specify one of the following adapters: #{adapters.keys.join(' ')}"
-      end
-      if options[:orm] && orms[options[:orm]]
-        stable.refresh_from_gems(*orms[options[:orm]])
-        success "Installed #{options[:orm]}"
-      elsif options[:orm]
-        error "Please specify one of the following orms: #{orms.keys.join(' ')}"
-      end
-    end
-  end
-
-  class Stable < Thor
-
-    # The Stable tasks deal with known -stable- gems; available
-    # as shortcuts to Merb and DataMapper gems.
+    # Uninstall application dependencies.
     #
-    # These are pulled from rubyforge and installed into into the
-    # desired gems dir (either system-wide or into the application's
-    # gems directory).
-
-    include MerbThorHelper
-
-    # Gets latest gem versions from RubyForge and installs them.
+    # By default all required dependencies are installed. An optional argument 
+    # can be used to filter on a set of known components.
+    #
+    # Existing dependencies will be clobbered; when :force => true then all gems
+    # will be cleared, otherwise only existing local dependencies of the
+    # matching component set will be removed.
     #
     # Examples:
     #
-    # thor merb:edge:core
-    # thor merb:edge:core --merb-root ./path/to/your/app
-    # thor merb:edge:core --sources ./path/to/sources.yml
-
-    desc 'core', 'Install extlib and merb-core from rubygems'
-    method_options "--merb-root" => :optional
-    def core
-      refresh_from_gems 'extlib', 'merb-core'
-      ensure_bin_wrapper_for('merb-core', 'rake', 'rspec', 'thor')
-    end
-
-    desc 'more', 'Install merb-more from rubygems'
-    method_options "--merb-root" => :optional
-    def more
-      refresh_from_gems 'merb-more'
-      ensure_bin_wrapper_for('merb-gen')
+    # merb:dependencies:uninstall                               # uninstall all dependencies - the default
+    # merb:dependencies:uninstall merb-more                     # uninstall merb-more related gems locally
+    # merb:dependencies:uninstall --config                      # read dependencies from the default config
+    
+    desc 'uninstall [comp]', 'Uninstall application dependencies'
+    method_options "--dry-run" => :boolean, "--force" => :boolean
+    def uninstall(comp = nil)
+      # If comp given, filter on known stack components
+      deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
+      self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      # Clobber existing local dependencies - based on self.local
+      clobber_dependencies!
     end
-
-    desc 'plugins', 'Install merb-plugins from rubygems'
-    method_options "--merb-root" => :optional
-    def plugins
-      refresh_from_gems 'merb-plugins'
+    
+    # Recreate binary gems on the current platform.
+    #
+    # This task should be executed as part of a deployment setup, where the 
+    # deployment system runs this after the app has been installed.
+    # Usually triggered by Capistrano, God...
+    #
+    # It will regenerate gems from the bundled gems cache for any gem that has 
+    # C extensions - which need to be recompiled for the target deployment platform.
+    #
+    # Note: gems/cache should be in your SCM for this to work correctly.
+    
+    desc 'redeploy', 'Recreate any binary gems on the target platform'
+    method_options "--dry-run" => :boolean
+    def redeploy
+      require 'tempfile' # for Dir::tmpdir access
+      if gem_dir && File.directory?(cache_dir = File.join(gem_dir, 'cache'))
+        local_gemspecs.each do |gemspec|
+          unless gemspec.extensions.empty?
+            if File.exists?(gem_file = File.join(cache_dir, "#{gemspec.full_name}.gem"))
+              gem_file_copy = File.join(Dir::tmpdir, File.basename(gem_file))
+              if dry_run?
+                note "Recreating #{gemspec.full_name}"
+              else
+                message "Recreating #{gemspec.full_name}"
+                # Copy the gem to a temporary file, because otherwise RubyGems/FileUtils
+                # will complain about copying identical files (same source/destination).
+                FileUtils.cp(gem_file, gem_file_copy)
+                Merb::Gem.install(gem_file_copy, :install_dir => gem_dir)
+                File.delete(gem_file_copy)
+              end
+            end
+          end
+        end
+      else
+        error "No application local gems directory found"
+      end
     end
-
-    desc 'dm_core', 'Install dm-core from rubygems'
-    method_options "--merb-root" => :optional
-    def dm_core
-      refresh_from_gems 'extlib', 'dm-core'
+    
+    # Create a dependencies configuration file.
+    #
+    # A configuration yaml file will be created from the extracted application
+    # dependencies. The format of the configuration is as follows:
+    #
+    # --- 
+    # - merb-core (= 0.9.8, runtime)
+    # - merb-slices (= 0.9.8, runtime)
+    # 
+    # This format is exactly the same as Gem::Dependency#to_s returns.
+    #
+    # Examples:
+    #
+    # merb:dependencies:configure --force                       # overwrite the default config file
+    # merb:dependencies:configure --version 0.9.8               # configure specific framework version
+    # merb:dependencies:configure --config-file file.yml        # write to the specified config file 
+    
+    desc 'configure [comp]', 'Create a dependencies config file'
+    method_options "--dry-run" => :boolean, "--force" => :boolean
+    def configure(comp = nil)
+      # If comp given, filter on known stack components
+      deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
+      config = YAML.dump(deps.map { |d| d.to_s })
+      puts "#{config}\n"
+      if File.exists?(config_file) && !options[:force]
+        error "File already exists! Use --force to overwrite."
+      else
+        if dry_run?
+          note "Written #{config_file}"
+        else
+          FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
+          File.open(config_file, 'w') { |f| f.write config }
+          success "Written #{config_file}"
+        end
+      end
+    rescue  
+      error "Failed to write to #{config_file}"
+    end 
+    
+    ### Helper Methods
+    
+    def strategy?(strategy)
+      if self.respond_to?(method = :"#{strategy}_strategy", true)
+        method
+      end
     end
-
-    desc 'dm_more', 'Install dm-more from rubygems'
-    method_options "--merb-root" => :optional
-    def dm_more
-      refresh_from_gems 'extlib', 'dm-core', 'dm-more'
-    end
-    
-    desc 'do [ADAPTER, ...]', 'Install data_objects and optional adapter'
-    method_options "--merb-root" => :optional
-    def do(*adapters)
-      refresh_from_gems 'data_objects'
-      adapters.each do |adapter|
-        if adapter && DO_ADAPTERS.include?(adapter)
-          refresh_from_gems "do_#{adapter}"
-        elsif adapter
-          error "Unknown DO adapter '#{adapter}'"
+    
+    def install_dependencies(strategy, deps)
+      if method = strategy?(strategy)
+        # Clobber existing local dependencies
+        clobber_dependencies!
+    
+        # Run the chosen strategy - collect files installed from stable gems
+        installed_from_stable = send(method, deps).map { |d| d.name }
+      
+        # Sleep a bit otherwise the following steps won't see the new files
+        sleep(deps.length) if deps.length > 0
+      
+        # Leave a file to denote the strategy that has been used for this dependency
+        self.local.each do |spec|
+          next unless File.directory?(spec.full_gem_path)
+          unless installed_from_stable.include?(spec.name)
+            FileUtils.touch(File.join(spec.full_gem_path, "#{strategy}.strategy"))
+          else
+            FileUtils.touch(File.join(spec.full_gem_path, "stable.strategy"))
+          end           
+        end
+        
+        # Ask for system installation of minigem - needs sudo...
+        if deps.find { |d| d.name == 'minigems' }
+          info "Installing minigems.rb on your system..."
+          `#{sudo} minigem install`
         end
+          
+        # Add local binaries for the installed framework dependencies
+        comps = Merb::Stack.all_components & deps.map { |d| d.name }
+        comps << { :no_minigems => 'merb-gen' }
+        ensure_bin_wrapper_for(*comps)
+        return true
       end
+      false
     end
     
-    desc 'minigems', 'Install minigems (system-wide)'
-    def minigems
-      if Merb.install_gem('minigems')
-        system("#{Gem.ruby} -S minigem install")
+    def dependencies
+      if use_config?
+        # Use preconfigured dependencies from yaml file
+        deps = config_dependencies
+      else
+        # Extract dependencies from the current application
+        deps = Merb::Stack.core_dependencies(gem_dir, ignore_dependencies?)
+        deps += Merb::Dependencies.extract_dependencies(working_dir)
       end
+      
+      stack_components = Merb::Stack.components
+
+      if options[:stack]
+        # Limit to stack components only
+        deps.reject! { |dep| not stack_components.include?(dep.name) }
+      elsif options[:"no-stack"]
+        # Limit to non-stack components
+        deps.reject! { |dep| stack_components.include?(dep.name) }
+      end
+      
+      if options[:version]
+        version_req = ::Gem::Requirement.create("= #{options[:version]}")
+      elsif core = deps.find { |d| d.name == 'merb-core' }
+        version_req = core.version_requirements
+      end
+      
+      if version_req
+        # Handle specific version requirement for framework components
+        framework_components = Merb::Stack.framework_components
+        deps.each do |dep|
+          if framework_components.include?(dep.name)
+            dep.version_requirements = version_req
+          end
+        end
+      end
+            
+      deps
     end
     
-    # Pull from RubyForge and install.
-    def refresh_from_gems(*components)
-      opts = components.last.is_a?(Hash) ? components.pop : {}
-      gems = Gems.new
-      gems.options = options
-      components.all? { |name| gems.install_gem(name, opts) }
+    def config_dependencies
+      if File.exists?(config_file)
+        self.class.parse_dependencies_yaml(File.read(config_file))
+      else
+        []
+      end
     end
-
-  end
-
-  # Retrieve latest Merb versions from git and optionally install them.
-  #
-  # Note: the --sources option takes a path to a YAML file
-  # with a regular Hash mapping gem names to git urls.
-  #
-  # Examples:
-  #
-  # thor merb:edge
-  # thor merb:edge --install
-  # thor merb:edge --merb-root ./path/to/your/app
-  # thor merb:edge --sources ./path/to/sources.yml
-
-  desc 'edge', 'Install extlib, merb-core and merb-more from git HEAD'
-  method_options "--merb-root" => :optional,
-                 "--sources"   => :optional,
-                 "--install"   => :boolean
-  def edge
-    edge = Edge.new
-    edge.options = options
-    edge.core
-    edge.more
-    edge.custom
-  end
-
-  class Edge < Thor
-
-    # The Edge tasks deal with known gems from the bleeding edge; available
-    # as shortcuts to Merb and DataMapper gems.
-    #
-    # These are pulled from git and optionally installed into into the
-    # desired gems dir (either system-wide or into the application's
-    # gems directory).
-
-    include MerbThorHelper
-
-    # Gets latest gem versions from git - optionally installs them.
-    #
-    # Note: the --sources option takes a path to a YAML file
-    # with a regular Hash mapping gem names to git urls,
-    # allowing pulling forks of the official repositories.
-    #
-    # Examples:
-    #
-    # thor merb:edge:core
-    # thor merb:edge:core --install
-    # thor merb:edge:core --merb-root ./path/to/your/app
-    # thor merb:edge:core --sources ./path/to/sources.yml
-
-    desc 'core', 'Update extlib and merb-core from git HEAD'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def core
-      refresh_from_source 'thor'
-      refresh_from_source 'extlib', 'merb-core'
-      ensure_bin_wrapper_for('merb-core', 'rake', 'rspec', 'thor')
+    
+    def use_config?
+      options[:config] || options[:"config-file"]
     end
-
-    desc 'more', 'Update merb-more from git HEAD'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def more
-      refresh_from_source 'merb-more'
-      ensure_bin_wrapper_for('merb-gen')
+    
+    def config_file
+      @config_file ||= begin
+        options[:"config-file"] || File.join(working_dir, 'config', 'dependencies.yml')
+      end
     end
-
-    desc 'plugins', 'Update merb-plugins from git HEAD'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def plugins
-      refresh_from_source 'merb-plugins'
+    
+    def config_dir
+      File.dirname(config_file)
     end
-
-    desc 'dm_core', 'Update dm-core from git HEAD'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def dm_core
-      refresh_from_source 'extlib', 'dm-core'
+    
+    ### Strategy handlers
+    
+    private
+    
+    def stable_strategy(deps)
+      installed_from_rubygems = []
+      if core = deps.find { |d| d.name == 'merb-core' }
+        if dry_run?
+          note "Installing #{core.name}..."
+        else
+          if install_dependency(core)
+            installed_from_rubygems << core
+          else
+            msg = "Try specifying a lower version of merb-core with --version"
+            if version_no = core.version_requirements.to_s[/([\.\d]+)$/, 1]
+              num = "%03d" % (version_no.gsub('.', '').to_i - 1)
+              puts "The required version (#{version_no}) probably isn't available as a stable rubygem yet."
+              info "#{msg} #{num.split(//).join('.')}"
+            else
+              puts "The required version probably isn't available as a stable rubygem yet."
+              info msg
+            end           
+          end
+        end
+      end
+      
+      deps.each do |dependency|
+        next if dependency.name == 'merb-core'
+        if dry_run?
+          note "Installing #{dependency.name}..."
+        else
+          install_dependency(dependency)
+          installed_from_rubygems << dependency
+        end        
+      end
+      installed_from_rubygems
     end
-
-    desc 'dm_more', 'Update dm-more from git HEAD'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def dm_more
-      refresh_from_source 'extlib', 'dm-core', 'dm-more'
-    end
-    
-    desc 'do [ADAPTER, ...]', 'Install data_objects and optional adapter'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def do(*adapters)
-      source = Source.new
-      source.options = options
-      source.clone('do')
-      source.install('do/data_objects')
-      adapters.each do |adapter|
-        if adapter && DO_ADAPTERS.include?(adapter)
-          source.install("do/do_#{adapter}")
-        elsif adapter
-          error "Unknown DO adapter '#{adapter}'"
+    
+    def edge_strategy(deps)
+      installed_from_rubygems = []
+      
+      # Selectively update repositories for the matching dependencies
+      update_dependency_repositories(deps) unless dry_run?
+      
+      # Skip gem dependencies to prevent them from being installed from stable;
+      # however, core dependencies will be retrieved from source when available
+      install_opts = { :ignore_dependencies => true }
+      if core = deps.find { |d| d.name == 'merb-core' }
+        if dry_run?
+          note "Installing #{core.name}..."
+        else
+          if install_dependency_from_source(core, install_opts)
+          elsif install_dependency(core, install_opts)
+            info "Installed #{core.name} from rubygems..."
+            installed_from_rubygems << core
+          end
         end
       end
+      
+      deps.each do |dependency|
+        next if dependency.name == 'merb-core'
+        if dry_run?
+          note "Installing #{dependency.name}..."
+        else
+          if install_dependency_from_source(dependency, install_opts)
+          elsif install_dependency(dependency, install_opts)
+            info "Installed #{dependency.name} from rubygems..."
+            installed_from_rubygems << dependency
+          end
+        end        
+      end
+      
+      installed_from_rubygems
     end
-
-    desc 'custom', 'Update all the custom repos from git HEAD'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional,
-                   "--install"   => :boolean
-    def custom
-      custom_repos = Merb.repos.keys - Merb.default_repos.keys
-      refresh_from_source *custom_repos
+    
+    ### Class Methods
+    
+    public
+    
+    def self.list(filter = 'all', comp = nil, options = {})
+      instance = Merb::Dependencies.new
+      instance.options = options
+      instance.list(filter, comp)
     end
-
-    desc 'minigems', 'Install minigems from git HEAD (system-wide)'
-    method_options "--merb-root" => :optional,
-                   "--sources"   => :optional
-    def minigems
-      source = Source.new
-      source.options = options
-      source.clone('minigems')
-      if Merb.install_gem_from_src(File.join(source_dir, 'minigems'))
-        system("#{Gem.ruby} -S minigem install")
+    
+    # Extract application dependencies by querying the app directly.
+    def self.extract_dependencies(merb_root, env = 'production')
+      require 'merb-core'
+      if !@_merb_loaded || Merb.root != merb_root
+        Merb.start_environment(
+          :testing => true, 
+          :adapter => 'runner', 
+          :environment => env, 
+          :merb_root => merb_root
+        )
+        @_merb_loaded = true
       end
+      Merb::BootLoader::Dependencies.dependencies
+    rescue => e
+      error "Couldn't extract dependencies from application!"
+      error e.message
+      
+      p e.backtrace
+      
+      puts  "Make sure you're executing the task from your app (--merb-root), or"
+      puts  "specify a config option (--config or --config-file=YAML_FILE)"
+      return []
     end
-
-    # Pull from git and optionally install the resulting gems.
-    def refresh_from_source(*components)
-      opts = components.last.is_a?(Hash) ? components.pop : {}
-      source = Source.new
-      source.options = options
-      components.each do |name|
-        source.clone(name)
-        source.install_from_src(name, opts) if options[:install]
+        
+    # Parse the basic YAML config data, and process Gem::Dependency output.
+    # Formatting example: merb_helpers (>= 0.9.8, runtime)
+    def self.parse_dependencies_yaml(yaml)
+      dependencies = []
+      entries = YAML.load(yaml) rescue []
+      entries.each do |entry|
+        if matches = entry.match(/^(\S+) \(([^,]+)?, ([^\)]+)\)/)
+          name, version_req, type = matches.captures
+          dependencies << ::Gem::Dependency.new(name, version_req, type.to_sym)
+        else
+          error "Invalid entry: #{entry}"
+        end
       end
+      dependencies
     end
-
-  end
-
-  class Source < Thor
-
-    # The Source tasks deal with gem source packages - mainly from github.
-    # Any directory inside ./src is regarded as a gem that can be packaged
-    # and installed from there into the desired gems dir (either system-wide
-    # or into the application's gems directory).
-
+    
+  end  
+  
+  class Stack < Thor
+    
+    # The Stack tasks will install dependencies based on known sets of gems,
+    # regardless of actual application dependency settings.
+    
+    DM_STACK = %w[
+      dm-core
+      dm-aggregates
+      dm-migrations
+      dm-timestamps
+      dm-types
+      dm-validations
+    ]
+    
+    MERB_STACK = %w[
+      minigems
+      
+      merb-core
+      merb-action-args
+      merb-assets
+      merb-cache
+      merb-helpers
+      merb-mailer
+      merb-slices
+      merb-auth
+    ] + DM_STACK
+    
+    MERB_BASICS = %w[
+      minigems
+      
+      merb-core
+      merb-action-args
+      merb-assets
+      merb-cache
+      merb-helpers
+      merb-mailer
+      merb-slices
+    ]
+    
+    # The following sets are meant for repository lookup; unlike the sets above
+    # these correspond to specific git repository items.
+    
+    MERB_MORE = %w[
+      merb-action-args
+      merb-assets
+      merb-auth
+      merb-auth-core
+      merb-auth-more 
+      merb-auth-slice-password
+      merb-cache
+      merb-exceptions
+      merb-gen
+      merb-haml
+      merb-helpers
+      merb-mailer
+      merb-param-protection
+      merb-slices
+      merb_datamapper
+    ]
+    
+    MERB_PLUGINS = %w[
+      merb_activerecord
+      merb_builder
+      merb_jquery
+      merb_laszlo
+      merb_parts
+      merb_screw_unit
+      merb_sequel
+      merb_stories
+      merb_test_unit
+    ]
+    
+    DM_MORE = %w[
+      dm-adjust
+      dm-aggregates
+      dm-ar-finders
+      dm-cli
+      dm-constraints
+      dm-is-example
+      dm-is-list
+      dm-is-nested_set
+      dm-is-remixable
+      dm-is-searchable
+      dm-is-state_machine
+      dm-is-tree
+      dm-is-versioned
+      dm-migrations
+      dm-observer
+      dm-querizer
+      dm-serializer
+      dm-shorthand
+      dm-sweatshop
+      dm-tags
+      dm-timestamps
+      dm-types
+      dm-validations
+      
+      dm-couchdb-adapter
+      dm-ferret-adapter
+      dm-rest-adapter
+    ]
+    
+    attr_accessor :system, :local, :missing
+    
     include MerbThorHelper
-
-    # Install a particular gem from source.
-    #
-    # If a local ./gems dir is found, or --merb-root is given
-    # the gems will be installed locally into that directory.
-    #
-    # Note that this task doesn't retrieve any (new) source from git;
-    # To update and install you'd execute the following two tasks:
+    
+    global_method_options = {
+      "--merb-root"            => :optional,  # the directory to operate on
+      "--include-dependencies" => :boolean,   # gather sub-dependencies
+      "--version"              => :optional   # gather specific version of framework    
+    }
+    
+    method_options global_method_options
+    def initialize(*args); super; end
+    
+    # List components and their dependencies.
     #
-    # thor merb:source:update merb-core
-    # thor merb:source:install merb-core
+    # Examples:
+    # 
+    # merb:stack:list                                           # list all standard stack components
+    # merb:stack:list all                                       # list all component sets
+    # merb:stack:list merb-more                                 # list all dependencies of merb-more
+  
+    desc 'list [all|comp]', 'List available components (optionally filtered, defaults to merb stack)'
+    def list(comp = 'stack')
+      if comp == 'all'
+        Merb::Stack.component_sets.keys.sort.each do |comp|
+          unless (components = Merb::Stack.component_sets[comp]).empty?
+            message "Dependencies for '#{comp}' set:"
+            components.each { |c| puts "- #{c}" }
+          end
+        end
+      else
+        message "Dependencies for '#{comp}' set:"
+        Merb::Stack.components(comp).each { |c| puts "- #{c}" }
+      end      
+    end
+    
+    # Install stack components or individual gems - from stable rubygems by default.
     #
-    # Alternatively, look at merb:edge and merb:edge:* with --install.
+    # See also: Merb::Dependencies#install and Merb::Dependencies#install_dependencies
     #
     # Examples:
     #
-    # thor merb:source:install merb-core
-    # thor merb:source:install merb-more
-    # thor merb:source:install merb-more/merb-slices
-    # thor merb:source:install merb-plugins/merb_helpers
-    # thor merb:source:install merb-core --merb-root ./path/to/your/app
-
-    desc 'install GEM_NAME', 'Install a rubygem from (git) source'
-    method_options "--merb-root" => :optional
-    def install(name)
-      message "Installing #{name}..."
-      install_from_src(name)
-    rescue => e
-      error "Failed to install #{name} (#{e.message})"
+    # merb:stack:install                                        # install the default merb stack
+    # merb:stack:install basics                                 # install a basic set of dependencies
+    # merb:stack:install merb-core                              # install merb-core from stable
+    # merb:stack:install merb-more --edge                       # install merb-core from edge
+    # merb:stack:install merb-core thor merb-slices             # install the specified gems                  
+      
+    desc 'install [COMP, ...]', 'Install stack components'
+    method_options  "--edge"      => :boolean,
+                    "--sources"   => :optional,
+                    "--force"     => :boolean,
+                    "--dry-run"   => :boolean,
+                    "--strategy"  => :optional
+    def install(*comps)
+      mngr = self.dependency_manager
+      deps = gather_dependencies(comps)
+      mngr.system, mngr.local, mngr.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      mngr.install_dependencies(strategy, deps)
     end
-
-    # Clone a git repository into ./src. The repository can be
-    # a direct git url or a known -named- repository.
+        
+    # Uninstall stack components or individual gems.
     #
-    # Examples:
+    # See also: Merb::Dependencies#uninstall
     #
-    # thor merb:source:clone dm-core
-    # thor merb:source:clone dm-core --sources ./path/to/sources.yml
-    # thor merb:source:clone git://github.com/sam/dm-core.git
-
-    desc 'clone REPOSITORY', 'Clone a git repository into ./src'
-    method_options "--sources" => :optional
-    def clone(repository)
-      if repository =~ /^git:\/\//
-        repository_url = repository
-      elsif url = Merb.repos(options[:sources])[repository]
-        repository_url = url
+    # Examples:
+    # merb:stack:uninstall                                      # uninstall the default merb stack
+    # merb:stack:uninstall merb-more                            # uninstall merb-more
+    # merb:stack:uninstall merb-core thor merb-slices           # uninstall the specified gems
+    
+    desc 'uninstall [COMP, ...]', 'Uninstall stack components'
+    method_options "--dry-run" => :boolean, "--force" => :boolean
+    def uninstall(*comps)
+      deps = gather_dependencies(comps)
+      self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      # Clobber existing local dependencies - based on self.local
+      clobber_dependencies!
+    end
+    
+    protected
+    
+    def gather_dependencies(comps = [])
+      if comps.empty?
+        gems = MERB_STACK
+      else
+        gems = comps.map { |c| Merb::Stack.components(c) }.flatten
       end
-
-      if repository_url
-        repository_name = repository_url[/([\w+|-]+)\.git/u, 1]
-        fork_name = repository_url[/.com\/+?(.+)\/.+\.git/u, 1]
-        local_repo_path =  "#{source_dir}/#{repository_name}"
-
-        if File.directory?(local_repo_path)
-          puts "\n#{repository_name} repository exists, updating or branching instead of cloning..."
-          FileUtils.cd(local_repo_path) do
-
-            # To avoid conflicts we need to set a remote branch for non official repos
-            existing_repos  = `git remote -v`.split("\n").map{|branch| branch.split(/\s+/)}
-            origin_repo_url = existing_repos.detect{ |r| r.first == "origin" }.last
-
-            # Pull from the original repository - no branching needed
-            if repository_url == origin_repo_url
-              puts "Pulling from #{repository_url}"
-              system %{
-                git fetch
-                git checkout master
-                git rebase origin/master
-              }
-            # Update and switch to a branch for a particular github fork
-            elsif existing_repos.map{ |r| r.last }.include?(repository_url)
-              puts "Switching to remote branch: #{fork_name}"
-              `git checkout -b #{fork_name} #{fork_name}/master`
-              `git rebase #{fork_name}/master`
-            # Create a new remote branch for a particular github fork
-            else
-              puts "Add a new remote branch: #{fork_name}"
-              `git remote add -f #{fork_name} #{repository_url}`
-              `git checkout -b#{fork_name} #{fork_name}/master`
-            end
-          end
+      
+      version_req = if options[:version]
+        ::Gem::Requirement.create(options[:version])
+      end
+      
+      framework_components = Merb::Stack.framework_components
+      
+      gems.map do |gem|
+        if version_req && framework_components.include?(gem)
+          ::Gem::Dependency.new(gem, version_req)
         else
-          FileUtils.cd(source_dir) do
-            puts "\nCloning #{repository_name} repository from #{repository_url}..."
-            system("git clone --depth 1 #{repository_url} ")
-          end
+          ::Gem::Dependency.new(gem, ::Gem::Requirement.default)
         end
+      end
+    end
+    
+    def strategy
+      options[:strategy] || (options[:edge] ? 'edge' : 'stable')
+    end
+    
+    def dependency_manager
+      @_dependency_manager ||= begin
+        instance = Merb::Dependencies.new
+        instance.options = options
+        instance
+      end
+    end
+    
+    public
+    
+    def self.repository_sets
+      @_repository_sets ||= begin
+        # the component itself as a fallback
+        comps = Hash.new { |(hsh,c)| [c] }
+        
+        # git repository based component sets
+        comps["merb"]         = ["merb-core"] + MERB_MORE
+        comps["merb-more"]    = MERB_MORE.sort
+        comps["merb-plugins"] = MERB_PLUGINS.sort
+        comps["dm-more"]      = DM_MORE.sort
         
-        # We don't want to have our source directory under sudo permissions
-        # even if clone (with --install) is called with sudo. Maybe there's
-        # a better way, but this works.
-        neutralise_sudo_for(local_repo_path)
+        comps
+      end     
+    end
+    
+    def self.component_sets
+      @_component_sets ||= begin
+        # the component itself as a fallback
+        comps = Hash.new { |(hsh,c)| [c] }
+        comps.update(repository_sets)
+        
+        # specific set of dependencies
+        comps["stack"]        = MERB_STACK.sort
+        comps["basics"]       = MERB_BASICS.sort
+        
+        # orm dependencies
+        comps["datamapper"]   = DM_STACK.sort
+        comps["sequel"]       = ["merb_sequel", "sequel"]
+        comps["activerecord"] = ["merb_activerecord", "activerecord"]
+        
+        comps
+      end
+    end
+    
+    def self.framework_components
+      %w[merb-core merb-more merb-plugins].inject([]) do |all, comp| 
+        all + components(comp)
+      end
+    end
+    
+    def self.components(comp = nil)
+      if comp
+        component_sets[comp]
       else
-        error "No valid repository url given"
+        comps = %w[merb-core merb-more merb-plugins dm-core dm-more]
+        comps.inject([]) do |all, grp|
+          all + (component_sets[grp] || [])
+        end
       end
     end
-
-    # Update a specific gem source directory from git. See #clone.
-
-    desc 'update REPOSITORY', 'Update a git repository in ./src'
-    alias :update :clone
-
-    # Update all gem sources from git - based on the current branch.
-    # Optionally install the gems when --install is specified.
-    
-    desc 'refresh', 'Pull fresh copies of all source gems'
-    method_options "--install" => :boolean
-    def refresh
-      repos = Dir["#{source_dir}/*"]
-      repos.each do |repo|
-        next unless File.directory?(repo) && File.exists?(File.join(repo, '.git'))
-        FileUtils.cd(repo) do
-          gem_name = File.basename(repo)
-          message "Refreshing #{gem_name}"
-          system %{git fetch}
-          branch = `git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1) /'`[/\* (.+)/, 1]
-          system %{git rebase #{branch}}
-          install(gem_name) if options[:install]
+    
+    def self.select_component_dependencies(dependencies, comp = nil)
+      comps = components(comp) || []
+      dependencies.select { |dep| comps.include?(dep.name) }
+    end
+    
+    def self.base_components
+      %w[thor rake]
+    end
+    
+    def self.all_components
+      base_components + framework_components
+    end
+    
+    # Find the latest merb-core and gather its dependencies.
+    # We check for 0.9.8 as a minimum release version.
+    def self.core_dependencies(gem_dir = nil, ignore_deps = false)
+      @_core_dependencies ||= begin
+        if gem_dir # add local gems to index
+          ::Gem.clear_paths; ::Gem.path.unshift(gem_dir)
+        end
+        deps = []
+        merb_core = ::Gem::Dependency.new('merb-core', '>= 0.9.8')
+        if gemspec = ::Gem.source_index.search(merb_core).last
+          deps << ::Gem::Dependency.new('merb-core', gemspec.version)
+          if ignore_deps 
+            deps += gemspec.dependencies.select do |d| 
+              base_components.include?(d.name)
+            end
+          else
+            deps += gemspec.dependencies
+          end
         end
-        neutralise_sudo_for(repo)
+        ::Gem.clear_paths if gem_dir # reset
+        deps
       end
     end
     
-    def install_from_src(name, opts = {})
-      gem_src_dir = File.join(source_dir, name)
-      defaults = {}
-      defaults[:install_dir] = gem_dir if gem_dir
-      Merb.install_gem_from_src(gem_src_dir, defaults.merge(opts))
+    def self.lookup_repository_name(item)
+      set_name = nil
+      # The merb repo contains -more as well, so it needs special attention
+      return 'merb' if self.repository_sets['merb'].include?(item)
+      
+      # Proceed with finding the item in a known component set
+      self.repository_sets.find do |set, items| 
+        next if set == 'merb'
+        items.include?(item) ? (set_name = set) : nil
+      end
+      set_name
     end
-
+    
   end
-
-  class Gems < Thor
-
-    # The Gems tasks deal directly with rubygems, either through remotely
-    # available sources (rubyforge for example) or by searching the
-    # system-wide gem cache for matching gems. The gems are installed from
-    # there into the desired gems dir (either system-wide or into the
-    # application's gems directory).
-
+  
+  class Tasks < Thor
+    
     include MerbThorHelper
-
-    # Install a gem and its dependencies.
+    
+    # Show merb.thor version information
     #
-    # If a local ./gems dir is found, or --merb-root is given
-    # the gems will be installed locally into that directory.
+    # merb:tasks:version                                        # show the current version info
+    # merb:tasks:version --info                                 # show extended version info
+    
+    desc 'version', 'Show verion info'
+    method_options "--info" => :boolean
+    def version
+      message "Currently installed merb.thor version: #{MERB_THOR_VERSION}"
+      if options[:version]
+        self.options = { :"dry-run" => true }
+        self.update # run update task with dry-run enabled
+      end
+    end
+    
+    # Update merb.thor tasks from remotely available version
     #
-    # The option --cache will look in the system's gem cache
-    # for the latest version and install it in the apps' gems.
-    # This is particularly handy for gems that aren't available
-    # through rubyforge.org - like in-house merb slices etc.
+    # merb:tasks:update                                        # update merb.thor
+    # merb:tasks:update --force                                # force-update merb.thor
+    # merb:tasks:update --dry-run                              # show version info only
+    
+    desc 'update [URL]', 'Fetch the latest merb.thor and install it locally'
+    method_options "--dry-run" => :boolean, "--force" => :boolean
+    def update(url = 'http://merbivore.com/merb.thor')
+      require 'open-uri'
+      require 'rubygems/version'
+      remote_file = open(url)
+      code = remote_file.read
+      
+      # Extract version information from the source code
+      if version = code[/^MERB_THOR_VERSION\s?=\s?('|")([\.\d]+)('|")/,2]
+        # borrow version comparison from rubygems' Version class
+        current_version = ::Gem::Version.new(MERB_THOR_VERSION)
+        remote_version  = ::Gem::Version.new(version)
+        
+        if current_version >= remote_version
+          puts "currently installed: #{current_version}"
+          if current_version != remote_version
+            puts "available version:   #{remote_version}"
+          end
+          info "No update of merb.thor necessary#{options[:force] ? ' (forced)' : ''}"
+          proceed = options[:force]
+        elsif current_version < remote_version
+          puts "currently installed: #{current_version}"
+          puts "available version:   #{remote_version}"
+          proceed = true
+        end
+          
+        if proceed && !dry_run?
+          File.open(File.join(__FILE__), 'w') do |f|
+            f.write(code)
+          end
+          success "Installed the latest merb.thor (v#{version})"
+        end
+      else
+        raise "invalid source-code data"
+      end      
+    rescue OpenURI::HTTPError
+      error "Error opening #{url}"
+    rescue => e
+      error "An error occurred (#{e.message})"
+    end
+    
+  end
+  
+  #### MORE LOW-LEVEL TASKS ####
+  
+  class Gem < Thor
+    
+    group 'core'
+    
+    include MerbThorHelper
+    extend GemManagement
+    
+    attr_accessor :system, :local, :missing
+    
+    global_method_options = {
+      "--merb-root"            => :optional,  # the directory to operate on
+      "--version"              => :optional,  # gather specific version of gem
+      "--ignore-dependencies"  => :boolean    # don't install sub-dependencies
+    }
+    
+    method_options global_method_options
+    def initialize(*args); super; end
+    
+    # List gems that match the specified criteria.
     #
+    # By default all local gems are listed. When the first argument is 'all' the
+    # list is partitioned into system an local gems; specify 'system' to show
+    # only system gems. A second argument can be used to filter on a set of known
+    # components, like all merb-more gems for example.
+    # 
     # Examples:
     #
-    # thor merb:gems:install merb-core
-    # thor merb:gems:install merb-core --cache
-    # thor merb:gems:install merb-core --version 0.9.7
-    # thor merb:gems:install merb-core --merb-root ./path/to/your/app
-
-    desc 'install GEM_NAME', 'Install a gem from rubygems'
-    method_options "--version"   => :optional,
-                   "--merb-root" => :optional,
-                   "--cache"     => :boolean,
-                   "--binaries"  => :boolean
-    def install(name)
-      message "Installing #{name}..."
-      install_gem(name, :version => options[:version], :cache => options[:cache])
-      ensure_bin_wrapper_for(name) if options[:binaries]
-    rescue => e
-      error "Failed to install #{name} (#{e.message})"
+    # merb:gem:list                                    # list all local gems - the default
+    # merb:gem:list all                                # list system and local gems
+    # merb:gem:list system                             # list only system gems
+    # merb:gem:list all merb-more                      # list only merb-more related gems
+    # merb:gem:list --version 0.9.8                    # list gems that match the version    
+       
+    desc 'list [all|local|system] [comp]', 'Show installed gems'
+    def list(filter = 'local', comp = nil)
+      deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
+      self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      case filter
+      when 'all'
+        message 'Installed system gems:'
+        display_gemspecs(system)
+        message 'Installed local gems:'
+        display_gemspecs(local)
+      when 'system'
+        message 'Installed system gems:'
+        display_gemspecs(system)
+      when 'local'
+        message 'Installed local gems:'
+        display_gemspecs(local)
+      else
+        warning "Invalid listing filter '#{filter}'"
+      end
     end
-
-    # Update a gem and its dependencies.
-    #
-    # If a local ./gems dir is found, or --merb-root is given
-    # the gems will be installed locally into that directory.
+    
+    # Install the specified gems.
     #
-    # The option --cache will look in the system's gem cache
-    # for the latest version and install it in the apps' gems.
-    # This is particularly handy for gems that aren't available
-    # through rubyforge.org - like in-house merb slices etc.
+    # All arguments should be names of gems to install.
     #
+    # When :force => true then any existing versions of the gems to be installed
+    # will be uninstalled first. It's important to note that so-called meta-gems
+    # or gems that exactly match a set of Merb::Stack.components will have their
+    # sub-gems uninstalled too. For example, uninstalling merb-more will install
+    # all contained gems: merb-action-args, merb-assets, merb-gen, ...
+    # 
     # Examples:
     #
-    # thor merb:gems:update merb-core
-    # thor merb:gems:update merb-core --cache
-    # thor merb:gems:update merb-core --merb-root ./path/to/your/app
-
-    desc 'update GEM_NAME', 'Update a gem from rubygems'
-    method_options "--merb-root" => :optional,
-                   "--cache"     => :boolean,
-                   "--binaries"  => :boolean
-    def update(name)
-      message "Updating #{name}..."
-      version = nil
-      if gem_dir && (gemspec_path = Dir[File.join(gem_dir, 'specifications', "#{name}-*.gemspec")].last)
-        gemspec = Gem::Specification.load(gemspec_path)
-        version = Gem::Requirement.new [">#{gemspec.version}"]
-      end
-      if install_gem(name, :version => version, :cache => options[:cache])
-        ensure_bin_wrapper_for(name) if options[:binaries]
-      elsif gemspec
-        message "current version is: #{gemspec.version}"
+    # merb:gem:install merb-core merb-slices          # install all specified gems
+    # merb:gem:install merb-core --version 0.9.8      # install a specific version of a gem
+    # merb:gem:install merb-core --force              # uninstall then subsequently install the gem
+    # merb:gem:install merb-core --cache              # try to install locally from system gems
+    # merb:gem:install merb-core --binaries           # also install adapted bin wrapper
+     
+    desc 'install GEM_NAME [GEM_NAME, ...]', 'Install a gem from rubygems'
+    method_options "--cache"     => :boolean,
+                   "--binaries"  => :boolean,
+                   "--dry-run"   => :boolean,
+                   "--force"     => :boolean
+    def install(*names)
+      self.include_dependencies = true # deal with dependencies by default
+      opts = { :version => options[:version], :cache => options[:cache] }
+      current_gem = nil
+      
+      # uninstall existing gems of the ones we're going to install
+      uninstall(*names) if options[:force]
+      
+      names.each do |gem_name|
+        current_gem = gem_name      
+        if dry_run?
+          note "Installing #{current_gem}..."
+        else
+          message "Installing #{current_gem}..."
+          self.class.install(gem_name, default_install_options.merge(opts))
+          ensure_bin_wrapper_for(gem_name) if options[:binaries]
+        end
       end
+    rescue => e
+      error "Failed to install #{current_gem ? current_gem : 'gem'} (#{e.message})"
     end
-
-    # Uninstall a gem - ignores dependencies.
+    
+    # Uninstall the specified gems.
     #
-    # If a local ./gems dir is found, or --merb-root is given
-    # the gems will be uninstalled locally from that directory.
+    # By default all specified gems are uninstalled. It's important to note that 
+    # so-called meta-gems or gems that match a set of Merb::Stack.components will 
+    # have their sub-gems uninstalled too. For example, uninstalling merb-more 
+    # will install all contained gems: merb-action-args, merb-assets, ...
     #
-    # The --all option indicates that all versions of the gem should be
-    # uninstalled. If --version isn't set, and multiple versions are
-    # available, you will be prompted to pick one - or all.
+    # Existing dependencies will be clobbered; when :force => true then all gems
+    # will be cleared, otherwise only existing local dependencies of the
+    # matching component set will be removed.
     #
     # Examples:
     #
-    # thor merb:gems:uninstall merb-core
-    # thor merb:gems:uninstall merb-core --all
-    # thor merb:gems:uninstall merb-core --version 0.9.7
-    # thor merb:gems:uninstall merb-core --merb-root ./path/to/your/app
-
-    desc 'uninstall GEM_NAME', 'Uninstall a gem'
-    method_options "--version"   => :optional,
-                   "--merb-root" => :optional,
-                   "--all" => :boolean
-    def uninstall(name)
-      message "Uninstalling #{name}..."
-      uninstall_gem(name, :version => options[:version], :all => options[:all])
+    # merb:gem:uninstall merb-core merb-slices        # uninstall all specified gems
+    # merb:gem:uninstall merb-core --version 0.9.8    # uninstall a specific version of a gem
+    
+    desc 'uninstall GEM_NAME [GEM_NAME, ...]', 'Unstall a gem'
+    method_options "--dry-run" => :boolean
+    def uninstall(*names)
+      self.include_dependencies = true # deal with dependencies by default
+      opts = { :version => options[:version] }
+      current_gem = nil
+      if dry_run?
+        note "Uninstalling any existing gems of: #{names.join(', ')}"
+      else
+        message "Uninstalling any existing gems of: #{names.join(', ')}"
+        names.each do |gem_name|
+          current_gem = gem_name
+          Merb::Gem.uninstall(gem_name, default_uninstall_options) rescue nil
+          # if this gem is a meta-gem or a component set name, remove sub-gems
+          (Merb::Stack.components(gem_name) || []).each do |comp|
+            Merb::Gem.uninstall(comp, default_uninstall_options) rescue nil
+          end
+        end
+      end 
     rescue => e
-      error "Failed to uninstall #{name} (#{e.message})"
+      error "Failed to uninstall #{current_gem ? current_gem : 'gem'} (#{e.message})"
+    end
+    
+    private
+    
+    # Return dependencies for all installed gems; both system-wide and locally;
+    # optionally filters on :version requirement.
+    def dependencies
+      version_req = if options[:version]
+        ::Gem::Requirement.create(options[:version])
+      else
+        ::Gem::Requirement.default
+      end
+      if gem_dir
+        ::Gem.clear_paths; ::Gem.path.unshift(gem_dir)
+        ::Gem.source_index.refresh!
+      end
+      deps = []
+      ::Gem.source_index.each do |fullname, gemspec| 
+        if version_req.satisfied_by?(gemspec.version)
+          deps << ::Gem::Dependency.new(gemspec.name, "= #{gemspec.version}")
+        end
+      end
+      ::Gem.clear_paths if gem_dir
+      deps.sort
+    end
+    
+    public
+    
+    # Install gem with some default options.
+    def self.install(name, options = {})
+      defaults = {}
+      defaults[:cache] = false unless opts[:install_dir]
+      install_gem(name, defaults.merge(options))
+    end
+    
+    # Uninstall gem with some default options.
+    def self.uninstall(name, options = {})
+      defaults = { :ignore => true, :executables => true }
+      uninstall_gem(name, defaults.merge(options))
+    end
+    
+  end
+  
+  class Source < Thor
+    
+    group 'core'
+        
+    include MerbThorHelper
+    extend GemManagement
+    
+    attr_accessor :system, :local, :missing
+    
+    global_method_options = {
+      "--merb-root"            => :optional,  # the directory to operate on
+      "--include-dependencies" => :boolean,   # gather sub-dependencies
+      "--sources"              => :optional   # a yml config to grab sources from
+    }
+    
+    method_options global_method_options
+    def initialize(*args); super; end
+        
+    # List source repositories, of either local or known sources.
+    #
+    # Examples:
+    #
+    # merb:source:list                                   # list all local sources
+    # merb:source:list available                         # list all known sources
+    
+    desc 'list [local|available]', 'Show git source repositories'
+    def list(mode = 'local')
+      if mode == 'available'
+        message 'Available source repositories:'
+        repos = self.class.repos(options[:sources])
+        repos.keys.sort.each { |name| puts "- #{name}: #{repos[name]}" }
+      elsif mode == 'local'
+        message 'Current source repositories:'
+        Dir[File.join(source_dir, '*')].each do |src|
+          next unless File.directory?(src)
+          src_name = File.basename(src)
+          unless (repos = source_manager.existing_repos(src_name)).empty?
+            puts "#{src_name}"
+            repos.keys.sort.each { |b| puts "- #{b}: #{repos[b]}" }
+          end
+        end
+      else
+        error "Unknown listing: #{mode}"
+      end
     end
 
-    # Completely remove a gem and all its versions - ignores dependencies.
+    # Install the specified gems.
     #
-    # If a local ./gems dir is found, or --merb-root is given
-    # the gems will be uninstalled locally from that directory.
+    # All arguments should be names of gems to install.
     #
+    # When :force => true then any existing versions of the gems to be installed
+    # will be uninstalled first. It's important to note that so-called meta-gems
+    # or gems that exactly match a set of Merb::Stack.components will have their
+    # sub-gems uninstalled too. For example, uninstalling merb-more will install
+    # all contained gems: merb-action-args, merb-assets, merb-gen, ...
+    # 
     # Examples:
     #
-    # thor merb:gems:wipe merb-core
-    # thor merb:gems:wipe merb-core --merb-root ./path/to/your/app
-
-    desc 'wipe GEM_NAME', 'Remove a gem completely'
-    method_options "--merb-root" => :optional
-    def wipe(name)
-      message "Wiping #{name}..."
-      uninstall_gem(name, :all => true, :executables => true)
+    # merb:source:install merb-core merb-slices          # install all specified gems
+    # merb:source:install merb-core --force              # uninstall then subsequently install the gem
+    # merb:source:install merb-core --wipe               # clear repo then install the gem
+    # merb:source:install merb-core --binaries           # also install adapted bin wrapper
+
+    desc 'install GEM_NAME [GEM_NAME, ...]', 'Install a gem from git source/edge'
+    method_options "--binaries"  => :boolean,
+                   "--dry-run"   => :boolean,
+                   "--force"     => :boolean,
+                   "--wipe"      => :boolean
+    def install(*names)
+      # uninstall existing gems of the ones we're going to install
+      uninstall(*names) if options[:force] || options[:wipe]
+      
+      # We want dependencies instead of just names
+      deps = names.map { |n| ::Gem::Dependency.new(n, ::Gem::Requirement.default) }
+      
+      # Selectively update repositories for the matching dependencies
+      update_dependency_repositories(deps) unless dry_run?
+      
+      current_gem = nil
+      deps.each do |dependency|
+        current_gem = dependency.name      
+        if dry_run?
+          note "Installing #{current_gem} from source..."
+        else
+          message "Installing #{current_gem} from source..."
+          if install_dependency_from_source(dependency)
+            ensure_bin_wrapper_for(dependency.name) if options[:binaries]
+          end
+        end
+      end
     rescue => e
-      error "Failed to wipe #{name} (#{e.message})"
+      error "Failed to install #{current_gem ? current_gem : 'gem'} (#{e.message})"
     end
     
-    # Refresh all local gems by uninstalling them and subsequently reinstall
-    # the latest versions from stable sources.
+    # Uninstall the specified gems.
+    #
+    # By default all specified gems are uninstalled. It's important to note that 
+    # so-called meta-gems or gems that match a set of Merb::Stack.components will 
+    # have their sub-gems uninstalled too. For example, uninstalling merb-more 
+    # will install all contained gems: merb-action-args, merb-assets, ...
     #
-    # A local ./gems dir is required, or --merb-root is given
-    # the gems will be uninstalled locally from that directory.
+    # Existing dependencies will be clobbered; when :force => true then all gems
+    # will be cleared, otherwise only existing local dependencies of the
+    # matching component set will be removed. Additionally when :wipe => true, 
+    # the matching git repositories will be removed from the source directory.
     #
     # Examples:
     #
-    # thor merb:gems:refresh
-    # thor merb:gems:refresh --merb-root ./path/to/your/app
-    
-    desc 'refresh', 'Refresh all local gems by installing only the most recent versions'
-    method_options "--merb-root" => :optional,
-                   "--cache"     => :boolean,
-                   "--binaries"  => :boolean
-    def refresh
-      if gem_dir
-        gem_names = []
-        local_gemspecs.each do |spec|
-          gem_names << spec.name unless gem_names.include?(spec.name)
-          uninstall_gem(spec.name, :version => spec.version)
-        end
-        gem_names.each { |name| install_gem(name) }
-        # if options[:binaries] is set this is already taken care of - skip it
-        ensure_bin_wrapper_for_core_components unless options[:binaries]
-      else
-        error "The refresh task only works with local gems"
-      end      
-    end
+    # merb:source:uninstall merb-core merb-slices       # uninstall all specified gems
+    # merb:source:uninstall merb-core --wipe            # force-uninstall a gem and clear repo
     
-    # This task should be executed as part of a deployment setup, where
-    # the deployment system runs this after the app has been installed.
-    # Usually triggered by Capistrano, God...
-    #
-    # It will regenerate gems from the bundled gems cache for any gem
-    # that has C extensions - which need to be recompiled for the target
-    # deployment platform.
-
-    desc 'redeploy', 'Recreate any binary gems on the target deployment platform'
-    def redeploy
-      require 'tempfile' # for
-      if gem_dir && File.directory?(cache_dir = File.join(gem_dir, 'cache'))
-        local_gemspecs.each do |gemspec|
-          unless gemspec.extensions.empty?
-            if File.exists?(gem_file = File.join(cache_dir, "#{gemspec.full_name}.gem"))
-              gem_file_copy = File.join(Dir::tmpdir, File.basename(gem_file))
-              # Copy the gem to a temporary file, because otherwise RubyGems/FileUtils
-              # will complain about copying identical files (same source/destination).
-              FileUtils.cp(gem_file, gem_file_copy)
-              install_gem(gem_file_copy, :install_dir => gem_dir)
-              File.delete(gem_file_copy)
+    desc 'uninstall GEM_NAME [GEM_NAME, ...]', 'Unstall a gem (specify --force to remove the repo)'
+    method_options "--version" => :optional, "--dry-run" => :boolean, "--wipe" => :boolean
+    def uninstall(*names)
+      # Remove the repos that contain the gem
+      if options[:wipe] 
+        extract_repositories(names).each do |(name, url)|
+          if File.directory?(src = File.join(source_dir, name))
+            if dry_run?
+              note "Removing #{src}..."
+            else
+              info "Removing #{src}..."
+              FileUtils.rm_rf(src)
             end
           end
         end
-      else
-        error "No application local gems directory found"
       end
+      
+      # Use the Merb::Gem#uninstall task to handle this
+      gem_tasks = Merb::Gem.new
+      gem_tasks.options = options
+      gem_tasks.uninstall(*names)
     end
     
-    # Install gem with some default options.
-    def install_gem(name, opts = {})
-      defaults = {}
-      defaults[:cache] = false unless gem_dir
-      defaults[:install_dir] = gem_dir if gem_dir
-      Merb.install_gem(name, defaults.merge(opts))
-    end
+    # Update the specified source repositories.
+    #
+    # The arguments can be actual repository names (from Merb::Source.repos)
+    # or names of known merb stack gems. If the repo doesn't exist already,
+    # it will be created and cloned.
+    #
+    # merb:source:pull merb-core                         # update source of specified gem
+    # merb:source:pull merb-slices                       # implicitly updates merb-more
     
-    # Uninstall gem with some default options.
-    def uninstall_gem(name, opts = {})
-      defaults = { :ignore => true, :executables => true }
-      defaults[:install_dir] = gem_dir if gem_dir
-      Merb.uninstall_gem(name, defaults.merge(opts))
-    end
+    desc 'pull REPO_NAME [GEM_NAME, ...]', 'Update git source repository from edge'
+    def pull(*names)
+      repos = extract_repositories(names)
+      update_repositories(repos)
+      unless repos.empty?
+        message "Updated the following repositories:"
+        repos.each { |name, url| puts "- #{name}: #{url}" }
+      else
+        warning "No repositories found to update!"
+      end
+    end    
     
-    protected
+    # Clone a git repository into ./src. 
     
-    def local_gemspecs(directory = gem_dir)
-      if File.directory?(specs_dir = File.join(directory, 'specifications'))
-        Dir[File.join(specs_dir, '*.gemspec')].map do |gemspec_path|
-          gemspec = Gem::Specification.load(gemspec_path)
-          gemspec.loaded_from = gemspec_path
-          gemspec
-        end
-      else
-        []
+    # The repository can be a direct git url or a known -named- repository.
+    #
+    # Examples:
+    #
+    # merb:source:clone merb-core 
+    # merb:source:clone dm-core awesome-repo
+    # merb:source:clone dm-core --sources ./path/to/sources.yml
+    # merb:source:clone git://github.com/sam/dm-core.git
+    
+    desc 'clone (REPO_NAME|URL) [DIR_NAME]', 'Clone git source repository by name or url'
+    def clone(repository, name = nil)
+      if repository =~ /^git:\/\//
+        repository_url  = repository
+        repository_name = File.basename(repository_url, '.git')
+      elsif url = Merb::Source.repo(repository, options[:sources])
+        repository_url = url
+        repository_name = repository
       end
+      source_manager.clone(name || repository_name, repository_url)
     end
-
-  end
-
-  class Tasks < Thor
-
-    include MerbThorHelper
-
-    # Install Thor, Rake and RSpec into the local gems dir, by copying it from
-    # the system-wide rubygems cache - which is OK since we needed it to run
-    # this task already.
+    
+    # Git repository sources - pass source_config option to load a yaml 
+    # configuration file - defaults to ./config/git-sources.yml and
+    # ~/.merb/git-sources.yml - which you need to create yourself. 
     #
-    # After this we don't need the system-wide rubygems anymore, as all required
-    # executables are available in the local ./bin directory.
+    # Example of contents:
     #
-    # RSpec is needed here because source installs might fail when running
-    # rake tasks where spec/rake/spectask has been required.
-
-    desc 'setup', 'Install Thor, Rake and RSpec in the local gems dir'
-    method_options "--merb-root" => :optional
-    def setup
-      if $0 =~ /^(\.\/)?bin\/thor$/
-        error "You cannot run the setup from #{$0} - try #{File.basename($0)} merb:tasks:setup instead"
-        return
+    # merb-core: git://github.com/myfork/merb-core.git
+    # merb-more: git://github.com/myfork/merb-more.git
+    
+    def self.repos(source_config = nil)
+      source_config ||= begin
+        local_config = File.join(Dir.pwd, 'config', 'git-sources.yml')
+        user_config  = File.join(ENV["HOME"] || ENV["APPDATA"], '.merb', 'git-sources.yml')
+        File.exists?(local_config) ? local_config : user_config
       end
-      create_if_missing(File.join(working_dir, 'gems'))
-      Merb.install_gem('thor',  :cache => true, :install_dir => gem_dir)
-      Merb.install_gem('rake',  :cache => true, :install_dir => gem_dir)
-      Merb.install_gem('rspec', :cache => true, :install_dir => gem_dir)
-      ensure_bin_wrapper_for('thor', 'rake', 'rspec')
-    end
-
-    # Get the latest merb.thor and install it into the working dir.
-
-    desc 'update', 'Fetch the latest merb.thor and install it locally'
-    def update
-      require 'open-uri'
-      url = 'http://merbivore.com/merb.thor'
-      remote_file = open(url)
-      File.open(File.join(working_dir, 'merb.thor'), 'w') do |f|
-        f.write(remote_file.read)
+      if source_config && File.exists?(source_config)
+        default_repos.merge(YAML.load(File.read(source_config)))
+      else
+        default_repos
       end
-      success "Installed the latest merb.thor"
-    rescue OpenURI::HTTPError
-      error "Error opening #{url}"
-    rescue => e
-      error "An error occurred (#{e.message})"
     end
-
+    
+    def self.repo(name, source_config = nil)
+      self.repos(source_config)[name]
+    end
+    
+    # Default Git repositories
+    def self.default_repos
+      @_default_repos ||= { 
+        'merb'          => "git://github.com/wycats/merb.git",
+        'merb-plugins'  => "git://github.com/wycats/merb-plugins.git",
+        'extlib'        => "git://github.com/sam/extlib.git",
+        'dm-core'       => "git://github.com/sam/dm-core.git",
+        'dm-more'       => "git://github.com/sam/dm-more.git",
+        'sequel'        => "git://github.com/wayneeseguin/sequel.git",
+        'do'            => "git://github.com/sam/do.git",
+        'thor'          => "git://github.com/wycats/thor.git",
+        'rake'          => "git://github.com/jimweirich/rake.git",
+        'minigems'      => "git://github.com/fabien/minigems.git"
+      }
+    end
+       
   end
-
+  
 end