quby 5.7.0 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edca9871e52f3dd5b65020d10d925875fc4fd300f7d69c088d7a9c49879a3b01
-  data.tar.gz: 1234e7289f810b043ec01d63d70a54a2d740489c1bd3b75c33c5f21fb5ae61df
+  metadata.gz: b9483f92750ebd1f166c443e1ed65e523c3095c37f1702a3bd905ceeff9c18af
+  data.tar.gz: e7cb4bf5cb35ecea8576704f9743ccc8fafea60fcb460dae99348107c3f4aca2
 SHA512:
-  metadata.gz: ec5c20dae4a565c65dc2bce7641ea1319a1b5fe53cb68d12bc10d639223bc4b8f476b999b50a9df1324a2b79b23031413b530a12a91b24146b2c868446bc4e11
-  data.tar.gz: 3c7878f7dca5965fce07753b45bf3827409bf74acc4597c8cb83c93949510c049571c92b5dae9913103d74f756a1822ed6643ed0612adec15c1b31028ff0dd3a
+  metadata.gz: b2b12c2ea7ff49aa3b4f75221aab71a12d16117e3a12bad555f2c60ebe8e7b1d32e27e6435bc45d15afc66a81243774acc95a85e1e583b85bf9d4aae658c6730
+  data.tar.gz: 0e8b954afa97a10310fc444cc49cde75971ae58e8d1450b989e0bec9a921add8d36290976648003db0de14661140c210781c61b162de93af7ffb33b80a161b09

data/lib/quby/answers/services/outcome_calculation.rb

@@ -40,7 +40,7 @@ module Quby
               results[key] = {missing_values: exception.missing}
             rescue StandardError => exception
               if defined? Roqua::Support::Errors
-                Roqua::Support::Errors.report exception, root_path: Rails.root.to_s
+                Roqua::Support::Errors.report exception, root_path: Rails.root, questionnaire: answer.questionnaire.key, score: key
               end
               results[key] = {exception: exception.message,
                               backtrace: exception.backtrace}

data/lib/quby/answers/services/score_calculator.rb

@@ -62,6 +62,7 @@ module Quby
         # Public: Get values for given question keys
         #
         # *keys - A list or array of keys for which to return values
+        # *missing_values - extra values to consider missing.
         #
         # Returns an Array of values. Values are whatever they may be defined as,
         # usually they are either Integers of Floats, but remember that no such
@@ -70,9 +71,9 @@ module Quby
         # Returns hash of all values if no keys are given.
         #
         # Raises MissingAnswerValues if one or more keys doesn't have a value.
-        def values(*keys)
+        def values(*keys, missing_values: [])
           keys = keys.flatten(1).map(&:to_s)
-          ensure_answer_values_for(keys)
+          ensure_answer_values_for(keys, missing_values:)
           values_with_nils(keys)
         end
 
@@ -81,6 +82,7 @@ module Quby
         # *keys - A list or array of keys for which to return values - required.
         # *minimum_present - see Raises.
         # *missing_values - extra values to consider missing.
+        # *replace_missings_with* - instead of removing, replace missing values with this one (can replace with nil, default :remove)
         #
         # Returns an Array of values. Values are whatever they may be defined as,
         # usually they are either Integers of Floats, but remember that no such
@@ -88,13 +90,19 @@ module Quby
         # be a String.
         #
         # Raises MissingAnswerValues when less than minimum_present keys have a value.
-        def values_without_missings(*keys, minimum_present: 1, missing_values: [])
+        def values_without_missings(*keys, minimum_present: 1, missing_values: [], replace_missings_with: :remove)
           keys = keys.flatten(1).map(&:to_s)
           fail ArgumentError, 'keys empty' unless keys.present?
 
           ensure_answer_values_for(keys, minimum_present: minimum_present, missing_values: missing_values)
-          values_with_nils(keys).reject do |v|
-            missing_value?(v, missing_values: missing_values)
+          if replace_missings_with == :remove
+            values_with_nils(keys).reject { |v|
+              missing_value?(v, missing_values: missing_values)
+            }
+          else
+            values_with_nils(keys).map { |v| 
+              missing_value?(v, missing_values: missing_values) ? replace_missings_with : v
+            }
           end
         end
 

