fe 0.0.4 → 2.0.0

data/app/models/{fe/concerns → concerns/fe}/choice_field_concern.rb

@@ -1,9 +1,11 @@
 require 'net/http'
+# :nocov:
 begin
   require 'xml/libxml'
 rescue LoadError
   require 'rexml/document'
 end
+# :nocov:
 
 module Fe
   module ChoiceFieldConcern
@@ -11,28 +13,50 @@ module Fe
 
     begin
       included do
-        has_many :elements, :class_name => "Element", :foreign_key => "choice_field_id", :dependent => :nullify#, :order => :position
+        has_many :elements, class_name: "Element", foreign_key: "choice_field_id", dependent: :nullify#, order: :position
+        serialize :rating_before_label_translations, Hash
+        serialize :rating_after_label_translations, Hash
+        serialize :rating_na_label_translations, Hash
       end
     rescue ActiveSupport::Concern::MultipleIncludedBlocks
     end
 
+    def rating_before_label(locale = nil)
+      rating_before_label_translations &&
+        rating_before_label_translations[locale].present? ?
+        rating_before_label_translations[locale] : self[:rating_before_label]
+    end
+
+    def rating_after_label(locale = nil)
+      rating_after_label_translations && 
+        rating_after_label_translations[locale].present? ?
+        rating_after_label_translations[locale] : self[:rating_after_label]
+    end
+
+    def rating_na_label(locale = nil)
+      rating_na_label_translations && 
+        rating_na_label_translations[locale].present? ?
+        rating_na_label_translations[locale] : self[:rating_na_label]
+    end
+
     # Returns choices stored one per line in content field
-    def choices
+    def choices(locale = nil)
       retVal = Array.new
       if ['yes-no', 'acceptance'].include?(self.style)
-        return [["Yes",1],["No",0]]
-      elsif !source.blank?
+        return [[_('Yes'),1],[_('No'),0]]
+      elsif source.present?
         begin
           doc = XML::Document.file(source)
           options = doc.find(text_xpath).collect { |n| n.content }
           values = doc.find(value_xpath).collect { |n| n.content }
           retVal = [options, values].transpose
-        rescue NameError
+        rescue NameError, LibXML::XML::Error
           doc = REXML::Document.new Net::HTTP.get_response(URI.parse(source)).body
-          retVal = [ doc.elements.collect(text_xpath){|c|c.text}, doc.elements.collect(value_xpath){|c|c.text} ].transpose.sort
+          retVal = [ doc.elements.collect(text_xpath){|c|c.text}, doc.elements.collect(value_xpath){|c|c.text} ].transpose
         end
-      elsif !content.nil?
-        content.split("\n").each do |opt|
+      elsif content.present?
+        choices = content(locale)
+        choices.split("\n").each do |opt|
           pair = opt.strip.split(";").reverse!
           pair[1] ||= pair[0]
           retVal << pair
@@ -41,19 +65,19 @@ module Fe
       return retVal
     end
 
-    def has_answer?(choice, app)
-      responses(app).each do |r|   # loop through Answers
-                                   # legacy field type choices may be int or tinyint
-                                   # raise r.inspect + ' - ' + choice.inspect if id == 1137 && r != 1
-                                   # r = r.to_s
-        return true if  case true
-                          when is_true(r) then is_true(choice)
-                          when is_false(r) then is_false(choice)
-                          else
-                            r.to_s == choice.to_s
-                        end
+    # choices can be an array, in which case any match returns true
+    def has_answer?(choice, answer_sheet)
+      if choice.is_a?(Array)
+        return choice.any? { |c| 
+          has_answer?(c, answer_sheet)
+        }
       end
-      false
+
+      responses(answer_sheet).any? { |r|
+        is_true(r) && is_true(choice) ||
+        is_false(r) && is_false(choice) ||
+        r.to_s.strip == choice.to_s.strip
+      }
     end
 
     # which view to render this element?
@@ -86,8 +110,8 @@ module Fe
     end
 
     # css class names for javascript-based validation
-    def validation_class(answer_sheet)
-      if self.required?(answer_sheet)
+    def validation_class(answer_sheet, page = nil)
+      if self.required?(answer_sheet, page)
         if self.style == 'drop-down'
           'validate-selection required'
         elsif self.style == 'rating'
