dynamic_fieldsets 0.0.3 → 0.0.4

data/CHANGELOG

@@ -1,3 +1,10 @@
+== 0.0.4
+
+* A very simple version of the spec completely works
+* The backend is done including a nice system for organizaing and ordering fieldsets
+* The front end is done including dependencies and form and show helpers
+* Additional work is needed for multiple fieldsets on the same page or model, date based dependencies, resuing fieldsets, etc
+
 == 0.0.3
 
 * Removed ActionView::Helpers from the include.  There were errors when it is included twice.

data/Gemfile

@@ -15,6 +15,7 @@ group :development do
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.3"
   gem "rcov", ">= 0"
+  gem "json"
 
   # hudson ci
   gem "ci_reporter"

data/Gemfile.lock

@@ -148,6 +148,7 @@ DEPENDENCIES
   cucumber-rails
   database_cleaner
   jeweler (~> 1.6.3)
+  json
   rails (= 3.0.7)
   rcov
   rspec (~> 2.6.0)

data/README.rdoc

@@ -1,9 +1,22 @@
-= DynamicFieldsets
+= dynamic_fieldsets 
 
 User defined fieldsets for dynamic questions in forms.
 
-== Contributing to acts_as_multipart_form
+I recommend not using this until a 0.1 release.j
+
+= how to use
+
+Install the gem, run the install generator
+
+Add the mixin to your model.  There are some configuration options here.
+
+There is a view helper you need to add to your application helper and call from the form view and the show view.
+
+The backend is automatically added to your project using the rails engine system.  At some point, there will be a controller generator to generate them out so you can add permissions/pagination/whatever else you need on your controllers.
+
+== Contributing to dynamic_fieldsets 
  
+* honestly, hold off for a 0.1 release before even thinking about this
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 * Fork the project

data/Rakefile

@@ -20,7 +20,7 @@ Jeweler::Tasks.new do |gem|
   gem.summary = %Q{Dynamic fieldsets for rails controllers}
   gem.description = %Q{Dynamic fieldsets for rails controllers}
   gem.email = "jeremiah@cloudspace.com"
-  gem.authors = ["Jeremiah Hemphill", "Ethan Pemble"]
+  gem.authors = ["Jeremiah Hemphill", "Ethan Pemble", "John Carter"]
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
@@ -62,8 +62,28 @@ namespace :hudson do
   end
 end
 
-#general cucumber rake task
+#general cucumber rake tasks
 require 'cucumber/rake/task'
-Cucumber::Rake::Task.new(:cucumber, 'run features that should pass') do |t|
-  t.cucumber_opts = "spec/dummy/features --format progress"
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:all, 'run features that should pass') do |t|
+    t.cucumber_opts = "spec/dummy/features --format progress"
+  end
+  Cucumber::Rake::Task.new(:no_js, 'run features that should pass') do |t|
+    t.cucumber_opts = "spec/dummy/features --format progress --tags ~@javascript"
+  end
+
+  task :setup_js_with_vnc4server do
+    puts "Cucumber test with vnc4server"
+    ENV['DISPLAY'] = ":99"
+    %x{vncserver :99 2>/dev/null >/dev/null &}
+    %x{DISPLAY=:99 firefox 2>/dev/null >/dev/null &}
+  end
+
+  task :kill_js do
+    puts "Killing vnc, xvfb, and ff processes"
+    %x{killall Xvnc4}
+    %x{killall Xvfb}
+    %x{killall firefox}
+  end
 end
+task :cucumber => ['cucumber:setup_js_with_vnc4server', 'cucumber:all', 'cucumber:kill_js']

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/app/controllers/dynamic_fieldsets/fields_controller.rb

@@ -35,12 +35,37 @@ module DynamicFieldsets
       @field = DynamicFieldsets::Field.find(params[:id])
     end
 
