merb 0.5.3 → 0.9.2

data/lib/merb/core_ext/symbol.rb

@@ -1,6 +0,0 @@
-class Symbol  
-  # ["foo", "bar"].map &:reverse #=> ['oof', 'rab']
-  def to_proc
-     Proc.new{|*args| args.shift.__send__(self, *args)}
-   end
-end

data/lib/merb/dispatcher.rb

@@ -1,109 +0,0 @@
-module Merb
-  class Dispatcher
-    
-    DEFAULT_ERROR_TEMPLATE = Erubis::MEruby.new((File.read(
-	File.join(Merb.root, 'app/views/exceptions/internal_server_error.html.erb')) rescue "Internal Server Error!"))
-        
-    class << self
-      
-      def use_mutex=(val)
-        @@use_mutex = val
-      end
-      
-      @@mutex = Mutex.new
-      @@use_mutex = ::Merb::Config[: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]
-      #
-      # ControllerExceptions are rescued here and redispatched.
-      # Exceptions still return [controller, action]
-      def handle(http_request, response)
-        start   = Time.now
-        request = Merb::Request.new(http_request)
-        Merb.logger.info("Params: #{request.params.inspect}")
-        Merb.logger.info("Cookies: #{request.cookies.inspect}")
-        # user friendly error messages
-        if request.route_params.empty?
-          raise ControllerExceptions::BadRequest, "No routes match the request"
-        elsif request.controller_name.nil?
-          raise ControllerExceptions::BadRequest, "Route matched, but route did not specify a controller" 
-        end
-        Merb.logger.debug("Routed to: #{request.route_params.inspect}")
-        # set controller class and the action to call
-        klass = request.controller_class
-        dispatch_action(klass, request.action, request, response)
-      rescue => exception
-        Merb.logger.error(Merb.exception(exception))
-        exception = controller_exception(exception)
-        dispatch_exception(request, response, exception)
-      end
-        
-      private 
-      
-      # setup the controller and call the chosen action 
-      def dispatch_action(klass, action, request, response, status=200)
-        # build controller
-        controller = klass.build(request, response, status)
-        # complete setup benchmarking
-        #controller._benchmarks[:setup_time] = Time.now - start
-        if @@use_mutex
-          @@mutex.synchronize { controller.dispatch(action) }
-        else
-          controller.dispatch(action)
-        end
-        [controller, action]
-      end
-      
-      # Re-route the current request to the Exception controller
-      # if it is available, and try to render the exception nicely
-      # if it is not available then just render a simple text error
-      def dispatch_exception(request, response, exception)
-        klass = Exceptions rescue Controller
-        request.params[:original_params] = request.params.dup rescue {}
-        request.params[:original_session] = request.session.dup rescue {}
-        request.params[:original_cookies] = request.cookies.dup rescue {}
-        request.params[:exception] = exception
-        request.params[:action] = exception.name
-        dispatch_action(klass, exception.name, request, response, exception.class::STATUS)
-      rescue => dispatch_issue
-        dispatch_issue = controller_exception(dispatch_issue)  
-        # when no action/template exist for an exception, or an
-        # exception occurs on an InternalServerError the message is
-        # rendered as simple text.
-        # ControllerExceptions raised from exception actions are 
-        # dispatched back into the Exceptions controller
-        if dispatch_issue.is_a?(ControllerExceptions::NotFound)
-          dispatch_default_exception(klass, request, response, exception)
-        elsif dispatch_issue.is_a?(ControllerExceptions::InternalServerError)
-          dispatch_default_exception(klass, request, response, dispatch_issue)
-        else
-          exception = dispatch_issue
-          retry
-        end
-      end
-      
-      # if no custom actions are available to render an exception
-      # then the errors will end up here for processing
-      def dispatch_default_exception(klass, request, response, e)
-        controller = klass.build(request, response, e.class::STATUS)
-        if e.is_a? ControllerExceptions::Redirection
-          controller.headers.merge!('Location' => e.message)
-          controller.instance_variable_set("@_body", %{ }) #fix
-        else
-          @exception = e # for ERB
-          controller.instance_variable_set("@_body", DEFAULT_ERROR_TEMPLATE.result(binding))
-        end
-        [controller, e.name]
-      end
-      
-      # Wraps any non-ControllerException errors in an 
-      # InternalServerError ready for displaying over HTTP
-      def controller_exception(e)
-        e.kind_of?(ControllerExceptions::Base) ?
-          e : ControllerExceptions::InternalServerError.new(e) 
-      end
-      
-    end # end class << self
-  end
-end

