dynamic_fieldsets 0.0.3 → 0.0.4

data/app/models/dynamic_fieldsets/dependency.rb

@@ -0,0 +1,76 @@
+module DynamicFieldsets
+
+  # Logical atom for dealing with dependency clauses
+  #
+  # @author John "hex" Carter
+  class Dependency < ActiveRecord::Base
+
+    RELATIONSHIP_LIST = ["equals","not equals","includes","not includes","blank","not blank"]
+
+    # Relations    
+
+    belongs_to :fieldset_child
+    belongs_to :dependency_clause
+
+    # Validations
+    validates_presence_of :fieldset_child_id
+
+    # This validation should really be on
+    # It is off due to a bug (?) in the nested attributes 
+    # where the dependency clause id is not set when it creates the dependency
+    # validates_presence_of :dependency_clause_id
+    
+    validates_inclusion_of :relationship, :in => RELATIONSHIP_LIST
+
+    # Returns a full list of the options for relationship_list
+    #
+    # @params [None]
+    # @returns [Array] The array of the constant RELATIONSHIP_LIST
+    #
+    def relationship_list
+      return RELATIONSHIP_LIST
+    end
+
+    # Returns true or false based on whether the value pushed in matches the logical relationship between it and the dependency's value 
+    #
+    # @params [String] input_value - The value to be tested
+    # @returns [Boolean] Logical response to relationship between the dependency value and the pushed value
+    #
+    def process_relationship(input_value)
+      case self.relationship
+      when "equals" 
+        return self.value == input_value
+      when "not equals"
+        return self.value != input_value
+      when "includes"
+        return input_value.include?(self.value)
+      when "not includes"
+        return !input_value.include?(self.value)
+      when "blank"
+        return input_value == ""
+      when "not blank"
+        return input_value != ""
+      else
+        return false
+      end
+    end
+
+    # Looks through the input_hash for the fieldset_child that matches the one belonging to this dependency and compares the values through process_relationship
+    #
+    # @params [Hash] input_hash - Key is the id of the fieldset_child to be tested, value is the input given by the user
+    # @returns [Boolean] returns the value of process_relationship unless the input doesn't contain the fieldset_child of the dependency, which also returns false 
+    #
+    def evaluate(input_hash)
+      input_value = input_hash[self.fieldset_child_id]
+      unless input_value.nil?
+        return self.process_relationship(input_value)
+      else
+        return false
+      end
+    end
+
+    def to_hash
+      return { "id" => self.id, "fieldset_child_id" => self.fieldset_child_id, "value" => self.value, "relationship" => self.relationship, "dependency_clause_id" => self.dependency_clause_id }
+    end
+  end
+end

data/app/models/dynamic_fieldsets/dependency_clause.rb

@@ -0,0 +1,32 @@
+module DynamicFieldsets
+  # A clause in CNF expression for question dependencies
+  #
+  # @author Jeremiah Hemphill
+  class DependencyClause < ActiveRecord::Base
+    belongs_to :dependency_group  
+
+    has_many :dependencies
+    accepts_nested_attributes_for :dependencies, :allow_destroy => true
+
+    validates_presence_of :dependency_group_id
+
+    # Evaluates the depdendencies in the claus by ORing them together
+    # Short circuit evaluation returns true as soon as possible
+    #
+    # @param [Hash] input_values A hash of fieldset_child_id:value pairs to test against
+    # @return [Boolean] True if one of the dependencies is true
+    def evaluate(input_values)
+      self.dependencies.each do |dependency|
+        if dependency.evaluate
+          return true
+        end
+      end
+      return false
+    end
+
+    def to_hash
+      return { "id" => self.id, "dependency_group_id" => self.dependency_group_id }
+    end
+
+  end
+end

data/app/models/dynamic_fieldsets/dependency_group.rb

