wycats-merb-core 0.9.8

data/lib/merb-core/rack/adapter/thin_turbo.rb

@@ -0,0 +1,24 @@
+require "thin-turbo"
+
+module Merb
+
+  module Rack
+
+    class ThinTurbo < Thin
+      # start a Thin Turbo server on given host and port.
+
+      # ==== Parameters
+      # opts<Hash>:: Options for Thin Turbo (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that Thin Turbo should serve.
+      # :port<Fixnum>:: The port Thin Turbo should bind to.
+      # :socket<Fixnum>>:: The socket number that thin should bind to.
+      # :socket_file<String>>:: The socket file that thin should attach to.
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        super(opts.merge(:backend => ::Thin::Backends::Turbo))
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/webrick.rb

@@ -0,0 +1,36 @@
+require 'webrick'
+require 'rack/handler/webrick'
+module Merb
+  module Rack
+
+    class WEBrick
+      # start WEBrick server on given host and port.
+      
+      # ==== Parameters
+      # opts<Hash>:: Options for WEBrick (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that WEBrick should serve.
+      # :port<Fixnum>:: The port WEBrick should bind to.
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using Webrick adapter")
+      
+        options = {
+          :Port        => opts[:port],
+          :BindAddress => opts[:host],
+          :Logger      => Merb.logger,
+          :AccessLog   => [
+            [Merb.logger, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+            [Merb.logger, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+          ]
+        }
+     
+        server = ::WEBrick::HTTPServer.new(options)
+        Merb::Server.change_privilege
+        server.mount("/", ::Rack::Handler::WEBrick, opts[:app])
+        server.start
+      end
+    end
+  end
+end

data/lib/merb-core/rack/application.rb

@@ -0,0 +1,32 @@
+module Merb  
+  module Rack
+    class Application
+      
+      def call(env) 
+        begin
+          controller = ::Merb::Dispatcher.handle(Merb::Request.new(env))
+        rescue Object => e
+          return [500, {Merb::Const::CONTENT_TYPE => "text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")]
+        end
+        Merb.logger.info "\n\n"
+        Merb.logger.flush
+
+        # unless controller.headers[Merb::Const::DATE]
+        #   require "time"
+        #   controller.headers[Merb::Const::DATE] = Time.now.rfc2822.to_s
+        # end
+        controller.rack_response
+      end
+
+      def deferred?(env)
+        path = env[Merb::Const::PATH_INFO] ? env[Merb::Const::PATH_INFO].chomp('/') : ""
+        if path =~ Merb.deferred_actions
+          Merb.logger.info! "Deferring Request: #{path}"
+          true
+        else
+          false
+        end        
+      end # deferred?(env)
+    end # Application
+  end # Rack
+end # Merb

data/lib/merb-core/rack/handler/mongrel.rb

@@ -0,0 +1,97 @@
+require 'stringio'
+class Mongrel::HttpResponse
+  NO_CLOSE_STATUS_FORMAT = "HTTP/1.1 %d %s\r\n".freeze
+
+  # Sends the status to the client without closing the connection.
+  #
+  # ==== Parameters
+  # content_length<Fixnum>:: The length of the content. Defaults to body length.
+  def send_status_no_connection_close(content_length=@body.length)
+    unless @status_sent
+      write(NO_CLOSE_STATUS_FORMAT % [@status, Mongrel::HTTP_STATUS_CODES[@status]])
+      @status_sent = true
+    end
+  end
+end
+
+module Merb
+  module Rack
+    module Handler
+      class Mongrel < ::Mongrel::HttpHandler
+        # Runs the server and yields it to a block.
+        #
+        # ==== Parameters
+        # app<Merb::Rack::Application>:: The app that Mongrel should handle.
+        # options<Hash>:: Options to pass to Mongrel (see below).
+        #
+        # ==== Block parameters
+        # server<Mongrel::HttpServer>:: The server to run.
+        #
+        # ==== Options (options)
+        # :Host<String>::
+        #   The hostname on which the app should run. Defaults to "0.0.0.0"
+        # :Port<Fixnum>:: The port for the app. Defaults to 8080.
+        def self.run(app, options={})
+          server = ::Mongrel::HttpServer.new(options[:Host] || '0.0.0.0',
+                                             options[:Port] || 8080)
+          server.register('/', ::Merb::Rack::Handler::Mongrel.new(app))
+          yield server  if block_given?
+          server.run.join
+        end
+  
+        # ==== Parameters
+        # app<Merb::Rack::Application>:: The app that Mongrel should handle.
+        def initialize(app)
+          @app = app
+        end
+
+        # ==== Parameters
+        # request<Merb::Request>:: The HTTP request to handle.
+        # response<HTTPResponse>:: The response object to write response to.
+        def process(request, response)
+          env = {}.replace(request.params)
+          env.delete "HTTP_CONTENT_TYPE"
+          env.delete "HTTP_CONTENT_LENGTH"
+  
+          env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+  
+          env.update({"rack.version" => [0,1],
+                       "rack.input" => request.body || StringIO.new(""),
+                       "rack.errors" => STDERR,
+  
+                       "rack.multithread" => true,
+                       "rack.multiprocess" => false, # ???
+                       "rack.run_once" => false,
+  
+                       "rack.url_scheme" => "http",
+                       "rack.streaming" => true
+                     })
+          env["QUERY_STRING"] ||= ""
+          env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+  
+          status, headers, body = @app.call(env)
+  
+          begin
+            response.status = status.to_i
+            headers.each { |k, vs|
+              vs.each { |v|
+                response.header[k] = v
+              }
+            }
+            
+            if Proc === body
+              body.call(response)
+            else  
+              body.each { |part|
+                response.body << part
+              }
+            end
+            response.finished
+          ensure
+            body.close  if body.respond_to? :close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/merb-core/rack/middleware.rb

@@ -0,0 +1,20 @@
+module Merb
+  module Rack
+    class Middleware
+      
+      def initialize(app)
+        @app = app
+      end
+      
+      def deferred?(env)
+        @app.deferred?(env)
+      end
+  
+      def call(env)
+        @app.call(env)
+      end
+      
+    end
+  end
+end
+

data/lib/merb-core/rack/middleware/conditional_get.rb

@@ -0,0 +1,29 @@
+module Merb
+  module Rack
+
+    class ConditionalGet < Merb::Rack::Middleware
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        if document_not_modified?(env, headers)
+          status = 304
+          body = ""
+          # set Date header using RFC1123 date format as specified by HTTP
+          # RFC2616 section 3.3.1.
+        end
+        
+        [status, headers, body]
+      end
+    
+    private
+      def document_not_modified?(env, headers)
+        if etag = headers[Merb::Const::ETAG]
+          etag == env[Merb::Const::HTTP_IF_NONE_MATCH]
+        elsif last_modified = headers[Merb::Const::LAST_MODIFIED]
+          last_modified == env[Merb::Const::HTTP_IF_MODIFIED_SINCE]
+        end
+      end
+    end
+    
+  end
+end

data/lib/merb-core/rack/middleware/content_length.rb

@@ -0,0 +1,18 @@
+module Merb
+  module Rack
+
+    class ContentLength < Merb::Rack::Middleware
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        # to_s is because Rack spec expects header
+        # values to be iterable and yield strings
+        header = 'Content-Length'.freeze
+        headers[header] = body.size.to_s unless headers.has_key?(header)
+
+        [status, headers, body]
+      end
+    end
+    
+  end
+end

data/lib/merb-core/rack/middleware/csrf.rb

@@ -0,0 +1,73 @@
+require 'digest/md5'
+
+module Merb
+  module Rack
+
+    class Csrf < Merb::Rack::Middleware
+      HTML_TYPES = %w(text/html application/xhtml+xml)
+      POST_FORM_RE = Regexp.compile('(<form\W[^>]*\bmethod=(\'|"|)POST(\'|"|)\b[^>]*>)', Regexp::IGNORECASE)
+      ERROR_MSG = '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"><body><h1>403 Forbidden</h1><p>Cross Site Request Forgery detected. Request aborted.</p></body></html>'.freeze
+
+      def call(env)
+        status, header, body = @app.call(env)
+
+        if env[Merb::Const::REQUEST_METHOD] == Merb::Const::GET
+          body = process_response(body) if valid_content_type?(header[Merb::Const::CONTENT_TYPE])
+        elsif env[Merb::Const::REQUEST_METHOD] == Merb::Const::POST
+          status, body = process_request(env, status, body)
+        end
+
+        [status, header, body]
+      end
+
+      private
+      def process_request(env, status, body)
+        session_id = Merb::Config[:session_id_key]
+        csrf_token = _make_token(session_id)
+
+        request_csrf_token = env['csrf_authentication_token']
+
+        unless csrf_token == request_csrf_token
+          exception = Merb::ControllerExceptions::Forbidden.new(ERROR_MSG)
+          status = exception.status
+          body = exception.message
+
+          return [status, body]
+        end
+
+        return [status, body]
+      end
+
+      def process_response(body)
+        session_id = Merb::Config[:session_id_key]
+        csrf_token = _make_token(session_id)
+
+        if csrf_token
+          modified_body = ''
+          body.scan(POST_FORM_RE) do |match|
+            modified_body << add_csrf_field($~, csrf_token)
+          end
+
+          body = modified_body
+        end
+
+        body
+      end
+
+      def add_csrf_field(match, csrf_token)
+        modified_body = match.pre_match
+        modified_body << match.to_s
+        modified_body << "<div style='display: none;'><input type='hidden' id='csrf_authentication_token' name='csrf_authentication_token' value='#{csrf_token}' /></div>"
+        modified_body << match.post_match
+      end
+
+      def valid_content_type?(content_type)
+        HTML_TYPES.include?(content_type.split(';').first)
+      end
+
+      def _make_token(session_id)
+        Digest::MD5.hexdigest(Merb::Config[:session_secret_key] + session_id)
+      end
+    end
+  end
+end

data/lib/merb-core/rack/middleware/path_prefix.rb

@@ -0,0 +1,31 @@
+module Merb
+  module Rack
+    class PathPrefix < Merb::Rack::Middleware
+
+      def initialize(app, path_prefix = nil)
+        super(app)
+        @path_prefix = /^#{Regexp.escape(path_prefix)}/
+      end
+      
+      def deferred?(env)
+        strip_path_prefix(env) 
+        @app.deferred?(env)
+      end
+      
+      def call(env)
+        strip_path_prefix(env) 
+        @app.call(env)
+      end
+
+      def strip_path_prefix(env)
+        ['PATH_INFO', 'REQUEST_URI'].each do |path_key|
+          if env[path_key] =~ @path_prefix
+            env[path_key].sub!(@path_prefix, '')
+            env[path_key] = '/' if env[path_key].empty?
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/merb-core/rack/middleware/profiler.rb

@@ -0,0 +1,19 @@
+module Merb
+  module Rack
+    class Profiler < Merb::Rack::Middleware
+
+      def initialize(app, min=1, iter=1)
+        super(app)
+        @min, @iter = min, iter
+      end
+
+      def call(env)
+        __profile__("profile_output", @min, @iter) do
+          @app.call(env)
+        end
+      end
+
+      
+    end
+  end
+end

data/lib/merb-core/rack/middleware/static.rb

@@ -0,0 +1,45 @@
+module Merb
+  module Rack
+    class Static < Merb::Rack::Middleware
+
+      def initialize(app,directory)
+        super(app)
+        @static_server = ::Rack::File.new(directory)
+      end
+      
+      def call(env)        
+        path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : ""
+        cached_path = (path.empty? ? 'index' : path) + '.html'
+        
+        if file_exist?(path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the file if it's there and the request method is GET or HEAD
+          serve_static(env)
+        elsif file_exist?(cached_path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the page cache if it's there and the request method is GET or HEAD
+          env['PATH_INFO'] = cached_path
+          serve_static(env)
+        elsif path =~ /favicon\.ico/
+          return [404, {"Content-Type"=>"text/html"}, "404 Not Found."]
+        else
+          @app.call(env)
+        end
+      end
+      
+       # ==== Parameters
+        # path<String>:: The path to the file relative to the server root.
+        #
+        # ==== Returns
+        # Boolean:: True if file exists under the server root and is readable.
+        def file_exist?(path)
+          full_path = ::File.join(@static_server.root, ::Merb::Request.unescape(path))
+          ::File.file?(full_path) && ::File.readable?(full_path)
+        end
+
+        # ==== Parameters
+        # env<Hash>:: Environment variables to pass on to the server.
+        def serve_static(env)
+          env["PATH_INFO"] = ::Merb::Request.unescape(env["PATH_INFO"])        
+          @static_server.call(env)
+        end
+      
+    end
+  end
+end

data/lib/merb-core/rack/middleware/tracer.rb

@@ -0,0 +1,20 @@
+module Merb
+  module Rack
+    class Tracer < Merb::Rack::Middleware
+
+      def call(env)
+
+        Merb.logger.debug!("Rack environment:\n" + env.inspect + "\n\n")
+
+        status, headers, body = @app.call(env)
+
+        Merb.logger.debug!("Status: #{status.inspect}")
+        Merb.logger.debug!("Headers: #{headers.inspect}")
+        Merb.logger.debug!("Body: #{body.inspect}")
+
+        [status, headers, body]
+      end
+      
+    end
+  end
+end