merb 0.0.7 → 0.0.8

data/lib/merb/merb_exceptions.rb

@@ -0,0 +1,4 @@
+module Merb
+  class Noroutefound < RuntimeError; end  
+  class MissingControllerFile < RuntimeError; end
+end  

data/lib/merb/merb_handler.rb

@@ -1,4 +1,3 @@
-
 class MerbHandler < Mongrel::HttpHandler
   @@file_only_methods = ["GET","HEAD"]
   
@@ -31,7 +30,7 @@ class MerbHandler < Mongrel::HttpHandler
       return
     end
     
-    MERB_LOGGER.info("Request: PATH_INFO: #{request.params[Mongrel::Const::PATH_INFO]}")
+    MERB_LOGGER.info("\nRequest: PATH_INFO: #{request.params[Mongrel::Const::PATH_INFO]}  (#{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 
@@ -58,18 +57,16 @@ class MerbHandler < Mongrel::HttpHandler
         controller, action = handle(request)
         MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{action}\nParsing HTTP Input took: #{Time.now - start} seconds")
         
-        # special case allows the progress action of a Files controller
-        # to be handled without locking since no db access is required.
-        # but we do need to synchronize whenever you use ActiveRecord 
-        # in your controllers.
-        if (action == 'progress') && (Files === controller)
-          puts 'skip mutex'
+        # 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)
-        else
-          @guard.synchronize {
-            controller.dispatch(action)
-          }
-        end
+        }
       rescue Exception => e
         response.start(500) do |head,out|
           head["Content-Type"] = "text/html"
@@ -98,10 +95,25 @@ class MerbHandler < Mongrel::HttpHandler
       
       if sendfile
         MERB_LOGGER.info("X-SENDFILE: #{sendfile}\nComplete Request took: #{Time.now - start} seconds")
-        # send X-SENDFILE header to mongrel
-        response.send_status(File.size(sendfile))
+        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
+        # Calculated the same as apache, not sure how well the works on win32
+        response.header[Mongrel::Const::ETAG] = Mongrel::Const::ETAG_FORMAT % [file_status.mtime.to_i, file_status.size, file_status.ino]
+        # send a status with out content length
+        response.send_status(file_status.size)
         response.send_header
         response.send_file(sendfile)
+      elsif controller.body.respond_to? :read
+        response.send_status(clength)
+        response.send_header
+        while chunk = controller.body.read(16384)
+          response.write(chunk)
+        end
+        if controller.body.respond_to? :close
+          controller.body.close
+        end
       else
         MERB_LOGGER.info("Response status: #{response.status}\nComplete Request took: #{Time.now - start} seconds\n\n")
         # render response from successful controller
@@ -131,12 +143,12 @@ class MerbHandler < Mongrel::HttpHandler
   # this is where your Merb::Controller is instantiated.
   def instantiate_controller(controller_name, req, env, params) 
     if !File.exist?(Merb::Server.config[:dist_root]+"/app/controllers/#{controller_name.snake_case}.rb")
-      return Object.const_get(:Noroutefound).new(req, env, params)
+      raise Merb::MissingControllerFile
     end
     begin
       controller_name.import
       return Object.const_get( controller_name.camel_case ).new(req, env, params)
-    rescue Exception
+    rescue RuntimeError
       warn "Error getting instance of '#{controller_name.camel_case}': #{$!}"
       raise $!
     end

data/lib/merb/merb_request.rb

