merb-gen 0.9.13 → 1.0

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

@@ -5,7 +5,7 @@ require 'fileutils'
 require 'yaml'
 
 # Important - don't change this line or its position
-MERB_THOR_VERSION = '0.1.0'
+MERB_THOR_VERSION = '0.2.1'
 
 ##############################################################################
 
@@ -335,7 +335,7 @@ end
 
 # use gems dir if ../gems exists - eg. only for ./bin/#{bin_file_name}
 if File.directory?(gems_dir = File.join(File.dirname(__FILE__), '..', 'gems'))
-  $BUNDLE = true; Gem.clear_paths; Gem.path.replace([gems_dir])
+  $BUNDLE = true; Gem.clear_paths; Gem.path.replace([File.expand_path(gems_dir)])
   ENV["PATH"] = "\#{File.dirname(__FILE__)}:\#{gems_dir}/bin:\#{ENV["PATH"]}"
   if (local_gem = Dir[File.join(gems_dir, "specifications", "#{spec.name}-*.gemspec")].last)
     version = File.basename(local_gem)[/-([\\.\\d]+)\\.gemspec$/, 1]
@@ -446,6 +446,10 @@ module MerbThorHelper
     base.extend ColorfulMessages
   end
   
+  def use_edge_gem_server
+    ::Gem.sources << 'http://edge.merbivore.com'
+  end
+  
   def source_manager
     @_source_manager ||= SourceManager.new(source_dir)
   end
@@ -643,166 +647,112 @@ end
 $SILENT = true # don't output all the mess some rake package tasks spit out
 
 module Merb
+  
+  class Gem < Thor
     
-  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.
+    include MerbThorHelper
+    extend GemManagement
     
     attr_accessor :system, :local, :missing
     
-    include MerbThorHelper
-    
     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
+      "--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 application dependencies.
+    # List gems that match the specified criteria.
     #
-    # 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.
+    # 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:
     #
-    # 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
+    # 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|missing] [comp]', 'Show application dependencies'
-    def list(filter = 'all', comp = nil)
+    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 gem dependencies:' 
+        message 'Installed system gems:'
         display_gemspecs(system)
-        message 'Installed local gem dependencies:'
+        message 'Installed local gems:'
         display_gemspecs(local)
-        unless missing.empty?
-          error 'Missing gem dependencies:'
-          display_dependencies(missing)
-        end
       when 'system'
-        message 'Installed system gem dependencies:'
+        message 'Installed system gems:'
         display_gemspecs(system)
       when 'local'
-        message 'Installed local gem dependencies:'
+        message 'Installed local gems:'
         display_gemspecs(local)
-      when 'missing'
-        error 'Missing gem dependencies:'
-        display_dependencies(missing)
       else
         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
     
-    # Install application dependencies.
+    # Install the specified gems.
     #
-    # 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.
+    # All arguments should be names of gems to install.
     #
-    # 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.
+    # 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:
     #
-    # 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
-    
-    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'
-        
-        # 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
-          clobber = false
-        else
-          message "Preparing to install #{where} using #{strategy} strategy..."
-          clobber = true
-        end
-        
-        # 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..."
+    # 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 --merb-edge               # install from edge.merbivore.com
+     
+    desc 'install GEM_NAME [GEM_NAME, ...]', 'Install a gem from rubygems'
+    method_options "--cache"        => :boolean,
+                   "--dry-run"      => :boolean,
+                   "--force"        => :boolean,
+                   "--merb-edge"    => :boolean
+    def install(*names)
+      opts = { :version => options[:version], :cache => options[:cache] }
+      use_edge_gem_server if options[:"merb-edge"]
+      current_gem = nil
+      
+      # uninstall existing gems of the ones we're going to install
+      uninstall(*names) if options[:force]
+      
+      message "Installing #{names.length} #{names.length == 1 ? 'gem' : 'gems'}..."
+      puts "This may take a while..."
+      
+      names.each do |gem_name|
+        current_gem = gem_name      
+        if dry_run?
+          note "Installing #{current_gem}..."
         else
-          puts "#{deps.length} dependencies to install..."
-          install_dependencies(strategy, deps, clobber)
+          message "Installing #{current_gem}..."
+          self.class.install(gem_name, default_install_options.merge(opts))
         end
-        
-        # 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
+    rescue => e
+      error "Failed to install #{current_gem ? current_gem : 'gem'} (#{e.message})"
     end
     