@@ -102,9 +126,8 @@ module Fe
       end
     end
 
-    def display_response(app=nil)
+    def display_response(app = nil)
       r = responses(app)
-      r.reject! {|a| a.class == Answer && a.value.blank?}
       if r.blank?
         ""
       elsif self.style == 'yes-no'
@@ -117,25 +140,27 @@ module Fe
       elsif self.style == 'acceptance'
         "Accepted"  # if not blank, it's accepted
       else
-        r.compact.join(", ")
+        r.compact.join(', ')
       end
     end
 
     def conditional_match(answer_sheet)
-      displayed_response = display_response(answer_sheet)
-      (is_true(displayed_response) && is_true(conditional_answer)) ||
-        (is_false(displayed_response) && is_false(conditional_answer)) ||
-        (displayed_response == conditional_answer)
+      has_answer?(conditional_answers, answer_sheet) || 
+        (responses(answer_sheet).empty? && conditional_answers.empty?)
+    end
+
+    def is_response_false(answer_sheet)
+      is_false(display_response(answer_sheet))
     end
 
     protected
     def is_true(val)
-      [1,'1',true,'true','Yes','yes'].include?(val) # note: true = anything but false | nil
+      ['1','true','yes'].include?(val.to_s.downcase)
     end
 
     def is_false(val)
       # returns false if false (a bit odd)
-      [0,'0',false,'false','No','no'].include?(val)
+      ['0','false','no'].include?(val.to_s.downcase)
     end
 
   end

data/app/models/fe/address.rb

@@ -1,3 +1,3 @@
-class Fe::Address < ActiveRecord::Base
-  belongs_to :person
+class Fe::Address < ApplicationRecord
+  belongs_to :person, optional: true
 end

data/app/models/fe/answer.rb

@@ -7,7 +7,7 @@
 # may want special handling for ChoiceFields to store both id/slug and text representations
 
 module Fe
-  class Answer < ActiveRecord::Base
+  class Answer < ApplicationRecord
     include Fe::AnswerConcern
   end
 end

data/app/models/fe/answer_sheet.rb

@@ -1,5 +1,5 @@
 module Fe
-  class AnswerSheet < ActiveRecord::Base
+  class AnswerSheet < ApplicationRecord
     self.abstract_class = true
 
 =begin

data/app/models/fe/answer_sheet_question_sheet.rb

@@ -1,7 +1,7 @@
 module Fe
-  class AnswerSheetQuestionSheet < ActiveRecord::Base
+  class AnswerSheetQuestionSheet < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
     belongs_to :answer_sheet, class_name: Fe.answer_sheet_class
-    belongs_to :question_sheet, class_name: 'Fe::QuestionSheet'
+    belongs_to :question_sheet, optional: true, class_name: 'Fe::QuestionSheet'
   end
 end

data/app/models/fe/application.rb

@@ -2,14 +2,19 @@ require 'aasm'
 
 # a visitor applies to a sleeve (application)
 class Fe::Application < Fe::AnswerSheet
+
   self.table_name = "#{Fe.table_name_prefix}applications"
 
-  belongs_to :applicant, :class_name => "Person", :foreign_key => "applicant_id"
-  has_many :references, :class_name => 'ReferenceSheet', :foreign_key => :applicant_answer_sheet_id, :dependent => :destroy
-  has_one :answer_sheet_question_sheet, :foreign_key => "answer_sheet_id"
-  has_many :answer_sheet_question_sheets, :foreign_key => 'answer_sheet_id'
-  has_many :question_sheets, :through => :answer_sheet_question_sheets
-  
+  belongs_to :applicant, optional: true, foreign_key: 'person_id', class_name: "Person"
+  has_many :references, class_name: 'ReferenceSheet', foreign_key: :applicant_answer_sheet_id, dependent: :destroy
+  has_one :answer_sheet_question_sheet, foreign_key: "answer_sheet_id"
+  has_many :answer_sheet_question_sheets, foreign_key: 'answer_sheet_id'
+  has_many :question_sheets, through: :answer_sheet_question_sheets
+
+  has_paper_trail on: [], ignore: [:updated_at]
+
+  alias_method :all_references, :references
+
   # This will be overridden by the state machine defined in the enclosing app
   def completed?
     raise "completed? should be implemented by the extending class"
