merb 0.3.4 → 0.3.7

data/lib/merb/session.rb

@@ -0,0 +1,23 @@
+module Merb
+  module SessionMixin
+    
+    def rand_uuid
+      sid = "%04x%04x%04x%04x%04x%06x%06x" % [
+                                            rand(0x0010000),
+                                            rand(0x0010000),
+                                            rand(0x0010000),
+                                            rand(0x0010000),
+                                            rand(0x0010000),
+                                            rand(0x1000000),
+                                            rand(0x1000000),
+                                           ]
+      sid                                     
+    end
+    
+    def needs_new_cookie!
+      @_new_cookie = true
+    end
+    
+    module_function :rand_uuid, :needs_new_cookie!
+  end
+end  

data/lib/merb/session/merb_ar_session.rb

@@ -6,20 +6,17 @@ module Merb
 
     def setup_session
       MERB_LOGGER.info("Setting up session")
-      before = @cookies[_session_id_key]
-      @session, @cookies[_session_id_key] = Merb::Session.persist(@cookies[_session_id_key])
-      @_fingerprint_before = Marshal.dump(@session).hash
-      @_new_cookie = @cookies[_session_id_key] != before
+      before = @_cookies[_session_id_key]
+      @_session, @_cookies[_session_id_key] = Merb::Session.persist(@_cookies[_session_id_key])
+      @_fingerprint = Marshal.dump(@_session.data).hash
+      @_new_cookie = @_cookies[_session_id_key] != before
     end
 
     def finalize_session
       MERB_LOGGER.info("Finalize session")
-      unless Marshal.dump(@session).hash == @_fingerprint_before
-        @session.save
-      end
-      set_cookie(_session_id_key, @cookies[_session_id_key], Time.now+Merb::Const::WEEK*2) if @_new_cookie
-    end 
-
+      @_session.save if @_fingerprint != Marshal.dump(@_session.data).hash
+      set_cookie(_session_id_key, @_session.session_id, _session_expiry) if (@_new_cookie || @_session.needs_new_cookie)
+    end
   end
 
   class Session < ::ActiveRecord::Base
@@ -28,14 +25,12 @@ module Merb
     self.data_column_name = 'data'
     before_save :marshal_data!
     before_save :raise_on_session_data_overflow!
-  
-    RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+    attr_accessor :needs_new_cookie
   
     class << self
       # Generates a new session ID and creates a row for the new session in the database.
       def generate
-        rand_max = RAND_CHARS.size
-        sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
+        sid = Merb::SessionMixin::rand_uuid
         create(:session_id => sid, :data => {})
       end
 
@@ -78,6 +73,24 @@ module Merb
       end
     end
     
+    # Regenerate the Session ID  
+   	def regenerate 
+   	  new_id = Merb::SessionMixin::rand_uuid 
+   	  update_attributes({:session_id => new_id}) 
+   	  self.needs_new_cookie=true 
+   	end 
+   	 
+   	# Recreates the cookie with the default expiration time 
+   	# Useful during log in for pushing back the expiration date 
+   	def refresh_expiration 
+   	  self.needs_new_cookie=true 
+   	end 
+   	
+   	# Lazy-delete of session data 
+   	def delete  
+   	  self.data = {} 
+   	end
+    
     def [](key)
       data[key]
     end
@@ -115,5 +128,4 @@ module Merb
         end
       end
   end
-
-end
+end

data/lib/merb/session/merb_mem_cache_session.rb