-    # Uninstall application dependencies.
+    # Uninstall the specified gems.
     #
-    # By default all required dependencies are installed. An optional argument 
-    # can be used to filter on a set of known components.
+    # 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, ...
     #
     # Existing dependencies will be clobbered; when :force => true then all gems
     # will be cleared, otherwise only existing local dependencies of the
@@ -810,21 +760,32 @@ module Merb
     #
     # Examples:
     #
-    # 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
+    # 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 [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!
+    desc 'uninstall GEM_NAME [GEM_NAME, ...]', 'Unstall a gem'
+    method_options "--dry-run" => :boolean
+    def uninstall(*names)
+      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 #{current_gem ? current_gem : 'gem'} (#{e.message})"
     end
     
-    # Recreate binary gems on the current platform.
+    # Recreate all gems from gems/cache 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.
@@ -833,27 +794,32 @@ module Merb
     # 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.
+    # Note: at least gems/cache and gems/specifications should be in your SCM.
     
-    desc 'redeploy', 'Recreate any binary gems on the target platform'
-    method_options "--dry-run" => :boolean
+    desc 'redeploy', 'Recreate all gems on the current platform'
+    method_options "--dry-run" => :boolean, "--force" => :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
+        specs = local_gemspecs
+        message "Recreating #{specs.length} gems from cache..."
+        puts "This may take a while..."
+        specs.each do |gemspec|
+          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}"       
+              if options[:force] && File.directory?(gem = File.join(gem_dir, 'gems', gemspec.full_name))
+                puts "Removing existing #{gemspec.full_name}"
+                FileUtils.rm_rf(gem) 
+              end              
+              # 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, :ignore_dependencies => true)
+              File.delete(gem_file_copy)
             end
           end
         end
@@ -862,1124 +828,1193 @@ module Merb
       end
     end
     
-    # 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 
+    private
     
-    desc 'configure [comp]', 'Create a dependencies config file'
-    method_options "--dry-run" => :boolean, "--force" => :boolean, "--versions" => :boolean
-    def configure(comp = nil)
-      # If comp given, filter on known stack components
-      deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
-      
-      # If --versions is set, update the version_requirements with the actual version available
-      if options[:versions]
-        specs = local_gemspecs
-        deps.each do |dep|
-          if spec = specs.find { |s| s.name == dep.name }
-            dep.version_requirements = ::Gem::Requirement.create(spec.version)
-          end
-        end
-      end
-      
-      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."
+    # 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
-        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
-    
-    def install_dependencies(strategy, deps, clobber = true)
-      if method = strategy?(strategy)
-        # Clobber existing local dependencies
-        clobber_dependencies! if clobber
-        
-        # Run the chosen strategy - collect files installed from stable gems
-        installed_from_stable = send(method, deps).map { |d| d.name }
-
-        unless dry_run?
-          # Sleep a bit otherwise the following steps won't see the new files
-          sleep(deps.length) if deps.length > 0 && deps.length <= 10
-          
-          # 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
-        end
-        return true
-      end
-      false
-    end
-    
-    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) }
+        ::Gem::Requirement.default
       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
+      if gem_dir
+        ::Gem.clear_paths; ::Gem.path.unshift(gem_dir)
+        ::Gem.source_index.refresh!
       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
+      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
-      
-      deps
+      ::Gem.clear_paths if gem_dir
+      deps.sort
     end
     
-    def config_dependencies
-      if File.exists?(config_file)
-        self.class.parse_dependencies_yaml(File.read(config_file))
-      else
-        []
-      end
-    end
+    public
     
-    def use_config?
-      options[:config] || options[:"config-file"]
+    # 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
     
-    def config_file
-      @config_file ||= begin
-        options[:"config-file"] || File.join(working_dir, 'config', 'dependencies.yml')
-      end
+    # Uninstall gem with some default options.
+    def self.uninstall(name, options = {})
+      defaults = { :ignore => true, :executables => true }
+      uninstall_gem(name, defaults.merge(options))
     end
     
-    def config_dir
-      File.dirname(config_file)
-    end
+  end
+  
+  class Tasks < Thor
     
-    ### Strategy handlers
+    include MerbThorHelper
     
-    private
+    # Show merb.thor version information
+    #
+    # merb:tasks:version                                        # show the current version info
+    # merb:tasks:version --info                                 # show extended version info
     
-    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        
+    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
-      installed_from_rubygems
     end
     
