merb 0.3.7 → 0.4.0

data/lib/merb/mixins/web_controller.rb

@@ -0,0 +1,29 @@
+module Merb
+  module WebControllerMixin
+    
+    def request
+       @web_controller.request  
+    end
+            
+    def params
+      @web_controller.params
+    end  
+    
+    def cookies
+      @web_controller.cookies
+    end  
+
+    def headers
+      @web_controller.headers
+    end
+    
+    def session
+      @web_controller.session
+    end
+
+    def response
+      @web_controller.response
+    end    
+     
+  end
+end

data/lib/merb/{merb_handler.rb → mongrel_handler.rb}

@@ -1,7 +1,7 @@
 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
+    unless @status_sent
       @header['Content-Length'] = content_length unless @status == 304
       write(NO_CLOSE_STATUS_FORMAT % [@status, Mongrel::HTTP_STATUS_CODES[@status]])
       @status_sent = true
@@ -10,7 +10,18 @@ class Mongrel::HttpResponse
 end  
 
 class MerbHandler < Mongrel::HttpHandler
-  @@file_only_methods = ["GET","HEAD"]
+  @@file_only_methods    = ["GET","HEAD"]
+  @@path_prefix          = nil
+  @@path_prefix_original = nil
+  
+  class << self
+    # Use :path_prefix in merb.yml to set this
+    def path_prefix() @@path_prefix_original end
+    def path_prefix=(prefix)
+      @@path_prefix_original = prefix
+      @@path_prefix          = (prefix.is_a?(String) ? /^#{prefix.escape_regexp}/ : prefix)
+    end
+  end
   
   # Take the name of a directory and use that as the doc root or public
   # directory of your site. This is set to the root of your merb app + '/public'
@@ -28,58 +39,59 @@ class MerbHandler < Mongrel::HttpHandler
   # into Merb::RouteMatcher to let it decide which controller and method will
   # serve the request.
   # 4. After the controller has done its thing, we check for the X-SENDFILE
-  # header. if you set this header to the path to a file in your controller
+  # header. if you set this header to the path of a file in your controller
   # then mongrel will serve the file directly and your controller can go on
   # processing other requests.
-  def process(request, response)
-    
-    start = Time.now
+  def process(request, response)    
+    start      = Time.now
     benchmarks = {}
     
-    if response.socket.closed?
-      return
-    end
+    return if response.socket.closed?
     
-    MERB_LOGGER.info("\nRequest: REQUEST_URI: #{request.params[Mongrel::Const::REQUEST_URI]}  (#{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")})")
+    
+    # Truncate the request URI if there's a path prefix so that an app can be
+    # hosted inside a subdirectory, for example.
+    if @@path_prefix
+      if request.params[Mongrel::Const::PATH_INFO] =~ @@path_prefix
+        MERB_LOGGER.info("Path prefix #{@@path_prefix.inspect} removed from PATH_INFO and REQUEST_URI.")
+        request.params[Mongrel::Const::PATH_INFO].sub!(@@path_prefix, '')
+        request.params[Mongrel::Const::REQUEST_URI].sub!(@@path_prefix, '')
+        path_info = request.params[Mongrel::Const::PATH_INFO]
+      else
+        raise "Path prefix is set to '#{@@path_prefix.inspect}', but is not in the REQUEST_URI. "
+      end
+    else
+      path_info = request.params[Mongrel::Const::PATH_INFO]
+    end
     
     # Rails style page caching. Check the public dir first for .html pages and
     # serve directly. Otherwise fall back to Merb routing and request
     # dispatching.
-    path_info = request.params[Mongrel::Const::PATH_INFO]
     page_cached = path_info + ".html"
     get_or_head = @@file_only_methods.include? request.params[Mongrel::Const::REQUEST_METHOD]
 
-    if get_or_head and @files.can_serve(path_info)
+    if get_or_head && @files.can_serve(path_info)
       # File exists as-is so serve it up
       MERB_LOGGER.info("Serving static file: #{path_info}")
       @files.process(request,response)
-    elsif get_or_head and @files.can_serve(page_cached)
+    elsif get_or_head && @files.can_serve(page_cached)
       # Possible cached page, serve it up
       MERB_LOGGER.info("Serving static file: #{page_cached}")
       request.params[Mongrel::Const::PATH_INFO] = page_cached
       @files.process(request,response)
     else
