merb 0.5.3 → 0.9.2

data/lib/merb/template.rb

@@ -1,37 +0,0 @@
-module Merb
-  module Template
-    autoload :Erubis,  'merb/template/erubis'
-    autoload :Haml,  'merb/template/haml'    
-    autoload :Markaby,  'merb/template/markaby'    
-    autoload :XMLBuilder,  'merb/template/xml_builder'      
-    
-    EXTENSIONS = {} unless defined?(EXTENSIONS)
-    
-    # lookup the template_extensions for the extname of the filename
-    # you pass. Answers with the engine that matches the extension
-    def self.engine_for(file)
-      engine_for_extension(File.extname(file)[1..-1])
-    end
-    
-    def self.engine_for_extension(ext)
-      const_get EXTENSIONS[ext]
-    end
-    
-    def self.register_extensions(engine,extensions)
-      raise ArgumentError unless engine.is_a?(Symbol) && extensions.is_a?(Array)
-      extensions.each{ |ext| EXTENSIONS[ext] = engine }
-    end
-    
-    # Register the default extensions.  They must be here
-    # since the template engines will not be loaded until they
-    # are directly referenced, or a file with their extension is found.
-    # If these are declared inside the template engine then
-    # they will never be found :(
-    register_extensions( :Erubis, %w[erb])
-    register_extensions( :Haml, %w[haml])
-    register_extensions( :Markaby, %w[mab])
-    register_extensions( :XMLBuilder, %w[builder])
-    
-  end
-  
-end

data/lib/merb/template/erubis.rb

