merb 0.0.7 → 0.0.8

data/lib/merb/core_ext/merb_object.rb

@@ -0,0 +1,6 @@
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end

data/lib/merb/core_ext/merb_string.rb

@@ -0,0 +1,40 @@
+class String
+  
+  # reloads controller classes on each request if
+  # :allow_reloading is set to true in the config
+  # file or command line options.
+  def import
+    if Merb::Server.config[:allow_reloading] 
+      Object.send(:remove_const, self.camel_case.intern) rescue nil
+      load(self.snake_case  + '.rb')
+    else  
+      require(self.snake_case)
+    end
+  end
+  
+  # "FooBar".snake_case #=> "foo_bar"
+  def snake_case
+    return self unless self =~ %r/[A-Z]/
+    self.reverse.scan(%r/[A-Z]+|[^A-Z]*[A-Z]+?/).reverse.map{|word| word.reverse.downcase}.join '_'
+  end
+
+  # "foo_bar".camel_case #=> "FooBar"
+  def camel_case
+    return self if self =~ %r/[A-Z]/ and self !~ %r/_/
+    words = self.strip.split %r/\s*_+\s*/
+    words.map!{|w| w.downcase.sub(%r/^./){|c| c.upcase}}
+    words.join
+  end
+
+  # Concatenates a path
+  def /(o)
+    File.join(self, o.to_s)
+  end
+  
+  def to_const
+    const = const.to_s.dup
+    base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+  end
+  
+end

data/lib/merb/core_ext/merb_symbol.rb

@@ -0,0 +1,12 @@
+class Symbol
+  
+  # faster Symbol#to_s to speed up routing.
+  def to_s
+    @str_rep ||= id2name.freeze
+  end
+  
+  # ["foo", "bar"].map &:reverse #=> ['oof', 'rab']
+  def to_proc
+     Proc.new{|*args| args.shift.__send__(self, *args)}
+   end
+end

data/lib/merb/merb_constants.rb

@@ -0,0 +1,18 @@
+module Merb
+  module Const
+    
+    ESCAPE_TABLE = {
+      '&' => '&',
+      '<' => '&lt;',
+      '>' => '&gt;',
+      '"' => '&quot;',
+      "'" => '&#039;',
+    }.freeze
+    
+    DEFAULT_SEND_FILE_OPTIONS = {
+      :type         => 'application/octet-stream'.freeze,
+      :disposition  => 'attachment'.freeze
+    }.freeze
+    
+  end
+end

data/lib/merb/merb_controller.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__)+'/mixins/controller_mixin'
 require File.dirname(__FILE__)+'/mixins/render_mixin'
-require File.dirname(__FILE__)+'/mixins/javascript_mixin'
 require File.dirname(__FILE__)+'/mixins/responder_mixin'
+require File.dirname(__FILE__)+'/merb_request'
 
 module Merb
   
@@ -12,90 +12,99 @@ module Merb
   # to your controller via params. It also parses the ?query=string and
   # puts that into params as well.
   class Controller
+    
+    meta_accessor :layout
+    
     include Merb::ControllerMixin
     include Merb::RenderMixin
-    include Merb::JavascriptMixin
     include Merb::ResponderMixin
     
-    if Merb::Server.config[:session] 
-      require "drb"
-      DRb.start_service('druby://localhost:0')
-      Merb.const_set :DRbSession, DRbObject.new(nil, "druby://#{Merb::Server.config[:host]}:#{Merb::Server.config[:session]}")
-      require File.dirname(__FILE__)+"/session/merb_drb_session"
-      include ::Merb::SessionMixin
-      puts "drb session mixed in"
-    end
-    
     attr_accessor :status, :body
     
+    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]
-      @layout = :application
+      env = ::MerbHash[env.to_hash]
       @status, @method, @env, @headers, @root = 200, method.downcase.to_sym, env, 
           {'Content-Type' =>'text/html'}, env['SCRIPT_NAME'].sub(/\/$/,'')
-      @k = query_parse(env['HTTP_COOKIE'], ';,')
-      qs = query_parse(env['QUERY_STRING'])
-      #puts req.read; req.rewind
+      cookies = query_parse(env['HTTP_COOKIE'], ';,')
+      querystring = query_parse(env['QUERY_STRING'])
+      self.layout ||= :application
       @in = req