@@ -0,0 +1,108 @@
+module DynamicFieldsets
+  class DependencyGroup < ActiveRecord::Base
+    belongs_to :fieldset_child
+
+    has_many :dependency_clauses
+    accepts_nested_attributes_for :dependency_clauses, :allow_destroy => true
+
+    # List of allowable actions for the group
+    # Success and failure options are returned by the get_action method
+    Action_list = { "show" => { :success => "show", :failure => "hide" }, "enable" => { :success => "enable", :failure => "disable" } }
+
+    validates_presence_of :fieldset_child_id
+    validates_presence_of :action
+    validate :action_in_action_list
+
+    # adds an error if the action isn't in the action list
+    def action_in_action_list
+      if !action_list.keys.include?(self.action)
+        self.errors.add(:action, "The action must be set to one of the provided values.")
+      end
+    end
+
+    # @return [Hash] The action list hash
+    def action_list
+      return Action_list
+    end
+
+    # Returns all fieldset children included in this dependency group
+    # Not sure if it will be useful, it would probably be called in evaluate
+    # I think it will be faster to just pass the input values array all the way down
+    # when evaluate is called.
+    #
+    # @returns [Array] An array of included fieldset children ids
+    def dependent_fieldset_children
+      children = []
+      self.dependency_clauses.each do |clause|
+        clause.dependencies.each do |dep|
+          children.push(dep.fieldset_child_id)
+        end
+      end
+      return children
+    end
+
+    # Parses the dependnecy_group's fieldset_child and ones inherited through dependency clause and creates a 
+    # hash where the key is the dependency_group's fieldset_child and the value is an array of all fieldset
+    # children dependent on this group. This is returned as a JSON object
+    #
+    # @returns [JSON] A hash inside a Json object
+    def dependency_group_fieldset_children
+      return { self.fieldset_child_id => self.dependent_fieldset_children }.to_json
+    end
+
+    # Returns the success or failure action depending on what evaluate returns
+    #
+    # @param [Hash] input_values A hash of fieldset_child_id:value pairs to test against
+    # @return [String] The success or failure action
+    def get_action(input_values)
+      if evaluate(input_values)
+        return Action_list[self.action][:success]
+      else
+        return Action_list[self.action][:failure]
+      end
+    end
+
+    # Evaluates the clauses by ANDing them together
+    # Short circuit evaluation returns false as soon as possible
+    #
+    # @param [Hash] values A hash of fieldset_child_id:value pairs to test against
+    # @return [Boolean] True if all of the clauses are true
+    def evaluate(values)
+      self.dependency_clauses.each do |clause|
+        if !clause.evaluate(values)
+          return false
+        end
+      end
+      return true
+    end
+
+    # Creates a nested hash that has information on the dependency_group as well
+    # as all dependency_clauses and nested dependencies within it. To be used
+    # when capturing dependencies for interacting with jQuery.
+    #
+    # @param [None]
+    # @return [Hash] A nested hash of the dependency group and related dependency_clauses and dependencies
+    def to_hash
+      dependency_group_hash =
+      {
+          "action" => self.action, 
+          "fieldset_child_id" => self.fieldset_child_id, 
+          "field_id" => self.fieldset_child.child_id,
+          "clause" => {}
+      }
+      for dependency_clause in self.dependency_clauses
+        dependency_group_hash["clause"][dependency_clause.id] = {}
+        for dependency in dependency_clause.dependencies
+          dependency_group_hash["clause"][dependency_clause.id][dependency.id] = 
+          {
+            "fieldset_child_id" => dependency.fieldset_child.id,
+            "relationship" => dependency.relationship,
+            "value" => dependency.value
+          }
+        end
+      end
+      dependency_group_hash
+    end
+
+  end
+end

data/app/models/dynamic_fieldsets/field.rb

@@ -4,7 +4,11 @@ module DynamicFieldsets
   # @author Jeremiah Hemphill, Ethan Pemble
   class Field < ActiveRecord::Base
     # Relations
-    belongs_to :fieldset
+    
+    # parents
+    has_many :fieldset_children, :dependent => :destroy, :as => :child
+    has_many :parent_fieldsets, :source => :fieldset, :foreign_key => "fieldset_id", :through => :fieldset_children, :class_name => "Fieldset"
+
     has_many :field_options
     accepts_nested_attributes_for :field_options, :allow_destroy => true
 
@@ -14,11 +18,13 @@ module DynamicFieldsets
     has_many :field_html_attributes
     accepts_nested_attributes_for :field_html_attributes, :allow_destroy => true
 
+    #has_many :dependency_groups
+    #accepts_nested_attributes_for :dependency_groups, :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
@@ -65,20 +71,19 @@ module DynamicFieldsets
     
     # @return [Array] Alias for field_defaults
     def defaults
-      if options?
-        return self.field_defaults
-      else 
-        return nil
-      end
+      return self.field_defaults if options?
+      return nil
     end
     
     # @return [String] Alias for field_defaults.first
     def default