-      begin
-        # Let Merb:Dispatcher find the route and call the filter chain and action
-        controller = nil
-        controller, action = Merb::Dispatcher.handle(request, response)
+      # Let Merb:Dispatcher find the route and call the filter chain and action
+      controller, action      = Merb::Dispatcher.handle(request, response)  
+      benchmarks.merge!(controller._benchmarks)
+      benchmarks[:controller] = controller.class.to_s
+      benchmarks[:action]     = action
 
-        benchmarks.merge!(controller._benchmarks)
-        benchmarks[:controller] = controller.class.to_s
-        benchmarks[:action] = action
-
-        MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{action}\nRoute Recognition & Parsing HTTP Input took: #{benchmarks[:setup_time]} seconds")
-      rescue Object => e
-        response.start(500) do |head,out|
-          head["Content-Type"] = "text/html"
-          MERB_LOGGER.info(Merb.exception(e))
-          out << Merb.html_exception(e)
-        end  
-        return
-      end   
+      MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{action}\nRoute Recognition & Parsing HTTP Input took: #{benchmarks[:setup_time]} seconds")
       
       sendfile, clength = nil
-      response.status = controller.status
+      response.status   = controller.status
       # Check for the X-SENDFILE header from your Merb::Controller and serve
       # the file directly instead of buffering.
       controller.headers.each do |k, v|
@@ -96,8 +108,9 @@ class MerbHandler < Mongrel::HttpHandler
       
       if sendfile
         benchmarks[:sendfile_time] = Time.now - start        
-        MERB_LOGGER.info("X-SENDFILE: #{sendfile}\nComplete Request took: #{benchmarks[:sendfile_time]} seconds")
-        file_status = File.stat(sendfile)
+        MERB_LOGGER.info("X-SENDFILE: #{sendfile}\nComplete Request took: #{
+          benchmarks[:sendfile_time]} seconds")
+        file_status     = File.stat(sendfile)
         response.status = 200
         # Set the last modified times as well and etag for all files
         response.header[Mongrel::Const::LAST_MODIFIED] = file_status.mtime.httpdate
@@ -129,9 +142,17 @@ class MerbHandler < Mongrel::HttpHandler
       total_request_time = Time.now - start
       benchmarks[:total_request_time] = total_request_time
         
-      MERB_LOGGER.info("Request Times: #{benchmarks.inspect}")
-      MERB_LOGGER.info("Response status: #{response.status}\nComplete Request took: #{total_request_time} seconds, #{1.0/total_request_time} Requests/Second\n\n")
+      MERB_LOGGER.info("Request Times: #{benchmarks.inspect}\nResponse status: #{response.status}\nComplete Request took: #{total_request_time} seconds, #{1.0/total_request_time} Requests/Second\n\n")
     end
-  end    
-    
-end
+  rescue Object => e
+    # if an exception is raised here then something is 
+    # wrong with the dispatcher code so we shouldn't pass the
+    # exception back in or we might end up in a loop
+    response.send_status(500)
+    response.send_header
+    response.write("500 Internal Server Error")
+    MERB_LOGGER.error(Merb.exception(e))
+  ensure
+    MERB_LOGGER.flush
+  end
+end

data/lib/merb/part_controller.rb

@@ -0,0 +1,19 @@
+module Merb
+  class PartController < AbstractController
+    self._template_root = File.expand_path(self._template_root / "../app/parts/views")
+    include Merb::WebControllerMixin
+    
+    def initialize(web_controller)
+      @web_controller = web_controller
+      super
+    end
+
+    def dispatch(action=:to_s)
+      old_action = params[:action]
+      params[:action] = action
+      super(action)
+      params[:action] = old_action
+      @_body
+    end    
+  end
+end    

data/lib/merb/plugins.rb

@@ -0,0 +1,16 @@
+module Merb
+  module Plugins
+    def self.config
+      @config ||= File.exists?(MERB_ROOT / "config" / "plugins.yml") ? YAML.load(File.read(MERB_ROOT / "config" / "plugins.yml")) || {} : {}
+    end
+    
+    @rakefiles = []
+    def self.rakefiles
+      @rakefiles
+    end
+    
+    def self.add_rakefiles(*rakefiles)
+      @rakefiles += rakefiles
+    end
+  end
+end

data/lib/merb/rack_adapter.rb

