inline_forms 0.1.0 → 0.1.1

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  shoulda

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/app/controllers/inline_forms_controller.rb

@@ -0,0 +1,132 @@
+class InlineFormsController < ApplicationController
+  unloadable # see http://dev.rubyonrails.org/ticket/6001
+  # == Generic controller for the inline_forms plugin.
+  # === Usage
+  # If you have an Example class, then you can add a route like this:
+  # <tt>map.resources :examples, :controller => :inline_forms</tt>
+  # this will give you REST stuff without creating a sepearte examples_controller.rb
+  # === How it works
+  # The getKlass before_filter extracts the classname from the request. So, '/examples/1' and
+  # '/examples?name=value' will result in @Klass being set to 'Example', which is the class.
+  # === Limited Access
+  # the must_be_xhr_request before_filter is supposed to only perform the specific actions
+  # if the request is an XhttpRequest. There is not much use perming the actions outside of
+  # the XhttpRequest context (except action => :index). Of course, this is not a security measure.
+  before_filter :getKlass
+  before_filter :must_be_xhr_request, :except => :index
+  helper :inline_form
+  include InlineFormHelper
+  layout false
+
+  # :index shows a list of all objects from class Klass, with all attribute values linked to the 'edit' action.
+  # Each field (attribute) is edited seperately (so you don't edit an entire object!)
+  # The link to 'new' allows you to create a new record.
+  #
+  # GET /examples
+  #
+  def index
+    nolayout = params[:layout] == 'false' || false
+    @objects = @Klass.constantize.all
+    render( :layout => nolayout || 'inline_forms' )
+  end
+
+  # :show shows one field (attribute) from a record (object). It inludes the link to 'edit'
+  #
+  # GET /examples/1?field=name&form_element=text
+  #
+  def show
+    @object = @Klass.constantize.find(params[:id])
+    @field = params[:field]
+    @form_element = params[:form_element]
+    if @form_element == "associated"
+      @sub_id = params[:sub_id]
+      if @sub_id.to_i > 0
+        @associated_record_id = @object.send(@field.singularize + "_ids").index(@sub_id.to_i)
+        @associated_record = @object.send(@field)[@associated_record_id]
+      end
+    end
+    render :inline => '<%= send("#{@form_element}_show", @object, @field, @values) %>'
+  end
+
+  # :new prepares a new object, updates the entire list of objects and replaces it with a new
+  # empty form. After pressing OK or Cancel, the list of objects is retrieved in the same way as :index
+  # 
+  # GET /examples/new
+  def new
+    @object = @Klass.constantize.new
+  end
+
+  # :edit presents a form to edit one specific field from an object
+  #
+  # GET /examples/1/edit
+  #
+  def edit
+    @object = @Klass.constantize.find(params[:id])
+    @field = params[:field]
+    @form_element = params[:form_element]
+    @values = params[:values]
+    @sub_id = params[:sub_id]
+  end
+
+  # :create creates the object made with :new. It then presents the list of objects.
+  #
+  # POST /examples
+  #
+  def create
+    object = @Klass.constantize.new
+    attributes = object.respond_to?(:field_list) ? object.field_list : [ '', :name, :text ] # sensible default
+    attributes = [ attributes ] if not attributes[0].is_a?(Array) # make sure we have an array of arrays
+    attributes.each do | name, attribute, form_element, values |
+      send("#{form_element.to_s}_update", object, attribute, values)
+    end
+    object.save
+    @objects = @Klass.constantize.all
+    render( :action => :index )
+  end
+
+  # :update updates a specific field from an object.
+  #
+  # PUT /examples/1
+  #
+  def update
+    @object = @Klass.constantize.find(params[:id])
+    @field = params[:field]
+    @form_element = params[:form_element]
+    @values = params[:values]
+    @sub_id = params[:sub_id]
+    send("#{@form_element.to_s}_update", @object, @field, @values)
+    @object.save
+    render :inline => '<%= send("#{@form_element.to_s}_show", @object, @field, @values) %>'
+  end
+
+  # :destroy is not implemented
+  # TODO implement a destroy method
+  #
+  # DELETE /examples/1
+  #
+  def destroy
+    #    @@Klass.constantize = @Klass.constantize.find(params[:id])
+    #    @@Klass.constantize.destroy
+    redirect_to(@Klass.constantizes_url)
+  end
+
+  private
+  # If it's not an XhttpRequest, redirect to the index page for this controller.
+  #
+  # Used in before_filter as a way to limit access to all actions (except :index)
+  def must_be_xhr_request #:doc:
+    redirect_to "/#{@Klass_pluralized}" if not request.xhr?
+  end
+
+  # Get the classname from the request uri.
+  # /examples/1 => Example
+  # /examples?field=name => Example
+  #
+  # Used in before_filter
+  def getKlass #:doc:
+    @Klass = request.request_uri.split(/[\/?]/)[1].classify
+    @Klass_constantized = @Klass.constantize
+    @Klass_underscored = @Klass.underscore
+    @Klass_pluralized  = @Klass_underscored.pluralize
+  end
+end

