dynamic_fieldsets 0.0.2

data/app/helpers/dynamic_fieldsets_helper.rb

@@ -0,0 +1,207 @@
+module DynamicFieldsetsHelper
+  include ActionView::Helpers
+  
+  # Builds HTML for the provided field.
+  # @param [FieldsetAssociator] fsa parent FieldsetAssociator
+  # @param [Field] field The Field 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)
+    if form_type == "form"
+      return field_form_renderer(fsa, field, values)
+    else
+      return field_show_renderer(fsa, field, 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 [Array] values Saved values for the field
+  # @return [Array] The HTML elements for the field
+  def field_show_renderer(fsa, field, values = [])
+    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"
+        values.each do |value|
+          lines.push value.to_s + "<br />"
+        end
+      elsif field.field_type == "select" || field.field_type == "radio"
+        lines.push values.to_s
+      else
+        lines.push values
+      end
+    else
+      lines.push "No answer given"
+    end
+    lines.push "</div>"
+    return lines
+  end
+
+
+  # Builds HTML for the provided field for a form.
+  # @param [FieldsetAssociator] fsa parent FieldsetAssociator
+  # @param [Field] field The Field 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 = [])
+    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>"
+    
+    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?
+    
+    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
+      
+    when :multiple_select
+      attrs.merge! multiple: 'multiple'
+      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
+      
+    when :radio
+      field_markup.push "<div id='field-#{field.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 "#{option.name}"
+        field_markup.push "</label>"
+      end
+      field_markup.push "</div>"
+      
+    when :checkbox
+      field_markup.push "<div id='field-#{field.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 "#{option.name}"
+        field_markup.push "</label>"
+      end
+      field_markup.push "</div>"
+      
+    when :textfield
+      attrs.merge!( {:value => populate( field, values )} )
+      field_markup.push text_field "fsa-#{fsa.id}", "field-#{field.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 ...
+      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 }
+      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
+      
+    when :datetime
+      date_options = {  add_month_numbers: true,
+                        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
+      
+    when :instruction
+      field_markup.push "<p>#{field.label}</p>"
+      
+    end # case field.field_type
+    
+    field_markup.push "</li>"
+    return field_markup
+  end
+  
+  # Builds HTML for the provided fieldset and its children.
+  # @param [FieldsetAssociator] fsa parent FieldsetAssociator
+  # @param [Field] 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 "<ol>"
+    fieldset.children.each do |child|
+      if child.is_a? DynamicFieldsets::Field then
+        lines += field_renderer( fsa, child, values[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
+  
+  # Build HTML for a specific dynamic fieldset on a show page
+  # @param [FieldsetAssociator] The fieldset associator for the dynamic fieldset to render
+  # @return [String] The HTML for the entire dynamic fieldset
+  def dynamic_fieldset_show_renderer(fsa)
+    return dynamic_fieldset_renderer(fsa, "show")
+  end
+
+  # Build HTML for a specific dynamic fieldset on a form page
+  # @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")
+  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 = ""
+    fieldset_renderer( fsa, fsa.fieldset, fsa.field_values, form_type ).each do |line|
+      rendered_dynamic_fieldset += line + "\n"
+    end
+    return rendered_dynamic_fieldset.html_safe
+  end
+  
+  # Gives precedence to saved values; returns default values if empty
+  # @param [Field] field Field to populate
+  # @param [String] value Possibly saved values
+  # @return The saved or default value(s)
+  # I know this is messy; this is what happens when we are past deadline.
+  def populate(field, value)
+    if value.nil? || (value.is_a?(Array) && value.empty?)
+      if field.field_defaults.length == 0
+        return ""
+      elsif field.field_defaults.length > 1
+        return field.field_defaults.collect{ |d| d[:value] }
+      else 
+        return field.field_defaults.first.value
+      end
+    else
+      return value
+    end
+  end
+  
+end

data/app/models/dynamic_fieldsets/field.rb

@@ -0,0 +1,85 @@
+module DynamicFieldsets
+  # Base class for various fieldtypes, i.e. questions
+  #
+  # @author Jeremiah Hemphill, Ethan Pemble
+  class Field < ActiveRecord::Base
+    # Relations
+    belongs_to :fieldset
+    has_many :field_options
+    accepts_nested_attributes_for :field_options, :allow_destroy => true
+
+    has_many :field_defaults
+    accepts_nested_attributes_for :field_defaults, :allow_destroy => true
+
+    has_many :field_html_attributes
+    accepts_nested_attributes_for :field_html_attributes, :allow_destroy => true
+
+    # Validations
+    validates_presence_of :name
+    validates_presence_of :label
+    validates_presence_of :field_type
+    validates_presence_of :order_num
+    validates_inclusion_of :enabled, :in => [true, false]
+    validates_inclusion_of :required, :in => [true, false]
+    validate :has_field_options, :field_type_in_field_types
+
+    # validates inclusion of wasn't working so I made it a custom validation
+    # refactor later when I figure out how rails works
+    def field_type_in_field_types
+      if !Field.field_types.include?(self.field_type)
+        self.errors.add(:field_type, "The field type must be one of the available field types.")
+      end
+    end
+    
+    # Custom validation for fields with multiple options on update
+    def has_field_options
+      if options? && self.field_options.empty?
+        self.errors.add(:field_options, "This field must have options")
+      end
+    end
+
+    # @returns [Array] An array of allowable field types
+    def self.field_types
+      ["select", "multiple_select", "checkbox", "radio", "textfield", "textarea", "date", "datetime", "instruction"]
+    end
+
+    # @returns [Array] An array of field types that use options
+    def self.option_field_types
+      ["select", "multiple_select", "checkbox", "radio"]
+    end
+    
+    # @return [Boolean] True if the field is of type 'select', 'multiple_select', 'radio', or 'checkbox'
+    def options?
+      Field.option_field_types.include? self.field_type
+    end
+    
+    # @return [FieldOptions] Returns all field options that are enabled
+    def options
+      return self.field_options.reject{ |option| !option.enabled }
+    end
+    
+    # @return [Boolean] False if field_default.value is empty
+    def has_defaults?
+      return self.field_defaults.length > 0
+    end
+    
+    # @return [Array] Alias for field_defaults
+    def defaults
+      if options?
+        return self.field_defaults
+      else 
+        return nil
+      end
+    end
+    
+    # @return [String] Alias for field_defaults.first
+    def default
+      if options?
+        return nil
+      else
+        return self.field_defaults.first
+      end
+    end
+    
+  end
+end

data/app/models/dynamic_fieldsets/field_default.rb

@@ -0,0 +1,14 @@
+module DynamicFieldsets
+  # Base class for various field_defaults,
+  # A text field would have a single default value
+  # While a multiple select could have multiple default values
+  #
+  # @authors Scott Sampson, Jeremiah Hemphill, Ethan Pemble
+  class FieldDefault < ActiveRecord::Base
+    #relations
+    belongs_to :field
+    
+    #validations
+    validates_presence_of :value
+  end
+end

data/app/models/dynamic_fieldsets/field_html_attribute.rb

@@ -0,0 +1,15 @@
+module DynamicFieldsets
+  # Base class for various field_html_attributes,
+  # an example of an html attribute is {attribute => 'class',value => 'required'}
+  # Any field can have more than one html attribute
+  #
+  # @authors Scott Sampson, Jeremiah Hemphill, Ethan Pemble
+  class FieldHtmlAttribute < ActiveRecord::Base
+    #relations
+    belongs_to :field
+    
+    #validations
+    validates_presence_of :attribute_name
+    validates_presence_of :value
+  end
+end

data/app/models/dynamic_fieldsets/field_option.rb

@@ -0,0 +1,18 @@
+module DynamicFieldsets
+  # Base class for various field_options,
+  # field options are used for fields with a set of answers to choose from
+  # the field types that need options are select, checkbox, or radio
+  #
+  # @authors Scott Sampson, Jeremiah Hemphill, Ethan Pemble
+  class FieldOption < ActiveRecord::Base
+    #relations
+    belongs_to :field
+    
+    #validations
+    validates_presence_of :name
+    validates_inclusion_of :enabled, :in => [true, false]
+
+    # @return [Array] Scope: enabled field options
+    scope :enabled, :conditions => { :enabled => true }
+  end
+end

data/app/models/dynamic_fieldsets/field_record.rb

@@ -0,0 +1,11 @@
+module DynamicFieldsets
+  # Stores a single record's answer to a field in a fieldset
+  # Fields with multiple answers should have multiple records in this model
+  class FieldRecord < ActiveRecord::Base
+    belongs_to :field
+    belongs_to :fieldset_associator
+
+    validates_presence_of :field, :fieldset_associator
+    validates_exclusion_of :value, :in => [nil] 
+  end
+end

data/app/models/dynamic_fieldsets/fieldset.rb

@@ -0,0 +1,57 @@
+module DynamicFieldsets
+  # Stores a collection of fields and other fieldsets
+  #
+  # @author Jeremiah Hemphill, Ethan Pemble
+  class Fieldset < ActiveRecord::Base
+    # Relations
+    has_many :fieldset_associators
+    belongs_to :parent_fieldset, :class_name => "Fieldset", :foreign_key => "parent_fieldset_id"
+    has_many :child_fieldsets, :class_name => "Fieldset", :foreign_key => "parent_fieldset_id"
+    has_many :fields
+
+    # Validations
+    validates_presence_of :name
+    validates_presence_of :description
+    validates_presence_of :nkey
+    validates_uniqueness_of :nkey
+    validates_presence_of :order_num, :if => lambda { !self.root? }
+    validate :cannot_be_own_parent
+
+    # looks recursively up the parent_fieldset value to check if it sees itself
+    def cannot_be_own_parent
+      parent = self.parent_fieldset
+      while !parent.nil?
+        if parent == self
+          self.errors.add(:parent_fieldset, "Parent fieldsets must not create a cycle.")
+          parent = nil
+        else
+          parent = parent.parent_fieldset
+        end
+      end
+    end
+    
+    # @return [Array] Scope: parent-less fieldsets
+    scope :roots, :conditions => ["parent_fieldset_id IS NULL"]
+    
+    # @return [Array] An array of name, id pairs to be used in select tags
+    def self.parent_fieldset_list
+      all.collect { |f| [f.name, f.id] }
+    end
+
+    # @return [Boolean] True if fieldset has no parent
+    def root?
+      return parent_fieldset.nil?
+    end
+    
+    # The collected descendents of a fieldset.  This group is sorted first by order number, 
+    # then alphabetically by name in the case of duplicate order numbers.
+    # @return [Array] Ordered collection of descendent fields and fieldsets.
+    def children
+      collected_children = []
+      fields.reject{|f| !f.enabled}.each{ |field| collected_children.push field }
+      child_fieldsets.each{ |fieldset| collected_children.push fieldset }
+      return collected_children.sort_by{ |child| [child.order_num, child.name] }
+    end
+
+  end
+end

data/app/models/dynamic_fieldsets/fieldset_associator.rb

@@ -0,0 +1,76 @@
+module DynamicFieldsets
+  class FieldsetAssociator < ActiveRecord::Base
+    belongs_to :fieldset
+    has_many :field_records
+
+    validates_presence_of :fieldset_id, :fieldset_model_id, :fieldset_model_type, :fieldset_model_name
+    validate :unique_fieldset_model_name_per_polymorphic_fieldset_model
+
+    def unique_fieldset_model_name_per_polymorphic_fieldset_model
+      FieldsetAssociator.where(:fieldset_model_id => self.fieldset_model_id, :fieldset_model_type => self.fieldset_model_id, :fieldset_model_name => self.fieldset_model_name).each do |fsa|
+        if fsa.id != self.id
+          self.errors.add(:fieldset_model_name, "A duplicate Field Model, Field Model Name pair has been found.")
+        end
+      end
+    end
+
+    # Scope to find a fieldset associator based on information from the fieldset model
+    #
+    # Arguments
+    # fieldset: The nkey of the fieldset
+    # fieldset_model_id: The id of the fieldset model
+    # fieldset_model_type: The class name of the fieldset model
+    # fieldset_model_name: The named fieldset in the model
+    #
+    # @params [Hash] args A hash of arguments for the scope
+    # @retursn [Array] An array of fieldset associators that match the arguments
+    def self.find_by_fieldset_model_parameters(args)
+      fieldset = Fieldset.find_by_nkey(args[:fieldset])
+      where(
+        :fieldset_id => fieldset.id, 
+        :fieldset_model_id => args[:fieldset_model_id], 
+        :fieldset_model_type => args[:fieldset_model_type], 
+        :fieldset_model_name => args[:fieldset_model_name])
+    end
+
+    # Returns a hash of field record values
+    # Fun nonintuitive stuff here
+    #
+    # The hash keys are field ids
+    # The hash values are field_record values or field_records ids depending on the field type
+    # The hash values are usually strings but sometimes arrays
+    # If a field that expects a single value has multiple values, it will
+    # choose one to use arbitrarily
+    #
+    # multiple_select: [option_ids,]
+    # checkbox: [option_ids,]
+    # select: option_id
+    # radio: option_id
+    # textfield: "value"
+    # textarea: "value"
+    # date: "value"
+    # datetime: "value"
+    # instruction: "value"
+    #
+    # @return [Hash] A hash of field record values associated with field ids
+    def field_values
+      output = {}
+      self.field_records.each do |record|
+        if record.field.field_type == "checkbox" || record.field.field_type == "multiple_select"
+          output[record.field.id] = [] unless output[record.field.id].is_a?(Array)
+          # note record.id array
+          # collect?
+          output[record.field.id].push record.value.to_i
+        elsif record.field.field_type == "radio" || record.field.field_type == "select"
+          # note record.id
+          output[record.field.id] = record.value.to_i
+        else
+          # note record.value
+          output[record.field.id] = record.value
+        end
+      end
+      return output
+    end
+
+  end
+end

data/app/views/dynamic_fieldsets/fields/_field_default_fields.html.erb

@@ -0,0 +1,7 @@
+<p class="fields">  
+  <%= f.label :value, "Default field value"  %>
+  <%= f.text_field :value %>
+  <%= f.hidden_field :_destroy %>  
+  <%= link_to_function "remove", "remove_fields(this)" %>  
+</p> 
+

data/app/views/dynamic_fieldsets/fields/_field_html_attribute_fields.html.erb

@@ -0,0 +1,8 @@
+<p class="fields">  
+  <%= f.label :attribute_name %>
+  <%= f.text_field :attribute_name %>
+  <%= f.label :value,  %>
+  <%= f.text_field :value %>
+  <%= f.hidden_field :_destroy %>  
+  <%= link_to_function "remove", "remove_fields(this)" %>  
+</p> 

data/app/views/dynamic_fieldsets/fields/_field_option_fields.html.erb

@@ -0,0 +1,6 @@
+<p class="fields">  
+  <%= f.label :name %>
+  <%= f.text_field :name %>
+  <%= f.hidden_field :_destroy %>  
+  <%= link_to_function "remove", "remove_fields(this)" %>  
+</p> 

data/app/views/dynamic_fieldsets/fields/_form.html.erb

@@ -0,0 +1,81 @@
+<%= form_for(@field) do |f| %>
+  <% if @field.errors.any? %>
+    <div id="error_explanation">
+      <h2><%= pluralize(@field.errors.count, "error") %> prohibited this field from being saved:</h2>
+
+      <ul>
+      <% @field.errors.full_messages.each do |msg| %>
+        <li><%= msg %></li>
+      <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div class="field">
+    <%= f.label :fieldset_id %><br />
+    <%= f.select :fieldset_id, options_for_select(DynamicFieldsets::Fieldset.parent_fieldset_list), :include_blank => "Choose One"  %>
+  </div>
+  <div class="field">
+    <%= f.label :name %><br />
+    <%= f.text_field :name %>
+  </div>
+  <div class="field">
+    <%= f.label :label %><br />
+    <%= f.text_field :label %>
+  </div>
+
+  <div class="field">
+    <%= f.label :field_type %><br />
+    <%= f.select :field_type, options_for_select(DynamicFieldsets::Field.field_types, @field.field_type), :include_blank => "Choose One" %>
+  </div>
+  <% @field.field_options.each do |field_option| %>
+    <%= f.fields_for :field_options, field_option do |field_option_form| %>
+      <%= render :partial => "field_option_fields", :locals => {:f => field_option_form} %>
+    <% end %>
+  <% end %>
+  <p><%= link_to_add_fields "Add Field Option", f, :field_options %></p>
+
+  <div class="field">
+    <%= f.label :required %><br />
+    <%= f.check_box :required %>
+  </div>
+  <div class="field">
+    <%= f.label :enabled %><br />
+    <%= f.check_box :enabled %>
+  </div>
+  <div class="field">
+    <%= f.label :order_num, "Order Number" %><br />
+    <%= f.text_field :order_num %>
+  </div>
+
+  <% @field.field_defaults.each do |field_default| %>
+    <%= f.fields_for :field_defaults, field_default do |field_default_form| %>
+      <%= render :partial => "field_default_fields", :locals => {:f => field_default_form} %>
+    <% end %>
+  <% end %>
+  <p><%= link_to_add_fields "Add Default Value", f, :field_defaults %></p>
+
+  <% @field.field_html_attributes.each do |field_html_attribute| %>
+    <%= f.fields_for :field_html_attributes, field_html_attribute do |field_html_attribute_form| %>
+      <%= render :partial => "field_html_attribute_fields", :locals => {:f => field_html_attribute_form} %>
+    <% end %>
+  <% end %>
+  <p><%= link_to_add_fields "Add Html Attribute", f, :field_html_attributes %></p>
+
+  <div class="actions">
+    <%= f.submit %>
+  </div>
+<% end %>
+
+<script>
+function remove_fields(link) {  
+  $(link).prev("input[type=hidden]").val("1");  
+  $(link).closest(".fields").hide();  
+}  
+  
+function add_fields(link, association, content) {  
+  var new_id = new Date().getTime();  
+  var regexp = new RegExp("new_" + association, "g");  
+  $(link).parent().before(content.replace(regexp, new_id));  
+}  
+</script>

data/app/views/dynamic_fieldsets/fields/edit.html.erb

@@ -0,0 +1,6 @@
+<h1>Editing field</h1>
+
+<%= render 'form' %>
+
+<%= link_to 'Show', @field %> |
+<%= link_to 'Back', dynamic_fieldsets_fields_path %>

data/app/views/dynamic_fieldsets/fields/index.html.erb

@@ -0,0 +1,29 @@
+<h1>Listing fields</h1>
+
+<table>
+  <tr>
+    <th>Fieldset</th>
+    <th>Name</th>
+    <th>Type</th>
+    <th>Order num</th>
+    <th></th>
+    <th></th>
+    <th></th>
+  </tr>
+
+<% @fields.each do |field| %>
+  <tr>
+    <td><%= field.fieldset.name if field.fieldset %></td>
+    <td><%= field.name %></td>
+    <td><%= field.field_type %></td>
+    <td><%= field.order_num %></td>
+    <td><%= link_to 'Show', dynamic_fieldsets_field_path(field) %></td>
+    <td><%= link_to 'Edit', edit_dynamic_fieldsets_field_path(field) %></td>
+    <td><%= link_to 'Destroy', dynamic_fieldsets_field_path(field), :confirm => 'Are you sure?', :method => :delete %></td>
+  </tr>
+<% end %>
+</table>
+
+<br />
+
+<%= link_to 'New Field', new_dynamic_fieldsets_field_path %>

data/app/views/dynamic_fieldsets/fields/new.html.erb

@@ -0,0 +1,5 @@
+<h1>New field</h1>
+
+<%= render 'form' %>
+
+<%= link_to 'Back', dynamic_fieldsets_fields_path %>