hobo_rapid 1.4.0.pre6 → 1.4.0.pre7

data/VERSION

@@ -1 +1 @@
-1.4.0.pre6
+1.4.0.pre7

data/app/helpers/hobo_cache_helper.rb

@@ -0,0 +1,37 @@
+module HoboCacheHelper
+  def hobo_cache_key(namespace=:views, route_on=nil, query_params=nil, attributes=nil)
+    attributes ||= {}
+
+    if route_on == true
+      route_on = this
+    end
+
+    if route_on.is_a?(ActiveRecord::Base)
+      route_on = url_for(route_on)
+    end
+
+    if route_on
+      attributes.reverse_merge!(Rails.application.routes.recognize_path(route_on))
+    elsif params[:page_path]
+      # it's quite possible that our page was rendered by a different action, so normalize
+      attributes.reverse_merge!(Rails.application.routes.recognize_path(params[:page_path]))
+    end
+
+    key_attrs = attributes
+    key_attrs[:only_path] = false
+    comma_split(query_params || "").each do |qp|
+      key_attrs["#{qp}"] = params[qp] || ""
+    end
+
+    ActiveSupport::Cache.expand_cache_key(url_for(key_attrs).split('://').last, namespace)
+  end
+
+  def item_cache(*args, &block)
+    unless Rails.configuration.action_controller.perform_caching
+      yield if block_given?
+    else
+      key = hobo_cache_key(:item, *args)
+      Rails.cache.fetch(key, &block)
+    end
+  end
+end

data/lib/hobo_rapid/previous_uri_filter.rb

@@ -0,0 +1,10 @@
+module HoboRapid
+  # this after_filter is useful for the after_submit tag
+  class PreviousUriFilter
+    def self.filter(controller)
+      if controller.request.get?
+        controller.session[:previous_uri] = controller.request.path
+      end
+    end
+  end
+end

data/lib/hobo_rapid.rb

@@ -1,3 +1,6 @@
+ActiveSupport::Dependencies.autoload_paths |= [File.dirname(__FILE__)]
+ActiveSupport::Dependencies.autoload_once_paths |= [File.dirname(__FILE__)]
+
 module HoboRapid
 
   VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip

data/taglibs/buttons/delete-button.dryml