data/lib/quby/questionnaires/deserializer.rb

@@ -8,18 +8,12 @@ module Quby
         # TODO: last_update
         Entities::Questionnaire.new(json.fetch("key"), json).tap do |questionnaire|
           questionnaire.title = json.fetch("title")
-          questionnaire.description = json.fetch("description")
-          questionnaire.outcome_description = json.fetch("outcome_description")
-          questionnaire.short_description = json.fetch("short_description")
           questionnaire.abortable = json.fetch("abortable")
           questionnaire.enable_previous_questionnaire_button = json.fetch("enable_previous_questionnaire_button")
           questionnaire.default_answer_value = json.fetch("default_answer_value")
           questionnaire.leave_page_alert = json.fetch("leave_page_alert")
           questionnaire.allow_hotkeys = json.fetch("allow_hotkeys")
-          questionnaire.license = json.fetch("license")&.to_sym
-          questionnaire.licensor = json.fetch("licensor")
           questionnaire.language = json.fetch("language").try(:to_sym)
-          questionnaire.last_author = json.fetch("last_author")
           questionnaire.extra_css = json.fetch("extra_css")
 
           questionnaire.flags = json.fetch("flags").with_indifferent_access.transform_values do |attrs|
@@ -45,30 +39,6 @@ module Quby
           json.fetch("panels").each do |panel_json|
             load_panel(questionnaire, panel_json)
           end
-
-          # roqua domain
-          questionnaire.roqua_keys = json.fetch("roqua_keys")
-          questionnaire.sbg_key = json.fetch("sbg_key")
-          questionnaire.sbg_domains = json.fetch("sbg_domains").map(&:symbolize_keys)
-          questionnaire.outcome_regeneration_requested_at = json.fetch("outcome_regeneration_requested_at")&.yield_self { |str| Time.zone.parse(str) }
-          questionnaire.deactivate_answers_requested_at = json.fetch("deactivate_answers_requested_at").try { |str| Time.zone.parse(str) }
-          questionnaire.respondent_types = json.fetch("respondent_types").map(&:to_sym)
-          questionnaire.tags = json.fetch("tags")
-
-          json.fetch("charts").fetch("overview")&.tap do |overview_json|
-            questionnaire.charts.overview = Quby::Questionnaires::Entities::Charting::OverviewChart.new(
-              subscore: overview_json.fetch("subscore").to_sym,
-              y_max: overview_json.fetch("y_max"),
-            )
-          end
-
-          json.fetch("charts").fetch("others").each do |chart_json|
-            questionnaire.add_chart(build_chart(questionnaire, chart_json))
-          end
-
-          questionnaire.outcome_tables = json.fetch("outcome_tables").map do |attributes|
-            build_outcome_table(questionnaire, attributes)
-          end
         end
       end
 
@@ -154,7 +124,6 @@ module Quby
 
           # only selectable via options passed in DSL, not via DSL methods
           # many apply only to certain types of questions
-          sbg_key: item_json.fetch("sbg_key"),
           allow_duplicate_option_values: item_json.fetch("allow_duplicate_option_values"),
           allow_blank_titles: item_json.fetch("allow_blank_titles"),
           as: item_json.fetch("as")&.to_sym,
@@ -326,7 +295,6 @@ module Quby
       def self.build_score_calculation(attrs)
         Entities::ScoreCalculation.new(attrs.fetch("key").to_sym,
           label: attrs.fetch("label"),
-          sbg_key: attrs.fetch("sbg_key"),
           options: attrs.fetch("options").symbolize_keys,
           sourcecode: attrs.fetch("sourcecode"),
         )
@@ -356,58 +324,6 @@ module Quby
         )
       end
 
