merb 0.3.7 → 0.4.0

data/lib/merb/merb_dispatcher.rb

@@ -1,87 +0,0 @@
-module Merb
-  
-  class Dispatcher
-    class << self
-      
-      attr_accessor :path_prefix
-      
-      def use_mutex=(val)
-        @@use_mutex = val
-      end
-      
-      @@mutex = Mutex.new
-      @@use_mutex = ::Merb::Server.use_mutex
-      # This is where we grab the incoming request REQUEST_URI and use that in
-      # the merb RouteMatcher to determine which controller and method to run.
-      # Returns a 2 element tuple of: [controller, action]
-      def handle(request, response)
-        start = Time.now
-        
-        request_uri = request.params[Merb::Const::REQUEST_URI]
-        request_uri.sub!(path_prefix, '') if path_prefix
-        route = route_path(request_uri)
-      
-        allowed = route.delete(:allowed)
-        rest = route.delete(:rest)
-        namespace = route.delete(:namespace)
-        
-        cont = namespace ? "#{namespace}/#{route[:controller]}" : route[:controller]
-        
-        klass = resolve_controller(cont)
-        controller = klass.build(request.body, request.params, route, response)
-      
-        if rest
-          method = controller.request.method
-          if allowed.keys.include?(method) && action = allowed[method]
-            controller.params[:action] = action
-          else
-            raise Merb::HTTPMethodNotAllowed.new(method, allowed)
-          end  
-        else  
-          action = route[:action]
-        end
-        controller._benchmarks[:setup_time] = Time.now - start
-        if @@use_mutex
-          @@mutex.synchronize {
-            controller.dispatch(action)
-          }
-        else
-          controller.dispatch(action)
-        end
-        [controller, action]
-      end
-      
-      def route_path(path)
-        path = path.sub(/\/+/, '/').sub(/\?.*$/, '')
-        path = path[0..-2] if (path[-1] == ?/) && path.size > 1
-        Merb::Router.match(path)
-      end
-      
-      # Take a controller class name string and reload or require the right
-      # controller file then CamelCase it and return the class object.
-      def resolve_controller(controller_name)
-        segments = controller_name.split('/').map{|s| s.snake_case}
-        path = "#{DIST_ROOT}/app/controllers/#{controller_name}.rb"
-        cnt = segments.map{|s| s.camel_case }.join('::')
-        
-        if !File.exist?(path)
-          raise "Bad controller! #{cnt}"
-        end unless $TESTING
-        
-        begin
-          if MERB_ENV == 'development'
-            Object.send(:remove_const, cnt) rescue nil
-            load(path)
-          end
-          return Object.full_const_get(cnt)
-        rescue RuntimeError
-          warn "Error getting instance of '#{controller_name.camel_case}': #{$!}"
-          raise $!
-        end
-      end
-
-    end # end class << self
-      
-  end
-  
-end

data/lib/merb/merb_exceptions.rb