data/lib/merb/drb_server.rb

@@ -1,19 +0,0 @@
-require 'drb'
-require File.dirname(__FILE__)+'/upload_progress'
-
-module Merb
-  
-  class DrbServiceProvider
-    include DRbUndumped
-    
-    class << self
-      
-      def upload_progress
-        @upload_progress ||= ::Merb::UploadProgress.new
-      end
-      
-    end
-    
-  end
-  
-end

data/lib/merb/erubis_ext.rb

@@ -1,10 +0,0 @@
-require 'erubis'
-module Erubis
-  class MEruby < Erubis::Eruby
-    include PercentLineEnhancer
-    include StringBufferEnhancer
-  end
-  def self.load_yaml_file(file, binding = binding)
-    YAML::load(Erubis::MEruby.new(IO.read(File.expand_path(file))).result(binding))
-  end
-end

data/lib/merb/exceptions.rb

@@ -1,192 +0,0 @@
-begin
-  require 'coderay'
-rescue LoadError => ex
-end
-
-module Merb
-  # ControllerExceptions are a way of simplifying controller code by placing
-  # exceptional logic back into the MVC pattern.
-  #
-  # When a ControllerException is raised within your application merb will
-  # attempt to re-route the request to your Exceptions controller to render
-  # the error in a friendly mannor.
-  #
-  # For example you might have an action in your app that raises NotFound
-  # if a some resource was not available
-  #
-  #   def show
-  #     product = Product.find(params[:id])
-  #     raise NotFound if product.nil?
-  #     [...]
-  #   end
-  #
-  # This would halt execution of your action and re-route it over to your
-  # Exceptions controller which might look something like
-  #
-  # class Exceptions < Application
-  #   def not_found
-  #     render :layout => :none
-  #   end
-  # end
-  #
-  # As usual the not_found action will look for a template in
-  #   app/views/exceptions/not_found.html.erb
-  #
-  # Note: All standard ControllerExceptions have an HTTP status code associated 
-  # with them which is sent to the browser when the action it is rendered.
-  #
-  # Note: If you do not specifiy how to handle raised ControllerExceptions 
-  # or an unhandlable exception occurs within your customised exception action
-  # then they will be rendered using the built-in error template
-  # in development mode this "built in" template will show stack-traces for
-  # any of the ServerError family of exceptions (you can force the stack-trace
-  # to display in production mode using the :exception_details config option in 
-  # merb.yml)
-  #
-  #
-  # Internal Exceptions 
-  #
-  # Any other rogue errors (not ControllerExceptions) that occur during the 
-  # execution of you app will be converted into the ControllerException 
-  # InternalServerError, and like all ControllerExceptions can be caught
-  # on your Exceptions controller.
-  #
-  # InternalServerErrors return status 500, a common use for cusomizing this
-  # action might be to send emails to the development team, warning that their
-  # application have exploded. Mock example:
-  #
-  #   def internal_server_error
-  #     MySpecialMailer.deliver(
-  #       "team@cowboys.com", 
-  #       "Exception occured at #{Time.now}", 
-  #       params[:exception])
-  #     render :inline => 'Something is wrong, but the team are on it!'
-  #   end
-  #
-  # Note: The special param[:exception] is available in all Exception actions 
-  # and contains the ControllerException that was raised (this is handy if
-  # you want to display the associated message or display more detailed info)
-  #
-  #
-  # Extending ControllerExceptions
-  #
-  # To extend the use of the ControllerExceptions one may extend any of the 
-  # HTTPError classes.
-  #
-  # As an example we can create an exception called AdminAccessRequired.
-  #
-  #   class AdminAccessRequired < Merb::ControllerExceptions::Unauthorized; end
-  #
-  # Add the required action to our Exceptions controller
-  #
-  #   class Exceptions < Application
-  #     def admin_access_required
-  #       render
-  #     end
-  #   end
-  #
-  # In app/views/exceptions/admin_access_required.rhtml
-  # 
-  #   <h1>You're not an administrator!</h1>
-  #   <p>You tried to access <%= @tried_to_access %> but that URL is 
-  #   restricted to administrators.</p>
-  #
-  module ControllerExceptions
-    
-    # Mapping of status code names to their numeric value.
-    STATUS_CODES = {}
-    
-    class Base < StandardError
-      def name
-        self.class.to_s.snake_case.split('::').last
-      end
-      
-      #
-      # Registers any subclasses with status codes for easy lookup by
-      # set_status in Merb::Controller.
-      #
-      # Inheritance ensures this method gets inherited by any subclasses, so
-      # it goes all the way down the chain of inheritance.
-      #
-      def self.inherited(subclass)
-        if subclass.const_defined?(:STATUS)
-          STATUS_CODES[subclass.name.snake_case.to_sym] = subclass.const_get(:STATUS)
-        end
-      end
-    end
-    
-    class Informational                 < Merb::ControllerExceptions::Base; end
-      class Continue                    < Merb::ControllerExceptions::Informational; STATUS = 100; end
-      class SwitchingProtocols          < Merb::ControllerExceptions::Informational; STATUS = 101; end
-    class Successful                    < Merb::ControllerExceptions::Base; end
-      class OK                          < Merb::ControllerExceptions::Successful; STATUS = 200; end
-      class Created                     < Merb::ControllerExceptions::Successful; STATUS = 201; end
-      class Accepted                    < Merb::ControllerExceptions::Successful; STATUS = 202; end
-      class NonAuthoritativeInformation < Merb::ControllerExceptions::Successful; STATUS = 203; end
-      class NoContent                   < Merb::ControllerExceptions::Successful; STATUS = 204; end
-      class ResetContent                < Merb::ControllerExceptions::Successful; STATUS = 205; end
-      class PartialContent              < Merb::ControllerExceptions::Successful; STATUS = 206; end
-    class Redirection                   < Merb::ControllerExceptions::Base; end
-      class MultipleChoices             < Merb::ControllerExceptions::Redirection; STATUS = 300; end
-      class MovedPermanently            < Merb::ControllerExceptions::Redirection; STATUS = 301; end
-      class MovedTemporarily            < Merb::ControllerExceptions::Redirection; STATUS = 302; end
-      class SeeOther                    < Merb::ControllerExceptions::Redirection; STATUS = 303; end
-      class NotModified                 < Merb::ControllerExceptions::Redirection; STATUS = 304; end
-      class UseProxy                    < Merb::ControllerExceptions::Redirection; STATUS = 305; end
-      class TemporaryRedirect           < Merb::ControllerExceptions::Redirection; STATUS = 307; end
-    class ClientError                   < Merb::ControllerExceptions::Base; end
-      class BadRequest                  < Merb::ControllerExceptions::ClientError; STATUS = 400; end
-        class MultiPartParseError       < Merb::ControllerExceptions::BadRequest; end
-      class Unauthorized                < Merb::ControllerExceptions::ClientError; STATUS = 401; end
-      class PaymentRequired             < Merb::ControllerExceptions::ClientError; STATUS = 402; end
-      class Forbidden                   < Merb::ControllerExceptions::ClientError; STATUS = 403; end
-      class NotFound                    < Merb::ControllerExceptions::ClientError; STATUS = 404; end
-        class ActionNotFound            < Merb::ControllerExceptions::NotFound; end
-        class TemplateNotFound          < Merb::ControllerExceptions::NotFound; end
-        class LayoutNotFound            < Merb::ControllerExceptions::NotFound; end
-      class MethodNotAllowed            < Merb::ControllerExceptions::ClientError; STATUS = 405; end
-      class NotAcceptable               < Merb::ControllerExceptions::ClientError; STATUS = 406; end
-      class ProxyAuthenticationRequired < Merb::ControllerExceptions::ClientError; STATUS = 407; end
-      class RequestTimeout              < Merb::ControllerExceptions::ClientError; STATUS = 408; end
-      class Conflict                    < Merb::ControllerExceptions::ClientError; STATUS = 409; end
-      class Gone                        < Merb::ControllerExceptions::ClientError; STATUS = 410; end
-      class LengthRequired              < Merb::ControllerExceptions::ClientError; STATUS = 411; end
-      class PreconditionFailed          < Merb::ControllerExceptions::ClientError; STATUS = 412; end
-      class RequestEntityTooLarge       < Merb::ControllerExceptions::ClientError; STATUS = 413; end
-      class RequestURITooLarge          < Merb::ControllerExceptions::ClientError; STATUS = 414; end
-      class UnsupportedMediaType        < Merb::ControllerExceptions::ClientError; STATUS = 415; end
-      class RequestRangeNotSatisfiable  < Merb::ControllerExceptions::ClientError; STATUS = 416; end
-      class ExpectationFailed           < Merb::ControllerExceptions::ClientError; STATUS = 417; end
-    class ServerError                   < Merb::ControllerExceptions::Base; end
-      class NotImplemented              < Merb::ControllerExceptions::ServerError; STATUS = 501; end
-      class BadGateway                  < Merb::ControllerExceptions::ServerError; STATUS = 502; end
-      class ServiceUnavailable          < Merb::ControllerExceptions::ServerError; STATUS = 503; end
-      class GatewayTimeout              < Merb::ControllerExceptions::ServerError; STATUS = 504; end
-      class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; STATUS = 505; end
-      class InternalServerError         < Merb::ControllerExceptions::ServerError; 
-        STATUS = 500
-        DEFAULT_TEMPLATE = ::Merb::Dispatcher::DEFAULT_ERROR_TEMPLATE
-      
-        def initialize(exception = nil)
-          @exception = exception
-          @coderay = CodeRay rescue nil
-        end
-      
-        def backtrace
-          @exception ? @exception.backtrace : backtrace
-        end
-      
-        def message
-          @exception ? @exception.message : message
-        end
-      end
-  end
-  
-  # PLEASE STOP REMOVING THIS ONE GUYS! It's used to show exceptions in the log file
-  # this is the second time I've had to add it back.
-  def self.exception(e) 
-    "#{ e.message } - (#{ e.class })\n" <<  
-    "#{(e.backtrace or []).join("\n")}" 
-  end
-
-end  