-      def self.build_chart(questionnaire, chart_json)
-        base_args = {
-          title: chart_json.fetch("title"),
-          plottables: chart_json.fetch("plottables").map do |plottable_json|
-            Quby::Questionnaires::Entities::Charting::Plottable.new(
-              plottable_json.fetch("key").to_sym,
-              label: plottable_json.fetch("label"),
-              plotted_key: plottable_json.fetch("plotted_key").to_sym,
-              global: plottable_json.fetch("global"),
-              questionnaire_key: plottable_json.fetch("questionnaire_key")
-            )
-          end,
-          y_categories: chart_json.fetch("y_categories"),
-          y_range_categories: chart_json.fetch("y_range_categories"),
-          chart_type: chart_json.fetch("chart_type"),
-          y_range: deserialize_range(chart_json.fetch("y_range")),
-          tick_interval: chart_json.fetch("tick_interval"),
-          plotbands: chart_json.fetch("plotbands").map do |plotband_json|
-            {
-              color: plotband_json.fetch("color"),
-              from: plotband_json.fetch("from"),
-              to: plotband_json.fetch("to")
-            }
-          end,
-          plotlines: chart_json.fetch("plotlines") { [] }.map do |plotline_json|
-            {
-              color: plotline_json.fetch("color"),
-              value: plotline_json.fetch("value")
-            }
-          end
-        }
-
-        case chart_json.fetch("type")
-        when "bar_chart"
-          Quby::Questionnaires::Entities::Charting::BarChart.new(chart_json.fetch("key").to_sym,
-            **base_args
-          )
-        when "line_chart"
-          Quby::Questionnaires::Entities::Charting::LineChart.new(chart_json.fetch("key").to_sym,
-            y_label: chart_json.fetch("y_label"),
-            tonality: chart_json.fetch("tonality").to_sym,
-            baseline: YAML.unsafe_load(chart_json.fetch("baseline")),
-            clinically_relevant_change: chart_json.fetch("clinically_relevant_change"),
-            **base_args
-          )
-        when "radar_chart"
-          Quby::Questionnaires::Entities::Charting::RadarChart.new(chart_json.fetch("key").to_sym,
-            **base_args
-          )
-        end
-      end
-
       def self.build_score_schema(attributes)
         Entities::ScoreSchema.new(
           key: attributes.fetch("key").to_sym,
@@ -422,17 +338,6 @@ module Quby
         )
       end
 
-      def self.build_outcome_table(questionnaire, attributes)
-        Entities::OutcomeTable.new(
-          questionnaire: questionnaire,
-          key: attributes.fetch("key").to_sym,
-          score_keys: attributes.fetch("score_keys").map(&:to_sym),
-          subscore_keys: attributes.fetch("subscore_keys").map(&:to_sym),
-          name: attributes.fetch("name"),
-          default_collapsed: attributes.fetch("default_collapsed"),
-        )
-      end
-
       def self.deserialize_range(range_attributes)
         return unless range_attributes
         Range.new(range_attributes.fetch("begin"), range_attributes.fetch("end"), range_attributes.fetch("exclude_end"))

data/lib/quby/questionnaires/entities/questionnaire.rb

@@ -13,7 +13,7 @@ module Quby
   module Questionnaires
     module Entities
       class Questionnaire
-        include ::Quby::InspectExcept.new(*%i[@attributes @charts @fields @flags @panels @questions @sourcecode @score_calculations @score_schemas @textvars])
+        include ::Quby::InspectExcept.new(*%i[@attributes @fields @flags @panels @questions @sourcecode @score_calculations @score_schemas @textvars])
 
         extend  ActiveModel::Naming
         include ActiveModel::Validations
@@ -22,33 +22,22 @@ module Quby
         class UnknownInputKey < ValidationError; end
         class InputKeyAlreadyDefined < ValidationError; end
 
-        VALID_LICENSES = [:unknown,
-                          :free,               # freely available without license costs,
-                          :pay_per_completion, # costs associated with each completed questionnaire,
-                          :private,            # not a publicly available questionnaire
-                          :deprecated]         # should no longer be used, hide from view
-
         RESPONDENT_TYPES = %i( profess patient parent second_parent teacher caregiver )
 
         def initialize(key, attributes = {})
           @key = key
           @attributes = attributes