@@ -0,0 +1,108 @@
+require 'memcache_util'
+
+module Merb
+
+  module SessionMixin
+
+    def setup_session
+      MERB_LOGGER.info("Setting up session")
+      before = @_cookies[_session_id_key]
+      @_session, @_cookies[_session_id_key] = Merb::MemCacheSession.persist(@_cookies[_session_id_key])
+      @_fingerprint = Marshal.dump(@_session.data).hash
+      @_new_cookie = cookies[_session_id_key] != before
+    end
+
+    def finalize_session
+      MERB_LOGGER.info("Finalize session")
+      ::Cache.put("session:#{@_session.session_id}", @_session) if @_fingerprint != Marshal.dump(@_session.data).hash
+      set_cookie(_session_id_key, @_session.session_id, _session_expiry) if (@_new_cookie || @_session.needs_new_cookie)
+    end
+
+  end
+
+  ##
+  # Sessions stored in memcached.
+  #
+  # Requires setup in your +merb_init.rb+:
+  #
+  #   require 'memcache_util'
+  #   CACHE = MemCache.new('127.0.0.1:11211', { :namespace => 'my_app' })
+  #
+  # And a setting in +merb.yml+:
+  #
+  #   :mem_cache_session: true
+
+  class MemCacheSession
+
+    attr_accessor :session_id
+    attr_accessor :data
+    attr_accessor :needs_new_cookie
+    
+    def initialize(session_id)
+      @session_id = session_id
+      @data = {}
+    end
+
+    class << self
+      # Generates a new session ID and creates a row for the new session in the database.
+      def generate
+        sid = Merb::SessionMixin::rand_uuid
+        new(sid)
+      end
+
+      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
+      # If none is found, generates a new session.
+      def persist(session_id)
+        if session_id
+          session = ::Cache.get("session:#{session_id}")
+          if session.nil?
+            # Not in memcached, but assume that cookie exists
+            session = new(session_id)
+          end
+        else
+          # No cookie...make a new session_id
+          session = generate
+        end
+        [session, session.session_id]
+      end
+
+      # Don't try to reload in dev mode.
+      def reloadable? #:nodoc:
+        false
+      end
+
+    end
+
+    # Regenerate the Session ID  
+   	def regenerate 
+   	  @session_id = Merb::SessionMixin::rand_uuid 
+   	  self.needs_new_cookie=true 
+   	end 
+   	 
+   	# Recreates the cookie with the default expiration time 
+   	# Useful during log in for pushing back the expiration date 
+   	def refresh_expiration 
+   	  self.needs_new_cookie=true 
+   	end 
+   	
+   	# Lazy-delete of session data 
+   	def delete  
+   	  @data = {} 
+   	end
+   	
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, val)
+      @data[key] = val
+    end
+
+    # Has the session been loaded yet?
+    def loaded?
+      !! @data
+    end
+
+  end
+
+end

data/lib/merb/session/merb_memory_session.rb

@@ -4,43 +4,88 @@ module Merb
 
     def setup_session
       MERB_LOGGER.info("Setting up session")
-      before = @cookies[_session_id_key]
-      @session , @cookies[_session_id_key] = Merb::MemorySession.persist(@cookies[_session_id_key])
-      @_new_cookie = @cookies[_session_id_key] != before
+      before = @_cookies[_session_id_key]
+      @_session , @_cookies[_session_id_key] = Merb::MemorySession.persist(@_cookies[_session_id_key])
+      @_new_cookie = @_cookies[_session_id_key] != before
     end
 
     def finalize_session
       MERB_LOGGER.info("Finalize session")
-      set_cookie(_session_id_key, @cookies[_session_id_key], Time.now+Merb::Const::WEEK*2) if @_new_cookie
+      set_cookie(_session_id_key, @_session.session_id, _session_expiry) if (@_new_cookie || @_session.needs_new_cookie)
     end 
 
   end
   
   class MemorySession
-        
-    class << self
-  
-      RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
 
+    attr_accessor :session_id
+    attr_accessor :data
+    attr_accessor :needs_new_cookie
+    
+    def initialize(session_id)
+      @session_id = session_id
+      @data = {}
+    end
+
+    class << self
       # Generates a new session ID and creates a row for the new session in the database.
       def generate
-        rand_max = RAND_CHARS.size
-        sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
-        [create(:session_id => sid, :data => {}), sid]
+        sid = Merb::SessionMixin::rand_uuid
+        MemorySessionContainer[sid] = new(sid)
       end
-      
+
       # Gets the existing session based on the <tt>session_id</tt> available in cookies.
       # If none is found, generates a new session.
       def persist(session_id)
         if session_id
-          session = self[session_id]
-          sid = session_id
+          session = session = MemorySessionContainer[session_id]
         end
         unless session
-          session, sid = generate
+          session = generate
         end
-        [session, sid]
+        [session, session.session_id]
       end
+
+    end
+
+    # Regenerate the Session ID  
+   	def regenerate
+   	  new_sid = Merb::SessionMixin::rand_uuid 
+   	  old_sid = @session_id
+   	  MemorySessionContainer[new_sid] = MemorySessionContainer[old_sid]
+   	  @session_id = new_sid
+   	  MemorySessionContainer.delete(old_sid)
+   	  self.needs_new_cookie=true 
+   	end 
+   	 
+   	# Recreates the cookie with the default expiration time 
+   	# Useful during log in for pushing back the expiration date 
+   	def refresh_expiration 
+   	  self.needs_new_cookie=true 
+   	end 
+   	
+   	# Lazy-delete of session data 
+   	def delete
+   	  @data = {} 
+   	end
+   	
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, val)
+      @data[key] = val
+    end
+
+    # Has the session been loaded yet?
+    def loaded?
+      !! @data
+    end
+
+  end
+  
+  class MemorySessionContainer
+    class << self
       
       def setup(opts={})
         @opts = opts
@@ -55,6 +100,7 @@ module Merb
       def create(opts={})
         self[opts[:session_id]] = opts[:data]
       end  