+    # Custom controller action to set the enabled field on the field object
+    # Expects a url with an id field and a form with the value [:dynamic_fieldsets_field][:enabled]
+    # On success or failure, redirects to the index page with a notice
+    #
+    # This should never fail the save unless the field was initially saved without validations
+    def enable
+      @field = DynamicFieldsets::Field.find(params[:id])
+      @field.enabled = params[:dynamic_fieldsets_field][:enabled]
+      respond_to do |format|
+        if @field.save
+          format.html { redirect_to(dynamic_fieldsets_fields_path, :notice => 'Successfully updated a new field.') }
+        else
+          format.html { redirect_to(dynamic_fieldsets_fields_path, :notice => 'Did not update the field successfully.') }
+        end
+      end
+    end
+
     # POST /dynamic_fieldsets/fields
     def create
+      parent_id = params[:parent]
       @field = DynamicFieldsets::Field.new(params[:dynamic_fieldsets_field])
 
       respond_to do |format|
         if @field.save
+          if !parent_id.empty?
+            parent = DynamicFieldsets::Fieldset.find_by_id(parent_id)
+            DynamicFieldsets::FieldsetChild.create( :fieldset => parent, :child => @field )
+            #relation = @fieldset.fieldset_children.build( :fieldset => parent )
+            #relation.child = @field
+            #relation.save
+          end
           format.html { redirect_to(@field, :notice => 'Successfully created a new field.') }
         else
           format.html { render :action => "new" }

data/app/controllers/dynamic_fieldsets/fieldset_children_controller.rb

@@ -0,0 +1,57 @@
+module DynamicFieldsets
+  # Controller for handling editing of fieldset children
+  # Most of this is done through the fieldsets#children action
+  # Dependencies are done here
+  class FieldsetChildrenController < ApplicationController
+    unloadable
+    
+    # this view doesn't exist
+    def index
+    end
+
+    # Show a record and all children
+    def show
+      @fieldset_child = DynamicFieldsets::FieldsetChild.find_by_id params[:id]
+      @fieldset = DynamicFieldsets::Fieldset.find_by_id @fieldset_child.fieldset_id
+
+      respond_to do |format|
+        format.html
+      end
+    end
+
+    def edit
+      @fieldset_child = DynamicFieldsets::FieldsetChild.find(params[:id])
+      respond_to do |format|
+        format.html
+      end
+    end
+
+    # updates the fieldset_child and uses accepts_nested_attributes_for to setup a dependency system
+    def update
+      @fieldset_child = DynamicFieldsets::FieldsetChild.find(params[:id])
+
+      respond_to do |format|
+        if @fieldset_child.update_attributes(params[:dynamic_fieldsets_fieldset_child])
+          format.html { redirect_to(dynamic_fieldsets_children_dynamic_fieldsets_fieldset_path(@fieldset_child.root_fieldset), :notice => "Successfully updated a child")}
+        else
+          format.html { render :action => "edit" }
+        end
+      end
+    end
+
+    # deletes the fieldset child and redirects to its root fieldset page
+    def remove
+      @fieldset_child = DynamicFieldsets::FieldsetChild.find(params[:id])
+      root = @fieldset_child.root_fieldset
+
+      respond_to do |format|  
+        if @fieldset_child.destroy
+          notice_text = "Successfully removed the child"
+        else
+          notice_text = "Child was not able to be removed"
+        end
+        format.html { redirect_to(dynamic_fieldsets_children_dynamic_fieldsets_fieldset_path(root), :notice => notice_text)}
+      end
+    end
+  end
+end

data/app/controllers/dynamic_fieldsets/fieldsets_controller.rb

@@ -3,7 +3,7 @@ module DynamicFieldsets
   class FieldsetsController < ApplicationController
     unloadable
   
-    # Show all record
+    # Show all fieldsets
     def index
       @fieldsets = DynamicFieldsets::Fieldset.all
 
@@ -12,7 +12,16 @@ module DynamicFieldsets
       end
     end
     
