merb-core 0.9.7 → 0.9.8

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

@@ -0,0 +1,267 @@
+require 'rubygems'
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+require 'rubygems/dependency'
+
+module ColorfulMessages
+  
+  # red
+  def error(*messages)
+    puts messages.map { |msg| "\033[1;31m#{msg}\033[0m" }
+  end
+  
+  # yellow
+  def warning(*messages)
+    puts messages.map { |msg| "\033[1;33m#{msg}\033[0m" }
+  end
+  
+  # green
+  def success(*messages)
+    puts messages.map { |msg| "\033[1;32m#{msg}\033[0m" }
+  end
+  
+  alias_method :message, :success
+  
+end
+
+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 = {})
+    refresh = options.delete(:refresh) || []
+    from_cache = (options.key?(:cache) && options.delete(:cache))
+    if from_cache
+      install_gem_from_cache(gem, options)
+    else
+      version = options.delete(:version)
+      Gem.configuration.update_sources = false
+
+      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?
+        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)
+        end
+      end
+      
+      exception = nil
+      begin
+        installer.install gem, version
+      rescue Gem::InstallError => e
+        exception = e
+      rescue Gem::GemNotFoundException => e
+        if from_cache && gem_file = find_gem_in_cache(gem, version)
+          puts "Located #{gem} in gem cache..."
+          installer.install gem_file
+        else
+          exception = e
+        end
+      rescue => e
+        exception = e
+      end
+      if installer.installed_gems.empty? && exception
+        error "Failed to install gem '#{gem} (#{version})' (#{exception.message})"
+      end
+      installer.installed_gems.each do |spec|
+        success "Successfully installed #{spec.full_name}"
+      end
+      return !installer.installed_gems.empty?
+    end
+  end
+
+  # Install a gem - looks in the system's gem cache instead of remotely;
+  # won't process rdoc or ri options.
+  def install_gem_from_cache(gem, options = {})
+    version = options.delete(:version)
+    Gem.configuration.update_sources = false
+    installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
+    exception = nil
+    begin
+      if gem_file = find_gem_in_cache(gem, version)
+        puts "Located #{gem} in gem cache..."
+        installer.install gem_file
+      else
+        raise Gem::InstallError, "Unknown gem #{gem}"
+      end
+    rescue Gem::InstallError => e
+      exception = e
+    end
+    if installer.installed_gems.empty? && exception
+      error "Failed to install gem '#{gem}' (#{e.message})"
+    end
+    installer.installed_gems.each do |spec|
+      success "Successfully installed #{spec.full_name}"
+    end
+  end
+
+  # Install a gem from source - builds and packages it first then installs.
+  def install_gem_from_src(gem_src_dir, options = {})
+    if !File.directory?(gem_src_dir)
+      raise "Missing rubygem source path: #{gem_src_dir}"
+    end
+    if options[:install_dir] && !File.directory?(options[:install_dir])
+      raise "Missing rubygems path: #{options[:install_dir]}"
+    end
+
+    gem_name = File.basename(gem_src_dir)
+    gem_pkg_dir = File.expand_path(File.join(gem_src_dir, 'pkg'))
+
+    # We need to use local bin executables if available.
+    thor = "#{Gem.ruby} -S #{which('thor')}"
+    rake = "#{Gem.ruby} -S #{which('rake')}"
+
+    # Handle pure Thor installation instead of Rake
+    if File.exists?(File.join(gem_src_dir, 'Thorfile'))
+      # Remove any existing packages.
+      FileUtils.rm_rf(gem_pkg_dir) if File.directory?(gem_pkg_dir)
+      # Create the package.
+      FileUtils.cd(gem_src_dir) { system("#{thor} :package") }
+      # Install the package using rubygems.
+      if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
+        FileUtils.cd(File.dirname(package)) do
+          install_gem(File.basename(package), options.dup)
+          return true
+        end
+      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)          
+        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
+          end
+          return true
+        end
+      end
+    end
+    raise Gem::InstallError, "No Rakefile found for #{gem_name}"
+  end
+
+  # Uninstall a gem.
+  def uninstall_gem(gem, options = {})
+    if options[:version] && !options[:version].is_a?(Gem::Requirement)
+      options[:version] = Gem::Requirement.new ["= #{options[:version]}"]
+    end
+    update_source_index(options[:install_dir]) if options[:install_dir]
+    Gem::Uninstaller.new(gem, options).uninstall
+  end
+
+  # Use the local bin/* executables if available.
+  def which(executable)
+    if File.executable?(exec = File.join(Dir.pwd, 'bin', executable))
+      exec
+    else
+      executable
+    end
+  end
+  
+  # Create a modified executable wrapper in the specified bin directory.
+  def ensure_bin_wrapper_for(gem_dir, bin_dir, *gems)
+    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)
+          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))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def executable_wrapper(spec, bin_file_name)
+    <<-TEXT
+#!/usr/bin/env ruby
+#
+# This file was generated by Merb's GemManagement
+#
+# The application '#{spec.name}' is installed as part of a gem, and
+# this file is here to facilitate running it.
+
+begin 
+  require 'minigems'
+rescue LoadError 
+  require 'rubygems'
+end
+
+if File.directory?(gems_dir = File.join(Dir.pwd, 'gems')) ||
+   File.directory?(gems_dir = File.join(File.dirname(__FILE__), '..', 'gems'))
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(gems_dir)
+end
+
+version = "#{Gem::Requirement.default}"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '#{spec.name}', version
+load '#{bin_file_name}'
+TEXT
+  end
+
+  def find_gem_in_cache(gem, version)
+    spec = if version
+      version = Gem::Requirement.new ["= #{version}"] unless version.is_a?(Gem::Requirement)
+      Gem.source_index.find_name(gem, version).first
+    else
+      Gem.source_index.find_name(gem).sort_by { |g| g.version }.last
+    end
+    if spec && File.exists?(gem_file = "#{spec.installation_path}/cache/#{spec.full_name}.gem")
+      gem_file
+    end
+  end
+
+  def update_source_index(dir)
+    Gem.source_index.load_gems_in(File.join(dir, 'specifications'))
+  end
+  
+end

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