data/app/helpers/inline_form_helper.rb

@@ -0,0 +1,330 @@
+module InlineFormHelper
+  # display the forms from an array of attributes
+  def inline_form_display(object, attributes, action=:show)
+    attributes = [ attributes ] if not attributes[0].is_a?(Array) # make sure we have an array of arrays
+    out = String.new #ugly as hell but that's how content_tag works...
+    case action
+    when :show
+      attributes.each do | name, attribute, form_element, values |
+        #css_class_id = form_element == :associated ? "subform_#{attribute.to_s}_#{object.id}" : "field_#{attribute.to_s}_#{object.id}"
+        css_class_id = "field_#{attribute.to_s}_#{object.id}"
+        name_cell = content_tag :td, :valign=>'top' do
+          content_tag :div, :class=> "field_name field_#{attribute.to_s} form_element_#{form_element.to_s}" do
+            h(name)
+          end
+        end
+        value_cell = content_tag :td, :valign=>'top' do
+          content_tag :div, :class=> "field_value field_#{attribute.to_s} form_element_#{form_element.to_s}" do
+            content_tag :span, :id => css_class_id do
+              send("#{form_element.to_s}_#{action}", object, attribute, values)
+            end
+          end
+        end
+        out += content_tag :tr, name_cell + value_cell
+      end
+      return content_tag :table, out, :cellspacing => 0, :cellpadding => 0
+    when :new
+      attributes.each do | name, attribute, form_element, values |
+        #css_class_id = form_element == :associated ? "subform_#{attribute.to_s}_#{object.id}" : "field_#{attribute.to_s}_#{object.id}"
+        css_class_id = "field_#{attribute.to_s}_#{object.id}"
+        name_cell = content_tag :td, :valign=>'top' do
+          content_tag :div, :class=> "field_name field_#{attribute.to_s} form_element_#{form_element.to_s}" do
+            h(name)
+          end
+        end
+        value_cell = content_tag :td, :valign=>'top' do
+          content_tag :div, :class=> "field_value field_#{attribute.to_s} form_element_#{form_element.to_s}" do
+            content_tag :span, :id => css_class_id do
+              if not form_element == :associated
+                send("#{form_element.to_s}_edit", object, attribute, values)
+              else
+                #send("#{form_element.to_s}_show", object, attribute, values)
+              end
+            end
+          end
+        end
+        out += content_tag :tr, name_cell + value_cell
+      end
+      return content_tag :table, out, :cellspacing => 0, :cellpadding => 0
+    end
+  end
+  # display a list of objects
+  def inline_form_display_list(objects, tag=:li)
+    t = ''
+    objects.each do |object|
+      t += content_tag tag do
+        inline_form_display object, object.respond_to?(:field_list) ? object.field_list : [ '', :name, :text ]
+      end
+    end
+    return t
+  end
+  # link for new item
+  def inline_form_new_record(attribute, form_element, text='new', update_span='inline_form_list')
+    link_to_remote( text,
+      :url => {
+        :action => :new,
+        :controller => @Klass_pluralized,
+        :field => attribute,
+        :form_element => form_element,
+        :update_span => update_span },
+      :method => :get,
+      :update => update_span )
+  end
+
+  # dropdown
+  def dropdown_show(object, attribute, values)
+    attribute_value = object.send(attribute).presentation rescue  nil
+    link_to_inline_edit object, attribute, attribute_value, nil
+  end
+  def dropdown_edit(object, attribute, values)
+    object.send('build_' + attribute.to_s) unless object.send(attribute)
+    values = object.send(attribute).class.name.constantize.find(:all, :order => 'name ASC')
+    # the leading underscore is to avoid name conflicts, like 'email' and 'email_type' will result in 'email' and 'email[email_type_id]' in the form!
+    collection_select( ('_' + object.class.to_s.downcase).to_sym, attribute.to_s.foreign_key.to_sym, values, 'id', 'presentation', :selected => object.send(attribute).id)
+  end
+  def dropdown_update(object, attribute, values)
+    object[attribute.to_s.foreign_key.to_sym] = params[('_' + object.class.to_s.downcase).to_sym][attribute.to_s.foreign_key.to_sym]
+  end
+
+  # dropdown_with_values
+  def dropdown_with_values_show(object, attribute, values)
+    link_to_inline_edit object, attribute, values[object.send(attribute)], values
+  end
+  def dropdown_with_values_edit(object, attribute, values)
+    # the leading underscore is to avoid name conflicts, like 'email' and 'email_type' will result in 'email' and 'email[email_type_id]' in the form!
+    collection_select( ('_' + object.class.to_s.downcase).to_sym, attribute.to_sym, values, 'first', 'last', :selected => object.send(attribute))
+  end
+  def dropdown_with_values_update(object, attribute, values)
+    object[attribute.to_sym] = params[('_' + object.class.to_s.downcase).to_sym][attribute.to_sym]
+  end
+
+  # range
+  def range_show(object, attribute, values)
+    link_to_inline_edit object, attribute, object.send(attribute), nil
+  end
+  def range_edit(object, attribute, values)
+    # the leading underscore is to avoid name conflicts, like 'email' and 'email_type' will result in 'email' and 'email[email_type_id]' in the form!
+    collection_select( ('_' + object.class.to_s.downcase).to_sym, attribute.to_sym, values, 'to_i', 'to_s', :selected => object.send(attribute))
+  end
+  def range_update(object, attribute, values)
+    object[attribute.to_sym] = params[('_' + object.class.to_s.downcase).to_sym][attribute.to_sym]
+  end
+
+  # date
+  def date_show(object, attribute, values)
+    link_to_inline_edit object, attribute, object.send(attribute), nil
+  end
+  def date_edit(object, attribute, values)
+    calendar_date_select_tag attribute, object[attribute], :year_range => 30.years.ago..5.years.from_now, :popup => :force
+  end
+  def date_update(object, attribute, values)
+    object[attribute.to_sym] = params[attribute.to_sym]
+  end
+
+  # textarea
+  def textarea_show(object, attribute, values)
+    link_to_inline_edit object, attribute, object.send(attribute), nil
+  end
+  def textarea_edit(object, attribute, values)
+    text_area_tag attribute, object[attribute], :class => 'field_textarea'
+  end
+  def textarea_update(object, attribute, values)
+    object[attribute.to_sym] = params[attribute.to_sym]
+  end
+
+  # text
+  def text_show(object, attribute, values)
+    link_to_inline_edit object, attribute, object.send(attribute), nil
+  end
+  def text_edit(object, attribute, values)
+    text_field_tag attribute, object[attribute], :class => 'input_text'
+  end
+  def text_update(object, attribute, values)
+    object[attribute.to_sym] = params[attribute.to_sym]
+  end
+
+  # bool
+  def bool_show(object, attribute, values)
+    link_to_inline_edit object, attribute, values[object.send(attribute).to_s], values
+  end
+  def bool_edit(object, attribute, values)
+    collection_select( object.class.to_s.downcase, attribute, values, 'first', 'last', :selected => object.send(attribute).to_s)
+  end
+  def bool_update(object, attribute, values)
+    object[attribute.to_s.to_sym] = params[object.class.to_s.downcase.to_sym][attribute.to_s.to_sym]
+  end
+
+  # checklist
+  def checklist_show(object, attribute, values)
+    out = '<ul class="checklist">'
+    out << link_to_inline_edit(object, attribute, nil, nil) if object.send(attribute).empty?
+    object.send(attribute).sort.each do | item |
+      out << '<li>'
+      out << link_to_inline_edit(object, attribute, item.title, nil)
+      out << '</li>'
+    end
+    out <<  '</ul>'
+  end
+  def checklist_edit(object, attribute, values)
+    object.send(attribute).build  if object.send(attribute).empty?
+    values = object.send(attribute).first.class.name.constantize.find(:all, :order => "name ASC")
+    out = '<div class="edit_form_checklist">'
+    out << '<ul>'
+    values.each do | item |
+      out << '<li>'
+      out << check_box_tag( attribute + '[' + item.id.to_s + ']', 'yes', object.send(attribute.singularize + "_ids").include?(item.id) )
+      out << '<div class="edit_form_checklist_text">'
+      out << h(item.title)
+      out << '</div>'
+      out << '<div style="clear: both;"></div>'
+      out << '</li>'
+    end
+    out << '</ul>'
+    out << '</div>'
+  end
+  def checklist_update(object, attribute, values)
+    params[attribute] ||= {}
+    object.send(attribute.singularize + '_ids=', params[attribute].keys)
+  end
+
+  # associated
+  def associated_show(object, attribute, values)
+    #show a list of records
+    out = ""
+    if @sub_id && @sub_id.to_i > 0
+      # if it's not a new record (sub_id > 0) then just update the list-element
+      out << '<li>'
+      out << link_to_remote( @associated_record.title,
+        :url => { :action => 'edit',
+          :id => object.id,
+          :field => attribute,
+          :sub_id => @sub_id,
+          :form_element => this_method.reverse.sub(/.*_/,'').reverse,
+          :values => values },
+        :method => :get,
+        :update => "field_#{attribute.singularize}_#{@sub_id.to_s}" )
+      out << '</li>'
+    else
+      # if it's a new record (sub_id == 0) then update the whole <ul> and redraw all list-elements
+      out << "<ul class='associated #{attribute}' id='list_#{attribute}_#{object.id.to_s}'>" if @sub_id.nil?
+      if not object.send(attribute.pluralize).empty?
+        # if there are things to show, show them
+        object.send(attribute.pluralize).each do |m|
+          out << "<span id='field_#{attribute.singularize}_#{m.id.to_s}'>"
+          out << '<li>'
+          out << link_to_remote( m.title,
+            :url => { :action => 'edit',
+              :id => object.id,
+              :field => attribute,
+              :sub_id => m.id,
+              :form_element => this_method.sub(/_[a-z]+$/,''),
+              :values => values },
+            :method => :get,
+            :update => "field_#{attribute.singularize}_#{m.id.to_s}" )
+          out << '</li>'
+          out << '</span>'
+        end
+      end
+      # add a 'new' link for creating a new record
+      out << '<li>'
+      out << link_to_remote( 'new',
+        :url => { :action => 'edit',
+          :id => object.id,
+          :field => attribute,
+          :sub_id => 0,
+          :form_element => this_method.sub(/_[a-z]+$/,''),
+          :values => values },
+        :method => :get,
+        :update => "list_#{attribute}_#{object.id.to_s}" )
+      out << '</li>'
+      out << '</ul>' if @sub_id.nil?
+    end
+    out
+  end
+  def associated_edit(object, attribute, values)
+    # @sub_id is the id of the assoicated record
+   if @sub_id.to_i > 0
+      # only if @sub_id > 0, means we have a associated record
+      @associated_record_id = object.send(attribute.singularize + "_ids").index(@sub_id.to_i)
+      @associated_record = object.send(attribute)[@associated_record_id]
+      @update_span = "field_#{attribute.singularize}_#{@sub_id.to_s}"
+    else
+      # but if @sub_id = 0, then we are dealing with a new associated record
+      # in that case, we .new a record, and the update_span is the whole <ul>
+      @associated_record = attribute.singularize.capitalize.constantize.new
+      @update_span = "list_#{attribute}_#{object.id.to_s}"
+    end
+    render :partial => "subform"
+  end
+  def associated_update(object, attribute, values)
+    return if object.id.nil?
+    if @sub_id.to_i > 0
+      # get the existing associated record
+      @associated_record_id = object.send(attribute.singularize + "_ids").index(@sub_id.to_i)
+      @associated_record = object.send(attribute)[@associated_record_id]
+      @update_span = "field_" + attribute.singularize + '_' + @sub_id.to_s
+    else
+      # create a new associated record
+      @associated_record = object.send(attribute.to_sym).new
+      @update_span = 'list_#{attribute}_#{object.id.to_s}'
+    end
+    # process the sub_form fields (attributes). These are declared in the model!
+    @associated_record.field_list.each do | @subform_description, @subform_field, @subform_element |
+      # have no fear
+      send("#{@subform_element}_update", @associated_record, @subform_field, nil)
+    end
+    @associated_record.save
+  end
+
+  # geo_code_curacao
+  def geo_code_curacao_show(object, attribute, values)
+    attribute_value = object.send(attribute).presentation rescue nil
+    link_to_inline_edit object, attribute, attribute_value, nil
+  end
+  def geo_code_curacao_edit(object, attribute, values)
+    text_field_with_auto_complete :geo_code_curacao, :street, :skip_style => true
+  end
+  def geo_code_curacao_update(object, attribute, values)
+    # extract the geocode
+    geo_code = params[attribute.to_sym][:street].scan(/\d\d\d\d\d\d/).to_s || nil
+    object[attribute.to_sym] = GeoCodeCuracao.new(geo_code).valid? ? geo_code : nil
+  end
+
+  private
+
+  # link_to_inline_edit
+  # Directly call Erb::Util.h because we sometimes call this from the controller!
+  # same with link_to_remote. We are using the @template stuff.
+  def link_to_inline_edit(object, attribute, attribute_value, values)
+   #needed for h() and link_to_remote()
+    attribute_value = h(attribute_value)
+    spaces = attribute_value.length > 40 ? 0 : 40 - attribute_value.length
+    attribute_value << "&nbsp;" * spaces
+    if @Klass == 'Index'
+    link_to_remote attribute_value,
+      :url => "/#{@Klass_pluralized}/edit/#{object.id}?field=#{attribute.to_s}&form_element=#{calling_method.sub(/_[a-z]+$/,'')}&values=#{values}",
+      :update => 'field_' + attribute.to_s + '_' + object.id.to_s,
+      :method => :get
+    else
+    link_to_remote attribute_value,
+      :url => "/#{@Klass_pluralized}/#{object.id}/edit?field=#{attribute.to_s}&form_element=#{calling_method.sub(/_[a-z]+$/,'')}&values=#{values}",
+      :update => 'field_' + attribute.to_s + '_' + object.id.to_s,
+      :method => :get
+
+    end
+  end
+end
+
+# make the current method and the calling method available
+#   http://www.ruby-forum.com/topic/75258
+#   supposedly, this is fixed in 1.9
+module Kernel
+  private
+  def this_method
+    caller[0] =~ /`([^']*)'/ and $1
+  end
+  def calling_method
+    caller[1] =~ /`([^']*)'/ and $1
+  end
+end
+

data/app/models/geo_code_curacao.rb

@@ -0,0 +1,51 @@
+class GeoCodeCuracao
+  attr_accessor :street, :neighbourhood, :zone
+  
+  class Zone < ActiveRecord::Base
+    set_table_name "Zones"
+    alias_attribute :name, :NAME
+  end
+  class Neighbourhood < ActiveRecord::Base
+    set_table_name "Buurten"
+    alias_attribute :name, :NAME
+  end
+  class Street < ActiveRecord::Base
+    set_table_name "Straatcode"
+    alias_attribute :name, :NAME
+  end
+  def initialize(geo_code_curacao)
+    return nil if geo_code_curacao.nil?
+    decoded = geo_code_curacao.to_s.scan(/\d\d/)
+    zone_code = decoded[0]
+    neighbourhood_code = decoded[1]
+    street_code = decoded[2]
+    #Hash[*['zone','neighbourhood','street'].zip(gecode.to_s.scan(/\d\d/).map(&:to_i)).flatten]
+    self.street = Street.find_by_ZONECODE_and_NBRHCODE_and_STREETCODE(zone_code,neighbourhood_code,street_code)
+    self.neighbourhood = Neighbourhood.find_by_ZONECODE_and_NBRHCODE(zone_code,neighbourhood_code) if self.street
+    self.zone = Zone.find_by_ZONECODE(zone_code) if self.street
+  end
+  def valid?
+    not self.street.nil?
+  end
+  def presentation
+    "#{street.name}, #{zone.name}"
+  end
+  def self.find(*args)
+    find_options = args.extract_options!
+    if args.first.to_s == "all"
+      # ActiveRecord::Base.sanitize_sql_for_conditions can not be called from here. Why?
+      street = find_options[:conditions][1].gsub(/\\/, '\&\&').gsub(/'/, "''") # http://www.ruby-forum.com/topic/80357, active_record/connection_adapter/Quoting.rb
+      sql = "select CONCAT( CONCAT_WS( ', ', S.NAME, B.NAME, Z.NAME), ' (', LPAD( S.ZONECODE, 2, '0' ), LPAD( S.NBRHCODE, 2, '0' ), LPAD( S.STREETCODE, 2, '0' ), ')' ) AS street
+              FROM Straatcode S,  Buurten B, Zones Z
+              WHERE 
+                  B.RECORDTYPE='NBRHOOD'
+              AND S.ZONECODE=Z.ZONECODE
+              AND B.ZONECODE=Z.ZONECODE
+              AND S.ZONECODE=B.ZONECODE
+              AND S.NBRHCODE = B.NBRHCODE
+              AND S.NAME LIKE '#{street}'
+              ORDER BY S.NAME"
+      ids = ActiveRecord::Base.connection.execute(sql)
+    end
+  end
+end

data/app/models/inline_form.rb

@@ -0,0 +1,2 @@
+class InlineForm < ActiveRecord::Base
+end

data/app/views/inline_forms/_subform.html.erb

@@ -0,0 +1,16 @@
+<table cellpadding="0" cellspacing="0" class="subform">
+  <% @associated_record.field_list.each do | @subform_description, @subform_field, @subform_element, @values | %>
+    <tr>
+      <td valign="top">
+        <div class="subform_field-name">
+          <%= h(@subform_description) %>
+        </div>
+      </td>
+      <td valign="top">
+        <div class="subform_field-value">
+          <%= send("#{@subform_element}_edit", @associated_record, @subform_field.to_s, @values) %>
+        </div>
+      </td>
+    </tr>
+  <% end %>
+</table>

data/app/views/inline_forms/edit.html.erb

@@ -0,0 +1,17 @@
+<% form_remote_tag :update => @update_span || @form_element == "associated" ? @sub_id && @sub_id.to_i > 0 ? "field_#{@field.singularize}_#{@sub_id}" : "list_#{@field}_#{@object.id.to_s}" : "field_#{@field}_#{@object.id.to_s}",
+ :url => "/#{@Klass_pluralized}/#{params[:id]}?field=#{@field}&form_element=#{@form_element}&values=#{@values}&sub_id=#{@sub_id}",
+  :method => :put,
+  :multipart => true,
+  :html => { :class  => "edit_form" } do -%>
+  <div class="edit_form_field">
+    <%= send("#{@form_element.to_s}_edit", @object, @field, @values) %>
+  </div>
+  <%= link_to_remote "nee",
+    :url => "/#{@Klass_pluralized}/#{params[:id]}?field=#{@field}&form_element=#{@form_element}&values=#{@values}&sub_id=#{@sub_id}",
+    :method => :get,
+    :html => { :class  => "edit_form_cancel" },
+    :update => @update_span || "field_#{@field}_#{@object.id.to_s}" -%>
+  <%= submit_tag "ok", :class => "edit_form_submit"-%>
+  <div style="clear: both;"></div>
+<% end -%>
+

data/app/views/inline_forms/index.html.erb

@@ -0,0 +1,4 @@
+<li class="inline_form_new_item">
+  <%= inline_form_new_record @field, @form_element  %>
+</li>
+<%= inline_form_display_list(@objects) %>

data/app/views/inline_forms/new.html.erb

@@ -0,0 +1,17 @@
+<% form_remote_tag :multipart => true,
+  :url => "/#{@Klass_pluralized}?field=#{@attribute.to_s}&form_element=#{@form_element}&values=#{@values}&sub_id=#{@sub_id}",
+  :update => @update_span || 'inline_form_list',
+  :html => { :class  => "edit_form" } do -%>
+  <div class="edit_form_field">
+    <%= inline_form_display(@object, @object.respond_to?(:field_list) ? @object.field_list : [ '', :name, :text ], :new) %>
+  </div>
+  <%= link_to_remote "nee",
+#  :url => "/#{@Klass_pluralized}/index?field=#{@attribute.to_s}&form_element=#{@form_element}&values=#{@values}&sub_id=#{@sub_id}",
+  :url => "/#{@Klass_pluralized}?layout=false",
+    :html => { :class  => "edit_form_cancel" },
+    :update => 'inline_form_list',
+    :method => :get -%>
+  <%= submit_tag "ok", :class => "edit_form_submit"-%>
+  <div style="clear: both;"></div>
+<% end -%>
+

data/app/views/layouts/inline_forms.rhtml

@@ -0,0 +1,7 @@
+    <%= stylesheet_link_tag 'inline_form_elements' %>
+    <%= javascript_include_tag :defaults %>
+    <%#= calendar_date_select_includes "red" %>
+<h1><%= @Klass.pluralize.humanize %></h1>
+<ul id="inline_form_list">
+<%= yield %>
+</ul>

data/inline_forms.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{inline_forms}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ace Suares"]
+  s.date = %q{2011-01-27}
+  s.description = %q{Inline Forms aims to ease the setup of forms that provide inline editing. The field list can be specified in the model.}
+  s.email = %q{ace@suares.an}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "app/controllers/inline_forms_controller.rb",
+    "app/helpers/inline_form_helper.rb",
+    "app/models/geo_code_curacao.rb",
+    "app/models/inline_form.rb",
+    "app/views/inline_forms/_subform.html.erb",
+    "app/views/inline_forms/edit.html.erb",
+    "app/views/inline_forms/index.html.erb",
+    "app/views/inline_forms/new.html.erb",
+    "app/views/layouts/inline_forms.rhtml",
+    "inline_forms.gemspec",
+    "lib/inline_forms.rb",
+    "test/helper.rb",
+    "test/test_inline_forms.rb"
+  ]
+  s.homepage = %q{http://github.com/acesuares/inline_forms}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Inline editing of forms.}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_inline_forms.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: inline_forms
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Ace Suares
@@ -90,10 +90,21 @@ extra_rdoc_files:
 files: 
 - .document
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.rdoc
 - Rakefile
 - VERSION
+- app/controllers/inline_forms_controller.rb
+- app/helpers/inline_form_helper.rb
+- app/models/geo_code_curacao.rb
+- app/models/inline_form.rb
+- app/views/inline_forms/_subform.html.erb
+- app/views/inline_forms/edit.html.erb
+- app/views/inline_forms/index.html.erb
+- app/views/inline_forms/new.html.erb
+- app/views/layouts/inline_forms.rhtml
+- inline_forms.gemspec
 - lib/inline_forms.rb
 - test/helper.rb
 - test/test_inline_forms.rb