ingoweiss-resourceful_views 0.2.0

data/README

@@ -0,0 +1,148 @@
+= ResourcefulViews 0.2
+
+ResourcefulViews aims to take RESTful conventions beyond controllers and into views by extending the 'map.resources' method to install a comprehensive vocabulary of resource-oriented view helpers
+
+
+== Why?
+
+Rails, being it's opinionated self, establishes strong RESTful conventions for routes and controllers. In comparison, Rails appears to have few opinions about how views should be written, let alone CSS sheets or JavaScripts. I think this is some wasted RESTful momentum worth recouping, and ResourcefulViews is here to recoup it.
+
+The vision is that once an application's resources are defined, developers and designers will have a rich, shared vocabulary of view helpers and CSS classes readily available, greatly reducing the need to come up with their own, potentially conflicting vocabularies, and freeing them to focus on higher level problems instead.
+
+
+== How?
+
+For every resource defined in routes.rb via 'resources' or 'resource', ResourcefulViews defines seven helper methods (plus some extra ones). For each of the seven 'CRUD' actions one helper is installed which:
+
+* is named '[CRUD action]_[route name prefix][resource name]': 'create_table', 'destroy_table_leg', 'new_table_top', etc.
+* renders either a link (index new show edit) or a form (create update delete), that, when clicked/submitted, will trigger an HTTP request which gets routed to the helper's CRUD action on the resource's controller
+* equips the link/form with a set of standard class attributes composed of the resource name, the CRUD action name, plus the two joined with '_' to help IE ('create table create_table')
+
+
+== Basic example:
+
+Say you have an app for furnishing your dream aparmtment, with a 'tables' resource. With ResourcefulViews installed, <code>map.resources :tables</code> will not only install the standard named route helpers, but also the following ones:
+
+  index_tables, new_table, create_table, show_table, edit_table, update_table, destroy_table
+
+Now let's look at a vertical slice through an application, with the deletion of a 'table' resource as an example:
+
+==== Routes
+
+  map.resources :tables
+
+==== Controller
+
+  class TablesController < ActiveRecord::Base
+    def  destroy
+      @table = Table.find(params[:table])
+      @table.destroy
+      redirect_to :action => 'index'
+    end
+  end
+  
+==== View
+
+So far so familar. However, here is where Rails drops the RESTful ball. With ResourcefulViews, however, you can write in your views:
+
+  <% destroy_table(@table) %>
+  
+  # this will render:
+  <form action="/tables/1" method="post" class="destroy table destroy_table">
+    <input type="hidden" name="_method" value="delete" />
+    <button type="submit">Delete</button>
+  </form>
+  
+Note the auto-generated class names, allowing you to use 'resourceful' naming conventions beyond the view, for example in CSS sheets and JavaScript scripts:
+  
+==== CSS
+  
+  form.destroy_table button { background-image: url(/images/buttons/remove.png) }
+  
+==== JavaScript
+  
+  # LowPro behavior:
+  Event.addBehavior({
+    'form.destroy': ConfirmDestroyResource()
+  });
+  
+==== Tests
+
+  # rspec story step
+  Then(/the page should have a(n?) ([a-z_]+) ([a-z_]+) (form|link)/) do |_, crud_action, resource_name, tag|
+    response.should have_tag("#{tag}.#{crud_action}_#{resource_name}")
+  end
+  
+  # rspec text story
+  Then the page should have a create comment form
+
+
+Nice and consistent, isn't it? And compact, too:
+
+  <% create_table :with => {:type => 'DiningTable'} %>
+  
+  # will render:
+  <form action="/tables" method="post" class="create table create_table">
+    <input type="text" name="table[type]" value="DiningTable" />
+    <button type="submit">Add</button>
+  </form>
+  
+  <% search_tables :parameters => {:order => 'name'} %>
+   
+  # will render:
+  <form action="/tables" method="get" class="index tables index_tables search search_tables">
+    <input type="hidden" name="order" value="name">
+    <input type="text" name="query" />
+    <button type="submit">Search</button>
+  </form>
+
+This is just to give you a taste of what is possible. For more examples please refer to the rdoc for the individual 'build_[CRUD action name]_helper' methods (<code>rake doc:plugins PLUGIN=resourceful_views</code>)
+
+== Common options
+
+* <code>:label</code> specifies the content of the link tag in link helpers, and of the button tag in form helpers. If <code>:label</code> is omitted, the helpers will use a default label
+* <code>:with</code> allows for specifying resource attributes to send with the request (using bracket syntax), via url query parameters in link helpers, and via hidden fields in form helpers (the old form of the option - <code>:attributes</code> - will continue to work for a while)
+* <code>:sending</code> allows for specifying additional parameters to send with the request, via url query parameters in link helpers, and via hidden fields in form helpers (the old form of the option - <code>:parameters</code> - will continue to work for a while)                                
+* All other options(such as <code>:id</code> and <code>:title</code>) are applied to the form in form helpers and to the link in link helpers
+* To apply options to the button tag instead of the form tag in form helpers, make the options hash the value of the <code>:button</code> option (<code>:button => {:id => 'logout_button'}</code>)
+* both the <code>create_resource</code> and the <code>update_resource</code> helpers support passing in a 'template' model as the last argument that is passed on to the 'fields_for' helper
+
+
+== How about nested resources?
+
+Not a problem. In fact, here is where it gets interesting:
+
+  <% edit_table_top(@table) %>
+  
+  # will render:
+  <a href="/tables/1/top/edit" class="edit top edit_top">Edit</a>
+  
+
+== Helper name suffixes
+
+If the helpers are crowding your namespace, or if you just don't like the short helper names, you can tell ResourcefulViews to use suffixes for naming the helpers. Just put this in an initializer:
+
+  # This will append '_link' to all link helpers, like 'edit_table_top_link'
+  ResourcefulViews.link_helpers_suffix = '_link'
+  
+  # This will append '_form' to all link helpers, like 'search_tables_form'
+  ResourcefulViews.form_helpers_suffix = '_form'
+  
+  
+== Tests
+
+ResourcefulViews comes with en extensive rspec test suite: <code>rake spec:plugins PLUGIN=resourceful_views</code>. The test suite might also be a good place to look for more usage examples
+
+
+== Feedback
+
+Please report bugs and suggest improvements at http://resourceful_views.lighthouseapp.com
+  
+
+== Known problems
+
+* ActiveMerchant seems to run 'routes.rb' before ResourcefulViews loads, resulting in ResourcefulViews helpers not being defined. To fix this, make sure ResourcefulViews loads before active_merchant by putting this in your environment file: <code>config.plugins = [ :resourceful_views, :all ]</code>  
+
+
+== License
+Copyright (c) 2008 Ingo Weiss, released under the MIT license

