quby-compiler 0.2.1

data/lib/quby/compiler/entities/flag.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      class Flag < Struct.new(:key, :description_true, :description_false, :description, :internal, :trigger_on,
+                              :shows_questions, :hides_questions, :depends_on, :default_in_interface)
+        # rubocop:disable ParameterLists
+        def initialize(key:,
+                       description_true: nil,
+                       description_false: nil,
+                       description: nil,
+                       internal: false,
+                       trigger_on: true,
+                       shows_questions: [],
+                       hides_questions: [],
+                       depends_on: nil, # used in interface to hide this flag unless the depended on flag is set to true
+                       default_in_interface: nil) # used in interface to set a default for the flag state,
+                                                  # does not have an effect outside of the interface
+          super(key, description_true, description_false, description, internal, trigger_on, shows_questions,
+                hides_questions, depends_on, default_in_interface)
+          ensure_valid_descriptions
+        end
+        # rubocop:enable ParameterLists
+
+        def if_triggered_by(answer_flags)
+          yield if answer_flags[key] == trigger_on
+        end
+
+        def variable_description
+          "#{description} (true - '#{description_true}', false - '#{description_false}')"
+        end
+
+        def to_codebook(_options = {})
+          output = []
+          output << "#{key} flag"
+          output << "'#{description}'" if description.present?
+          output << " 'true' - #{description_true}"
+          output << " 'false' - #{description_false}"
+          output << " '' (leeg) - Vlag niet ingesteld, informatie onbekend"
+          output << ""
+          output.join("\n")
+        end
+
+        private
+
+        def ensure_valid_descriptions
+          unless (description_false.present? && description_true.present?) || description.present?
+            raise "Flag '#{key}' Requires at least either both description_true and description_false or a description"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/item.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module Quby
+  module Compiler
+    module Entities
+      class Item
+        include ActiveModel::Validations
+        include ActiveSupport::Callbacks
+        define_callbacks :after_dsl_enhance
+
+        attr_accessor :presentation
+        attr_accessor :switch_cycle
+
+        # Raw content may contain a raw HTML replacement for this item
+        attr_accessor :raw_content
+
+        def initialize(options = {})
+          @raw_content = options[:raw_content]
+          @switch_cycle = options[:switch_cycle] || false
+        end
+
+        def presentation
+          @presentation || "vertical"
+        end
+
+        def as_json(options = {})
+          {
+            class: self.class.to_s
+          }
+        end
+
+        def to_codebook(questionnaire, options = {})
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/lookup_tables.rb