data/lib/merb/generators/merb_app/merb_app.rb

@@ -1,22 +0,0 @@
-require 'fileutils'
-require 'find'
-
-module Merb
-  
-  class AppGenerator    
-    def self.run(path)
-      require 'rubygems'
-      require 'rubigen'
-
-      require 'rubigen/scripts/generate'
-      source = RubiGen::PathSource.new(:application, 
-        File.join(File.dirname(__FILE__), "../../../../app_generators"))
-      RubiGen::Base.reset_sources
-      RubiGen::Base.append_sources source
-      RubiGen::Scripts::Generate.new.run([path], :generator => 'merb', :backtrace => true)
-    end  
-
-  end
-        
-end  
-

data/lib/merb/generators/merb_generator_helpers.rb

@@ -1,318 +0,0 @@
-# Provides some basic generator support that is generally required in various 
-# Generators
-
-module Merb
-  module GeneratorHelpers
-    
-    class ModelGeneratorBase < RubiGen::Base
-
-      default_options :author => nil
-      attr_reader :name, :model_attributes
-      attr_accessor :model_template_name, :model_test_generator_name, :migration_generator_name
-      
-      def initialize(runtime_args, runtime_options = {})
-        super
-        usage if args.empty?
-        @class_name = args.shift.snake_case.to_const_string
-        extract_options
-      end
-
-      def manifest
-        unless @class_name
-          puts banner
-          exit 1
-        end
-        record do |m|
-
-          # ensure there are no other definitions of this model already defined.
-          m.class_collisions(@class_name)
-          # Ensure appropriate folder(s) exists
-          m.directory 'app/models'
-          # 
-          model_filename = @class_name.snake_case
-          spec_filename = @class_name.snake_case.pluralize
-          table_name = spec_filename
-
-
-          # Create stubs
-          m.template  model_template_name, 
-                      "app/models/#{model_filename}.rb", 
-                      :assigns => {  :class_name => @class_name, 
-                                     :table_attributes => model_attributes}
-
-          # Check to see if a scope has been set for which test framework to use.
-          # If we try to run the dependency without an :rspec or :test_unit scope an
-          # error will be raised.
-          scopes = RubiGen::Base.sources.select{ |s| s.is_a?( RubiGen::PathFilteredSource )}.first.filters
-          if scopes.include?(:rspec) || scopes.include?(:test_unit)
-            unless options[:skip_testing] 
-              m.dependency model_test_generator_name, [@class_name]
-            end
-          else
-            puts "\nSelect a scope for :rspec or :test_unit in script/generate if you want to generate test stubs\n\n"
-          end
-
-          unless options[:skip_migration]
-            m.dependency migration_generator_name,["add_model_#{spec_filename}"], :table_name => table_name, :table_attributes => model_attributes
-          end
-
-        end    
-      end
-
-      protected
-        def banner
-            <<-EOS
-Creates a new model for merb
-
-USAGE: #{$0} #{spec.name} NameOfModel [field:type field:type]
-
-Example:
-  #{$0} #{spec.name} person
-
-  If you already have 3 migrations, this will create the AddModelPeople migration in
-  schema/migration/004_add_model_people.rb
-
-Options: 
-  --skip-migration will not create a migration file
-
-EOS
-          end
-
-        def add_options!(opts)
-          opts.separator ''
-          opts.separator 'Options:'
-          # For each option below, place the default
-          # at the top of the file next to "default_options"
-          # opts.on("-a", "--author=\"Your Name\"", String,
-          #         "Some comment about this option",
-          #         "Default: none") { |options[:author]| }
-          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
-          opts.on( "--skip-migration", "Don't generate a migration for this model") { |options[:skip_migration]| }
-          opts.on( "--skip-testing", "Don't generate a test or spec file for this model") { |options[:skip_testing]| }
-        end
-
-        def extract_options
-          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
-          # Templates can access these value via the attr_reader-generated methods, but not the
-          # raw instance variable value.
-          # @author = options[:author]
-          # get the attributes into a format that can be used.
-          attribute = Struct.new(:name, :type)
-          @model_attributes = args.map{ |b| b.split(":").size > 1 ? attribute.new(*b.split(":")) : nil }.compact
-        end
-    end
-    
-    class MigrationGeneratorBase < RubiGen::Base
-
-      default_options :author => nil
-
-      attr_reader :name
-      attr_accessor :migration_template_name
-      
-      def initialize(runtime_args, runtime_options = {})
-        super
-        usage if args.empty?
-        @class_name = args.shift
-        options[:table_name] ||= runtime_options[:table_name]
-        extract_options
-      end
-
-      def manifest
-        unless @class_name
-          puts banner
-          exit 1
-        end
-        record do |m|
-          # Ensure appropriate folder(s) exists
-          m.directory 'schema/migrations'
-
-          # Create stubs
-          highest_migration = Dir[Dir.pwd+'/schema/migrations/*'].map{|f| File.basename(f) =~ /^(\d+)/; $1}.max
-          filename = format("%03d_%s", (highest_migration.to_i+1), @class_name.snake_case)
-          m.template "new_migration.erb", "schema/migrations/#{filename}.rb", 
-            :assigns => { :class_name => @class_name, 
-                          :table_name => options[:table_name],
-                          :table_attributes => options[:table_attributes] }
-
-        end
-      end
-
-      protected
-        def banner
-          <<-EOS
-Creates a new migration for merb
-
-USAGE: #{$0} #{spec.name} NameOfMigration [field:type field:type]
-
-Example:
-  #{$0} #{spec.name} AddPeople
-
-  If you already have 3 migrations, this will create the AddPeople migration in
-  schema/migration/004_add_people.rb
-
-  #{$0} #{spec.name} project --table-name projects_table name:string created_at:timestamp
-
-  This will create a migration that creates a table call projects_table with these attributes:
-    string :name
-    timestamp :created_at
-
-EOS
-        end
-
-        def add_options!(opts)
-          opts.separator ''
-          opts.separator 'Options:'
-          # For each option below, place the default
-          # at the top of the file next to "default_options"
-          # opts.on("-a", "--author=\"Your Name\"", String,
-          #         "Some comment about this option",
-          #         "Default: none") { |options[:author]| }
-          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
-          opts.on( "--table-name=\"table_name_for_migration\"", 
-                    String,
-                    "Include a create table with the given table name"){ |options[:table_name]| }
-        end
-
-        def extract_options
-          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
-          # Templates can access these value via the attr_reader-generated methods, but not the
-          # raw instance variable value.
-          # @author = options[:author]
-          if !options[:table_attributes]
-            attribute = Struct.new(:name, :type)
-            options[:table_attributes] = args.map{ |b| b.split(":").size == 2 ? attribute.new(*b.split(":")) : nil }.compact
-          end
-        end
-    end
-    
-    class MerbModelTestGenerator < RubiGen::Base
-
-      default_options :author => nil
-
-      attr_reader :name, :model_test_template_name, :model_test_path_name, :model_test_file_suffix
-
-      def initialize(runtime_args, runtime_options = {})
-        super
-        usage if args.empty?
-        @class_name = args.shift.snake_case.to_const_string
-        extract_options
-      end
-
-      def manifest
-        unless @class_name
-          puts banner
-          exit 1
-        end
-        record do |m|
-          # ensure there are no other definitions of this model already defined.
-          # Ensure appropriate folder(s) exists
-          m.directory model_test_path_name
-          # 
-          model_filename = @class_name.snake_case
-
-          # Create stubs
-          m.template model_test_template_name, 
-            "#{model_test_path_name}/#{model_filename}_#{model_test_file_suffix}.rb", 
-            :assigns => {:class_name => @class_name}
-        end
-      end
-
-      protected
-
-
-        def add_options!(opts)
-          # opts.separator ''
-          # opts.separator 'Options:'
-          # For each option below, place the default
-          # at the top of the file next to "default_options"
-          # opts.on("-a", "--author=\"Your Name\"", String,
-          #         "Some comment about this option",
-          #         "Default: none") { |options[:author]| }
-          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
-        end
-
-        def extract_options
-          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
-          # Templates can access these value via the attr_reader-generated methods, but not the
-          # raw instance variable value.
-          # @author = options[:author]
-        end
-    end
-    
-    # Pass the following options are available to this generatrs
-    class ControllerGeneratorBase < RubiGen::Base
-
-      default_options :author => nil
-
-      attr_reader :name, :class_name, :file_name
-
-      def initialize(runtime_args, runtime_options = {})
-        super
-        usage if args.empty?
-        @name             = args.shift
-        @class_name       = @name.camel_case #.pluralize
-        @file_name        = @name.snake_case #.pluralize
-        @engine           = runtime_options[:engine] || "erb" # set by subclasses only
-        @template_actions = runtime_options[:actions] || %w[index] # Used by subclasses only
-        @test_generator   = runtime_options[:test_stub_generator] || "merb_controller_test"
-        @base_dest_folder = runtime_options[:base_dest_folder] || "app"
-        extract_options
-      end
-
-      def manifest
-        record do |m|
-          
-          # ensure there are no other definitions of this model already defined.
-          m.class_collisions(@class_name)
-          
-          m.directory "#{@base_dest_folder}/controllers"
-          m.template "controller.rb", "#{@base_dest_folder}/controllers/#{file_name}.rb", :assigns => {:actions => @template_actions}
-          
-          m.directory "#{@base_dest_folder}/views/#{file_name}"
-          
-          # Include templates if they exist
-          @template_actions.each do |the_action|  
-            template_name = "#{the_action}.html.#{@engine}"
-            template_path = "/" + source_path(spec.name).split("/")[0..-2].join("/")
-
-            if File.exists?(File.join(template_path,template_name))
-              m.template template_name, "#{@base_dest_folder}/views/#{file_name}/#{template_name}"
-            end
-          end
-
-          m.directory "#{@base_dest_folder}/helpers/"
-          m.template "helper.rb", "#{@base_dest_folder}/helpers/#{file_name}_helper.rb"
-          m.dependency @test_generator, [name], :destination => destination_root, :template_actions => @template_actions
-        end
-      end
-
-      protected
-        def banner
-          <<-EOS
-    Creates a Merb controller
-
-    USAGE: #{$0} #{spec.name} name"
-    EOS
-        end
-
-        def add_options!(opts)
-          # opts.separator ''
-          # opts.separator 'Options:'
-          # For each option below, place the default
-          # at the top of the file next to "default_options"
-          # opts.on("-a", "--author=\"Your Name\"", String,
-          #         "Some comment about this option",
-          #         "Default: none") { |options[:author]| }
-          # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
-        end
-
-        def extract_options
-          # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
-          # Templates can access these value via the attr_reader-generated methods, but not the
-          # raw instance variable value.
-          # @author = options[:author]
-        end
-    end
-    
-  end
-end