thorero-mailer 0.9.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,282 @@
+h2. Overview.
+
+A plugin for the Merb framework that allows you to send email from Merb application.
+It separates email composition and sending into micro MVC: you may have mail controllers
+that compose complex emails, emails have their own views and models (models use MailFactory
+library and non-persistable).
+
+
+h2. Installation.
+
+(sudo) gem install merb-mailer
+
+It will install "mailfactory":http://mailfactory.rubyforge.org/ gem and "mime-types":http://mime-types.rubyforge.org/ that mailfactory depends on.
+
+
+h2. Configuration.
+
+In init.rb, include a dependency on 'merb-mailer'.With versions of Merb earlier than 0.9.3 Merb::Mailer may raise a NameError when configuration is put into
+after_app_loads block. Put it to the very end of your init file and it should work. This problem does not exist in Git HEAD.
+
+
+h3. Using SMTP.
+
+<pre><code class="ruby">
+  Merb::Mailer.config = {
+    :host   => 'smtp.yourserver.com',
+    :port   => '25',
+    :user   => 'user',
+    :pass   => 'pass',
+    :auth   => :plain # :plain, :login, :cram_md5, the default is no auth
+    :domain => "localhost.localdomain" # the HELO domain provided by the client to the server
+  }
+</code></pre>  
+
+  
+h3. Using Gmail SMTP.
+
+Configuration example for Gmail SMTP:
+
+<pre><code class="ruby">
+Merb::Mailer.config = {
+  :host   => 'smtp.gmail.com',
+  :port   => '587',
+  :user   => 'user@gmail.com',
+  :pass   => 'pass',
+  :auth   => :plain
+}
+</code></pre>  
+
+* require "smtp_tls":http://www.rubyinside.com/how-to-use-gmails-smtp-server-with-rails-394.html
+* Use :text option instead of :body when deliver.
+
+<pre><code class="ruby">
+m = Merb::Mailer.new :to      => 'foo@bar.com',
+                     :from    => 'bar@foo.com',
+                     :subject => 'Welcome to whatever!',
+                     :text    => partial(:sometemplate)
+m.deliver!
+</code></pre>
+
+h3. Using Sendmail.
+
+  Merb::Mailer.config = {:sendmail_path => '/somewhere/odd'}
+  Merb::Mailer.delivery_method = :sendmail
+
+
+
+h2. Sending mail from controllers.
+
+Merb mailer plugin has idea of separation of mailer logic from mailer templates
+to the point mailers in Merb have own tiny MVC architecture for emails.
+Your application controllers usually delegate email sending to mail controllers
+instead of doing it on their own.
+
+To send your mail using mail controller you use send_mail method that
+takes mail controller class, action name, mail parameters and action parameters.
+params hash with action parameters mentioned above is accessible in mail controller's
+action.
+
+<pre>
+<code class="ruby">
+def send_activation_email(person)
+	send_mail PeopleMailer, :activation, {
+		:from => "no-reply@example.com",
+		:to => person.email,
+		:subject => "Please activate your account"
+	}, {
+		:name => person.name
+	}
+end
+</code>
+</pre>
+
+Mail parameters you can specify:
+
+* :to
+* :from
+* :replyto
+* :subject
+* :body
+* :cc
+
+
+Example of Merb controller:
+<pre>
+<code class="ruby">
+class ProductDeliveryMailer < Merb::MailController
+  def notify_on_delivery
+	  @delivery_info = params[:details]
+		# you can access @delivery_info in rendered template
+    render_mail
+  end  
+end
+</code>
+</pre>
+
+Mail templates are kept under app/views/mail controller name/template name just like with regular controllers.
+Content types in template name may be either text or html, like in
+app/mailers/views/user_mailer/hello.text.erb for the mailer controller above:
+
+<pre>
+Hello <%= params[:name] %>
+</pre>
+
+render_mail works similarly to render method. It takes either action as Symbol or Hash of
+template paths. Most of the times naming templates the same as your actions works so you
+can just use
+
+<pre>
+<code class="ruby">
+class ResourceShortageMailer < Merb::MailController
+  def notify_on_disk_space_shortage
+    render_mail
+  end  
+end
+</code>
+</pre>
+
+and it will render app/mailers/views/resource_shortage_mailer/notify_on_disk_space_shortage.text.erb.
+
+If you need to specify template path explicitly, you can do it for both text and html:
+
+<pre>
+<code class="ruby">
+class ResourceShortageMailer < Merb::MailController
+  def notify_on_disk_space_shortage
+    render_mail :action => { :html => :hdd_space_shortage_detailed, :text => :hdd_space_shortage }
+  end  
+end
+</code>
+</pre>
+
+This will look for app/mailers/views/resource_shortage_mailer/hdd_space_shortage_detailed.html.erb for
+html and app/mailers/views/resource_shortage_mailer/hdd_space_shortage.text.erb for text.
+
+See "render_mail documentation":http://merbivore.com/documentation/merb-more/0.9.3/merb-mailer/index.html?a=M000019&name=render_mail
+for more examples, this method has a lot of options how you can use it.
+
+
+
+h2. Using Merb mailer to send emails outside of controllers.
+
+There are two ways of sending email with merb-mailer: using mail controllers and using just Merb::Mailer.
+Here is example of using Merb::Mailer to deliver emails from model hook.
+
+class Person
+	include DataMapper::Resource
+
+	after :create, :deliver_activation_notification
+
+  protected
+  
+  def deliver_activation_notification
+	  body_string = <<-EOS
+		  Please activate your account...
+		EOS
+	
+	  Merb::Mailer.new(
+		  :from    => "no-reply@webapp.com",
+			:to      => self.email,
+			:subject => "Activate your account",
+			:body    => body_string
+		).deliver!
+  end
+end
+
+In this example we deliver signup activation email from model hook.
+Keep in mind that Merb::Mailer is a thin wrapper around MailFactory that
+provides several ways of sending emails. You can access plain text email body
+with text method of mailer and html body with html method, respectively.
+
+
+
+h2. Testing mailers.
+
+A word of warning: merb-mailer does not raise exceptions when your template is not found.
+So if nothing gets rendered, check merb test environment log to make sure you have no
+warnings. If it is considered a bug, file a ticket to LightHouse.
+
+Make sure you use test sending method so emails won't be sent on each tests run.
+Add this line to your test file:
+
+<pre>
+<code class="ruby">
+Merb::Mailer.delivery_method = :test_send
+</code>
+</pre>
+
+Here is an example of helper to test mailers themselves:
+<pre>
+<code class="ruby">
+def describe_mail(mailer, template, &block)
+  describe "/#{mailer.to_s.downcase}/#{template}" do
+    before :each do
+      @mailer_class, @template = mailer, template
+      @assigns = {}
+    end
+
+    def deliver(send_params={}, mail_params={})
+      mail_params = {:from => "from@example.com", :to => "to@example.com", :subject => "Please activate your account"}.merge(mail_params)
+      @mailer_class.new(send_params).dispatch_and_deliver @template.to_sym, mail_params
+      @mail = Merb::Mailer.deliveries.last
+    end
+
+    instance_eval &block
+  end
+end
+</code>
+</pre>
+
+Mailer controller specs may look like this then:
+<pre>
+<code class="ruby">
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe_mail UserMailer, :hello do
+  it "sends activation" do
+    deliver :name => "Jamie"
+    @mail.text.should == "Please activate your account, Jamie"
+  end
+end
+</code>
+</pre>
+
+Most of mail controller specs verify delivered email headers like
+to, subject or body. To access deliveries you use Merb::Mailer.deliveries
+array.
+
+It is recommended to clear it on test setup first:
+
+<pre>
+<code class="ruby">
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe_mail UserMailer, :hello do
+  before :each do
+    Merb::Mailer.deliveries.clear
+	end
+end
+</code>
+</pre>
+
+To do actual matching you can create a helper like this:
+
+<pre>
+<code class="ruby">
+def last_delivered_email
+  Merb::Mailer.deliveries.last
+end
+</code>
+</pre>
+
+and use it like this:
+
+<pre>
+<code class="ruby">
+last_delivered_email.from.first.should == "no-reply@webapp.com"
+</code>
+</pre>
+
+Note that MailFactory that is used by merb-mailer under the covers returns headers
+as Arrays. This is why we used from.first in example above.

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require "extlib"
+require 'merb-core/tasks/merb_rake_helper'
+require "spec/rake/spectask"
+
+##############################################################################
+# Package && release
+##############################################################################
+RUBY_FORGE_PROJECT  = "thorero"
+PROJECT_URL         = "http://merbivore.com"
+PROJECT_SUMMARY     = "Merb plugin that provides mailer functionality to Merb"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY
+
+GEM_AUTHOR = "Yehuda Katz"
+GEM_EMAIL  = "ykatz@engineyard.com"
+
+GEM_NAME    = "thorero-mailer"
+PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION = (Merb::MORE_VERSION rescue "0.9.4") + PKG_BUILD
+
+RELEASE_NAME    = "REL #{GEM_VERSION}"
+
+require "extlib/tasks/release"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.textile", "LICENSE", 'TODO']
+  s.summary = PROJECT_SUMMARY
+  s.description = PROJECT_DESCRIPTION
+  s.author = GEM_AUTHOR
+  s.email = GEM_EMAIL
+  s.homepage = PROJECT_URL
+  s.add_dependency('merb-core', '>= 0.9.4')
+  s.add_dependency('mailfactory', '>= 1.2.3')
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.textile Rakefile TODO) + Dir.glob("{lib,spec,merb_generators}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install the gem"
+task :install => [:package] do
+  sh %{#{sudo} gem install #{install_home} pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+namespace :jruby do
+
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{sudo} jruby -S gem install #{install_home} pkg/#{GEM_NAME}-#{GEM_VERSION}.gem --no-rdoc --no-ri}
+  end
+
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new("specs") do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir["spec/**/*_spec.rb"].sort
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb-mailer.rb
+Add your Merb rake tasks to lib/merb-mailer/merbtasks.rb

data/lib/merb-mailer.rb

@@ -0,0 +1,5 @@
+require "merb-mailer/mailer"
+require "merb-mailer/mail_controller"
+require "merb-mailer/mailer_mixin"
+
+Merb::Controller.send(:include, Merb::MailerMixin)

data/lib/merb-mailer/mail_controller.rb

@@ -0,0 +1,359 @@
+module Merb
+
+  # Sending mail from a controller involves three steps:
+  #
+  # * Set mail settings in merb_init.rb (Not shown here...see the Mailer docs).
+  # * Create a MailController subclass with actions and templates.
+  # * Call the MailController from another Controller via the send_mail method.
+  #
+  # First, create a file in app/mailers that subclasses Merb::MailController. 
+  # The actions in this controller will do nothing but render mail.
+  #
+  #   # app/mailers/article_mailer.rb
+  #   class ArticleMailer < Merb::MailController
+  # 
+  #     def notify
+  #       @user = params[:user]
+  #       render_mail
+  #     end
+  # 
+  #   end
+  #
+  # You also can access the params hash for values passed with the 
+  # Controller.send_mail method. See also the documentation for 
+  # render_mail to see all the ways it can be called.
+  #
+  # Create a template in a subdirectory of app/mailers/views that corresponds
+  # to the controller and action name. Put plain text and ERB tags here:
+  #
+  #   # app/mailers/views/article_mailer/notify.text.erb
+  #   Hey, <%= @user.name %>,
+  #   
+  #   We're running a sale on dog bones!
+  #
+  # Finally, call the Controller.send_mail method from a standard 
+  # Merb controller.
+  #
+  #   class Articles < Application
+  #
+  #     def index
+  #       @user = User.find_by_name('louie')
+  #
+  #       send_mail(ArticleMailer, :notify, {
+  #         :from => "me@example.com",
+  #         :to => "louie@example.com",
+  #         :subject => "Sale on Dog Bones!"
+  #       }, { :user => @user })
+  #       render
+  #     end
+  #
+  #   end  
+  #
+  # Note: If you don't pass a fourth argument to Controller.send_mail,
+  # the controller's params will be sent to the MailController subclass
+  # as params. However, you can explicitly send a hash of objects that 
+  # will populate the params hash instead. In either case, you must 
+  # set instance variables in the MailController's actions if you 
+  # want to use them in the MailController's views.
+  #
+  # The MailController class is very powerful. You can:
+  #
+  # * Send multipart email with a single call to render_mail.
+  # * Attach files.
+  # * Render layouts and other templates.
+  # * Use any template engine supported by Merb.
+
+  class MailController < AbstractController
+
+    class_inheritable_accessor :_mailer_klass
+    self._mailer_klass  = Merb::Mailer
+
+    attr_accessor :params, :mailer, :mail
+    attr_reader   :session, :base_controller
+
+    cattr_accessor :_subclasses
+    self._subclasses = Set.new
+
+    # ==== Returns
+    # Array[Class]:: Classes that inherit from Merb::MailController.
+    def self.subclasses_list() _subclasses end
+
+    # ==== Parameters
+    # action<~to_s>:: The name of the action that will be rendered.
+    # type<~to_s>::
+    #    The mime-type of the template that will be rendered. Defaults to nil.
+    # controller<~to_s>::
+    #   The name of the controller that will be rendered. Defaults to
+    #   controller_name.
+    #
+    # ==== Returns
+    # String:: The template location, i.e. ":controller/:action.:type".
+    def _template_location(action, type = nil, controller = controller_name)
+      "#{controller}/#{action}.#{type}"
+    end
+    
+    # The location to look for a template and mime-type. This is overridden 
+    # from AbstractController, which defines a version of this that does not 
+    # involve mime-types.
+    #
+    # ==== Parameters
+    # template<String>:: 
+    #    The absolute path to a template - without mime and template extension.
+    #    The mime-type extension is optional - it will be appended from the 
+    #    current content type if it hasn't been added already.
+    # type<~to_s>::
+    #    The mime-type of the template that will be rendered. Defaults to nil.
+    #
+    # @public
+    def _absolute_template_location(template, type)
+      template.match(/\.#{type.to_s.escape_regexp}$/) ? template : "#{template}.#{type}"
+    end
+
+    # ==== Parameters
+    # params<Hash>:: Configuration parameters for the MailController.
+    # controller<Merb::Controller>:: The base controller.
+    def initialize(params = {}, controller = nil)
+      @params = params
+      @base_controller = controller
+      @session = (controller && controller.session) || {}
+      super
+    end
+
+    # Sets the template root to the default mailer view directory.
+    #
+    # ==== Parameters
+    # klass<Class>::
+    #   The Merb::MailController inheriting from the base class.  
+    def self.inherited(klass)
+      super
+      klass._template_root = Merb.dir_for(:mailer) / "views" unless self._template_root
+    end
+
+    # Override filters halted to return nothing.
+    def filters_halted
+    end
+
+    # Allows you to render various types of things into the text and HTML parts
+    # of an email If you include just text, the email will be sent as
+    # plain-text. If you include HTML, the email will be sent as a multi-part
+    # email.
+    #
+    # ==== Parameters
+    # options<~to_s, Hash>::
+    #   Options for rendering the email or an action name. See examples below
+    #   for usage.
+    #
+    # ==== Examples
+    # There are a lot of ways to use render_mail, but it works similarly to the
+    # default Merb render method.
+    #
+    # First of all, you'll need to store email files in your
+    # app/mailers/views directory. They should be under a directory that
+    # matches the name of your mailer (e.g. TestMailer's views would be stored
+    # under test_mailer).
+    #
+    # The files themselves should be named action_name.mime_type.extension. For
+    # example, an erb template that should be the HTML part of the email, and
+    # rendered from the "foo" action would be named foo.html.erb.
+    #
+    # The only mime-types currently supported are "html" and "text", which
+    # correspond to text/html and text/plain respectively. All template systems
+    # supported by your app are available to MailController, and the extensions
+    # are the same as they are throughout the rest of Merb.
+    #
+    # render_mail can take any of the following option patterns:
+    #
+    #   render_mail
+    #
+    # will attempt to render the current action. If the current action is
+    # "foo", this is identical to render_mail :foo.
+    #
+    #   render_mail :foo
+    # 
+    # checks for foo.html.ext and foo.text.ext and applies them as appropriate.
+    #
+    #   render_mail :action => {:html => :foo, :text => :bar}
+    #
+    # checks for foo.html.ext and bar.text.ext in the view directory of the
+    # current controller and adds them to the mail object if found
+    #
+    #   render_mail :template => {:html => "foo/bar", :text => "foo/baz"}
+    #
+    # checks for bar.html.ext and baz.text.ext in the foo directory and adds
+    # them to the mail object if found.
+    #
+    #   render_mail :html => :foo, :text => :bar
+    #
+    # the same as render_mail :action => {html => :foo, :text => :bar }
+    #
+    #   render_mail :html => "FOO", :text => "BAR"
+    #
+    # adds the text "FOO" as the html part of the email and the text "BAR" as
+    # the text part of the email. The difference between the last two examples
+    # is that symbols represent actions to render, while string represent the
+    # literal text to render. Note that you can use regular render methods
+    # instead of literal strings here, like:
+    #
+    #   render_mail :html => render(:action => :foo)
+    #
+    # but you're probably better off just using render_mail :action at that
+    # point.
+    #
+    # You can also mix and match:
+    #
+    #   render_mail :action => {:html => :foo}, :text => "BAR"
+    #
+    # which would be identical to:
+    #
+    #   render_mail :html => :foo, :text => "BAR"
+    def render_mail(options = @method)
+      @_missing_templates = false # used to make sure that at least one template was found
+      # If the options are not a hash, normalize to an action hash
+      options = {:action => {:html => options, :text => options}} if !options.is_a?(Hash)
+  
+      # Take care of the options
+      opts_hash = {}
+      opts = options.dup
+      actions = opts.delete(:action) if opts[:action].is_a?(Hash)
+      templates = opts.delete(:template) if opts[:template].is_a?(Hash)
+  
+      # Prepare the options hash for each format
+      # We need to delete anything relating to the other format here
+      # before we try to render the template.
+      [:html, :text].each do |fmt|
+        opts_hash[fmt] = opts.delete(fmt)
+        opts_hash[fmt] ||= actions[fmt] if actions && actions[fmt]
+        opts_hash[:template] = templates[fmt] if templates && templates[fmt]
+      end
+        
+      # Send the result to the mailer
+      { :html => "rawhtml=", :text => "text="}.each do |fmt,meth|
+        begin
+          local_opts = opts.merge(:format => fmt)
+          local_opts.merge!(:layout => false) if opts_hash[fmt].is_a?(String)
+      
+          value = render opts_hash[fmt], local_opts
+          @mail.send(meth,value) unless value.nil? || value.empty?
+        rescue Merb::ControllerExceptions::TemplateNotFound => e
+          # An error should be logged if no template is found instead of an error raised
+          if @_missing_templates
+            Merb.logger.error(e)
+          else
+            @_missing_templates = true
+          end
+        end
+      end
+      @mail
+    end
+
+    # Mimic the behavior of absolute_url in AbstractController
+    # but use @base_controller.request
+    def absolute_url(name, rparams={})
+      req = @base_controller.request
+      uri =  req.protocol + req.host + url(name, rparams)
+    end
+
+    # Attaches a file or multiple files to an email. You call this from a
+    # method in your MailController (including a before filter).
+    # 
+    # ==== Parameters
+    # file_or_files<File, Array[File]>:: File(s) to attach.
+    # filename<String>::
+    # type<~to_s>::
+    #   The attachment MIME type. If left out, it will be determined from
+    #   file_or_files.
+    # headers<String, Array>:: Additional attachment headers.
+    #
+    # ==== Examples
+    #   attach File.open("foo")
+    #   attach [File.open("foo"), File.open("bar")]
+    # 
+    # If you are passing an array of files, you should use an array of the
+    # allowed parameters:
+    # 
+    #   attach [[File.open("foo"), "bar", "text/html"], [File.open("baz"),
+    #     "bat", "text/css"]
+    # 
+    #  which would attach two files ("foo" and "baz" in the filesystem) as
+    # "bar" and "bat" respectively. It would also set the mime-type as
+    # "text/html" and "text/css" respectively.
+    def attach( file_or_files, filename = file_or_files.is_a?(File) ? File.basename(file_or_files.path) : nil, 
+      type = nil, headers = nil)
+      @mailer.attach(file_or_files, filename, type, headers)
+    end
+
+    # ==== Parameters
+    # method<~to_s>:: The method name to dispatch to.
+    # mail_params<Hash>:: Parameters to send to MailFactory (see below).
+    #
+    # ==== Options (mail_params)
+    # MailFactory recognizes the following parameters:
+    # * :to
+    # * :from
+    # * :replyto
+    # * :subject
+    # * :body
+    # * :cc
+    #
+    # Other parameters passed in will be interpreted as email headers, with
+    # underscores converted to dashes.
+    def dispatch_and_deliver(method, mail_params)
+      @mailer         = self.class._mailer_klass.new(mail_params)
+      @mail           = @mailer.mail
+      @method         = method
+  
+      # dispatch and render use params[:action], so set it
+      self.action_name = method
+
+      body             = _dispatch method
+      if !@mail.html.blank? || !@mail.text.blank?
+        @mailer.deliver!
+        Merb.logger.info "#{method} sent to #{@mail.to} about #{@mail.subject}"
+      else
+        Merb.logger.info "#{method} was not sent because nothing was rendered for it"
+      end
+    end
+
+    # A convenience method that creates a blank copy of the MailController and
+    # runs dispatch_and_deliver on it.
+    #
+    # ==== Parameters
+    # method<~to_s>:: The method name to dispatch to.
+    # mail_params<Hash>:: Parameters to send to MailFactory.
+    # send_params<Hash>:: Configuration parameters for the MailController.
+    def self.dispatch_and_deliver(method, mail_params, send_params = {})
+      new(send_params).dispatch_and_deliver method, mail_params
+    end
+
+    protected
+
+    # ==== Returns
+    # Hash:: The route from base controller.
+    def route
+      @base_controller.route if @base_controller
+    end
+
+    private
+    # This method is here to overwrite the one in the general_controller mixin
+    # The method ensures that when a url is generated with a hash, it contains
+    # a controller.
+    #
+    # ==== Parameters
+    # opts<Hash>:: The options to get the controller from (see below).
+    #
+    # ==== Options (opts)
+    # :controller<Merb::Controller>:: The controller.
+    #
+    # ==== Returns
+    # Merb::Controller::
+    #   The controller. If no controller was specified in opts, attempt to find
+    #   it in the base controller params.
+    def get_controller_for_url_generation(opts)
+      controller = opts[:controller] || ( @base_controller.params[:controller] if @base_controller)
+      raise "No Controller Specified for url()" unless controller
+      controller
+    end
+
+
+  end
+end