merb-core 0.9.3 → 0.9.4

data/lib/merb-core/dispatch/session.rb

@@ -1,7 +1,19 @@
 module Merb
   
   module SessionMixin
+    # Sets the session id cookie, along with the correct
+    # expiry and domain -- used for new or reset sessions
+    def set_session_id_cookie(key)
+      options = {}
+      options[:value] = key
+      options[:expires] = Time.now + _session_expiry if _session_expiry > 0
+      options[:domain] = _session_cookie_domain if _session_cookie_domain
+      cookies[_session_id_key] = options
+    end
 
+    @_finalize_session_exception_callbacks = []
+    @_persist_exception_callbacks = []
+    
     # ==== Returns
     # String:: A random 32 character string for use as a unique session ID.
     def rand_uuid
@@ -21,8 +33,46 @@ module Merb
     def needs_new_cookie!
       @_new_cookie = true
     end
+
+    # Adds a callback to the list of callbacks run when
+    # exception is raised on session finalization, so
+    # you can recover.
+    #
+    # See session mixins documentation for details on
+    # session finalization.
+    #
+    # ==== Params
+    # &block::
+    #   A block to be added to the callbacks that will be executed
+    #   if there's exception on session finalization.
+    def finalize_session_exception_callbacks(&block)
+      if block_given?
+        @_finalize_session_exception_callbacks << block
+      else
+        @_finalize_session_exception_callbacks
+      end
+    end
+
+    # Adds a callback to the list of callbacks run when
+    # exception is raised on session persisting, so
+    # you can recover.
+    #
+    # See session mixins documentation for details on
+    # session persisting.
+    #
+    # ==== Params
+    # &block::
+    #   A block to be added to the callbacks that will be executed
+    #   if there's exception on session persisting.
+    def persist_exception_callbacks(&block)
+      if block_given?
+        @_persist_exception_callbacks << block
+      else
+        @_persist_exception_callbacks
+      end
+    end
     
-    module_function :rand_uuid, :needs_new_cookie!
+    module_function :rand_uuid, :needs_new_cookie!, :finalize_session_exception_callbacks, :persist_exception_callbacks
   end
 
-end
+end

data/lib/merb-core/dispatch/session/cookie.rb

@@ -3,7 +3,7 @@ require 'openssl'       # to generate the HMAC message digest
 # Most of this code is taken from bitsweat's implementation in rails
 module Merb
 
-  module SessionMixin #:nodoc:
+  module SessionMixin
 
     # Adds a before and after dispatch hook for setting up the cookie session
     # store.
@@ -20,7 +20,9 @@ module Merb
     def finalize_session
       new_session = request.session.read_cookie
       if @original_session != new_session
-        cookies.set_cookie(_session_id_key, new_session, :expires => (Time.now + _session_expiry))
+        options = {:expires => (Time.now + _session_expiry)}
+        options[:domain] = _session_cookie_domain if _session_cookie_domain
+        cookies.set_cookie(_session_id_key, new_session, options)
       end
     end
 

data/lib/merb-core/dispatch/session/memcached.rb

@@ -1,6 +1,6 @@
 module Merb
 
-  module SessionMixin #:nodoc:
+  module SessionMixin
 
     # Adds a before and after dispatch hook for setting up the memcached
     # session store.
@@ -8,23 +8,29 @@ module Merb
     # ==== Parameters
     # base<Class>:: The class to which the SessionMixin is mixed into.
     def setup_session
-      before = cookies[_session_id_key]
-      request.session, cookies[_session_id_key] = Merb::MemCacheSession.persist(cookies[_session_id_key])
+      orig_key = cookies[_session_id_key]
+      session, key = Merb::MemCacheSession.persist(orig_key)
+      request.session = session
       @_fingerprint = Marshal.dump(request.session.data).hash
-      @_new_cookie = cookies[_session_id_key] != before
+      if key != orig_key 
+        set_session_id_cookie(key)
+      end
     end
 
     # Finalizes the session by storing the session ID in a cookie, if the
     # session has changed.
-    def finalize_session 
+    def finalize_session
       if @_fingerprint != Marshal.dump(request.session.data).hash
         begin
           CACHE.set("session:#{request.session.session_id}", request.session.data)
         rescue => err
           Merb.logger.debug("MemCache Error: #{err.message}")
+          Merb::SessionMixin::finalize_session_exception_callbacks.each {|x| x.call(err) }
         end
       end
-      set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
+      if request.session.needs_new_cookie or @_new_cookie
+        set_session_id_cookie(request.session.session_id)
+      end
     end
 
     # ==== Returns
@@ -82,12 +88,17 @@ module Merb
       # Array::
       #   A pair consisting of a MemCacheSession and the session's ID. If no
       #   sessions matched session_id, a new MemCacheSession will be generated.