@@ -47,7 +47,12 @@ All the standard ajax attributes *except the callbacks* are supported (see the m
     in_place = !(this == @this && request.method.downcase == "get") if in_place.nil?
     update_attrs, attributes = attributes.partition_hash(HoboRapidHelper::AJAX_UPDATE_ATTRS)
     ajax_attrs, attributes = attributes.partition_hash(HoboRapidHelper::AJAX_ATTRS)
-    attributes[src] = "#{base_url}/images/#{image}" if image
+    if image
+      attributes[:src] ||= image_path(image)
+      attributes[:type] ||= 'image'
+    else
+      attributes[:type] ||= 'submit'
+    end
     label ||= t("hobo.actions.remove", :default=>"Remove")
     confirm = t("hobo.messages.confirm", :default=>"Are you sure?") if confirm.nil?
     ajax_attrs[:confirm] = confirm if confirm
@@ -69,7 +74,7 @@ All the standard ajax attributes *except the callbacks* are supported (see the m
 %>
   <if test="&url && can_delete?">
     <form method="delete" action="&url" class="button_to" merge-attrs="&ajax_attrs" data-rapid="&data_rapid" data-rapid-context="&typed_id">
-      <input type="submit" value="&label" merge/>
+      <input value="&label" merge/>
     </form>
   </if>
 </def>

data/taglibs/cache/cache.dryml

@@ -1 +1,42 @@
 <!-- Tags for caching -->
+
+
+<!-- `<cache>` is a simple fragment cache without the hierarchical dependency tracking used in `<swept-cache>` or `<nested-cache>`.
+
+### Attributes
+
+All extra attributes are used as cache keys.
+
+`query-params`: A comma separated list of query (or post) parameters
+used as non-hierarchical cache keys.
+
+`route-on`: Rails fragment caching uses the the current route to build
+its cache key.  If you are caching an item that will be used in
+multiple different actions, you can specify route-on to ensure that
+the different actions can share the cache.  You can pass either an
+object or a path to route-on.  If you pass an object, it is converted
+to a path with `url_for`.  If you specify route-on without a value,
+`this` is used.  An alternative to using `route-on` is to specify
+`controller`, `action` and any other required path parameters
+explicitly.  For example route-on="&posts_path" is identical to
+controller="posts" action="index".  If you do not specify route-on or
+controller, action, etc., `params[:page_path]` or the current action
+is used.
+
+-->
+<def tag="cache" attrs="query-params,route-on"><%
+   unless Rails.configuration.action_controller.perform_caching
+     %><%= parameters.default %><%
+   else
+     key_key_s = hobo_cache_key(:views, route_on, query_params, attributes)
+     cache_content = Rails.cache.read key_key_s
+     unless cache_content.nil?
+       Rails.logger.debug "CACHE HIT #{key_key_s}"
+       %><%= raw cache_content %><%
+     else
+       Rails.logger.debug "CACHE MISS #{key_key_s}"
+       %><%= raw cache_content=parameters.default %><%
+       Rails.cache.write(key_key_s, cache_content)
+     end
+   end
+%></def>

data/taglibs/cache/nested_cache.dryml

@@ -59,7 +59,8 @@ replace with:
 ### Attributes
 
 All extra attributes are used as non-hierarchical cache keys, so for
-inner caches these should be constants.
+inner caches these should either be constants or be manually
+propagated to the outer caches
 
 `methods`: A comma separated list of methods or fields that can be
 called on the context (aka this) to produce cache keys.  Example:
@@ -76,7 +77,7 @@ its cache key.  If you are caching an item that will be used in
 multiple different actions, you can specify route-on to ensure that
 the different actions can share the cache.  You can pass either an
 object or a path to route-on.  If you pass an object, it is converted
-to a path with `url_for`.  If you specify route-on with a value,
+to a path with `url_for`.  If you specify route-on without a value,
 `this` is used.  An alternative to using `route-on` is to specify
 `controller`, `action` and any other required path parameters
 explicitly.  For example route-on="&posts_path" is identical to
@@ -88,25 +89,13 @@ attribute.
 
 ### Hints
 
-If you are using an LRU cache such as memory-cache, memcached or redis
-you typically specify `updated_at` in the methods attribute.
+If you have sweepers, you probably want `<swept-cache>` instead.
 
-If you are using a cache with manual expiration, `typed_id` is a
-convenient unique id that is available on all Hobo models that have
-been saved in the database.  You can then add this to your FooSweeper:
-
-    def after_update(foo)
-      Rails.cache.delete_matched(/typed_id\=#{CGI.escape foo.typed_id}(&|$)/)
-    end
-
-This will delete the fragment, along will all fragments that contain
-that fragment.
-
-Another thing to keep in mind is that any Hobo tag that can generate a
-page refresh, such as filter-menu, table-plus or page-nav stores query
-parameters such as search, sort & page so that these are not lost when
-refreshed.  So they will need to be added to the query-params for any
-cache containing such tags.
+Any Hobo tag that can generate a page refresh, such as filter-menu,
+table-plus or page-nav stores query parameters such as search, sort &
+page so that these are not lost when the tag is used to refresh the
+page. These will need to be added to the query-params for any cache
+containing such tags.
 
 -->
 <def tag="nested-cache" attrs="methods,query-params,route-on">
@@ -133,7 +122,7 @@ cache containing such tags.
      end
 
      comma_split(query_params).each do |qp|
-       key_key["@#{qp}"] = params[qp]
+       key_key["@#{qp}"] = params[qp] || ""
      end
 
      if route_on == true
@@ -146,10 +135,8 @@ cache containing such tags.
 
      if route_on
        attributes.reverse_merge!(Rails.application.routes.recognize_path(route_on))
-     end
-
-     # it's quite possible that our page was rendered by a different action, so normalize
-     if params[:page_path]
+     elsif params[:page_path]
+       # it's quite possible that our page was rendered by a different action, so normalize
        attributes.reverse_merge!(Rails.application.routes.recognize_path(params[:page_path]))
      end
 
@@ -247,7 +234,7 @@ cache containing such tags.
            fail if scope.cache_paths_stack.length>0
          end
        else
-         # we have a parent cache, so it's set up the scope.
+         # we have a parent cache, so it has set up the scope.
          if form_field_path.nil? || form_field_path[0...scope.cache_path_root.length] != scope.cache_path_root
            fail "nested caching error:  form_field_path has been corrupted via with= or form"
          end
@@ -303,9 +290,10 @@ cache containing such tags.
          thunk2.call(k,v,cache_keys[k])
        end
 
+       # if content_key_s has a value, it means that our original key is still valid, but we were invalidated by our children.
        if content_key_s.nil?
          if !have_children
-           # if we don't have any children, then we can store the content against key_key_s.  We also store cache_keys in case we ever have a parent who needs to regenerate their keys.  We can give then them ours without regenerating.
+           # if we don't have any children, then we can store the content against key_key_s.  We also store cache_keys in case we ever have a parent who needs to regenerate their keys.  We can then give them ours without regenerating.
            Rails.logger.debug "CACHE: #{key_key_s} -> content + key #{cache_keys}"
            Rails.cache.write(key_key_s, [cache_content, cache_keys])
            content_key_s = ""
@@ -328,5 +316,4 @@ cache containing such tags.
 
      end
    end
-%>
-</def>
+%></def>

data/taglibs/cache/swept_cache.dryml

@@ -0,0 +1,264 @@
+<!--
+
+`<swept-cache>` is a fragment cache that stores context dependency information for itself and all contained inner swept-cache's.   Dependencies are not checked if the cache is hit.   This means that swept-cache should be considerably faster than `<nested-cache>`, but it does require that you create sweepers for your caches.   These sweepers can use the stored dependency information to invalidate the appropriate fragments.
+
+### Example
+
+    <def tag="card" for="Foo">
+      <swept-cache route-on suffix="card">
+        <card without-header>
+          <body:><view:body/></body>
+        </card>
+      </nested-cache>
+    </def>
+
+    <def tag="view" for="Bar">
+      <swept-cache route-on suffix="view">
+        <view:body/>
+        <swept-cache:foos route-on="&this_parent" suffix="collection">
+          <collection/>
+        <swept-cache>
+      </swept-cache>
+    </def>
+
+    class FooSweeper < ActionController::Caching::Sweeper
+      observe Foo
+
+      def after_create(foo)
+        expire_swept_caches_for(foo.bar, :foos)
+      end
+
+      def after_update(foo)
+        expire_swept_caches_for(foo)
+        expire_swept_caches_for(foo.bar, :foos)
+      end
+
+      def after_destroy(foo)
+        expire_swept_caches_for(foo)
+        expire_swept_caches_for(foo.bar, :foos)
+      end
+    end
+
+    class BarSweeper < ActionController::Caching::Sweeper
+      observe Bar
+
+      def after_update(bar)
+        expire_swept_caches_for(bar)
+      end
+
+      def after_destroy(bar)
+        expire_swept_caches_for(bar)
+      end
+    end
+
+In the above example, if a Foo gets updated, the following fragment caches will be invalidated:
+
+  - the card for the foo
+  - the collection of foos inside bar
+  - the bar view
+  - any pages that have a swept-cache that contains a view of bar
+
+When outer caches are rebuilt, inner caches that are still valid may be used as is.
+
+### Specifying the Context
+
+swept-cache assumes that the cache is dependent on the current context
+(aka this) as well as the context of any contained swept-cache's.
+
+The context must be either an object that has been saved to the
+database, or an attribute on an object that has been saved to the
+database. If it is not one of these two, you must either switch the
+context to something that is, or specify the dependencies manually.
+
+When specifying the dependencies manually, you pass a list of database
+objects, database objects plus an attribute name, and/or strings.
+
+    <swept-cache dependencies="&[this, [this, :comments], foo, :all_foos]"
+
+Note that when dependencies are specified manually, `this` must be
+added to the list, if so desired.
+
+Also note that dependencies are not added to the cache key.
+
+### Attributes
+
+All extra attributes are used as non-hierarchical cache keys, so for
+inner caches these should either be constants or be manually
+propagated to the outer caches
+
+`dependencies`: see above.   Default is "&[this]"
+
+`query-params`: A comma separated list of query (or post) parameters
+used as non-hierarchical cache keys.
+
+`route-on`: Rails fragment caching uses the the current route to build
+its cache key.  If you are caching an item that will be used in
+multiple different actions, you can specify route-on to ensure that
+the different actions can share the cache.  You can pass either an
+object or a path to route-on.  If you pass an object, it is converted
+to a path with `url_for`.  If you specify route-on without a value,
+`this` is used.  An alternative to using `route-on` is to specify
+`controller`, `action` and any other required path parameters
+explicitly.  For example route-on="&posts_path" is identical to
+controller="posts" action="index".  If you do not specify route-on or
+controller, action, etc., `params[:page_path]` or the current action
+is used.  route-on is a non-hierarchical key.
+
+### Hints
+
+Any Hobo tag that can generate a page refresh, such as filter-menu,
+table-plus or page-nav stores query parameters such as search, sort &
+page so that these are not lost when the tag is used to refresh the
+page. These will need to be added to the query-params for any cache
+containing such tags.
+
+### Example: Caching @current_user
+
+This is the pattern we use to cache the page header:
+
+     <swept-cache suffix="header" current-user="&@current_user.id" dependencies="&[@current_user]">
+
+Notice that @current_user is specified as a dependency in 2 different ways.
+
+`current-user="&@current_user.id"` ensures that the current user's ID
+is added to the cache key, ensuring that each user gets their own
+header rather than having every user share the same header.
+
+`dependencies="&[@current_user]` does not affect the cache key, only
+the cache content. It enables the cache to be swept if any of the user
+columns change, such as the user's name.
+
+### Cache Store requirements
+
+#### stability
+
+For this tag to function correctly, the cache must not evict the
+dependency information, so purely LRU caches such as MemoryStore may
+not be used in production. The cache can evict fragments, though. For
+this reason, you may configure two separate caches:
+
+    config.cache_store = :memory_store, {:size => 512.megabytes}
+    config.hobo.stable_cache_store = :file_store
+
+Note that the dependency cache store does not have to be persistent,
+it's OK to clear the dependency cache at the same time as the fragment
+cache.
+
+#### atomic updates
+
+In production, swept-cache needs to be able to update a list
+atomically.  This is not an operation supported by the Rails cache API,
+but it is supported by most non-trivial caches via one of several
+mechanisms.
+
+#### supported caches
+
+memory_store: not compliant, but can be used for development if the size is set large enough to avoid evictions.
+
+[file_store](http://api.rubyonrails.org/classes/ActiveSupport/Cache/FileStore.html):  A good choice for low traffic sites where reads vastly outnumber writes.
+
+memcached: not compliant
+
+redis:  a great choice.   You can use the same instance for both fragment caching with expiry set the fragments to expire without disturbing the dependency information by setting the options differently:
+
+    config.cache_store = :redis_store, "redis://192.168.1.2:6379/1", :expires_in => 60.minutes
+    config.hobo.stable_cache_store = :redis_store, "redis://192.168.1.2:6379/1"
+
+[torquebox infinispan](http://torquebox.org/): another great choice
+
+    config.cache_store = :torque_box_store
+    config.hobo.stable_cache_store = :torque_box_store, :name => 'dependencies', :mode => :replicated, :sync => true
+
+others: ask on the hobo-users list.
+
+-->
+<def tag="swept-cache" attrs="query-params,route-on,dependencies"><%
+   unless Rails.configuration.action_controller.perform_caching
+     %><%= parameters.default %><%
+   else
+     key_key_s = hobo_cache_key(:views, route_on, query_params, attributes)
+     cache_content = Rails.cache.read key_key_s
+     unless cache_content.nil?
+       Rails.logger.debug "CACHE HIT #{key_key_s}"
+
+       cache_content, cache_ids = cache_content
+
+       if scope.cache_ids
+         # we have parent caches trying to generate their keys, so oblige them
+         scope.cache_ids += Set.new(cache_ids)
+       end
+
+       %><%= raw cache_content %><%
+     else
+       Rails.logger.debug "CACHE MISS #{key_key_s}"
+       # darn, cache is invalid.  Now we have to generate our content and (re)generate our keys.
+
+       unless scope.cache_ids
+         # no parent caches so we need to set up the scope.
+         scope.new_scope(:cache_ids => Set.new, :cache_stack => []) do
+           %><%= cache_content=parameters.default %><%
+           cache_ids = scope.cache_ids
+         end
+       else
+         # we have a parent cache, so it has set up the scope.
+         scope.cache_stack.push scope.cache_ids
+         scope.cache_ids = Set.new
+         %><%= cache_content=parameters.default %><%
+         cache_ids = scope.cache_ids
+       end
+
+       dependencies = comma_split(dependencies) if dependencies.is_a?(String)
+       dependencies ||= [this]
+       dependencies.each do |dep|
+         if dep.respond_to?(:typed_id) && dep.typed_id
+           cache_ids << dep.typed_id
+         elsif dep.respond_to?(:origin) && dep.origin
+           cache_ids << "#{dep.origin.typed_id}:#{dep.origin_attribute}"
+         elsif dep.respond_to?(:to_sym)
+           cache_ids << dep.to_s
+         elsif dep.respond_to?(:first) && dep.first.respond_to?(:typed_id) && dep.first.typed_id && dep.last.respond_to?(:to_sym)
+           cache_ids << "#{dep.first.typed_id}:#{dep.last}"
+         else
+           fail "#{dep} not a Hobo model or not in database"
+         end
+       end
+
+       if scope.cache_stack
+         scope.cache_ids += scope.cache_stack.pop
+       end
+
+       cache_ids.each do |cache_id|
+         # the database we're using must support atomically adding to a cache key
+         # there are several possible ways of doing so.
+         #   transactions: supported by Infinispan and activerecord-cache
+         #   sets: Redis has a set datatype (SADD & friends)
+         #   regex read: munge the value onto the key and then store that instead.   Then do a regex read to get all values
+
+
+         if Hobo.stable_cache.respond_to?(:transaction)
+           key = ActiveSupport::Cache.expand_cache_key(cache_id, :sweep_key)
+           Hobo.stable_cache.transaction do
+             l = Set.new(Hobo.stable_cache.read(key)) << key_key_s
+             Rails.logger.debug "CACHE SWEEP KEY: #{cache_id} #{l.to_a}"
+             Hobo.stable_cache.write(key, l.to_a)
+           end
+         elsif Hobo.stable_cache.respond_to?(:read_matched)
+           key = ActiveSupport::Cache.expand_cache_key([cache_id, key_key_s], :sweep_key)
+           Rails.logger.debug "CACHE SWEEP KEY: #{key}"
+           Hobo.stable_cache.write(key, nil)
+         else
+           # TODO: add support for Redis
+           key = ActiveSupport::Cache.expand_cache_key(cache_id, :sweep_key)
+           Rails.logger.warn "WARNING!  cache transactions not supported please fix before going to production"
+           l = Set.new(Hobo.stable_cache.read(key)) << key_key_s
+           Rails.logger.debug "CACHE SWEEP KEY: #{cache_id} #{l.to_a}"
+           Hobo.stable_cache.write(key, l.to_a)
+         end
+       end
+
+       # Also store cache_ids in case we ever have a parent who needs to regenerate their keys.  We can give then them ours without regenerating.
+       Rails.logger.debug "CACHE: #{key_key_s} -> content + ids #{cache_ids.to_a}"
+       Rails.cache.write(key_key_s, [cache_content, cache_ids.to_a])
+     end
+   end
+%></def>

data/taglibs/html/a.dryml

@@ -114,7 +114,7 @@ The standard AJAX attributes are supported.
       nil_view
     elsif action == "new"
       # Link to a new object form
-      new_record = target.new
+      new_record = target.respond_to?(:build) ? target.build : target.new
       new_record.set_creator(current_user)
       href = object_url(target, "new", params._?.merge(:subsite => subsite))
 

data/taglibs/html/table.dryml

@@ -139,7 +139,7 @@ Produces:
   </if>
   <else>
     <% field_tag ||= "view" %>
-    <unless test="&this.empty? && !empty">
+    <unless test="&(this.nil? || this.empty?) && !empty">
       <%= element "table", attributes - attrs_for(:with_fields) do %>
       <thead if="&all_parameters[:thead] || fields" param>
         <tr param="field-heading-row">

data/taglibs/inputs/after_submit.dryml

@@ -10,19 +10,25 @@ Use the `stay-here` attribute to remain on the current page:
       ...
     </form>
 
-Use the `go-back` option to return to the page in `session[:previous_uri]`:
+Use the `uri` option to specify a redirect location:
 
     <form>
-      <after-submit go-back/>
+      <after-submit uri="/admin"/>
       ...
     </form>
 
-Use the `uri` option to specify a redirect location:
+Use the `go-back` option to return to the page in `session[:previous_uri]`:
 
     <form>
-      <after-submit uri="/admin"/>
+      <after-submit go-back/>
       ...
     </form>
+
+Note that session[:previous_uri] isn't automatically populated. To
+automatically populate it, add to application_controller.rb:
+
+    after_filter HoboRapid::PreviousUriFilter
+
 -->
 <def tag="after-submit" attrs="uri, stay-here, go-back"><%
   uri = "stay-here" if stay_here

data/taglibs/inputs/input.dryml

@@ -48,7 +48,8 @@ If the context is a `has_many :through` association, the polymorphic `<collectio
     elsif no_edit_permission && no_edit == :skip
       ""
     else
-      attrs = add_classes(attributes, type_id.dasherize, type_and_field.dasherize)
+      attrs = attributes
+      attrs = add_classes(attrs, type_id.dasherize, type_and_field.dasherize) unless type_id.nil? || type_and_field.nil?
       attrs[:name] ||= param_name_for_this
       attrs[:disabled] = true if no_edit_permission && no_edit == :disable
       the_input = if (refl = this_field_reflection)
@@ -66,7 +67,7 @@ If the context is a `has_many :through` association, the polymorphic `<collectio
                       (call_polymorphic_tag('input', HoboFields.to_class(this_type::COLUMN_TYPE), attrs) if defined?(this_type::COLUMN_TYPE)) or
                       raise Hobo::Error, ("No input tag for #{this_field}:#{this_type} (this=#{this.inspect})")
                   end
-      unless this_parent.errors[this_field].empty?
+      unless this_parent.nil? || this_parent.errors[this_field].empty?
         "<span class='field-with-errors'>#{the_input}</span>".html_safe
       else
         the_input

data/taglibs/plus/filter_menu.dryml

@@ -22,9 +22,9 @@ See [Filtering stories by status](/tutorials/agility#filtering_stories_by_status
 Standard AJAX attributes such as 'update' are supported.   If any are supplied, filter-menu uses Ajax rather than a page refresh.
 
  - `param-name` - the name of the HTTP parameter to use for the filter
- - `options` - an array of options or an array of arrays (useful for localized apps) for the menu.
-   It can be omitted if you provide the options as an array or array of arrays in the locale file.
- - `no-filter` - The text of the first option which indicates no filter is in effect. Defaults to 'All'
+ - `options` - an array of options or an array of pairs (useful for localized apps) for the menu.
+   It can be omitted if you provide the options as an array or array of pairs in the locale file.
+ - `no-filter` - The text of the first option which indicates no filter is in effect. Defaults to 'All'.  Pass "&false" to disable the no-filter option
  - `first-value` - the value to be used with the first option. Typically not used,
  meaning the option has a blank value.
  - model - the model name (optional: needed if you use the "activerecord.attributes" namespace.
@@ -85,11 +85,17 @@ or
      </select>
 
   -->
-<def tag="filter-menu" attrs="model, param-name, options, no-filter, id, first-value">
-  <% options = t("activerecord.attributes.#{model}.filter_menu.#{param_name}.options", :default=>[:"tags.filter_menu.#{param_name}.options", options])
-     raise ArgumentError, %(You must provide an "options" attribute, or set "activerecord.attributes.#{model}.filter_menu.#{param_name}.options" or "tags.filter_menu.#{param_name}.options" to an Array or to an Array of Arrays
-     in your locale file(s)) unless options.is_a?(Array)
-     no_filter = t("activerecord.attributes.#{model}.filter_menu.#{param_name}.no_filter", :default=>[:"tags.filter_menu.#{param_name}.no_filter", :"tags.filter_menu.default.no_filter", no_filter, "All"])
+<def tag="filter-menu" attrs="model, param-name, options, no-filter, first-value">
+  <% # this odd construction is required in production mode for some reason
+      translated_options = I18n.translate("activerecord.attributes.#{model}.filter_menu.#{param_name}.options", :default=>[:"tags.filter_menu.#{param_name}.options"])
+      options = translated_options unless translated_options.is_a?(String)
+     raise ArgumentError, %(You must provide an "options" attribute, or set "activerecord.attributes.#{model}.filter_menu.#{param_name}.options" or "tags.filter_menu.#{param_name}.options" to an Array or to an Array of pairs in your locale file(s)) unless options.is_a?(Array)
+     if no_filter==false
+       no_filter = nil
+     else
+       no_filter = t("activerecord.attributes.#{model}.filter_menu.#{param_name}.no_filter", :default=>[:"tags.filter_menu.#{param_name}.no_filter", :"tags.filter_menu.default.no_filter", no_filter, "All"])
+     end
+     attributes['message'] ||= t("FIXME", :default => "Loading...") if HoboRapidHelper::AJAX_ATTRS.any?{|a| attributes.has_key?(a)}
      %>
   <form action="&request.path" method="get" class="filter-menu" merge-attrs="&attributes"  data-rapid="&data_rapid('filter-menu')">
     <div>

data/taglibs/plus/search_filter.dryml

@@ -0,0 +1,15 @@
+<def tag="search-filter">
+  <form param="search-form" method="get" action="" with="&nil" merge-attrs >
+    <hidden-fields for-query-string skip="page, search"/>
+    <span param="label"><t key="hobo.table_plus.search">Search</t></span>
+    <input class="search" type="search" name="search" value="&params[:search]"/>
+    <submit label="&t('hobo.table_plus.submit_label', :default=>'Go')" class="search-button" param="search-submit"/>
+  </form>
+  <if test="&params[:search]">
+    <form param="clear-form" method="get" action="" merge-attrs>
+      <hidden-fields for-query-string skip="page, search"/>
+      <input type="hidden" name="search" value=""/>
+      <submit label="Clear" class="search-button" param="clear-submit"/>
+    </form>
+  </if>
+</def>

data/taglibs/plus/table_plus.dryml

@@ -26,12 +26,7 @@ sort-columns: a hash that allow you to map fields to sortable columns.   The def
   <div class="table-plus" merge-attrs="&attributes - attrs_for(:with_fields) - attrs_for(:table)">
     <div class="header" param="header">
       <div class="search">
-        <form param="search-form" method="get" action="" with="&nil" merge-attrs="&ajax_attrs" >
-          <hidden-fields for-query-string skip="page, search"/>
-          <span><t key="hobo.table_plus.search">Search</t></span>
-          <input class="search" type="search" name="search" value="&params[:search]"/>
-          <submit label="&t('hobo.table_plus.submit_label', :default=>'Go')" class="search-button" param="search-submit"/>
-        </form>
+        <search-filter merge-attrs="&ajax_attrs" param/>
       </div>
     </div>
 

metadata

@@ -2,7 +2,7 @@
 name: hobo_rapid
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 1.4.0.pre6
+  version: 1.4.0.pre7
 platform: ruby
 authors: 
 - Tom Locke, Bryan Larsen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-24 00:00:00 Z
+date: 2012-07-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: hobo
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 1.4.0.pre6
+        version: 1.4.0.pre7
   type: :runtime
   version_requirements: *id001
 description: The RAPID tag library for Hobo
@@ -35,9 +35,11 @@ files:
 - README.markdown
 - VERSION
 - app/controllers/dev_controller.rb
+- app/helpers/hobo_cache_helper.rb
 - app/helpers/hobo_rapid_helper.rb
 - hobo_rapid.gemspec
 - lib/hobo_rapid.rb
+- lib/hobo_rapid/previous_uri_filter.rb
 - lib/hobo_rapid/railtie.rb
 - taglibs/buttons/buttons.dryml
 - taglibs/buttons/create_button.dryml
@@ -48,6 +50,7 @@ files:
 - taglibs/buttons/update_button.dryml
 - taglibs/cache/cache.dryml
 - taglibs/cache/nested_cache.dryml
+- taglibs/cache/swept_cache.dryml
 - taglibs/cards/card.dryml
 - taglibs/cards/cards.dryml
 - taglibs/cards/search_card.dryml
@@ -122,6 +125,7 @@ files:
 - taglibs/plus/gravatar.dryml
 - taglibs/plus/live_search.dryml
 - taglibs/plus/plus.dryml
+- taglibs/plus/search_filter.dryml
 - taglibs/plus/sortable_collection.dryml
 - taglibs/plus/table_plus.dryml
 - taglibs/views/a_or_an.dryml
@@ -165,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: hobo
-rubygems_version: 1.8.17
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: The RAPID tag library for Hobo