-    # Show single record
+    # Show all root fieldsets
+    def roots
+      @fieldsets = DynamicFieldsets::Fieldset.roots
+
+      respond_to do |format|
+        format.html { render action: 'index' }
+      end
+    end
+    
+    # Show single fieldset
     def show
       @fieldset = DynamicFieldsets::Fieldset.find_by_id(params[:id])
 
@@ -21,7 +30,7 @@ module DynamicFieldsets
       end
     end 
 
-    # Create new record
+    # Create new fieldset
     def new
       @fieldset = DynamicFieldsets::Fieldset.new()
 
@@ -41,20 +50,97 @@ module DynamicFieldsets
 
     # Show a record and all children
     def children
-      @fieldset_family = DynamicFieldsets::Fieldset.find_by_id(params[:id]).children
-      @parent_fieldset = DynamicFieldsets::Fieldset.find_by_id(params[:id])
+      @fieldset = DynamicFieldsets::Fieldset.find_by_id params[:id]
 
       respond_to do |format|
         format.html
       end
     end
+
+    # associates a field or fieldset with the given fieldset by creating a fieldset child
+    def associate_child
+      @fieldset = DynamicFieldsets::Fieldset.find_by_id(params[:id])
+      @field = DynamicFieldsets::Field.find_by_id(params[:field])
+
+      @fieldset_child = DynamicFieldsets::FieldsetChild.where(:child_id => @field.id, :child_type => @field.class.name, :fieldset_id => @fieldset.id).first
+      if(@fieldset_child.nil?)
+        @fieldset_child = DynamicFieldsets::FieldsetChild.new(
+          :child_id => @field.id, 
+          :child_type => @field.class.name,
+          :fieldset_id => @fieldset.id,
+          :order_num => DynamicFieldsets::FieldsetChild.where(:fieldset_id => @fieldset.id).count + 1)
+      else
+        child_already_exists = true
+      end
+
+      respond_to do |format|
+        if @fieldset_child.save
+          if child_already_exists
+            notice_text = "Field was already associated with the fieldset"
+          else
+            notice_text = "Successfully associated a field"
+          end
+          format.html { redirect_to(dynamic_fieldsets_children_dynamic_fieldsets_fieldset_path(@fieldset), :notice => notice_text )}
+        else
+          format.html { redirect_to(dynamic_fieldsets_children_dynamic_fieldsets_fieldset_path(@fieldset), :notice => "Field was not successsfully associated." )}
+        end
+      end
+    end
+    
+    # ...
+    def reorder
+      root = params[:id]
+      parent_child_pairs = params[:child].inject({}) do |hash,(key,val)|
+        if val.eql? 'root' then hash[key.to_i] = root.to_i
+        else hash[key.to_i] = val.to_i
+        end
+        hash
+      end
+      
+      @order = {}
+      parent_child_pairs.each do |key,val|
+        if @order.keys.include? val
+        then @order[val].push key
+        else @order.merge! val=>[key]
+        end
+      end
+      
+      # e.g. { 1 => [6], 6 => [7,8] }
+      # First number is always the root Fieldset id.
+      # The rest are FieldsetChild ids.
+      @order.each do |parent_identifier,children|
+        if parent_identifier.eql? @order.first[0] # This is the first number:
+        then parent_id = parent_identifier # the root fieldset id.
+        # Otherwise, we need to retrieve the parent fieldset_id from the FieldsetChild's child_id.
+        else parent_id = DynamicFieldsets::FieldsetChild.find_by_id(parent_identifier).child_id
+        end
+        children.each_with_index do |fieldset_child_id,index|
+          fieldset_child = DynamicFieldsets::FieldsetChild.find_by_id fieldset_child_id
+          fieldset_child.fieldset_id = parent_id
+          fieldset_child.order_num = index+1
+          fieldset_child.save
+        end
+      end
+
+      respond_to do |format|
+        format.json { render :json => @order }
+      end
+    end
     
     # Save new record
     def create
