merb-core 0.9.8 → 0.9.9

data/lib/merb-core/tasks/gem_management.rb

@@ -1,7 +1,4 @@
 require 'rubygems'
-require 'rubygems/dependency_installer'
-require 'rubygems/uninstaller'
-require 'rubygems/dependency'
 
 module ColorfulMessages
   
@@ -22,12 +19,28 @@ module ColorfulMessages
   
   alias_method :message, :success
   
+  # magenta
+  def note(*messages)
+    puts messages.map { |msg| "\033[1;35m#{msg}\033[0m" }
+  end
+  
+  # blue
+  def info(*messages)
+    puts messages.map { |msg| "\033[1;34m#{msg}\033[0m" }
+  end
+  
 end
 
+##############################################################################
+
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+require 'rubygems/dependency'
+
 module GemManagement
   
   include ColorfulMessages
-  
+    
   # Install a gem - looks remotely and local gem cache;
   # won't process rdoc or ri options.
   def install_gem(gem, options = {})
@@ -39,13 +52,13 @@ module GemManagement
       version = options.delete(:version)
       Gem.configuration.update_sources = false
 
+      # Limit source index to install dir
       update_source_index(options[:install_dir]) if options[:install_dir]
 
       installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
       
-      # Exclude gems to refresh from index - force (re)install of new version
-      # def installer.source_index; @source_index; end
-      unless refresh.empty?
+      # Force-refresh certain gems by excluding them from the current index
+      if !options[:ignore_dependencies] && refresh.respond_to?(:include?) && !refresh.empty?
         source_index = installer.instance_variable_get(:@source_index)
         source_index.gems.each do |name, spec| 
           source_index.gems.delete(name) if refresh.include?(spec.name)
@@ -68,7 +81,7 @@ module GemManagement
         exception = e
       end
       if installer.installed_gems.empty? && exception
-        error "Failed to install gem '#{gem} (#{version})' (#{exception.message})"
+        error "Failed to install gem '#{gem} (#{version || 'any version'})' (#{exception.message})"
       end
       installer.installed_gems.each do |spec|
         success "Successfully installed #{spec.full_name}"
@@ -103,81 +116,73 @@ module GemManagement
   end
 
   # Install a gem from source - builds and packages it first then installs.
-  def install_gem_from_src(gem_src_dir, options = {})
-    if !File.directory?(gem_src_dir)
-      raise "Missing rubygem source path: #{gem_src_dir}"
-    end
-    if options[:install_dir] && !File.directory?(options[:install_dir])
-      raise "Missing rubygems path: #{options[:install_dir]}"
-    end
+  # 
+  # Examples:
+  # install_gem_from_source(source_dir, :install_dir => ...)
+  # install_gem_from_source(source_dir, gem_name)
+  # install_gem_from_source(source_dir, :skip => [...])
+  def install_gem_from_source(source_dir, *args)
+    installed_gems = []
+    Dir.chdir(source_dir) do
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      gem_name     = args[0] || File.basename(source_dir)
+      gem_pkg_dir  = File.join(source_dir, 'pkg')
+      gem_pkg_glob = File.join(gem_pkg_dir, "#{gem_name}-*.gem")
+      skip_gems    = opts.delete(:skip) || []
 
-    gem_name = File.basename(gem_src_dir)
-    gem_pkg_dir = File.expand_path(File.join(gem_src_dir, 'pkg'))
+      # Cleanup what's already there
+      clobber(source_dir)
+      FileUtils.mkdir_p(gem_pkg_dir) unless File.directory?(gem_pkg_dir)
 
