merb 0.3.4 → 0.3.7

data/lib/merb/mixins/render_mixin.rb

@@ -1,57 +1,103 @@
 module Merb
 
   module RenderMixin
-    
+   
+    def self.included(base)
+      base.class_eval {        
+        class_inheritable_accessor :_template_root,
+                                   :_layout
+                                    
+        @@template_extensions = { }                           
+        self._layout = :application
+        self._template_root = File.expand_path(MERB_VIEW_ROOT)
+        # This method is called by templating-engines to register themselves with
+        # a list of extensions that will be looked up on #render of an action.
+        def self.register_engine(engine, *extensions)
+          [extensions].flatten.uniq.each do |ext|
+            @@template_extensions[ext] = engine
+          end  
+        end
+        
+      }
+    end
+
     # universal render method. Template handlers are registered
     # by template extension. So you can use the same render method
     # for any kind of template that implements an adapter module.
-    # out of the box Merb support Erubis, Markaby and Builder templates
+    # out of the box Merb support Erubis, Haml, Markaby and Builder templates
     #
     # Erubis template ext:  .herb .jerb .erb
     # Markaby template ext: .mab
     # Builder template ext: .rxml .builder .xerb 
+    # Haml template ext: .haml
     #
     # Examples:
     #
-    # render
-    # looks for views/controllername/actionname.* and renders
+    #   render
+    #
+    # Looks for views/controllername/actionname.* and renders
     # the template with the proper engine based on its file extension.
     #
-    # render :layout => :none
-    # renders the current template with no layout. XMl Builder templates
+    #   render :layout => :none
+    #
+    # Renders the current template with no layout. XMl Builder templates
     # are exempt from layout by default.
     # 
-    # render :action => 'foo'
-    # renders views/controllername/foo.*
+    #   render :action => 'foo'
+    #
+    # Renders views/controllername/foo.*
+    #
+    #   render :nothing => 200
     #
-    # render :nothing => 200
-    # renders nothing with a status of 200
+    # Renders nothing with a status of 200
     #
-    # render :template => 'shared/message'
-    # renders views/shared/message
+    #   render :template => 'shared/message'
     #
-    # render :js => "$('some-div').toggle();"
-    # if the right hand side of :js => is a string then the proper
+    # Renders views/shared/message
+    #
+    #   render :js => "$('some-div').toggle();"
+    #
+    # If the right hand side of :js => is a string then the proper
     # javascript headers will be set and the string will be returned 
     # verbatim as js.
     #
-    # render :js => :spinner
-    # when the rhs of :js => is a Symbol, it will be used as the 
+    #   render :js => :spinner
+    #
+    # When the rhs of :js => is a Symbol, it will be used as the 
     # action/template name so: views/controllername/spinner.jerb
     # will be rendered as javascript
     #
-    # render :js => true
-    # this will just look for the current controller/action tenmplate
+    #   render :js => true
+    #
+    # This will just look for the current controller/action template
     # with the .jerb extension and render it as javascript
     #
-    # render :xml => @posts.to_xml
-    # render :xml => "<foo><bar>Hi!</bar></foo>"
-    # this will set the appropriate xml headers and render the rhs
+    # XML can be rendered with the same options as Javascript.
+    #
+    #   render :xml => @posts.to_xml
+    #   render :xml => "<foo><bar>Hi!</bar></foo>"
+    #
+    # This will set the appropriate xml headers and render the rhs
     # of :xml => as a string. SO you can pass any xml string to this
     # to be rendered. 
     #
+    #   render :xml => :hello
+    #
+    # Renders the hello.xrb template for the current controller.
+    #
+    #   render :xml => true
+    #   render :xml => true, :action => "buffalo"
+    #
+    # Renders the buffalo.xerb template for the current controller.
+    #
     def render(opts={}, &blk)
-      action = opts[:action] || params[:action]
+      
+      action = if kind_of?(Merb::ControllerExceptions::Base)
+        self.class.name.snake_case.split('::').last
+      else
+        opts[:action] || params[:action]
+      end
+      
       opts[:layout] ||= _layout 
       
       case