@@ -0,0 +1,71 @@
+require 'csv'
+
+module Quby
+  module Compiler
+    module Entities
+      class LookupTables
+        def initialize(path)
+          @path = path
+        end
+
+        def fetch(key)
+          csv_path = File.join(@path, "#{key}.csv")
+          data = CSV.read(csv_path, col_sep: ';', skip_blanks: true)
+          headers = data.shift
+          compare = data.shift
+          self.class.from_csv(levels: headers, compare: compare, data: data)
+        end
+
+        # load csv data into a tree.
+        # each row is a path through the tree.
+        # String and float types are used to make an exact match.
+        # A range is always a range between two floats where the range is between
+        # the low value (inclusive) and the high value (exclusive),
+        # written as 4:5 (low:high). These boundaries can be given as floats or
+        # integers, but internally they are always treated as a floats.
+        # The low and high values of a range cannot be equal.
+        # Use minfinity or infinity to create infinite ranges.
+        #
+        # @params levels [Array<String>] An array of column names
+        # @param compare [Array<String>]An array of lookup types (string, float or range) for each column
+        # @param data [Array<Array<>>] The rows describing a path through the tree.
+        def self.from_csv(levels:, compare:, data:)
+          tree = data.each_with_object({}) do |row, tree|
+            add_to_tree(tree, row, levels, compare)
+          end
+          {levels: levels, tree: tree}
+        end
+
+        private
+
+        def self.add_to_tree(tree, (value, *path), (level, *levels), (compare, *compares))
+          key = case compare
+                when 'string' then value.to_s
+                when 'float' then parse_float(value)
+                when 'range' then create_range(value)
+                end
+
+          if levels.empty?
+            return key
+          end
+
+          tree.merge! key => add_to_tree(tree[key] || {}, path, levels, compares)
+        end
+
+        def self.create_range(value)
+          min, max = value.split(':').map { |val| parse_float(val) }
+          fail 'Cannot create range between two equal values' if min == max
+          (min...max)
+        end
+
+        def self.parse_float(value)
+          case value
+          when 'infinity'  then Float::INFINITY
+          when 'minfinity' then -Float::INFINITY
+          else Float(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/outcome_table.rb

@@ -0,0 +1,31 @@
+module Quby
+  module Compiler
+    module Entities
+      # OutcomeTable describes how scores are formatted in a table in outcome views
+      # @param key [Symbol] key to reference this outcome table by
+      # @param score_keys [Array<Symbol>] which scores are selected for the rows of the table
+      # @param subscore_keys [Array<Symbol>] which subscores (:value, :interpretation etc.) make up the table columns
+      # @param name [String] a title that will be shown above the table
+      # @param default_collapsed [Boolean] if true, collapses the table to only show the name by default
+      # @param questionnaire [Questionnaire] for validating score keys and subscore keys according to its score_schema
+      class OutcomeTable
+        include ActiveModel::Model
+        attr_accessor :score_keys, :subscore_keys, :name, :default_collapsed, :questionnaire, :key
+
+        validates :score_keys, :subscore_keys, :questionnaire, :key, presence: true
+        validates :name, presence: true, if: proc { |table| table.default_collapsed }
+        validate :references_existing_score_keys
+
+        def references_existing_score_keys
+          (score_keys - questionnaire.score_schemas.values.map(&:key)).each do |missing_key|
+            errors.add :score_keys, "#{missing_key.inspect} not found in score schemas"
+          end
+          existing_subscore_keys = questionnaire.score_schemas.values.flat_map(&:subscore_schemas).map(&:key)
+          (subscore_keys - existing_subscore_keys).each do |missing_key|
+            errors.add :subscore_keys, "#{missing_key.inspect} not found in subscore schemas"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/panel.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities'
+
+module Quby
+  module Compiler
+    module Entities
+      class Panel < Item
+        attr_accessor :title
+        attr_accessor :items
+        attr_accessor :key
+        attr_reader :questionnaire
+
+        def initialize(options = {})
+          @questionnaire = options[:questionnaire]
+          @title = options[:title]
+          @key = options[:key]
+          @items = options[:items] || []
+        end
+
+        def as_json(options = {})
+          super.merge(title: title, index: index, items: json_items)
+        end
+
+        def index
+          @questionnaire.panels.index(self)
+        end
+
+        def next
+          this_panel_index = index
+
+          if this_panel_index < @questionnaire.panels.size
+            return @questionnaire.panels[this_panel_index + 1]
+          else
+            nil
+          end
+        end
+
+        def prev
+          this_panel_index = index
+
+          if this_panel_index > 0
+            return @questionnaire.panels[this_panel_index - 1]
+          else
+            nil
+          end
+        end
+
+        def json_items
+          items.map do |item|
+            case item
+            when Text
+              { type: 'html', html: item.html }
+            when Question
+              next if item.table # things inside a table are added to the table, AND ALSO to the panel. skip them.
+              { type: 'question', key: item.key }
+            when Table
+              { type: "table" }
+            end
+          end.compact
+        end
+
+        def validations
+          vals = {}
+          items.each do |item|
+            if item.is_a? Question
+              item.options.each do |opt|
+                if opt.questions
+                  opt.questions.each do |q|
+                    vals[q.key] = q.validations
+                  end
+                end
+              end
+              vals[item.key] = item.validations
+            end
+          end
+          vals
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/question.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/item'
+
+module Quby
+  module Compiler
+    module Entities
+      class Question < Item
+        MARKDOWN_ATTRIBUTES = %w(description title).freeze
+
+        set_callback :after_dsl_enhance, :expand_depends_on_input_keys
+
+        # Standard attributes
+        attr_accessor :key
+        validates :key, presence: true, 'quby/type': {is_a: Symbol}
+        attr_accessor :sbg_key
+        attr_accessor :questionnaire
+        attr_accessor :title
+        attr_accessor :context_free_title
+        attr_accessor :description
+
+        attr_accessor :labels
+
+        # What kind of question is this?
+        attr_accessor :type
+
+        # How should we display this question
+        attr_accessor :as
+
+        # To hide old questions
+        attr_accessor :hidden
+
+        # Whether to skip the uniqueness validation on radio and select option values
+        attr_reader :allow_duplicate_option_values
+
+        # In what modes do we display this question
+        # NOTE We always display questions in print-view (if they have an answer)
+        attr_accessor :display_modes
+
+        # Multiple-choice questions have options to choose from
+        attr_accessor :options
+
+        # Question validation fails when there are no title and no context_free_title.
+        # When :allow_blank_titles => true passed, validation does not fail. Any other value will raise the failure.
+        attr_accessor :allow_blank_titles
+
+        # Minimum and maximum values for float and integer types
+        attr_accessor :minimum
+        attr_accessor :maximum
+
+        # Whether the browser should autocomplete this question (off by default)
+        attr_accessor :autocomplete
+
+        # Whether we show the value for each option
+        # :all => in all questionnaire display modes
+        # :none => in none of display modes
+        # :paged => for only in :paged display mode
+        # :bulk => for only in :bulk display mode
+        attr_accessor :show_values
+        validates :show_values, inclusion: {
+          in: [:all, :none, :paged, :bulk, :print],
+          message: "option invalid: %{value}. Valid options: :all, :none, :paged, :bulk)" }
+
+        # Structuring
+        attr_accessor :validations
+        attr_accessor :dependencies
+
+        # To display unit for number items
+        attr_accessor :unit
+        # To specify size of string/number input boxes
+        attr_accessor :size
+
+        # Whether this radio question is deselectable
+        attr_accessor :deselectable
+
+        # Some questions are a tree.
+        attr_accessor :parent
+        attr_accessor :parent_option_key
+
+        # Whether we can collapse this in bulk view
+        attr_accessor :disallow_bulk
+
+        # This question should not validate itself unless the depends_on question is answered.
+        # May also be an array of "#{question_key}_#{option_key}" strings that specify options
+        # this question depends on.
+        attr_accessor :depends_on
+
+        # Extra data hash to store on the question item's html element
+        attr_accessor :extra_data
+
+        # data-attributes for the input tag.
+        attr_accessor :input_data
+
+        # Whether we use the :description, the :value or :none for the score header above this question
+        attr_accessor :score_header
+
+        # options for grouping questions and setting a minimum or maximum number of answered questions in the group
+        attr_accessor :question_group
+        attr_accessor :group_minimum_answered
+        attr_accessor :group_maximum_answered
+
+        # Text variable name that will be replaced with the answer to this question
+        # In all following text elements that support markdown
+        attr_accessor :sets_textvar
+
+        # Amount of rows and cols a textarea has
+        attr_accessor :lines
+        attr_accessor :cols
+
+        # Table this question might belong to
+        attr_accessor :table
+
+        # In case of being displayed inside a table, amount of columns/rows to span
+        attr_accessor :col_span
+        attr_accessor :row_span
+
+        attr_accessor :default_invisible
+
+        # Slider only: where to place the sliding thing by default
+        # Can have value :hidden for a hidden handle.
+        attr_accessor :default_position
+
+        ##########################################################
+
+        # rubocop:disable CyclomaticComplexity, Metrics/MethodLength
+        def initialize(key, options = {})
+          super(options)
+
+          @extra_data ||= {}
+          @options = []
+          @allow_duplicate_option_values = options[:allow_duplicate_option_values]
+          @questionnaire = options[:questionnaire]
+          @key = key
+          @sbg_key = options[:sbg_key]
+          @type = options[:type]
+          @as = options[:as]
+          @title = options[:title]
+          @context_free_title = options[:context_free_title]
+          @allow_blank_titles = options[:allow_blank_titles]
+          @description = options[:description]
+          @display_modes = options[:display_modes]
+          @presentation = options[:presentation]
+          @validations = []
+          @parent = options[:parent]
+          @hidden = options[:hidden]
+          @table = options[:table]
+          @parent_option_key = options[:parent_option_key]
+          @autocomplete = options[:autocomplete] || "off"
+          @show_values = options[:show_values] || :bulk
+          @deselectable = (options[:deselectable].nil? || options[:deselectable])
+          @disallow_bulk = options[:disallow_bulk]
+          @score_header = options[:score_header] || :none
+          @sets_textvar = "#{questionnaire.key}_#{options[:sets_textvar]}" if options[:sets_textvar]
+          @unit = options[:unit]
+          @lines = options[:lines] || 6
+          @cols = options[:cols] || 40
+          @default_invisible = options[:default_invisible] || false
+          @labels ||= []
+
+          @col_span = options[:col_span] || 1
+          @row_span = options[:row_span] || 1
+
+          set_depends_on(options[:depends_on])
+
+          @question_group = options[:question_group]
+          @group_minimum_answered = options[:group_minimum_answered]
+          @group_maximum_answered = options[:group_maximum_answered]
+
+          @input_data = {}
+          @input_data[:value_tooltip] = true if options[:value_tooltip]
+
+          # Require subquestions of required questions by default
+          options[:required] = true if @parent&.validations&.first&.fetch(:type, nil) == :requires_answer
+          @validations << {type: :requires_answer, explanation: options[:error_explanation]} if options[:required]
+
+          if @type == :float
+            @validations << {type: :valid_float, explanation: options[:error_explanation]}
+          elsif @type == :integer
+            @validations << {type: :valid_integer, explanation: options[:error_explanation]}
+          end
+
+          if options[:minimum] and (@type == :integer || @type == :float)
+            fail "deprecated" # pretty sure this is not used anywhere
+          end
+          if options[:maximum] and (@type == :integer || @type == :float)
+            fail "deprecated" # pretty sure this is not used anywhere
+          end
+          @default_position = options[:default_position]
+
+          if @question_group
+            if @group_minimum_answered
+              @validations << {type: :answer_group_minimum, group: @question_group, value: @group_minimum_answered,
+                               explanation: options[:error_explanation]}
+            end
+            if @group_maximum_answered
+              @validations << {type: :answer_group_maximum, group: @question_group, value: @group_maximum_answered,
+                               explanation: options[:error_explanation]}
+            end
+          end
+        end
+        # rubocop:enable CyclomaticComplexity, Metrics/MethodLength
+
+        # rubocop:disable AccessorMethodName
+        def set_depends_on(keys)
+          return if keys.blank?
+          keys = [keys] unless keys.is_a?(Array)
+          @depends_on = keys
+        end
+        # rubocop:enable AccessorMethodName
+
+        def context_free_title
+          @context_free_title || @title
+        end
+
+        def expand_depends_on_input_keys
+          return unless @depends_on
+          @depends_on = questionnaire.expand_input_keys(@depends_on)
+          @extra_data[:"depends-on"] = @depends_on.to_json
+        rescue => e
+          raise e.class, "Question #{key} depends_on contains an error: #{e.message}"
+        end
+
+        def col_span
+          options.length > 0 && type != :select ? options.length : @col_span
+        end
+
+        def as_json(options = {})
+          # rubocop:disable SymbolName
+          super.merge(
+            key: key,
+            title: Quby::MarkdownParser.new(title).to_html,
+            description: Quby::MarkdownParser.new(description).to_html,
+            type: type,
+            unit: unit,
+            size: size,
+            hidden: hidden?,
+            displayModes: display_modes,
+            defaultInvisible: default_invisible,
+            viewSelector: view_selector,
+            parentKey: parent&.key,
+            parentOptionKey: parent_option_key,
+            deselectable: deselectable,
+            presentation: presentation,
+            as: as,
+            questionGroup: question_group
+          )
+        end
+
+        # Returns all keys belonging to html inputs generated by this question.
+        def input_keys
+          if options.blank?
+            answer_keys
+          else
+            # Some options don't have a key (inner_title), they are stripped
+            options.map { |opt| opt.input_key }.compact
+          end
+        end
+
+        def key_in_use?(k)
+          claimed_keys.include?(k) ||
+          options.any? { |option| option.key_in_use?(k) }
+        end
+
+        # The keys this question claims as his own. Not including options and subquestions.
+        # Includes keys for the question, inputs and answers.
+        def claimed_keys
+          [key]
+        end
+
+        # Returns all possible answer keys of this question (excluding subquestions, including options).
+        # radio/select/scale-options do not create answer_keys, but answer values.
+        def answer_keys
+          [key]
+        end
+
+        def default_position
+          return unless as == :slider
+          half = (type == :float) ? 2.0 : 2
+          @default_position || ((minimum + maximum) / half if minimum && maximum)
+        end
+
+        def minimum
+          validations.find { |i| i[:type] == :minimum }.try(:fetch, :value)
+        end
+
+        def maximum
+          validations.find { |i| i[:type] == :maximum }.try(:fetch, :value)
+        end
+
+        def html_id
+          "answer_#{key}_input"
+        end
+
+        def view_selector
+          table.blank? ? "#item_#{key}" : "[data-for=#{key}], #answer_#{key}_input"
+        end
+
+        def hidden?
+          hidden
+        end
+
+        def show_values_in_mode?(mode)
+          case show_values
+          when :none then false
+          when :all then true
+          else show_values == mode
+          end
+        end
+
+        def subquestions
+          options.map { |opt| opt.questions }.flatten
+        end
+
+        def subquestion?
+          !parent_option_key.nil?
+        end
+
+        def to_codebook(questionnaire, opts = {})
+          output = []
+          question_key = codebook_key(key, questionnaire, opts)
+          output << "#{question_key} #{codebook_output_type} #{codebook_output_range}#{' deprecated' if hidden}"
+          output << "\"#{context_free_title}\"" unless context_free_title.blank?
+          options_string = options.map do |option|
+            option.to_codebook(questionnaire, opts)
+          end.compact.join("\n")
+          output << options_string unless options.blank?
+          output.join("\n")
+        end
+
+        def codebook_key(key, questionnaire, opts = {})
+          key.to_s.gsub(/^v_/, "#{opts[:roqua_key] || questionnaire.key.to_s}_")
+        end
+
+        def codebook_output_type
+          type
+        end
+
+        def codebook_output_range
+          range_min = validations.find { |i| i[:type] == :minimum }&.fetch(:value, nil)
+          range_max = validations.find { |i| i[:type] == :maximum }&.fetch(:value, nil)
+
+          if range_min || range_max
+            "(#{[range_min, "value", range_max].compact.join(" &lt;= ")})"
+          else
+            ""
+          end
+        end
+
+        def variable_descriptions
+          {key => context_free_title}.with_indifferent_access
+        end
+      end
+    end
+  end
+end
+
+require 'quby/compiler/entities/questions/checkbox_question'
+require 'quby/compiler/entities/questions/date_question'
+require 'quby/compiler/entities/questions/deprecated_question'
+require 'quby/compiler/entities/questions/float_question'
+require 'quby/compiler/entities/questions/integer_question'
+require 'quby/compiler/entities/questions/radio_question'
+require 'quby/compiler/entities/questions/select_question'
+require 'quby/compiler/entities/questions/string_question'
+require 'quby/compiler/entities/questions/text_question'