-    # We need to use local bin executables if available.
-    thor = "#{Gem.ruby} -S #{which('thor')}"
-    rake = "#{Gem.ruby} -S #{which('rake')}"
-
-    # Handle pure Thor installation instead of Rake
-    if File.exists?(File.join(gem_src_dir, 'Thorfile'))
-      # Remove any existing packages.
-      FileUtils.rm_rf(gem_pkg_dir) if File.directory?(gem_pkg_dir)
-      # Create the package.
-      FileUtils.cd(gem_src_dir) { system("#{thor} :package") }
-      # Install the package using rubygems.
-      if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
-        FileUtils.cd(File.dirname(package)) do
-          install_gem(File.basename(package), options.dup)
-          return true
-        end
+      # Recursively process all gem packages within the source dir
+      skip_gems << gem_name
+      packages = package_all(source_dir, skip_gems)
+      
+      if packages.length == 1
+        # The are no subpackages for the main package
+        refresh = [gem_name]
       else
-        raise Gem::InstallError, "No package found for #{gem_name}"
-      end
-    # Handle elaborate installation through Rake
-    else
-      # Clean and regenerate any subgems for meta gems.
-      Dir[File.join(gem_src_dir, '*', 'Rakefile')].each do |rakefile|
-        FileUtils.cd(File.dirname(rakefile)) do 
-          system("#{rake} clobber_package; #{rake} package")
-        end
-      end
-
-      # Handle the main gem install.
-      if File.exists?(File.join(gem_src_dir, 'Rakefile'))
-        subgems = []
-        # Remove any existing packages.
-        FileUtils.cd(gem_src_dir) { system("#{rake} clobber_package") }
-        # Create the main gem pkg dir if it doesn't exist.
-        FileUtils.mkdir_p(gem_pkg_dir) unless File.directory?(gem_pkg_dir)
-        # Copy any subgems to the main gem pkg dir.
-        Dir[File.join(gem_src_dir, '*', 'pkg', '*.gem')].each do |subgem_pkg|
-          if name = File.basename(subgem_pkg, '.gem')[/^(.*?)-([\d\.]+)$/, 1]
-            subgems << name
-          end
-          dest = File.join(gem_pkg_dir, File.basename(subgem_pkg))
-          FileUtils.copy_entry(subgem_pkg, dest, true, false, true)          
+        # Gather all packages into the top-level pkg directory
+        packages.each do |pkg|
+          FileUtils.copy_entry(pkg, File.join(gem_pkg_dir, File.basename(pkg)))
         end
-
-        # Finally generate the main package and install it; subgems
-        # (dependencies) are local to the main package.
-        FileUtils.cd(gem_src_dir) do         
-          system("#{rake} package")
-          FileUtils.cd(gem_pkg_dir) do
-            if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
-              # If the (meta) gem has it's own package, install it.
-              install_gem(File.basename(package), options.merge(:refresh => subgems))
-            else
-              # Otherwise install each package seperately.
-              Dir["*.gem"].each { |gem| install_gem(gem, options.dup) }
-            end
+        
+        # Finally package the main gem - without clobbering the already copied pkgs
+        package(source_dir, false)
+        
+        # Gather subgems to refresh during installation of the main gem
+        refresh = packages.map do |pkg|
+          File.basename(pkg, '.gem')[/^(.*?)-([\d\.]+)$/, 1] rescue nil
+        end.compact
+        
+        # Install subgems explicitly even if ignore_dependencies is set
+        if opts[:ignore_dependencies]
+          refresh.each do |name| 
+            gem_pkg = Dir[File.join(gem_pkg_dir, "#{name}-*.gem")][0]
+            install_pkg(gem_pkg, opts)
           end
-          return true
         end
       end
+      
+      # Finally install the main gem
+      if install_pkg(Dir[gem_pkg_glob][0], opts.merge(:refresh => refresh))
+        installed_gems = refresh
+      else
+        installed_gems = []
+      end
     end
-    raise Gem::InstallError, "No Rakefile found for #{gem_name}"
+    installed_gems
   end
-
+  
+  def install_pkg(gem_pkg, opts = {})
+    if (gem_pkg && File.exists?(gem_pkg))
+      # Needs to be executed from the directory that contains all packages
+      Dir.chdir(File.dirname(gem_pkg)) { install_gem(gem_pkg, opts) }
+    else
+      false
+    end
+  end
+  
   # Uninstall a gem.
   def uninstall_gem(gem, options = {})
     if options[:version] && !options[:version].is_a?(Gem::Requirement)