+      parent_id = params[:parent]
       @fieldset = DynamicFieldsets::Fieldset.new(params[:dynamic_fieldsets_fieldset])
 
       respond_to do |format|
         if @fieldset.save
+          if !parent_id.empty?
+            parent = DynamicFieldsets::Fieldset.find_by_id(parent_id)
+            DynamicFieldsets::FieldsetChild.create( :fieldset => parent, :child => @fieldset )
+            #relation = @fieldset.fieldset_children.build( :fieldset => parent )
+            #relation.child = @fieldset
+            #relation.save
+          end
           format.html { redirect_to( dynamic_fieldsets_fieldset_path(@fieldset), :notice => "Successfully created a new fieldset" )}
         else
           format.html { render :action => "new" }

data/app/helpers/dynamic_fieldsets/fields_helper.rb

@@ -1,19 +1,5 @@
 module DynamicFieldsets
   module FieldsHelper
-
-    # returns a link with an onclick call to remove_fields using link_to_function
-    def link_to_remove_fields(name, f)  
-      f.hidden_field(:_destroy) + link_to_function(name, "remove_fields(this)")  
-    end 
-
-    # returns a link with an onclick call to add_fields
-    # the field information is rendered from a partial and stored as a string until it is needed
-    def link_to_add_fields(name, f, association)  
-      new_object = f.object.class.reflect_on_association(association).klass.new  
-      fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |builder|  
-        render(association.to_s.singularize + "_fields", :f => builder)  
-      end  
-      link_to_function(name, "add_fields(this, '#{association}', '#{escape_javascript(fields)}')")
-    end
+    include NestedModelHelper
   end
 end

data/app/helpers/dynamic_fieldsets/fieldset_children_helper.rb

@@ -0,0 +1,5 @@
+module DynamicFieldsets
+  module FieldsetChildrenHelper
+    include NestedModelHelper
+  end
+end

data/app/helpers/dynamic_fieldsets/nested_model_helper.rb

@@ -0,0 +1,18 @@
+module DynamicFieldsets
+  module NestedModelHelper
+    # returns a link with an onclick call to remove_fields using link_to_function
+    def link_to_remove_fields(name, f)  
+      f.hidden_field(:_destroy) + link_to_function(name, {:onclick => "remove_fields(this)"})  
+    end 
+
+    # returns a link with an onclick call to add_fields
+    # the field information is rendered from a partial and stored as a string until it is needed
+    def link_to_add_fields(name, f, association, method = "add_fields")  
+      new_object = f.object.class.reflect_on_association(association).klass.new  
+      fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |builder|  
+        render(association.to_s.singularize + "_fields", {:f => builder, :obj => new_object})  
+      end  
+      link_to_function(name, {:class => name.underscore.gsub(' ', '_'), :onclick => "#{method}(this, '#{association}', '#{escape_javascript(fields)}')"})
+    end
+  end
+end

data/app/helpers/dynamic_fieldsets_helper.rb

@@ -1,32 +1,33 @@
 module DynamicFieldsetsHelper
   #include ActionView::Helpers
-  
+
   # Builds HTML for the provided field.
   # @param [FieldsetAssociator] fsa parent FieldsetAssociator
-  # @param [Field] field The Field to render
+  # @param [FieldsetChild] fieldset_child The FieldsetChild to render
   # @param [Array] values Saved values for the field
   # @return [Array] The HTML elements for the field
-  def field_renderer(fsa, field, values = [], form_type)
+  def field_renderer(fsa, fieldset_child, values = [], form_type)
     if form_type == "form"
-      return field_form_renderer(fsa, field, values)
+      return field_form_renderer(fsa, fieldset_child, values)
     else
-      return field_show_renderer(fsa, field, values)
+      return field_show_renderer(fsa, fieldset_child, values)
     end
   end
 
 
   # Builds HTML for the provided field for a show page.
   # @param [FieldsetAssociator] fsa parent FieldsetAssociator