-    def edge_strategy(deps)
-      installed_from_rubygems = []
-      
-      # Selectively update repositories for the matching dependencies
-      update_dependency_repositories(deps) unless dry_run?
+    # Update merb.thor tasks from remotely available version
+    #
+    # 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
       
-      if core = deps.find { |d| d.name == 'merb-core' }
-        if dry_run?
-          note "Installing #{core.name}..."
-        else
-          if install_dependency_from_source(core)
-          elsif install_dependency(core)
-            info "Installed #{core.name} from rubygems..."
-            installed_from_rubygems << core
+      # 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
-      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)
-          elsif install_dependency(dependency)
-            info "Installed #{dependency.name} from rubygems..."
-            installed_from_rubygems << dependency
+          
+        if proceed && !dry_run?
+          File.open(File.join(__FILE__), 'w') do |f|
+            f.write(code)
           end
-        end        
-      end
-      
-      installed_from_rubygems
+          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
     
-    ### Class Methods
+  end
+  
+  #### MORE LOW-LEVEL TASKS ####
+  
+  class Source < Thor
     
-    public
+    group 'core'
+        
+    include MerbThorHelper
+    extend GemManagement
     
-    def self.list(filter = 'all', comp = nil, options = {})
-      instance = Merb::Dependencies.new
-      instance.options = options
-      instance.list(filter, comp)
-    end
+    attr_accessor :system, :local, :missing
     
-    # Extract application dependencies by querying the app directly.
-    def self.extract_dependencies(merb_root)
-      require 'merb-core'
-      if !@_merb_loaded || Merb.root != merb_root
-        Merb.start_environment(
-          :log_level => :fatal,
-          :testing => true, 
-          :adapter => 'runner', 
-          :environment => ENV['MERB_ENV'] || 'development', 
-          :merb_root => merb_root
-        )
-        @_merb_loaded = true
+    global_method_options = {
+      "--merb-root"            => :optional,  # the directory to operate on
+      "--ignore-dependencies"  => :boolean,   # don't install 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
-      Merb::BootLoader::Dependencies.dependencies
-    rescue StandardError => e     
-      error "Couldn't extract dependencies from application!"
-      error e.message
-      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 []
-    rescue SystemExit      
-      error "Couldn't extract dependencies from application!"
-      error "application failed to run"
-      puts  "Please check if your application runs using 'merb'; for example,"
-      puts  "look for any gem version mismatches in dependencies.rb"
-      return []
     end
-        
-    # 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)
+
+    # Install the specified gems.
+    #
+    # 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:
+    #
+    # 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
+
+    desc 'install GEM_NAME [GEM_NAME, ...]', 'Install a gem from git source/edge'
+    method_options "--dry-run"      => :boolean,
+                   "--force"        => :boolean,
+                   "--wipe"         => :boolean
+    def install(*names)
+      use_edge_gem_server
+      # 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
-          error "Invalid entry: #{entry}"
+          message "Installing #{current_gem} from source..."
+          puts "This may take a while..."
+          unless install_dependency_from_source(dependency)
+            raise "gem source not found"
+          end
         end
       end
-      dependencies
+    rescue => e
+      error "Failed to install #{current_gem ? current_gem : 'gem'} (#{e.message})"
     end
     
-  end  
-  
-  class Stack < Thor
+    # 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, ...
+    #
+    # 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:
+    #
+    # merb:source:uninstall merb-core merb-slices       # uninstall all specified gems
+    # merb:source:uninstall merb-core --wipe            # force-uninstall a gem and clear repo
     
-    # The Stack tasks will install dependencies based on known sets of gems,
-    # regardless of actual application dependency settings.
+    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
+      end
+      
+      # Use the Merb::Gem#uninstall task to handle this
+      gem_tasks = Merb::Gem.new
+      gem_tasks.options = options
+      gem_tasks.uninstall(*names)
+    end
     
-    DM_STACK = %w[
-      extlib
-      data_objects
-      dm-core
-      dm-aggregates
-      dm-migrations
-      dm-timestamps
-      dm-types
-      dm-validations
-      merb_datamapper
-    ]
+    # 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
     
-    MERB_STACK = %w[
-      extlib
-      merb-core
-      merb-action-args
-      merb-assets
-      merb-cache
-      merb-helpers
-      merb-mailer
-      merb-slices
-      merb-auth
-      merb-auth-core
-      merb-auth-more 
-      merb-auth-slice-password
-      merb-param-protection
-      merb-exceptions
-    ] + DM_STACK
+    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    
     
-    MERB_BASICS = %w[
-      extlib
-      merb-core
-      merb-action-args
-      merb-assets
-      merb-cache
-      merb-helpers
-      merb-mailer
-      merb-slices
-    ]
+    # Clone a git repository into ./src. 
     
-    # The following sets are meant for repository lookup; unlike the sets above
-    # these correspond to specific git repository items.
+    # 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
     
-    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
-    ]
+    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
     