@@ -70,23 +116,32 @@ module Merb
       when js = opts[:js]
         headers['Content-Type'] = "text/javascript"
         opts[:layout] = :none
-        if String === js
+        case js
+        when String
           return js
-        elsif Symbol === js
+        when Symbol
           template = find_template(:action => js, :ext => 'jerb')
-        else  
+        else
           template = find_template(:action => action, :ext => 'jerb')
         end
       when xml = opts[:xml]
         headers['Content-Type'] = 'application/xml'
         headers['Encoding']     = 'UTF-8'
-        return xml
+        # TODO This is the same as the js logic above. Can it be refactored?
+        case xml
+        when String
+          return xml
+        when Symbol
+          template = find_template(:action => xml, :ext => 'rxml,xerb,builder')
+        else
+          template = find_template(:action => action, :ext => 'rxml,xerb,builder')
+        end
       when template = opts[:template]
         template = find_template(:template => template)
       else          
         template = find_template(:action => action)
       end
-        
+
       engine = engine_for(template)
       options = {
         :file     => template,
@@ -101,16 +156,7 @@ module Merb
       end
     end
 
-    # this returns a ViewContext object populated with all
-    # the instance variables in your controller. This is used
-    # as the view context object for the Erubis templates.
-    def cached_view_context
-      @_view_context_cache ||= ViewContext.new(self)
-    end
-    
-    def clean_view_context
-      ViewContext.new(self)
-    end  
+ 
     
     # does a render with no layout. Also sets the
     # content type header to text/javascript. Use
@@ -124,10 +170,14 @@ module Merb
     # to 200. does send one ' ' space char, this is for
     # safari and flash uploaders to work.
     def render_nothing(status=200)
-      @status = status
+      @_status = status
       return " "
     end
 
+    def set_status(status)
+      @_status = status
+    end
+
     def render_no_layout(opts={})
       render opts.update({:layout => :none})
     end 
@@ -144,14 +194,32 @@ module Merb
     def partial(template, locals={})
       render :partial => template, :locals => locals
     end 
+
+    # +catch_content+ catches the thrown content from another template
+    # So when you throw_content(:foo) {...} you can catch_content :foo
+    # in another view or the layout.
+    def catch_content(name)
+      cached_view_context.instance_variable_get("@_#{name}_content")
+    end
     
     private
     
+      # this returns a ViewContext object populated with all
+      # the instance variables in your controller. This is used
+      # as the view context object for the Erubis templates.
+      def cached_view_context
+        @_view_context_cache ||= ViewContext.new(self)
+      end
+      
+      def clean_view_context
+        ViewContext.new(self)
+      end
+    
       def wrap_layout(content, opts={})
         if opts[:layout] != :application
           layout_choice = find_template(:layout => opts[:layout])
         else
-          if name = find_template(:layout => self.class.name.snake_case)
+          if name = find_template(:layout => self.class.name.snake_case.split('::').join('/'))
             layout_choice = name
           else
             layout_choice = find_template(:layout => :application)
@@ -172,14 +240,17 @@ module Merb
       def find_template(opts={})
         if template = opts[:template]
           path = _template_root / template
+        elsif opts[:action] and kind_of?(Merb::ControllerExceptions::Base)
+          path = _template_root / 'exceptions' / opts[:action]
         elsif action = opts[:action]
-          path = _template_root / self.class.name.snake_case / action
+          segment = self.class.name.snake_case.split('::').join('/')
+          path = _template_root / segment / action
         elsif _layout = opts[:layout]
-          path = _layout_root / _layout
+          path = _template_root / 'layout' / _layout
         else
           raise "called find_template without an :action or :layout"  
-        end        
-        extensions = [_template_extensions.keys].flatten.uniq
+        end
+        extensions = [@@template_extensions.keys].flatten.uniq
         glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
         Dir[glob].first
       end
@@ -190,12 +261,23 @@ module Merb
           template = t.pop
           path = _template_root / t.join('/') / "_#{template}"
         else  
-          path = _template_root  / self.class.name.snake_case / "_#{template}"
+          segment = self.class.name.snake_case.split('::').join('/')
+          path = _template_root  / segment / "_#{template}"
         end
-        extensions = [_template_extensions.keys].flatten.uniq
+        extensions = [@@template_extensions.keys].flatten.uniq
         glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
         Dir[glob].first
       end
     
+      # lookup the template_extensions for the extname of the filename
+      # you pass. Answers with the engine that matches the extension, Template::Erubis
+      # is used if none matches.
+      def engine_for(file)
+        extension = File.extname(file)[1..-1]
+        @@template_extensions[extension]
+      rescue
+        ::Merb::Template::Erubis
+      end
+      
   end  
 end

data/lib/merb/mixins/responder_mixin.rb

@@ -12,10 +12,10 @@ module Merb
   module ResponderMixin
     
     def respond_to(&block)
-      responder = Rest::Responder.new(@env['HTTP_ACCEPT'], params)
+      responder = Rest::Responder.new(request.env['HTTP_ACCEPT'], params)
       block.call(responder)
       responder.respond(headers)
-      @status = responder.status if responder.status
+      @_status = responder.status if responder.status
       responder.body
     end
 
@@ -57,9 +57,7 @@ module Merb
             headers['Content-Type'] = mime_type.super_range
             @body   = @stack[mime_type.to_sym].call
           else
-            headers['Content-Type'] = nil
-            @status = 406
-            @body   = nil
+            raise ControllerExceptions::NotAcceptable
           end
         end
         
@@ -84,7 +82,7 @@ module Merb
         private
         
           def negotiate_content
-            if @params['format']
+            if @params[:format]
               negotiate_by_format
             elsif (@stack.keys & @accepts.map(&:to_sym)).size > 0
               negotiate_by_accept_header
@@ -92,7 +90,7 @@ module Merb
           end
           
           def negotiate_by_format
-            format = @params['format'].to_sym
+            format = @params[:format].to_sym
             if @stack[format]
               if @accepts.map(&:to_sym).include?(format)
                 @accepts.detect{|a| a.to_sym == format }

data/lib/merb/mixins/view_context_mixin.rb

@@ -1,39 +1,96 @@
 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
-  
+    # :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={})
       %{<a href="#{url}" #{opts.map{|k,v| "#{k}=\"#{v}\""}.join(' ')}>#{name}</a>}
     end
   
-    # escape text for javascript.
+    # 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' />
+    #
+    def image_tag(img, opts={})
+      opts[:path] ||= '/images/'
+      %{<img src="#{opts.delete(:path) + img}" #{opts.map{|k,v| "#{k}=\"#{v}\""}.join(' ')} />}
+    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 an <a> tag with with an onclick containing
-    # a js function
-    # link_to_function('click me', "alert('hi!')")
+    # 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
     
-    # creates an <img> tag
-    # defaults to a src path prefix of /images/
-    #
-    # image_tag('foo.gif') => <img src='/images/foo.gif' />
-    # image_tag('foo.gif', :class => 'bar') => <img src='/images/foo.gif' class='bar' />
+    # 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+.
     #
-    # you can override the default path by sending a :path parameter in the opts
+    # ==== Examples
+    #   js({'user' => 'Lewis', 'page' => 'home'})
+    #   # => "{\"user\":\"Lewis\",\"page\":\"home\"}"
     #
-    # image_tag('foo.gif', :path => '/files/') => <img src='/files/foo.gif' />
+    #   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 image_tag(img, opts={})
-      opts[:path] ||= '/images/'
-      %{<img src="#{opts.delete(:path) + img}" #{opts.map{|k,v| "#{k}=\"#{v}\""}.join(' ')} />}
-    end
-    
-    # calls .to_json on data.
-    # so it can be faster than escape_js
     def js(data)
       if data.respond_to? :to_json
         data.to_json
@@ -41,117 +98,226 @@ module Merb
         data.inspect.to_json
       end
     end
-    
-    
-    # Helper method to cache a fragment. 
-    # <h1>Article list</h1>
+      
+    # :section: External JavaScript and Stylesheets
     #
-    # <% cache(:article_list) do %>
-    #   <ul>
-    #   <% @articles.each do |a| %>
-    #     <li><%= a.title %></li>
-    #   <% end %>
-    #   </ul>
-    # <% end %>
-
-    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
-    
-    # Requiring javascripts 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. In the head of your layout you will
-    # need to add these two tags:
-    #
-    # <%= include_required_js %>
-    # <%= include_required_css %>
-    #
-    # --app/views/layouts/application.rhtml
-    #
-    # <html>
-    #   <head>
-    #     <%= include_required_js %>
-    #     <%= include_required_css %>
-    #   </head>
-    #   <body>
-    #   <%= catch_content :layout %>
-    #   </body>
-    # </html>
-    # 
-    # --app/views/whatever/index.rhtml
+    # 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.herb
     #
-    # <%= partial(:part1) %>
-    # <%= partial(:part2) %>
+    #   <html>
+    #     <head>
+    #       <%= include_required_js %>
+    #       <%= include_required_css %>
+    #     </head>
+    #     <body>
+    #       <%= catch_content :layout %>
+    #     </body>
+    #   </html>
     # 
-    # --app/views/whatever/_part1.rhtml
+    #   # File: app/views/whatever/_part1.herb
     #
-    # <% require_js  'this' -%>
-    # <% require_css 'that', 'another_one' -%>
+    #   <% require_js  'this' -%>
+    #   <% require_css 'that', 'another_one' -%>
     # 
-    # --app/views/whatever/_part2.rhtml
+    #   # File: app/views/whatever/_part2.herb
     #
-    # <% require_js 'this', 'something_else' -%>
-    # <% require_css 'that' -%>
-    
+    #   <% 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.
     
-    # require_js(:myjs) can be used to require any javascript
-    # file anywhere in your templates. It will only include the
-    # javascript tag once in the header
+    # 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
     
-    # require_css(:mystyles) can be used to require any javascript
-    # file anywhere in your templates. It will only include the
-    # javascript tag once in the header
+    # The require_ccs 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
     
-    # this goes in the head of your layout if you will be using
-    # require_js
+    # 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.
+    #
+    # ==== Examples
+    #   # my_action.herb has a call to require_js 'jquery'
+    #   # File: layout/application.herb
+    #   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.herb
+    #   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
       js_include_tag(*@required_js)
     end
     
-    # this goes in the head of your layout if you will be using
-    # require_css 
+    # 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.
+    #
+    # ==== Examples
+    #   # my_action.herb has a call to require_css 'style'
+    #   # File: layout/application.herb
+    #   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.herb
+    #   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
-      css_link_tag(*@required_js)
+      css_link_tag(*@required_css)
     end
     
-    # js_include_tag(:foo, :bar, :baz) will create a javascript 
-    # include tag for each script in the arguments. It will append
+    # 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.
+    #
+    # ==== 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)
       return nil if scripts.empty?
-      scripts.inject('') do |memo,script|
+      include_tag = ""
+      scripts.each do |script|
         script = script.to_s
-        memo << %Q|<script src="/javascripts/#{script=~/\.js$/ ? script : script+'.js' }" type="text/javascript">//</script>\n|
+        include_tag << %Q|<script src="/javascripts/#{script=~/\.js$/ ? script : script+'.js' }" type="text/javascript">//</script>\n|
       end
+      include_tag
     end
     
-    # css_include_tag(:foo, :bar, :baz) will create a stylesheet  
-    # link tag for each stylesheet in the arguments. It will append
+    # 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.
+    #
+    # ==== 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"/>
+    #
     def css_include_tag(*scripts)
       return nil if scripts.empty?
-      scripts.inject('') do |memo,script|
+      include_tag = ""
+      scripts.each do |script|
         script = script.to_s
-        memo << %Q|<link href="/stylesheets/#{script=~/\.css$/ ? script : script+'.css' }" media="all" rel="Stylesheet" type="text/css"/>\n|
+        include_tag << %Q|<link href="/stylesheets/#{script=~/\.css$/ ? script : script+'.css' }" media="all" rel="Stylesheet" type="text/css"/>\n|
       end
+      include_tag
     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
   end  
-end
+end