thorero 0.9.4.4 → 0.9.4.5

data/lib/merb-core/config.rb

@@ -0,0 +1,303 @@
+require "optparse"
+require "yaml"
+
+module Merb
+
+  class Config
+
+    class << self
+
+      # ==== Returns
+      # Hash:: The defaults for the config.
+      def defaults
+        @defaults ||= {
+          :host                   => "0.0.0.0",
+          :port                   => "4000",
+          :adapter                => "runner",
+          :reload_classes         => true,
+          :environment            => "development",
+          :merb_root              => Dir.pwd,
+          :use_mutex              => true,
+          :session_id_key         => "_session_id",
+          :log_delimiter          => " ~ ",
+          :log_auto_flush         => false,
+          :log_level              => :info,
+          :disabled_components    => [],
+          :deferred_actions       => [],
+          :verbose                => false
+        }
+      end
+
+      # Yields the configuration.
+      #
+      # ==== Block parameters
+      # c<Hash>:: The configuration parameters.
+      #
+      # ==== Examples
+      #   Merb::Config.use do |config|
+      #     config[:exception_details] = false
+      #   end
+      def use
+        @configuration ||= {}
+        yield @configuration
+      end
+
+      # ==== Parameters
+      # key<Object>:: The key to check.
+      #
+      # ==== Returns
+      # Boolean:: True if the key exists in the config.
+      def key?(key)
+        @configuration.key?(key)
+      end
+
+      # ==== Parameters
+      # key<Object>:: The key to retrieve the parameter for.
+      #
+      # ==== Returns
+      # Object:: The value of the configuration parameter.
+      def [](key)
+        (@configuration||={})[key]
+      end
+
+      # ==== Parameters
+      # key<Object>:: The key to set the parameter for.
+      # val<Object>:: The value of the parameter.
+      def []=(key,val)
+        @configuration[key] = val
+      end
+
+      # ==== Parameters
+      # key<Object>:: The key of the parameter to delete.
+      def delete(key)
+        @configuration.delete(key)
+      end
+
+      # ==== Parameters
+      # key<Object>:: The key to retrieve the parameter for.
+      # default<Object>::
+      #   The default value to return if the parameter is not set.
+      #
+      # ==== Returns
+      # Object:: The value of the configuration parameter or the default.
+      def fetch(key, default)
+        @configuration.fetch(key, default)
+      end
+
+      # ==== Returns
+      # Hash:: The config as a hash.
+      def to_hash
+        @configuration
+      end
+
+      # ==== Returns
+      # String:: The config as YAML.
+      def to_yaml
+        @configuration.to_yaml
+      end
+
+      # Sets up the configuration by storing the given settings.
+      #
+      # ==== Parameters
+      # settings<Hash>::
+      #   Configuration settings to use. These are merged with the defaults.
+      def setup(settings = {})
+        @configuration = defaults.merge(settings)
+      end
+
+      # Parses the command line arguments and stores them in the config.
+      #
+      # ==== Parameters
+      # argv<String>:: The command line arguments. Defaults to +ARGV+.
+      def parse_args(argv = ARGV)
+        @configuration ||= {}
+        # Our primary configuration hash for the length of this method
+        options = {}
+
+        # Environment variables always win
+        options[:environment] = ENV["MERB_ENV"] if ENV["MERB_ENV"]
+
+        # Build a parser for the command line arguments
+        opts = OptionParser.new do |opts|
+          opts.version = Merb::VERSION
+          opts.release = Merb::RELEASE
+
+          opts.banner = "Usage: merb [uGdcIpPhmailLerkKX] [argument]"
+          opts.define_head "Merb. Pocket rocket web framework"
+          opts.separator '*'*80
+          opts.separator 'If no flags are given, Merb starts in the foreground on port 4000.'
+          opts.separator '*'*80
+
+          opts.on("-u", "--user USER", "This flag is for having merb run as a user other than the one currently logged in. Note: if you set this you must also provide a --group option for it to take effect.") do |user|
+            options[:user] = user
+          end
+
+          opts.on("-G", "--group GROUP", "This flag is for having merb run as a group other than the one currently logged in. Note: if you set this you must also provide a --user option for it to take effect.") do |group|
+            options[:group] = group
+          end
+
+          opts.on("-d", "--daemonize", "This will run a single merb in the background.") do |daemon|
+            options[:daemonize] = true
+          end
+
+          opts.on("-c", "--cluster-nodes NUM_MERBS", "Number of merb daemons to run.") do |nodes|
+            options[:cluster] = nodes
+          end
+
+          opts.on("-I", "--init-file FILE", "File to use for initialization on load, defaults to config/init.rb") do |init_file|
+            options[:init_file] = init_file
+          end
+
+          opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000.") do |port|
+            options[:port] = port
+          end
+
+          opts.on("-o", "--socket-file FILE", "Socket file to run merb on, defaults to [Merb.root]/log/merb.sock") do |port|
+            options[:socket_file] = port
+          end
+
+          opts.on("-s", "--socket SOCKNUM", "Socket number to run merb on, defaults to 0.") do |port|
+            options[:socket] = port
+          end
+
+          opts.on("-P", "--pid PIDFILE", "PID file, defaults to [Merb.root]/log/merb.[port_number].pid") do |pid_file|
+            options[:pid_file] = pid_file
+          end
+
+          opts.on("-h", "--host HOSTNAME", "Host to bind to (default is 0.0.0.0).") do |host|
+            options[:host] = host
+          end
+
+          opts.on("-m", "--merb-root /path/to/approot", "The path to the Merb.root for the app you want to run (default is current working dir).") do |root|
+            options[:merb_root] = File.expand_path(root)
+          end
+
+          opts.on("-a", "--adapter mongrel", "The rack adapter to use to run merb[mongrel, emongrel, thin, ebb, fastcgi, webrick, runner, irb]") do |adapter|
+            options[:adapter] = adapter
+          end
+
+          opts.on("-R", "--rackup FILE", "Load an alternate Rack config file (default is config/rack.rb)") do |rackup|
+            options[:rackup] = rackup
+          end
+
+          opts.on("-i", "--irb-console", "This flag will start merb in irb console mode. All your models and other classes will be available for you in an irb session.") do |console|
+            options[:adapter] = 'irb'
+          end
+
+          opts.on("-S", "--sandbox", "This flag will enable a sandboxed irb console. If your ORM supports transactions, all edits will be rolled back on exit.") do |sandbox|
+            options[:sandbox] = true
+          end
+
+          opts.on("-l", "--log-level LEVEL", "Log levels can be set to any of these options: debug < info < warn < error < fatal") do |log_level|
+            options[:log_level] = log_level.to_sym
+          end
+
+          opts.on("-L", "--log LOGFILE", "A string representing the logfile to use.") do |log_file|
+            options[:log_file] = log_file
+          end
+
+          opts.on("-e", "--environment STRING", "Run merb in the correct mode(development, production, testing)") do |env|
+            options[:environment] = env
+          end
+
+          opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]",
+          "Command-line option to run scripts and/or code in the merb app.") do |code_or_file|
+            options[:runner_code] = code_or_file
+            options[:adapter] = 'runner'
+          end
+
+          opts.on("-K", "--graceful PORT or all", "Gracefully kill one merb proceses by port number.  Use merb -K all to gracefully kill all merbs.") do |ports|
+            options[:action] = :kill
+            options[:port] = ports
+          end
+
+          opts.on("-k", "--kill PORT or all", "Kill one merb proceses by port number.  Use merb -k all to kill all merbs.") do |port|
+            options[:action] = :kill_9
+            options[:port] = port
+          end
+
+          opts.on("-X", "--mutex on/off", "This flag is for turning the mutex lock on and off.") do |mutex|
+            if mutex == "off"
+              options[:use_mutex] = false
+            else
+              options[:use_mutex] = true
+            end
+          end
+
+          opts.on("-D", "--debugger", "Run merb using rDebug.") do
+            begin
+              require "ruby-debug"
+              Debugger.start
+              Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+              puts "Debugger enabled"
+            rescue LoadError
+              puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+              exit
+            end
+          end
+
+          opts.on("-V", "--verbose", "Print extra information") do
+            options[:verbose] = true
+          end
+
+          opts.on("-?", "-H", "--help", "Show this help message") do
+            puts opts
+            exit
+          end
+        end
+
+        # Parse what we have on the command line
+        opts.parse!(argv)
+        Merb::Config.setup(options)
+      end
+
+      attr_accessor :configuration
+
+      # Set configuration parameters from a code block, where each method
+      # evaluates to a config parameter.
+      #
+      # ==== Parameters
+      # &block:: Configuration parameter block.
+      #
+      # ==== Examples
+      #   # Set environment and log level.
+      #   Merb::Config.configure do
+      #     environment "development"
+      #     log_level   "debug"
+      #   end
+      def configure(&block)
+        ConfigBlock.new(self, &block) if block_given?
+      end
+
+      # Allows retrieval of single key config values via Merb.config.<key>
+      # Allows single key assignment via Merb.config.<key> = ...
+      #
+      # ==== Parameters
+      # method<~to_s>:: Method name as hash key value.
+      # *args:: Value to set the configuration parameter to.
+      def method_missing(method, *args)
+        if method.to_s[-1,1] == '='
+          @configuration[method.to_s.tr('=','').to_sym] = *args
+        else
+          @configuration[method]
+        end
+      end
+
+    end # class << self
+
+    class ConfigBlock
+
+      def initialize(klass, &block)
+        @klass = klass
+        instance_eval(&block)
+      end
+
+      def method_missing(method, *args)
+        @klass[method] = *args
+      end
+
+    end # class Configurator
+
+  end # Config
+
+end # Merb