-    MERB_PLUGINS = %w[
-      merb_activerecord
-      merb_builder
-      merb_jquery
-      merb_laszlo
-      merb_parts
-      merb_screw_unit
-      merb_sequel
-      merb_stories
-      merb_test_unit
-    ]
+    # 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. 
+    #
+    # Example of contents:
+    #
+    # merb-core: git://github.com/myfork/merb-core.git
+    # merb-more: git://github.com/myfork/merb-more.git
     
-    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
-    ]
+    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
+    
+    def self.repo(name, source_config = nil)
+      self.repos(source_config)[name]
+    end
     
-    DATA_OBJECTS = %w[
-      data_objects 
-      do_derby do_hsqldb 
-      do_jdbc
-      do_mysql
-      do_postgres
-      do_sqlite3
-    ]
+    # 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"
+      }
+    end
+       
+  end
+  
+  class Dependencies < Thor
+  
+    group 'core'
     
-    attr_accessor :system, :local, :missing
+    # 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, :extract_dependencies
     
     include MerbThorHelper
     
     global_method_options = {
       "--merb-root"            => :optional,  # the directory to operate on
-      "--ignore-dependencies"  => :boolean,   # skip sub-dependencies
-      "--version"              => :optional   # gather specific version of framework    
+      "--ignore-dependencies"  => :boolean,   # ignore sub-dependencies
+      "--stack"                => :boolean,   # gather only stack dependencies
+      "--no-stack"             => :boolean,   # gather only non-stack dependencies
+      "--extract"              => :boolean,   # gather dependencies from the app itself
+      "--config-file"          => :optional,  # gather from the specified yaml config
+      "--version"              => :optional   # gather specific version of framework
     }
     
     method_options global_method_options
     def initialize(*args); super; end
     
-    # List components and their dependencies.
+    # List application dependencies.
     #
-    # Examples:
+    # 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.
     # 
-    # 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
+    # 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 --extract                          # list dependencies by extracting them
+    # 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
+      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
-        message "Dependencies for '#{comp}' set:"
-        Merb::Stack.components(comp).each { |c| puts "- #{c}" }
-      end      
+        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
     
-    # Install stack components or individual gems - from stable rubygems by default.
+    # Install application dependencies.
     #
-    # See also: Merb::Dependencies#install and Merb::Dependencies#install_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.
+    # 
     # Examples:
     #
-    # 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
+    # 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 --extract                # extract dependencies from the actual app
+    # 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
+    
+    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]
         
-    # Uninstall stack components or individual gems.
+        where = gem_dir ? 'locally' : 'system-wide'
+        
+        # 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
+          clobber = false
+        else
+          message "Preparing to install #{where} using #{strategy} strategy..."
+          clobber = true
+        end
+        
+        # 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
+          puts "#{deps.length} dependencies to install..."
+          puts "This may take a while..."
+          install_dependencies(strategy, deps, clobber)
+        end
+        
+        # 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
+    
+    # Uninstall application dependencies.
     #
-    # See also: Merb::Dependencies#uninstall
+    # 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:
     #
-    # 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
+    # merb:dependencies:uninstall                               # uninstall all dependencies - the default
+    # merb:dependencies:uninstall merb-more                     # uninstall merb-more related gems locally
     
-    desc 'uninstall [COMP, ...]', 'Uninstall stack components'
+    desc 'uninstall [comp]', 'Uninstall application dependencies'
     method_options "--dry-run" => :boolean, "--force" => :boolean
-    def uninstall(*comps)
-      deps = gather_dependencies(comps)
+    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
     
-    # Install or uninstall minigems from the system.
-    #
-    # Due to the specific nature of MiniGems it can only be installed system-wide.
-    #
-    # Examples:
+    # Recreate all gems from gems/cache on the current platform.
     #