-  # @param [Field] field The Field to render
+  # @param [FieldsetChild] fieldset_child The FieldsetChild to render
   # @param [Array] values Saved values for the field
   # @return [Array] The HTML elements for the field
-  def field_show_renderer(fsa, field, values = [])
+  def field_show_renderer(fsa, fieldset_child, values = [])
+    field = fieldset_child.child
     lines = []
     lines.push "<div class='dynamic_fieldsets_field'>"
     lines.push "<div class='dynamic_fieldsets_field_label'>#{field.label}</div>"
     lines.push "<div class='dynamic_fieldsets_field_value'>"
     if values
-      if field.field_type == "multiple_select" || field.field_type == "checkboxes"
+      if field.field_type == "multiple_select" || field.field_type == "checkbox"
         values.each do |value|
           lines.push value.to_s + "<br />"
         end
@@ -45,57 +46,61 @@ module DynamicFieldsetsHelper
 
   # Builds HTML for the provided field for a form.
   # @param [FieldsetAssociator] fsa parent FieldsetAssociator
-  # @param [Field] field The Field to render
+  # @param [FieldsetChild] fieldset_child The FieldsetChild to render
   # @param [Array] values Saved values for the field
   # @return [Array] The HTML elements for the field
-  def field_form_renderer(fsa, field, values = [])
+  def field_form_renderer(fsa, fieldset_child, values = [])
+    field = fieldset_child.child
     classes  = "#{field.field_type} "
     classes += ( field.required ? 'required' : 'optional' )
     
-    field_markup = ["<li class='#{classes}' id='field-input-#{field.id}'>"]
-    field_markup.push "<label for='field-#{field.id}'>"
-    field_markup.push "#{field.label}"
-    field_markup.push "<abbr title='required'>*</abbr>" if field.required?
-    field_markup.push "</label>"
+    field_markup = ["<li class='#{classes}' id='input-field-#{field.id}-child-#{fieldset_child.id}'>"]
+    
+    if !field.field_type.eql?('instruction')
+      field_markup.push "<label for='field-#{field.id}'>"
+      field_markup.push "#{field.label}: "
+      field_markup.push "<abbr title='required'>*</abbr>" if field.required?
+      field_markup.push "</label>"
+    end
     
-    attrs = { :id => "field-#{field.id}" }
-    field.field_html_attributes.each{ |a| attrs.merge({ a.attribute_name.to_sym => a.value}) } if !field.field_html_attributes.empty?
+    attrs = { :id => "field-#{field.id}-child-#{fieldset_child.id}" }
+    field.field_html_attributes.each{ |a| attrs.merge! a.attribute_name.to_sym => a.value } if !field.field_html_attributes.empty?
     
     case field.field_type.to_sym
     when :select
       selected = populate(field,values).to_i # should return the ID of the saved or default option
-      field_markup.push select_tag "fsa-#{fsa.id}[field-#{field.id}]", options_from_collection_for_select( field.options, :id, :name, selected ), attrs
+      field_markup.push select_tag "fsa-#{fsa.id}[field-#{fieldset_child.id}]", options_from_collection_for_select( field.options, :id, :name, selected ), attrs
       
     when :multiple_select
-      attrs.merge! multiple: 'multiple'
+      attrs.merge! multiple: true
       opts = populate( field, values )
       opts = [opts] if !opts.is_a? Array
       selected = opts.map( &:to_i ) if !opts.empty? # array of option IDs, saved > default
-      field_markup.push select_tag "fsa-#{fsa.id}[field-#{field.id}]", options_from_collection_for_select( field.options, :id, :name, selected ), attrs
+      field_markup.push select_tag "fsa-#{fsa.id}[field-#{fieldset_child.id}]", options_from_collection_for_select( field.options, :id, :name, selected ), attrs
       
     when :radio