@@ -34,7 +39,7 @@ class Fe::Application < Fe::AnswerSheet
     end
     return Fe::ReferenceSheet.new()
   end
-  
+
   def answer_sheets
     a_sheets = [self]
     references.each do |r|
@@ -42,7 +47,7 @@ class Fe::Application < Fe::AnswerSheet
     end
     a_sheets
   end
-  
+
   def reference_answer_sheets
     r_sheets = Array.new()
     references.each do |r|
@@ -50,9 +55,9 @@ class Fe::Application < Fe::AnswerSheet
     end
     r_sheets
   end
-  
+
   def has_references?
     self.references.size > 0
   end
-  
+
 end

data/app/models/fe/condition.rb

@@ -3,17 +3,17 @@
 #                   i.e. "answer == 'yes'"
 # a question can have more than one answer (choose many) in which case ANY answer will do (find)
 module Fe
-  class Condition < ActiveRecord::Base
+  class Condition < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
     belongs_to :question_sheet
 
     belongs_to :trigger,
-               :class_name => "Question",
-               :foreign_key => "trigger_id"
+               class_name: "Question",
+               foreign_key: "trigger_id"
 
     validates_presence_of :expression
-    validates_length_of :expression, :maximum => 255, :allow_nil => true
+    validates_length_of :expression, maximum: 255, allow_nil: true
 
     # evaluate triggering element against expression and return match|nil
     def evaluate?

data/app/models/fe/date_field.rb

@@ -3,7 +3,7 @@
 module Fe
   class DateField < Question
 
-    def validation_class(answer_sheet = nil)
+    def validation_class(answer_sheet = nil, page = nil)
       if self.style == 'mmyy'
         'validate-selection ' + super
       else
@@ -35,7 +35,7 @@ module Fe
 
     def format_date_response(answer_sheet = nil)
       r = response(answer_sheet)
-      r = r.strftime("%m/%d/%Y") unless r.blank?
+      r = r.strftime("%Y-%m-%d") unless r.blank?
       r
     end
 

data/app/models/fe/element.rb

@@ -1,46 +1,79 @@
 # Element represents a section, question or content element on the question sheet
 module Fe
-  class Element < ActiveRecord::Base
+  class Element < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
+    attr_accessor :old_id
+
     belongs_to :question_grid,
-               :class_name => "Fe::QuestionGrid",
-               :foreign_key => "question_grid_id"
+               optional: true, class_name: "Fe::QuestionGrid"
+
+    belongs_to :question_grid_with_total,
+               optional: true, class_name: "Fe::QuestionGridWithTotal",
+               foreign_key: "question_grid_id"
 
     belongs_to :choice_field,
-               :class_name => "Fe::ChoiceField",
-               :foreign_key => "choice_field_id"
+               optional: true, class_name: "Fe::ChoiceField"
+
+    has_many :choice_field_children, foreign_key: 'choice_field_id',
+      class_name: 'Fe::Element'
 
-    belongs_to :question_sheet, :foreign_key => "related_question_sheet_id"
+    belongs_to :question_sheet, optional: true, foreign_key: "related_question_sheet_id"
 
-    belongs_to :conditional, :polymorphic => true
+    belongs_to :conditional, optional: true, polymorphic: true
 
     self.inheritance_column = :kind
 
-    has_many :page_elements, :dependent => :destroy
-    has_many :pages, :through => :page_elements
+    has_many :page_elements, dependent: :destroy
+    has_many :pages, through: :page_elements
 