@@ -1,68 +0,0 @@
-module Merb # :nodoc:
-  module Template # :nodoc:
-
-    class ErubisViewContext < ViewContext
-      include ::Merb::ErubisCaptureMixin
-      include ::Merb::InlinePartialMixin
-    end
-    
-    # Module to allow you to use Embedded Ruby templates through Erubis["http://www.kuwata-lab.com/erubis/"].
-    # Your template must end in .herb (HTML and ERb), .jerb (JavaScript ERb), .erb (Embedded Ruby), or .rhtml (Ruby HTML) for Merb to use it.
-    module Erubis
-      class << self
-        
-        @@erbs = {}
-        @@mtimes = {}
-        
-        def exempt_from_layout? # :nodoc:
-          false    
-        end
-       
-        # Main method to compile the ERb template.
-        # 
-        # In the case of ERb/Erubis, it first checks the template cache for precompiled
-        # templates.  If no precompiled version is found, then it compiles the template
-        # by calling <tt>new_eruby_obj</tt>, which will compile the template and return an Erubis
-        # object holding the parsed template.
-        def transform(options = {})
-          opts, text, file, view_context = options.values_at(:opts, :text, :file, :view_context)
-          eruby = text ? ::Erubis::MEruby.new(text) : new_eruby_obj(file)
-          eruby.evaluate(view_context)
-        end
-        
-        def view_context_klass
-          ErubisViewContext
-        end
-        
-        # Creates a new Erubis object to parse the template given in +path+.
-        def new_eruby_obj(path)
-          if @@erbs[path] && Merb.environment == 'production' 
-            return @@erbs[path]
-          else  
-            begin
-              eruby = ::Erubis::MEruby.new(IO.read(path))
-              eruby.init_evaluator :filename => path
-              if cache_template?(path)
-                @@erbs[path], @@mtimes[path] = eruby, Time.now
-              end  
-              eruby
-            rescue Errno::ENOENT
-              raise "No template found at path: #{path}"
-            end
-          end  
-        end
-        
-        private
-          def cache_template?(path)
-            return false unless ::Merb::Config[:cache_templates]
-            return true unless @@erbs[path]
-            @@mtimes[path] < File.mtime(path) ||
-              (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
-          end
-        
-      end
-    end
-  
-  end
-   
-end

data/lib/merb/template/haml.rb

@@ -1,87 +0,0 @@
-begin
-  require 'haml/engine'
-rescue LoadError
-  puts "you must install the haml gem to use .haml templates"
-end
-require File.join( File.dirname(__FILE__), "..", "template")
-
-module Haml
-  module Helpers
-    
-    def _buffer( binding )
-      @_buffer = eval( "_erbout", binding )
-    end
-
-    alias_method :capture, :capture_haml
-
-  end
-end
-
-module Merb
-  module Template
-    
-    class HamlViewContext < ViewContext
-      include ::Merb::InlinePartialMixin
-    end
-    
-    module Haml
-      
-      class << self
-        
-        @@hamls ||= {}
-        @@mtimes ||= {}
-        
-        def exempt_from_layout?
-          false    
-        end
-        
-        def transform(options = {})
-          opts, text, file, view_context = options.values_at(:opts, :text, :file, :view_context)
-          
-          begin 
-
-            # Merb handles the locals
-            opts.delete(:locals)
-            
-            template = text ? text : load_template(file)
-            
-            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. 
-            # Let's replace it with the path of the actual template 
-            $@[0].sub! /\(haml\)/, file  
-            raise # Raise the exception again
-          end
-        end
-        
-        def view_context_klass
-          HamlViewContext
-        end
-      
-        private
-          def load_template(file)
-            template = ""
-            if @@hamls[file] && !cache_template?(file)
-              template = @@hamls[file]
-            else  
-              template = IO.read(file)
-              if cache_template?(file)
-                @@hamls[file], @@mtimes[file] = template, Time.now
-              end
-              return template
-            end
-          end
-        
-          def cache_template?(path)
-            return false unless ::Merb::Config[:cache_templates]
-            return true unless @@hamls[path]
-            @@mtimes[path] < File.mtime(path) ||
-              (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
-          end
-        
-      end
-      
-    end
-  end
-end

data/lib/merb/template/markaby.rb

@@ -1,59 +0,0 @@
-begin
-  require 'markaby'
-rescue LoadError
-  puts "you must install the markaby gem to use .mab templates"
-end
-  
-module Markaby  
-  class Builder
-    def _buffer( binding )
-      eval( "_erbout", binding )
-    end
-    
-    def concat( string, binding )
-      _buffer( binding ) << string
-    end
-  end
-end
-  
-module Merb
-  
-  module Template  
-    module Markaby    
-      class << self
-
-        def exempt_from_layout?
-          false    
-        end
-        
-        # OPTIMIZE :  add mab template caching. what does this mean for mab? 
-        # mab is just ruby, there's no two phase compile and run
-        def transform(options = {})
-          opts, text, file, view_context = options.values_at(:opts, :text, :file, :view_context)
-          
-          if opts[:locals]
-            locals = ""
-            opts[:locals].keys.each do |key|
-              locals << "#{key} = @_merb_partial_locals[:#{key}]\n"
-            end
-            locals
-          end
-          
-          template = text ? text : File.read(file)
-          mab = ::Markaby::Builder.new({}, view_context) {
-            instance_eval("#{locals}#{template}")
-          }
-          mab.to_s
-        end
-        
-        def view_context_klass
-          ::Merb::ViewContext
-        end
-        
-      end
-      
-    end
-        
-  end
-    
-end

data/lib/merb/template/xml_builder.rb

@@ -1,50 +0,0 @@
-begin
-  require 'builder'
-rescue LoadError
-  puts "you must install the builder gem to use .rxml templates"
-end
-
-module Merb
-  
-  module Template # :nodoc:
-    # A module to allow you to use Builder["http://builder.rubyforge.org/"] templates in your Merb applications.
-    # Your Builder templates must end in .rxml, .xerb, or .builder for Merb to use them.
-    
-    
-    
-    module XMLBuilder
-        
-      class << self
-
-        def exempt_from_layout? # :nodoc:
-          true    
-        end
-
-        # Main method to run the Builder template.
-        # 
-        # In Builder's case, it sets the content type and encoding, 
-        # executes the Builder template by feeding it to <tt>Builder::XmlMarkup.new</tt>, 
-        # then calls <tt>target!</tt> on the<tt>Builder::XmlMarkup</tt> instance to get its XML output.   
-        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['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
-
-        def view_context_klass
-          ::Merb::ViewContext
-        end
-      end
-      
-    end
-        
-  end
-    
-end

data/lib/merb/test/fake_request.rb

@@ -1,74 +0,0 @@
-require 'ostruct'
-
-module Merb
-  module Test
-    # FakeRequest sets up a default enviroment which can be overridden either
-    # by passing and env into initialize or using request['HTTP_VAR'] = 'foo' 
-    class FakeRequest < Request
-      attr_reader :req
-      alias :body :req
-      alias :params :env
-      alias :to_hash :env
-    
-      def initialize(env = {}, req = StringIO.new)
-        env[:http_cookie] = env.delete(:cookies) if env[:cookies]
-        env.environmentize_keys!
-        
-        r = OpenStruct.new
-        r.params = DEFAULT_ENV.dup.merge(env)
-        r.body = req
-        super(r)
-        self.post_body = ''
-        @session = {}
-      end
-
-      def self.with(path, options = {})
-        options.merge!(:QUERY_STRING => path.split("?")[1])
-        options.environmentize_keys!
-        new({'REQUEST_URI' => path,
-             'PATH_INFO' => path.sub(/\?.*$/,'')}.merge(options))
-      end
-  
-      def post_body=(post)
-        @req = StringIO.new(post)
-      end  
-      
-      def session
-        @session
-      end
-      
-      def [](key)
-        @env[key]
-      end
-  
-      def []=(key, value)
-        @env[key] = value
-      end
-      
-      private    
-      DEFAULT_ENV = Mash.new({
-        'SERVER_NAME' => 'localhost',
-        'PATH_INFO' => '/',
-        'HTTP_ACCEPT_ENCODING' => 'gzip,deflate',
-        'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.8.0.1) Gecko/20060214 Camino/1.0',
-        'SCRIPT_NAME' => '/',
-        'SERVER_PROTOCOL' => 'HTTP/1.1',
-        'HTTP_CACHE_CONTROL' => 'max-age=0',
-        'HTTP_ACCEPT_LANGUAGE' => 'en,ja;q=0.9,fr;q=0.9,de;q=0.8,es;q=0.7,it;q=0.7,nl;q=0.6,sv;q=0.5,nb;q=0.5,da;q=0.4,fi;q=0.3,pt;q=0.3,zh-Hans;q=0.2,zh-Hant;q=0.1,ko;q=0.1',
-        'HTTP_HOST' => 'localhost',
-        'REMOTE_ADDR' => '127.0.0.1',
-        'SERVER_SOFTWARE' => 'Mongrel 1.1',
-        'HTTP_KEEP_ALIVE' => '300',
-        'HTTP_REFERER' => 'http://localhost/',
-        'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
-        'HTTP_VERSION' => 'HTTP/1.1',
-        'REQUEST_URI' => '/',
-        'SERVER_PORT' => '80',
-        'GATEWAY_INTERFACE' => 'CGI/1.2',
-        'HTTP_ACCEPT' => 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
-        'HTTP_CONNECTION' => 'keep-alive',
-        'REQUEST_METHOD' => 'GET'      
-      }) unless defined?(DEFAULT_ENV)
-    end
-  end
-end

data/lib/merb/test/helper.rb

@@ -1,260 +0,0 @@
-require 'merb/test/fake_request'
-require 'merb/test/hpricot'
-require 'merb/test/multipart'
-include HpricotTestHelper
-
-module Merb
-  module Test
-    module Helper
-      include Merb::GeneralControllerMixin
-      
-      # Create a FakeRequest suitable for passing to Controller.build
-      def fake_request(params = {})
-        method = method.to_s.upcase
-        Merb::Test::FakeRequest.with("/", {:request_method => "GET"}.merge(params))
-      end
-      
-      # For integration/functional testing
-      #
-      # This helper is the basis of the <tt>get</tt>, <tt>post</tt>, <tt>put</tt>, and <tt>delete</tt> helper
-      #
-      # By default a fake request is yielded to the block for local modification. 
-      # +opts+ takes any options that you want pass to the methods, plus some reserved ones
-      # 
-      # ===Yielding
-      # You can get the request helper to yield either a fake request object, or a controller
-      # Do this with the +:yield+ option.  Values can be +:request+, or +:controller+.  +:request+ is default
-      # When you yield the controller, it is available inside the block with the controller method, so you don't need to
-      # explicitly set it in the block chute.
-      # ====Example
-      #   request( :get, '/', :yields => :controller) do |controller|
-      #     controller.stub!(:render)
-      #   end
-      # 
-      # You can also pass in a fake request object which may be useful if your yielding a controller.
-      # Use the opts[:fake_request] to do this.  
-      # ====Example
-      #   request( :get, '/', :yields => :controller, :fake_request => @my_fake_request) do
-      #     controller.stub!(:render)
-      #   end
-      def request(verb, path, opts = {}, &block)
-        response = StringIO.new
-        
-        yield_to_controller = opts.delete(:yields)
-        
-        request = opts.delete(:fake_request) || Merb::Test::FakeRequest.with(path_with_options(path, opts), :request_method => (verb.to_s.upcase rescue 'GET'))
-
-        if yield_to_controller == :controller
-          request_yielding_controller(request, response, &block)
-        else
-          request_yielding_request(request, response, &block)
-        end
-      end
-                
-      # Makes a get request routed to +path+ with any options encoded into the 
-      # request url
-      # Example
-      # {{{ 
-      #   get "/users", :user => {:login => "dave", :email => "email@example.com"} 
-      # }}}
-      def get(path, opts = {}, &block)
-        request("GET", path, opts, &block)
-      end
-      
-      # Makes a post request routed to +path+ with any options encoded into the 
-      # request url
-      # Example
-      # {{{ 
-      #   post "/users", :user => {:login => "dave", :email => "email@example.com"} 
-      # }}}
-      def post(path, opts = {}, &block)
-        request("POST",path, opts, &block)
-      end
-      
-      # Makes a put request routed to +path+ with any options encoded into the 
-      # request url
-      # Example
-      # {{{ 
-      #   put "/users/1", :user => {:login => "dave", :email => "email@example.com"} 
-      # }}}
-      def put(path,opts = {}, &block)
-        request("PUT",path, opts, &block)
-      end
-      
-      # Makes a delete request routed to +path+ with any options encoded into the request url
-      # Example
-      # {{{ 
-      #   delete "/users/1", :user => {:login => "dave", :email => "email@example.com"} 
-      # }}}
-      def delete(path, opts= {}, &block)
-        request("DELETE",path, opts, &block)
-      end
-            
-      # Posts multipart form data to a path
-      # pass the +path+ to send and the parameters.  For file uploads, just include a file as the option value.
-      # ===Example
-      # multipart_post("/my_collection", :foo => "bar", :user => { :login => "joe", :image => File.open("my_image.png")})
-      def multipart_post(path, params = {}, &block)
-        multipart_request(path, params.merge!(:request_method => 'POST'), &block)
-      end
-
-      # Posts multipart form data to a path
-      # Same as +multipart_post+ but used for PUT(ting) data to the server
-      def multipart_put(path, params = {}, &block)
-        multipart_request(path, params.merge!(:request_method => 'PUT'), &block)
-      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")
-        _fake_request = Merb::Test::FakeRequest.with(the_path, :request_method => _method)
-        result = Merb::Router.match(_fake_request, {})
-        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
-        @controller = klass.build(fake_request)
-        @controller.stub!(:params).and_return(opts.merge(:controller => klass.name.downcase, :action => action.to_s).to_mash)
-        yield @controller if block_given?
-        [@controller, @controller.dispatch(action.to_sym)]
-      end
-      
-      def path_with_options(path, opts)
-        path = path << "?" << params_to_query_string(opts) unless opts.empty?
-        path
-      end
-      
-      protected
-      
-      def request_yielding_request(request, response, &block)
-        # response = StringIO.new
-        # @request = Merb::Test::FakeRequest.with(path, :request_method => (verb.to_s.upcase rescue 'GET'))
-        @request = request
-        
-        yield @request if block_given?
-      
-        @controller, @action = Merb::Dispatcher.handle @request, response
-      end
-      
-      def request_yielding_controller(request, response, &block)
-        # response = StringIO.new
-        # @request = Merb::Test::FakeRequest.with(path, :request_method => (verb.to_s.upcase rescue 'GET'))
-        @request = Merb::Request.new(request)
-
-        check_request_for_route(@request)
-        
-        dispatch_fake_request(@request, response, &block)
-      end
-      
-      def multipart_request(path, params = {}, &block)
-        response = StringIO.new
-        request = request_with_multipart_params(path, params)
-        check_request_for_route(request)
-        dispatch_fake_request(request, response, &block)
-      end
-      
-      
-      def check_request_for_route(request)
-        if request.route_params.empty?
-          raise ControllerExceptions::BadRequest, "No routes match the request"
-        elsif request.controller_name.nil?
-          raise ControllerExceptions::BadRequest, "Route matched, but route did not specify a controller" 
-        end
-      end
-      
-      # Used for yielding a controller with request and multipart helpers
-      def dispatch_fake_request(request, response, status = 200, &block)
-        klass = request.controller_class
-        @controller = klass.build(request, response, status)
-        
-        @controller.send(:setup_session)
-         # This will be a mock framework agnostic way of ensuring setup_session is not done again
-        class << @controller
-          def setup_session; true; end
-        end
-        
-        yield @controller if block_given?
-
-        @controller.dispatch(request.action)
-        [@controller, request.action]
-        
-        rescue => exception
-          exception = Dispatcher.send(:controller_exception, exception)
-          @controller, @action = Dispatcher.send(:dispatch_exception, request, response, exception)
-      end
-      
-      def request_with_multipart_params(path, params = {})
-        request_method = params.delete(:request_method) || "GET"
-        request = Merb::Test::FakeRequest.new(:request_uri => path)
-        m = Merb::Test::Multipart::Post.new(params)
-        body, head = m.to_multipart
-        request['REQUEST_METHOD'] = request_method
-        request['CONTENT_TYPE'] = head
-        request['CONTENT_LENGTH'] = body.length
-        request.post_body = body
-        Merb::Request.new(request)
-      end
-      
-    end
-  end
-end
-
-class Object
-  # Checks that an object has assigned an instance variable of name
-  # :name
-  # 
-  # ===Example in a spec
-  #  @my_obj.assings(:my_value).should == @my_value
-  def assigns(attr)
-    self.instance_variable_get("@#{attr}")
-  end
-end
-