data/lib/merb-core/constants.rb

@@ -0,0 +1,43 @@
+# Most of this list is simply constants frozen for efficiency
+module Merb
+    module Const
+    
+    DEFAULT_SEND_FILE_OPTIONS = {
+      :type         => 'application/octet-stream'.freeze,
+      :disposition  => 'attachment'.freeze
+    }.freeze
+    
+    SET_COOKIE               = " %s=%s; path=/; expires=%s".freeze
+    COOKIE_EXPIRATION_FORMAT = "%a, %d-%b-%Y %H:%M:%S GMT".freeze
+    COOKIE_SPLIT             = /[;,] */n.freeze
+    COOKIE_REGEXP            = /\s*(.+)=(.*)\s*/.freeze
+    COOKIE_EXPIRED_TIME      = Time.at(0).freeze
+    HOUR                     = 60 * 60
+    DAY                      = HOUR * 24
+    WEEK                     = DAY * 7
+    MULTIPART_REGEXP         = /\Amultipart\/form-data.*boundary=\"?([^\";,]+)/n.freeze
+    HTTP_COOKIE              = 'HTTP_COOKIE'.freeze
+    QUERY_STRING             = 'QUERY_STRING'.freeze
+    JSON_MIME_TYPE_REGEXP    = %r{^application/json|^text/x-json}.freeze
+    XML_MIME_TYPE_REGEXP     = %r{^application/xml|^text/xml}.freeze
+    FORM_URL_ENCODED_REGEXP  = %r{^application/x-www-form-urlencoded}.freeze
+    UPCASE_CONTENT_TYPE      = 'CONTENT_TYPE'.freeze
+    CONTENT_TYPE             = "Content-Type".freeze
+    LAST_MODIFIED            = "Last-Modified".freeze
+    SLASH                    = "/".freeze
+    REQUEST_METHOD           = "REQUEST_METHOD".freeze
+    GET                      = "GET".freeze
+    POST                     = "POST".freeze
+    HEAD                     = "HEAD".freeze
+    CONTENT_LENGTH           = "CONTENT_LENGTH".freeze
+    HTTP_X_FORWARDED_FOR     = "HTTP_X_FORWARDED_FOR".freeze
+    HTTP_IF_MODIFIED_SINCE   = "HTTP_IF_MODIFIED_SINCE".freeze
+    HTTP_IF_NONE_MATCH       = "HTTP_IF_NONE_MATCH".freeze
+    UPLOAD_ID                = "upload_id".freeze
+    PATH_INFO                = "PATH_INFO".freeze
+    SCRIPT_NAME              = "SCRIPT_NAME".freeze
+    REQUEST_URI              = "REQUEST_URI".freeze
+    REQUEST_PATH             = "REQUEST_PATH".freeze
+    REMOTE_ADDR              = "REMOTE_ADDR".freeze
+  end
+end