-    # merb:stack:minigems install                               # install minigems
-    # merb:stack:minigems uninstall                             # uninstall minigems
-    
-    desc 'minigems (install|uninstall)', 'Install or uninstall minigems (needs sudo privileges)'
-    def minigems(action)
-      case action
-      when 'install'
-        Kernel.system "#{sudo} thor merb:stack:install_minigems"
-      when 'uninstall'
-        Kernel.system "#{sudo} thor merb:stack:uninstall_minigems"
-      else
-        error "Invalid command: merb:stack:minigems #{action}"
-      end
-    end    
-    
-    # hidden minigems install task
-    def install_minigems
-      message "Installing MiniGems"
-      mngr = self.dependency_manager
-      deps = gather_dependencies('minigems')
-      mngr.system, mngr.local, mngr.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
-      mngr.force_gem_dir = ::Gem.dir
-      mngr.install_dependencies(strategy, deps)
-      Kernel.system "#{sudo} minigem install"
-    end
+    # Note: use merb:gem:redeploy instead
     
-    # hidden minigems uninstall task
-    def uninstall_minigems
-      message "Uninstalling MiniGems"
-      Kernel.system "#{sudo} minigem uninstall"
-      deps = gather_dependencies('minigems')
-      self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
-      # Clobber existing local dependencies - based on self.local
-      clobber_dependencies!      
+    desc 'redeploy', 'Recreate all gems on the current platform'
+    method_options "--dry-run" => :boolean, "--force" => :boolean
+    def redeploy
+      warning 'Warning: merb:dependencies:redeploy has been deprecated - use merb:gem:redeploy instead'
+      gem = Merb::Gem.new
+      gem.options = options
+      gem.redeploy
     end
     
-    protected
+    # 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 
     
-    def gather_dependencies(comps = [])
-      if comps.empty?
-        gems = MERB_STACK
-      else
-        gems = comps.map { |c| Merb::Stack.components(c) }.flatten
-      end
+    desc 'configure [comp]', 'Create a dependencies config file'
+    method_options "--dry-run" => :boolean, "--force" => :boolean, "--versions" => :boolean
+    def configure(comp = nil)
+      self.extract_dependencies = true # of course we need to consult the app itself
+      # If comp given, filter on known stack components
+      deps = comp ? Merb::Stack.select_component_dependencies(dependencies, comp) : dependencies
       
-      version_req = if options[:version]
-        ::Gem::Requirement.create(options[:version])
+      # If --versions is set, update the version_requirements with the actual version available
+      if options[:versions]
+        specs = local_gemspecs
+        deps.each do |dep|
+          if spec = specs.find { |s| s.name == dep.name }
+            dep.version_requirements = ::Gem::Requirement.create(spec.version)
+          end
+        end
       end
       
-      framework_components = Merb::Stack.framework_components
-      
-      gems.map do |gem|
-        if version_req && framework_components.include?(gem)
-          ::Gem::Dependency.new(gem, version_req)
+      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
-          ::Gem::Dependency.new(gem, ::Gem::Requirement.default)
+          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
-    end
+    rescue  
+      error "Failed to write to #{config_file}"
+    end 
     
-    def strategy
-      options[:strategy] || (options[:edge] ? 'edge' : 'stable')
-    end
+    ### Helper Methods
     
-    def dependency_manager
-      @_dependency_manager ||= begin
-        instance = Merb::Dependencies.new
-        instance.options = options
-        instance
+    def strategy?(strategy)
+      if self.respond_to?(method = :"#{strategy}_strategy", true)
+        method
       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
-        comps["do"]           = DATA_OBJECTS.sort
-        
-        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"]
+    def install_dependencies(strategy, deps, clobber = true)
+      if method = strategy?(strategy)
+        # Clobber existing local dependencies
+        clobber_dependencies! if clobber
         
-        comps
+        # Run the chosen strategy - collect files installed from stable gems
+        installed_from_stable = send(method, deps).map { |d| d.name }
+
+        unless dry_run?
+          # Sleep a bit otherwise the following steps won't see the new files
+          sleep(deps.length) if deps.length > 0 && deps.length <= 10
+          
+          # 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
+        end
+        return true
       end
+      false
     end
     
-    def self.framework_components
-      %w[merb-core merb-more].inject([]) do |all, comp| 
-        all + components(comp)
+    def dependencies
+      if extract_dependencies?
+        # Extract dependencies from the current application
+        deps = Merb::Stack.core_dependencies(gem_dir, ignore_dependencies?)
+        deps += Merb::Dependencies.extract_dependencies(working_dir)        
+      else
+        # Use preconfigured dependencies from yaml file
+        deps = config_dependencies
+      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
     