@@ -1 +1,2 @@
+require 'merb-core/tasks/merb_rake_helper'
 Dir[File.dirname(__FILE__) / '*.rake'].each { |ext| load ext }

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

@@ -1,37 +1,51 @@
-def sudo
-  ENV['MERB_SUDO'] ||= "sudo"
-  sudo = windows? ? "" : ENV['MERB_SUDO']
-end
+require File.join(File.dirname(__FILE__), 'gem_management')
 
-def windows?
-  (PLATFORM =~ /win32|cygwin/) rescue nil
-end
+module Merb
+  module RakeHelper
+    
+    extend GemManagement
+    
+    def self.install(name, options = {})
+      defaults = { :cache => false }
+      defaults[:install_dir] = ENV['GEM_DIR'] if ENV['GEM_DIR']
+      opts = defaults.merge(options)
+      install_gem_from_src(Dir.pwd, opts)
+      ensure_wrapper(opts[:install_dir] || Gem.default_dir, name)
+    end
+    
+    def self.install_package(pkg, options = {})
+      defaults = { :cache => false }
+      defaults[:install_dir] = ENV['GEM_DIR'] if ENV['GEM_DIR']
+      opts = defaults.merge(options)
+      install_gem(pkg, opts)
+      name = File.basename(pkg, '.gem')[/^(.*?)-([\d\.]+)$/, 1]
+      ensure_wrapper(opts[:install_dir] || Gem.default_dir, name)
+    end
+    
+    def self.uninstall(name, options = {})
+      defaults = { :ignore => true, :executables => true }
+      defaults[:install_dir] = ENV['GEM_DIR'] if ENV['GEM_DIR']
+      uninstall_gem(name, defaults.merge(options))
+    end
+    
+    def self.sudo
+      ENV['MERB_SUDO'] ||= "sudo"
+      sudo = windows? ? "" : ENV['MERB_SUDO']
+    end
 