data/lib/resourceful_views.rb

@@ -0,0 +1,618 @@
+class ResourcefulViews
+  
+  cattr_accessor :form_helpers_suffix, :link_helpers_suffix
+  cattr_accessor :helpers
+  
+  def initialize # :nodoc:    
+    @module ||= Module.new
+    yield self
+  end
+  
+  # generate a string of space-separated standardized CSS classnames
+  def self.resourceful_classnames(primary_classname, *secondary_classnames)
+    classnames = []
+    classnames << primary_classname
+    secondary_classnames.each do |classname|
+      classnames << classname
+      classnames << [classname, primary_classname].join('_') # a little help for IE
+    end
+    classnames.join(' ')
+  end
+  
+  # Build resourceful helpers for a plural resource and install them into ActionView::Base
+  def build_and_install_helpers_for_resource(resource) # :nodoc:
+    build_index_helper(resource)
+    build_search_helper(resource)
+    build_show_helper(resource)
+    build_new_helper(resource)
+    build_edit_helper(resource)
+    build_destroy_helper(resource)
+    build_list_helpers(resource)
+    build_table_helpers(resource)
+    build_create_helper(resource)
+    build_update_helper(resource)
+    memorize_helpers(resource)
+    install_helpers
+  end
+  
+  # Build resourceful helpers for a singular resource and install them into ActionView::Base
+  def build_and_install_helpers_for_singular_resource(resource) # :nodoc:
+    build_show_helper(resource)
+    build_new_helper(resource)
+    build_edit_helper(resource)
+    build_destroy_helper(resource)
+    build_create_helper(resource)
+    build_update_helper(resource)
+    memorize_helpers(resource)
+    install_helpers
+  end
+  
+  def self.deprecation_warning(msg) # :nodoc:
+    RAILS_DEFAULT_LOGGER.warn('ResourcefulViews deprecation warning: ' + msg)
+  end
+  
+  def memorize_helpers(resource) # :nodoc:
+    @@helpers ||= {}
+    @@helpers["#{resource.name_prefix}#{resource.plural} at #{resource.path}"] = @module.instance_methods
+  end
+  
+  
+  protected
+  
+  # Build the 'index_[resource]' helper
+  # 
+  # === Examples
+  # 
+  #   <% index_tables %>
+  #
+  #   renders:
+  # 
+  #   <a href="/tables" class="index tables index_tables">Index</a>
+  #
+  #   <% index_table_legs(@table, :id => 'back_button', :label => 'Back') %>
+  #
+  #   renders:
+  #
+  #   <a href="/tables/1/legs" id="back_button" class="index legs index_legs">Back</a>
+  # 
+  def build_index_helper(resource)
+    helper_name = "index_#{resource.name_prefix}#{resource.plural}#{@@link_helpers_suffix}"
+    return if already_defined?(helper_name)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args)
+        opts = args.extract_options!
+        label = opts.delete(:label) || 'Index'
+        custom_classes = opts.delete(:class) || ''
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.plural}', 'index', *custom_classes.split)
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        args << opts.delete(:sending) if opts[:sending]
+        link_to(label, #{resource.name_prefix}#{resource.plural}_path(*args), opts)
+      end
+    end_eval
+  end
+  
+  
+  
+  # Build the 'search_[resource]' helper
+  # 
+  # === Examples
+  # 
+  #   <% search_tables %>
+  #
+  #   renders:
+  # 
+  #   <form action="/tables" method="get" class="index tables index_tables search search_tables">
+  #     <input type="text" name="query" />
+  #     <button type="submit">Search</button>
+  #   </form>
+  #
+  #   <%= search_tables(:label => 'Find', :sending => {:order => 'material'}) %>
+  # 
+  #   renders:
+  # 
+  #   <form action="/tables" method="get" class="index tables index_tables search search_tables">
+  #     <input type="text" name="query" />
+  #     <input type="hidden" name="order" value="material" />
+  #     <button type="submit">Find</button>
+  #   </form>
+  #
+  #   <% search_table_legs(table, :sending => {:order => 'price'}) do %>
+  #     <%= select_tag 'filter', '<option>wood</option><option>metal</option>', :id => false %>
+  #     <%= submit_button 'Search' %>
+  #   <% end %>
+  #
+  #   renders:
+  # 
+  #   <form action="/tables/1/legs" method="get" class="index tables index_tables search search_tables">
+  #     <input type="text" name="query" />
+  #     <input type="hidden" name="order" value="price" />
+  #     <select name="filter"><option>wood</option><option>glass</option></select>
+  #     <button type="submit">Search</button>
+  #   </form>
+  #    
+  def build_search_helper(resource)
+    helper_name = "search_#{resource.name_prefix}#{resource.plural}#{@@form_helpers_suffix}"
+    return if already_defined?(helper_name)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args, &block)
+        opts = args.extract_options!
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.plural}', 'search', *(opts.delete(:class) || '').split)
+        opts[:method] = :get
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        parameters = opts.delete(:sending) || {}
+        if block_given?
+          concat(form_tag(#{resource.name_prefix}#{resource.plural}_path(*args), opts), block.binding)
+            parameters.collect{ |key, value|
+              concat(hidden_field_tag(key.to_s, value, :id => nil), block.binding)
+            }
+            yield
+          concat('</form>', block.binding)
+        else
+          opts_for_button = opts.delete(:button) || {}
+          opts_for_button.merge!(:type => 'submit')
+          label = opts.delete(:label) || 'Search'
+          opts[:action] = #{resource.name_prefix}#{resource.plural}_path(*args)
+           content_tag('form', opts) do
+            text_field_tag(:query, @query, :id => nil) +
+            parameters.collect{ |key, value|
+              hidden_field_tag(key.to_s, value, :id => nil)
+            }.join +
+            content_tag(:button, label, opts_for_button)
+          end
+        end
+      end
+    end_eval
+  end
+  
+  
+  
+  # Build the 'show_[resource]' helper
+  # 
+  # === Examples
+  # 
+  #   <% show_table_top(@table, @top) %>
+  #
+  #   renders:
+  # 
+  #   <a href="/tables/1/top" class="show top show_top">Show</a>
+  #
+  #   <% show_table(@table, :label => @top.material) %>
+  # 
+  #   renders:
+  # 
+  #   <a href="/tables/1" class="show table show_table">Linoleum</a>
+  #
+  def build_show_helper(resource) 
+    helper_name = "show_#{resource.name_prefix}#{resource.singular}#{@@link_helpers_suffix}"
+    return if already_defined?(helper_name)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args)
+        opts = args.extract_options!
+        label = opts.delete(:label) || #{resource.kind_of?(ActionController::Resources::SingletonResource) ? "'Show'" : 'args.last.to_s'}
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'show', *(opts.delete(:class) || '').split)
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        args << opts.delete(:sending) if opts[:sending]
+        link_to(label, #{resource.name_prefix}#{resource.singular}_path(*args), opts)
+      end
+    end_eval
+  end
+
+
+  
+  # Build the 'new_[resource]' helper
+  # 
+  # === Examples
+  # 
+  #   <%= new_table %>
+  #
+  #   renders:
+  # 
+  #   <a href="/tables/new" class="new table new_table">New</a>
+  #
+  #   <%= new_table_top(@table, :label => 'Add a top', :id => 'add_button') %>
+  # 
+  #   renders:
+  # 
+  #   <a href="/tables/1/top/new" id="add_button" class="new top new_top">Add a top</a>
+  #
+  #   <%- new_table :with => {:name => 'Ingo'} do |f| %>
+  #     <%= f.text_area :description %>
+  #     <%= submit_button 'Save' %>
+  #   <%- end %>
+  #
+  #   renders:
+  #
+  #   <form action="/tables/new" method="get" class="new table new_table">
+  #     <input type="hidden" name="table[name]" value="Ingo" />
+  #     <textarea name="table[description]" value="" />
+  #     <button type="submit">Save</button>
+  #   </form>
+  #
+  def build_new_helper(resource)
+    helper_name = "new_#{resource.name_prefix}#{resource.singular}#{@@link_helpers_suffix}"
+    return if already_defined?(helper_name)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args, &block)
+        opts = args.extract_options!
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'new', *(opts.delete(:class) || '').split)
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        parameters = opts.delete(:sending) || {}
+        opts[:with] = opts.delete(:attributes) and ResourcefulViews.deprecation_warning('Please use :with instead of :attributes') if opts[:attributes]
+        resource_attributes = opts.delete(:with) || {}
+        parameters.merge!(resource_attributes.inject({}){|attributes, (key, value)| attributes['#{resource.singular}[' + key.to_s + ']'] = value; attributes}) if resource_attributes
+        if block_given?
+          opts[:method] = :get
+          args_for_fields_for = ['#{resource.singular}']
+          concat(form_tag(new_#{resource.name_prefix}#{resource.singular}_path(*args), opts), block.binding)
+          concat(parameters.collect{|key, value| hidden_field_tag(key.to_s, value, :id => nil)}.join, block.binding) unless parameters.empty?
+          fields_for(*args_for_fields_for, &block)
+          concat('</form>', block.binding)
+        else
+          label = opts.delete(:label) || 'New'
+          args << parameters unless parameters.empty?
+          link_to(label, new_#{resource.name_prefix}#{resource.singular}_path(*args), opts)
+        end
+      end
+    end_eval
+  end
+
+
+  
+  # Build the 'edit_[resource]' helper
+  # 
+  # === Examples
+  # 
+  #   <% edit_table_top(@table) %>
+  #
+  #   renders:
+  # 
+  #   <a href="/tables/1/top/edit" class="edit top edit_top">Edit</a>
+  #
+  #   <% edit_table_top(@table, :label => 'Change top') %>
+  # 
+  #   renders:
+  # 
+  #   <a href="/tables/1/top/edit" class="edit top edit_top">Change top</a>
+  #
+  def build_edit_helper(resource)
+    helper_name = "edit_#{resource.name_prefix}#{resource.singular}#{@@link_helpers_suffix}"
+    return if already_defined?(helper_name)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args)
+        opts = args.extract_options!
+        label = opts.delete(:label) || 'Edit'
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'edit', *(opts.delete(:class) || '').split)
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        args << opts.delete(:sending) if opts[:sending]
+        link_to(label, edit_#{resource.name_prefix}#{resource.singular}_path(*args), opts)
+      end
+    end_eval
+  end
+
+
+  
+  # Build the 'destroy_[resource]' helper
+  # 
+  # === Examples
+  # 
+  #   <% destroy_table_leg(@table, @leg) %>
+  #
+  #   renders:
+  # 
+  #   <form action="/tables/1/legs/1" class="leg destroy destroy_leg" method="post">
+  #     <input name="_method" type="hidden" value="delete" />
+  #     <button type="submit">Delete</button>
+  #   </form>
+  #
+  #   <% destroy_table_leg(@table, @leg, :button => {:title => 'Click to remove'}) %>
+  # 
+  #   renders:
+  # 
+  #   <form action="/tables/1/legs/1" class="leg destroy destroy_leg" method="post">
+  #     <input name="_method" type="hidden" value="delete" />
+  #     <button type="submit" title="Click to remove">Delete</button>
+  #   </form>
+  #
+  def build_destroy_helper(resource)
+    helper_name = "destroy_#{resource.name_prefix}#{resource.singular}#{@@form_helpers_suffix}"
+    return if already_defined?(helper_name)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args)
+        opts = args.extract_options!
+        opts_for_button = opts.delete(:button) || {}
+        opts_for_button.merge!(:type => 'submit')
+        label = opts.delete(:label) || 'Delete'
+        opts_for_button[:title] = opts.delete(:title) if opts[:title]
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'destroy', *(opts.delete(:class) || '').split)
+        opts[:method] = :post
+        opts[:action] = #{resource.name_prefix}#{resource.singular}_path(*args)
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        parameters = opts.delete(:sending) || {} 
+        content_tag('form', opts) do
+          hidden_field_tag(:_method, :delete, :id => nil) +
+          parameters.collect{|key, value| 
+            hidden_field_tag(key, value, :id => nil)
+          }.join +
+          token_tag.to_s +
+          content_tag(:button, label, opts_for_button)
+        end
+      end
+    end_eval
+  end
+  
+
+
+  # Build the list helpers
+  #
+  # === Examples
+  #
+  #   <% table_list do %>
+  #     ...
+  #   <%- end -%>
+  # 
+  #   renders:
+  # 
+  #   <ul class="table_list">
+  #     ...
+  #   </ul>
+  # 
+  #   <% table_list :ordered => true do %>
+  #     ...
+  #   <% end %>
+  # 
+  #   renders:
+  # 
+  #   <ol class="table_list">
+  #     ...
+  #   </ol>
+  # 
+  def build_list_helpers(resource)
+    @module.module_eval <<-end_eval
+      def #{resource.singular}_list(opts={}, &block)
+        content = capture(&block)
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}_list', *(opts.delete(:class) || '').split)
+        concat(content_tag((opts[:ordered] ? :ol : :ul), content, opts), block.binding)
+      end
+      def #{resource.singular}_item(*args, &block)
+        opts = args.extract_options!
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', *(opts.delete(:class) || '').split)
+        opts[:id] = '#{resource.singular}_' + args.first.id.to_s unless args.empty?
+        content = capture(&block)
+        concat(content_tag(:li, content, opts), block.binding)
+      end
+    end_eval
+  end
+   
+  
+  
+  # Build the table helpers
+  #
+  # === Examples
+  #
+  #   <% user_table do %>
+  #     ...
+  #   <%- end -%>
+  # 
+  #   renders:
+  # 
+  #   <table class="user_table">
+  #     ...
+  #   </table>
+  # 
+  def build_table_helpers(resource)
+    @module.module_eval <<-end_eval
+      def #{resource.singular}_table(opts={}, &block)
+        content = capture(&block)
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}_table', *(opts.delete(:class) || '').split)
+        concat(content_tag(:table, content, opts), block.binding)
+      end
+      def #{resource.singular}_row(*args, &block)
+        opts = args.extract_options!
+        opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', *(opts.delete(:class) || '').split)
+        opts[:id] = '#{resource.singular}_' + args.first.id.to_s unless args.empty?
+        content = capture(&block)
+        concat(content_tag(:tr, content, opts), block.binding)
+      end
+    end_eval
+  end
+  
+  
+
+  # Build the 'create_[resource]' helper
+  #
+  # === Examples without block
+  #
+  #   <% create_table_top(@table, :with => {:material => 'Mahogany'}) %>
+  #
+  #   renders:
+  #
+  #   <form action="/tables/1/top" class="top create create_top" method="post">
+  #     <input type="hidden" type="top[material]" value="Mahogany" />
+  #     <button type="submit">Save</button>
+  #   </form>
+  #
+  #   <% create_table(:label => 'Add table') %>
+  #   
+  #   renders:
+  #
+  #   <form action="/tables" class="table create create_table" method="post">
+  #     <button type="submit">Add table</button>
+  #   </form>   
+  #
+  # === Examples with block
+  #
+  #   <% create_table do |form| %>
+  #     <%= form.text_field :title %>
+  #     <%= submit_button 'Save' %>
+  #   <% end %>
+  #   
+  #   renders:
+  #
+  #   <form action="/tables" class="table create create_table" method="post">
+  #     <input type="text" type="table[title]" value="My title" />
+  #     <button type="submit">Save</button>
+  #   </form>
+  #
+  def build_create_helper(resource)
+    helper_name = "create_#{resource.name_prefix}#{resource.singular}#{@@form_helpers_suffix}"
+    return if already_defined?(helper_name)
+    number_of_expected_args = number_of_args_expected_by_named_route_helper([resource.name_prefix, resource.plural].join)
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args, &block)
+        opts = args.extract_options!
+        opts[:with] = opts.delete(:attributes) and ResourcefulViews.deprecation_warning('Please use :with instead of :attributes') if opts[:attributes]
+        resource_attributes = opts.delete(:with) || {}
+        opts[:sending] = opts.delete(:parameters) and ResourcefulViews.deprecation_warning('Please use :sending instead of :parameters') if opts[:parameters]
+        parameters = opts.delete(:sending) || {}
+        if block_given?
+          args_for_fields_for = ['#{resource.singular}']
+          args_for_fields_for.push(args.pop) if args.length > #{number_of_expected_args}
+          opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'create', *(opts.delete(:class) || '').split)
+          concat(form_tag(#{resource.name_prefix}#{resource.plural}_path(*args), opts), block.binding)
+            concat(resource_attributes.collect{|key, value| hidden_field_tag('#{resource.singular}[' + key.to_s + ']', value, :id => nil)}.join, block.binding)
+            concat(parameters.collect{|key, value| hidden_field_tag(key, value, :id => nil)}.join, block.binding)
+            fields_for(*args_for_fields_for, &block)
+          concat('</form>', block.binding)
+        else
+          label = opts.delete(:label) || 'Add'
+          opts_for_button = opts.delete(:button) || {}
+          opts_for_button.merge!(:type => 'submit')
+          opts[:method] = :post
+          opts[:action] = #{resource.name_prefix}#{resource.plural}_path(*args)
+          opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'create', *(opts.delete(:class) || '').split)
+          content_tag('form', opts) do
+            token_tag.to_s +
+            parameters.collect{|key, value| 
+              hidden_field_tag(key, value, :id => nil)
+            }.join +
+            resource_attributes.collect{ |key, value|
+              hidden_field_tag('#{resource.singular}[' + key.to_s + ']', value, :id => nil)
+            }.join +
+            content_tag(:button, label, opts_for_button)
+          end
+        end
+      end  
+    end_eval
+  end
+  
+
+
+  # Build the 'update_[resource](resource)' helper
+  #
+  # === Examples without block
+  #
+  #   <% update_table(@table, :with => {:name => 'Ingo'}) %>
+  #
+  #   renders:
+  #
+  #   <form action="/tables/1" class="table update update_table" method="post">
+  #     <input type="hidden" name="_method" value="put" />
+  #     <input type="hidden" name="table[name]" value="Ingo" />
+  #     <button type="submit">Save</button>
+  #   </form>
+  #
+  # === Examples with block
+  #
+  #   <% update_table(@table) do |form| %>
+  #     <%= form.text_field :name %>
+  #     <%= submit_button 'Save' %>
+  #   <% end %>
+  #
+  #   <form action="/tables/1" class="table update update_table" method="post">
+  #     <input type="hidden" name="_method" value="put" />
+  #     <input type="text" name="table[name]" value="Ingo" />
+  #     <button type="submit">Save</button>
+  #   </form>
+  #
+  def build_update_helper(resource)
+    helper_name = "update_#{resource.name_prefix}#{resource.singular}#{@@form_helpers_suffix}"
+    return if already_defined?(helper_name)
+    number_of_expected_args = number_of_args_expected_by_named_route_helper([resource.name_prefix, resource.singular].join)
+    resource_is_singular = resource.is_a?(ActionController::Resources::SingletonResource)
+    resource_is_plural = !resource_is_singular
+    @module.module_eval <<-end_eval
+      def #{helper_name}(*args, &block)
+        if block_given?
+          opts = args.extract_options!
+          args_for_fields_for = ['#{resource.singular}']
+          #{'args_for_fields_for.push(args.pop) if args.length > ' + number_of_expected_args.to_s if resource_is_singular}
+          #{'args_for_fields_for.push(args.last)' if resource_is_plural}
+          opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'update', *(opts.delete(:class) || '').split)
+          opts[:method] = :put
+          concat(form_tag(#{resource.name_prefix}#{resource.singular}_path(*args), opts), block.binding)
+          fields_for(*args_for_fields_for, &block)
+          concat('</form>', block.binding)
+        else
+          opts = args.extract_options!
+          label = opts.delete(:label) || 'Save'
+          opts[:with] = opts.delete(:attributes) and ResourcefulViews.deprecation_warning('Please use :with instead of :attributes') if opts[:attributes]
+          resource_attributes = opts.delete(:with) || {}
+          opts_for_button = opts.delete(:button) || {}
+          opts_for_button.merge!(:type => 'submit')
+          opts[:class] = ResourcefulViews.resourceful_classnames('#{resource.singular}', 'update', *(opts.delete(:class) || '').split)
+          opts[:method] = :post
+          opts[:action] = #{resource.name_prefix}#{resource.singular}_path(*args)
+          content_tag('form', opts) do
+            token_tag.to_s +
+            resource_attributes.collect{ |key, value|
+              hidden_field_tag('#{resource.singular}[' + key.to_s + ']', value, :id => nil)
+            }.join <<
+            hidden_field_tag('_method', 'put', :id => nil) <<
+            content_tag(:button, label, opts_for_button)
+          end
+        end
+      end
+    end_eval
+  end
+  
+    
+   # include the module (loaded with helper methods) into ActionView::Base
+  def install_helpers # :nodoc:
+    ActionView::Base.send! :include, @module
+  end
+  
+  protected
+  
+  # Check whether method is already defined
+  def already_defined?(helper_name)
+    ActionView::Base.instance_methods.include?(helper_name) or @module.methods.include?(helper_name)
+  end
+  
+  # determine how many arguments a specific named route helper expects
+  def number_of_args_expected_by_named_route_helper(helper_name)
+    ActionController::Routing::Routes.named_routes.routes[helper_name.to_sym].segment_keys.size
+  end  
+  
+end
+
+
+ActionController::Routing::RouteSet::Mapper.class_eval do
+  
+  def resources_with_resourceful_view_helpers(*entities, &block)
+    resources_without_resourceful_view_helpers(*entities, &block)
+    options = entities.extract_options!
+    ResourcefulViews.new do |resourceful_views|
+      entities.each do |entity|
+        resource = ActionController::Resources::Resource.new(entity, options)
+        resourceful_views.build_and_install_helpers_for_resource(resource)
+      end
+    end
+  end
+  
+  alias_method_chain :resources, :resourceful_view_helpers
+  
+  def resource_with_resourceful_view_helpers(*entities, &block)
+    resource_without_resourceful_view_helpers(*entities, &block)
+    options = entities.extract_options!
+    ResourcefulViews.new do |resourceful_views|
+      entities.each do |entity|
+        resource = ActionController::Resources::SingletonResource.new(entity, options)
+        resourceful_views.build_and_install_helpers_for_singular_resource(resource)
+      end
+    end
+  end
+    
+  alias_method_chain :resource, :resourceful_view_helpers
+  
+end
+

data/tasks/resourceful_views_tasks.rake

@@ -0,0 +1,11 @@
+namespace :resourceful_views do
+  desc 'List view helper methods introduced by ResourcefulViews'
+  task :helpers => :environment do
+    ResourcefulViews.helpers.each do |resource, helper_names|
+      puts resource
+      puts '-' * resource.length
+      puts helper_names
+      puts
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: ingoweiss-resourceful_views
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Ingo Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-15 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: ResourcefulViews aims to take RESTful conventions beyond controllers and into views by extending the 'map.resources' method to install a comprehensive vocabulary of resource-oriented view helpers
+email: 
+- ingo@ingoweiss.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/resourceful_views.rb
+- tasks/resourceful_views_tasks.rake
+has_rdoc: true
+homepage: http://github.com/ingoweiss/resourceful_views
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Resource-oriented helpers for rendering forms and links in Rails
+test_files: []
+