-    def self.components(comp = nil)
-      if comp
-        component_sets[comp]
+    def config_dependencies
+      if File.exists?(config_file)
+        self.class.parse_dependencies_yaml(File.read(config_file))
       else
-        comps = %w[merb-core merb-more merb-plugins dm-core dm-more]
-        comps.inject([]) do |all, grp|
-          all + (component_sets[grp] || [])
-        end
+        warning "No dependencies.yml file found at: #{config_file}"
+        []
       end
     end
     
-    def self.select_component_dependencies(dependencies, comp = nil)
-      comps = components(comp) || []
-      dependencies.select { |dep| comps.include?(dep.name) }
+    def extract_dependencies?
+      options[:extract] || extract_dependencies
     end
     
-    def self.base_components
-      %w[thor rake extlib]
+    def config_file
+      @config_file ||= begin
+        options[:"config-file"] || File.join(working_dir, 'config', 'dependencies.yml')
+      end
     end
     
-    def self.all_components
-      base_components + framework_components
+    def config_dir
+      File.dirname(config_file)
     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
-          orig_gem_path = ::Gem.path
-          ::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
+    ### 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
-            deps += gemspec.dependencies
+            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
+    
+    def edge_strategy(deps)
+      use_edge_gem_server
+      installed_from_rubygems = []
+      
+      # Selectively update repositories for the matching dependencies
+      update_dependency_repositories(deps) unless dry_run?
+      
+      if core = deps.find { |d| d.name == 'merb-core' }
+        if dry_run?
+          note "Installing #{core.name}..."
+        else
+          if install_dependency_from_source(core)
+          elsif install_dependency(core)
+            info "Installed #{core.name} from rubygems..."
+            installed_from_rubygems << core
           end
         end
-        ::Gem.path.replace(orig_gem_path) if gem_dir # reset
-        deps
       end
-    end
-    
-    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
+      deps.each do |dependency|
+        next if dependency.name == 'merb-core'
+        if dry_run?
+          note "Installing #{dependency.name}..."
+        else
+          if install_dependency_from_source(dependency)
+          elsif install_dependency(dependency)
+            info "Installed #{dependency.name} from rubygems..."
+            installed_from_rubygems << dependency
+          end
+        end        
       end
-      set_name
+      
+      installed_from_rubygems
     end
     
-  end
-  
-  class Tasks < Thor
+    ### Class Methods
     
-    include MerbThorHelper
+    public
     
-    # Show merb.thor version information
-    #
-    # merb:tasks:version                                        # show the current version info
-    # merb:tasks:version --info                                 # show extended version info
+    def self.list(filter = 'all', comp = nil, options = {})
+      instance = Merb::Dependencies.new
+      instance.options = options
+      instance.list(filter, comp)
+    end
     
-    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
+    # Extract application dependencies by querying the app directly.
+    def self.extract_dependencies(merb_root)
+      require 'merb-core'
+      if !@_merb_loaded || Merb.root != merb_root
+        Merb.start_environment(
+          :log_level => :fatal,
+          :testing => true, 
+          :adapter => 'runner', 
+          :environment => ENV['MERB_ENV'] || 'development', 
+          :merb_root => merb_root
+        )
+        @_merb_loaded = true
       end
+      Merb::BootLoader::Dependencies.dependencies
+    rescue StandardError => e     
+      error "Couldn't extract dependencies from application!"
+      error e.message
+      puts  "Make sure you're executing the task from your app (--merb-root)"
+      return []
+    rescue SystemExit      
+      error "Couldn't extract dependencies from application!"
+      error "application failed to run"
+      puts  "Please check if your application runs using 'merb'; for example,"
+      puts  "look for any gem version mismatches in dependencies.rb"
+      return []
     end
-    
-    # Update merb.thor tasks from remotely available version
-    #
-    # 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})"
+    # 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
-      else
-        raise "invalid source-code data"
-      end      
-    rescue OpenURI::HTTPError
-      error "Error opening #{url}"
-    rescue => e
-      error "An error occurred (#{e.message})"
+      end
+      dependencies
     end
     
   end
   
-  #### MORE LOW-LEVEL TASKS ####
-  
-  class Gem < Thor
+  class Stack < Thor
     
     group 'core'
     