-    scope :active, -> { select("distinct(#{Fe::Element.table_name}.id), #{Fe::Element.table_name}.*").where(Fe::QuestionSheet.table_name + '.archived' => false).joins({:pages => :question_sheet}) }
+    scope :active, -> { select("distinct(#{Fe::Element.table_name}.id), #{Fe::Element.table_name}.*").where(Fe::QuestionSheet.table_name + '.archived' => false).joins({pages: :question_sheet}) }
+    scope :questions, -> { where("kind NOT IN('Fe::Paragraph', 'Fe::Section', 'Fe::QuestionGrid', 'Fe::QuestionGridWithTotal')") }
+    scope :shared, -> { where(share: true) }
+    scope :grid_kinds, -> { where(kind: ['Fe::QuestionGrid', 'Fe::QuestionGridWithTotal']) }
+    scope :reference_kinds, -> { where(kind: 'Fe::ReferenceQuestion') }
 
     validates_presence_of :kind
     validates_presence_of :style
-    # validates_presence_of :label, :style, :on => :update
+    # validates_presence_of :label, :style, on: :update
 
-    validates_length_of :kind, :maximum => 40, :allow_nil => true
-    validates_length_of :style, :maximum => 40, :allow_nil => true
-    # validates_length_of :label, :maximum => 255, :allow_nil => true
+    validates_length_of :kind, maximum: 40, allow_nil: true
+    validates_length_of :style, maximum: 40, allow_nil: true
+    # validates_length_of :label, maximum: 255, allow_nil: true
 
-    before_validation :set_defaults, :on => :create
+    before_validation :set_defaults, on: :create
     before_save :set_conditional_element
+    after_save :update_page_all_element_ids
     after_save :update_any_previous_conditional_elements
 
+    serialize :label_translations, Hash
+    serialize :tip_translations, Hash
+    serialize :content_translations, Hash
+
     # HUMANIZED_ATTRIBUTES = {
-    #   :slug => "Variable"
+    #   slug: "Variable"
     # }changed.include?('address1')
     #
     # def self.human_attrib_name(attr)
     #   HUMANIZED_ATTRIBUTES[attr.to_sym] || super
     # end
+    def label(locale = nil)
+      label_translations[locale].present? ? label_translations[locale] : self[:label]
+    end
+
+    def content(locale = nil)
+      content_translations[locale].present? ? content_translations[locale] : self[:content]
+    end
+
+    def tooltip(locale = nil)
+      tip_translations[locale].present? ? tip_translations[locale] : self[:tooltip]
+    end
+
+    # returns all pages this element is on, whether that be directly, through a grid, or as a choice field conditional option
+    def pages_on
+      all_pages = pages.reload + [question_grid, question_grid_with_total, choice_field].compact.collect(&:pages_on)
+      all_pages.flatten.uniq
+    end
 
     def has_response?(answer_sheet = nil)
       false
@@ -52,7 +85,7 @@ module Fe
           unless eval("answer_sheet." + self.object_name + ".nil?")
             klass = eval("answer_sheet." + self.object_name + ".class")
             column = klass.columns_hash[self.attribute_name]
-            column.limit
+            return column.limit
           end
         rescue
           nil
@@ -61,24 +94,85 @@ module Fe
     end
 
     # assume each element is on a question sheet only once to make things simpler. if not, just take the first one
-    def previous_element(question_sheet)
-      page_element = page_elements.joins(page: :question_sheet).where("#{Fe::QuestionSheet.table_name}.id" => question_sheet.id).first
-      #binding.pry if page_element.nil?
-      return unless page_element
-      index = page_element.page.elements.index(self)
-      if index > 0 && prev_el = page_element.page.elements[index-1]
-        return prev_el
+    # NOTE: getting the previous_element isn't an expensive operation any more because of the all_elements_id cache
+    def previous_element(question_sheet, page = nil)
+      return false unless question_sheet
+      page ||= pages_on.detect{ |p| p.question_sheet == question_sheet }
+
+      index = page.all_element_ids_arr.index(self.id)
+      unless index
+        # this can happen for yesno options, since they're rendered as elements but aren't on the page or in a grid
+        # but just in case self is an element on the page and the element_ids got out of sync, rebuild the all_element_ids
+        # and try again
+        page.rebuild_all_element_ids
+        index = page.all_element_ids_arr.index(self.id)
+      end
+      if index && index > 0 && prev_el_id = page.all_element_ids_arr[index-1]
+        # occasionally the all_elements_ids_arr can get out of sync here, resulting in no element found
+        el = Fe::Element.find_by(id: prev_el_id)
+        unless el
+          page.rebuild_all_element_ids
+          index = page.all_element_ids_arr.index(self.id)
+          prev_el_id = page.all_element_ids_arr[index-1]
+          el = Fe::Element.find(prev_el_id) # give an error at this point if it's not found
+        end
+
+        return el
+      end
+    end
+
+    # return an array of all elements whose answers or visibility might affect
+    # the visibility of this element
+    def visibility_affecting_element_ids
+      return @visibility_affecting_element_ids if @visibility_affecting_element_ids
+
+      # the form doesn't change much so caching on the last updated element will
+      # provide a good balance of speed and cache invalidation
+      Rails.cache.fetch([self, 'element#visibility_affecting_element_ids', Fe::Element.order('updated_at desc, id desc').first]) do
+        elements = []
+
+        elements << question_grid if question_grid
+        elements << choice_field if choice_field
+        elements += Fe::Element.where(conditional_type: 'Fe::Element', conditional_id: id)
+        element_ids = elements.collect(&:id) +
+          elements.collect { |e| e.visibility_affecting_element_ids }.flatten
+        element_ids.uniq
       end
     end
 
