merb 0.4.1 → 0.4.2

data/lib/merb/template/erubis.rb

@@ -3,6 +3,37 @@ module Merb # :nodoc:
 
     class ErubisViewContext < ViewContext
       include ::Merb::ErubisCaptureMixin
+      
+      def partial(template, opts={})
+
+        unless @_template_format
+          @web_controller.choose_template_format(Merb.available_mime_types, {})
+        end
+
+        template = @web_controller._cached_partials["#{template}.#{@_template_format}"] ||=
+          @web_controller.send(:find_partial, template)
+
+        template_method = template.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_")
+
+        unless self.respond_to?(template_method)
+          raise Merb::ControllerExceptions::TemplateNotFound, "No template matched at #{template}"          
+        end
+
+        if with = opts.delete(:with)
+          as = opts.delete(:as) || template.match(/(.*\/_)([^\.]*)/)[2]
+          @_merb_partial_locals = opts        
+          sent_template = [with].flatten.map do |temp|
+            @_merb_partial_locals[as.to_sym] = temp
+            send(template_method)
+          end.join
+        else
+          @_merb_partial_locals = opts        
+          sent_template = send(template_method)
+        end
+
+        return sent_template if sent_template
+
+      end      
     end
     
     # Module to allow you to use Embedded Ruby templates through Erubis["http://www.kuwata-lab.com/erubis/"].

data/lib/merb/template/haml.rb

@@ -9,7 +9,7 @@ module Haml
   module Helpers
     
     def _buffer( binding )
-      @_buffer ||= eval( "_erbout", binding )
+      @_buffer = eval( "_erbout", binding )
     end
 
     alias_method :capture, :capture_haml
@@ -35,12 +35,12 @@ module Merb
           opts, text, file, view_context = options.values_at(:opts, :text, :file, :view_context)
           
           begin 
-            locals_code = build_locals(opts[:locals])
-            opts[:locals] = {}
+
+            opts[:locals] = {} # Merb handles the locals
             
             template = text ? text : load_template(file)
             
-            haml = ::Haml::Engine.new("#{locals_code}#{template}", opts) 
+            haml = ::Haml::Engine.new(template, opts)  
             haml.to_html(view_context) 
           rescue 
             # ::Haml::Engine often inserts a bogus "(haml):#{line_number}" entry in the backtrace. 
@@ -67,16 +67,6 @@ module Merb
               return template
             end
           end
-          
-          def build_locals(locals)
-            locals_code = ""
-            if locals
-              locals.keys.each do |key|
-                locals_code << "- #{key} = @_merb_partial_locals[:#{key}]\n"
-              end
-            end
-            locals_code
-          end
         
           def cache_template?(path)
             return false unless ::Merb::Server.config[:cache_templates]

data/lib/merb/template/xml_builder.rb

@@ -28,7 +28,7 @@ module Merb
         def transform(options = {})
           opts, text, file, view_context = options.values_at(:opts, :text, :file, :view_context)
           xml_body = text ? text : IO.read(file) 