@@ -0,0 +1,95 @@
+module Merb
+
+  class Request
+    
+    def initialize(env, method)
+      @env = env
+      @method = method
+    end
+    
+    # returns true if the request is an ajax request.
+    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?(Mongrel::Const::HTTP_X_FORWARDED_FOR) then
+        remote_ips = @env[Mongrel::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[Mongrel::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 he request uri.
+    def uri
+      @env['REQUEST_URI']
+    end
+    
+    # returns the uri without the query string.
+    def path
+      uri ? uri.split('?').first : ''
+    end
+    
+    # returns the PATH_INFO
+    def path_info
+      @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
+    
+    # returns the REQUEST_METHOD
+    def method
+      @method ||= @env['REQUEST_METHOD']
+    end  
+    
+    # create predicate methods for querying the REQUEST_METHOD
+    [:get, :post, :put, :delete, :head].each do |m|
+      eval %{
+        def #{m}?; method == :#{m}; end
+      }
+    end
+  
+  end
+  
+end    
+    
+    

data/lib/merb/merb_upload_handler.rb

@@ -0,0 +1,46 @@
+require 'mongrel'
+
+
+class MerbUploadHandler < Mongrel::HttpHandler
+
+  def initialize(options = {})
+    @path_info      = Array(options[:path_info])
+    @frequency      = options[:frequency] || 3
+    @request_notify = true
+    if options[:drb]
+      require 'drb'
+      DRb.start_service
+      Mongrel.const_set :Uploads, DRbObject.new(nil, "druby://#{Merb::Server.config[:host]}:#{Merb::Server.config[:session]}").upload_progress
+    else
+      require File.dirname(__FILE__)+'/merb_upload_progress'
+      Mongrel.const_set :Uploads, Merb::UploadProgress.new
+    end
+    Mongrel::Uploads.debug = true if options[:debug]
+  end
+
+  def request_begins(params)
+    upload_notify(:add, params, params[Mongrel::Const::CONTENT_LENGTH].to_i)
+  end
+
+  def request_progress(params, clen, total)
+    upload_notify(:mark, params, clen)
+  end
+
+  def process(request, response)
+    upload_notify(:finish, request.params)
+  end
+
+  private
+    def upload_notify(action, params, *args)
+      return unless @path_info.include?(params['PATH_INFO']) &&
+        params[Mongrel::Const::REQUEST_METHOD] == 'POST' &&
+        upload_id = Mongrel::HttpRequest.query_parse(params['QUERY_STRING'])['upload_id']
+      if action == :mark
+        last_checked_time = Mongrel::Uploads.last_checked(upload_id)
+        return unless last_checked_time && Time.now - last_checked_time > @frequency
+      end
+      Mongrel::Uploads.send(action, upload_id, *args) 
+      Mongrel::Uploads.update_checked_time(upload_id) unless action == :finish
+    end
+end
+

data/lib/merb/merb_upload_progress.rb

@@ -0,0 +1,48 @@
+module Merb
+  # Keeps track of the status of all currently processing uploads
+  class UploadProgress
+    include DRbUndumped
+    attr_accessor :debug
+    def initialize
+      @guard    = Mutex.new
+      @counters = {}
+    end
+  
+    def check(upid)
+      @counters[upid].last rescue nil
+    end
+  
+    def last_checked(upid)
+      @counters[upid].first rescue nil
+    end
+  
+    def update_checked_time(upid)
+      @guard.synchronize { @counters[upid][0] = Time.now }
+    end
+  
+    def add(upid, size)
+      @guard.synchronize do
+        @counters[upid] = [Time.now, {:size => size, :received => 0}]
+        puts "#{upid}: Added" if @debug
+      end
+    end
+  
+    def mark(upid, len)
+      return unless status = check(upid)
+      puts "#{upid}: Marking" if @debug
+      @guard.synchronize { status[:received] = status[:size] - len }
+    end
+  
+    def finish(upid)
+      @guard.synchronize do
+        puts "#{upid}: Finished" if @debug
+        @counters.delete(upid)
+      end
+    end
+  
+    def list
+      @counters.keys.sort
+    end
+  end
+  
+end  

data/lib/merb/merb_view_context.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__)+'/mixins/erubis_capture_mixin'
+require File.dirname(__FILE__)+'/mixins/javascript_mixin'
+
+module Merb
+  
+  # the ViewContext is really
+  # just an empty container for us to fill with instance 
+  # variables from the controller, include helpers into
+  # and then use as the context object passed to Erubis
+  # when evaluating the templates.
+  class ViewContext
+    include Merb::ErubisCaptureMixin
+    include Merb::JavascriptMixin
+    
+    def initialize(controller)
+      @controller = controller
+      (@controller.instance_variables - %w[@cookies @session @headers @params 
+                 @env @in @status @root @method @request @fingerprint_before
+                  @controller @k]).each do |ivar|
+        self.instance_variable_set(ivar, @controller.instance_variable_get(ivar))
+      end
+      begin
+        self.class.class_eval("include Merb::#{@controller.class.name}Helper")
+      rescue NameError
+        MERB_LOGGER.info("Missing Helper: Merb::#{@controller.class.name}Helper")
+      end  
+    end
+    
+    # accessor for the view. refers to the current @controller object
+    def controller
+      @controller
+    end  
+    
+    # catch any method calls that the controller responds to
+    # and delegate them back to the controller.
+    def method_missing(sym, *args, &blk)
+      if @controller.respond_to? sym
+        @controller.send(sym, *args, &blk)
+      else
+        super
+      end    
+    end
+    
+  end
+  
+end  

data/lib/merb/merb_yaml_store.rb

@@ -0,0 +1,31 @@
+require 'yaml/store'
+
+module Merb
+  # thanks to Michael Fellinger from Ramaze
+  class SimpleModel
+    attr_accessor :db
+  
+    def initialize(filename = "#{DIST_ROOT}/schema/db.yaml")
+      FileUtils.touch(filename)
+      @db = YAML::Store.new(filename)
+    end
+  
+    def method_missing(meth, *args, &block)
+      @db.transaction do
+        @db.send(meth, *args, &block)
+      end
+    end
+    
+    def [](key)
+      @db.transaction do
+        @db[key]
+      end
+    end
+  
+    def []=(key, value)
+      @db.transaction do
+        @db[key] = value
+      end
+    end
+  end
+end

data/lib/merb/mixins/basic_authentication_mixin.rb

@@ -18,13 +18,13 @@ module Merb
     
     def authenticate
       if !authenticated?
-        throw :halt
+        throw :halt, :access_denied
       end
     end
       
     def self.included(base)
       base.class_eval do
-        def filters_halted
+        def access_denied
           @status = 401
           @headers['Content-type'] = 'text/plain'
           @headers['Status'] = 'Unauthorized'

data/lib/merb/mixins/controller_mixin.rb

@@ -14,8 +14,22 @@ module Merb
     # pass in a path to a file and this will set the
     # right headers and let mongrel do its thang and
     # serve the static file directly.
-    def send_file(file)
-      headers['X-SENDFILE'] = file
+    def send_file(file, opts={})
+      opts.update(Merb::Const::DEFAULT_SEND_FILE_OPTIONS.merge(opts))
+      [:type, :disposition].each do |arg|
+        raise ArgumentError, ":#{arg} option required" if opts[arg].nil?
+      end
+
+      disposition = opts[:disposition].dup || 'attachment'
+
+      disposition << %(; filename="#{opts[:filename] ? opts[:filename] : File.basename(file)}")
+
+      headers.update(
+        'Content-Type'              => opts[:type].strip,  # fixes a problem with extra '\r' with some browsers
+        'Content-Disposition'       => disposition,
+        'Content-Transfer-Encoding' => 'binary',
+        'X-SENDFILE'                => file
+      )
       return
     end
     
@@ -41,10 +55,18 @@ module Merb
           }
     end
   