-      if options?
-        return nil
-      else
-        return self.field_defaults.first
-      end
+      return nil if options?
+      return self.field_defaults.first
+    end
+
+    # @return [Boolean] True if there are any field records for the field or if it is in any fieldsets
+    def in_use?
+      self.fieldset_children.count { |child| !child.fieldset_id.nil? || !child.field_records.empty? } > 0
     end
     
   end

data/app/models/dynamic_fieldsets/field_default.rb

@@ -10,5 +10,31 @@ module DynamicFieldsets
     
     #validations
     validates_presence_of :value
+
+    before_save :convert_option_name_to_id
+    
+    # When the field type is an option type, the saved value should be converted into an id
+    # This needs to happen because the value field normally stores a string but sometimes stores a field option id
+    #
+    # In some cases, the field_option instance is not set before this, no idea what happens then
+    #
+    # http://www.youtube.com/watch?v=BeP6CpUnfc0 
+    def convert_option_name_to_id
+      if Field.option_field_types.include?(self.field.field_type)
+        option = FieldOption.find_by_name(self.value)
+        self.value = option.id unless option.nil?
+      end
+    end
+
+    # @return [String] Either the value or the name of the field option reference by the value
+    def pretty_value
+      if !self.field.nil? && Field.option_field_types.include?(self.field.field_type)
+        option = FieldOption.find_by_id(self.value)
+        if !option.nil?
+          return option.name
+        end
+      end
+      return self.value
+    end
   end
-end
+end

data/app/models/dynamic_fieldsets/field_record.rb

@@ -2,10 +2,25 @@ 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_child
     belongs_to :fieldset_associator
 
-    validates_presence_of :field, :fieldset_associator
-    validates_exclusion_of :value, :in => [nil] 
-  end
+    validates_presence_of :fieldset_child, :fieldset_associator
+    validates_exclusion_of :value, :in => [nil]
+    validate :type_of_fieldset_child
+
+    # make sure the fieldset child has the type field
+    # does not explicitly check to make sure the fieldset_child exists, still have to validate presence
+    def type_of_fieldset_child
+      if self.fieldset_child && !self.fieldset_child.child.is_a?(DynamicFieldsets::Field)
+        self.errors.add(:fieldset_child, "The fieldset child must refer to a Field object")
+      end
+    end
+  
+    # @return [Field] Alias for fieldset_child.child.
+    # A record can only be associated with Field children
+    def field
+      self.fieldset_child.child
+    end
+  end  
 end

data/app/models/dynamic_fieldsets/fieldset.rb

@@ -5,53 +5,58 @@ module DynamicFieldsets
   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
+
+    # parents
+    has_one :fieldset_parent, :dependent => :destroy, :class_name => "FieldsetChild", :as => :child
+    has_one :parent, :source => :fieldset, :foreign_key => "fieldset_id", :through => :fieldset_parent, :class_name => "DynamicFieldsets::Fieldset"
+    # children
+    has_many :fieldset_children, :dependent => :destroy, :foreign_key => "fieldset_id", :class_name => "FieldsetChild"
+    has_many :child_fields, :source => :child, :through => :fieldset_children, :source_type => "DynamicFieldsets::Field", :class_name => "DynamicFieldsets::Field"
+    has_many :child_fieldsets, :source => :child, :through => :fieldset_children, :source_type => "DynamicFieldsets::Fieldset", :class_name => "DynamicFieldsets::Fieldset"
+
 
     # 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] }
+    def self.roots
+      # the old method used a scope and the old table definition
+      # scope :roots, :conditions => ["parent_fieldset_id IS NULL"]
+      # the new method doesn't use a scope because I am bad at them
+      all.select { |fs| fs.parent.nil? }
     end
 
     # @return [Boolean] True if fieldset has no parent
     def root?
-      return parent_fieldset.nil?
+      return parent.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] 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
+    
+    # The collected descendents of a fieldset.
+    # This group is sorted by order number on the fieldsetchild model 
     # @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] }
+      self.fieldset_children.sort_by(&:order_num).each do |fs_child|
+        child = fs_child.child_type.constantize.find_by_id fs_child.child_id
+        if child.respond_to? :enabled? and child.enabled?
+          collected_children.push child
+        elsif !child.respond_to? :enabled?
+          collected_children.push child
+        end
+      end
+      return collected_children
+    end
+    
+    def has_children?
+      return !self.fieldset_children.empty?
     end