-          @sbg_domains = []
           @score_calculations = {}.with_indifferent_access
-          @charts = Charting::Charts.new
           @fields = Fields.new(self)
-          @license = :unknown
           @extra_css = ""
           @panels = []
           @flags = {}.with_indifferent_access
           @textvars = {}.with_indifferent_access
           @language = :nl
           @respondent_types = []
-          @tags = OpenStruct.new
           @check_key_clashes = true
           @validate_html = true
           @score_schemas = {}.with_indifferent_access
-          @outcome_tables = []
           @check_score_keys_consistency = true
           @lookup_tables = {}
         end
@@ -57,12 +46,6 @@ module Quby
 
         attr_accessor :key
         attr_accessor :title
-        attr_accessor :description
-        attr_accessor :outcome_description
-        attr_accessor :short_description
-        attr_writer   :roqua_keys
-        attr_accessor :sbg_key # not required to be unique
-        attr_accessor :sbg_domains
         attr_accessor :abortable
         attr_accessor :enable_previous_questionnaire_button
         attr_accessor :panels
@@ -71,13 +54,8 @@ module Quby
         attr_writer   :leave_page_alert
         attr_reader   :fields
         attr_accessor :extra_css
-        attr_reader   :license
-        attr_accessor :licensor
         attr_accessor :language
         attr_accessor :respondent_types
-        attr_reader :tags # tags= is manually defined below
-        attr_accessor :outcome_regeneration_requested_at
-        attr_accessor :deactivate_answers_requested_at
         # whether to check for clashes between question input keys (HTML form keys)
         attr_accessor :check_key_clashes
         # whether to check consistency of score subkeys during seed generation
@@ -85,26 +63,16 @@ module Quby
         # If false, we don't check html for validity (for mate1 and mate1_pre)
         attr_accessor :validate_html
 
-        attr_accessor :last_author
         attr_writer :allow_hotkeys # allow hotkeys for :all views, just :bulk views (default), or :none for never
 
-        attr_accessor :charts
-
         attr_accessor :flags
         attr_accessor :textvars
 
-        attr_accessor :outcome_tables
         attr_accessor :score_schemas
         attr_accessor :lookup_tables
 
         delegate :question_hash, :input_keys, :answer_keys, :expand_input_keys, to: :fields
 
-        def tags=(tags)
-          tags.each do |tag|
-            @tags[tag] = true
-          end
-        end
-
         def leave_page_alert
           return nil unless Settings.enable_leave_page_alert
           @leave_page_alert || "Als u de pagina verlaat worden uw antwoorden niet opgeslagen."
@@ -114,10 +82,6 @@ module Quby
           (@allow_hotkeys || :bulk).to_s
         end
 
-        def roqua_keys
-          @roqua_keys || [key]
-        end
-
         def to_param
           key
         end
@@ -162,26 +126,6 @@ module Quby
           questions.select { |question| question.type == type }
         end
 
-        def license=(type)
-          fail ArgumentError, 'Invalid license' unless VALID_LICENSES.include?(type)
-          @license = type
-        end
-
-        def as_json(options = {})
-          {
-            key: key,
-            title: title,
-            description: description,
-            outcomeDescription: outcome_description,
-            shortDescription: short_description,
-            panels: panels,
-            fields: fields,
-            flags: flags,
-            textvars: textvars,
-            validations: validations,
-          }
-        end
-
         def key_in_use?(key)
           fields.key_in_use?(key) || score_calculations.key?(key)
         end
@@ -206,10 +150,6 @@ module Quby
           score_calculations.values.select(&:score)
         end
 
-        def find_plottable(key)
-          score_calculations[key] || question_hash.with_indifferent_access[key]
-        end
-
         def actions
           score_calculations.values.select(&:action)
         end
@@ -218,10 +158,6 @@ module Quby
           score_calculations.values.select(&:completion).first
         end
 
-        def add_chart(chart)
-          charts.add chart
-        end
-
         def filter_flags(given_flags)
           given_flags.select do |flag_key, _|
             flags.key? flag_key
@@ -332,10 +268,6 @@ module Quby
           end
         end
 
-        def add_outcome_table(outcome_table_options)
-          outcome_tables << OutcomeTable.new(**outcome_table_options, questionnaire: self)
-        end
-
         def validations
           @validations ||= fields.question_hash.values.flat_map do |question|
             question.validations.map do |validation|

data/lib/quby/questionnaires/entities.rb

@@ -12,14 +12,6 @@ require 'quby/questionnaires/entities/score_schema'
 
 require 'quby/questionnaires/entities/fields'
 
-require 'quby/questionnaires/entities/charting/charts'
-require 'quby/questionnaires/entities/charting/chart'
-require 'quby/questionnaires/entities/charting/overview_chart'
-require 'quby/questionnaires/entities/charting/line_chart'
-require 'quby/questionnaires/entities/charting/bar_chart'
-require 'quby/questionnaires/entities/charting/radar_chart'
-require 'quby/questionnaires/entities/charting/plottable'
-
 require 'quby/questionnaires/entities/panel'
 require 'quby/questionnaires/entities/text'
 require 'quby/questionnaires/entities/table'

data/lib/quby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quby
-  VERSION = "5.7.0"
+  VERSION = "5.8.0"
 end

data/spec/fixtures/aged_score_interpretations.rb

@@ -3,9 +3,7 @@ title "Patient age can be used in scores"
 panel do
 end
 
-score :tot, label: "Totaalscore",
-      schema: [{key: :value, export_key: :tot, label: 'Score'},
-               {key: :interpretation, export_key: :tot_i, label: 'Interpretatie'}] do
+score :tot, label: "Totaalscore", schema: [{key: :value, export_key: :tot, label: 'Score'}, {key: :interpretation, export_key: :tot_i, label: 'Interpretatie'}] do
   tot = 10
   if gender != :unknown && age
     if gender == :male

data/spec/fixtures/score_test.rb

@@ -2,20 +2,16 @@ title 'Score test'
 
 question :v_1, type: :integer
 
-score :test, label: 'Testscore',
-      schema: [{key: :value, export_key: :tes, label: 'Waarde'},
-               {key: :interpretation, export_key: :tes_i, label: 'Interpretatie'}] do
+score :test, label: 'Testscore', schema: [{key: :value, export_key: :tes, label: 'Waarde'}, {key: :interpretation, export_key: :tes_i, label: 'Interpretatie'}] do
   {value: value(:v_1),
    interpretation: 'Matig'}
 end
 
-score :test2, label: 'Testscore 2',
-      schema: [{key: :value, export_key: :tes2, label: 'Waarde'},
-               {key: :interpretation, export_key: :tes2_i, label: 'Interpretatie'}] do
+score :test2, label: 'Testscore 2', schema: [{key: :value, export_key: :tes2, label: 'Waarde'}, {key: :interpretation, export_key: :tes2_i, label: 'Interpretatie'}] do
   {value: values_with_nils(:v_1).first + 5,
    interpretation: 'Miniem'}
 end
 
 completion do
    values_with_nils(:v_1).compact.size / 1.0
-end
+end

data/spec/fixtures/subset_mansa.rb

@@ -124,10 +124,7 @@ end
 
 end_panel
 
-score :somscore, label: "Score",
-      schema: [{key: :value, export_key: :som, label: 'Score'},
-               {key: :mean, export_key: :som_m, label: 'Gemiddelde'},
-               {key: :interpretation, export_key: :som_i, label: 'Interpretatie'}] do
+score :somscore, label: "Score", schema: [{key: :value, export_key: :som, label: 'Score'}, {key: :mean, export_key: :som_m, label: 'Gemiddelde'}, {key: :interpretation, export_key: :som_i, label: 'Interpretatie'}] do
   somvars = values_with_nils('v_1','v_6','v_7','v_8','v_9','v_10','v_12','v_16','v_17','v_18','v_19','v_20').select{|v| v and v.to_f > 0}
   if somvars.size >= 8
     somscore = ((somvars.map(&:to_i).reduce(&:+) / somvars.size.to_f) * 12).round