-    include MerbThorHelper
-    extend GemManagement
+    # The Stack tasks will install dependencies based on known sets of gems,
+    # regardless of actual application dependency settings.
+    
+    DM_STACK = %w[
+      extlib
+      data_objects
+      dm-core
+      dm-aggregates
+      dm-migrations
+      dm-timestamps
+      dm-types
+      dm-validations
+      merb_datamapper
+    ]
+    
+    MERB_STACK = %w[
+      extlib
+      merb-core
+      merb-action-args
+      merb-assets
+      merb-cache
+      merb-helpers
+      merb-mailer
+      merb-slices
+      merb-auth
+      merb-auth-core
+      merb-auth-more 
+      merb-auth-slice-password
+      merb-param-protection
+      merb-exceptions
+    ] + DM_STACK
+    
+    MERB_BASICS = %w[
+      extlib
+      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
+    ]
+    
+    DATA_OBJECTS = %w[
+      data_objects 
+      do_derby do_hsqldb 
+      do_jdbc
+      do_mysql
+      do_postgres
+      do_sqlite3
+    ]
     
     attr_accessor :system, :local, :missing
     
+    include MerbThorHelper
+    
     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
+      "--ignore-dependencies"  => :boolean,   # skip sub-dependencies
+      "--version"              => :optional   # gather specific version of framework    
     }
     
     method_options global_method_options
     def initialize(*args); super; end
     
-    # List gems that match the specified criteria.
+    # List components and their dependencies.
     #
-    # 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:
-    #
-    # 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)
+    # 
+    # 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
-        warning "Invalid listing filter '#{filter}'"
-      end
+        message "Dependencies for '#{comp}' set:"
+        Merb::Stack.components(comp).each { |c| puts "- #{c}" }
+      end      
     end
     
-    # Install the specified gems.
+    # Install stack components or individual gems - from stable rubygems by default.
     #
-    # All arguments should be names of gems to install.
+    # See also: Merb::Dependencies#install and Merb::Dependencies#install_dependencies
     #
-    # 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:
     #
-    # 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
-     
-    desc 'install GEM_NAME [GEM_NAME, ...]', 'Install a gem from rubygems'
-    method_options "--cache"        => :boolean,
-                   "--dry-run"      => :boolean,
-                   "--force"        => :boolean
-    def install(*names)
-      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]
+    # 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                  
       
-      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))
-        end
-      end
-    rescue => e
-      error "Failed to install #{current_gem ? current_gem : 'gem'} (#{e.message})"
+    desc 'install [COMP, ...]', 'Install stack components'
+    method_options  "--edge"      => :boolean,
+                    "--sources"   => :optional,
+                    "--force"     => :boolean,
+                    "--dry-run"   => :boolean,
+                    "--strategy"  => :optional
+    def install(*comps)
+      use_edge_gem_server if options[:edge]
+      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
-    
-    # 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, ...
+        
+    # Uninstall stack components or individual gems.
     #
-    # 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.
+    # See also: Merb::Dependencies#uninstall
     #
     # Examples:
     #
-    # 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
+    # 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 GEM_NAME [GEM_NAME, ...]', 'Unstall a gem'
-    method_options "--dry-run" => :boolean
-    def uninstall(*names)
-      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 #{current_gem ? current_gem : 'gem'} (#{e.message})"
+    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
     
-    private
+    # Install or uninstall minigems from the system.
+    #
+    # Due to the specific nature of MiniGems it can only be installed system-wide.
+    #
+    # Examples:
+    #
+    # merb:stack:minigems install                               # install minigems
+    # merb:stack:minigems uninstall                             # uninstall minigems
     
-    # 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])
+    desc 'minigems (install|uninstall)', 'Install or uninstall minigems (needs sudo privileges)'
+    def minigems(action)
+      case action
+      when 'install'
+        Kernel.system "#{sudo} thor merb:stack:install_minigems"
+      when 'uninstall'
+        Kernel.system "#{sudo} thor merb:stack:uninstall_minigems"
       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
+        error "Invalid command: merb:stack:minigems #{action}"
       end
-      ::Gem.clear_paths if gem_dir
-      deps.sort
-    end
-    
-    public
+    end    
     
-    # 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))
+    # hidden minigems install task
+    def install_minigems
+      message "Installing MiniGems"
+      mngr = self.dependency_manager
+      deps = gather_dependencies('minigems')
+      mngr.system, mngr.local, mngr.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      mngr.force_gem_dir = ::Gem.dir
+      mngr.install_dependencies(strategy, deps)
+      Kernel.system "#{sudo} minigem install"
     end
     
