nakajima-rack-flash 0.0.2 → 0.0.5

data/lib/rack/flash.rb

@@ -0,0 +1,125 @@
+require 'metaid'
+
+module Rack
+  class Flash
+    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__] ||= {}
+      end
+
+      # Remove an entry from the session and return its value. Cache result in
+      # the instance cache.
+      def [](key)
+        get(key.to_sym)
+      end
+
+      # Store the entry in the session, updating the instance cache as well.
+      def []=(key,val)
+        set(key.to_sym, val)
+      end
+      
+      # Checks for the presence of a flash entry without retrieving or removing
+      # it from the cache or store.
+      def has?(key)
+        [cache, values].any? { |store| store.keys.include?(key.to_sym) }
+      end
+
+      # Mark existing entries to allow for sweeping.
+      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.
+      def cache
+        @cache ||= {}
+      end
+
+      # Helper to access flash entries from :__FLASH__ session value. This key
+      # is used to prevent collisions with other user-defined session values.
+      def values
+        @store[:__FLASH__]
+      end
+    end
+    
+    def initialize(app, opts={})
+      @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
+
+if defined?(Sinatra::Base)
+  Sinatra::Base.class_eval do
+    def flash
+      env['rack-flash']
+    end
+  end
+end

data/lib/rack-flash.rb

@@ -1,94 +1 @@
-module Rack
-  class Flash
-    class SessionUnavailable < StandardError; end
-    
-    # Implements bracket accessors for storing and retrieving flash entries.
-    class FlashHash
-      attr_reader :flagged
-      
-      def initialize(store)
-        @store = store
-        @store[:__FLASH__] ||= {}
-      end
-
-      # Remove an entry from the session and return its value. Cache result in
-      # the instance cache.
-      def [](key)
-        get(key.to_sym)
-      end
-
-      # Store the entry in the session, updating the instance cache as well.
-      def []=(key,val)
-        set(key.to_sym, val)
-      end
-      
-      # Checks for the presence of a flash entry without retrieving or removing
-      # it from the cache or store.
-      def has?(key)
-        [cache, values].any? { |store| store.keys.include?(key.to_sym) }
-      end
-
-      # Mark existing entries to allow for sweeping.
-      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
-
-      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
-
-      # 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
-
-      # Helper to access flash entries from :__FLASH__ session value. This key
-      # is used to prevent collisions with other user-defined session values.
-      def values
-        @store[:__FLASH__]
-      end
-    end
-    
-    def initialize(app)
-      @app = app
-      @app.class.class_eval do
-        def flash
-          raise Rack::Flash::SessionUnavailable \
-            .new('Rack::Flash depends on session middleware.') unless env['rack.session']
-          @flash ||= Rack::Flash::FlashHash.new(env['rack.session'])
-        end
-      end
-    end
-    
-    def call(env)
-      @app.call(env)
-    end
-  end
-end
+require File.join(File.dirname(__FILE__), *%w[rack flash])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nakajima-rack-flash
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -22,6 +22,16 @@ 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: []
@@ -32,6 +42,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/rack-flash.rb
+- lib/rack/flash.rb
 has_rdoc: false
 homepage: 
 post_install_message: