upgrade_surveyor 1.4.2

data/lib/generators/surveyor/templates/surveys/quiz.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+survey "Favorites" do
+  section "Foods" do
+    # In a quiz, both the questions and the answers need to have reference identifiers
+    # Here, the question has reference_identifier: "1", and the answers: "oint", "tweet", and "moo"
+    question_1 "What is the best meat?", :pick => :one, :correct => "oink"
+    a_oink "bacon"
+    a_tweet "chicken"
+    a_moo "beef"
+  end
+end

data/lib/generators/surveyor/templates/surveys/translations/languages.es.yml

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+title: "Un idioma nunca es suficiente"
+survey_sections:
+  one:
+    title: "Uno"
+  two:
+    title: "Dos"
+question_groups:
+  hello:
+    text: "¡Hola!"
+questions:
+  name:
+    text: "¿Cómo se llama Usted?"
+    answers:
+      name:
+        help_text: "Mi nombre es..."
+  color:
+    text: "¿Cuál es tu color favorito?"

data/lib/generators/surveyor/templates/surveys/translations/languages.he.yml

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+title: "ידיעת שפה אחת אינה מספיקה"
+survey_sections:
+  one:
+    title: "אחת"
+  two:
+    title: "שנים"
+question_groups:
+  hello:
+    text: "שלום"
+questions:
+  name:
+    text: "מה שמך?"
+    answers:
+      name:
+        help_text: "שמי..."
+  color:
+    text: "מהו הצבע האהוב עליך?"

data/lib/generators/surveyor/templates/surveys/translations/languages.ko.yml

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+title: "한가지 언어로는 충분치 않습니다."
+survey_sections:
+  one:
+    title: "하나"
+  two:
+    title: "두"
+question_groups:
+  hello:
+    text: "안녕하십니까"
+questions:
+  name:
+    text: "성함이 어떻게 되십니까?"
+    answers:
+      name:
+        help_text: "제 이름은 ... 입니다"
+  color:
+    text: "좋아하는 색은 무엇입니까?"

data/lib/generators/surveyor/templates/vendor/assets/stylesheets/custom.sass

@@ -0,0 +1,5 @@
+/* Add custom styles here. They will be
+ * loaded after the surveyor stylesheets */
+
+#surveyor
+ :font-family "Century Gothic"

data/lib/surveyor/acts_as_response.rb

@@ -0,0 +1,19 @@
+module Surveyor
+  module ActsAsResponse
+    extend ActiveSupport::Concern
+    
+    # Returns the response as a particular response_class type
+    def as(type_symbol)
+      return case type_symbol.to_sym
+      when :string, :text, :integer, :float, :datetime
+        self.send("#{type_symbol}_value".to_sym)
+      when :date
+        self.datetime_value.nil? ? nil : self.datetime_value.to_date
+      when :time
+        self.datetime_value.nil? ? nil : self.datetime_value.to_time
+      else # :answer_id
+        self.answer_id
+      end
+    end
+  end
+end

data/lib/surveyor/common.rb