-          view_context.headers['Content-Type'] = 'application/xml'
+          view_context.headers['Content-Type'] ||= 'application/xml'
           view_context.headers['Encoding']     = 'UTF-8'
           view_context.instance_eval %{
             xml = Builder::XmlMarkup.new :indent => 2

data/lib/merb/test/helper.rb

@@ -2,30 +2,102 @@ require 'merb/test/fake_request'
 require 'merb/test/hpricot'
 include HpricotTestHelper
 
-# Create a FakeRequest suitable for passing to Controller.build
-def fake_request(path="/",method='GET')
-  method = method.to_s.upcase
-  Merb::Test::FakeRequest.with(path, :request_method => method)
-end
+module Merb
+  module Test
+    module Helper
+      # Create a FakeRequest suitable for passing to Controller.build
+      def fake_request(path="/",method='GET')
+        method = method.to_s.upcase
+        Merb::Test::FakeRequest.with(path, :request_method => method)
+      end
 
-# Turn a named route into a string with the path
-def url(name, *args)
-  Merb::Router.generate(name, *args)
-end
+      # Turn a named route into a string with the path
+      # This is the same method as is found in the controller
+      def url(name, *args)
+        Merb::Router.generate(name, *args)
+      end
 
 
-# For integration/functional testing
+      # For integration/functional testing
 
 
-def request(verb, path)
-  response = StringIO.new
-  @request = Merb::Test::FakeRequest.with(path, :request_method => (verb.to_s.upcase rescue 'GET'))
+      def request(verb, path)
+        response = StringIO.new
+        @request = Merb::Test::FakeRequest.with(path, :request_method => (verb.to_s.upcase rescue 'GET'))
   
-  yield @request if block_given?
+        yield @request if block_given?
   
-  @controller, @action = Merb::Dispatcher.handle @request, response
-end
+        @controller, @action = Merb::Dispatcher.handle @request, response
+      end
+
+      def get(path)
+        request("GET",path)
+      end
+      
+      def controller
+        @controller
+      end
+      
+      [:body, :status, :params, :cookies, :headers,
+        :session, :response, :route].each do |method|
+        define_method method do
+          controller ? controller.send(method) : nil
+        end
+      end
+      
+      # Checks that a route is made to the correct controller etc
+      # 
+      # === Example
+      # with_route("/pages/1", "PUT") do |params|
+      #   params[:controller].should == "pages"
+      #   params[:action].should == "update"
+      #   params[:id].should == "1"
+      # end
+      def with_route(the_path, _method = "GET")
+        result = Merb::Router.match(fake_request(the_path, _method), {})
+        yield result[1] if block_given?
+        result
+      end 
+
+      def fixtures(*files)
+        files.each do |name|
+          klass = Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
+          entries = YAML::load_file(File.dirname(__FILE__) + "/fixtures/#{name}.yaml")
+          entries.each do |name, entry|
+            klass::create(entry)
+          end
+        end
+      end
+
+
+      # Dispatches an action to a controller.  Defaults to index.  
+      # The opts hash, if provided will act as the params hash in the controller
+      # and the params method in the controller is infact the provided opts hash
+      # This controller is based on a fake_request and does not go through the router
+      # 
+      # === Simple Example
+      #  {{{
+      #    controller, result = dispatch_to(Pages, :show, :id => 1, :title => "blah")
+      #  }}}
+      #
+      # === Complex Example
+      # By providing a block to the dispatch_to method, the controller may be stubbed or mocked prior to the 
+      # actual dispatch action being called.
+      #   {{{
+      #     controller, result = dispatch_to(Pages, :show, :id => 1) do |controller|
+      #       controller.stub!(:render).and_return("rendered response")
+      #     end
+      #   }}}
+      def dispatch_to(controller, action = :index, opts = {})
+        klass = controller.class == Class ? controller : controller.class
+        klass.stub!(:find_by_title).and_return(@page)
+        the_controller = klass.build(fake_request)
+        the_controller.stub!(:params).and_return(opts.merge!(:controller => "#{klass.name.downcase}", :action => action.to_s))
 
-def get(path)
-  request("GET",path)
+        yield the_controller if block_given?
+        @controller = the_controller
+        [the_controller, the_controller.dispatch(action.to_sym)]
+      end
+    end
+  end
 end

data/lib/merb/test/rspec.rb

@@ -1,93 +1,164 @@
 require 'hpricot'
 require 'spec'
-module MerbRspecMatchers
-  class HaveSelector
-    def initialize(expected)
-      @expected = expected
-    end
-    
-    def matches?(stringlike)
-      @document = case stringlike
-      when Hpricot::Elem
-        stringlike
-      when StringIO
-        Hpricot.parse(stringlike.string)
-      else
-        Hpricot.parse(stringlike)
+module Merb
+  module Test
+    module MerbRspecControllerRedirect
+      class BeRedirect
+        def matches?(target)
+          @target = target
+          target == 302
+        end
+        def failure_message
+          "expected to redirect"
+        end
+        def negative_failure_message
+          "expected not to redirect"
+        end
       end
-      !@document.search(@expected).empty?
-    end
-    
-    def failure_message
-      "expected following text to match selector #{@expected}:\n#{@document}"
-    end
 
-    def negative_failure_message
-      "expected following text to not match selector #{@expected}:\n#{@document}"
-    end
-  end
-  
-  class MatchTag
-    def initialize(name, attrs)
-      @name, @attrs = name, attrs
-    end
-
-    def matches?(target)
-      @errors = []
-      unless target.include?("<#{@name}")
-        @errors << "Expected a <#{@name}>, but was #{target}"
+      class Redirect
+        def matches?(target)
+          @target = target
+          BeRedirect.new.matches?(target.status)
+        end
+        def failure_message
+          "expected #{@target.inspect} to redirect"
+        end
+        def negative_failure_message
+          "expected #{@target.inspect} not to redirect"
+        end
       end
-      @attrs.each do |attr, val|
-        unless target.include?("#{attr}=\"#{val}\"")
-          @errors << "Expected #{attr}=\"#{val}\", but was #{target}"
+
+      class RedirectTo
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(target)
+          @target = target.headers['Location']
+          @redirected = BeRedirect.new.matches?(target.status)
+          @target == @expected
+        end
+
+        def failure_message
+          msg = "expected a redirect to <#{@expected}>, but "
+          if @redirected
+            msg << "found one to <#{@target}>" 
+          else
+            msg << "there was no redirect"
+          end
+        end
+
+        def negative_failure_message
+          "expected not to redirect to <#{@expected}>, but did anyway"
         end
       end
-      @errors.size == 0
+
+      def be_redirect
+        BeRedirect.new
+      end
+
+      def redirect
+        Redirect.new
+      end
+
+      def redirect_to(expected)
+        RedirectTo.new(expected)
+      end
     end
+      
+    module RspecMatchers
+      class HaveSelector
+        def initialize(expected)
+          @expected = expected
+        end
     
-    def failure_message
-      @errors[0]
-    end
+        def matches?(stringlike)
+          @document = case stringlike
+          when Hpricot::Elem
+            stringlike
+          when StringIO
+            Hpricot.parse(stringlike.string)
+          else
+            Hpricot.parse(stringlike)
+          end
+          !@document.search(@expected).empty?
+        end
     
-    def negative_failure_message
-      "Expected not to match against <#{@name} #{@attrs.map{ |a,v| "#{a}=\"#{v}\"" }.join(" ")}> tag, but it matched"
-    end
-  end
+        def failure_message
+          "expected following text to match selector #{@expected}:\n#{@document}"
+        end
+
+        def negative_failure_message
+          "expected following text to not match selector #{@expected}:\n#{@document}"
+        end
+      end
   
-  class NotMatchTag
-    def initialize(attrs)
-      @attrs = attrs
-    end
+      class MatchTag
+        def initialize(name, attrs)
+          @name, @attrs = name, attrs
+          @content = @attrs.delete(:content)
+        end
+
+        def matches?(target)
+          @errors = []
+          unless target.include?("<#{@name}")
+            @errors << "Expected a <#{@name}>, but was #{target}"
+          end
+          @attrs.each do |attr, val|
+            unless target.include?("#{attr}=\"#{val}\"")
+              @errors << "Expected #{attr}=\"#{val}\", but was #{target}"
+            end
+          end
+          if @content
+            unless target.include?(">#{@content}<")
+              @errors << "Expected #{target} to include #{@content}"
+            end
+          end
+          @errors.size == 0
+        end
     
-    def matches?(target)
-      @errors = []
-      @attrs.each do |attr, val|
-        if target.include?("#{attr}=\"#{val}\"")
-          @errors << "Should not include #{attr}=\"#{val}\", but was #{target}"
+        def failure_message
+          @errors[0]
+        end
+    
+        def negative_failure_message
+          "Expected not to match against <#{@name} #{@attrs.map{ |a,v| "#{a}=\"#{v}\"" }.join(" ")}> tag, but it matched"
         end
       end
-      @errors.size == 0
-    end
+  
+      class NotMatchTag
+        def initialize(attrs)
+          @attrs = attrs
+        end
     
-    def failure_message
-      @errors[0]
-    end
-  end
+        def matches?(target)
+          @errors = []
+          @attrs.each do |attr, val|
+            if target.include?("#{attr}=\"#{val}\"")
+              @errors << "Should not include #{attr}=\"#{val}\", but was #{target}"
+            end
+          end
+          @errors.size == 0
+        end
+    
+        def failure_message
+          @errors[0]
+        end
+      end
   
-  def match_tag(name, attrs)
-    MatchTag.new(name, attrs)
-  end
-  def not_match_tag(attrs)
-    NotMatchTag.new(attrs)
-  end
+      def match_tag(name, attrs)
+        MatchTag.new(name, attrs)
+      end
+      def not_match_tag(attrs)
+        NotMatchTag.new(attrs)
+      end
   
-  def have_selector(expected)
-    HaveSelector.new(expected)
+      def have_selector(expected)
+        HaveSelector.new(expected)
+      end
+      alias_method :match_selector, :have_selector
+      # alias_method :match_regex, :match
+    end
   end
-  alias_method :match_selector, :have_selector
-  # alias_method :match_regex, :match
-end
-
-Spec::Runner.configure do |config|
-  config.include(MerbRspecMatchers)
 end

data/lib/merb/version.rb

@@ -0,0 +1,11 @@
+module Merb
+  VERSION='0.4.2' unless defined?(::Merb::VERSION)
+  
+  # Merb::RELEASE meanings:
+  # 'svn'   : unreleased
+  # 'pre'   : pre-release Gem candidates
+  #  nil    : released
+  # You should never check in to trunk with this changed.  It should
+  # stay 'svn'.  Change it to nil in release tags.
+  RELEASE='svn' unless defined?(::Merb::RELEASE)
+end