Skip to content
This repository
tree: e6cadd422b
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 214 lines (183 sloc) 6.682 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
module ActionController #:nodoc:
  # The flash provides a way to pass temporary objects between actions. Anything you place in the flash will be exposed
  # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create
  # action that sets <tt>flash[:notice] = "Successfully created"</tt> before redirecting to a display action that can
  # then expose the flash to its template. Actually, that exposure is automatically done. Example:
  #
  # class PostsController < ActionController::Base
  # def create
  # # save post
  # flash[:notice] = "Successfully created post"
  # redirect_to posts_path(@post)
  # end
  #
  # def show
  # # doesn't need to assign the flash notice to the template, that's done automatically
  # end
  # end
  #
  # show.html.erb
  # <% if flash[:notice] %>
  # <div class="notice"><%= flash[:notice] %></div>
  # <% end %>
  #
  # This example just places a string in the flash, but you can put any object in there. And of course, you can put as
  # many as you like at a time too. Just remember: They'll be gone by the time the next action has been performed.
  #
  # See docs on the FlashHash class for more details about the flash.
  module Flash
    def self.included(base)
      base.class_eval do
        include InstanceMethods

        alias_method_chain :perform_action, :flash
        alias_method_chain :reset_session, :flash
        alias_method_chain :redirect_to, :flash

        helper_method :alert
        helper_method :notice
      end
    end

    class FlashNow #:nodoc:
      def initialize(flash)
        @flash = flash
      end

      def []=(k, v)
        @flash[k] = v
        @flash.discard(k)
        v
      end

      def [](k)
        @flash[k]
      end
    end

    class FlashHash < Hash
      def initialize #:nodoc:
        super
        @used = {}
      end

      def []=(k, v) #:nodoc:
        keep(k)
        super
      end

      def update(h) #:nodoc:
        h.keys.each { |k| keep(k) }
        super
      end

      alias :merge! :update

      def replace(h) #:nodoc:
        @used = {}
        super
      end

      # Sets a flash that will not be available to the next action, only to the current.
      #
      # flash.now[:message] = "Hello current action"
      #
      # This method enables you to use the flash as a central messaging system in your app.
      # When you need to pass an object to the next action, you use the standard flash assign (<tt>[]=</tt>).
      # When you need to pass an object to the current action, you use <tt>now</tt>, and your object will
      # vanish when the current action is done.
      #
      # Entries set via <tt>now</tt> are accessed the same way as standard entries: <tt>flash['my-key']</tt>.
      def now
        FlashNow.new(self)
      end

      # Keeps either the entire current flash or a specific flash entry available for the next action:
      #
      # flash.keep # keeps the entire flash
      # flash.keep(:notice) # keeps only the "notice" entry, the rest of the flash is discarded
      def keep(k = nil)
        use(k, false)
      end

      # Marks the entire flash or a single flash entry to be discarded by the end of the current action:
      #
      # flash.discard # discard the entire flash at the end of the current action
      # flash.discard(:warning) # discard only the "warning" entry at the end of the current action
      def discard(k = nil)
        use(k)
      end

      # Mark for removal entries that were kept, and delete unkept ones.
      #
      # This method is called automatically by filters, so you generally don't need to care about it.
      def sweep #:nodoc:
        keys.each do |k|
          unless @used[k]
            use(k)
          else
            delete(k)
            @used.delete(k)
          end
        end

        # clean up after keys that could have been left over by calling reject! or shift on the flash
        (@used.keys - keys).each{ |k| @used.delete(k) }
      end

      def store(session, key = "flash")
        return if self.empty?
        session[key] = self
      end

      private
        # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
        # use() # marks the entire flash as used
        # use('msg') # marks the "msg" entry as used
        # use(nil, false) # marks the entire flash as unused (keeps it around for one more action)
        # use('msg', false) # marks the "msg" entry as unused (keeps it around for one more action)
        def use(k=nil, v=true)
          unless k.nil?
            @used[k] = v
          else
            keys.each{ |key| use(key, v) }
          end
        end
    end

    module InstanceMethods #:nodoc:
      protected
        def perform_action_with_flash
          perform_action_without_flash
          if defined? @_flash
            @_flash.store(session)
            remove_instance_variable(:@_flash)
          end
        end

        def reset_session_with_flash
          reset_session_without_flash
          remove_instance_variable(:@_flash) if defined? @_flash
        end

        def redirect_to_with_flash(options = {}, response_status_and_flash = {}) #:doc:
          if alert = response_status_and_flash.delete(:alert)
            flash[:alert] = alert
          end

          if notice = response_status_and_flash.delete(:notice)
            flash[:notice] = notice
          end
          
          if other_flashes = response_status_and_flash.delete(:flash)
            flash.update(other_flashes)
          end
          
          redirect_to_without_flash(options, response_status_and_flash)
        end

        # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
        # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
        # to put a new one.
        def flash #:doc:
          if !defined?(@_flash)
            @_flash = session["flash"] || FlashHash.new
            @_flash.sweep
          end

          @_flash
        end

        
        # Convenience accessor for flash[:alert]
        def alert
          flash[:alert]
        end
        
        # Convenience accessor for flash[:alert]=
        def alert=(message)
          flash[:alert] = message
        end

        # Convenience accessor for flash[:notice]
        def notice
          flash[:notice]
        end
        
        # Convenience accessor for flash[:notice]=
        def notice=(message)
          flash[:notice] = message
        end
    end
  end
end
Something went wrong with that request. Please try again.