+    # creates a random token like:
+    # "b9a82e011694cc13a4249731b9e83cea" 
     def make_token
       require 'digest/md5'
       Digest::MD5.hexdigest("#{inspect}#{Time.now}#{rand}")
     end  
+
+    def escape_xml(obj)
+      obj.to_s.gsub(/[&<>"']/) { |s| Merb::Const::ESCAPE_TABLE[s] }
+    end
+    alias h escape_xml
+    alias html_escape escape_xml
   
     # does url escaping
     def escape(s)
@@ -56,78 +78,5 @@ module Merb
       Mongrel::HttpRequest.unescape(s)
     end
   
-    # returns true if the request is an ajax request.
-    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?(Mongrel::Const::HTTP_X_FORWARDED_FOR) then
-        remote_ips = @env[Mongrel::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[Mongrel::Const::REMOTE_ADDR]
-    end
-    
-    # returns either 'https://' or 'http://' depending on
-    # the HTTPS header
-    def protocol
-      @env['HTTPS'] == 'on' ? 'https://' : 'http://'
-    end
-    
-    # returns true if the request is an SSL request
-    def ssl?
-      @env['HTTPS'] == 'on'
-    end
-    
-    # The request uri.
-    def uri
-      @env['REQUEST_URI']
-    end
-    
-    # The path is the uri without the query string.
-    def path
-      uri ? uri.split('?').first : ''
-    end
-  
-    def path_info
-      @env['PATH_INFO']
-    end
-    
-    def port
-      @env['SERVER_PORT'].to_i
-    end
-  
-    def host
-      @env['HTTP_X_FORWARDED_HOST'] || @env['HTTP_HOST'] 
-    end
-    
-    def subdomains(tld_length = 1)
-      parts = host.split('.')
-      parts[0..-(tld_length+2)]
-    end
-    
-    def domain(tld_length = 1)
-      host.split('.').last(1 + tld_length).join('.')
-    end
-    
-    def method
-      @method ||= @env['REQUEST_METHOD']
-    end  
-    
-    [:get, :post, :put, :delete, :head].each do |m|
-      eval %{
-        def #{m}?; method == :#{m}; end
-      }
-    end
   end
 end