+      #
+      # ==== Notes
+      # If there are persiste exceptions callbacks to execute, they all get executed
+      # when Memcache library raises an exception.
       def persist(session_id)
         unless session_id.blank?
           begin
             session = CACHE.get("session:#{session_id}")
           rescue => err
-            Merb.logger.debug("MemCache Error: #{err.message}")
+            Merb.logger.warn!("Could not persist session to MemCache: #{err.message}")
+            Merb::SessionMixin::persist_exception_callbacks.each {|x| x.call(err) }
           end
           if session.nil?
             # Not in memcached, but assume that cookie exists
@@ -108,27 +119,27 @@ module Merb
       end
 
       # Don't try to reload in dev mode.
-      def reloadable? #:nodoc:
+      def reloadable?
         false
       end
 
     end
 
     # Regenerate the session ID.
-    def regenerate 
-      @session_id = Merb::SessionMixin::rand_uuid 
-      self.needs_new_cookie=true 
-    end 
-      
+    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 
-     
+    def refresh_expiration
+      self.needs_new_cookie=true
+    end
+
     # Deletes the session by emptying stored data.
-    def delete  
-      @data = {} 
+    def delete
+      @data = {}
     end
 
     # ==== Returns
@@ -136,11 +147,11 @@ module Merb
     def loaded?
       !! @data
     end
-    
+
     # ==== Parameters
     # k<~to_s>:: The key of the session parameter to set.
     # v<~to_s>:: The value of the session parameter to set.
-    def []=(k, v) 
+    def []=(k, v)
       @data[k] = v
     end
 
@@ -149,18 +160,18 @@ module Merb
     #
     # ==== Returns
     # String:: The value of the session parameter.
-    def [](k) 
-      @data[k] 
+    def [](k)
+      @data[k]
     end
 
     # Yields the session data to an each block.
     #
     # ==== Parameter
     # &b:: The block to pass to each.
-    def each(&b) 
-      @data.each(&b) 
+    def each(&b)
+      @data.each(&b)
     end
-    
+
     private
 
     # Attempts to redirect any messages to the data object.
@@ -170,4 +181,4 @@ module Merb
 
   end
 
-end
+end

data/lib/merb-core/dispatch/session/memory.rb

@@ -1,6 +1,6 @@
 module Merb
 
-  module SessionMixin #:nodoc:
+  module SessionMixin
 
     # Adds a before and after dispatch hook for setting up the memory session
     # store.
@@ -8,15 +8,20 @@ module Merb
     # ==== Parameters
     # base<Class>:: The class to which the SessionMixin is mixed into.
     def setup_session
-      before = cookies[_session_id_key]
-      request.session , cookies[_session_id_key] = Merb::MemorySession.persist(cookies[_session_id_key])
-      @_new_cookie = cookies[_session_id_key] != before
+      orig_key = cookies[_session_id_key]
+      session, key = Merb::MemorySession.persist(orig_key)
+      request.session = session
+      if key != orig_key 
+        set_session_id_cookie(key)
+      end
     end
 
     # Finalizes the session by storing the session ID in a cookie, if the
     # session has changed.
     def finalize_session
-      set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
+      if request.session.needs_new_cookie or @_new_cookie
+        set_session_id_cookie(request.session.session_id)
+      end
     end
 
     # ==== Returns
@@ -29,10 +34,12 @@ module Merb
   ##
   # Sessions stored in memory.
   #
-  # And a setting in +merb.yml+:
+  # Set it up by adding the following to your init file:
   #
-  #   :session_store: memory
-  #   :memory_session_ttl: 3600 (in seconds, one hour)
+  #  Merb::Config.use do |c|
+  #    c[:session_store]      = :memory
+  #    c[:memory_session_ttl] = 3600 # in seconds, one hour
+  #  end
   #
   # Sessions will remain in memory until the server is stopped or the time
   # as set in :memory_session_ttl expires.
@@ -94,10 +101,10 @@ module Merb
     def refresh_expiration 
       self.needs_new_cookie=true 
     end 
-     
+    
     # Deletes the session by emptying stored data.
     def delete
-      @data = {} 
+      @data = {}
     end
      
     # ==== Returns
@@ -231,4 +238,4 @@ module Merb
   end # end MemorySessionContainer
 end
 
-Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl])
+Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl])

data/lib/merb-core/dispatch/worker.rb

