merb 0.1.0 → 0.2.0

data/lib/merb/core_ext.rb

@@ -9,4 +9,4 @@ corelib = __DIR__+'/merb/core_ext'
     merb_hash
     merb_numeric
     merb_symbol
-  ].each {|fn| require File.join(corelib, fn)} 
+  ].each {|fn| require File.join(corelib, fn)}

data/lib/merb/core_ext/merb_hash.rb

@@ -2,6 +2,41 @@ class Hash
   def with_indifferent_access
     MerbHash.new(self)
   end
+  def to_params()
+    result = ''
+    stack = []
+
+    each do |key, value|
+      Hash === value ? stack << [key, value] : result <<  "#{key}=#{value}&"
+    end
+
+    stack.each do |parent, hash|
+      hash.each do |key, value|
+        if Hash === value
+          stack << ["#{parent}[#{key}]", value]
+        else
+          result << "#{parent}[#{key}]=#{value}&"
+        end
+      end
+    end
+    result.chop
+  end
+  
+  # lets through the keys in the argument
+  # >> {:one => 1, :two => 2, :three => 3}.pass(:one)
+  # => {:one=>1}
+  def pass(*keys) 
+    self.reject { |k,v| ! keys.include?(k) } 
+  end
+  alias only pass
+  
+  # blocks the keys in the arguments
+  # >> {:one => 1, :two => 2, :three => 3}.block(:one)
+  # => {:two=>2, :three=>3}
+  def block(*keys) 
+    self.reject { |k,v| keys.include?(k) } 
+  end
+  alias except block
 end  
 
 # like HashWithIndifferentAccess from ActiveSupport.

data/lib/merb/core_ext/merb_object.rb

@@ -1,15 +1,72 @@
+Traits = Hash.new{|h,k| h[k] = {}}
+
 class Object
+  # traits thanks to Michael Fellinger m.fellinger@gmail.com
+  # Adds a method to Object to annotate your objects with certain traits.
+  # It's basically a simple Hash that takes the current object as key
+  #
+  # Example:
+  #
+  #   class Foo
+  #     trait :instance => false
+  #
+  #     def initialize
+  #       trait :instance => true
+  #     end
+  #   end
+  #
+  #   Foo.trait[:instance]
+  #   # false
+  #
+  #   foo = Foo.new
+  #   foo.trait[:instance]
+  #   # true
+
+  def trait hash = nil
+    if hash
+      Traits[self].merge! hash
+    else
+      Traits[self]
+    end
+  end
+
+  # builds a trait from all the ancestors, closer ancestors
+  # overwrite distant ancestors
+  #
+  # class Foo
+  #   trait :one => :eins
+  #   trait :first => :erstes
+  # end
+  #
+  # class Bar < Foo
+  #   trait :two => :zwei
+  # end
+  #
+  # class Foobar < Bar
+  #   trait :three => :drei
+  #   trait :first => :overwritten
+  # end
+  #
+  # Foobar.ancestral_trait
+  # {:three=>:drei, :two=>:zwei, :one=>:eins, :first=>:overwritten}
+
+  def ancestral_trait
+    ancs = (ancestors rescue self.class.ancestors)
+    ancs.reverse.inject({}){|s,v| s.merge(v.trait)}.merge(trait)
+  end
+  
   def returning(value)
     yield(value)
     value
   end
   
-  def __meta() class << self; self end end
-  def meta_eval(&blk) __meta.instance_eval( &blk ) end
+  def meta_class() class << self; self end end
+  def meta_eval(&blk) meta_class.instance_eval( &blk ) end
   def meta_def(name, &blk) meta_eval { define_method name, &blk } end
   def class_def name, &blk
     self.class.class_eval { define_method name, &blk }
   end   
+  
   def blank?
     if    respond_to? :empty? then empty?
     elsif respond_to? :zero?  then zero?
@@ -17,4 +74,33 @@ class Object
     end   
   end
 
