wycats-merb-core 0.9.8 → 0.9.9

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

@@ -7,6 +7,10 @@ module Merb
       ResponderMixin::TYPES
     end
 
+    def available_accepts
+      ResponderMixin::MIMES
+    end
+
     # Any specific outgoing headers should be included here.  These are not
     # the content-type header but anything in addition to it.
     # +transform_method+ should be set to a symbol of the method used to

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

@@ -62,6 +62,7 @@ module Merb
     # ==== Parameters
     # data<String>:: a chunk of data to return.
     def send_chunk(data)
+      only_runs_on_mongrel!
       @response.write('%x' % data.size + "\r\n")
       @response.write(data + "\r\n")
     end
@@ -76,12 +77,8 @@ module Merb
     #   A block that Mongrel can call later, allowing Merb to release the
     #   thread lock and render another request.
     def render_deferred(&blk)
-      must_support_streaming!
       Proc.new {|response|
-        result = blk.call
-        response.send_status(result.length)
-        response.send_header
-        response.write(result)
+        response.write(blk.call)
       }
     end
     
@@ -96,10 +93,7 @@ module Merb
     # Proc::
     #   A block that Mongrel can call after returning the string to the user.
     def render_then_call(str, &blk)
-      must_support_streaming!
       Proc.new {|response|
-        response.send_status(str.length)
-        response.send_header
         response.write(str)
         blk.call        
       }      
@@ -166,7 +160,13 @@ module Merb
         'Content-Disposition'       => disposition,
         'Content-Transfer-Encoding' => 'binary'
       )
-      File.open(file, 'rb')
+      Proc.new {|response|
+        file = File.open(file, 'rb')
+        while chunk = file.read(16384)
+          response.write chunk
+        end  
+        file.close
+      }
     end
     
     # Send binary data over HTTP to the user as a file download. May set content type,
@@ -217,7 +217,6 @@ module Merb
     #     end
     #   end
     def stream_file(opts={}, &stream)
-      must_support_streaming!
       opts.update(Merb::Const::DEFAULT_SEND_FILE_OPTIONS.merge(opts))
       disposition = opts[:disposition].dup || 'attachment'
       disposition << %(; filename="#{opts[:filename]}")
@@ -229,8 +228,6 @@ module Merb
         'CONTENT-LENGTH'            => opts[:content_length].to_s
       )
       Proc.new{|response|
-        response.send_status(opts[:content_length])
-        response.send_header
         stream.call(response)
       }
     end
@@ -306,13 +303,13 @@ module Merb
     alias escape_html escape_xml
     
     private
-      # Checks whether streaming is supported by the current Rack adapter.
+      # Marks an output method that only runs on the mongrel webserver.
       #
       # ==== Raises
-      # NotImplemented:: The Rack adapter doens't support streaming.
-      def must_support_streaming!
-        unless request.env['rack.streaming']
-          raise(Merb::ControllerExceptions::NotImplemented, "Current Rack adapter does not support streaming")
+      # NotImplemented:: The Rack adapter is not mongrel.
+      def only_runs_on_mongrel!
+        unless Merb::Config[:log_stream] == 'mongrel'
+          raise(Merb::ControllerExceptions::NotImplemented, "Current Rack adapter is not mongrel. cannot support this feature")
         end
       end
   end

data/lib/merb-core/controller/mixins/render.rb

@@ -268,17 +268,6 @@ module Merb::RenderMixin
   #
   # In this case, "one" will be available in the partial through the local
   # variable named +number+.
-  #
-  # ==== Notes
-  # It is important to note that the object being passed to the partial
-  # as well as any extra local variables cannot use names of helper methods
-  # since any helper method of the same name will take precedence over the
-  # passed variable. Example:
-  #
-  #   partial :bar, :with => "one", :as => :partial
-  #
-  # In this case, "one" will not be available in the partial because "partial"
-  # is already a helper method.
   def partial(template, opts={})
 
     # partial :foo becomes "#{controller_name}/_foo"
@@ -290,32 +279,36 @@ module Merb::RenderMixin
       kontroller = (m = template.match(/.*(?=\/)/)) ? m[0] : controller_name
       template = "_#{File.basename(template)}"
     end