@@ -0,0 +1,28 @@
+module Merb
+  class Worker
+    
+    attr_accessor :thread
+    
+    def initialize
+      @thread = Thread.new { loop { process_queue } }
+    end
+    
+    def process_queue
+      begin
+        while blk = Merb::Dispatcher.work_queue.pop
+           # we've been blocking on the queue waiting for an item sleeping.
+           # when someone pushes an item it wakes up this thread so we 
+           # immediately pass execution to the scheduler so we don't 
+           # accidentally run this block before the action finishes 
+           # it's own processing
+          Thread.pass
+          blk.call
+        end
+      rescue Exception => e
+        Merb.logger.warn! %Q!Worker Thread Crashed with Exception:\n#{Merb.exception(e)}\nRestarting Worker Thread!
+        retry
+      end    
+    end
+    
+  end
+end    

data/lib/merb-core/gem_ext/erubis.rb

@@ -1,5 +1,63 @@
 require 'erubis'
 module Erubis
+  module Basic::Converter
+    def convert_input(src, input)
+      pat = @pattern
+      regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat)
+      pos = 0
+      is_bol = true     # is beginning of line
+      input.scan(regexp) do |indicator, code, tailch, rspace|
+        match = Regexp.last_match()
+        len  = match.begin(0) - pos
+        text = input[pos, len]
+        pos  = match.end(0)
+        ch   = indicator ? indicator[0] : nil
+        lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol)
+        is_bol = rspace ? true : false
+        add_text(src, text) if text && !text.empty?
+        ## * when '<%= %>', do nothing
+        ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
+        if ch == ?=              # <%= %>
+          rspace = nil if tailch && !tailch.empty?
+          add_text(src, lspace) if lspace
+          add_expr(src, code, indicator)
+          add_text(src, rspace) if rspace
+        elsif ch == ?\#          # <%# %>
+          n = code.count("\n") + (rspace ? 1 : 0)
+          if @trim && lspace && rspace
+            add_stmt(src, "\n" * n)
+          else
+            add_text(src, lspace) if lspace
+            add_stmt(src, "\n" * n)
+            add_text(src, rspace) if rspace
+          end
+        elsif ch == ?%           # <%% %>
+          s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}"
+          add_text(src, s)
+        else                     # <% %>
+          if @trim && lspace && rspace
+            if respond_to?(:add_stmt2)
+              add_stmt2(src, "#{lspace}#{code}#{rspace}", tailch)
+            else
+              add_stmt(src, "#{lspace}#{code}#{rspace}")
+            end
+          else
+            add_text(src, lspace) if lspace
+            if respond_to?(:add_stmt2)
+              add_stmt2(src, code, tailch)
+            else
+              add_stmt(src, code)
+            end
+            add_text(src, rspace) if rspace
+          end
+        end
+      end
+      #rest = $' || input                        # ruby1.8
+      rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
+      add_text(src, rest)
+    end
+    
+  end
   
   class MEruby < Erubis::Eruby
     include PercentLineEnhancer

data/lib/merb-core/logger.rb

@@ -33,13 +33,12 @@ require "time" # httpdate
 #   Merb::Logger.new(log{String, IO},level{Symbol, String})
 module Merb
 
-  class << self #:nodoc:
+  class << self
     attr_accessor :logger
   end
 
   class Logger
 
-    attr_accessor :aio
     attr_accessor :level
     attr_accessor :delimiter
     attr_accessor :auto_flush
@@ -61,36 +60,10 @@ module Merb
       :warn  => 4,
       :info  => 3,
       :debug => 0
-    }
+    } unless const_defined?(:Levels)
 
     private
 
-    # Define the write method based on if asynchronous IO an be used.
-    #
-    # ==== Notes
-    # The idea here is that instead of performing an 'if' conditional check on
-    # each logging we do it once when the log object is setup.
-    def set_write_method
-      @log.instance_eval do
-
-        # ==== Returns
-        # Boolean:: True if asynchronous IO can be used.
-        def aio?
-          @aio = !Merb.environment.to_s.match(/development|test/) && 
-          !RUBY_PLATFORM.match(/java|mswin/) &&
-          !(@log == STDOUT) &&
-          @log.respond_to?(:write_nonblock)
-        end
-
-        undef write_method if defined? write_method #:nodoc:
-        if aio?
-          alias :write_method :write_nonblock
-        else
-          alias :write_method :write
-        end
-      end
-    end
-
     # Readies a log for writing.
     #
     # ==== Parameters
@@ -109,7 +82,6 @@ module Merb
         @log.sync = true
         @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
       end
-      set_write_method
     end
 
     public
@@ -155,7 +127,7 @@ module Merb
     # Flush the entire buffer to the log object.
     def flush
       return unless @buffer.size > 0
-      @log.write_method(@buffer.slice!(0..-1).to_s)
+      @log.write(@buffer.slice!(0..-1).to_s)
     end
 
     # Close and remove the current log object.