merb 0.5.3 → 0.9.2

data/lib/merb/mixins/responder.rb

@@ -1,449 +0,0 @@
-  require 'enumerator'
-
-module Merb
-  class << self
-    # Provides the currently implemented mime types as a hash
-    def available_mime_types
-      ResponderMixin::Rest::TYPES
-    end
-    
-    # Any specific outgoing headers should be included here.  These are not
-    # the content-type header but anything in addition to it.
-    # +tranform_method+ should be set to a symbol of the method used to
-    # transform a resource into this mime type.
-    # For example for the :xml mime type an object might be transformed by
-    # calling :to_xml, or for the :js mime type, :to_json.
-    # If there is no transform method, use nil.
-    def add_mime_type(key,transform_method, values,new_response_headers = {})
-      raise ArgumentError unless key.is_a?(Symbol) && values.is_a?(Array)
-      ResponderMixin::Rest::TYPES.update(key => values)
-      add_response_headers!(key, new_response_headers)   
-      ResponderMixin::Rest::TRANSFORM_METHODS.merge!(key => transform_method)
-    end    
-    
-    def remove_mime_type(key)
-      key == :all ? false : ResponderMixin::Rest::TYPES.delete(key)
-    end
-    
-    # Return the method name (if any) for the mimetype
-    def mime_transform_method(key)
-      ResponderMixin::Rest::TRANSFORM_METHODS[key]
-    end
-    
-    # Return default arguments for transform method (if any)
-    def mime_transform_method_defaults(key)
-      ResponderMixin::Rest::TRANSFORM_METHOD_DEFAULTS[key]
-    end
-    
-    # Set default arguments/proc for a format transform method
-    def set_mime_transform_method_defaults(key, *args, &block)
-      raise "Unknown mimetype #{key}" unless ResponderMixin::Rest::TRANSFORM_METHODS[key]
-      args = block if block_given?
-      ResponderMixin::Rest::TRANSFORM_METHOD_DEFAULTS[key] = args unless args.empty?
-    end
-    
-    # Adds outgoing headers to a mime type.  This can be done with the Merb.add_mime_type method
-    # or directly here.  
-    # ===Example
-    # {{[
-    #   Merb.outgoing_headers!(:xml => { :Encoding => "UTF-8" })
-    # ]}}
-    #
-    # This method is destructive on any already defined outgoing headers
-    def add_response_headers!(key, values = {})
-      raise ArgumentError unless key.is_a?(Symbol) && values.is_a?(Hash)
-      response_headers[key] = values
-    end
-    
-    def response_headers
-      ResponderMixin::Rest::RESPONSE_HEADERS
-    end
-    
-    # Completely removes any headers set that are additional to the content-type header.
-    def remove_response_headers!(key)
-      raise ArgumentError unless key.is_a?(Symbol)
-      response_headers[key] = {}
-    end
-    
-    # Sets the mime types and outgoing headers to their original states
-    def reset_default_mime_types!
-      available_mime_types.clear
-      response_headers.clear
-      Merb.add_mime_type(:all,nil,%w[*/*])
-      Merb.add_mime_type(:yaml,:to_yaml,%w[application/x-yaml text/yaml])
-      Merb.add_mime_type(:text,:to_text,%w[text/plain])
-      Merb.add_mime_type(:html,nil,%w[text/html application/xhtml+xml application/html])
-      Merb.add_mime_type(:xml,:to_xml,%w[application/xml text/xml application/x-xml], :Encoding => "UTF-8")
-      Merb.add_mime_type(:js,:to_json,%w[ text/javascript  application/javascript application/x-javascript])
-      Merb.add_mime_type(:json,:to_json,%w[application/json  text/x-json  ])
-    end
-  
-  end
-
-  # The ResponderMixin adds methods that help you manage what
-  # formats your controllers have available, determine what format(s)
-  # the client requested and is capable of handling, and perform
-  # content negotiation to pick the proper content format to
-  # deliver.
-  # 
-  # If you hear someone say "Use provides" they're talking about the
-  # Responder.  If you hear someone ask "What happened to respond_to?"
-  # it was replaced by provides and the other Responder methods.
-  # 
-  # == A simple example
-  # 
-  # The best way to understand how all of these pieces fit together is
-  # with an example.  Here's a simple web-service ready resource that
-  # provides a list of all the widgets we know about.  The widget list is 
-  # available in 3 formats: :html (the default), plus :xml and :text.
-  # 
-  #     class Widgets < Application
-  #       provides :html   # This is the default, but you can
-  #                        # be explicit if you like.
-  #       provides :xml, :text
-  #       
-  #       def index
-  #         @widgets = Widget.fetch
-  #         render @widgets
-  #       end
-  #     end
-  # 
-  # Let's look at some example requests for this list of widgets.  We'll
-  # assume they're all GET requests, but that's only to make the examples
-  # easier; this works for the full set of RESTful methods.
-  # 
-  # 1. The simplest case, /widgets.html
-  #    Since the request includes a specific format (.html) we know
-  #    what format to return.  Since :html is in our list of provided
-  #    formats, that's what we'll return.  +render+ will look
-  #    for an index.html.erb (or another template format
-  #    like index.html.mab; see the documentation on Template engines)
-  # 
-  # 2. Almost as simple, /widgets.xml
-  #    This is very similar.  They want :xml, we have :xml, so
-  #    that's what they get.  If +render+ doesn't find an 
-  #    index.xml.builder or similar template, it will call +to_xml+
-  #    on @widgets.  This may or may not do something useful, but you can 
-  #    see how it works.
-  #
-  # 3. A browser request for /widgets
-  #    This time the URL doesn't say what format is being requested, so
-  #    we'll look to the HTTP Accept: header.  If it's '*/*' (anything),
-  #    we'll use the first format on our list, :html by default.
-  #    
-  #    If it parses to a list of accepted formats, we'll look through 
-  #    them, in order, until we find one we have available.  If we find
-  #    one, we'll use that.  Otherwise, we can't fulfill the request: 
-  #    they asked for a format we don't have.  So we raise
-  #    406: Not Acceptable.
-  # 
-  # == A more complex example
-  # 
-  # Sometimes you don't have the same code to handle each available 
-  # format. Sometimes you need to load different data to serve
-  # /widgets.xml versus /widgets.txt.  In that case, you can use
-  # +content_type+ to determine what format will be delivered.
-  # 
-  #     class Widgets < Application
-  #       def action1
-  #         if content_type == :text
-  #           Widget.load_text_formatted(params[:id])
-  #         else
-  #           render
-  #         end
-  #       end
-  #       
-  #       def action2
-  #         case content_type
-  #         when :html
-  #           handle_html()
-  #         when :xml
-  #           handle_xml()
-  #         when :text
-  #           handle_text()
-  #         else
-  #           render
-  #         end
-  #       end
-  #     end
-  # 
-  # You can do any standard Ruby flow control using +content_type+.  If
-  # you don't call it yourself, it will be called (triggering content
-  # negotiation) by +render+.
-  #
-  # Once +content_type+ has been called, the output format is frozen,
-  # and none of the provides methods can be used.
-  module ResponderMixin
-    
-    def self.included(base) # :nodoc:
-      base.extend(ClassMethods)
-      base.class_eval do
-        class_inheritable_accessor :class_provided_formats
-        class_inheritable_accessor :class_provided_format_arguments
-      end
-      base.reset_provides
-    end
-
-    module ClassMethods
-
-      # Adds symbols representing formats to the controller's
-      # default list of provided_formats.  These will apply to
-      # every action in the controller, unless modified in the action.
-      # If the last argument is a Hash or an Array, these are regarded
-      # as arguments to pass to the to_<mime_type> method as needed.
-      def provides(*formats, &block)
-        options = extract_provides_options(formats, &block)
-        formats.each do |fmt|
-          self.class_provided_formats << fmt unless class_provided_formats.include?(fmt)
-          self.class_provided_format_arguments[fmt] = options unless options.nil?
-        end
-      end
-      
-      # Overwrites the controller's list of provided_formats. These
-      # will apply to every action in the controller, unless modified
-      # in the action.
-      def only_provides(*formats)
-        clear_provides
-        provides(*formats)
-      end
-      
-      # Removes formats from the controller's
-      # default list of provided_formats. These will apply to
-      # every action in the controller, unless modified in the action.
-      def does_not_provide(*formats)
-        self.class_provided_formats -= formats
-        formats.each { |fmt| self.class_provided_format_arguments.delete(fmt) }
-      end
-      
-      # Clear any formats and their options
-      def clear_provides
-        self.class_provided_formats = []
-        self.class_provided_format_arguments = {}
-      end
-      
-      # Reset to the default list of formats
-      def reset_provides
-        only_provides(:html)
-      end
-      
-      # Extract arguments for provided format methods
-      def extract_provides_options(args, &block)
-        return block if block_given?
-        case args.last
-          when Hash   then [args.pop]
-          when Array  then args.pop
-          when Proc   then args.pop
-          else nil
-        end
-      end
-            
-    end
-    
-    # Returns the current list of formats provided for this instance
-    # of the controller.  It starts with what has been set in the controller
-    # (or :html by default) but can be modifed on a per-action basis.
-    def provided_formats
-      @_provided_formats ||= class_provided_formats.dup
-    end
-    
-    # Sets the provided formats for this action.  Usually, you would
-    # use a combination of +provides+, +only_provides+ and +does_not_provide+
-    # to manage this, but you can set it directly.
-    # If the last argument is a Hash or an Array, these are regarded
-    # as arguments to pass to the to_<mime_type> method as needed. 
-    def set_provided_formats(*formats, &block)
-      raise_if_content_type_already_set!
-      @_provided_formats = []
-      @_provided_format_arguments = {}
-      provides(*formats.flatten, &block)
-    end
-    alias :provided_formats= :set_provided_formats
-    
-    # Returns a Hash of arguments for format methods
-    def provided_format_arguments
-      @_provided_format_arguments ||= Hash.new.replace(class_provided_format_arguments)
-    end
-    
-    # Returns the arguments (if any) for the mime_transform_method call
-    def provided_format_arguments_for(fmt)
-      self.provided_format_arguments[fmt] || Merb.mime_transform_method_defaults(fmt)
-    end
-    
-    # Adds formats to the list of provided formats for this particular 
-    # request.  Usually used to add formats to a single action.  See also
-    # the controller-level provides that affects all actions in a controller.
-    def provides(*formats, &block)
-      raise_if_content_type_already_set!
-      options = self.class.extract_provides_options(formats, &block)
-      formats.each do |fmt|
-        self.provided_formats << fmt unless provided_formats.include?(fmt)
-        self.provided_format_arguments[fmt] = options unless options.nil?
-      end
-    end
-    
-    # Sets list of provided formats for this particular 
-    # request.  Usually used to limit formats to a single action.  See also
-    # the controller-level provides that affects all actions in a controller.
-    def only_provides(*formats)
-      self.set_provided_formats(*formats)
-    end
-    
-    # Removes formats from the list of provided formats for this particular 
-    # request.  Usually used to remove formats from a single action.  See
-    # also the controller-level provides that affects all actions in a
-    # controller.
-    def does_not_provide(*formats)
-      formats.flatten!
-      self.provided_formats -= formats
-      formats.each { |fmt| self.provided_format_arguments.delete(fmt) }
-    end
-    
-    # Do the content negotiation:
-    # 1. if params[:format] is there, and provided, use it
-    # 2. Parse the Accept header
-    # 3. If it's */*, use the first provided format
-    # 4. Look for one that is provided, in order of request
-    # 5. Raise 406 if none found
-    def perform_content_negotiation # :nodoc:
-      raise Merb::ControllerExceptions::NotAcceptable if provided_formats.empty?
-      if fmt = params[:format]
-        if provided_formats.include?(fmt.to_sym)
-          fmt.to_sym
-        else
-          raise Merb::ControllerExceptions::NotAcceptable
-        end
-      else
-        accepts = Rest::Responder.parse(request.accept).
-          collect {|t| t.to_sym}
-        if accepts.include?(:all)
-          provided_formats.first
-        else
-          accepts.each do |type|
-            return type if provided_formats.include?(type)
-          end
-          raise Merb::ControllerExceptions::NotAcceptable
-        end
-      end
-    end
-    
-    # Checks to see if content negotiation has already been performed.
-    # If it has, you can no longer modify the list of provided formats.
-    def content_type_set?
-      !@_content_type.nil?
-    end
-    
-    # Returns the output format for this request, based on the 
-    # provided formats, <tt>params[:format]</tt> and the client's HTTP
-    # Accept header.
-    #
-    # The first time this is called, it triggers content negotiation
-    # and caches the value.  Once you call +content_type+ you can
-    # not set or change the list of provided formats.
-    #
-    # Called automatically by +render+, so you should only call it if
-    # you need the value, not to trigger content negotiation. 
-    def content_type
-      unless content_type_set?
-        @_content_type = perform_content_negotiation
-        raise Merb::ControllerExceptions::NotAcceptable.new("Unknown content_type for response: #{@_content_type}") unless
-          Merb.available_mime_types.has_key?(@_content_type)
-        headers['Content-Type'] = Merb.available_mime_types[@_content_type].first
-      end
-      @_content_type
-    end
-    
-    # Sets the output content_type for this request.  Normally you
-    # should use +provides+, +does_not_provide+ and +only_provides+
-    # and then let the content negotiation process determine the proper
-    # content_type.  However, in some circumstances you may want to
-    # set it directly, or override what content negotiation picks.
-    def content_type=(new_type)
-      @_content_type = new_type
-    end
-
-    private
-    
-    def raise_if_content_type_already_set!
-      raise "Cannot modify provided_formats because content_type has already been set" if content_type_set?
-    end
-
-    module Rest
-      
-      TYPES = {}
-      RESPONSE_HEADERS = Hash.new([])
-      TRANSFORM_METHODS = {}
-      TRANSFORM_METHOD_DEFAULTS = {}
-
-      class Responder
-      
-        protected
-          
-          def self.parse(accept_header)
-            # parse the raw accept header into a unique, sorted array of AcceptType objects
-            list = accept_header.to_s.split(/,/).enum_for(:each_with_index).map do |entry,index|
-              AcceptType.new(entry,index += 1)
-            end.sort.uniq
-            # firefox (and possibly other browsers) send broken default accept headers.
-            # fix them up by sorting alternate xml forms (namely application/xhtml+xml)
-            # ahead of pure xml types (application/xml,text/xml).
-            if app_xml = list.detect{|e| e.super_range == 'application/xml'}
-              list.select{|e| e.to_s =~ /\+xml/}.each { |acc_type|
-                list[list.index(acc_type)],list[list.index(app_xml)] = 
-                  list[list.index(app_xml)],list[list.index(acc_type)] }
-            end
-            list
-          end
-          
-      end
-
-      class AcceptType
-
-        attr_reader :media_range, :quality, :index, :type, :sub_type
-        
-        def initialize(entry,index)
-          @index = index
-          @media_range, quality = entry.split(/;\s*q=/).map{|a| a.strip }
-          @type, @sub_type = @media_range.split(/\//)
-          quality ||= 0.0 if @media_range == '*/*'
-          @quality = ((quality || 1.0).to_f * 100).to_i
-        end
-      
-        def <=>(entry)
-          c = entry.quality <=> quality
-          c = index <=> entry.index if c == 0
-          c
-        end
-      
-        def eql?(entry)
-          synonyms.include?(entry.media_range)
-        end
-      
-        def ==(entry); eql?(entry); end
-      
-        def hash; super_range.hash; end
-      
-        def synonyms
-          @syns ||= TYPES.values.select{|e| e.include?(@media_range)}.flatten
-        end
-      
-        def super_range
-          synonyms.first || @media_range
-        end
-      
-        def to_sym
-          TYPES.select{|k,v| 
-            v == synonyms || v[0] == synonyms[0]}.flatten.first
-        end
-      
-        def to_s
-          @media_range
-        end
-      
-      end
-      
-    end
-
-  end
-  reset_default_mime_types!
-  
-end

data/lib/merb/mixins/view_context.rb

@@ -1,558 +0,0 @@
-module Merb
-  # The ViewContextMixin module provides a number of helper methods to views for
-  # linking to assets and other pages, dealing with JavaScript, and caching.
-  module ViewContextMixin
-    
-    include Merb::Assets::AssetHelpers
-    
-    # :section: Accessing Assets
-    # Merb provides views with convenience methods for links images and other assets.
-    
-    # Creates a link for the URL given in +url+ with the text in +name+; HTML options are given in the +opts+
-    # hash.
-    #
-    # ==== Options
-    # The +opts+ hash is used to set HTML attributes on the tag.
-    #    
-    # ==== Examples
-    #   link_to("The Merb home page", "http://www.merbivore.com/")
-    #   # => <a href="http://www.merbivore.com/">The Merb home page</a>
-    #
-    #   link_to("The Ruby home page", "http://www.ruby-lang.org", {'class' => 'special', 'target' => 'blank'})
-    #   # => <a href="http://www.ruby-lang.org" class="special" target="blank">The Ruby home page</a>
-    #
-    #   link_to p.title, "/blog/show/#{p.id}"
-    #   # => <a href="blog/show/13">The Entry Title</a>
-    #
-    def link_to(name, url='', opts={})
-      opts[:href] ||= url
-      %{<a #{ opts.to_xml_attributes }>#{name}</a>}
-    end
-  
-    # Creates an image tag with the +src+ attribute set to the +img+ argument.  The path
-    # prefix defaults to <tt>/images/</tt>.  The path prefix can be overriden by setting a +:path+
-    # parameter in the +opts+ hash.  The rest of the +opts+ hash sets HTML attributes.
-    #
-    # ==== Options
-    # path:: Sets the path prefix for the image (defaults to +/images/+)
-    # 
-    # All other options in +opts+ set HTML attributes on the tag.
-    #
-    # ==== Examples
-    #   image_tag('foo.gif') 
-    #   # => <img src='/images/foo.gif' />
-    #   
-    #   image_tag('foo.gif', :class => 'bar') 
-    #   # => <img src='/images/foo.gif' class='bar' />
-    #
-    #   image_tag('foo.gif', :path => '/files/') 
-    #   # => <img src='/files/foo.gif' />
-    #
-    #   image_tag('http://test.com/foo.gif')
-    #   # => <img src="http://test.com/foo.gif">
-    def image_tag(img, opts={})
-      opts[:path] ||= 
-        if img =~ %r{^https?://}
-          ''
-        else
-          if Merb::Config[:path_prefix]
-            Merb::Config[:path_prefix] + '/images/'
-          else
-            '/images/'
-          end
-        end
-      opts[:src] ||= opts.delete(:path) + img
-      %{<img #{ opts.to_xml_attributes } />}    
-    end
-
-    # :section: JavaScript related functions
-    #
-    
-    # Escapes text for use in JavaScript, replacing unsafe strings with their
-    # escaped equivalent.
-    #
-    # ==== Examples
-    #   escape_js("'Lorem ipsum!' -- Some guy")
-    #   # => "\\'Lorem ipsum!\\' -- Some guy"
-    #
-    #   escape_js("Please keep text\nlines as skinny\nas possible.")
-    #   # => "Please keep text\\nlines as skinny\\nas possible."
-    def escape_js(javascript)
-      (javascript || '').gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
-    end
-    
-    # Creates a link tag with the text in +name+ and the <tt>onClick</tt> handler set to a JavaScript 
-    # string in +function+.
-    #
-    # ==== Examples
-    #   link_to_function('Click me', "alert('hi!')")
-    #   # => <a href="#" onclick="alert('hi!'); return false;">Click me</a>
-    #
-    #   link_to_function('Add to cart', "item_total += 1; alert('Item added!');")
-    #   # => <a href="#" onclick="item_total += 1; alert('Item added!'); return false;">Add to cart</a>
-    #   
-    def link_to_function(name, function)
-      %{<a href="#" onclick="#{function}; return false;">#{name}</a>}
-    end
-    
-    # The js method simply calls +to_json+ on an object in +data+; if the object
-    # does not implement a +to_json+ method, then it calls +to_json+ on 
-    # +data.inspect+.
-    #
-    # ==== Examples
-    #   js({'user' => 'Lewis', 'page' => 'home'})
-    #   # => "{\"user\":\"Lewis\",\"page\":\"home\"}"
-    #
-    #   my_array = [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-    #   js(my_array)
-    #   # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
-    #
-    def js(data)
-      if data.respond_to? :to_json
-        data.to_json
-      else
-        data.inspect.to_json
-      end
-    end
-      
-    # :section: External JavaScript and Stylesheets
-    #
-    # You can use require_js(:prototype) or require_css(:shinystyles)
-    # from any view or layout, and the scripts will only be included once
-    # in the head of the final page. To get this effect, the head of your layout you will
-    # need to include a call to include_required_js and include_required_css.
-    #
-    # ==== Examples
-    #   # File: app/views/layouts/application.html.erb
-    #
-    #   <html>
-    #     <head>
-    #       <%= include_required_js %>
-    #       <%= include_required_css %>
-    #     </head>
-    #     <body>
-    #       <%= catch_content :layout %>
-    #     </body>
-    #   </html>
-    # 
-    #   # File: app/views/whatever/_part1.herb
-    #
-    #   <% require_js  'this' -%>
-    #   <% require_css 'that', 'another_one' -%>
-    # 
-    #   # File: app/views/whatever/_part2.herb
-    #
-    #   <% require_js 'this', 'something_else' -%>
-    #   <% require_css 'that' -%>
-    #
-    #   # File: app/views/whatever/index.herb
-    #
-    #   <%= partial(:part1) %>
-    #   <%= partial(:part2) %>
-    #
-    #   # Will generate the following in the final page...
-    #   <html>
-    #     <head>
-    #       <script src="/javascripts/this.js" type="text/javascript"></script>
-    #       <script src="/javascripts/something_else.js" type="text/javascript"></script>
-    #       <link href="/stylesheets/that.css" media="all" rel="Stylesheet" type="text/css"/>
-    #       <link href="/stylesheets/another_one.css" media="all" rel="Stylesheet" type="text/css"/>
-    #     </head>
-    #     .
-    #     .
-    #     .
-    #   </html>
-    #
-    # See each method's documentation for more information.
-    
-    # :section: Bundling Asset Files
-    # 
-    # The key to making a fast web application is to reduce both the amount of
-    # data transfered and the number of client-server interactions. While having
-    # many small, module Javascript or stylesheet files aids in the development
-    # process, your web application will benefit from bundling those assets in
-    # the production environment.
-    # 
-    # An asset bundle is a set of asset files which are combined into a single
-    # file. This reduces the number of requests required to render a page, and
-    # can reduce the amount of data transfer required if you're using gzip
-    # encoding.
-    # 
-    # Asset bundling is always enabled in production mode, and can be optionally
-    # enabled in all environments by setting the <tt>:bundle_assets</tt> value
-    # in <tt>config/merb.yml</tt> to +true+.
-    # 
-    # ==== Examples
-    # 
-    # In the development environment, this:
-    # 
-    #   js_include_tag :prototype, :lowpro, :bundle => true
-    # 
-    # will produce two <script> elements. In the production mode, however, the
-    # two files will be concatenated in the order given into a single file,
-    # <tt>all.js</tt>, in the <tt>public/javascripts</tt> directory.
-    # 
-    # To specify a different bundle name:
-    # 
-    #   css_include_tag :typography, :whitespace, :bundle => :base
-    #   css_include_tag :header, :footer, :bundle => "content"
-    #   css_include_tag :lightbox, :images, :bundle => "lb.css"
-    # 
-    # (<tt>base.css</tt>, <tt>content.css</tt>, and <tt>lb.css</tt> will all be
-    # created in the <tt>public/stylesheets</tt> directory.)
-    # 
-    # == Callbacks
-    # 
-    # To use a Javascript or CSS compressor, like JSMin or YUI Compressor:
-    # 
-    #   Merb::Assets::JavascriptAssetBundler.add_callback do |filename|
-    #     system("/usr/local/bin/yui-compress #{filename}")
-    #   end
-    #   
-    #   Merb::Assets::StylesheetAssetBundler.add_callback do |filename|
-    #     system("/usr/local/bin/css-min #{filename}")
-    #   end
-    # 
-    # These blocks will be run after a bundle is created.
-    # 
-    # == Bundling Required Assets
-    # 
-    # Combining the +require_css+ and +require_js+ helpers with bundling can be
-    # problematic. You may want to separate out the common assets for your
-    # application -- Javascript frameworks, common CSS, etc. -- and bundle those
-    # in a "base" bundle. Then, for each section of your site, bundle the
-    # required assets into a section-specific bundle.
-    # 
-    # <b>N.B.: If you bundle an inconsistent set of assets with the same name,
-    # you will have inconsistent results. Be thorough and test often.</b>
-    # 
-    # ==== Example
-    # 
-    # In your application layout:
-    # 
-    #   js_include_tag :prototype, :lowpro, :bundle => :base
-    # 
-    # In your controller layout:
-    # 
-    #   require_js :bundle => :posts
-    
-    # The require_js method can be used to require any JavaScript
-    # file anywhere in your templates. Regardless of how many times
-    # a single script is included with require_js, Merb will only include
-    # it once in the header.
-    #
-    # ==== Examples
-    #   <% require_js 'jquery' %>
-    #   # A subsequent call to include_required_js will render...
-    #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
-    #
-    #   <% require_js 'jquery', 'effects' %>
-    #   # A subsequent call to include_required_js will render...
-    #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
-    #   #    <script src="/javascripts/effects.js" type="text/javascript"></script>
-    #
-    def require_js(*js)
-      @required_js ||= []
-      @required_js |= js
-    end
-    
-    # The require_css method can be used to require any CSS
-    # file anywhere in your templates. Regardless of how many times
-    # a single stylesheet is included with require_css, Merb will only include
-    # it once in the header.
-    #
-    # ==== Examples
-    #   <% require_css('style') %>
-    #   # A subsequent call to include_required_css will render...
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
-    #
-    #   <% require_css('style', 'ie-specific') %>
-    #   # A subsequent call to include_required_css will render...
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
-    #   #    <link href="/stylesheets/ie-specific.css" media="all" rel="Stylesheet" type="text/css"/>
-    #
-    def require_css(*css)
-      @required_css ||= []
-      @required_css |= css
-    end
-    
-    # A method used in the layout of an application to create +<script>+ tags to include JavaScripts required in 
-    # in templates and subtemplates using require_js.
-    # 
-    # ==== Options
-    # bundle::  The name of the bundle the scripts should be combined into.
-    #           If +nil+ or +false+, the bundle is not created. If +true+, a
-    #           bundle named <tt>all.js</tt> is created. Otherwise,
-    #           <tt>:bundle</tt> is treated as an asset name.
-    # 
-    # ==== Examples
-    #   # my_action.herb has a call to require_js 'jquery'
-    #   # File: layout/application.html.erb
-    #   include_required_js
-    #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
-    #
-    #   # my_action.herb has a call to require_js 'jquery', 'effects', 'validation'
-    #   # File: layout/application.html.erb
-    #   include_required_js
-    #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
-    #   #    <script src="/javascripts/effects.js" type="text/javascript"></script>
-    #   #    <script src="/javascripts/validation.js" type="text/javascript"></script>
-    #
-    def include_required_js(options = {})
-      return '' if @required_js.nil?
-      js_include_tag(*(@required_js + [options]))
-    end
-    
-    # A method used in the layout of an application to create +<link>+ tags for CSS stylesheets required in 
-    # in templates and subtemplates using require_css.
-    # 
-    # ==== Options
-    # bundle::  The name of the bundle the stylesheets should be combined into.
-    #           If +nil+ or +false+, the bundle is not created. If +true+, a
-    #           bundle named <tt>all.css</tt> is created. Otherwise,
-    #           <tt>:bundle</tt> is treated as an asset name.
-    # 
-    # ==== Examples
-    #   # my_action.herb has a call to require_css 'style'
-    #   # File: layout/application.html.erb
-    #   include_required_css
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
-    #
-    #   # my_action.herb has a call to require_js 'style', 'ie-specific'
-    #   # File: layout/application.html.erb
-    #   include_required_css
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
-    #   #    <link href="/stylesheets/ie-specific.css" media="all" rel="Stylesheet" type="text/css"/>
-    #
-    def include_required_css(options = {})
-      return '' if @required_css.nil?
-      css_include_tag(*(@required_css + [options]))
-    end
-    
-    # The js_include_tag method will create a JavaScript 
-    # +<include>+ tag for each script named in the arguments, appending
-    # '.js' if it is left out of the call.
-    # 
-    # ==== Options
-    # bundle::  The name of the bundle the scripts should be combined into.
-    #           If +nil+ or +false+, the bundle is not created. If +true+, a
-    #           bundle named <tt>all.js</tt> is created. Otherwise,
-    #           <tt>:bundle</tt> is treated as an asset name.
-    # 
-    # ==== Examples
-    #   js_include_tag 'jquery'
-    #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
-    #
-    #   js_include_tag 'moofx.js', 'upload'
-    #   # => <script src="/javascripts/moofx.js" type="text/javascript"></script>
-    #   #    <script src="/javascripts/upload.js" type="text/javascript"></script>
-    #
-    #   js_include_tag :effects
-    #   # => <script src="/javascripts/effects.js" type="text/javascript"></script>
-    #
-    #   js_include_tag :jquery, :validation
-    #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
-    #   #    <script src="/javascripts/validation.js" type="text/javascript"></script>
-    #
-    def js_include_tag(*scripts)
-      options = scripts.last.is_a?(Hash) ? scripts.pop : {}
-      return nil if scripts.empty?
-      
-      if (bundle_name = options[:bundle]) && Merb::Assets.bundle? && scripts.size > 1
-        bundler = Merb::Assets::JavascriptAssetBundler.new(bundle_name, *scripts)
-        bundled_asset = bundler.bundle!
-        return js_include_tag(bundled_asset)
-      end
-
-      tags = ""
-
-      for script in scripts
-        attrs = {
-          :src => asset_path(:javascript, script),
-          :type => "text/javascript"
-        }
-        tags << %Q{<script #{attrs.to_xml_attributes}>//</script>}
-      end
-
-      return tags
-    end
-    
-    # The css_include_tag method will create a CSS stylesheet 
-    # +<link>+ tag for each stylesheet named in the arguments, appending
-    # '.css' if it is left out of the call.
-    # 
-    # ==== Options
-    # bundle::  The name of the bundle the stylesheets should be combined into.
-    #           If +nil+ or +false+, the bundle is not created. If +true+, a
-    #           bundle named <tt>all.css</tt> is created. Otherwise,
-    #           <tt>:bundle</tt> is treated as an asset name.
-    # media::   The media attribute for the generated link element. Defaults
-    #           to <tt>:all</tt>.
-    #
-    # ==== Examples
-    #   css_include_tag 'style'
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
-    #
-    #   css_include_tag 'style.css', 'layout'
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
-    #   #    <link href="/stylesheets/layout.css" media="all" rel="Stylesheet" type="text/css" />
-    #
-    #   css_include_tag :menu
-    #   # => <link href="/stylesheets/menu.css" media="all" rel="Stylesheet" type="text/css" />
-    #
-    #   css_include_tag :style, :screen
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
-    #   #    <link href="/stylesheets/screen.css" media="all" rel="Stylesheet" type="text/css" />
-    # 
-    #  css_include_tag :style, :media => :print
-    #  # => <link href="/stylesheets/style.css" media="print" rel="Stylesheet" type="text/css" />
-    def css_include_tag(*stylesheets)
-      options = stylesheets.last.is_a?(Hash) ? stylesheets.pop : {}
-      return nil if stylesheets.empty?
-      
-      if (bundle_name = options[:bundle]) && Merb::Assets.bundle? && stylesheets.size > 1
-        bundler = Merb::Assets::StylesheetAssetBundler.new(bundle_name, *stylesheets)
-        bundled_asset = bundler.bundle!
-        return css_include_tag(bundled_asset)
-      end
-
-      tags = ""
-
-      for stylesheet in stylesheets
-        attrs = {
-          :href => asset_path(:stylesheet, stylesheet),
-          :type => "text/css",
-          :rel => "Stylesheet",
-          :media => options[:media] || :all
-        }
-        tags << %Q{<link #{attrs.to_xml_attributes} />}
-      end
-
-      return tags
-    end
-    
-    # :section: Caching
-    # ViewContextMixin provides views with fragment caching facilities.
-    
-    # The cache method is a simple helper method
-    # for caching template fragments.  The value of the supplied
-    # block is stored in the cache and identified by the string
-    # in the +name+ argument.
-    #
-    # ==== Example
-    #   <h1>Article list</h1>
-    #
-    #   <% cache(:article_list) do %>
-    #     <ul>
-    #     <% @articles.each do |a| %>
-    #       <li><%= a.title %></li>
-    #     <% end %>
-    #     </ul>
-    #   <% end %>
-    #
-    # See the documentation for Merb::Caching::Fragment for more
-    # information.
-    #
-    def cache(name, &block)
-      return block.call unless caching_enabled?
-      buffer = eval("_buf", block.binding)
-      if fragment = ::Merb::Caching::Fragment.get(name)
-        buffer.concat(fragment)
-      else
-        pos = buffer.length
-        block.call
-        ::Merb::Caching::Fragment.put(name, buffer[pos..-1])
-      end
-    end
-  
-    # Calling throw_content stores the block of markup for later use.
-    # Subsequently, you can make calls to it by name with <tt>catch_content</tt>
-    # in another template or in the layout. 
-    # 
-    # Example:
-    # 
-    #   <% throw_content :header do %>
-    #     alert('hello world')
-    #   <% end %>
-    #
-    # You can use catch_content :header anywhere in your templates.
-    #
-    #   <%= catch_content :header %>
-    #
-    # You may find that you have trouble using thrown content inside a helper method
-    # There are a couple of mechanisms to get around this.
-    # 
-    # 1. Pass the content in as a string instead of a block
-    # 
-    # Example: 
-    #  
-    #   throw_content(:header, "Hello World")
-    #
-    def throw_content(name, content = "", &block)
-      content << capture(&block) if block_given?
-      controller.thrown_content[name] << content
-    end
-    
-    # Concat will concatenate text directly to the buffer of the template.
-    # The binding must be supplied in order to obtian the buffer.  This can be called directly in the 
-    # template as 
-    # concat( "text", binding )
-    #
-    # or from a helper method that accepts a block as
-    # concat( "text", block.binding )
-    def concat( string, binding )
-      _buffer( binding ) << string
-    end
-    
-    # Creates a generic HTML tag. You can invoke it a variety of ways.
-    #   
-    #   tag :div
-    #   # <div></div>
-    #   
-    #   tag :div, 'content'
-    #   # <div>content</div>
-    #   
-    #   tag :div, :class => 'class'
-    #   # <div class="class"></div>
-    #   
-    #   tag :div, 'content', :class => 'class'
-    #   # <div class="class">content</div>
-    #   
-    #   tag :div do
-    #     'content'
-    #   end
-    #   # <div>content</div>
-    #   
-    #   tag :div, :class => 'class' do
-    #     'content'
-    #   end
-    #   # <div class="class">content</div>
-    # 
-    def tag(name, contents = nil, attrs = {}, &block)
-      attrs = contents if contents.is_a?(Hash)
-      contents = capture(&block) if block_given?
-      open_tag(name, attrs) + contents.to_s + close_tag(name)
-    end
-    
-    # Creates the opening tag with attributes for the provided +name+
-    # attrs is a hash where all members will be mapped to key="value"
-    #
-    # Note: This tag will need to be closed
-    def open_tag(name, attrs = nil)
-      "<#{name}#{' ' + attrs.to_html_attributes if attrs && !attrs.empty?}>"
-    end
-    
-    # Creates a closing tag
-    def close_tag(name)
-      "</#{name}>"
-    end
-    
-    # Creates a self closing tag.  Like <br/> or <img src="..."/>
-    #
-    # +name+ : the name of the tag to create
-    # +attrs+ : a hash where all members will be mapped to key="value"
-    def self_closing_tag(name, attrs = nil)
-      "<#{name}#{' ' + attrs.to_html_attributes if attrs && !attrs.empty?}/>"
-    end
-  end
-end