nakajima-rack-flash 0.0.5 → 0.0.6

data/lib/rack/flash.rb

@@ -1,33 +1,46 @@
-require 'metaid'
-
 module Rack
   class Flash
+    # Raised when the session passed to FlashHash initialize is nil. This
+    # is usually an indicator that session middleware is not in use.
     class SessionUnavailable < StandardError; end
-    
+
     # Implements bracket accessors for storing and retrieving flash entries.
     class FlashHash
       attr_reader :flagged
-      
+
       def initialize(store, opts={})
         raise Rack::Flash::SessionUnavailable \
           .new('Rack::Flash depends on session middleware.') unless store
-        
+
         @opts = opts
         @store = store
         @store[:__FLASH__] ||= {}
+
+        if accessors = @opts[:accessorize]
+          accessors.each { |opt| def_accessor(opt) }
+        end
       end
 
       # Remove an entry from the session and return its value. Cache result in
       # the instance cache.
       def [](key)
-        get(key.to_sym)
+        key = key.to_sym
+        cache[key] ||= values.delete(key)
       end
 
       # Store the entry in the session, updating the instance cache as well.
       def []=(key,val)
-        set(key.to_sym, val)
+        key = key.to_sym
+        cache[key] = values[key] = val
+      end
+
+      # Store a flash entry for only the current request, swept regardless of
+      # whether or not it was actually accessed. Useful for AJAX requests, where
+      # you want a flash message, even though you're response isn't redirecting.
+      def now
+        cache
       end
-      
+
       # Checks for the presence of a flash entry without retrieving or removing
       # it from the cache or store.
       def has?(key)
@@ -38,62 +51,29 @@ module Rack
       def flag!
         @flagged = values.keys
       end
-      
+
       # Remove flagged entries from flash session, clear flagged list.
       def sweep!
         Array(flagged).each { |key| values.delete(key) }
         flagged.clear
       end
-      
+
       # Hide the underlying :__FLASH__ session key and only expose values stored
       # in the flash.
       def inspect
         '#<FlashHash @values=%s>' % [values.inspect]
       end
-      
+
       # Human readable for logging.
       def to_s
         values.inspect
       end
-      
-      # Allow more convenient style for accessing flash entries (This isn't really
-      # necessary for Sinatra, since it provides the flash[:foo] hash that we're all
-      # used to. This is for vanilla Rack apps where it can be difficult to define
-      # such helpers as middleware).
-      def method_missing(sym, *args)
-        super unless @opts[:accessorize]
-        key = sym.to_s =~ /\w=$/ ? sym.to_s[0..-2] : sym
-        def_accessors(key)
-        send(sym, *args)
-      end
 
       private
-      
-      def get(key)
-        raise ArgumentError.new("Flash key must be symbol.") unless key.is_a?(Symbol)
-        cache[key] ||= values.delete(key)
-      end
-      
-      def set(key, val)
-        raise ArgumentError.new("Flash key must be symbol.") unless key.is_a?(Symbol)
-        cache[key] = values[key] = val
-      end
-      
-      def def_accessors(key)
-        return if respond_to?(key)
-        
-        meta_def(key) do
-          self[key]
-        end
-        
-        meta_def("#{key}=") do |val|
-          self[key] = val
-        end
-      end
 
-      # Maintain an instance-level cache of retrieved flash entries. These entries
-      # will have been removed from the session, but are still available through
-      # the cache.
+      # Maintain an instance-level cache of retrieved flash entries. These
+      # entries will have been removed from the session, but are still available
+      # through the cache.
       def cache
         @cache ||= {}
       end
@@ -103,23 +83,46 @@ module Rack
       def values
         @store[:__FLASH__]
       end
+
+      # Generate accessor methods for the given entry key if :accessorize is true.
+      def def_accessor(key)
+        raise ArgumentError.new('Invalid entry type: %s' % key) if respond_to?(key)
+
+        class << self; self end.class_eval do
+          define_method(key) { |*args| val = args.first; val ? (self[key]=val) : self[key] }
+          define_method("#{key}=") { |val| self[key] = val }
+          define_method("#{key}!") { |val| cache[key] = val }
+        end
+      end
     end
-    
+
+    # -------------------------------------------------------------------------
+    # - Rack Middleware implementation
+
     def initialize(app, opts={})
+      if defined?(Sinatra::Base)
+        Sinatra::Base.class_eval do
+          def flash; env['rack-flash'] end
+        end
+      end
+
       @app, @opts = app, opts
     end
 
     def call(env)
-      env['rack-flash'] = Rack::Flash::FlashHash.new(env['rack.session'], @opts)
-      @app.call(env)
-    end
-  end
-end
+      env['rack-flash'] ||= Rack::Flash::FlashHash.new(env['rack.session'], @opts)
+
+      if @opts[:sweep]
+        env['rack-flash'].flag!
+      end
+
+      res = @app.call(env)
 
-if defined?(Sinatra::Base)
-  Sinatra::Base.class_eval do
-    def flash
-      env['rack-flash']
+      if @opts[:sweep]
+        env['rack-flash'].sweep!
+      end
+
+      res
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nakajima-rack-flash
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -22,16 +22,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: metaid
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 description: 
 email: patnakajima@gmail.com
 executables: []