data/lib/merb-core/controller/abstract_controller.rb

@@ -0,0 +1,578 @@
+# ==== Why do we use Underscores?
+# In Merb, views are actually methods on controllers. This provides
+# not-insignificant speed benefits, as well as preventing us from
+# needing to copy over instance variables, which we think is proof
+# that everything belongs in one class to begin with.
+#
+# Unfortunately, this means that view helpers need to be included
+# into the <strong>Controller</strong> class. To avoid causing confusion
+# when your helpers potentially conflict with our instance methods,
+# we use an _ to disambiguate. As long as you don't begin your helper
+# methods with _, you only need to worry about conflicts with Merb
+# methods that are part of the public API.
+#
+#
+#
+# ==== Filters
+# #before is a class method that allows you to specify before filters in
+# your controllers. Filters can either be a symbol or string that
+# corresponds to a method name to call, or a proc object. if it is a method
+# name that method will be called and if it is a proc it will be called
+# with an argument of self where self is the current controller object.
+# When you use a proc as a filter it needs to take one parameter.
+# 
+# #after is identical, but the filters are run after the action is invoked.
+#
+# ===== Examples
+#   before :some_filter
+#   before :authenticate, :exclude => [:login, :signup]
+#   before :has_role, :with => ["Admin"], :exclude => [:index,:show]
+#   before Proc.new {|c| c.some_method }, :only => :foo
+#   before :authorize, :unless => logged_in?  
+#
+# You can use either :only => :actionname or :exclude => [:this, :that]
+# but not both at once. :only will only run before the listed actions
+# and :exclude will run for every action that is not listed.
+#
+# Merb's before filter chain is very flexible. To halt the filter chain you
+# use throw :halt. If throw is called with only one argument of :halt the
+# return of the method filters_halted will be what is rendered to the view.
+# You can overide filters_halted in your own controllers to control what it
+# outputs. But the throw construct is much more powerful then just that.
+# throw :halt can also take a second argument. Here is what that second arg
+# can be and the behavior each type can have:
+#
+# * +String+:
+#   when the second arg is a string then that string will be what
+#   is rendered to the browser. Since merb's render method returns
+#   a string you can render a template or just use a plain string:
+#
+#     throw :halt, "You don't have permissions to do that!"
+#     throw :halt, render(:action => :access_denied)
+#
+# * +Symbol+:
+#   If the second arg is a symbol then the method named after that
+#   symbol will be called
+#
+#   throw :halt, :must_click_disclaimer
+#
+# * +Proc+:
+#
+#   If the second arg is a Proc, it will be called and its return
+#   value will be what is rendered to the browser:
+#
+#     throw :halt, proc {|c| c.access_denied }
+#     throw :halt, proc {|c| Tidy.new(c.index) }
+#
+# ===== Filter Options (.before, .after, .add_filter, .if, .unless)
+# :only<Symbol, Array[Symbol]>::
+#   A list of actions that this filter should apply to
+#
+# :exclude<Symbol, Array[Symbol]::
+#   A list of actions that this filter should *not* apply to
+# 
+# :if<Symbol, Proc>::
+#   Only apply the filter if the method named after the symbol or calling the proc evaluates to true
+# 
+# :unless<Symbol, Proc>::
+#   Only apply the filter if the method named after the symbol or calling the proc evaluates to false
+#
+# ===== Types (shortcuts for use in this file)
+# Filter:: <Array[Symbol, (Symbol, String, Proc)]>
+#
+# ==== params[:action] and params[:controller] deprecated
+# params[:action] and params[:controller] have been deprecated as of
+# the 0.9.0 release. They are no longer set during dispatch, and
+# have been replaced by action_name and controller_name respectively.
+class Merb::AbstractController
+  include Merb::RenderMixin
+  include Merb::InlineTemplates
+  
+  class_inheritable_accessor :_layout, :_template_root, :template_roots
+  class_inheritable_accessor :_before_filters, :_after_filters
+  
+  FILTER_OPTIONS = [:only, :exclude, :if, :unless, :with]
+
+  # ==== Returns
+  # String:: The controller name in path form, e.g. "admin/items".
+  #---
+  # @public
+  def self.controller_name() @controller_name ||= self.name.to_const_path end
+
+  # ==== Returns
+  # String:: The controller name in path form, e.g. "admin/items".
+  def controller_name()      self.class.controller_name                   end
+
+  self._before_filters, self._after_filters = [], []
+  
+  # This is called after the controller is instantiated to figure out where to
+  # for templates under the _template_root. Override this to define a new
+  # structure for your app.
+  #
+  # ==== Parameters
+  # context<~to_s>:: The controller context (the action or template name).
+  # type<~to_s>:: The content type. Defaults to nil.
+  # controller<~to_s>::
+  #   The name of the controller. Defaults to controller_name.
+  #
+  #
+  # ==== Returns
+  # String:: 
+  #   Indicating where to look for the template for the current controller,
+  #   context, and content-type.
+  #
+  # ==== Notes
+  # The type is irrelevant for controller-types that don't support
+  # content-type negotiation, so we default to not include it in the
+  # superclass.
+  #
+  # ==== Examples
+  #   def _template_location
+  #     "#{params[:controller]}.#{params[:action]}.#{content_type}"
+  #   end
+  #
+  # This would look for templates at controller.action.mime.type instead
+  # of controller/action.mime.type
+  #---
+  # @public
+  def _template_location(context, type = nil, controller = controller_name)
+    controller ? "#{controller}/#{context}" : context
+  end
+
+  # The location to look for a template - stub method for particular behaviour.
+  #
+  # ==== Parameters
+  # template<String>:: The absolute path to a template - without template extension.
+  # type<~to_s>::
+  #    The mime-type of the template that will be rendered. Defaults to nil.
+  #
+  # @public
+  def _absolute_template_location(template, type)
+    template
+  end
+
+  def self._template_root=(root)
+    @_template_root = root
+    _reset_template_roots
+  end
+
+  def self._reset_template_roots
+    self.template_roots = [[self._template_root, :_template_location]]
+  end
+
+  # ==== Returns
+  # roots<Array[Array]>::
+  #   Template roots as pairs of template root path and template location
+  #   method.
+  def self._template_roots
+    self.template_roots || _reset_template_roots
+  end
+
+  # ==== Parameters
+  # roots<Array[Array]>::
+  #   Template roots as pairs of template root path and template location
+  #   method.
+  def self._template_roots=(roots)
+    self.template_roots = roots
+  end
+  
+  cattr_accessor :_abstract_subclasses, :_template_path_cache
+  #---
+  # We're using abstract_subclasses so that Merb::Controller can have its
+  # own subclasses. We're using a Set so we don't have to worry about
+  # uniqueness.
+  self._abstract_subclasses = Set.new
+
+  # ==== Returns
+  # Set:: The subclasses.
+  def self.subclasses_list() _abstract_subclasses end
+  
+  class << self
+    # ==== Parameters
+    # klass<Merb::AbstractController>::
+    #   The controller that is being inherited from Merb::AbstractController
+    def inherited(klass)
+      _abstract_subclasses << klass.to_s
+      helper_module_name = klass.to_s =~ /^(#|Merb::)/ ? "#{klass}Helper" : "Merb::#{klass}Helper"
+      Object.make_module helper_module_name
+      klass.class_eval <<-HERE
+        include Object.full_const_get("#{helper_module_name}") rescue nil
+      HERE
+      super
+    end
+  end
+  
+  attr_accessor :_benchmarks, :_thrown_content
+
+  #---
+  # @semipublic
+  attr_accessor :body
+  
+  attr_accessor :action_name
+  
+  # ==== Parameters
+  # *args:: The args are ignored.
+  def initialize(*args)
+    @_benchmarks = {}
+    @_caught_content = {}
+    @_template_stack = []
+  end
+  
+  # This will dispatch the request, calling setup_session and finalize_session
+  # 
+  # ==== Parameters
+  # action<~to_s>::
+  #   The action to dispatch to. This will be #send'ed in _call_action.
+  #   Defaults to :to_s.
+  #
+  # ==== Raises
+  # MerbControllerError:: Invalid body content caught.
+  def _dispatch(action=:to_s)
+    setup_session
+    self.action_name = action
+    
+    caught = catch(:halt) do
+      start = Time.now
+      result = _call_filters(_before_filters)
+      @_benchmarks[:before_filters_time] = Time.now - start if _before_filters
+      result
+    end
+  
+    @body = case caught
+    when :filter_chain_completed  then _call_action(action_name)
+    when String                   then caught
+    when nil                      then _filters_halted
+    when Symbol                   then __send__(caught)
+    when Proc                     then caught.call(self)
+    else
+      raise MerbControllerError, "The before filter chain is broken dude. wtf?"
+    end
+    start = Time.now
+    _call_filters(_after_filters)
+    @_benchmarks[:after_filters_time] = Time.now - start if _after_filters
+    finalize_session
+    @body
+  end
+  
+  # This method exists to provide an overridable hook for ActionArgs
+  #
+  # ==== Parameters
+  # action<~to_s>:: the action method to dispatch to
+  def _call_action(action)
+    send(action)
+  end
+  
+  # ==== Parameters
+  # filter_set<Array[Filter]>::
+  #   A set of filters in the form [[:filter, rule], [:filter, rule]]
+  #
+  # ==== Returns
+  # Symbol:: :filter_chain_completed.
+  #
+  # ==== Notes
+  # Filter rules can be Symbols, Strings, or Procs.
+  #
+  # Symbols or Strings::
+  #   Call the method represented by the +Symbol+ or +String+.
+  # Procs::
+  #   Execute the +Proc+, in the context of the controller (self will be the
+  #   controller)
+  def _call_filters(filter_set)
+    (filter_set || []).each do |filter, rule|
+      if _call_filter_for_action?(rule, action_name) && _filter_condition_met?(rule)
+        case filter
+        when Symbol, String
+          if rule.key?(:with)
+            args = rule[:with]
+            send(filter, *args)
+          else
+            send(filter)
+          end
+        when Proc           then self.instance_eval(&filter)
+        end
+      end
+    end
+    return :filter_chain_completed
+  end
+
+  # ==== Parameters
+  # rule<Hash>:: Rules for the filter (see below).
+  # action_name<~to_s>:: The name of the action to be called.
+  #
+  # ==== Options (rule)
+  # :only<Array>::
+  #   Optional list of actions to fire. If given, action_name must be a part of
+  #   it for this function to return true.
+  # :exclude<Array>::
+  #   Optional list of actions not to fire. If given, action_name must not be a
+  #   part of it for this function to return true.
+  #
+  # ==== Returns
+  # Boolean:: True if the action should be called.
+  def _call_filter_for_action?(rule, action_name)
+    # Both:
+    # * no :only or the current action is in the :only list
+    # * no :exclude or the current action is not in the :exclude list
+    (!rule.key?(:only) || rule[:only].include?(action_name)) &&
+    (!rule.key?(:exclude) || !rule[:exclude].include?(action_name))
+  end
+
+  # ==== Parameters
+  # rule<Hash>:: Rules for the filter (see below).
+  #
+  # ==== Options (rule)
+  # :if<Array>:: Optional conditions that must be met for the filter to fire.
+  # :unless<Array>::
+  #   Optional conditions that must not be met for the filter to fire.
+  #
+  # ==== Returns
+  # Boolean:: True if the conditions are met.
+  def _filter_condition_met?(rule)
+    # Both:
+    # * no :if or the if condition evaluates to true
+    # * no :unless or the unless condition evaluates to false
+    (!rule.key?(:if) || _evaluate_condition(rule[:if])) &&
+    (!rule.key?(:unless) || ! _evaluate_condition(rule[:unless]))
+  end
+
+  # ==== Parameters
+  # condition<Symbol, Proc>:: The condition to evaluate.
+  #
+  # ==== Raises
+  # ArgumentError:: condition not a Symbol or Proc.
+  #
+  # ==== Returns
+  # Boolean:: True if the condition is met.
+  #
+  # ==== Alternatives
+  # If condition is a symbol, it will be send'ed. If it is a Proc it will be
+  # called directly with self as an argument.
+  def _evaluate_condition(condition)
+    case condition
+    when Symbol : self.send(condition)
+    when Proc : condition.call(self)
+    else
+      raise ArgumentError,
+            'Filter condtions need to be either a Symbol or a Proc'
+    end
+  end
+
+  # ==== Parameters
+  # filter<Symbol, Proc>:: The filter to add. Defaults to nil.
+  # opts<Hash>::
+  #   Filter options (see class documentation under <tt>Filter Options</tt>).
+  # &block:: A block to use as a filter if filter is nil.
+  #
+  # ==== Notes
+  # If the filter already exists, its options will be replaced with opts.
+  def self.after(filter = nil, opts = {}, &block)
+    add_filter(self._after_filters, filter || block, opts)
+  end
+
+  # ==== Parameters
+  # filter<Symbol, Proc>:: The filter to add. Defaults to nil.
+  # opts<Hash>::
+  #   Filter options (see class documentation under <tt>Filter Options</tt>).
+  # &block:: A block to use as a filter if filter is nil.
+  #
+  # ==== Notes
+  # If the filter already exists, its options will be replaced with opts.
+  def self.before(filter = nil, opts = {}, &block)
+    add_filter(self._before_filters, filter || block, opts)
+  end
+     
+  # Skip an after filter that has been previously defined (perhaps in a
+  # superclass)
+  #
+  # ==== Parameters
+  # filter<Symbol>:: A filter name to skip.
+  def self.skip_after(filter)
+    skip_filter(self._after_filters, filter)
+  end
+  
+  # Skip a before filter that has been previously defined (perhaps in a
+  # superclass).
+  #
+  # ==== Parameters
+  # filter<Symbol>:: A filter name to skip.
+  def self.skip_before(filter)
+    skip_filter(self._before_filters , filter)
+  end  
+  
+  #---
+  # Defaults that can be overridden by plugins, other mixins, or subclasses
+  def _filters_halted()   "<html><body><h1>Filter Chain Halted!</h1></body></html>"  end
+
+  # Method stub for setting up the session. This will be overriden by session
+  # modules.
+  def setup_session()    end
+
+  # Method stub for finalizing up the session. This will be overriden by
+  # session modules.
+  def finalize_session() end  
+
+  # Stub so content-type support in RenderMixin doesn't throw errors
+  attr_accessor :content_type
+  
+  # Handles the template cache (which is used by BootLoader to cache the list
+  # of all templates).
+  #
+  # ==== Parameters
+  # template<String>::
+  #   The full path to a template to add to the list of available templates
+  def self.add_path_to_template_cache(template)
+    return false if template.blank? || template.split("/").last.split(".").size != 3
+    key = template.match(/(.*)\.(.*)$/)[1]
+    self._template_path_cache[key] = template
+  end
+  
+  # Resets the template_path_cache to an empty hash
+  def self.reset_template_path_cache!
+    self._template_path_cache = {}
+  end  
+  
+  # ==== Parameters
+  # name<~to_sym, Hash>:: The name of the URL to generate.
+  # rparams<Hash>:: Parameters for the route generation.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Alternatives
+  # If a hash is used as the first argument, a default route will be
+  # generated based on it and rparams.
+  def url(name, rparams = {}, qparams = {})
+    unless rparams.is_a?(Hash) || qparams.empty?
+      rparams = qparams.merge(:id => rparams)
+    end
+    uri = Merb::Router.generate(name, rparams,
+      { :controller => controller_name,
+        :action => action_name,
+        :format => params[:format]
+      }
+    ) 
+    uri = Merb::Config[:path_prefix] + uri if Merb::Config[:path_prefix]
+    uri
+  end
+  alias_method :relative_url, :url
+
+  # ==== Parameters
+  # name<~to_sym, Hash>:: The name of the URL to generate.
+  # rparams<Hash>:: Parameters for the route generation.
+  #
+  # ==== Returns
+  # String:: The generated url with protocol + hostname + URL.
+  #
+  # ==== Alternatives
+  # If a hash is used as the first argument, a default route will be
+  # generated based on it and rparams.
+  def absolute_url(name, rparams={})
+    request.protocol + request.host + url(name, rparams)
+  end
+
+  # Calls the capture method for the selected template engine.
+  #
+  # ==== Parameters
+  # *args:: Arguments to pass to the block.
+  # &block:: The template block to call.
+  #
+  # ==== Returns
+  # String:: The output of the block.
+  def capture(*args, &block)
+    send("capture_#{@_engine}", *args, &block)
+  end
+
+  # Calls the concatenate method for the selected template engine.
+  #
+  # ==== Parameters
+  # str<String>:: The string to concatenate to the buffer.
+  # binding<Binding>:: The binding to use for the buffer.
+  def concat(str, binding)
+    send("concat_#{@_engine}", str, binding)
+  end
+
+  private
+  # ==== Parameters
+  # filters<Array[Filter]>:: The filter list that this should be added to.
+  # filter<Filter>:: A filter that should be added.
+  # opts<Hash>::
+  #   Filter options (see class documentation under <tt>Filter Options</tt>).
+  #
+  # ==== Raises
+  # ArgumentError::
+  #   Both :only and :exclude, or :if and :unless given, if filter is not a
+  #   Symbol, String or Proc, or if an unknown option is passed.
+  def self.add_filter(filters, filter, opts={})
+    raise(ArgumentError,
+      "You can specify either :only or :exclude but 
+       not both at the same time for the same filter.") if opts.key?(:only) && opts.key?(:exclude)
+       
+     raise(ArgumentError,
+       "You can specify either :if or :unless but 
+        not both at the same time for the same filter.") if opts.key?(:if) && opts.key?(:unless)
+        
+    opts.each_key do |key| raise(ArgumentError,
+      "You can only specify known filter options, #{key} is invalid.") unless FILTER_OPTIONS.include?(key)
+    end
+
+    opts = normalize_filters!(opts)
+
+    case filter
+    when Symbol, Proc, String
+      if existing_filter = filters.find {|f| f.first.to_s[filter.to_s]}
+        existing_filter.last.replace(opts)
+      else
+        filters << [filter, opts]
+      end
+    else
+      raise(ArgumentError, 
+        'Filters need to be either a Symbol, String or a Proc'
+      )        
+    end
+  end  
+
+  # Skip a filter that was previously added to the filter chain. Useful in
+  # inheritence hierarchies.
+  #
+  # ==== Parameters
+  # filters<Array[Filter]>:: The filter list that this should be removed from.
+  # filter<Filter>:: A filter that should be removed.
+  #
+  # ==== Raises
+  # ArgumentError:: filter not Symbol or String.
+  def self.skip_filter(filters, filter)
+    raise(ArgumentError, 'You can only skip filters that have a String or Symbol name.') unless
+      [Symbol, String].include? filter.class
+
+    Merb.logger.warn("Filter #{filter} was not found in your filter chain.") unless
+      filters.reject! {|f| f.first.to_s[filter.to_s] }
+  end
+
+  # Ensures that the passed in hash values are always arrays.
+  #
+  # ==== Parameters
+  # opts<Hash>:: Options for the filters (see below).
+  #
+  # ==== Options (opts)
+  # :only<Symbol, Array[Symbol]>:: A list of actions.
+  # :exclude<Symbol, Array[Symbol]>:: A list of actions.
+  #
+  # ==== Examples
+  #   normalize_filters!(:only => :new) #=> {:only => [:new]}
+  def self.normalize_filters!(opts={})
+    opts[:only]     = Array(opts[:only]).map {|x| x.to_s} if opts[:only]
+    opts[:exclude]  = Array(opts[:exclude]).map {|x| x.to_s} if opts[:exclude]
+    return opts
+  end
+
+  # Attempts to return the partial local variable corresponding to sym.
+  #
+  # ==== Paramteres
+  # sym<Symbol>:: Method name.
+  # *arg:: Arguments to pass to the method.
+  # &blk:: A block to pass to the method.
+  def method_missing(sym, *args, &blk)
+    return @_merb_partial_locals[sym] if @_merb_partial_locals && @_merb_partial_locals.key?(sym)
+    super
+  end  
+end