-    template_method, template_location = 
-      _template_for(template, opts.delete(:format) || content_type, kontroller, template_path)
 
-    (@_old_partial_locals ||= []).push @_merb_partial_locals
-    
     # This handles no :with as well
     with = [opts.delete(:with)].flatten
-    as = opts.delete(:as) || template_location.match(%r[.*/_([^\.]*)])[1]
-    
-    @_merb_partial_locals = opts.merge(:collection_index => -1, :collection_size => with.size)
+    as = (opts.delete(:as) || template.match(%r[(?:.*/)?_([^\./]*)])[1]).to_sym
+
+    # Ensure that as is in the locals hash even if it isn't passed in here
+    # so that it's included in the preamble. 
+    locals = opts.merge(:collection_index => -1, :collection_size => with.size, as => opts[as])
+    template_method, template_location = _template_for(
+      template, 
+      opts.delete(:format) || content_type, 
+      kontroller, 
+      template_path, 
+      locals.keys)
     
     # this handles an edge-case where the name of the partial is _foo.* and your opts
     # have :foo as a key.
-    named_local = @_merb_partial_locals.key?(as.to_sym)
+    named_local = opts.key?(as)
     
     sent_template = with.map do |temp|
-      @_merb_partial_locals[as.to_sym] = temp unless named_local
+      locals[as] = temp unless named_local
+
       if template_method && self.respond_to?(template_method)
-        @_merb_partial_locals[:collection_index] += 1
-        send(template_method)
+        locals[:collection_index] += 1
+        send(template_method, locals)
       else
         raise TemplateNotFound, "Could not find template at #{template_location}.*"
       end
     end.join
     
-    @_merb_partial_locals = @_old_partial_locals.pop
     sent_template
   end
 
@@ -382,6 +375,7 @@ module Merb::RenderMixin
   # context<Object>:: The controller action or template (basename or absolute path).
   # content_type<~to_s>:: The content type (like html or json).
   # controller<~to_s>:: The name of the controller. Defaults to nil.
+  # locals<Array[Symbol]>:: A list of locals to assign from the args passed into the compiled template.
   #
   # ==== Options (opts)
   # :template<String>::
@@ -391,13 +385,13 @@ module Merb::RenderMixin
   # ==== Returns
   # Array[Symbol, String]::
   #   A pair consisting of the template method and location.
-  def _template_for(context, content_type, controller=nil, template=nil)
+  def _template_for(context, content_type, controller=nil, template=nil, locals=[])
     template_method, template_location = nil, nil
 
     # absolute path to a template (:template => "/foo/bar")
     if template.is_a?(String) && template =~ %r{^/}
       template_location = self._absolute_template_location(template, content_type)
-      return [_template_method_for(template_location), template_location]
+      return [_template_method_for(template_location, locals), template_location]
     end
 
     self.class._template_roots.reverse_each do |root, template_meth|
@@ -409,7 +403,7 @@ module Merb::RenderMixin
         template_location = root / self.send(template_meth, context, content_type, controller)
       end
       
-      break if template_method = _template_method_for(template_location.to_s)
+      break if template_method = _template_method_for(template_location.to_s, locals)
     end
 
     # template_location is a Pathname
@@ -421,11 +415,12 @@ module Merb::RenderMixin
   #
   # ==== Parameters
   # template_location<String>:: The phyical path of the template
+  # locals<Array[Symbol]>:: A list of locals to assign from the args passed into the compiled template.
   #
   # ==== Returns
   # String:: The method, if it exists. Otherwise return nil.
-  def _template_method_for(template_location)
-    meth = Merb::Template.template_for(template_location)
+  def _template_method_for(template_location, locals)
+    meth = Merb::Template.template_for(template_location, [], locals)
     meth && self.respond_to?(meth) ? meth : nil
   end
 

data/lib/merb-core/controller/mixins/responder.rb

@@ -1,6 +1,5 @@
 require 'enumerator'
 require 'merb-core/controller/mime'
-require "merb-core/vendor/facets/dictionary"
 
 module Merb
   # The ResponderMixin adds methods that help you manage what

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