-      if %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)|n =~ (env['CONTENT_TYPE'])
-        b = /(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r$/
+      if MULTIPART_REGEXP =~ env['CONTENT_TYPE']
+        boundary_regexp = /(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r$/
         until @in.eof?
-          fh=MerbHash[]
-          for l in @in
-            case l
+          attrs=MerbHash[]
+          for line in @in
+            case line
             when "\r\n" : break
-            when /^Content-Disposition: form-data;/
-              fh.update MerbHash[*$'.scan(/(?:\s(\w+)="([^"]+)")/).flatten]
-            when /^Content-Type: (.+?)(\r$|\Z)/m
-              puts "=> fh[type] = #$1"
-              fh[:type] = $1
+            when CONTENT_DISPOSITION_REGEXP
+              attrs.update ::MerbHash[*$'.scan(FIELD_ATTRIBUTE_REGEXP).flatten]
+            when CONTENT_TYPE_REGEXP
+              attrs[:type] = $1
             end
           end
-          fn=fh[:name]
-          o=if fh[:filename]
-            o=fh[:tempfile]=Tempfile.new(:Merb)
-            o.binmode
+          name=attrs[:name]
+          io_buffer=if attrs[:filename]
+            io_buffer=attrs[:tempfile]=Tempfile.new(:Merb)
+            io_buffer.binmode
           else
-            fh=""
+            attrs=""
           end
-          while l=@in.read(16384)
-            if l=~b
-              o<<$`.chomp
-              @in.seek(-$'.size,IO::SEEK_CUR)
+          while chunk=@in.read(16384)
+            if chunk =~ boundary_regexp
+              io_buffer << $`.chomp
+              @in.seek(-$'.size, IO::SEEK_CUR)
               break
             end
-            o<<l
+            io_buffer << chunk
           end
-          qs[fn]=fh if fn
-          fh[:tempfile].rewind if fh.is_a?MerbHash
+          querystring[name]=attrs if name
+          attrs[:tempfile].rewind if attrs.is_a?MerbHash
         end
-      elsif @method == :post  
+      elsif @method == :post
         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
-          qs.merge!(json)
+          json = ::MerbHash.new(json) if json.is_a? Hash
+          querystring.merge!(json)
         else
-          qs.merge!(query_parse(@in.read))
+          querystring.merge!(query_parse(@in.read))
         end  
       end
-      @cookies, @params = @k.dup, qs.dup.merge(args)
-      @cookies.merge!(:sess_id => @params.delete(:sess_id)) if @params.has_key?:sess_id
+      @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)
+      @request = Request.new(@env, @method)
       MERB_LOGGER.info("Params: #{params.inspect}")
     end
     
     def dispatch(action=:to_s)
       start = Time.now
       setup_session if respond_to?:setup_session
-      if catch(:halt) { call_filters(before_filters) }
+      cought = catch(:halt) { call_filters(before_filters) }
+      case cought
+      when :filter_chain_completed
         @body = send(action)
-      else
+      when String
+        @body = cought
+      when nil
         @body = filters_halted
-      end    
+      when Symbol
+        @body = send(cought)
+      when Proc
+        @body = cought.call(self)  
+      else
+        raise MerbControllerError, "The before filter chain is broken dude."
+      end
+      call_filters(after_filters) 
       finalize_session if respond_to?:finalize_session
       MERB_LOGGER.info("Time spent in #{action} action: #{Time.now - start} seconds")
     end
@@ -105,7 +114,13 @@ module Merb
     def filters_halted
       "<html><body><h1>Filter Chain Halted!</h1></body></html>"  
     end
-          
+    
+    # accessor for @request. Please use request and 
+    # never @request directly.
+    def request
+       @request  
+    end
+            
     # accessor for @params. Please use params and 
     # never @params directly.
     def params
@@ -123,18 +138,27 @@ module Merb
     def headers
       @headers
     end
-
+    
+    # accessor for @session. Please use session and 
+    # never @session directly.    
+    def session
+      @session
+    end
+    
     # meta_accessor sets up a class instance variable that can
     # be unique for each class but also inherits the meta attrs
     # from its superclasses. Since @@class variables are almost
-    # global vars within an inheritance tree
+    # global vars within an inheritance tree, we use 
+    # @class_instance_variables instead
     meta_accessor :before_filters
+    meta_accessor :after_filters
     
+    # calls a filter chain according to rules.
     def call_filters(filter_set)
       (filter_set || []).each do |(filter, rule)|
         ok = false
-        if rule.has_key?(:include)
-          if rule[:include].include?(params[:action].intern)
+        if rule.has_key?(:only)
+          if rule[:only].include?(params[:action].intern)
             ok = true
           end  
         elsif rule.has_key?(:exclude)
@@ -150,23 +174,63 @@ module Merb
           when Proc
            filter.call(self) if ok
         end 
-      end 
+      end
+      return :filter_chain_completed
     end 
     
     # #before is a class method that allows you to specify before
-    # filters in your controllers. Filters can either before a symbol
-    # or string that corresponds to a method name or a proc object.
-    # if it is a method name that method will be called and if it
-    # is a proc it will be called with an argument of self. When 
+    # filters in your controllers. Filters can either be a symbol
+    # or string that corresponds to a method name to call, or a 
+    # proc object. if it is a method name that method will be 
+    # called and if it is a proc it will be called with an argument
+    # of self where self is the current controller object. When 
     # you use a proc as a filter it needs to take one parameter.
+    # 
+    # examples:
+    # before :some_filter
+    # before :authenticate, :exclude => [:login, :signup]
+    # before Proc.new {|c| c.some_method }, :only => :foo
+    #
+    # You can use either :only => :actionname or :exclude => [:this, :that]
+    # but not both at once. :only will only run before the listed actions
+    # and :exclude will run for every action that is not listed.
+    #
+    # Merb's before filter chain is very flixible. To halt the 
+    # filter chain you use throw :halt . If throw is called with
+    # only one argument of :halt the return of the method filters_halted 
+    # will be what is rendered to the view. You can overide filters_halted
+    # in your own controllers to control what it outputs. But the throw
+    # construct is much more powerful then just that. throw :halt can
+    # also take a second argument. Here is what that second arg can be 
+    # and the behavior each type can have:
+    #
+    # when the second arg is a string then that string will be what
+    # is rendered to the browser. Since merb's render method returns
+    # a string you can render a template or just use a plain string:
+    #
+    # String:
+    # throw :halt, "You don't have permissions to do that!"
+    # throw :halt, render(:action => :access_denied)
+    #
+    # if the second arg is a symbol then the method named after that
+    # symbol will be called
+    # Symbol: 
+    # throw :halt, :must_click_disclaimer
+    #
+    # If the second arg is a Proc, it will be called and its return
+    # value will be what is rendered to the browser:
+    # Proc:
+    # throw :halt, Proc.new {|c| c.access_denied }
+    # throw :halt, Proc.new {|c| Tidy.new(c.index) }
+    # 
     def self.before(filter, opts={})
       raise(ArgumentError,
-        "You can specify either :include or :exclude but 
+        "You can specify either :only or :exclude but 
          not both at the same time for the same filter."
-      ) if opts.has_key?(:include) && opts.has_key?(:exclude)
+      ) if opts.has_key?(:only) && opts.has_key?(:exclude)
       
-      if opts[:include] && opts[:include].is_a?(Symbol)
-        opts[:include] = [opts[:include]]
+      if opts[:only] && opts[:only].is_a?(Symbol)
+        opts[:only] = [opts[:only]]
       end 
       if opts[:exclude] && opts[:exclude].is_a?(Symbol)
         opts[:exclude] = [opts[:exclude]]
@@ -181,23 +245,33 @@ module Merb
         )        
       end  
     end
-
-    if Merb::Server.config[:basic_auth] 
-      require File.dirname(__FILE__)+"/mixins/basic_authentication_mixin"
-      include ::Merb::Authentication
-      puts "Basic Authentication mixed in"
+    
+    # #after is a class method that allows you to specify after
+    # filters in your controllers. Filters can either be a symbol
+    # or string that corresponds to a method name or a proc object.
+    # if it is a method name that method will be called and if it
+    # is a proc it will be called with an argument of self. When 
+    # you use a proc as a filter it needs to take one parameter.
+    # you can gain access to the response body like so:
+    # after Proc.new {|c| Tidy.new(c.body) }, :only => :index
+    # 
+    def self.after(filter, opts={})
+      raise(ArgumentError,
+        "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
+      if opts[:only] && opts[:only].is_a?(Symbol)
+        opts[:only] = [opts[:only]]
+      end 
+      if opts[:exclude] && opts[:exclude].is_a?(Symbol)
+        opts[:exclude] = [opts[:exclude]]
+      end
+      (self.after_filters ||= []) << [filter, opts]
     end
     
   end  
   
 end
-
-class Noroutefound < Merb::Controller
-  # This is the class that handles requests that don't
-  # match any defined routes.
-  def method_missing
-    @status = 404
-    "<html><body><h1>No Matching Route!</h1></body></html>"    
-  end  
-
-end

data/lib/merb/{session/merb_drb_server.rb → merb_drb_server.rb}

@@ -1,5 +1,5 @@
 require 'drb'
-require 'thread'
+require File.dirname(__FILE__)+'/merb_upload_progress'
 
 module Merb
   
@@ -15,6 +15,7 @@ module Merb
         @timestamps = Hash.new
         @mutex = Mutex.new
         @session_ttl = opts.fetch(:session_ttl, 15*60) # default 15 minutes
+        start_timer
         self
       end
       
@@ -51,57 +52,23 @@ module Merb
         GC.start
       end  
       
+      def start_timer
+        Thread.new do
+          sleep @session_ttl
+          reap_old_sessions
+        end  
+      end  
+      
       def sessions
         @sessions
       end  
       
+      def upload_progress
+        ::Merb::UploadProgress.new
+      end  
+      
     end # end singleton class
     
   end # end DRbSession
   
-  # Keeps track of the status of all currently processing uploads
-  class UploadProgress
-    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