@@ -1,319 +0,0 @@
-begin
-  require 'coderay'
-rescue LoadError => ex
-end
-
-module Merb
-  
-  module ControllerExceptions
-    # ControllerExceptions are a way of simplifying controller code by placing
-    # exceptional logic elsewhere. ControllerExceptions are like 
-    # mini-controllers which have one action. The exception action is called 
-    # to render a web page when the exception is raised. Additionally all
-    # ControllerExceptions have an HTTP status code associated with them
-    # which is given to the browser when it's action is rendered.
-    #
-    # ControllerExceptions::Base is an abstract base class, it cannot be
-    # raised. Derived from Base are many exceptions, one for each HTTP status
-    # code. EG Unauthorized (401), PaymentRequired (402), and Forbidden (403).
-    #
-    # These exceptions can be raised by your controller without any further
-    # work. For example
-    #
-    #   def show
-    #     product = Product.find(params[:id])
-    #     raise NotFound if product.nil?
-    #     [...]
-    #   end
-    #
-    # By default the NotFound exception will look in for a template at
-    #   app/views/exceptions/not_found.{rhtml, haml, whatevs}
-    # If the template is not found then a simple message will be sent.
-    #
-    # To extend the use of the ControllerExceptions one may derive a new
-    # exception from one of the already defined ones. Then one must add a
-    # special method called error_response which is like a controller action
-    # preparing the context for rendering a template at 
-    #   app/views/exceptions/my_exception_snake_cased.whatevs
-    #
-    # As an example we will create an exception called AdminAccessRequired.
-    # First we decide on what HTTP status code such an error might have.
-    # 401, Unauthorized seems to fit. 
-    #
-    #   class AdminAccessRequired < Merb::ControllerExceptions::Unauthorized
-    #     def error_response
-    #       @tried_to_access request.uri
-    #       render :layout => 'error_page'
-    #     end
-    #   end
-    #
-    # At app/views/exceptions/admin_access_required.rhtml we write
-    # 
-    #   <h1>You're not an administrator!</h1>
-    #   <p>You tried to access <%= @tried_to_access %> but that URL is 
-    #   restricted to administrators.</p>
-    #
-    # The layout 'error_page' works like any other controller, it would be
-    # looked for at app/views/layouts
-    #
-    # TODO: if you need to pass data to your exception use a constructor.
-    class Base < StandardError
-      include Merb::RenderMixin
-      include Merb::ControllerMixin
-      include Merb::ResponderMixin
-      
-      def _template_root
-        @controller._template_root
-      end
-      
-      # The filename of the exception template. usually something like
-      # views/exceptions/not_found.rhtml
-      def template_path
-        _template_root / 'exceptions' / self.class.name.snake_case.split('::').last
-      end
-      
-      def set_controller(controller)
-        @controller = controller
-      end
-      
-      def request;  @controller.request;  end      
-      def params;   @controller.params;   end
-      def cookies;  @controller.cookies;  end
-      def headers;  @controller.headers;  end
-      def session;  @controller.session;  end
-      def response; @controller.response; end      
-      
-      def status
-        self.class.const_get(:STATUS)
-      end
-      
-      def call_action
-        # TODO: this method is meaningless at the moment but it could call
-        # filters
-        # before filters?
-        error_response
-        # after filters?
-      end
-      
-      def error_response
-        if File.exists?(template_path)
-          render
-        else
-          "Error #{status} #{self.class.name.split('::').last}!"
-        end
-      end
-    end
-    module HTTPErrors
-      # created with: 
-      # ruby -r rubygems -e "require 'mongrel'; puts Mongrel::HTTP_STATUS_CODES.keys.sort.map {|code| %Q{class #{Mongrel::HTTP_STATUS_CODES[code].gsub /[^\w]/,''} < Merb::ControllerExceptions::Base; STATUS = #{code}; end} }.join(%Q{\n})"
-      # we could do some magic here, but i think it's more instructive to just
-      # have these values copied
-      class Continue < Merb::ControllerExceptions::Base; STATUS = 100; end
-      class SwitchingProtocols < Merb::ControllerExceptions::Base; STATUS = 101; end
-      class OK < Merb::ControllerExceptions::Base; STATUS = 200; end
-      class Created < Merb::ControllerExceptions::Base; STATUS = 201; end
-      class Accepted < Merb::ControllerExceptions::Base; STATUS = 202; end
-      class NonAuthoritativeInformation < Merb::ControllerExceptions::Base; STATUS = 203; end
-      class NoContent < Merb::ControllerExceptions::Base; STATUS = 204; end
-      class ResetContent < Merb::ControllerExceptions::Base; STATUS = 205; end
-      class PartialContent < Merb::ControllerExceptions::Base; STATUS = 206; end
-      class MultipleChoices < Merb::ControllerExceptions::Base; STATUS = 300; end
-      class MovedPermanently < Merb::ControllerExceptions::Base; STATUS = 301; end
-      class MovedTemporarily < Merb::ControllerExceptions::Base; STATUS = 302; end
-      class SeeOther < Merb::ControllerExceptions::Base; STATUS = 303; end
-      class NotModified < Merb::ControllerExceptions::Base; STATUS = 304; end
-      class UseProxy < Merb::ControllerExceptions::Base; STATUS = 305; end
-      class BadRequest < Merb::ControllerExceptions::Base; STATUS = 400; end
-      class Unauthorized < Merb::ControllerExceptions::Base; STATUS = 401; end
-      class PaymentRequired < Merb::ControllerExceptions::Base; STATUS = 402; end
-      class Forbidden < Merb::ControllerExceptions::Base; STATUS = 403; end
-      class NotFound < Merb::ControllerExceptions::Base; STATUS = 404; end
-      class MethodNotAllowed < Merb::ControllerExceptions::Base; STATUS = 405; end
-      class NotAcceptable < Merb::ControllerExceptions::Base; STATUS = 406; end
-      class ProxyAuthenticationRequired < Merb::ControllerExceptions::Base; STATUS = 407; end
-      class RequestTimeout < Merb::ControllerExceptions::Base; STATUS = 408; end
-      class Conflict < Merb::ControllerExceptions::Base; STATUS = 409; end
-      class Gone < Merb::ControllerExceptions::Base; STATUS = 410; end
-      class LengthRequired < Merb::ControllerExceptions::Base; STATUS = 411; end
-      class PreconditionFailed < Merb::ControllerExceptions::Base; STATUS = 412; end
-      class RequestEntityTooLarge < Merb::ControllerExceptions::Base; STATUS = 413; end
-      class RequestURITooLarge < Merb::ControllerExceptions::Base; STATUS = 414; end
-      class UnsupportedMediaType < Merb::ControllerExceptions::Base; STATUS = 415; end
-      class InternalServerError < Merb::ControllerExceptions::Base; STATUS = 500; end
-      class NotImplemented < Merb::ControllerExceptions::Base; STATUS = 501; end
-      class BadGateway < Merb::ControllerExceptions::Base; STATUS = 502; end
-      class ServiceUnavailable < Merb::ControllerExceptions::Base; STATUS = 503; end
-      class GatewayTimeout < Merb::ControllerExceptions::Base; STATUS = 504; end
-      class HTTPVersionNotSupported < Merb::ControllerExceptions::Base; STATUS = 505; end
-    end
-    
-    include HTTPErrors
-  end
-  
-  class MerbError < StandardError; end  
-  class Noroutefound < MerbError; end  
-  class MissingControllerFile < MerbError; end
-  class MerbControllerError < MerbError; end
-  class HTTPMethodNotAllowed < MerbError
-    def initialize(method, allowed)
-      super("HTTPMethodNotAllowed: #{method}\n"+ "Allowed: #{allowed.keys.join(' ')})")
-    end
-    
-  end
-  
-  # Format exception message for browser display.
-  def self.html_exception(e)
-    if ::Merb::Server.show_error
-      ErrorResponse.new(e).out 
-    else
-      IO.read(DIST_ROOT / 'public/500.html') rescue "500 Internal Server Error!"
-    end
-  end  
-  
-  def self.exception(e)
-    "#{ e.message } - (#{ e.class })\n" << 
-    "#{(e.backtrace or []).join("\n")}"
-  end
-
-  class ErrorResponse
-    def initialize error
-      @error = error
-    end
-
-    def out
-      error = @error
-      backtrace = @error.backtrace
-    
-      colors = []
-      min = 200
-      max = 255
-      step = -((max - min) / backtrace.size).abs
-      max.step(min, step) do |color|
-        colors << color
-      end
-    
-      backtrace.map! do |line|
-        file, lineno, meth = line.scan(/(.*?):(\d+)(?::in `(.*?)')?/).first
-        
-        # When a backtrace entry doesn't have a filepath as the first field 
-        # (e.g., "(haml):12" or "(eval):41:in `_haml_render'"), it'll cause 
-        # a second exception to be raised, masking the first.  This traps it.  
-        lines = (__caller_lines__(file, lineno, 5) rescue [])
-        
-        [ lines, lines.object_id.abs, file, lineno, meth ]
-      end
-    
-      error_page(colors, error, *backtrace)
-    end
-    
-    # This method offers highlighting for the sourcecode-chunks from the
-    # traceback. Just 'gem install coderay'.
-    def error_page(colors, title, *backtrace)
-      @backtrace = backtrace
-      @colors = colors
-      @title = title
-      @coderay = Object.constants.include?('CodeRay')
-      
-    
-      template = 
-          <<-HEREDOC
-<html>
-  <head>
-    <title><%= @title %></title>
-    <style type="text/css">
-      <!--
-      table {border:0px}
-      tr {line-height:1.3}
-      td {font-size:.8em; padding:4px}
-      h1 {font-size:2em}
-      h1, td {font-family:'courier new', 'courier', monospace}
-      td.line {color:#000;  text-align:center}
-      td.method {font-weight:bold; text-align:right}
-      td.file a {color:#000}
-      td.file a:hover {color:#F00}
-      tr.clickable:hover {background:#FFA}
-      .clickable {cursor: help }
-      #title {float: left;}
-      .source 
-      {
-        border:1px #000 solid;
-        margin:2px;
-        padding:8px;
-        background:#F0F0F0;
-      }
-      
-      -->
-      <% if @coderay %>
-        <%= CodeRay::Encoders[:html]::CSS.new.stylesheet %>
-      <% end %>  
-    </style>
-    <script type="text/javascript">
-    $ = function(el){
-      if(el === null || el === undefined)
-        throw("Argument for $() must be a domRef/domId");
-      if( el.constructor === String )
-        el = document.getElementById(el);
-      if(el === null || !el.nodeType)
-        throw("Argument for $() not found in document tree.");
-      return el;
-    }
-
-    var toggle = function(el){
-      el = $(el);
-      var visible = el.style.display != 'none';  // visible? boolean
-      if(visible){
-        el.style.display = 'none'; // hide
-      }else{
-        el.style.display = '';  // unhide
-      }
-    }
-    </script>
-  </head>
-  <body>
-    <div>
-      <h1><img src="data:image/jpg;base64,/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAJQAA/+4ADkFk\nb2JlAGTAAAAAAf/bAIQADQkJCQoJDQoKDRMMCwwTFhENDREWGhUVFhUVGhkU\nFhUVFhQZGR0fIB8dGScnKionJzk4ODg5QEBAQEBAQEBAQAEODAwOEA4RDw8R\nFA4RDhQVERISERUgFRUXFRUgKB0ZGRkZHSgjJiAgICYjLCwoKCwsNzc1NzdA\nQEBAQEBAQEBA/8AAEQgAJgAtAwEiAAIRAQMRAf/EAT8AAAEFAQEBAQEBAAAA\nAAAAAAMAAQIEBQYHCAkKCwEAAQUBAQEBAQEAAAAAAAAAAQACAwQFBgcICQoL\nEAABBAEDAgQCBQcGCAUDDDMBAAIRAwQhEjEFQVFhEyJxgTIGFJGhsUIjJBVS\nwWIzNHKC0UMHJZJT8OHxY3M1FqKygyZEk1RkRcKjdDYX0lXiZfKzhMPTdePz\nRieUpIW0lcTU5PSltcXV5fVWZnaGlqa2xtbm9jdHV2d3h5ent8fX5/cRAAIC\nAQIEBAMEBQYHBwYFNQEAAhEDITESBEFRYXEiEwUygZEUobFCI8FS0fAzJGLh\ncoKSQ1MVY3M08SUGFqKygwcmNcLSRJNUoxdkRVU2dGXi8rOEw9N14/NGlKSF\ntJXE1OT0pbXF1eX1VmZ2hpamtsbW5vYnN0dXZ3eHl6e3x//aAAwDAQACEQMR\nAD8A9OVDK6xRQYa02axuEBvnB7x8Fm/W36x19HqoxmAvyswkMraHFwY2N7va\nCe/5Vy/Seu29RvdXaI2CW6EBw4OhGnZAk9Einrbuvn03Oaw1lvmCCP8ANXPW\n9Zz7shlrM9zKBLnN3Fmg1gnj8An61m14eCbAN9j4ZVWJJc5x2gQPivO3ZnUM\nXLtfY8by73sDmuHw9pPCZRPVNgdH13F+teJU51WbZpX9O4xpPEho4juug9Wr\n0vW3t9Lbv9SRt2xO7dxEL5+blW5I2W2FrdsSJJgdj4r0P1W/+Nf6Un1p9PZJ\nnf8AaPU2+P0fwThdVaLF3TlfXZvUsr63ZIpZY4Y9VDKTWwuIY5vqEe3uXFx+\nSn0XBupy9t+loqDXy1zTJLST7tefJbVDLsjLycwO9Sy/09ANQafUJP8A4IrG\nQGufXltEAjZYPA900kkeCRoXA+sHSeoTXn41xJxnB9bY3e4HRcTbVsfB2h7j\ntDWkkAT7jrPjC9FzCMfpJZU5wDGgN7wNI4HZcJdiNrvP2t+62SNg9vedxnRO\nj2WyQfZy2oOA5kbfGedF0jb8w/Uq2ra/25NcGD9F1dk6/BqrYNODY5rrve4+\n2rGpBcR3Mr0j9iVf83vscD1J3bZMep/NelM+Hsn5oqa3RG0uuf6b9j9dsCRI\n+lx4haGT9g1FgZ6nc0n/AKrSEkko/Kg7vO9XtsxzV+y6a8xjtxu+hWWwPY0f\npBMnv2XN52ZmbyLunYocCZNl1bpdENmS0wOdUkkPsT9rL6rfbf8AnJiPzvT+\nzfpPVrZ6ezb6Ttv0e26OTzC9U3uk+z88ACRu+hz8YSSR6q6P/9k=\n"/>
-    <%= @title %></h1>
-    </div>
-    
-    <table class="main">
-      <thead>
-        <tr>
-          <td class="method">Method</td>
-          <td class="line">Line</td>        
-          <td class="file">File</td>
-        </tr>
-      </thead>
-      <% @backtrace.each do |lines, hash, file, lineno, meth| %>
-        <tr id="line_<%= hash %>" onclick="toggle('source_<%= hash %>'); return false"; class="clickable" style="background:rgb(250,250,<%= @colors.shift %>);">
-          <td class="method"><%= meth %></td>          
-          <td class="line"><%= lineno %></td>
-          <td class="file"><%= file %></td>          
-        </tr>
-        <tr id="source_<%= hash %>" <%= @coderay? " class='CodeRay' " : ''%> style="display:none;">
-          <td colspan="3">
-            <div class="source">
-              <table>
-                <tr><td colspan='2'><a href='txmt://open?url=file://<%=file%>&line=<%=lineno%>'>Open in TextMate</a></td></tr>
-                <% lines.each do |llineno, lcode, lcurrent| %>
-                  <tr class="source"<%=  'style="background:#faa;"' if lcurrent %>>
-                    <td><%= llineno %></td>
-                    <td>
-                      <%= @coderay ? CodeRay.scan(lcode, :ruby).html : "<pre>\#{lcode}</pre>" %>
-                    </td>
-                  </tr>
-                <% end %>
-              </table>
-            </div>
-          </td>
-        </tr>
-      <% end %>
-    </table>
-  </body>
-</html>
-        HEREDOC
-      tmpl = Erubis::MEruby.new template
-      tmpl.result(binding)
-    end
-  end
-  
-end  

data/lib/merb/merb_part_controller.rb

@@ -1,42 +0,0 @@
-module Merb
-  class PartController < AbstractController
-    self._template_root = File.expand_path(DIST_ROOT / "app/parts/views")
-    
-    def initialize(web_controller)
-      @_benchmarks = {}
-      @web_controller = web_controller
-    end
-
-    def dispatch(action=:to_s)
-      old_action = params[:action]
-      params[:action] = action
-      super(action)
-      params[:action] = old_action
-      @_body
-    end
-    
-    def request
-       @web_controller.request  
-    end
-            
-    def params
-      @web_controller.params
-    end  
-    
-    def cookies
-      @web_controller.cookies
-    end  
-
-    def headers
-      @web_controller.headers
-    end
-    
-    def session
-      @web_controller.session
-    end
-
-    def response
-      @web_controller.response
-    end
-  end
-end    

data/lib/merb/merb_plugins.rb

@@ -1,293 +0,0 @@
-# TODO: Find Merb app root so we aren't wantonly copying Rakefiles
-# TODO: Figure out a good way to handle the lack of install/uninstall script
-# TODO: Minimum versions for local gems in install
-
-require 'yaml'
-require 'rubygems'
-
-module Merb
-  class PluginManager
-    
-    def self.gem_name
-      @@gem_name
-    end
-    
-    def self.gem_spec
-      @@gem_spec
-    end
-    
-    def self.options
-      @@options
-    end
-    
-    def self.gem_name=(val)
-      @@gem_name = val
-    end
-    
-    def self.gem_spec=(val)
-      @@gem_spec = val
-    end
-    
-    def self.options=(val)
-      @@options = val
-    end
-
-
-    # Run a particular plugin action
-    def self.action(action, gem_name = nil, opts = [])
-      @@gem_name = gem_name
-      @@options = opts.flatten
-      
-      case action
-        when 'install':
-          install
-        when 'uninstall':
-          uninstall
-        when 'remove':
-          remove_from_manifest
-        when 'list':
-          list
-        when 'help'
-          help
-        when 'migrate'
-          migrate
-        when 'update'
-          raise "This hasn't been implemented yet!"
-        when 'upgrade'
-          raise "This hasn't been implemented yet!"
-        else
-          raise "Invalid action: #{action}"
-      end
-    end
-    
-    # Install a new plugin named +gem_name+.
-    def self.install
-      raise "Plugin already installed!" if plugin_installed?
-      
-      self.gem_spec = find_locally or install_gem 
-      
-      run_install_script
-      copy_rakefile
-      add_to_manifest
-    rescue Exception => e
-      puts "\n!!! Plugin installation FAILED: #{e.message}\n\n"
-    end
-    
-    # Check the manifest to see if the plugin is already installed in this application.
-    def self.plugin_installed?
-      with_manifest do |manifest|
-        return manifest.has_key?(gem_name)
-      end
-    rescue
-      false
-    end
-    
-    # Search the local Rubygems installation for the gem.
-    def self.find_locally
-      all_installed_gems = Gem::SourceIndex.from_installed_gems
-      latest_gem_version = all_installed_gems.search(gem_name).sort_by {|x| x.version.version }.last
-      require 'pp'
-
-      if latest_gem_version
-        puts "Local gem found."
-        return latest_gem_version
-      else
-        puts "Can't find gem...installing."
-        return false
-      end
-    end
-    
-    # Run the installation code in the gem.
-    def self.run_install_script
-      require "#{gem_name}/install"
-    end
-    
-    # Copy the Rakefile from the gem to a directory in our application.
-    def self.copy_rakefile
-      path = gem_spec.loaded_from.split(/specifications/)[0] + "gems/#{gem_name}-#{gem_spec.version.version}/"
-      
-      merb_rake_file = path + "Rakefile.merb"
-      
-      require 'fileutils'
-      Dir.mkdir 'plugins' if !File.exists?('plugins/')
-      FileUtils.cp merb_rake_file, "plugins/#{gem_name}.rake"
-      
-      File.open('Rakefile', 'a') do |rakefile|
-        rakefile.write("\nrequire 'plugins/#{gem_name}.rake\n")
-      end
-    end
-    
-    def self.remove_rakefile
-      FileUtils.rm "plugins/#{gem_name}.rake"
-      
-      File.open('Rakefile', 'r+') do |rakefile|
-        contents = rakefile.read
-        contents.gsub!("\nrequire 'plugins/#{gem_name}.rake\n", "")
-        
-        rakefile.pos = 0
-        rakefile.write contents
-        rakefile.truncate rakefile.pos
-      end
-    end
-    
-    # Do a gem installation since it wasn't found in the locally installed gems.
-    def self.install_gem
-      require 'rubygems/installer'
-      
-      options = {
-          :domain => :both, 
-          :generate_rdoc => true,
-          :generate_ri   => true,
-          :force => false, 
-          :test => false, 
-          :wrappers => true,
-          :version => "> 0",
-          :install_dir => Gem.dir,
-          :security_policy => nil }
-          
-      
-          
-      puts "Attempting local install..."
-      local_install = Gem::Installer.new(gem_name, options).install(options[:force], options[:install_dir]) rescue false
-      
-      if !local_install
-        # Do remote installation
-        require 'rubygems/remote_installer'     
-        
-        Gem.configuration = ConfigStub.new
-        
-        puts "Attempting remote installation..."
-        installer = Gem::RemoteInstaller.new(options)
-        
-        @@options.each do |opt|
-          installer.sources << opt.gsub(/source=/, '') if opt.scan(/^source=/) != []
-          options[:version] = "> #{opt.gsub(/version=/, '')}" if opt.scan(/^version=/) != []
-        end
-        
-        remote_install = installer.install(gem_name, options[:version], options[:force], options[:install_dir]) rescue false
-      end
-      
-      if !remote_install && !local_install
-        raise "That plugin can't be found in locally or in a remote repository."
-      else
-        find_locally
-      end
-    end
-    
-    # Method to open and load our manifest; yields the manifest data to whatever method calls it.
-    def self.with_manifest
-      File.open('plugins.manifest', 'r+') do |manifest_file|
-        manifest_data = YAML::load(manifest_file.read)
-        manifest_data = {} if !manifest_data.is_a?(Hash)
-
-        yield manifest_data
-        
-        manifest_file.pos = 0
-        manifest_file.write manifest_data.to_yaml
-        manifest_file.truncate manifest_file.pos
-      end
-    end
-    
-    # Write our newly installed plugin to the application's manifest.
-    def self.add_to_manifest
-      with_manifest do |manifest_data|
-        manifest_data[gem_name] = {'version' => gem_spec.version.version}
-      end
-    end
-    
-    def self.uninstall
-      raise "That plugin isn't installed!" if !plugin_installed?
-      
-      require "#{gem_name}/uninstall" rescue nil
-      
-      remove_rakefile
-      remove_from_manifest
-      uninstall_gem
-    end
-    
-    def self.remove_from_manifest
-      with_manifest do |manifest|
-        manifest.delete(gem_name)
-      end
-    end
-    
-    def self.uninstall_gem
-      require 'rubygems/installer'
-      require 'rubygems/doc_manager'
-      
-      options = {
-          :domain => :both, 
-          :generate_rdoc => true,
-          :generate_ri   => true,
-          :force => false, 
-          :test => false, 
-          :wrappers => true,
-          :version => "> 0",
-          :install_dir => Gem.dir,
-          :security_policy => nil }
-          
-      Gem::Uninstaller.new(gem_name, options).uninstall
-    end
-    
-    def self.list
-      with_manifest do |manifest_data|
-        manifest_data.each do |key, value|
-          gem_name = key
-          gem_spec = find_locally
-          puts "#{key} (#{gem_spec.version.version})"
-          puts "\t#{gem_spec.description}\n"
-        end
-      end
-    end
-    
-    def self.migrate
-      raise "This hasn't been implemented yet!"
-    end
-    
-    def self.help
-      puts """
-Merb Plugins
-The -P (--plugin) option fed to Merb allows you to manage plugins.
-
-Commands
---------
-install     Installs a new plugin.
-uninstall   Uninstalls a plugin, removing its entry from the manifest and uninstalling the gem.
-remove      Uninstalls a plugin, removing its entry from the manifest but leaving the gem installed.
-list        Lists all installed plugins for this Merb application.
-upgrade     Upgrades a plugin to the specified version.
-update      Updates a plugin to the latest available version.
-migrate     Reads the manifest for this application, installing and updating gems as needed.
-help        Shows this help message.
-
-"""
-    end
-  end
-  
-  # Class to stub out the verbose flag in Rubygems user interaction lib
-  class ConfigStub
-    attr_accessor :verbose
-    
-    def initialize
-      @verbose = false
-    end
-  end
-end
-
-module Gem
-  # Fixes a bug in RubyGems where the SilentProgressReporter class is
-  # inaccurately named SilentReporter. Maybe one day we'll monkeypatch this for
-  # our own purposes.
-  class SilentProgressReporter
-    attr_reader :count
-
-    def initialize(out_stream, size, initial_message)
-    end
-
-    def updated(message)
-    end
-
-    def done
-    end
-  end
-end