@@ -187,6 +192,45 @@ module GemManagement
     Gem::Uninstaller.new(gem, options).uninstall
   end
 
+  def clobber(source_dir)
+    Dir.chdir(source_dir) do 
+      system "#{Gem.ruby} -S rake -s clobber" unless File.exists?('Thorfile')
+    end
+  end
+
+  def package(source_dir, clobber = true)
+    Dir.chdir(source_dir) do 
+      if File.exists?('Thorfile')
+        thor ":package"
+      elsif File.exists?('Rakefile')
+        rake "clobber" if clobber
+        rake "package"
+      end
+    end
+    Dir[File.join(source_dir, 'pkg/*.gem')]
+  end
+
+  def package_all(source_dir, skip = [], packages = [])
+    if Dir[File.join(source_dir, '{Rakefile,Thorfile}')][0]
+      name = File.basename(source_dir)
+      Dir[File.join(source_dir, '*', '{Rakefile,Thorfile}')].each do |taskfile|
+        package_all(File.dirname(taskfile), skip, packages)
+      end
+      packages.push(*package(source_dir)) unless skip.include?(name)
+    end
+    packages.uniq
+  end
+  
+  def rake(cmd)
+    cmd << " >/dev/null" if $SILENT && !Gem.win_platform?
+    system "#{Gem.ruby} -S #{which('rake')} -s #{cmd} >/dev/null"
+  end
+  
+  def thor(cmd)
+    cmd << " >/dev/null" if $SILENT && !Gem.win_platform?
+    system "#{Gem.ruby} -S #{which('thor')} #{cmd}"
+  end
+
   # Use the local bin/* executables if available.
   def which(executable)
     if File.executable?(exec = File.join(Dir.pwd, 'bin', executable))
@@ -196,17 +240,43 @@ module GemManagement
     end
   end
   
+  # Partition gems into system, local and missing gems
+  def partition_dependencies(dependencies, gem_dir)
+    system_specs, local_specs, missing_deps = [], [], []
+    if gem_dir && File.directory?(gem_dir)
+      gem_dir = File.expand_path(gem_dir)
+      ::Gem.clear_paths; ::Gem.path.unshift(gem_dir)
+      ::Gem.source_index.refresh!
+      dependencies.each do |dep|
+        gemspecs = ::Gem.source_index.search(dep)
+        local = gemspecs.reverse.find { |s| s.loaded_from.index(gem_dir) == 0 }
+        if local
+          local_specs  << local
+        elsif gemspecs.last
+          system_specs << gemspecs.last
+        else
+          missing_deps << dep
+        end
+      end
+      ::Gem.clear_paths
+    end
+    [system_specs, local_specs, missing_deps]
+  end
+  
   # Create a modified executable wrapper in the specified bin directory.
   def ensure_bin_wrapper_for(gem_dir, bin_dir, *gems)
+    options = gems.last.is_a?(Hash) ? gems.last : {}
+    options[:no_minigems] ||= []
     if bin_dir && File.directory?(bin_dir)
       gems.each do |gem|
         if gemspec_path = Dir[File.join(gem_dir, 'specifications', "#{gem}-*.gemspec")].last
           spec = Gem::Specification.load(gemspec_path)
+          enable_minigems = !options[:no_minigems].include?(spec.name)
           spec.executables.each do |exec|
             executable = File.join(bin_dir, exec)
             message "Writing executable wrapper #{executable}"
             File.open(executable, 'w', 0755) do |f|
-              f.write(executable_wrapper(spec, exec))
+              f.write(executable_wrapper(spec, exec, enable_minigems))
             end
           end
         end
@@ -216,7 +286,10 @@ module GemManagement
 
   private
 
-  def executable_wrapper(spec, bin_file_name)
+  def executable_wrapper(spec, bin_file_name, minigems = true)
+    requirements = ['minigems', 'rubygems']
+    requirements.reverse! unless minigems
+    try_req, then_req = requirements
     <<-TEXT
 #!/usr/bin/env ruby
 #