@@ -3,9 +3,10 @@ end
 
 module Merb::Template
   
-  EXTENSIONS  = {} unless defined?(EXTENSIONS)
-  METHOD_LIST = {} unless defined?(METHOD_LIST)
-  MTIMES      = {} unless defined?(MTIMES)
+  EXTENSIONS            = {} unless defined?(EXTENSIONS)
+  METHOD_LIST           = {} unless defined?(METHOD_LIST)
+  SUPPORTED_LOCALS_LIST = Hash.new([].freeze) unless defined?(SUPPORTED_LOCALS_LIST)
+  MTIMES                = {} unless defined?(MTIMES)
   
   class << self
     # Get the template's method name from a full path. This replaces
@@ -55,26 +56,37 @@ module Merb::Template
     # ==== Parameters
     # path<String>:: A full path to find a template method for.
     # template_stack<Array>:: The template stack. Not used.
+    # locals<Array[Symbol]>:: The names of local variables
     #
     # ==== Returns
     # <String>:: name of the method that inlines the template.
     #---
     # @semipublic
-    def template_for(path, template_stack = [])
+    def template_for(path, template_stack = [], locals=[])
       path = File.expand_path(path)
       
-      ret = 
-      if Merb::Config[:reload_templates]
+      if needs_compilation?(path, locals)
         file = Dir["#{path}.{#{template_extensions.join(',')}}"].first
-        METHOD_LIST[path] = file ? inline_template(load_template_io(file)) : nil
-      else
-        METHOD_LIST[path] ||= begin
-          file = Dir["#{path}.{#{template_extensions.join(',')}}"].first          
-          file ? inline_template(load_template_io(file)) : nil
-        end
+        METHOD_LIST[path] = file ? inline_template(load_template_io(file), locals) : nil
       end
       
-      ret
+      METHOD_LIST[path]
+    end
+    
+    # Decide if a template needs to be re/compiled.
+    #
+    # ==== Parameters
+    # path<String>:: The full path of the template to check support for.
+    # locals<Array[Symbol]>:: The list of locals that need to be supported
+    #
+    # ==== Returns
+    # Boolean:: Whether or not the template for the provided path needs to be recompiled
+    #---
+    def needs_compilation?(path, locals)
+      return true if Merb::Config[:reload_templates] || !METHOD_LIST[path]
+      
+      current_locals = SUPPORTED_LOCALS_LIST[path]
+      locals.any?{|local| !current_locals.include?(local)}
     end
     
     # Get all known template extensions
@@ -93,6 +105,9 @@ module Merb::Template
     # ==== Parameters
     # io<#path>::
     #   An IO that responds to #path (File or VirtualFile)
+    # locals<Array[Symbol]>::
+    #   A list of local names that should be assigned in the template method
+    #   from the arguments hash. Defaults to [].
     # mod<Module>::
     #   The module to put the compiled method into. Defaults to
     #   Merb::InlineTemplates
@@ -102,10 +117,14 @@ module Merb::Template
     # must be available to instances of AbstractController that will use it.
     #---
     # @public
-    def inline_template(io, mod = Merb::InlineTemplates)
-      path = File.expand_path(io.path)
-      ret = METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = 
-        engine_for(path).compile_template(io, template_name(path), mod)
+    def inline_template(io, locals=[], mod = Merb::InlineTemplates)
+      full_file_path = File.expand_path(io.path)
+      engine_neutral_path = full_file_path.gsub(/\.[^\.]*$/, "")
+      
+      SUPPORTED_LOCALS_LIST[engine_neutral_path] |= locals unless locals.empty?
+      ret = METHOD_LIST[engine_neutral_path] =
+        engine_for(full_file_path).compile_template(io, template_name(full_file_path), locals, mod)
+        
       io.close
       ret
     end
@@ -156,12 +175,17 @@ module Merb::Template
     # ==== Parameters
     # io<#path>:: An IO containing the full path of the template.
     # name<String>:: The name of the method that will be created.
+    # locals<Array[Symbol]>:: A list of locals to assign from the args passed into the compiled template.
     # mod<Module>:: The module that the compiled method will be placed into.