+  def with_options(options)
+    yield Merb::OptionMerger.new(self, options)
+  end
 end
+
+module Merb
+  class OptionMerger #:nodoc:
+    instance_methods.each do |method| 
+      undef_method(method) if method !~ /^(__|instance_eval|class)/
+    end
+    
+    def initialize(context, options)
+      @context, @options = context, options
+    end
+    
+    private
+      def method_missing(method, *arguments, &block)
+        merge_argument_options! arguments
+        @context.send(method, *arguments, &block)
+      end
+      
+      def merge_argument_options!(arguments)
+        arguments << if arguments.last.respond_to? :to_hash
+          @options.merge(arguments.pop)
+        else
+          @options.dup
+        end  
+      end
+  end
+end

data/lib/merb/merb_controller.rb

@@ -12,85 +12,55 @@ module Merb
   # to your controller via params. It also parses the ?query=string and
   # puts that into params as well.
   class Controller
-    
-    shared_accessor :layout, :session_id_key, :cache_templates
+        
+    trait :layout => :application
+    trait :session_id_key => :_session_id
         
     include Merb::ControllerMixin
     include Merb::RenderMixin
     include Merb::ResponderMixin
     
-    attr_accessor :status, :body
-    
+    attr_accessor :status, :body, :request
+
     MULTIPART_REGEXP = /\Amultipart\/form-data.*boundary=\"?([^\";,]+)/n.freeze
-    CONTENT_DISPOSITION_REGEXP = /^Content-Disposition: form-data;/.freeze
-    FIELD_ATTRIBUTE_REGEXP = /(?:\s(\w+)="([^"]+)")/.freeze
-    CONTENT_TYPE_REGEXP = /^Content-Type: (.+?)(\r$|\Z)/m.freeze
-    
+        
     # parses the http request into params, headers and cookies
     # that you can use in your controller classes. Also handles
     # file uploads by writing a tempfile and passing a reference 
     # in params.