-def install_home
-  ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
-end
-
-def install_command(gem_name, gem_version, options = '--no-update-sources --no-rdoc --no-ri')
-  options << " -i #{ENV['GEM_DIR']}" if ENV['GEM_DIR']
-  %{#{sudo} gem install #{install_home} --local pkg/#{gem_name}-#{gem_version}.gem #{options}}
-end
-
-def dev_install_command(gem_name, gem_version, options = '--no-update-sources --no-rdoc --no-ri')
-  options << ' --development'
-  install_command(gem_name, gem_version, options)
-end
-
-def jinstall_command(gem_name, gem_version, options = '--no-update-sources --no-rdoc --no-ri')
-  options << " -i #{ENV['GEM_DIR']}" if ENV['GEM_DIR']
-  %{#{sudo} jruby -S gem install #{install_home} --local pkg/#{gem_name}-#{gem_version}.gem #{options}}
-end
-
-def dev_jinstall_command(gem_name, gem_version, options = '--no-update-sources --no-rdoc --no-ri')
-  options << ' --development'
-  jinstall_command(gem_name, gem_version, options)
-end
-
-def uninstall_command(gem_name, options = '')
-  options << " -i #{ENV['GEM_DIR']}" if ENV['GEM_DIR']
-  %{#{sudo} gem uninstall #{gem_name} #{options}}
+    def self.windows?
+      (PLATFORM =~ /win32|cygwin/) rescue nil
+    end
+    
+    protected
+    
+    def self.ensure_wrapper(gemdir, name)
+      # See if there's a local bin dir - one directory up from ./gems
+      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)
+    end
+    
+  end
 end

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

@@ -39,7 +39,7 @@ task :stats do
     :models       => 'app/models',
     :lib          => 'lib',
     :spec         => 'spec'
-  }
+  }.reject {|name, dir| !File.exist?(dir) }
   EMPTY_STATS = { :lines => 0, :loc => 0, :classes => 0, :modules => 0, :methods => 0 }
  
   @all = {}

data/lib/merb-core/test.rb

@@ -1,6 +1,9 @@
-require "hpricot"
+begin
+  require "hpricot"
+  require 'merb-core/test/test_ext/hpricot'
+rescue
+end
 
-require 'merb-core/test/test_ext/hpricot'
 require 'merb-core/test/test_ext/object'
 require 'merb-core/test/test_ext/string'
 
@@ -8,4 +11,7 @@ module Merb; module Test; end; end
 
 require 'merb-core/test/helpers'
 
-require 'merb-core/test/matchers'
+if Merb.test_framework.to_s == "rspec"
+  require 'merb-core/test/test_ext/rspec'
+  require 'merb-core/test/matchers'
+end

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

@@ -2,6 +2,7 @@
 # testing helpers
 module Merb::Test::Helpers; end
 
+require "merb-core/test/helpers/mock_request_helper"
 require "merb-core/test/helpers/request_helper"
 require "merb-core/test/helpers/multipart_request_helper"
 require "merb-core/test/helpers/controller_helper"

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