-    def required?(answer_sheet = nil)
-      if answer_sheet && 
-        self.question_grid.nil? && 
-        (prev_el = previous_element(answer_sheet.question_sheet)) && 
-        prev_el.is_a?(Fe::Question) && 
-        prev_el.class != Fe::QuestionGrid && 
-        prev_el.conditional_match(answer_sheet)
+    def visibility_affecting_questions
+      Fe::Question.where(id: visibility_affecting_element_ids)
+    end
+
+    def hidden_by_conditional?(answer_sheet, page)
+      return false unless answer_sheet.question_sheets.include?(page.question_sheet)
+      prev_el = previous_element(page.question_sheet, page)
+      prev_el.is_a?(Fe::Question) &&
+        prev_el.conditional == self &&
+        !prev_el.conditional_match(answer_sheet)
+    end
+
+    def hidden_by_choice_field?(answer_sheet)
+      choice_field.present? &&
+        choice_field.is_a?(Fe::ChoiceField) &&
+        choice_field.is_response_false(answer_sheet)
+    end
+
+    # use page if it's passed in, otherwise it will revert to the first page in answer_sheet
+    def visible?(answer_sheet = nil, page = nil)
+      !hidden?(answer_sheet, page)
+    end
 
+    # use page if it's passed in, otherwise it will revert to the first page in answer_sheet
+    def hidden?(answer_sheet = nil, page = nil)
+      page ||= pages_on.detect{ |p| answer_sheet.question_sheets.include?(p.question_sheet) }
+      return true if !page || page.hidden?(answer_sheet)
+      return page.all_hidden_elements(answer_sheet).include?(self)
+    end
+
+    # use page if it's passed in, otherwise it will revert to the first page in answer_sheet
+    def required?(answer_sheet = nil, page = nil)
+      if answer_sheet && hidden?(answer_sheet, page)
         return false
       else
         required == true
@@ -87,7 +181,7 @@ module Fe
 
     def position(page = nil)
       if page
-        page_elements.where(:page_id => page.id).first.try(:position)
+        page_elements.where(page_id: page.id).first.try(:position)
       else
         self[:position]
       end
@@ -95,7 +189,7 @@ module Fe
 
     def set_position(position, page = nil)
       if page
-        pe = page_elements.where(:page_id => page.id).first
+        pe = page_elements.where(page_id: page.id).first
         pe.update_attribute(:position, position) if pe
       else
         self[:position] = position
@@ -130,8 +224,9 @@ module Fe
         when "Fe::ChoiceField"
           new_element.choice_field_id = parent.id
       end
-      new_element.save(:validate => false)
-      Fe::PageElement.create(:element => new_element, :page => page) unless parent
+      new_element.position = parent.elements.maximum(:position).to_i + 1 if parent
+      new_element.save!(validate: false)
+      Fe::PageElement.create(element: new_element, page: page) unless parent
 
       # duplicate children
       if respond_to?(:elements) && elements.present?
@@ -144,20 +239,29 @@ module Fe
     # include nested elements
     def all_elements
       if respond_to?(:elements)