@@ -226,9 +299,9 @@ module GemManagement
 # this file is here to facilitate running it.
 
 begin 
-  require 'minigems'
+  require '#{try_req}'
 rescue LoadError 
-  require 'rubygems'
+  require '#{then_req}'
 end
 
 if File.directory?(gems_dir = File.join(Dir.pwd, 'gems')) ||
@@ -263,5 +336,5 @@ TEXT
   def update_source_index(dir)
     Gem.source_index.load_gems_in(File.join(dir, 'specifications'))
   end
-  
-end
+    
+end

data/lib/merb-core/tasks/merb_rake_helper.rb

@@ -9,7 +9,12 @@ module Merb
       defaults = { :cache => false }
       defaults[:install_dir] = ENV['GEM_DIR'] if ENV['GEM_DIR']
       opts = defaults.merge(options)
-      install_gem_from_src(Dir.pwd, opts)
+      dir = if File.directory?(subdir = File.join(Dir.pwd, name))
+        subdir
+      else
+        Dir.pwd
+      end
+      install_gem_from_source(dir, name, opts)
       ensure_wrapper(opts[:install_dir] || Gem.default_dir, name)
     end
     
@@ -17,7 +22,10 @@ module Merb
       defaults = { :cache => false }
       defaults[:install_dir] = ENV['GEM_DIR'] if ENV['GEM_DIR']
       opts = defaults.merge(options)
-      install_gem(pkg, opts)
+      # Needs to be executed from the directory that contains all packages
+      Dir.chdir(File.dirname(pkg_file = File.expand_path(pkg))) do 
+        install_gem(pkg_file, opts)
+      end
       name = File.basename(pkg, '.gem')[/^(.*?)-([\d\.]+)$/, 1]
       ensure_wrapper(opts[:install_dir] || Gem.default_dir, name)
     end
@@ -26,7 +34,7 @@ module Merb
       defaults = { :ignore => true, :executables => true }
       defaults[:install_dir] = ENV['GEM_DIR'] if ENV['GEM_DIR']
       uninstall_gem(name, defaults.merge(options))
-    end
+    end  
     
     def self.sudo
       ENV['MERB_SUDO'] ||= "sudo"
@@ -44,7 +52,7 @@ module Merb
       bindir = File.expand_path(File.join(gemdir, '..', 'bin'))
       # Fall back to system wide bindir - usually needs sudo permissions
       bindir = Gem.bindir unless File.directory?(bindir)
-      ensure_bin_wrapper_for(gemdir, bindir, name)
+      ensure_bin_wrapper_for(gemdir, bindir, name, :no_minigems => ['merb-gen'])
     end
     
   end

data/lib/merb-core/tasks/stats.rake

@@ -66,6 +66,6 @@ task :stats do
   code_loc = [:controllers, :helpers, :models].inject(0) { |sum, e| sum += @all[e][:loc] }
   test_loc = @all[:spec][:loc]
  
-  puts "   Code LOC: #{cb}#{code_loc}#{ce}     Test LOC: #{cb}#{test_loc}#{ce}     Test to code radio:  #{cb}1:%0.2f#{ce}" % (test_loc.to_f / code_loc.to_f)
+  puts "   Code LOC: #{cb}#{code_loc}#{ce}     Test LOC: #{cb}#{test_loc}#{ce}     Code to test radio:  #{cb}1:%0.2f#{ce}" % (test_loc.to_f / code_loc.to_f)
   puts
 end

data/lib/merb-core/test/helpers/mock_request_helper.rb

@@ -74,8 +74,8 @@ module Merb
       # ==== Notes
       # If you pass a post body, the content-type will be set to URL-encoded.
       #
-      #---
-      # @public
+      # @api public
+      # @deprecated
       def fake_request(env = {}, opt = {})
         if opt[:post_body]
           req = opt[:post_body]