-    def self.compile_template(io, name, mod)
+    def self.compile_template(io, name, locals, mod)
       template = ::Erubis::BlockAwareEruby.new(io.read)
-
       _old_verbose, $VERBOSE = $VERBOSE, nil
-      template.def_method(mod, name, File.expand_path(io.path))
+      assigns = locals.inject([]) do |assigns, local|
+        assigns << "#{local} = _locals[#{local.inspect}]"
+      end.join(";")
+      
+      code = "def #{name}(_locals={}); #{assigns}; #{template.src}; end"
+      mod.module_eval code, File.expand_path(io.path)
       $VERBOSE = _old_verbose
       
       name

data/lib/merb-core/core_ext/kernel.rb

@@ -34,10 +34,13 @@ module Kernel
   # @param name<String> The name of the gem to load.
   # @param *ver<Gem::Requirement, Gem::Version, Array, #to_str>
   #   Version requirements to be passed to Gem::Dependency.new.
+  #   If the last argument is a Hash, extract the :immediate option,
+  #   forcing a dependency to load immediately.
   #
   # @return <Gem::Dependency> The dependency information.
   def dependency(name, *ver)
-    if Merb::BootLoader.finished?(Merb::BootLoader::Dependencies)
+    immediate = ver.last.is_a?(Hash) && ver.pop[:immediate]
+    if immediate || Merb::BootLoader.finished?(Merb::BootLoader::Dependencies)
       load_dependency(name, *ver)
     else
       track_dependency(name, *ver)
@@ -230,9 +233,11 @@ module Kernel
     else
       lines = File.read(file).split("\n")
       first_line = (f = line - size - 1) < 0 ? 0 : f
-      lines = lines[first_line, size * 2 + 1]
       
-      lines.each_with_index do |str, index|
+      old_lines = lines
+      lines = lines[first_line, size * 2 + 1]
+
+      lines && lines.each_with_index do |str, index|
         yield index + line - size, str.chomp
       end
     end

data/lib/merb-core/dispatch/default_exception/default_exception.rb

@@ -41,7 +41,7 @@ module Merb
         ret   << "  <tbody>"
         (arr || []).each_with_index do |(key, val), i|
           klass = i % 2 == 0 ? "even" : "odd"
-          ret << "    <tr class=#{klass}><td>#{key}</td><td>#{val.inspect}</td></tr>"
+          ret << "    <tr class=\"#{klass}\"><td>#{key}</td><td>#{val.inspect}</td></tr>"
         end
         if arr.blank?
           ret << "    <tr class='odd'><td colspan='2'>None</td></tr>"

data/lib/merb-core/dispatch/default_exception/views/_css.html.erb

@@ -1,3 +1,4 @@
+<% if Merb.env != "test" %>
 <style type="text/css" media="screen">
   body {
     font-family:arial;
@@ -195,4 +196,5 @@
     color:#444;
     text-align:right;
   }
-</style>
+</style>
+<% end %>

data/lib/merb-core/dispatch/default_exception/views/_javascript.html.erb