@@ -0,0 +1,393 @@
+require 'tempfile'
+
+module Merb
+  module Test
+    module RequestHelper
+      # FakeRequest sets up a default enviroment which can be overridden either
+      # by passing and env into initialize or using request['HTTP_VAR'] = 'foo'
+      class FakeRequest < Request
+
+        # ==== Parameters
+        # env<Hash>:: Environment options that override the defaults.
+        # req<StringIO>:: The request to set as input for Rack.
+        def initialize(env = {}, req = StringIO.new)
+          env.environmentize_keys!
+          env['rack.input'] = req
+          super(DEFAULT_ENV.merge(env))
+        end
+
+        private
+        DEFAULT_ENV = Mash.new({
+          'SERVER_NAME' => 'localhost',
+          'PATH_INFO' => '/',
+          'HTTP_ACCEPT_ENCODING' => 'gzip,deflate',
+          'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.8.0.1) Gecko/20060214 Camino/1.0',
+          'SCRIPT_NAME' => '/',
+          'SERVER_PROTOCOL' => 'HTTP/1.1',
+          'HTTP_CACHE_CONTROL' => 'max-age=0',
+          'HTTP_ACCEPT_LANGUAGE' => 'en,ja;q=0.9,fr;q=0.9,de;q=0.8,es;q=0.7,it;q=0.7,nl;q=0.6,sv;q=0.5,nb;q=0.5,da;q=0.4,fi;q=0.3,pt;q=0.3,zh-Hans;q=0.2,zh-Hant;q=0.1,ko;q=0.1',
+          'HTTP_HOST' => 'localhost',
+          'REMOTE_ADDR' => '127.0.0.1',
+          'SERVER_SOFTWARE' => 'Mongrel 1.1',
+          'HTTP_KEEP_ALIVE' => '300',
+          'HTTP_REFERER' => 'http://localhost/',
+          'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+          'HTTP_VERSION' => 'HTTP/1.1',
+          'REQUEST_URI' => '/',
+          'SERVER_PORT' => '80',
+          'GATEWAY_INTERFACE' => 'CGI/1.2',
+          'HTTP_ACCEPT' => 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
+          'HTTP_CONNECTION' => 'keep-alive',
+          'REQUEST_METHOD' => 'GET'
+        }) unless defined?(DEFAULT_ENV)
+      end
+
+      # CookieJar keeps track of cookies in a simple Mash.
+      class CookieJar < Mash
+        
+        # ==== Parameters
+        # request<Merb::Request, Merb::FakeRequest>:: The controller request.
+        def update_from_request(request)
+          request.cookies.each do |key, value|
+            if value.blank?
+              self.delete(key)
+            else
+              self[key] = Merb::Request.unescape(value)
+            end
+          end
+        end
+        
+      end
+
+      # ==== Parameters
+      # env<Hash>:: A hash of environment keys to be merged into the default list.
+      # opt<Hash>:: A hash of options (see below).
+      #
+      # ==== Options (opt)
+      # :post_body<String>:: The post body for the request.
+      # :req<String>::
+      #   The request string. This will only be used if :post_body is left out.
+      #
+      # ==== Returns
+      # FakeRequest:: A Request object that is built based on the parameters.
+      #
+      # ==== Notes
+      # If you pass a post body, the content-type will be set to URL-encoded.
+      #
+      #---
+      # @public
+      def fake_request(env = {}, opt = {})
+        if opt[:post_body]
+          req = opt[:post_body]
+          env[:content_type] ||= "application/x-www-form-urlencoded"
+        else
+          req = opt[:req]
+        end
+        FakeRequest.new(env, StringIO.new(req || ''))
+      end
+
+      # Dispatches an action to the given class. This bypasses the router and is
+      # suitable for unit testing of controllers.
+      #
+      # ==== Parameters
+      # controller_klass<Controller>::
+      #   The controller class object that the action should be dispatched to.
+      # action<Symbol>:: The action name, as a symbol.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+), including :req or :post_body
+      #   for setting the request body itself.
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Example
+      #   dispatch_to(MyController, :create, :name => 'Homer' ) do |controller|
+      #     controller.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      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)
+      end
+      
+      # Keep track of cookie values in CookieJar within the context of the
+      # block; you need to set this up for secific controllers.
+      #
+      # ==== 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.
+      def with_cookies(*controller_classes, &blk)
+        cookie_jar = CookieJar.new
+        before_cb = lambda { |c| c.cookies.update(cookie_jar) }
+        after_cb  = lambda { |c| cookie_jar.update_from_request(c.request) }
+        controller_classes.each do |klass|
+          klass._before_dispatch_callbacks << before_cb
+          klass._after_dispatch_callbacks  << after_cb
+        end
+        blk.arity == 1 ? blk.call(cookie_jar) : blk.call
+        controller_classes.each do |klass|
+          klass._before_dispatch_callbacks.delete before_cb
+          klass._after_dispatch_callbacks.delete after_cb
+        end
+      end
+
+      # Dispatches an action to the given class and using HTTP Basic Authentication
+      # This bypasses the router and is suitable for unit testing of controllers.
+      #
+      # ==== Parameters
+      # controller_klass<Controller>::
+      #   The controller class object that the action should be dispatched to.
+      # action<Symbol>:: The action name, as a symbol.
+      # username<String>:: The username.
+      # password<String>:: The password.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+), including :req or :post_body
+      #   for setting the request body itself.
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Example
+      #   dispatch_with_basic_authentication_to(MyController, :create, 'Fred', 'secret', :name => 'Homer' ) do |controller|
+      #     controller.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      def dispatch_with_basic_authentication_to(controller_klass, action, username, password, params = {}, env = {}, &blk)
+        env["X_HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64("#{username}:#{password}")}"
+        
+        params = merge_controller_and_action(controller_klass, action, params)        
+        dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
+      end
+      
+      def merge_controller_and_action(controller_klass, action, params)
+        params[:controller] = controller_klass.name.to_const_path
+        params[:action]     = action.to_s
+        
+        params
+      end
+
+      # Prepares and returns a request suitable for dispatching with
+      # dispatch_request. If you don't need to modify the request
+      # object before dispatching (e.g. to add cookies), you probably
+      # want to use dispatch_to instead.
+      #
+      # ==== Parameters
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+), including :req or :post_body
+      #   for setting the request body itself.
+      #
+      # ==== Example
+      #   req = build_request(:id => 1)
+      #   req.cookies['app_cookie'] = "testing"
+      #   dispatch_request(req, MyController, :edit)
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public      
+      def build_request(params = {}, env = {})
+        params             = Merb::Request.params_to_query_string(params)
+
+        query_string = env[:query_string] || env['QUERY_STRING']
+        env[:query_string] = query_string ? "#{query_string}&#{params}" : params
+        
+        post_body = env[:post_body] || env['POST_BODY']
+        fake_request(env, { :post_body => post_body, :req => env[:req] })
+      end
+
+      # An HTTP GET request that operates through the router.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public      
+      def get(path, params = {}, env = {}, &block)
+        env[:request_method] = "GET"
+        mock_request(path, params, env, &block)
+      end
+
+      # An HTTP POST request that operates through the router.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see fake_request).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public      
+      def post(path, params = {}, env = {}, &block)
+        env[:request_method] = "POST"
+        mock_request(path, params, env, &block)
+      end
+
+      # An HTTP PUT request that operates through the router.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see fake_request).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public      
+      def put(path, params = {}, env = {}, &block)
+        env[:request_method] = "PUT"
+        mock_request(path, params, env, &block)
+      end
+
+      # An HTTP DELETE request that operates through the router
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see fake_request).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #---
+      # @public
+      def delete(path, params = {}, env = {}, &block)
+        env[:request_method] = "DELETE"
+        mock_request(path, params, env, &block)
+      end
+
+      # A generic request that checks the router for the controller and action.
+      # This request goes through the Merb::Router and finishes at the controller.
+      #
+      # ==== Parameters
+      # path<String>:: The path that should go to the router as the request uri.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+).
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Example
+      #   request(path, { :name => 'Homer' }, { :request_method => "PUT" }) do |controller|
+      #     controller.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Uses Routes.
+      #
+      #---
+      # @semi-public
+      def mock_request(path, params = {}, env= {}, &block)
+        env[:request_method] ||= "GET"
+        env[:request_uri], env[:query_string] = path.split('?')
+        
+        multipart = env.delete(:test_with_multipart)
+
+        request = build_request(params, env)
+
+        opts = check_request_for_route(request) # Check that the request will be routed correctly
+        controller_name = (opts[:namespace] ? opts.delete(:namespace) + '/' : '') + opts.delete(:controller)
+        klass = Object.full_const_get(controller_name.snake_case.to_const_string)
+        
+        action = opts.delete(:action).to_s
+        params.merge!(opts)
+
+        multipart.nil? ? dispatch_to(klass, action, params, env, &block) : dispatch_multipart_to(klass, action, params, env, &block)
+      end
+
+
+      # The workhorse for the dispatch*to helpers.
+      #
+      # ==== Parameters
+      # request<Merb::Test::RequestHelper::FakeRequest, Merb::Request>::
+      #   A request object that has been setup for testing.
+      # controller_klass<Merb::Controller>::
+      #   The class object off the controller to dispatch the action to.
+      # action<Symbol>:: The action to dispatch the request to.
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Returns
+      # An instance of +controller_klass+ based on the parameters.
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      def dispatch_request(request, controller_klass, action, &blk)
+        controller = controller_klass.new(request)
+        yield controller if block_given?
+        controller._dispatch(action)
+
+        Merb.logger.info controller._benchmarks.inspect
+        Merb.logger.flush
+
+        controller
+      end
+
+      # Checks to see that a request is routable.
+      #
+      # ==== Parameters
+      # request<Merb::Test::RequestHelper::FakeRequest, Merb::Request>::
+      #   The request object to inspect.
+      #
+      # ==== Raises
+      # Merb::ControllerExceptions::BadRequest::
+      #   No matching route was found.
+      #
+      # ==== Returns
+      # Hash:: The parameters built based on the matching route.
+      #
+      #---
+      # @semi-public
+      def check_request_for_route(request)
+        match =  ::Merb::Router.match(request)
+        if match[0].nil? && match[1].empty?
+          raise ::Merb::ControllerExceptions::BadRequest, "No routes match the request. Request uri: #{request.uri}"
+        else
+          match[1]
+        end
+      end # check_request_for_route
+    end # RequestHelper
+  end # Test
+end # Merb