-      field_markup.push "<div id='field-#{field.id}'>"
+      field_markup.push "<div id='field-#{field.id}-child-#{fieldset_child.id}'>"
       field.options.each do |option|
         attrs[:id] = "field-#{field.id}-#{option.name.parameterize}"
         these_attrs = attrs
         these_attrs = attrs.merge checked: true if populate(field,values).to_i.eql? option.id
-        field_markup.push "<label for='#{attrs[:id]}'>"
-        field_markup.push radio_button "fsa-#{fsa.id}", "field-#{field.id}", option.id, these_attrs
+        field_markup.push "<label for='#{these_attrs[:id]}'>"
+        field_markup.push radio_button "fsa-#{fsa.id}", "field-#{fieldset_child.id}", option.id, these_attrs
         field_markup.push "#{option.name}"
         field_markup.push "</label>"
       end
       field_markup.push "</div>"
       
     when :checkbox
-      field_markup.push "<div id='field-#{field.id}'>"
+      field_markup.push "<div id='field-#{field.id}-child-#{fieldset_child.id}'>"
+      attrs[:name] = "fsa-#{fsa.id}[field-#{fieldset_child.id}][]"
       opts = populate( field, values )
       checked = []
       checked = opts.map( &:to_i ) if !opts.empty? # array of option IDs, saved > default
       field.options.each do |option|
         attrs[:id] = "field-#{field.id}-#{option.name.underscore}"
-        attrs.merge! checked: true if checked.include? option.id
         field_markup.push "<label for='#{attrs[:id]}'>"
-        field_markup.push check_box "fsa-#{fsa.id}", "field-#{field.id}", attrs
+        field_markup.push check_box_tag "#{attrs[:name]}", "#{option.id}", checked.include?(option.id), attrs
         field_markup.push "#{option.name}"
         field_markup.push "</label>"
       end
@@ -103,33 +108,32 @@ module DynamicFieldsetsHelper
       
     when :textfield
       attrs.merge!( {:value => populate( field, values )} )
-      field_markup.push text_field "fsa-#{fsa.id}", "field-#{field.id}", attrs
+      field_markup.push text_field "fsa-#{fsa.id}", "field-#{fieldset_child.id}", attrs
       
     when :textarea
       attrs.merge! cols: '40' if !attrs.include? :cols
-      attrs.merge! rows: '20' if !attrs.include? :rows
-      attrs.merge! name: "fsa-#{fsa.id}[field-#{field.id}]"
-      field_markup.push "<textarea>"
-      # attrs ...
+      attrs.merge! rows: '6' if !attrs.include? :rows
+      attrs.merge! name: "fsa-#{fsa.id}[field-#{fieldset_child.id}]"
+      tag = "<textarea"
+      attrs.each{ |att,val| tag += " #{att}=\"#{val}\"" }
+      tag += ">"
+      field_markup.push tag
       field_markup.push populate( field, values )
       field_markup.push "</textarea>"
       
     when :date
-      date_options = {  date_separator: '/',
-                        add_month_numbers: true,
-                        start_year: Time.now.year - 70 }
+      date_options = { start_year: Time.now.year - 70 }
       setdate = populate( field, values ) # date string if saved or default
       date_options.merge! default: Time.parse( setdate ) if !setdate.empty?
       # attrs.reject!{ |k| k.eql? :id }
-      field_markup.push date_select "fsa-#{fsa.id}", "field-#{field.id}", date_options, attrs
+      field_markup.push date_select "fsa-#{fsa.id}", "field-#{fieldset_child.id}", date_options, attrs
       
     when :datetime
-      date_options = {  add_month_numbers: true,
-                        start_year: Time.now.year - 70 }
+      date_options = { start_year: Time.now.year - 70 }
       setdate = populate( field, values ) # datetime string if saved or default
       date_options.merge! default: Time.parse( setdate ) if !setdate.empty?
       # attrs.reject!{ |k| k.eql? :id }
-      field_markup.push datetime_select "fsa-#{fsa.id}", "field-#{field.id}", date_options, attrs
+      field_markup.push datetime_select "fsa-#{fsa.id}", "field-#{fieldset_child.id}", date_options, attrs
       
     when :instruction
       field_markup.push "<p>#{field.label}</p>"