-
   end
 end

data/app/models/dynamic_fieldsets/fieldset_associator.rb

@@ -1,8 +1,9 @@
 module DynamicFieldsets
   class FieldsetAssociator < ActiveRecord::Base
     belongs_to :fieldset
+    belongs_to :fieldset_model, :polymorphic => true
     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
 
@@ -56,21 +57,64 @@ module DynamicFieldsets
     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)
+        fieldtype = record.fieldset_child.child.field_type
+        child_id = record.fieldset_child.id
+        if fieldtype == "checkbox" || fieldtype == "multiple_select"
+          output[child_id] = [] unless output[child_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"
+          output[child_id].push record.value.to_i
+        elsif fieldtype == "radio" || fieldtype == "select"
           # note record.id
-          output[record.field.id] = record.value.to_i
+          output[child_id] = record.value.to_i
         else
           # note record.value
-          output[record.field.id] = record.value
+          output[child_id] = record.value
         end
       end
       return output
     end
 
+
+    # OMG COMMENT
+    #
+    # TODO: Fill in actual comments
+    #
+    # @params - stuff
+    # @returns - other stuff
+    def dependency_child_hash
+      @fieldset_child_collection = []
+      look_for_dependents(self.fieldset)
+  
+      output = {}
+      for fieldset_child in @fieldset_child_collection
+        output[fieldset_child.id] = {}
+        for dependency in fieldset_child.dependencies
+          dependency_group = dependency.dependency_clause.dependency_group
+          output[fieldset_child.id][dependency_group.id] = dependency_group.to_hash
+        end
+      end
+      output
+    end
+ 
+
+    # OMG COMMENT
+    #
+    # TODO: Fill in actual comments
+    #
+    # @params - stuff
+    # @returns - other stuff
+    def look_for_dependents(parent_fieldset)
+      for fieldset_child in parent_fieldset.fieldset_children
+        if (fieldset_child.child_type == "DynamicFieldsets::Field") && (!fieldset_child.dependencies.empty?)
+          @fieldset_child_collection.push(fieldset_child)
+          return
+        elsif (fieldset_child.child_type == "DynamicFieldsets::Field") && (fieldset_child.dependencies.empty?)
+          return
+        else
+          look_for_dependents(fieldset_child.child)
+        end
+      end
+    end
+
   end
 end

data/app/models/dynamic_fieldsets/fieldset_child.rb

@@ -0,0 +1,148 @@
+module DynamicFieldsets
+
+  # FieldsetChild
+  # @author Jeremiah Hemphill, John "hex" Carter
+  class FieldsetChild < ActiveRecord::Base
+
+    # Constants
+
+    FIELDSET_CHILD_LIST = ["DynamicFieldsets::Field", "DynamicFieldsets::Fieldset"]
+
+    # Relationships
+
+    belongs_to :child, :polymorphic => true
+    belongs_to :fieldset
+    
+    has_many :field_records
+
+    # this is a little confusing, so let's explain:
+    # a fieldset_child can have many dependencies when it is a part of several dependencies
+    # which each belong to a dependency_clause, which consequently belongs to a dependency_group.
+    # a fieldset_child belongs to a dependency_group when it is at the END of a dependency_clause
+    # statement:
+    #   IF Field1 == A AND Field2 == B THEN show Field3
+    # In that example, Field1 and Field2 belong to dependencies and Field3 belongs to a dependency_group
+    has_one :dependency_group
+    accepts_nested_attributes_for :dependency_group, :allow_destroy => true
+
+    has_many :dependencies
+
+    # Validations
+
+    validates_presence_of :fieldset_id
+    validates_presence_of :child_id
+    validates_inclusion_of :child_type, :in => FIELDSET_CHILD_LIST
+    validates_presence_of :order_num
+    validate :no_duplicate_fields_in_fieldset_children
+    validate :cannot_be_own_parent
+    validate :no_parental_loop
+    
+    before_validation :assign_order
+    
+    # This method is called when FieldsetChildren is instantiated. 
+    # It ensures that the Child has a valid order number.
+    def assign_order
+      self.order_num = self.last_order_num + 1 if self.order_num.nil?
+    end
+
+    # Methods
+
+    # Returns a list of all the values in the FIELDSET_CHILD_LIST constant
+    #
+    # @params [None]
+    # @returns [Array] An array of all the values stored in FIELDSET_CHILD_LIST
+    def fieldset_child_list
+      return FIELDSET_CHILD_LIST
+    end
+
+    # Sends a validation error if there are any duplicate pairings of fieldsets and fieldset children.
+    # 
+    # @params [None]
+    # @returns [Errors] In the case a duplicate pairing fieldsets and fieldset children are found, it returns a validation error.
+    def no_duplicate_fields_in_fieldset_children
+      if self.fieldset && self.child
+        duplicate_children = FieldsetChild.where(:fieldset_id => self.fieldset.id, :child_id => self.child_id, :child_type => self.child_type).select { |fieldset_child| fieldset_child.id != self.id }
+        if duplicate_children.length > 0
+          self.errors.add(:child_id, "There is already a copy of this child in the fieldset.")
+        end
+      end
+    end
+
+    # Sends a validation error if there is an attempt to save a fieldset as its own parent.
+    #
+    # @params [None]
+    # @returns [Errors] In the case a fieldset is its own parent a validation error is returned.
+    def cannot_be_own_parent
+      if self.child_type == "DynamicFieldsets::Fieldset"
+        if self.fieldset_id == self.child_id
+          self.errors.add(:child_id, "A fieldset cannot have itself as a parent.")
+        end
+      end
+    end
+
+    # Recursively looks to see if there is an attempt to save a fieldset as a descendent of itself
+    #
+    # @params [None]
+    # @returns [Errors] In the case a fieldset contains itself as a parent, a validation error is returned.
+    def no_parental_loop
+      if (self.child_type == "DynamicFieldsets::Fieldset") && (self.has_loop?([self.fieldset_id]))
+        self.errors.add(:child_id, "There is a fieldset that contains itself as a parent.")
+      end
+    end
+
+    # Recursively calls itself to span entire hierarchy of a fieldset child family to see if any attempts to have a parental loop exist
+    #
+    # @params [Array] parent_array - A collection of all previously checked parents. If a repeat parent is found, it returns false, else true.
+    # @returns [Boolean] If there are no parental loops, it returns true, else it returns true
+    def has_loop?(parent_array)
+      return true if parent_array.include? self.child_id
+      parent_array.push self.child_id
+      return true if FieldsetChild.where(:fieldset_id => self.child_id).find { |f| f.has_loop? parent_array }
+      parent_array.pop
+      return false
+    end
+    
+    scope :ordered, order( 'order_num asc' )
+    
+    # @return [ActiveRecord::Relation] Collection of FieldsetChildren that are direct descendents; ascending order.
+    def children
+      FieldsetChild.where( fieldset_id: self.child_id ).ordered
+    end
+    
+    # @return [ActiveRecord::Relation] Collection of FieldsetChildren that share the same parent; ascending order.
+    def siblings
+      sib = FieldsetChild.where( fieldset_id: self.fieldset_id ).ordered
+      sib.delete_if{ |child| child.id == self.id }
+      sib
+    end
+    
+    # @return [Integer] The order number of the last sibling.
+    def last_order_num
+      return 0 if siblings.empty?
+      return self.siblings.last[:order_num]
+    end
+    
+
+    def to_hash
+      return { "id" => self.id, "fieldset_id" => self.fieldset_id, "child_id" => self.child_id, "child_type" => self.child_type }
+    end
+
+    # Returns the root fieldset of the child
+    # Loops up the parent fieldset field until the parent is nil, then returns the child
+    #
+    # Important: This method is dependent on fieldsets not being reusable
+    #
+    # @return [Fieldset] The root fieldset of the fieldsetchild
+    def root_fieldset(fs = self.fieldset)
+      # whether the parent is a child
+      parent_as_a_child = FieldsetChild.where(:child_id => fs.id, :child_type => "DynamicFieldsets::Fieldset")
+      # my parent is nobody's child, it is the root
+      if parent_as_a_child.count == 0
+        return fs
+      else # if my parent is someone else's child, then
+        # look at her parent
+        return root_fieldset(parent_as_a_child.first.fieldset)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+<%= form_for field, :method => :post, :url => dynamic_fieldsets_enable_field_path(field) do |f| %>
+  <%= f.hidden_field :enabled, :value => !field.enabled %>
+  <%= f.submit field.enabled ? "Disable" : "Enable"  %>
+<% end %>

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

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