@@ -1,73 +1,77 @@
-<script type="text/javascript" charset="utf-8">
-  (function() {
-    els = document.getElementsByTagName('td');
-    var forEach = function(arr, fn) {
-      for(var i=0; i<arr.length; i++) {
-        var res = fn(arr[i]);
-        if(res === false) break;
-      }
-    }
-    var toggleClasses = function(node, first, second) {
-      var classes = node.className.split(" ");
-      var newClasses = [];
-      forEach(classes, function(k) {
-        if(k == first) newClasses.push(second);
-        else if(k == second) newClasses.push(first);
-        else newClasses.push(k);
-      });
-      node.className = newClasses.join(" ");
-    }
-    forEach(els, function(el) {
-      // swap the open & closed classes       
-      if(hasClass(el, "expand") || hasClass(el, "collapse")) {
-        el.onclick = function(e){
-          tbody = this.parentNode.parentNode;
-          toggleClasses(tbody, "open", "close");
-        }
-      }        
-    })
-    forEach(document.getElementsByTagName("h3"), function(el) {
-      el.onclick = function(e) {
-        var tag = this.nextSibling;
-        while(tag.nodeType != 1) tag = tag.nextSibling;
-        tag.style.display = tag.style.display == "none" ? "" : "none";
-      }        
-    })
-    function hasClass(node, matchClass) {
-      var classes = node.className.split(" ");
-      for(var i=0,className;className=classes[i];i++)
-        if(className == matchClass) return true;
-      return false;
-    }
-    var els = document.getElementsByTagName("p");
-    forEach(els, function(tag) {
-      if(tag.className != "options") return true;
-      var checkboxes = tag.getElementsByTagName("input");
-      forEach(checkboxes, function(box) {
-        if(window.navigator.userAgent.match(/Firefox/)) {
-          box.style.top = "3px";
+<% if Merb.env != "test" %>
+<script type="text/javascript">
+  //<![CDATA[
+    (function() {
+      els = document.getElementsByTagName('td');
+      var forEach = function(arr, fn) {
+        for(var i=0; i<arr.length; i++) {
+          var res = fn(arr[i]);
+          if(res === false) break;
         }
-      });
-      tag.getElementsByTagName("input")[0].onclick = function(e) {
+      }
+      var toggleClasses = function(node, first, second) {
+        var classes = node.className.split(" ");
+        var newClasses = [];
+        forEach(classes, function(k) {
+          if(k == first) newClasses.push(second);
+          else if(k == second) newClasses.push(first);
+          else newClasses.push(k);
+        });
+        node.className = newClasses.join(" ");
+      }
+      forEach(els, function(el) {
+        // swap the open & closed classes       
+        if(hasClass(el, "expand") || hasClass(el, "collapse")) {
+          el.onclick = function(e){
+            tbody = this.parentNode.parentNode;
+            toggleClasses(tbody, "open", "close");
+          }
+        }        
+      })
+      forEach(document.getElementsByTagName("h3"), function(el) {
+        el.onclick = function(e) {
+          var tag = this.nextSibling;
+          while(tag.nodeType != 1) tag = tag.nextSibling;
+          tag.style.display = tag.style.display == "none" ? "" : "none";
+        }        
+      })
+      function hasClass(node, matchClass) {
+        var classes = node.className.split(" ");
+        for(var i=0,className;className=classes[i];i++)
+          if(className == matchClass) return true;
+        return false;
+      }
+      var els = document.getElementsByTagName("p");
+      forEach(els, function(tag) {
+        if(tag.className != "options") return true;
+        var checkboxes = tag.getElementsByTagName("input");
         forEach(checkboxes, function(box) {
-          if(box == e.target) return true;
-          box.checked = e.target.checked;
-          toggleTraces(box, box);
-        })
-      };
-      var toggleTraces = function(box, target) {
-        var tbodies = tag.parentNode.getElementsByTagName("tbody");
-        forEach(tbodies, function(tbody) {
-          if(hasClass(tbody, target.parentNode.className)) {
-            if(target.checked) tbody.style.display = "";
-            else tbody.style.display = "none";
+          if(window.navigator.userAgent.match(/Firefox/)) {
+            box.style.top = "3px";
           }
+        });
+        tag.getElementsByTagName("input")[0].onclick = function(e) {
+          forEach(checkboxes, function(box) {
+            if(box == e.target) return true;
+            box.checked = e.target.checked;
+            toggleTraces(box, box);
+          })
+        };
+        var toggleTraces = function(box, target) {
+          var tbodies = tag.parentNode.getElementsByTagName("tbody");
+          forEach(tbodies, function(tbody) {
+            if(hasClass(tbody, target.parentNode.className)) {
+              if(target.checked) tbody.style.display = "";
+              else tbody.style.display = "none";
+            }
+          })
+        }
+        forEach(checkboxes, function(box) {
+          if(box == checkboxes[0]) return true;
+          box.onchange = function(e) { toggleTraces(box, e.target) }
         })
-      }
-      forEach(checkboxes, function(box) {
-        if(box == checkboxes[0]) return true;
-        box.onchange = function(e) { toggleTraces(box, e.target) }
       })
-    })
-  })();
+    })();
+  //]]>
 </script>
+<% end %>