-        (elements + elements.collect(&:all_elements)).flatten
+        elements.reload
+        #(elements + elements.collect(&:all_elements)).flatten
+        elements.collect{ |el|
+          [el, el.all_elements]
+        }.flatten
       else
         []
       end
     end
 
     def reuseable?
+      return false if Fe.never_reuse_elements
       (self.is_a?(Fe::Question) || self.is_a?(Fe::QuestionGrid) || self.is_a?(Fe::QuestionGridWithTotal))
     end
 
+    def conditional_answers
+      conditional_answer.split(';').collect(&:strip)
+    end
+
     def conditional_match(answer_sheet)
       displayed_response = display_response(answer_sheet)
       return false unless displayed_response && conditional_answer
-      (displayed_response.split(',') & conditional_answer.split(',')).length > 0
+      conditional_answers.include?(displayed_response)
     end
 
     def self.max_label_length
@@ -167,27 +271,79 @@ module Fe
     def set_conditional_element
       case conditional_type
       when "Fe::Element"
-        pages.reload.each do |page|
-          index = page.elements.index(self)
-          if index && index < page.elements.length - 1
-            self.conditional_id = page.elements[index+1].id
+        pages_on.each do |page|
+
+          if index = page.all_element_ids_arr.index(self.id)
+            self.conditional_id = page.all_element_ids_arr[index+1]
+          else
+            self.conditional_id = nil
           end
         end
+      when ""
+        # keep conditional_type nil instead of empty to be consistent
+        self.conditional_type = nil
       end
     end
 
     def update_any_previous_conditional_elements
-      pages.reload.each do |page|
-        index = page.elements.index(self)
+      pages_on.each do |page|
+        index = page.all_element_ids_arr.index(self.id)
         if index && index > 0
-          prev_el = page.elements[index-1]
+          prev_el = Fe::Element.find(page.all_element_ids_arr[index-1])
           if prev_el.conditional_type == "Fe::Element"
-            prev_el.update_attribute(:conditional_id, id)
+            prev_el.update_column(:conditional_id, id)
           end
         end
       end
     end
 
+    def update_page_all_element_ids
+      [question_grid, question_grid_with_total, choice_field].compact.each do |field|
+        field.update_page_all_element_ids
+      end
+
+      pages.reload.each do |p| p.rebuild_all_element_ids end
+    end
+
+    # matches in an AND method; if requested we can add a second filter method later
+    # to match on an OR basis
+    def matches_filter(filter)
+      filter.all? { |method| self.send(method) }
+    end
+
+    def css_classes
+      css_class.to_s.split(' ').collect(&:strip)
+    end
+
+    def self.create_from_import(element_data, page, question_sheet)
+      element_data[:old_id] = element_data.delete('id')
+      children = element_data.delete(:children)
+      element = element_data['kind'].constantize.create!(element_data)
+      question_sheet.element_id_mappings[element.old_id] = element.id
+      children.each do |child|
+        byebug unless child.class == Hash
+        child_element = create_from_import(child, page, question_sheet)
+        if child['choice_field_id'].present?
+          child_element.choice_field_id = element.id
+        end
+        byebug if child_element.label == 'Your Name:'
+        if child['question_grid_id'].present?
+          child_element.question_grid_id = element.id
+        end
+        child_element.save!
+      end
+      element
+    end
+
+    def export_hash
+      children = choice_field_children.collect(&:export_hash)
+      self.attributes.to_hash.merge(children: children)
+    end
+
+    def export_to_yaml
+      export_hash.to_yaml
+    end
+
     protected
 
     def set_defaults

data/app/models/fe/email_address.rb

@@ -1,7 +1,7 @@
 require 'validates_email_format_of'
-class Fe::EmailAddress < ActiveRecord::Base
+class Fe::EmailAddress < ApplicationRecord
   belongs_to :person
-  validates :email, :email_format => { :message => "doesn't look right." }
+  validates :email, email_format: { message: "doesn't look right." }
 
   self.table_name = "email_addresses"
 end

data/app/models/fe/email_template.rb

@@ -1,5 +1,5 @@
 module Fe
-  class EmailTemplate < ActiveRecord::Base
+  class EmailTemplate < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
     validates_presence_of :name