@@ -142,21 +146,24 @@ module DynamicFieldsetsHelper
   
   # Builds HTML for the provided fieldset and its children.
   # @param [FieldsetAssociator] fsa parent FieldsetAssociator
-  # @param [Field] fieldset The Fieldset to render
+  # @param [Fieldset] fieldset The Fieldset to render
   # @param [Hash] values Stored values for the fieldset
   # @return [Array] The HTML elements for the fieldset
   def fieldset_renderer(fsa, fieldset, values, form_type)
     lines = ["<div id='fieldset-#{fieldset.id}' class='inputs'>"]
+    lines.push "<h3 class='name'>#{fieldset.name}</h3>"
     lines.push "<ol>"
     fieldset.children.each do |child|
       if child.is_a? DynamicFieldsets::Field then
-        lines += field_renderer( fsa, child, values[child.id], form_type )
+        fieldset_child = DynamicFieldsets::FieldsetChild.where( :child_id => child.id, :fieldset_id => fieldset.id, :child_type => child.class.name ).first
+        lines += field_renderer( fsa, fieldset_child, values[fieldset_child.id], form_type )
       else # child.is_a? Fieldset
         lines += fieldset_renderer( fsa, child, values, form_type )
       end
     end
     lines.push "</ol>"
     lines.push "</div>"
+
     return lines
   end
   
@@ -171,17 +178,21 @@ module DynamicFieldsetsHelper
   # @param [FieldsetAssociator] The fieldset associator for the dynamic fieldset to render
   # @return [String] The HTML for the entire dynamic fieldset
   def dynamic_fieldset_form_renderer(fsa)
-    return dynamic_fieldset_renderer(fsa, "form")
+    return dynamic_fieldset_renderer(fsa, "form") << javascript_renderer(fsa)
   end
 
   # Builds HTML for a specific dynamic fieldset in a form.
   # @param [FieldsetAssociator] The fieldset associator for the dynamic fieldset to render
   # @return [String] The HTML for the entire dynamic fieldset
   def dynamic_fieldset_renderer(fsa, form_type)
-    rendered_dynamic_fieldset = ""
+    rendered_dynamic_fieldset = "<div id='fsa-#{fsa.id}'>\n"
+    rendered_dynamic_fieldset += "<input type='hidden' name='fsa-#{fsa.id}[fieldset_id]' value='#{fsa.fieldset_id}' />\n"
+    rendered_dynamic_fieldset += "<input type='hidden' name='fsa-#{fsa.id}[fieldset_model_name]' value='#{fsa.fieldset_model_name}' />\n"
     fieldset_renderer( fsa, fsa.fieldset, fsa.field_values, form_type ).each do |line|
       rendered_dynamic_fieldset += line + "\n"
     end
+    rendered_dynamic_fieldset += "</div>"
+
     return rendered_dynamic_fieldset.html_safe
   end
   
@@ -196,12 +207,27 @@ module DynamicFieldsetsHelper
         return ""
       elsif field.field_defaults.length > 1
         return field.field_defaults.collect{ |d| d[:value] }
-      else 
+      else
         return field.field_defaults.first.value
       end
     else
       return value
     end
   end
-  
+
+  # Method that returns the javascript in string format to be pushed on with the rest of the
+  # generated form
+  #
+  # @params [FieldsetAssociator] The fieldset associator for the dynamic fieldset to render
+  # @return [String] The javascript variable that shows what fields have dependencies
+  def javascript_renderer(fsa)
+    unless fsa.id == nil
+      rendered_javascript = "<script type='text/javascript'> var json_holder = #{fsa.dependency_child_hash.to_json}; </script>"
+      rendered_javascript += render "dynamic_fieldsets/shared/javascript_watcher"
+      return rendered_javascript.html_safe
+    else
+      return ""
+    end
+  end
+
 end