@@ -111,8 +111,8 @@ module Merb
       # ==== Notes
       # Does not use routes.
       #
-      #---
-      # @public
+      # @api public
+      # @deprecated
       def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
         params = merge_controller_and_action(controller_klass, action, params)
         dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
@@ -124,6 +124,9 @@ module Merb
       # ==== Parameters
       # *controller_classes:: Controller classes to operate on in the context of the block.
       # &blk:: The context to operate on; optionally accepts the cookie jar as an argument.
+      #
+      # @api public
+      # @deprecated
       def with_cookies(*controller_classes, &blk)
         cookie_jar = CookieJar.new
         before_cb = lambda { |c| c.cookies.update(cookie_jar) }
@@ -166,8 +169,8 @@ module Merb
       # ==== Notes
       # Does not use routes.
       #
-      #---
-      # @public
+      # @api public
+      # @deprecated
       def dispatch_with_basic_authentication_to(controller_klass, action, username, password, params = {}, env = {}, &blk)
         env["X_HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64("#{username}:#{password}")}"
         
@@ -175,6 +178,7 @@ module Merb
         dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
       end
       
+      # @api private
       def merge_controller_and_action(controller_klass, action, params)
         params[:controller] = controller_klass.name.to_const_path
         params[:action]     = action.to_s
@@ -203,8 +207,8 @@ module Merb
       # ==== Notes
       # Does not use routes.
       #
-      #---
-      # @public      
+      # @api public    
+      # @deprecated  
       def build_request(params = {}, env = {})
         params             = Merb::Request.params_to_query_string(params)
 
@@ -227,8 +231,9 @@ module Merb
       # &blk::
       #   The controller is yielded to the block provided for actions *prior* to
       #   the action being dispatched.
-      #---
-      # @public      
+      #
+      # @api public  
+      # @deprecated    
       def get(path, params = {}, env = {}, &block)
         env[:request_method] = "GET"
         mock_request(path, params, env, &block)
@@ -246,8 +251,9 @@ module Merb
       # &blk::
       #   The controller is yielded to the block provided for actions *prior* to
       #   the action being dispatched.
-      #---
-      # @public      
+      #
+      # @api public  
+      # @deprecated    
       def post(path, params = {}, env = {}, &block)
         env[:request_method] = "POST"
         mock_request(path, params, env, &block)
@@ -265,8 +271,8 @@ module Merb
       # &blk::
       #   The controller is yielded to the block provided for actions *prior* to
       #   the action being dispatched.
-      #---
-      # @public      
+      #
+      # @api public      
       def put(path, params = {}, env = {}, &block)
         env[:request_method] = "PUT"
         mock_request(path, params, env, &block)
@@ -284,8 +290,9 @@ module Merb
       # &blk::
       #   The controller is yielded to the block provided for actions *prior* to
       #   the action being dispatched.
-      #---
-      # @public
+      #
+      # @api public
+      # @deprecated
       def delete(path, params = {}, env = {}, &block)
         env[:request_method] = "DELETE"
         mock_request(path, params, env, &block)
@@ -313,8 +320,8 @@ module Merb
       # ==== Notes
       # Uses Routes.
       #
-      #---
-      # @semi-public
+      # @api plugin
+      # @deprecated
       def mock_request(path, params = {}, env= {}, &block)
         env[:request_method] ||= "GET"
         env[:request_uri], env[:query_string] = path.split('?')
@@ -352,8 +359,8 @@ module Merb
       # ==== Notes
       # Does not use routes.
       #
-      #---
-      # @public
+      # @api public
+      # @deprecated
       def dispatch_request(request, controller_klass, action, &blk)
         controller = controller_klass.new(request)
         yield controller if block_given?
@@ -378,8 +385,8 @@ module Merb
       # ==== Returns
       # Hash:: The parameters built based on the matching route.
       #
-      #---
-      # @semi-public
+      # @api plugin
+      # @deprecated
       def check_request_for_route(request)
         match =  ::Merb::Router.match(request)
         if match[0].nil? && match[1].empty?