sinatra-flash 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.markdown
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE.markdown

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE.markdown

@@ -0,0 +1,113 @@
+The Don't Be a Dick License
+===========================
+_version 0.2_
+
+**Project:** [Sinatra::Flash](http://github.com/SFEley/sinatra-flash)   
+**Author:** Stephen Eley (<sfeley@gmail.com>)
+
+This is a proposed draft of the **Don't Be a Dick** license for open source projects.  The purpose of this license is to permit the broadest feasible scope for reuse and modification of creative work, restricted only by the requirement that one is not a dick about it.
+
+1. Legal Parameters
+-------------------
+For legal purposes, the DBAD license is a superset of the [Apache License, Version 2.0][1] and incorporates all terms, conditions, privileges and limitations therein.  The following text is a binding part of this license for this project:
+
+> Copyright 2010 Stephen Eley
+
+> Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+>   <http://www.apache.org/licenses/LICENSE-2.0>
+
+> Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  
+Nothing in the following text should be construed to inhibit, contradict, or override any part of the Apache License, Version 2.0.  
+
+2. Definitions
+--------------
+The following terms and definitions shall be in effect for the rest of this document.
+
+>  **NOTE:** Singular nouns and pronouns are used throughout this License for 
+  grammatical convenience.  However, any of the terms below _may_ refer to a
+  collective work or group of people.  If this pegs your punctiliousness, you
+  are directed to mentally substitute "Person _or persons_," "Dick _or 
+  dicks,_" etc., throughout this license.  Just don't tell us about it.
+
+### A. Project
+
+A creative work of (software | writing | visual art | music) into which significant time and energy have been invested by people who _are not you,_ and which has been released into the world for the benefit of the general public (_including you._)
+
+The **Project** may include, incorporate, derive from, or be inspired by other works.  The Author, being a Reasonable Person, has made use of such source materials only as permitted by their own licenses or applicable law.  The License you are reading applies only to those portions of the Project which are original and distinct to it.  Source materials may be covered by their own licenses or conditions, and should not be assumed to have coverage under this License.  (However, you are strongly encouraged not to be a dick about them either.)
+
+### B. Author
+
+A person who has invested significant time and energy into the Project licensed herein.  Given the Author's release of the Project to the world under a liberal license, the Author is declared a Reasonable Person (at least within this context) and inherits all attributes, freedoms, and responsibilities thereof.  No other assumptions are made about the Author, nor should you make any.
+
+### C. Reasonable Person
+
+A person who respects the time and energy that have been invested in the Project licensed herein, and acts accordingly.  A Reasonable Person is broadly characterized as one who exercises his or her privilege to use, _not_ use, redistribute, modify, improve, worsen, review, report issues upon, participate in the community of, or ignore the work _without_ placing undue demands upon the Author.  I.e., a Reasonable Person is a constituent of the majority of open source users and the population at large who are not Dicks.
+
+### D. Dick
+
+A person who _does not_ respect the time and energy that have been invested in the Project, and acts to punish such effort by giving others associated with the Project -- including, but not limited to, the Author -- a hard time.  A Dick is nearly always selfish, but not necessarily with deliberate intent; some Dicks are merely thoughtless.  The distinguishing characteristic of a Dick is that he or she places burdens upon Reasonable People, reducing their motivation to engage in open source activities.  This damping effect is a significant detriment to the Project, to open source in general, to the production of new intellectual value in the world -- and, ultimately, to the Dick himself or herself.
+
+>  **NOTE:** Despite its original gender association, the word "Dick" is used herein in a _cultural_ context and not a _genital_ context.  This License has chosen to adopt the term for its linguistic force and psychological impact, and sincerely regrets any inference of sexism.  For purposes of the terms and conditions contained herein, it is understood that both men and women are equally capable of being Dicks.  
+  
+>  (But they shouldn't be.)  
+  
+3. Permissions
+--------------
+
+The following privileges are granted explicitly and exclusively to Reasonable People.  Although the Author acknowledges the practical unfeasibility of barring Dicks from enjoying the same privileges, they are nevertheless asked to refrain from any activity related to the Project _and/or_ to reconsider their behavior and stop being Dicks.
+
+1. You are permitted to use the Project or any component of the Project.
+
+2. You are permitted to redistribute the Project or any component of the Project, by itself or as part of a different work, provided that you give fair and reasonable credit back to the Author.
+
+3. You are permitted to change the Project for your own needs or anyone else's.  You may keep your changes to yourself or submit them back to the Author or the community, as you see fit, provided you are not a Dick about it.
+
+4. You are permitted and encouraged to participate in any community related to the Project, or to create new communities.
+
+5. You are permitted to report issues or problems with the Project, and to request that they be addressed, so long as the request is made in a reasonable fashion.  (This privilege does _not_ oblige the Author to respond.)
+
+6. You are permitted to make money from the Project.  No recompense is owed to the Author unless by separate agreement, although sharing opportunities for mutual benefit is by no means discouraged.
+
+7. You are permitted to discuss the Project in any medium, in any positive or negative spirit, so long as criticism is not libelous nor _ad hominem._  (I.e., don't lie, and keep it about the _work_ and not the _people._)
+
+8. You are permitted to ignore the Project completely and make no use of it whatsoever.  This right is irrevocable and absolute, and extended to Dicks and Reasonable People alike.
+
+4. Limitations
+--------------
+
+The following restrictions are imposed explicitly and exclusively upon Dicks.  These limitations are the inverse of the above privileges and are also tautological, as the prohibited actions are those _definitive_ of Dickhood.
+
+1. You may not impede Reasonable People from exercising their privilege to use, redistribute, change, participate in, profit from, discuss, or ignore the Project.
+
+2. You may not withhold the Author's credit for the Project, nor otherwise present the work of anyone else as your own.
+
+3. You may not hold the Author responsible for any use or abuse of the Project by you or anyone else.
+
+4. You may not troll, flame, nor dumb down any community associated with the Project.
+
+5. Barring separate agreements, you may not _demand_ any time or attention on the part of the Author nor anyone else in the community.  You may not hold the Author personally accountable for any issues you discover nor otherwise spread your own problems to other people.
+
+6. You may not attempt to _compel_ time nor money from the Author nor any other community member by any means, including but not limited to legal action, intimidation, or annoyance.  
+
+7. You may not engage in _ad hominem_ (i.e. personal) attacks or criticism of the Author in the course of criticizing the Project.
+
+8. You may not impede the absolute and irrevocable privilege of the Author and other members of the community to ignore you.  
+
+5. Use of This License
+----------------------
+The Don't Be a Dick License is released under the terms of the Don't Be a Dick License. Projects released under this License should remain under the License, and the terms of the License may not be modified by anyone other than the Project's original Author.
+  
+If you wish to make use of the License for your own open work, you may do so without asking permission, provided said work is truly your own, truly open, and you are truly not a Dick. You may modify the terms of the License to suit your own needs, but are strongly advised to annotate said changes.  Modifications may not reduce the freedoms granted to Reasonable People as described in Section 3.
+
+Reasonable People are _invited,_ but not compelled, to visit the Web site at <http://dbad-license.org> and browse or add their project to the repository of works released under the License.
+ 
+
+[1]: http://apache.org/licenses/LICENSE-2.0

data/README.markdown

@@ -0,0 +1,157 @@
+Sinatra::Flash
+==============
+This is an implementation of show-'em-once 'flash' messages for the [Sinatra][1] Web framework. It offers the following feature set:
+
+* Simplicity (less than 50 significant lines of code)
+* Implements the documented [behavior][3] and [public API][4] of the Rails flash that many developers are used to
+* Acts entirely like a hash, including iterations and merging
+* Zero configuration for a Sinatra 'classic' app -- it'll even turn sessions on if you didn't already
+* Optional multiple named flash collections, each with their own message hash, so that different embedded applications can access different sets of messages
+* An HTML helper for displaying flash messages with CSS styling
+* Verbose documentation in [YARD][5] format
+* Full RSpec tests
+
+The primary catch for experienced Rack developers is that it _does not_ function as standalone Rack middleware. (You could get to the messages inside the session if you needed to, but the message rotation occurs in a Sinatra `after` hook.)  It should function just fine across multiple Sinatra apps, but if you need flash that's accessible from non-Sinatra applications, consider the [Rack::Flash][2] middleware.
+
+Setting Up
+----------
+You should know this part:
+    
+    $ gem install sinatra-flash
+
+(Or `sudo gem install` if you're the last person on Earth who isn't using [RVM][6] yet.)
+
+If you're developing a Sinatra ['classic'][7] application, then all you need to do is require the library:
+
+    # blah_app.rb
+    require 'sinatra'
+    require 'sinatra/flash'
+    
+    post '/blah' do
+      # This message won't be seen until the NEXT Web request that accesses the flash collection
+      flash[:blah] = "You were feeling blah at #{Time.now}."
+      
+      # Accessing the flash displays messages set from the LAST request
+      "Feeling blah again? That's too bad. #{flash[:blah]}"
+    end
+
+If you're using the [Sinatra::Base][7] style, you also need to register the extension:
+
+    # bleh_app.rb
+    require 'sinatra/base'
+    require 'sinatra/flash'
+    
+    class BlehApp < Sinatra::Base
+      register Sinatra::Flash
+      
+      get '/bleh' do
+        if flash[:blah]
+          # The flash collection is cleared after any request that uses it
+          "Have you ever felt blah? Oh yes. #{flash[:blah]} Remember?"
+        else
+          "Oh, now you're only feeling bleh?"
+        end
+      end
+    end
+    
+See the Sinatra documentation on [using extensions][8] for more detail and rationale.
+
+styled_flash
+------------
+The gem comes with a handy view helper that iterates through current flash messages and renders them in styled HTML:
+
+    # Using HAML, 'cause the cool kids are all doing it
+    %html
+      %body
+        =styled_flash
+
+Yields (assuming three flash messages with different keys):
+
+    <html>
+      <body>
+        <div id='flash'>
+          <div class='flash info'>I'm sorry, Dave. I'm afraid I can't do that.</div>
+          <div class='flash warning'>This mission is too important for me to allow you to jeopardize it.</div>
+          <div class='flash fatal'>Without your space helmet, Dave, you're going to find reaching the emergency airlock rather difficult.</div>
+        </div>
+      </body>
+    </html>
+          
+Styling the CSS for the #flash id, the .flash class, or any of the key-based classes is entirely up to you.  
+
+(_Side note:_ This view helper was my initial reason for making this gem. I'd gotten used to pasting this little method in on every Rails project, and when I switched to Sinatra was distraught to discover that [Rack::Flash][2] couldn't do it, because the FlashHash isn't really a hash and you can't iterate it. Reinventing flash was sort of a side effect.)
+
+Advanced Tips
+-------------
+### Now vs. Next
+The flash object acts like a hash, but it's really _two_ hashes:
+
+* The **now** hash displays messages for the current request.
+* The **next** hash stores messages to be displayed in the _next_ request.
+
+When you access the **flash** helper, the _now_ hash is initialized from a session value.  (Named `:flash` by default, but see 'Scoped Flash' below.)  Every method except assignment (`[]=`) is delegated to _now_; assignments occur on the _next_ hash.  At the end of the request, a Sinatra `after` hook sets the session value to the _next_ hash, effectively rotating it to _now_ for the next request that uses it.
+
+This is usually what you want, and you don't have to worry about the details.  However, you occasionally want to set a message to display during _this_ request, or access values that are coming up.  In these cases you can access the `.now` and `.next` hashes directly:
+
+    # This will be displayed during the current request
+    flash.now[:error] = "We're shutting down now.  Goodbye!"
+    
+    # Look at messages upcoming in the next request
+    @weapon = Stake.new if flash.next[:warning] == "The vampire is attacking."
+    
+In practice, you'll probably want to set `.now` any time you're displaying errors with an immediate render instead of redirecting.  It's hard to think of a common reason to check `.next` -- but it's there if you want it.
+
+### Keep, Discard, and Sweep
+These convenience methods allow you to modify the standard rotation cycle, and are based directly on the [Rails flash API][4]:
+
+    flash.keep               # Will show all messages again
+    flash.keep(:groundhog)   # Will show the message on key :groundhog again
+    flash.discard            # Clears the next messages without showing them
+    flash.discard(:amnesia)  # Clears only the message on key :amnesia
+    flash.sweep              # Rotates the flash manually, discarding _now_ and moving _next_ into its place
+
+### Sessions
+The basic _concept_ of flash messages relies on having an active session for your application. Sinatra::Flash is built on the assumption that Sinatra's `session` helper points to something useful, and ensures that it does. If you've already set up Rack::Session::Cookie or done `enable sessions` or whatever, that session will be used. If you haven't, the `after` hook will enable sessions on your behalf using Sinatra's defaults. You'll probably get better results by configuring it yourself.
+
+### Scoped Flash
+If one flash collection isn't exciting enough for your application stack, you can have multiple sets of flash messages scoped by a symbol. Each has its own lifecycle and will _not_ be rotated by any Web request that ignores it.
+
+    get "/complicated" do
+      flash(:one)[:hello] = "This will appear the next time flash(:one) is called"
+      flash(:two).discard(:hello)  # Clear a message someone else set on flash(:two)
+      "A message for you on line three: #{flash(:three)[:hello]}"
+    end
+
+Both the **flash** and **styled_flash** helper methods accept such keys as optional parameters. If don't specify one, the default key is `:flash`.  Whatever keys you use will become session keys as well, so take heed that you don't run into naming conflicts.
+
+Do you need this? Probably not. The principal use case is for complex application stacks in which some messages are only relevant within specific subsystems. If you _do_ use it, be sure to model your message flows carefully, and don't confuse collection keys with message keys.
+
+Credit, Support, and Contributions
+----------------------------------
+This extension is the fault of **Stephen Eley**. You can reach me at <sfeley@gmail.com>. If you like science fiction stories, I know a [good podcast][9] for them as well.
+
+If you find bugs, please report them on the [Github issue tracker][10]. 
+
+The documentation can of course be found on [RDoc.info][11].
+
+Contributions are welcome. I'm not sure how much more _must_ be done on a flash message extension, but I'm sure there's plenty that _could_ be done.  Please note that the test suite uses RSpec, and you'll need the [Sessionography][14] helper for testing sessions.  (I actually developed Sessionography in order to TDD _this_ gem.)
+
+License
+-------
+This project is licensed under the **Don't Be a Dick License**, version 0.2, and is copyright 2010 by Stephen Eley. See the [LICENSE.markdown][12] file or the [DBAD License site][13] for elaboration on not being a dick.
+
+
+[1]: http://sinatrarb.com
+[2]: http://nakajima.github.com/rack-flash/
+[3]: http://api.rubyonrails.org/classes/ActionController/Flash.html
+[4]: http://api.rubyonrails.org/classes/ActionController/Flash/FlashHash.html
+[5]: http://yardoc.org
+[6]: http://rvm.beginrescueend.com
+[7]: https://sinatra.lighthouseapp.com/projects/9779/tickets/240-sinatrabase-vs-sinatradefault-vs-sinatraapplication
+[8]: http://www.sinatrarb.com/extensions-wild.html
+[9]: http://escapepod.org
+[10]: http://github.com/SFEley/sinatra-flash/issues
+[11]: http://rdoc.info/projects/SFEley/sinatra-flash
+[12]: http://github.com/SFEley/sinatra-flash/blob/master/LICENSE.markdown
+[13]: http://dbad-license.org
+[14]: http://github.com/SFEley/sinatra-sessionography

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sinatra-flash"
+    gem.summary = %Q{Proper flash messages in Sinatra}
+    gem.description = %Q{A Sinatra extension for setting and showing Rails-like flash messages. This extension improves on the Rack::Flash gem by being simpler to use, providing a full range of hash operations (including iterating through various flash keys, testing the size of the hash, etc.), and offering a 'styled_flash' view helper to render the entire flash hash with sensible CSS classes. The downside is reduced flexibility -- these methods will *only* work in Sinatra.}
+    gem.email = "sfeley@gmail.com"
+    gem.homepage = "http://github.com/SFEley/sinatra-flash"
+    gem.authors = ["Stephen Eley"]
+    gem.add_dependency "sinatra", ">= 1.0.0"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", ">= 0"
+    gem.add_development_dependency "sinatra-sessionography"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sinatra/flash.rb

@@ -0,0 +1,20 @@
+require 'sinatra/base'
+require 'sinatra/flash/storage'
+require 'sinatra/flash/style'
+
+
+module Sinatra
+  module Flash
+    
+    # This callback rotates any flash structure we referenced, placing the 'next' hash into the session
+    # for the next request.
+    after do
+      set :sessions, true unless session # If you do not have a session, one will be appointed for you by the court.
+      @flash.each{|key, flash| session[key] = @flash[key].next}
+    end
+    
+    helpers Storage
+    helpers Style
+  end
+  register Flash
+end

data/lib/sinatra/flash/hash.rb

@@ -0,0 +1,49 @@
+require 'delegate'
+
+module Sinatra
+  module Flash
+    
+    # A subclass of Hash that "remembers forward" by exactly one action. 
+    # Tastes just like the API of Rails's ActionController::Flash::FlashHash, but with fewer calories.
+    class FlashHash < DelegateClass(Hash)
+      attr_reader :now, :next
+      
+      # Builds a new FlashHash. It takes the hash for this action's values as an initialization variable.
+      def initialize(session)
+        @now = session || Hash.new
+        @next = Hash.new
+        super(@now)
+      end
+      
+      # We assign to the _next_ hash, but retrieve values from the _now_ hash.  Freaky, huh?  
+      def []=(key, value)
+        self.next[key] = value
+      end
+      
+      # Swaps out the current flash for the future flash, then returns it.
+      def sweep
+        @now.replace(@next)
+        @next = Hash.new
+        @now
+      end
+      
+      # Keep all or one of the current values for next time.
+      def keep(key=nil)
+        if key
+          @next[key] = @now[key]
+        else
+          @next.merge!(@now)
+        end
+      end
+      
+      # Tosses any values or one value before next time.
+      def discard(key=nil)
+        if key
+          @next.delete(key)
+        else
+          @next = Hash.new
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/flash/storage.rb

@@ -0,0 +1,23 @@
+require 'sinatra/flash/hash'
+
+module Sinatra
+  module Flash
+    module Storage
+  
+      # The main Sinatra helper for accessing the flash. You can have multiple flash collections (e.g.,
+      # for different apps in your Rack stack) by passing a symbol to it.
+      # 
+      # @param [optional, String, Symbol] key Specifies which key in the session contains the hash
+      # you want to reference. Defaults to ':flash'. If there is no session or the key is not found, 
+      # an empty hash is used.  Note that this is only used in the case of multiple flash _collections_,
+      # which is rarer than multiple flash messages.
+      #
+      # @return [FlashHash] Assign to this like any other hash.
+      def flash(key=:flash)
+        @flash ||= {}
+        @flash[key.to_sym] ||= FlashHash.new((session ? session[key.to_sym] : {}))
+      end
+      
+    end
+  end
+end

data/lib/sinatra/flash/style.rb

@@ -0,0 +1,33 @@
+module Sinatra
+  module Flash
+    module Style
+
+      # A view helper for rendering flash messages to HTML with reasonable CSS structure. Handles 
+      # multiple flash messages in one request. Wraps them in a <div> tag with id #flash containing
+      # a <div> for each message with classes of .flash and the message type.  E.g.:
+      #
+      # @example
+      #   <div id='flash'>
+      #     <div class='flash info'>Today is Tuesday, April 27th.</div>
+      #     <div class='flash warning'>Missiles are headed to destroy the Earth!</div>
+      #   </div>
+      #
+      # It is your responsibility to style these classes the way you want in your stylesheets.
+      #
+      # @param[optional, String, Symbol] key Specifies which flash collection you want to display. 
+      #   If you use this, the collection key will be appended to the top-level div id (e.g.,
+      #   'flash_login' if you pass a key of  :login).  
+      #
+      # @return [String] Styled HTML if the flash contains messages, or an empty string if it's empty.
+      def styled_flash(key=:flash)
+        return "" if flash(key).empty?
+        id = (key == :flash ? "flash" : "flash_#{key}")
+        messages = flash(key).collect {|message| "  <div class='flash #{message[0]}'>#{message[1]}</div>\n"}
+        "<div id='#{id}'>\n" + messages.join + "</div>"
+      end
+      
+    end
+  end
+end
+
+

data/spec/classic_spec.rb

@@ -0,0 +1,20 @@
+# require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+# 
+# # Make sure it behaves properly in a top-level 'classic' app
+# 
+# require 'sinatra'
+# require 'sinatra/flash'
+# # set test environment
+# set :environment, :test
+# set :run, false
+# set :raise_errors, true
+# set :logging, false
+# 
+# get "/first" do 
+#   flash[:info] = 'You should see this on the second page.'
+#   erb "<%= styled_flash%><h1>There should be no flash here!</h1>"
+# end
+# 
+# describe "A Sinatra classic app" do
+#   
+# end

data/spec/flash/hash_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Sinatra::Flash
+  describe FlashHash do
+    before(:each) do
+      @flash = {:do => 'A deer, a female deer', :re => 'A drop of golden sun'}
+      @this = FlashHash.new(@flash)  # Stubbing out the session with a simple hash
+      @this[:one] = "My thumb"
+      @this[:two] = "My shoe"
+      @this[:three] = "My knee"
+    end
+
+    it "requires a session to be passed to it" do
+      lambda{FlashHash.new}.should raise_error(ArgumentError)
+    end
+  
+    it "acts just like a Hash" do
+      Hash.instance_methods.each do |method|
+        @this.should respond_to(method)
+      end
+    end
+  
+    it "knows its length" do
+      @this.length.should == 2
+    end
+    
+    it "swaps its contents after one sweep" do
+      @this.sweep
+      @this.length.should == 3
+    end
+    
+    it "gets rid of its contents after two sweeps" do
+      @this.sweep
+      @this.sweep
+      @this.should be_empty
+    end
+    
+    it "can discard the whole flash" do
+      @this.discard
+      @this.sweep
+      @this.should be_empty
+    end
+    
+    it "can discard just one key" do
+      @this.discard(:two)
+      @this.sweep
+      @this.length.should == 2
+    end
+    
+    it "can keep the whole flash" do
+      @this.sweep
+      @this.keep
+      @this.sweep
+      @this.length.should == 3
+    end
+    
+    it "can keep just one key" do
+      @this.sweep
+      @this.keep(:three)
+      @this.sweep
+      @this.length.should == 1
+    end
+      
+    it "doesn't know the values you set right away" do
+      @this[:foo] = "bar"
+      @this[:foo].should be_nil
+    end
+    
+    it "knows the values you set next time" do
+      @this[:foo] = "bar"
+      @this.sweep
+      @this[:foo].should == "bar"
+    end
+    
+    it "can set values only for now" do
+      @this.now[:foo] = "bar"
+      @this[:foo].should == "bar"
+    end
+    
+    it "forgets values you set only for now next time" do
+      @this.now[:foo] = "bar"
+      @this.sweep
+      @this.now[:foo].should be_nil
+    end
+    
+      
+  end
+end

data/spec/flash/style_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'sinatra/flash/style'
+
+describe 'styled_flash method' do
+  include Sinatra::Sessionography  # for the 'session' method
+  include Sinatra::Flash::Storage
+  include Sinatra::Flash::Style
+  
+  before(:each) do
+    Sinatra::Sessionography.session = {:flash => {:foo=>:bar, :too=>'tar'},
+                                       :smash => {:yoo=>:yar, :zoo=>'zar'}}
+  end
+  
+  it "returns an empty string if the flash is empty" do
+    Sinatra::Sessionography.session = {}
+    styled_flash.should == ""
+  end
+  
+  it "returns a div of #flash if the structure is the default" do
+    styled_flash.should =~ /<div id='flash'>/
+  end
+  
+  it "contains each key as a class" do
+    styled_flash.should =~ /<div class='flash foo'>bar<\/div>/
+    styled_flash.should =~ /<div class='flash too'>tar<\/div>/
+  end
+  
+  describe "if a key is passed" do
+    it "returns an empty string if that structure is empty" do
+      styled_flash(:trash).should == ""
+    end
+    
+    it "returns a div containing the key name if a key is passed" do
+      styled_flash(:smash).should =~ /<div id='flash_smash'>/
+    end
+    
+    it "returns each of the keys within that key as a class" do
+      styled_flash(:smash).should =~ /<div class='flash yoo'>yar<\/div>/
+      styled_flash(:smash).should =~ /<div class='flash zoo'>zar<\/div>/
+    end
+    
+  end
+end

data/spec/flash_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# See the spec_helper for the 'app' that we're testing.
+describe Sinatra::Flash do
+  before(:each) do
+    Sinatra::Sessionography.session = { 
+        :flash => {:marco => :polo},
+        :smash => {:applecore => :baltimore}}    
+  end
+      
+  it "provides a 'flash' helper" do
+    get '/flash'
+    last_response.body.should =~ /\{.*\}/
+  end
+  
+  it "looks up the :flash variable in the session by default" do
+    get '/flash'
+    last_response.body.should == "{:marco=>:polo}"
+  end
+  
+  it "is empty, not nil, if there's no session" do
+    Sinatra::Sessionography.session = nil
+    get '/flash'
+    last_response.body.should == "{}"
+  end
+
+  it "can take a different flash key" do
+    get '/flash', {:key => :smash}
+    last_response.body.should == "{:applecore=>:baltimore}"
+  end
+  
+  it "is empty, not nil, if the session doesn't have the flash key" do
+    get '/flash', {:key => :trash}
+    last_response.body.should == "{}"
+  end
+  
+  it "can set the flash for the future" do
+    post '/flash', {:fire => :ice}
+    last_response.body.should == "{:marco=>:polo}"
+  end
+
+  it "knows the future flash" do
+    post '/flash', {:fire => :ice}
+    get '/flash'
+    last_response.body.should == "{:fire=>:ice}"
+  end
+  
+  it "can set a different flash key for the future" do
+    post '/flash', {:key => :smash, :knockknock => :whosthere}
+    get '/flash', {:key => :smash}
+    last_response.body.should == "{:knockknock=>:whosthere}"
+  end
+  
+  it "sweeps only the flash that gets used" do
+    post '/flash', {:hi => :ho}
+    post '/flash', {:aweem => :owep, :key => :smash}
+    get '/flash', {:key => :smash}
+    last_response.body.should == "{:aweem=>:owep}"
+    get '/flash'
+    last_response.body.should == "{:hi=>:ho}"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sinatra'
+require 'rack/test'
+require 'spec'
+require 'spec/autorun'
+
+set :environment, :test
+require 'sinatra/flash'
+require 'sinatra/sessionography'
+
+get '/flash' do
+  if params[:key]
+    flash(params[:key]).inspect
+  else
+    flash.inspect
+  end
+end
+
+post '/flash' do
+  if (key = params.delete('key'))
+    params.each{|k,v| flash(key)[k.to_sym] = v.to_sym}
+    flash(key).inspect
+  else
+    params.each{|k,v| flash[k.to_sym] = v.to_sym}
+    flash.inspect
+  end
+end
+    
+
+# Stub out our application; it's silly, but we have to do it. (http://www.sinatrarb.com/testing.html)
+module SinatraApp
+  def app
+    Sinatra::Application
+  end
+end
+
+Spec::Runner.configure do |config|
+  include SinatraApp
+  include Rack::Test::Methods
+  
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-flash
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stephen Eley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sinatra-sessionography
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: A Sinatra extension for setting and showing Rails-like flash messages. This extension improves on the Rack::Flash gem by being simpler to use, providing a full range of hash operations (including iterating through various flash keys, testing the size of the hash, etc.), and offering a 'styled_flash' view helper to render the entire flash hash with sensible CSS classes. The downside is reduced flexibility -- these methods will *only* work in Sinatra.
+email: sfeley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.markdown
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE.markdown
+- README.markdown
+- Rakefile
+- VERSION
+- lib/sinatra/flash.rb
+- lib/sinatra/flash/hash.rb
+- lib/sinatra/flash/storage.rb
+- lib/sinatra/flash/style.rb
+- spec/classic_spec.rb
+- spec/flash/hash_spec.rb
+- spec/flash/style_spec.rb
+- spec/flash_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/SFEley/sinatra-flash
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Proper flash messages in Sinatra
+test_files: 
+- spec/classic_spec.rb
+- spec/flash/hash_spec.rb
+- spec/flash/style_spec.rb
+- spec/flash_spec.rb
+- spec/spec_helper.rb