-    # Uninstall gem with some default options.
-    def self.uninstall(name, options = {})
-      defaults = { :ignore => true, :executables => true }
-      uninstall_gem(name, defaults.merge(options))
+    # hidden minigems uninstall task
+    def uninstall_minigems
+      message "Uninstalling MiniGems"
+      Kernel.system "#{sudo} minigem uninstall"
+      deps = gather_dependencies('minigems')
+      self.system, self.local, self.missing = Merb::Gem.partition_dependencies(deps, gem_dir)
+      # Clobber existing local dependencies - based on self.local
+      clobber_dependencies!      
     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
-      "--ignore-dependencies"  => :boolean,   # don't install 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
+    protected
     
-    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
+    def gather_dependencies(comps = [])
+      if comps.empty?
+        gems = MERB_STACK
       else
-        error "Unknown listing: #{mode}"
+        gems = comps.map { |c| Merb::Stack.components(c) }.flatten
       end
-    end
-
-    # Install the specified gems.
-    #
-    # 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:
-    #
-    # 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
-
-    desc 'install GEM_NAME [GEM_NAME, ...]', 'Install a gem from git source/edge'
-    method_options "--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) }
+      version_req = if options[:version]
+        ::Gem::Requirement.create(options[:version])
+      end
       
-      # Selectively update repositories for the matching dependencies
-      update_dependency_repositories(deps) unless dry_run?
+      framework_components = Merb::Stack.framework_components
       
-      current_gem = nil
-      deps.each do |dependency|
-        current_gem = dependency.name      
-        if dry_run?
-          note "Installing #{current_gem} from source..."
+      gems.map do |gem|
+        if version_req && framework_components.include?(gem)
+          ::Gem::Dependency.new(gem, version_req)
         else
-          message "Installing #{current_gem} from source..."
-          unless install_dependency_from_source(dependency)
-            raise "gem source not found"
-          end
+          ::Gem::Dependency.new(gem, ::Gem::Requirement.default)
         end
       end
-    rescue => e
-      error "Failed to install #{current_gem ? current_gem : 'gem'} (#{e.message})"
     end
     
-    # 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, ...
-    #
-    # 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:
-    #
-    # merb:source:uninstall merb-core merb-slices       # uninstall all specified gems
-    # merb:source:uninstall merb-core --wipe            # force-uninstall a gem and clear repo
-    
-    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
-      end
-      
-      # Use the Merb::Gem#uninstall task to handle this
-      gem_tasks = Merb::Gem.new
-      gem_tasks.options = options
-      gem_tasks.uninstall(*names)
+    def strategy
+      options[:strategy] || (options[:edge] ? 'edge' : 'stable')
     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
-    
-    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!"
+    def dependency_manager
+      @_dependency_manager ||= begin
+        instance = Merb::Dependencies.new
+        instance.options = options
+        instance
       end
-    end    
+    end
     
-    # Clone a git repository into ./src. 
+    public
     
-    # 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
+    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
+        comps["do"]           = DATA_OBJECTS.sort
+        
+        comps
+      end     
+    end
     
-    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
+    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
-      source_manager.clone(name || repository_name, repository_url)
     end
     
-    # 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. 
-    #
-    # 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
+    def self.framework_components
+      %w[merb-core merb-more].inject([]) do |all, comp| 
+        all + components(comp)
       end
-      if source_config && File.exists?(source_config)
-        default_repos.merge(YAML.load(File.read(source_config)))
+    end
+    
+    def self.components(comp = nil)
+      if comp
+        component_sets[comp]
       else
-        default_repos
+        comps = %w[merb-core merb-more merb-plugins dm-core dm-more]
+        comps.inject([]) do |all, grp|
+          all + (component_sets[grp] || [])
+        end
       end
     end
     
-    def self.repo(name, source_config = nil)
-      self.repos(source_config)[name]
+    def self.select_component_dependencies(dependencies, comp = nil)
+      comps = components(comp) || []
+      dependencies.select { |dep| comps.include?(dep.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"
-      }
+    def self.base_components
+      %w[thor rake extlib]
     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
+          orig_gem_path = ::Gem.path
+          ::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
+        ::Gem.path.replace(orig_gem_path) if gem_dir # reset
+        deps
+      end
+    end
+    
+    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
   
 end