+
       
       def [](key)
         @mutex.synchronize {
@@ -62,7 +108,7 @@ module Merb
           @sessions[key]
         }
       end  
-       
+      
       def []=(key, val) 
         @mutex.synchronize {
           @timestamps[key] = Time.now
@@ -98,9 +144,8 @@ module Merb
       def sessions
         @sessions
       end  
-  
+      
     end # end singleton class
-    
-  end # end DRbSession
 
+  end # end MemorySessionContainer
 end

data/lib/merb/template/erubis.rb

@@ -1,25 +1,33 @@
-module Merb
-  module Template
-
+module Merb # :nodoc:
+  module Template # :nodoc:
 
+    # Module to allow you to use Embedded Ruby templates through Erubis["http://www.kuwata-lab.com/erubis/"].
+    # Your template must end in .herb (HTML and ERb), .jerb (JavaScript ERb), .erb (Embedded Ruby), or .rhtml (Ruby HTML) for Merb to use it.
     module Erubis
-      ::Merb::Controller.register_engine self, %w[ herb jerb erb rhtml ]
+      ::Merb::AbstractController.register_engine self, %w[ herb jerb erb rhtml html.erb js.erb ]
       class << self
         
         @@erbs = {}
         @@mtimes = {}
         
-        def exempt_from_layout?
+        def exempt_from_layout? # :nodoc:
           false    
         end
-    
+       
+        # Main method to compile the ERb template.
+        # 
+        # In the case of ERb/Erubis, it first checks the template cache for precompiled
+        # templates.  If no precompiled version is found, then it compiles the template
+        # by calling <tt>new_eruby_obj</tt>, which will compile the template and return an Erubis
+        # object holding the parsed template.
         def transform(options = {})
           opts, file, view_context = options.values_at(:opts, :file, :view_context)
           eruby = new_eruby_obj(file)
-          view_context.class.send(:include, ::Merb::ErubisCaptureMixin)
+          view_context.extend(::Merb::ErubisCaptureMixin)
           eruby.evaluate(view_context)
         end
         
+        # Creates a new Erubis object to parse the template given in +path+.
         def new_eruby_obj(path)
           if @@erbs[path] && !cache_template?(path)
             return @@erbs[path]
@@ -37,12 +45,13 @@ module Merb
           end  
         end
         
-        def cache_template?(path)
-          return false unless ::Merb::Server.config[:cache_templates]
-          return true unless @@erbs[path]
-          @@mtimes[path] < File.mtime(path) ||
-            (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
-        end
+        private
+          def cache_template?(path)
+            return false unless ::Merb::Server.config[:cache_templates]
+            return true unless @@erbs[path]
+            @@mtimes[path] < File.mtime(path) ||
+              (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
+          end
         
       end
     end

data/lib/merb/template/haml.rb

@@ -5,25 +5,13 @@ begin
 rescue LoadError
   puts "you must install the haml gem to use .haml templates"
 end
-module ActionView
-  # stub, in case the requires for that active_* stuff of Haml doesn't fail
-  # but we are not running Rails ;)
-  class Base
-    # stub
-    def concat
-    end
-    # stub
-    def form_tag
-    end
-  end
-end
 
 
 module Merb
   module Template
     module Haml
     
-       ::Merb::Controller.register_engine self, %w[ haml ]
+       ::Merb::AbstractController.register_engine self, %w[ haml ]
     
       class << self
         
@@ -70,10 +58,11 @@ module Merb
           def build_locals(locals)
             locals_code = ""
          	  if locals
-         	    locals_code = locals.keys.inject("") do |code, key| 
-                code << "- #{key} = @_merb_partial_locals[:#{key}]\n"
+              locals.keys.each do |key|
+                locals_code << "- #{key} = @_merb_partial_locals[:#{key}]\n"
               end
             end
+            locals_code
           end
         
           def cache_template?(path)
@@ -87,4 +76,4 @@ module Merb
       
     end
   end
-end
+end

data/lib/merb/template/markaby.rb

@@ -21,7 +21,7 @@ module Merb
     
     module Markaby
     
-      ::Merb::Controller.register_engine self, %w[ mab ]
+      ::Merb::AbstractController.register_engine self, %w[ mab ]
     
       class << self
 
@@ -35,9 +35,11 @@ module Merb
           opts, file, view_context = options.values_at(:opts, :file, :view_context)
           
           if opts[:locals]
-            locals = opts[:locals].keys.inject("") do |code, key| 
-              code << "#{key} = @_merb_partial_locals[:#{key}]\n"
+            locals = ""
+            opts[:locals].keys.each do |key|
+              locals << "#{key} = @_merb_partial_locals[:#{key}]\n"
             end
+            locals
           end
           
           mab = ::Markaby::Builder.new({}, view_context) {