-    def initialize(req, env, args, method=(env['REQUEST_METHOD']||'GET'))
-      env = ::MerbHash[env.to_hash]
-      @status, @method, @env, @headers, @root = 200, method.downcase.to_sym, env, 
-          {'Content-Type' =>'text/html'}, env['SCRIPT_NAME'].sub(/\/$/,'')
-      cookies = query_parse(env['HTTP_COOKIE'], ';,')
-      querystring = query_parse(env['QUERY_STRING'])
-      self.layout ||= :application
-      self.session_id_key ||= :_session_id
-      @in = req
-      if MULTIPART_REGEXP =~ env['CONTENT_TYPE']
-        boundary_regexp = /(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r$/
-        until @in.eof?
-          attrs=MerbHash[]
-          for line in @in
-            case line
-            when "\r\n" : break
-            when CONTENT_DISPOSITION_REGEXP
-              attrs.update ::MerbHash[*$'.scan(FIELD_ATTRIBUTE_REGEXP).flatten]
-            when CONTENT_TYPE_REGEXP
-              attrs[:type] = $1
-            end
-          end
-          name=attrs[:name]
-          io_buffer=if attrs[:filename]
-            io_buffer=attrs[:tempfile]=Tempfile.new(:Merb)
-            io_buffer.binmode
-          else
-            attrs=""
-          end
-          while chunk=@in.read(16384)
-            if chunk =~ boundary_regexp
-              io_buffer << $`.chomp
-              @in.seek(-$'.size, IO::SEEK_CUR)
-              break
-            end
-            io_buffer << chunk
-          end
-          if name =~ /(.*)?\[\]/
-            (querystring[$1] ||= []) << attrs
-          else  
-            querystring[name]=attrs if name
-          end
-          attrs[:tempfile].rewind if attrs.is_a?MerbHash
-        end
+    def initialize(request, env, args, response)
+      @env = MerbHash[env.to_hash]
+      @status, @method, @response, @headers = 200, (env['REQUEST_METHOD']||'GET').downcase.to_sym, response,
+          {'Content-Type' =>'text/html'}
+      cookies = query_parse(@env['HTTP_COOKIE'], ';,')
+      querystring = query_parse(@env['QUERY_STRING'])
+      
+      if MULTIPART_REGEXP =~ @env['CONTENT_TYPE'] && @method == :post
+        querystring.update(parse_multipart(request, $1))
       elsif @method == :post
-        if ['application/json', 'text/x-json'].include?(env['CONTENT_TYPE'])
+        if ['application/json', 'text/x-json'].include?(@env['CONTENT_TYPE'])
           MERB_LOGGER.info("JSON Request")
-          json = JSON.parse(@in.read || "") || {}
-          json = ::MerbHash.new(json) if json.is_a? Hash
-          querystring.merge!(json)
+          json = JSON.parse(request.read || "") || {}
+          json = MerbHash.new(json) if json.is_a? Hash
+          querystring.update(json)
         else
-          querystring.merge!(query_parse(@in.read))
+          querystring.update(query_parse(request.read))
         end  
       end
-      @cookies, @params = cookies.dup, querystring.dup.merge(args)
-      @cookies.merge!(:_session_id => @params[:_session_id]) if @params.has_key?(:_session_id)
-      @method = @params.delete(:_method).downcase.to_sym if @params.has_key?(:_method)
+      
+      @cookies, @params = cookies, querystring.update(args)
+      @cookies[ancestral_trait[:session_id_key]] = @params[ancestral_trait[:session_id_key]] if @params.key?(ancestral_trait[:session_id_key])
+      
+      allow = [:post, :put, :delete]
+      allow << :get if MERB_ENV == 'development'
+      if @params.key?(:_method) && allow.include?(@method)
+        @method = @params.delete(:_method).downcase.intern 
+      end
       @request = Request.new(@env, @method)
-      MERB_LOGGER.info("Params: #{params.inspect}")
+      
+      MERB_LOGGER.info("Params: #{params.inspect}\nCookies: #{cookies.inspect}")
     end
-    
+  
     def dispatch(action=:to_s)
       start = Time.now
       setup_session if respond_to?:setup_session
@@ -150,8 +120,37 @@ module Merb
       @session
     end
     
+    # accessor for @response. Please use response and 
+    # never @response directly.
+    def response
+      @response
+    end
+    
+    trait :template_extensions => { }
+    trait :template_root => File.expand_path(MERB_ROOT / "dist/app/views")
+    trait :layout_root   => File.expand_path(MERB_ROOT / "dist/app/views/layout")
+    # lookup the trait[: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]
+      ancestral_trait[:template_extensions][extension]
+    rescue
+      ::Merb::Template::Erubis
+    end
+   
+    # 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|
+        trait[:template_extensions][ext] = engine
+      end  
+    end
+
+    
+    
     # shared_accessor sets up a class instance variable that can
-    # be unique for each class but also inherits the meta attrs
+    # be unique for each class but also inherits the shared attrs
     # from its superclasses. Since @@class variables are almost
     # global vars within an inheritance tree, we use 
     # @class_instance_variables instead
@@ -260,14 +259,17 @@ module Merb
         "You can specify either :only or :exclude but 
          not both at the same time for the same filter."
       ) if opts.has_key?(:only) && opts.has_key?(:exclude)
-      
-      raise(ArgumentError, 
-        'after filters can only be a Proc object'
-      ) unless Proc === filter
-      
+    
       opts = shuffle_filters!(opts)
       
-      (self.after_filters ||= []) << [filter, opts]
+      case filter
+      when Symbol, Proc, String
+        (self.after_filters ||= []) << [filter, opts]
+      else
+        raise(ArgumentError, 
+          'After filters need to be either a Symbol, String or a Proc'
+        )        
+      end
     end
     
     def self.shuffle_filters!(opts={})

data/lib/merb/merb_dispatcher.rb

@@ -0,0 +1,72 @@
+module Merb
+  
+  class Dispatcher
+    class << self
+      
+      attr_accessor :path_prefix
+      
+      @@mutex = Mutex.new
+      @@use_mutex = ::Merb::Server.use_mutex
+      # This is where we grab the incoming request PATH_INFO
+      # and use that in the merb routematcher to determine
+      # which controller and method to run. 
+      # returns a 2 element tuple of:
+      # [controller, action]
+      def handle(request, response)
+        request_uri = request.params[Mongrel::Const::REQUEST_URI]
+        request_uri.sub!(path_prefix, '') if path_prefix
+        route = route_path(request_uri)
+      
+        allowed = route.delete(:allowed)
+        rest = route.delete(:rest)
+      
+        controller = instantiate_controller(route[:controller], request.body, request.params, route, response)
+      
+        if rest
+          method = controller.request.method
+          if allowed.keys.include?(method) && action = allowed[method]
+            controller.params[:action] = action
+          else
+            raise Merb::RestfulMethodNotAllowed.new(method, allowed)
+          end  
+        else  
+          action = route[:action]
+        end
+        if @@use_mutex
+          @@mutex.synchronize {
+            controller.dispatch(action)
+          }
+        else
+          controller.dispatch(action)
+        end
+        [controller, action]
+      end
+      
+      def route_path(path)
+        path = path.sub(/\/+/, '/').sub(/\?.*$/, '')
+        path = path[0..-2] if (path[-1] == ?/) && path.size > 1
+        Merb::RouteMatcher.new.route_request(path)
+      end
+      
+      # take a controller class name string and reload or require
+      # the right controller file then CamelCase it and turn it 
+      # into a new object passing in the request and response.
+      # this is where your Merb::Controller is instantiated.
+      def instantiate_controller(controller_name, req, env, params, res) 
+        if !File.exist?(DIST_ROOT+"/app/controllers/#{controller_name.snake_case}.rb")
+          raise "Bad controller! #{controller_name.snake_case}"
+        end unless $TESTING
+        begin
+          controller_name.import
+          return Object.const_get( controller_name.camel_case ).new(req, env, params, res)
+        rescue RuntimeError
+          warn "Error getting instance of '#{controller_name.camel_case}': #{$!}"
+          raise $!
+        end
+      end
+    
+    end # end class << self
+      
+  end
+  
+end

data/lib/merb/merb_exceptions.rb

@@ -8,7 +8,12 @@ module Merb
   class Noroutefound < MerbError; end  
   class MissingControllerFile < MerbError; end
   class MerbControllerError < MerbError; end
-  
+  class RestfulMethodNotAllowed < MerbError
+    def initialize(method, allowed)
+      super("RestfulMethodNotAllowed: #{method}\n"+ "Allowed: #{allowed.keys.join(' ')})")
+    end
+    
+  end
   # format exception message for browser display  
   def self.html_exception(e)
     ::Merb::Server.show_error ? ErrorResponse.new(e).out : "500 Internal Server Error!"

data/lib/merb/merb_handler.rb

@@ -1,3 +1,16 @@
+class Mongrel::HttpResponse
+  NO_CLOSE_STATUS_FORMAT = "HTTP/1.1 %d %s\r\n".freeze
+  def send_status_no_connection_close(content_length=@body.length)
+    if not @status_sent
+      @header['Content-Length'] = content_length unless @status == 304
+      write(NO_CLOSE_STATUS_FORMAT % [@status, Mongrel::HTTP_STATUS_CODES[@status]])
+      @status_sent = true
+    end
+  end
+end  
+
+
+
 class MerbHandler < Mongrel::HttpHandler
   @@file_only_methods = ["GET","HEAD"]
   
@@ -6,7 +19,6 @@ class MerbHandler < Mongrel::HttpHandler
   # by default.
   def initialize(dir, opts = {})
     @files = Mongrel::DirHandler.new(dir,false)
-    @guard = Mutex.new
   end
   
   # process incoming http requests and do a number of things
@@ -30,7 +42,7 @@ class MerbHandler < Mongrel::HttpHandler
       return
     end
     
-    MERB_LOGGER.info("\nRequest: PATH_INFO: #{request.params[Mongrel::Const::PATH_INFO]}  (#{Time.now.strftime("%Y-%m-%d %H:%M:%S")})")
+    MERB_LOGGER.info("\nRequest: REQUEST_URI: #{request.params[Mongrel::Const::REQUEST_URI]}  (#{Time.now.strftime("%Y-%m-%d %H:%M:%S")})")
     
     # Rails style page caching. Check the public dir first for
     # .html pages and serve directly. Otherwise fall back to Merb 
@@ -50,23 +62,11 @@ class MerbHandler < Mongrel::HttpHandler
       @files.process(request,response)
     else
       begin
-        # This handles parsing the query string and post/file upload
-        # params and is outside of the synchronize call so that
-        # multiple file uploads can be done at once.
+        # dLet Merb:Dispatcher find the route and call the filter chain and action
         controller = nil
-        controller, action = handle(request)
-        MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{action}\nParsing HTTP Input took: #{Time.now - start} seconds")
+        controller, action = Merb::Dispatcher.handle(request, response)
         
-        # We need a mutex here because ActiveRecord code can be run
-        # in your controller actions. AR performs much better in single
-        # threaded mode so we lock here for the shortest amount of time 
-        # possible. Route recognition and mime parsing has already occured
-        # at this point because those processes are thread safe. This 
-        # gives us the best trade off for multi threaded performance 
-        # of thread safe, and a lock around calls to your controller actions.
-        @guard.synchronize {
-          controller.dispatch(action)
-        }
+        MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{action}\nRoute Recognition & Parsing HTTP Input took: #{Time.now - start} seconds")
       rescue Object => e
         response.start(500) do |head,out|
           head["Content-Type"] = "text/html"
@@ -113,6 +113,8 @@ class MerbHandler < Mongrel::HttpHandler
         if controller.body.respond_to? :close
           controller.body.close
         end
+      elsif Proc === controller.body
+        controller.body.call
       else
         MERB_LOGGER.info("Response status: #{response.status}\nComplete Request took: #{Time.now - start} seconds\n\n")
         # render response from successful controller
@@ -124,34 +126,4 @@ class MerbHandler < Mongrel::HttpHandler
     end
   end    
     
-  # This is where we grab the incoming request PATH_INFO
-  # and use that in the merb routematcher to determine
-  # which controller and method to run. 
-  # returns a 2 element tuple of:
-  # [controller, action]
-  def handle(request)
-    path = request.params[Mongrel::Const::PATH_INFO].sub(/\/+/, '/')
-    path = path[0..-2] if (path[-1] == ?/) && path.size > 1
-    route = Merb::RouteMatcher.new.route_request(path)
-    [ instantiate_controller(route[:controller], request.body, request.params, route), 
-      route[:action] ]
-  end
-  
-  # take a controller class name string and reload or require
-  # the right controller file then CamelCase it and turn it 
-  # into a new object passing in the request and response.
-  # this is where your Merb::Controller is instantiated.
-  def instantiate_controller(controller_name, req, env, params) 
-    if !File.exist?(DIST_ROOT+"/app/controllers/#{controller_name.snake_case}.rb")
-      raise Merb::MissingControllerFile
-    end
-    begin
-      controller_name.import
-      return Object.const_get( controller_name.camel_case ).new(req, env, params)
-    rescue RuntimeError
-      warn "Error getting instance of '#{controller_name.camel_case}': #{$!}"
-      raise $!
-    end
-  end
-    
 end