@@ -0,0 +1,59 @@
+require 'securerandom'
+require 'uuidtools'
+
+module Surveyor
+  class Common
+    OPERATORS = %w(== != < > <= >= =~)
+
+    class << self
+      if SecureRandom.respond_to?(:urlsafe_base64)
+        def make_tiny_code
+          # 7 random bytes is increased to ~10 characters (sans padding) by
+          # base64 encoding
+          SecureRandom.urlsafe_base64(7)
+        end
+      else
+        def make_tiny_code
+          s = [SecureRandom.random_bytes(7)].pack("m*")
+          s.delete!("\n")
+          s.tr!("+/", "-_")
+          s.delete!("=")
+        end
+      end
+
+      def to_normalized_string(text)
+        words_to_omit = %w(a be but has have in is it of on or the to when)
+        col_text = text.to_s.gsub(/(<[^>]*>)|\n|\t/su, ' ') # Remove html tags
+        col_text.downcase!                            # Remove capitalization
+        col_text.gsub!(/\"|\'/u, '')                   # Remove potential problem characters
+        col_text.gsub!(/\(.*?\)/u,'')                  # Remove text inside parens
+        col_text.gsub!(/\W/u, ' ')                     # Remove all other non-word characters
+        cols = (col_text.split(' ') - words_to_omit)
+        (cols.size > 5 ? cols[-5..-1] : cols).join("_")
+      end
+
+      alias :normalize :to_normalized_string
+
+      def generate_api_id
+        UUIDTools::UUID.random_create.to_s
+      end
+
+      ##
+      # @private Intended for internal use only.
+      #
+      # Loads and uses either `FasterCSV` (for Ruby 1.8) or the stdlib `CSV`
+      # (for Ruby 1.9+).
+      #
+      # @return [Class] either `CSV` for `FasterCSV`.
+      def csv_impl
+        @csv_impl ||= if RUBY_VERSION < '1.9'
+                         require 'fastercsv'
+                         FasterCSV
+                       else
+                         require 'csv'
+                         CSV
+                       end
+      end
+    end
+  end
+end

data/lib/surveyor/engine.rb

@@ -0,0 +1,15 @@
+require 'rails'
+require 'surveyor'
+require 'haml' # required for view resolution
+
+module Surveyor
+  class Engine < Rails::Engine
+    root = File.expand_path('../../', __FILE__)
+    config.autoload_paths << root
+    config.to_prepare do
+      Dir.glob(File.expand_path('../../../app/inputs/*_input*.rb', __FILE__)).each do |c|
+        require_dependency(c)
+      end
+    end
+  end
+end

data/lib/surveyor/helpers/formtastic_custom_input.rb

@@ -0,0 +1,13 @@
+module Surveyor
+  module Helpers
+    module FormtasticCustomInput
+      def input_html_options_with(choice, response_class)
+        input_html_options.merge(choice_html_options(choice)).merge({:id => (input_html_options[:id] || "answer_id").gsub("answer_id", response_class_to_method(response_class).to_s), :class => [input_html_options[:class], response_class].join(" ")})
+      end
+      def response_class_to_method(type_sym)
+        # doesn't handle response_class == answer, and doesn't have to
+        "#{type_sym.to_s}_value".to_sym
+      end
+    end
+  end
+end

data/lib/surveyor/helpers/surveyor_helper_methods.rb

@@ -0,0 +1,86 @@
+module Surveyor
+  module Helpers
+    module SurveyorHelperMethods
+
+      # Layout: stylsheets and javascripts
+      def surveyor_includes
+        stylesheet_link_tag('surveyor_all') + javascript_include_tag('surveyor_all')
+      end
+      # Helper for displaying warning/notice/error flash messages
+      def flash_messages(types)
+        types.map{|type| content_tag(:div, "#{flash[type]}".html_safe, :class => type.to_s)}.join.html_safe
+      end
+      # Section: dependencies, menu, previous and next
+      def dependency_explanation_helper(question,response_set)
+        # Attempts to explain why this dependent question needs to be answered by referenced the dependent question and users response
+        trigger_responses = []
+        dependent_questions = Question.find_all_by_id(question.dependency.dependency_conditions.map(&:question_id)).uniq
+        response_set.responses.find_all_by_question_id(dependent_questions.map(&:id)).uniq.each do |resp|
+          trigger_responses << resp.to_s
+        end
+        "&nbsp;&nbsp;You answered &quot;#{trigger_responses.join("&quot; and &quot;")}&quot; to the question &quot;#{dependent_questions.map(&:text).join("&quot;,&quot;")}&quot;"
+      end
+      def menu_button_for(section)
+        submit_tag(section.translation(I18n.locale)[:title], :name => "section[#{section.id}]")
+      end
+      def previous_section
+        # use copy in memory instead of making extra db calls
+        prev_index = [(@sections.index(@section) || 0) - 1, 0].max
+        submit_tag(t('surveyor.previous_section').html_safe, :name => "section[#{@sections[prev_index].id}]") unless @sections[0] == @section
+      end
+      def next_section
+        # use copy in memory instead of making extra db calls
+        next_index = [(@sections.index(@section) || @sections.count) + 1, @sections.count].min
+        @sections.last == @section ? submit_tag(t('surveyor.click_here_to_finish').html_safe, :name => "finish") : submit_tag(t('surveyor.next_section').html_safe, :name => "section[#{@sections[next_index].id}]")
+      end
+
+      # Questions
+      def q_text(q, context=nil, locale=nil)
+        "#{next_question_number(q) unless (q.dependent? or q.display_type == "label" or q.display_type == "image" or q.part_of_group?)}#{q.text_for(nil, context, locale)}"
+      end
+
+      def next_question_number(question)
+        @n ||= 0
+        "<span class='qnum'>#{@n += 1}) </span>"
+      end
+
+      # Responses
+      def rc_to_attr(type_sym)
+        case type_sym.to_s
+        when /^answer$/ then :answer_id
+        else "#{type_sym.to_s}_value".to_sym
+        end
+      end
+
+      def rc_to_as(type_sym)
+        case type_sym.to_s
+        when /(integer|float|date|time|datetime)/ then :string
+        else type_sym
+        end
+      end
+
+      def generate_pick_none_input_html(value, default_value, css_class, response_class, disabled, input_mask, input_mask_placeholder)
+        html = {}
+        html[:class] = [response_class,css_class].reject{ |c| c.blank? }
+        html[:value] = value.blank? ? default_value : value
+        html[:disabled] = disabled unless disabled.blank?
+        if input_mask
+          html[:'data-input-mask'] = input_mask
+          html[:'data-input-mask-placeholder'] = input_mask_placeholder unless input_mask_placeholder.blank?
+        end
+        html
+      end
+
+      # Responses
+      def response_for(response_set, question, answer = nil, response_group = nil)
+        return nil unless response_set && question && question.id
+        result = response_set.responses.detect{|r| (r.question_id == question.id) && (answer.blank? ? true : r.answer_id == answer.id) && (r.response_group.blank? ? true : r.response_group.to_i == response_group.to_i)}
+        result.blank? ? response_set.responses.build(:question_id => question.id, :response_group => response_group) : result
+      end
+      def response_idx(increment = true)
+        @rc ||= 0
+        (increment ? @rc += 1 : @rc).to_s
+      end
+    end
+  end
+end

data/lib/surveyor/models/answer_methods.rb

@@ -0,0 +1,76 @@
+require 'surveyor/common'
+module Surveyor
+  module Models
+    module AnswerMethods
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      include MustacheContext
+      include ActiveModel::ForbiddenAttributesProtection
+
+      included do
+        # Associations
+        belongs_to :question
+        has_many :responses
+        has_many :validations, :dependent => :destroy
+        attr_accessible *PermittedParams.new.answer_attributes if defined? ActiveModel::MassAssignmentSecurity
+
+        # Validations
+        validates_presence_of :text
+      end
+
+      # Instance Methods
+      def initialize(*args)
+        super(*args)
+        default_args
+      end
+
+      def default_args
+        self.is_exclusive ||= false
+        self.display_type ||= "default"
+        self.response_class ||= "answer"
+        self.short_text ||= text
+        self.data_export_identifier ||= Surveyor::Common.normalize(text)
+        self.api_id ||= Surveyor::Common.generate_api_id
+      end
+      def display_type=(val)
+        write_attribute(:display_type, val.nil? ? nil : val.to_s)
+      end
+
+      def css_class
+        [(is_exclusive ? "exclusive" : nil), custom_class].compact.join(" ")
+      end
+
+      def text_for(position = nil, context = nil, locale = nil)
+        return "" if display_type == "hidden_label"
+        imaged(split(in_context(translation(locale)[:text], context), position))
+      end
+      def help_text_for(context = nil, locale = nil)
+        in_context(translation(locale)[:help_text], context)
+      end
+      def default_value_for(context = nil, locale = nil)
+        in_context(translation(locale)[:default_value], context)
+      end
+      def split(text, position=nil)
+        case position
+        when :pre
+          text.split("|",2)[0]
+        when :post
+          text.split("|",2)[1]
+        else
+          text
+        end.to_s
+      end
+      def translation(locale)
+        {:text => self.text, :help_text => self.help_text, :default_value => self.default_value}.with_indifferent_access.merge(
+          (self.question.translation(locale)[:answers] || {})[self.reference_identifier] || {}
+        )
+      end
+
+      private
+
+      def imaged(text)
+        self.display_type == "image" && !text.blank? ? ActionController::Base.helpers.image_tag(text) : text
+      end
+    end
+  end
+end

data/lib/surveyor/models/dependency_condition_methods.rb

@@ -0,0 +1,65 @@
+module Surveyor
+  module Models
+    module DependencyConditionMethods
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      include Surveyor::ActsAsResponse # includes "as" instance method
+      include ActiveModel::ForbiddenAttributesProtection
+
+      included do
+        # Associations
+        belongs_to :answer
+        belongs_to :dependency
+        belongs_to :dependent_question, :foreign_key => :question_id, :class_name => :question
+        belongs_to :question
+        attr_accessible *PermittedParams.new.dependency_condition_attributes if defined? ActiveModel::MassAssignmentSecurity
+
+        # Validations
+        validates_presence_of :operator, :rule_key
+        validate :validates_operator
+        validates_uniqueness_of :rule_key, :scope => :dependency_id
+      end
+
+      module ClassMethods
+        def operators
+          Surveyor::Common::OPERATORS
+        end
+      end
+
+      # Instance methods
+      def to_hash(response_set)
+        # all responses to associated question
+        responses = question.blank? ? [] : response_set.responses.where("responses.answer_id in (?)", question.answer_ids)
+        if self.operator.match /^count(>|>=|<|<=|==|!=)\d+$/
+          op, i = self.operator.scan(/^count(>|>=|<|<=|==|!=)(\d+)$/).flatten
+          # logger.warn({rule_key.to_sym => responses.count.send(op, i.to_i)})
+          return {rule_key.to_sym => (op == "!=" ? !responses.count.send("==", i.to_i) : responses.count.send(op, i.to_i))}
+        elsif operator == "!=" and (responses.blank? or responses.none?{|r| r.answer.id == self.answer.id})
+          # logger.warn( {rule_key.to_sym => true})
+          return {rule_key.to_sym => true}
+        elsif response = responses.to_a.detect{|r| r.answer.id == self.answer.id}
+          klass = response.answer.response_class
+          klass = "answer" if self.as(klass).nil? # it should compare answer ids when the dependency condition *_value is nil
+          case self.operator
+          when "==", "<", ">", "<=", ">="
+            # logger.warn( {rule_key.to_sym => response.as(klass).send(self.operator, self.as(klass))})
+            return {rule_key.to_sym => !response.as(klass).nil? && response.as(klass).send(self.operator, self.as(klass))}
+          when "!="
+            # logger.warn( {rule_key.to_sym => !response.as(klass).send("==", self.as(klass))})
+            return {rule_key.to_sym => !response.as(klass).send("==", self.as(klass))}
+          end
+        end
+        # logger.warn({rule_key.to_sym => false})
+        {rule_key.to_sym => false}
+      end
+
+    protected
+
+      def validates_operator
+        errors.add(:operator, "Invalid operator") unless
+          Surveyor::Common::OPERATORS.include?(self.operator) ||
+            self.operator && self.operator.match(/^count(<|>|==|>=|<=|!=)(\d+)/)
+      end
+    end
+  end
+end

data/lib/surveyor/models/dependency_methods.rb

@@ -0,0 +1,57 @@
+module Surveyor
+  module Models
+    module DependencyMethods
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      include ActiveModel::ForbiddenAttributesProtection
+
+      included do
+        # Associations
+        belongs_to :question
+        belongs_to :question_group
+        has_many :dependency_conditions, :dependent => :destroy
+        attr_accessible *PermittedParams.new.dependency_attributes if defined? ActiveModel::MassAssignmentSecurity
+
+        # Validations
+        validates_presence_of :rule
+        validates_format_of :rule, :with => /\A(?:and|or|\)|\(|[A-Z]|\s)+\Z/ #TODO properly formed parenthesis etc.
+        validates_numericality_of :question_id, :if => Proc.new { |d| d.question_group_id.nil? }
+        validates_numericality_of :question_group_id, :if => Proc.new { |d| d.question_id.nil? }
+
+        # Attribute aliases
+        alias_attribute :dependent_question_id, :question_id
+      end
+
+      # Instance Methods
+      def question_group_id=(i)
+        write_attribute(:question_id, nil) unless i.nil?
+        write_attribute(:question_group_id, i)
+      end
+
+      def question_id=(i)
+        write_attribute(:question_group_id, nil) unless i.nil?
+        write_attribute(:question_id, i)
+      end
+
+      # Has this dependency has been met in the context of response_set?
+      # Substitutes the conditions hash into the rule and evaluates it
+      def is_met?(response_set)
+        ch = conditions_hash(response_set)
+        return false if ch.blank?
+        # logger.debug "rule: #{self.rule.inspect}"
+        # logger.debug "rexp: #{rgx.inspect}"
+        # logger.debug "keyp: #{ch.inspect}"
+        # logger.debug "subd: #{self.rule.gsub(rgx){|m| ch[m.to_sym]}}"
+        rgx = Regexp.new(self.dependency_conditions.map{|dc| ["a","o"].include?(dc.rule_key) ? "\\b#{dc.rule_key}(?!nd|r)\\b" : "\\b#{dc.rule_key}\\b"}.join("|")) # exclude and, or
+        eval(self.rule.gsub(rgx){|m| ch[m.to_sym]})
+      end
+
+      # A hash of the conditions (keyed by rule_key) and their evaluation (boolean) in the context of response_set
+      def conditions_hash(response_set)
+        hash = {}
+        self.dependency_conditions.each{|dc| hash.merge!(dc.to_hash(response_set))}
+        return hash
+      end
+    end
+  end
+end