@@ -0,0 +1,37 @@
+module Merb
+  module Rack
+    
+    class RequestWrapper
+      def initialize(env)
+        @env = env
+      end
+      
+      def params
+        @env
+      end
+      
+      def body
+        @env['rack.input']
+      end
+    end
+      
+    class Adapter
+      def call(env)
+        env["PATH_INFO"] ||= ""
+        env["SCRIPT_NAME"] ||= ""
+        if env["REQUEST_URI"] =~ %r{(https?://)[^/](.*)}
+          env["REQUEST_URI"] = $2
+        end  
+        request = RequestWrapper.new(env)
+        response = StringIO.new
+        begin
+          controller, action = ::Merb::Dispatcher.handle(request, response)
+        rescue Object => e
+          return [500, {"Content-Type"=>"text/html"}, "Internal Server Error"]
+        end
+        
+        [controller.status, controller.headers, controller.body]
+      end
+    end
+  end
+end

data/lib/merb/request.rb

@@ -0,0 +1,421 @@
+module Merb
+  class Request
+    attr_accessor :env, :session
+    
+    # by setting these to false, auto-parsing is disabled; this way you can do your own parsing instead
+    cattr_accessor :parse_multipart_params, :parse_json_params, :parse_xml_params
+    self.parse_multipart_params = true
+    self.parse_json_params = true
+    self.parse_xml_params = true
+    
+    def initialize(http_request)
+      @env = http_request.params
+      @body = http_request.body
+    end
+    
+    METHODS = %w{get post put delete head}
+    
+    def method
+      @method ||= begin
+        request_method = @env['REQUEST_METHOD'].downcase.to_sym
+        case request_method
+        when :get, :head, :put, :delete
+          request_method
+        when :post
+          m = body_and_query_params['_method'] 
+          m.downcase! if m
+          METHODS.include?(m) ? m.to_sym : :post
+        else
+          raise "Unknown REQUEST_METHOD: #{@env['REQUEST_METHOD']}"
+        end
+      end
+    end
+    
+    # create predicate methods for querying the REQUEST_METHOD
+    # get? post? head? put? etc
+    METHODS.each do |m|
+      define_method("#{m}?") { method == m.to_sym }
+    end
+    
+    private
+    
+    # FIXME: symbolize_keys on params is a potential problem. symbols are 
+    # not garbage collected so a malicious user could send many large query
+    # keys to Merb forcing it to eat up memeory.
+    
+    # A hash of parameters passed from the URL like ?blah=hello
+    def query_params
+      @query_params ||= self.class.query_parse(query_string || '')
+    end
+    
+    # A hash of parameters passed in the body of the request.
+    #
+    # Ajax calls from prototype.js and other libraries 
+    # pass content this way.
+    def body_params
+      @body_params ||= begin
+        if content_type && content_type.match(Merb::Const::FORM_URL_ENCODED_REGEXP) # or content_type.nil?
+          self.class.query_parse(raw_post)
+        end
+      end
+    end
+    
+    def body_and_query_params
+      # ^-- FIXME a better name for this method
+      @body_and_query_params ||= begin
+        h = query_params
+        h.merge!(body_params) if body_params
+        h
+      end
+    end
+    
+    def multipart_params
+      @multipart_params ||= begin
+        if Merb::Const::MULTIPART_REGEXP =~ content_type
+          self.class.parse_multipart(@body, $1, content_length)
+        end
+      end
+    end
+    
+    def json_params
+      @json_params ||= begin
+        if [Merb::Const::APPLICATION_JSON, Merb::Const::TEXT_JSON].include?(content_type)
+          JSON.parse(raw_post)
+        end
+      end
+    end
+    
+    def xml_params
+      @xml_params ||= begin
+        if [Merb::Const::APPLICATION_XML, Merb::Const::TEXT_XML].include?(content_type)
+          Hash.from_xml(raw_post) rescue Mash.new
+        end
+      end
+    end
+    
+    public
+    
+    def params
+      @params ||= begin
+        h = route_params.to_mash.merge(body_and_query_params)        
+        h.merge!(multipart_params) if self.class.parse_multipart_params && multipart_params
+        h.merge!(json_params) if self.class.parse_json_params && json_params
+        h.merge!(xml_params) if self.class.parse_xml_params && xml_params
+        h
+      end
+    end
+    
+    def cookies
+      @cookies ||= self.class.query_parse(@env[Merb::Const::HTTP_COOKIE], ';,')
+    end
+    
+    def route
+      @route ||= Merb::Router.routes[route_index]
+    end
+    
+    # returns two objects, route_index and route_params
+    def route_match
+      @route_match ||= Merb::Router.match(self, body_and_query_params)
+    end
+    private :route_match
+    
+    def route_index
+      route_match.first
+    end
+    
+    def route_params
+      route_match.last
+    end
+    
+    def controller_name
+      route_params[:controller]
+    end
+    
+    def controller_class
+      begin
+        cnt = controller_name.to_const_string
+      rescue ::String::InvalidPathConversion
+        raise ControllerExceptions::NotFound
+      end
+      if !Controller._subclasses.include?(cnt)
+        raise ControllerExceptions::NotFound, "Controller '#{cnt}' not found"
+      end
+      
+      begin
+        if cnt == "Application"
+          raise ControllerExceptions::NotFound, "The 'Application' controller has no public actions" 
+        end
+        return Object.full_const_get(cnt)
+      rescue NameError
+        raise ControllerExceptions::NotFound
+      end
+    end
+    
+    def action
+      route_params[:action]
+    end
+    
+    def raw_post
+      @body.rewind
+      @body.read
+    end
+    
+    # Returns true if the request is an Ajax request.
+    #
+    # Also aliased as the more memorable ajax? and xhr?.
+    def xml_http_request?
+      not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
+    end
+    alias xhr? :xml_http_request?
+    alias ajax? :xml_http_request?
+    
+    # returns the remote IP address if it can find it.
+    def remote_ip
+      return @env['HTTP_CLIENT_IP'] if @env.include?('HTTP_CLIENT_IP')
+    
+      if @env.include?(Merb::Const::HTTP_X_FORWARDED_FOR) then
+        remote_ips = @env[Merb::Const::HTTP_X_FORWARDED_FOR].split(',').reject do |ip|
+          ip =~ /^unknown$|^(127|10|172\.16|192\.168)\./i
+        end
+    
+        return remote_ips.first.strip unless remote_ips.empty?
+      end
+    
+      return @env[Merb::Const::REMOTE_ADDR]
+    end
+    
+    # returns either 'https://' or 'http://' depending on
+    # the HTTPS header
+    def protocol
+      ssl? ? 'https://' : 'http://'
+    end
+    
+    # returns true if the request is an SSL request
+    def ssl?
+      @env['HTTPS'] == 'on' || @env['HTTP_X_FORWARDED_PROTO'] == 'https'
+    end
+    
+    # returns the request HTTP_REFERER.
+    def referer
+      @env['HTTP_REFERER']
+    end
+    
+    # returns he request uri.
+    def uri
+      @env['REQUEST_URI']
+    end
+    
+    def user_agent
+      @env['HTTP_USER_AGENT']
+    end
+
+    def server_name
+      @env['SERVER_NAME']
+    end
+
+    def accept_encoding
+      @env['HTTP_ACCEPT_ENCODING']
+    end
+
+    def script_name
+      @env['SCRIPT_NAME']
+    end
+
+    def cache_control
+      @env['HTTP_CACHE_CONTROL']
+    end
+
+    def accept_language
+      @env['HTTP_ACCEPT_LANGUAGE']
+    end
+
+    def host
+      @env['HTTP_HOST']
+    end
+
+    def server_software
+      @env['SERVER_SOFTWARE']
+    end
+
+    def keep_alive
+      @env['HTTP_KEEP_ALIVE']
+    end
+
+    def accept_charset
+      @env['HTTP_ACCEPT_CHARSET']
+    end
+
+    def version
+      @env['HTTP_VERSION']
+    end
+
+    def gateway
+      @env['GATEWAY_INTERFACE']
+    end
+
+    def accept
+      @env['HTTP_ACCEPT']
+    end
+
+    def connection
+      @env['HTTP_CONNECTION']
+    end
+
+    def query_string
+      @env['QUERY_STRING']  
+    end
+    
+    def content_type
+      @env['CONTENT_TYPE']
+    end
+    
+    def content_length
+      @content_length ||= @env[Merb::Const::CONTENT_LENGTH].to_i
+    end
+    
+    # Returns the uri without the query string. Strips trailing '/' and reduces
+    # duplicate '/' to a single '/'
+    def path
+      path = (uri ? uri.split('?').first : '').sub(/\/+/, '/')
+      path = path[0..-2] if (path[-1] == ?/) && path.size > 1
+      path
+    end
+    
+    # returns the PATH_INFO
+    def path_info
+      @path_info ||= Mongrel::HttpRequest.unescape(@env['PATH_INFO'])
+    end
+    
+    # returns the port the server is running on
+    def port
+      @env['SERVER_PORT'].to_i
+    end
+    
+    # returns the full hostname including port
+    def host
+      @env['HTTP_X_FORWARDED_HOST'] || @env['HTTP_HOST'] 
+    end
+    
+    # returns an array of all the subdomain parts of the host.
+    def subdomains(tld_length = 1)
+      parts = host.split('.')
+      parts[0..-(tld_length+2)]
+    end
+    
+    # returns the full domain name without the port number.
+    def domain(tld_length = 1)
+      host.split('.').last(1 + tld_length).join('.').sub(/:\d+$/,'')
+    end
+    
+    class << self
+      # parses a query string or the payload of a POST
+      # request into the params hash. So for example:
+      # /foo?bar=nik&post[title]=heya&post[body]=whatever
+      # parses into:
+      # {:bar => 'nik', :post => {:title => 'heya', :body => 'whatever'}}
+      def query_parse(qs, d = '&;')
+        (qs||'').split(/[#{d}] */n).inject({}) { |h,p| 
+          normalize_params(h, *Mongrel::HttpRequest.unescape(p).split('=',2))
+        }
+      end
+    
+      NAME_REGEX = /Content-Disposition:.* name="?([^\";]*)"?/ni.freeze
+      CONTENT_TYPE_REGEX = /Content-Type: (.*)\r\n/ni.freeze
+      FILENAME_REGEX = /Content-Disposition:.* filename="?([^\";]*)"?/ni.freeze
+      CRLF = "\r\n".freeze
+      EOL = CRLF
+      def parse_multipart(request,boundary, content_length)
+        boundary = "--#{boundary}"
+        paramhsh = {}
+        buf = ""
+        input = request
+        input.binmode if defined? input.binmode
+        boundary_size = boundary.size + EOL.size
+        bufsize = 16384
+        content_length -= boundary_size
+        status = input.read(boundary_size)
+        raise EOFError, "bad content body"  unless status == boundary + EOL
+        rx = /(?:#{EOL})?#{Regexp.quote(boundary,'n')}(#{EOL}|--)/
+        loop {
+          head = nil
+          body = ''
+          filename = content_type = name = nil
+          read_size = 0
+          until head && buf =~ rx
+            i = buf.index("\r\n\r\n")
+            if( i == nil && read_size == 0 && content_length == 0 )
+              content_length = -1
+              break
+            end
+            if !head && i
+              head = buf.slice!(0, i+2) # First \r\n
+              buf.slice!(0, 2)          # Second \r\n
+              filename = head[FILENAME_REGEX, 1]
+              content_type = head[CONTENT_TYPE_REGEX, 1]
+              name = head[NAME_REGEX, 1]
+            
+              if filename && !filename.empty?
+                body = Tempfile.new(:Merb)
+                body.binmode if defined? body.binmode
+              end
+              next
+            end
+          
+            # Save the read body part.
+            if head && (boundary_size+4 < buf.size)
+              body << buf.slice!(0, buf.size - (boundary_size+4))
+            end
+          
+            read_size = bufsize < content_length ? bufsize : content_length
+            if( read_size > 0 )
+              c = input.read(read_size)
+              raise EOFError, "bad content body"  if c.nil? || c.empty?
+              buf << c
+              content_length -= c.size
+            end
+          end
+        
+          # Save the rest.
+          if i = buf.index(rx)
+            body << buf.slice!(0, i)
+            buf.slice!(0, boundary_size+2)
+          
+            content_length = -1  if $1 == "--"
+          end
+        
+          if filename && !filename.empty?   
+            body.rewind
+            data = { 
+              :filename => File.basename(filename),  
+              :content_type => content_type,  
+              :tempfile => body, 
+              :size => File.size(body) 
+            }
+          else
+            data = body
+          end
+          paramhsh = normalize_params(paramhsh,name,data)
+          break  if buf.empty? || content_length == -1
+        }
+        paramhsh
+      end
+      
+      def normalize_params(parms, name, val=nil)
+        name =~ %r([\[\]]*([^\[\]]+)\]*)
+        key = $1 || ''
+        after = $' || ''
+        
+        if after == ""
+          parms[key] = val
+        elsif after == "[]"
+          (parms[key] ||= []) << val
+        else
+          parms[key] ||= {}
+          parms[key] = normalize_params(parms[key], after, val)
+        end
+        parms
+      end
+    end
+  end
+end    
+