merb 0.1.0 → 0.2.0

data/lib/merb/mixins/form_control_mixin.rb

@@ -19,6 +19,7 @@ module Merb
     # <%= control_for @post, :created_at, :time %>
     # <%= control_for @post, :published_at, :date %>
     #
+    # TODO : is this useful enough? Needs some love
     def control_for(obj, meth, type, opts={})
       instance = obj
       obj = obj.class

data/lib/merb/mixins/render_mixin.rb

@@ -1,32 +1,94 @@
 module Merb
 
   module RenderMixin
-    @@erbs = {}
-    @@mtimes = {}
     
-    def self.erbs
-      @@erbs
-    end  
-    
-    # shortcut to a template path based on name.
-    def template_dir(loc)
-      File.expand_path(MERB_ROOT / "/dist/app/views/#{loc}")
-    end  
-    
-    # returns the current method name. Used for
-    # auto discovery of which template to render
-    # based on the action name.
-    def current_method_name(depth=0)
-      caller[depth] =~ /`(.*)'$/; $1
-    end
-    
-    # given html, js and xml this method returns the template 
-    # extension from the :template_ext map froom your app's
-    # configuration. defaults to .herb, .jerb & .xerb
-    def template_extension_for(ext)
-      (@tmpl_ext_cache ||= Merb::Server.template_ext)[ext]
+    # 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
+    #
+    # Erubis template ext:  .herb .jerb .erb
+    # Markaby template ext: .mab
+    # Builder template ext: .rxml .builder .xerb 
+    #
+    # Examples:
+    #
+    # 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
+    # are exempt from layout by default.
+    # 
+    # render :action => 'foo'
+    # renders views/controllername/foo.*
+    #
+    # render :nothing => 200
+    # renders nothing with a status of 200
+    #
+    # 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 
+    # 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
+    # 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
+    # of :xml => as a string. SO you can pass any xml string to this
+    # to be rendered. 
+    #
+    def render(opts={}, &blk)
+      action = opts[:action] || params[:action]
+      opts[:layout] ||= ancestral_trait[:layout] 
+      
+      case
+      when status = opts[:nothing]
+        return render_nothing(status)
+      when partial = opts[:partial]
+        template = find_partial(partial, opts)
+        opts[:layout] = :none
+      when js = opts[:js]
+        headers['Content-Type'] = "text/javascript"
+        opts[:layout] = :none
+        if String === js
+          return js
+        elsif Symbol === js
+          template = find_template(:action => js, :ext => 'jerb')
+        else  
+          template = find_template(:action => action, :ext => 'jerb')
+        end
+      when xml = opts[:xml]
+        headers['Content-Type'] = 'application/xml'
+        headers['Encoding']     = 'UTF-8'
+        return xml
+      else  
+        template = find_template(:action => action)
+      end
+        
+      engine = engine_for(template)
+      options = {
+        :file     => template,
+        :view_context  => (opts[:clean_context] ? clean_view_context : _view_context),
+        :opts => opts
+      }
+      content = engine.transform(options)
+      if engine.exempt_from_layout? || opts[:layout] == :none
+        content 
+      else
+        wrap_layout(content, opts)
+      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.
@@ -34,36 +96,32 @@ module Merb
       @_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
     # this when you want to render a template with 
     # .jerb extension.
-    def render_js(template=current_method_name(1))
-      headers['Content-Type'] = "text/javascript"
-      template = new_eruby_obj(template_dir(self.class.name.snake_case) / "/#{template}.#{template_extension_for(:js)}") 
-      template.evaluate(_view_context)
+    def render_js(template=nil)
+      render :js => true, :action => (template || params[:action])
     end
-    
+
     # renders nothing but sets the status, defaults
-    # to 200. does send one \n newline char, tyhis is for
+    # to 200. does send one ' ' space char, this is for
     # safari and flash uploaders to work.
     def render_nothing(status=200)
       @status = status
-      return "\n"
+      return " "
     end
-    
-    # renders the action without wrapping it in a layout.
-    # call it without arguments if your template matches
-    # the name of the running action. Otherwise you can 
-    # explicitely set the template name excluding the file
-    # extension
-    def render_no_layout(template=current_method_name(1))
-      template = new_eruby_obj(template_dir(self.class.name.snake_case) / "/#{template}.#{template_extension_for(:html)}")
-      template.evaluate(_view_context)
+
+    def render_no_layout(opts={})
+      render opts.update({:layout => :none})
     end 
     
     # This is merb's partial render method. You name your 
-    # partials _partialname.herb, and then call it like
+    # partials _partialname.* , and then call it like
     # partial(:partialname). If there is no '/' character
     # in the argument passed in it will look for the partial 
     # in the view directory that corresponds to the current
@@ -72,120 +130,59 @@ module Merb
     # if you create a views/shared directory then you can call
     # partials that live there like partial('shared/foo')
     def partial(template)
-      if template =~ /\//
-        t = template.split('/')
-        template = t.pop
-        tmpl = new_eruby_obj(template_dir(t.join('/')) / "/_#{template}.#{template_extension_for(:html)}") 
-      else  
-        tmpl = new_eruby_obj(template_dir(self.class.name.snake_case) / "/_#{template}.#{template_extension_for(:html)}")
-      end
-      tmpl.evaluate(_view_context)
+      render :partial => template
     end 
     
-    # This creates and returns a new Erubis object populated
-    # with the template from path. If there is no matching
-    # template then we rescue the Errno::ENOENT exception
-    # and raise a no template found message
-    def new_eruby_obj(path)
-      if @@erbs[path] && !cache_template?(path)
-        return @@erbs[path]
-      else  
-        begin
-          returning Erubis::MEruby.new(IO.read(path)) do |eruby|
-            eruby.init_evaluator :filename => path
-            if cache_template?(path)
-              @@erbs[path] = eruby
-              @@mtimes[path] = Time.now
-            end  
-          end
-        rescue Errno::ENOENT
-          raise "No template found at path: #{path}"
-        end
-      end  
-    end
-    
-    def cache_template?(path)
-      return false unless Merb::Server.config[:cache_templates]
-      return true unless @@erbs[path]
-      @@mtimes[path] < File.mtime(path) ||
-        (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
-    end
+    private
     
-    # this is the xml builder render method. This method
-    # builds the Builder::XmlMarkup object for you and adds
-    # the xml headers and encoding. Then it evals your template
-    # in the context of the xml object. So your .xerb templates
-    # will look like this:
-    # xml.foo {|xml|
-    #   xml.bar "baz"
-    # }
-    def render_xml(template=current_method_name(1))
-      _xml_body = IO.read( template_dir(self.class.name.snake_case) + "/#{template}.#{template_extension_for(:xml)}" ) 
-      headers['Content-Type'] = 'application/xml'
-      headers['Encoding']     = 'UTF-8'
-      _view_context.instance_eval %{
-        xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
-        #{_xml_body}
-        return xml.target!
-      } 
-    end
-    
-    # This is the main render method that handles layouts.
-    # render will use layout/application.rhtml unless
-    # there is a layout named after the current controller
-    # or if self.layout= has been set to another value in
-    # the current controller. You can over-ride this setting
-    # by passing an options hash with a :layout => 'layoutname'.
-    # if you with to not render a layout then pass :layout => :none
-    # the first argument to render is the template name. if you do
-    # not pass a template name, it will set the template to 
-    # views/controller/action automatically.
-    # examples:
-    # class Test < Merb::Controller
-    #   # renders views/test/foo.herb 
-    #   # in layout application.herb
-    #   def foo
-    #     # code
-    #     render
-    #   end
-    #
-    #   # renders views/test/foo.herb
-    #   # in layout application.herb    
-    #   def bar
-    #     # code
-    #     render :foo
-    #   end
-    #
-    #   # renders views/test/baz.herb
-    #   # with no layout    
-    #   def baz
-    #     # code
-    #     render :layout => :none
-    #   end    
-    def render(opts={})
-      template = opts.is_a?(Symbol) ? opts : (opts[:action] || params[:action])
-      tmpl_ext = template_extension_for(:html)
-      MERB_LOGGER.info("Rendering template: #{template}.#{tmpl_ext}")
-      name = self.class.name.snake_case
-      template = new_eruby_obj(template_dir(name) / "/#{template}.#{tmpl_ext}")
-      layout_content = template.evaluate(_view_context)
-      self.layout = opts[:layout].to_sym if opts.has_key?(:layout)
-      return layout_content if (layout == :none)
-      if layout != :application
-        layout_choice = layout
-      else
-        if File.exist?(template_dir("layout/#{name}.#{tmpl_ext}"))
-          layout_choice = name
+      def wrap_layout(content, opts={})
+        if opts[:layout] != :application
+          layout_choice = find_template(:layout => opts[:layout])
         else
-          layout_choice = layout
+          if name = find_template(:layout => self.class.name.snake_case)
+            layout_choice = name
+          else
+            layout_choice = find_template(:layout => :application)
+          end  
+        end      
+        
+        _view_context.instance_variable_set('@_layout_content', content)
+        engine = engine_for(layout_choice)
+        options = {
+          :file     => layout_choice,
+          :view_context  => _view_context,
+          :opts => opts
+        }
+        engine.transform(options)
+      end
+      
+      # OPTIMIZE : combine find_template and find_partial ?
+      def find_template(opts={})
+        if action = opts[:action]
+          path =
+            File.expand_path(MERB_ROOT / "dist/app/views" / self.class.name.snake_case / action)
+        elsif layout = opts[:layout]
+          path = ancestral_trait[:layout_root] / layout
+        else
+          raise "called find_template without an :action or :layout"  
         end  
-      end      
-      MERB_LOGGER.info("With Layout: #{layout_choice}.#{tmpl_ext}")
-      _view_context.instance_variable_set('@_layout_content', layout_content)
-      layout_tmpl = new_eruby_obj("#{template_dir('layout')}/#{layout_choice}.#{tmpl_ext}")     
-      layout_tmpl.evaluate(_view_context)
-    end
+        extensions = [ancestral_trait[:template_extensions].keys].flatten.uniq
+        glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
+        Dir[glob].first
+      end
+      
+      def find_partial(template, opts={})
+        if template =~ /\//
+          t = template.split('/')
+          template = t.pop
+          path = ancestral_trait[:template_root] / t.join('/') / "_#{template}"
+        else  
+          path = ancestral_trait[:template_root]  / self.class.name.snake_case / "_#{template}"
+        end
+        extensions = [ancestral_trait[:template_extensions].keys].flatten.uniq
+        glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
+        Dir[glob].first
+      end
     
   end  
-end  
+end

data/lib/merb/mixins/responder_mixin.rb

@@ -9,31 +9,146 @@ module Merb
   #   type.yaml { @foo.to_yaml }
   # end  
   
+  # TODO : revisit this whole patern. Can we improve on this?
   module ResponderMixin
-    def respond_to
-      yield response = Response.new(@env['HTTP_ACCEPT'])
-      @headers['Content-Type'] = response.content_type
-      response.body
+    
+    def respond_to(&block)
+      responder = Rest::Responder.new(@env['HTTP_ACCEPT'], params)
+      block.call(responder)
+      responder.respond(headers)
+      @status = responder.status
+      responder.body
     end
 
-    class Response
-      attr_reader :body, :content_type
-      def initialize(accept) @accept = accept end
-
-      TYPES = { 
-        :yaml => %w[application/yaml text/yaml],
+    module Rest
+      
+      TYPES = {
+        :all  => %w[*/*],
+        :yaml => %w[application/x-yaml text/yaml],
         :text => %w[text/plain],
-        :html => %w[text/html */* application/html],
-        :xml  => %w[application/xml],
-        :js   => %w[application/json text/x-json]
+        :html => %w[text/html application/xhtml+xml application/html],
+        :xml  => %w[application/xml text/xml application/x-xml],
+        :js   => %w[application/json text/x-json text/javascript application/javascript application/x-javascript]
       }
+      
+      class Responder
+      
+        attr_reader :body, :type, :status
+      
+        def initialize(accept_header, params={})
+          MERB_LOGGER.info accept_header
+          @accepts = Responder.parse(accept_header)
+          @params = params
+          @stack  = {}
+        end
+      
+        def method_missing(symbol, &block)
+          raise "respond_to expects a block" unless block_given?
+          # the first method we encounter here will be used for the catch all mime-type */*
+          @stack[:all] = block unless @stack[:all]
+          @stack[symbol] = block
+        end
+        
+        def respond(headers)
+          unless @stack.keys.all?{|k| TYPES.has_key?(k) }
+            raise "unrecognized mime type in respond_to block"
+          end
+          mime_type = negotiate_content
+          if mime_type
+            headers['Content-Type'] = mime_type.super_range
+            @status = 200
+            @body   = @stack[mime_type.to_sym].call
+          else
+            headers['Content-Type'] = nil
+            @status = 406
+            @body   = nil
+          end
+        end
+        
+        protected
+          
+          def self.parse(accept_header)
+            index = 0
+            list = accept_header.split(/,/).map! do |entry|
+              AcceptType.new(entry,index += 1)
+            end.sort!.uniq
+          end
+          
+        private
+        
+          def negotiate_content
+            if @params['format']
+              negotiate_by_format
+            elsif (@stack.keys & @accepts.map(&:to_sym)).size > 0
+              negotiate_by_accept_header
+            end
+          end
+          
+          def negotiate_by_format
+            format = @params['format'].to_sym
+            if @stack[format]
+              if @accepts.map(&:to_sym).include?(format)
+                @accepts.select{|a| a.to_sym == format }.first
+              else
+                AcceptType.new(TYPES[format].first,0)
+              end
+            end
+          end
+          
+          def negotiate_by_accept_header
+            @accepts.each do |accept|
+              return accept if @stack[accept.to_sym] || accept.to_sym == :all
+            end
+          end
+        
+      end
+
+      class AcceptType
 
-      def method_missing(method, *args)
-        if TYPES[method] && @accept =~ Regexp.union(*TYPES[method])
-          @content_type = TYPES[method].first 
-          @body = yield if block_given?
+        attr_reader :media_range, :quality, :index, :type, :sub_type
+        
+        def initialize(entry,index)
+          @index = index
+          @media_range, quality = entry.split(/;\s*q=/).map(&: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)
+          returning (entry.quality <=> quality).to_s do |c|
+            c.replace((index <=> entry.index).to_s) if c == '0'
+          end.to_i
         end
+      
+        def eql?(entry)
+          synonyms.include?(entry.media_range)
+        end
+      
+        def ==(entry); eql?(entry); end
+      
+        def hash; super_range.hash; end
+      
+        def synonyms
+          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 }.flatten.first
+        end
+      
+        def to_s
+          @media_range
+        end
+      
       end
+      
     end
+
   end
-end  
+  
+end