quby 5.1.1 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 791dc35955fc33de42a6fdadceb82d3b9ac244b5f361bfb40aa864f2932b9789
-  data.tar.gz: 48d1d7c68d27ae3ed2541f48f33f991d3eb7e59d7ea417e1d85082d1b97b1f54
+  metadata.gz: 19449694a4b1e836d79081e5dd7743a5270abd55c468c9b0279e09e996c55e99
+  data.tar.gz: 9dddab34f429be6b67b40543a19819c2f55af0ffc22e85f54a1f179f978002cb
 SHA512:
-  metadata.gz: 76dc22bfca03f05fcb79b7c6596b8e7f5139db5fad2f5521f2b76f5b7ca80b1d84738f497457c8cd84ede32022d293f180870c100cf9fe7db5d0ed332c1c06bf
-  data.tar.gz: e44cc1c13839f862946174a497577cd1bc836f0534579f187e56d9500d40cc40fa486d3e69cba418a5503a50083187ceaa7767a4a6300d88f16c6ebe99d73bda
+  metadata.gz: b6443985515b2999e7e6970f1d9effa2a578b6e9153997d7523ad240327fc7a5c6af3ee8c320a586b94512846c265e10510a118fe1b35150077228c3aaace90c
+  data.tar.gz: f02e3ab996caeddb0e97b3eaa486ff3a53fccafa8f8bb9bd722e6d65282ae5441d64d96efbaaa09fc58b174081d707d725126c3327976938e98bd58a863d8668

data/lib/quby/answers/dsl.rb

@@ -6,7 +6,6 @@ module Quby
       def self.enhance(target_instance)
         answer = target_instance
         questionnaire = target_instance.questionnaire
-        answer.dsl_last_update = questionnaire.last_update
         answer.extend(questionnaire.answer_dsl_module)
       end
     end

data/lib/quby/answers/entities/patient.rb

@@ -14,12 +14,12 @@ module Quby
           @birthyear = attributes[:birthyear]
         end
 
-        # returns the age at the given timestamp, as an integer
+        # returns the age at the given completed_at, as an integer
         # NB: if you make this a float, this breaks various questionnaire score calculations that do the following:
         # `if (8..12).cover?(age) ... elsif (13..15).cover?(age)` etc.
-        def age_at(timestamp)
-          return nil unless @birthyear and timestamp
-          ((timestamp - Time.gm(@birthyear, 1, 1)) / 1.year).floor
+        def age_at(completed_at)
+          return nil unless @birthyear and completed_at
+          ((completed_at - Time.gm(@birthyear, 1, 1)) / 1.year).floor
         end
       end
     end

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

@@ -22,7 +22,7 @@ module Quby
           {
             questionnaire_key:    questionnaire.key,
             token:                SecureRandom.hex(8),
-            dsl_last_update:      questionnaire.last_update,
+            dsl_last_update:      nil,
             raw_params:           given_attributes.fetch(:raw_params,           {}),
             import_notes:         given_attributes.fetch(:import_notes,         {}),
             patient:              given_attributes.fetch(:patient,              {}),

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

@@ -24,7 +24,7 @@ module Quby
             begin
               result = ScoreCalculator.calculate(questionnaire: answer.questionnaire,
                                                  values: value_by_regular_values,
-                                                 timestamp: completed_at,
+                                                 completed_at: completed_at,
                                                  patient_attrs: patient&.slice("birthyear", "gender"),
                                                  respondent_attrs: patient&.slice("respondent_type"),
                                                  &calculation.calculation)

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

@@ -20,12 +20,19 @@ module Quby
           end
         end
 
+        attr_reader :outcome_warnings
+
         # Evaluates block within the context of a new calculator
         # instance. All instance methods are accessible.
         def self.calculate(**kwargs, &block)
           instance = new(**kwargs)
           result = instance.instance_eval(&block)
-          result = result.merge(referenced_values: instance.referenced_values) if result.respond_to?(:merge)
+          if result.respond_to?(:merge)
+            result = result.merge({
+              referenced_values: instance.referenced_values,
+              outcome_warnings: instance.outcome_warnings.presence
+            }.compact)
+          end
           result
         end
 
@@ -33,7 +40,7 @@ module Quby
         #
         # values - The Hash values describes the keys of questions and the values
         #          of the answer given to that question.
-        # timestamp - The Time to be used to calculate the age of the patient.
+        # completed_at - The Time to be used to calculate the age of the patient.
         # patient_attrs - A Hash describing extra patient information (default: {})
         #           :birthyear - The Integer birthyear of the patient to be used in
         #                        score calculation (optional)
@@ -41,14 +48,15 @@ module Quby
         #                     :male, :female or :unknown (optional)
         # respondent_attrs - A Hash describing respondent information (default: {})
         #           :respondent_type - The Symbol or String type of respondent
-        def initialize(questionnaire:, values:, timestamp:, patient_attrs: {}, respondent_attrs: {})
+        def initialize(questionnaire:, values:, completed_at:, patient_attrs: {}, respondent_attrs: {})
           @questionnaire = questionnaire
           @values = values
-          @timestamp = timestamp
+          @completed_at = completed_at
           @patient = Entities::Patient.new(patient_attrs)
           @respondent = Entities::Respondent.new(respondent_attrs)
           @score = {}
           @referenced_values = []
+          @outcome_warnings = []
         end
 
         # Public: Get values for given question keys
@@ -195,9 +203,20 @@ module Quby
           values.flatten.compact.max
         end
 
+        # Public: Returns false if response was completed before the given date, true if on or after
+        # completed_on_or_after input could be a Date, e.g. `Date::new(2020,1,30)`
+        def observed_on_or_after(date)
+          @completed_at >= date
+        end
+
+        # Public: Returns initial completion date, for manual comparisons. Preferably use observed_on_or_after instead,
+        def observation_time
+          @completed_at
+        end
+
         # Public: Returns the Integer age of the patient, or nil if it's not known.
         def age
-          @patient.age_at @timestamp
+          @patient.age_at @completed_at
         end
 
         # Public: Returns the Symbol describing the gender of the patient.
@@ -235,6 +254,35 @@ module Quby
           @questionnaire.lookup_tables.fetch(table_key).lookup(parameters)
         end
 
+        # Way to test and warn about age/gender requirements for subscore calculation.
+        # If all given arguments are matched, the block is yielded.
+        # If an argument is given but does not match an outcome_warning is added to the score.
+        # May be called multiple times per score.
+        # ages - range or array of Ranges of valid ages
+        # genders - array of Symbols for genders we can calculate for (:male, :female, :unknown)
+        def when_demographics_match(ages: nil, genders: nil) # &block
+          warnings = []
+          unless ages.nil?
+            if age.nil?
+              warnings.push "No age given, some subscores can't be calculated"
+            elsif Array.wrap(ages).none? { |range| range.cover?(age) }
+              warnings.push "Some subscores can't be calculated, for recorded age"
+            end
+          end
+
+          unless genders.nil?
+            unless genders.include?(gender)
+              warnings.push "Some subscores can't be calculated for gender #{gender}"
+            end
+          end
+
+          if warnings.present?
+            @outcome_warnings.concat(warnings).uniq!
+          else
+            yield
+          end
+        end
+
         # Public: Ensure given question_keys have answers. Strings with nothing but whitespace are
         # not considered answered.
         #

data/lib/quby/answers/specs/repo_specs.rb

@@ -127,7 +127,6 @@ if defined?(RSpec)
       expect(record.actions).to              eq(stringified(attributes[:actions]))
       expect(record.completion).to           eq(stringified(attributes[:completion]))
       expect(record.import_notes).to         eq(stringified(attributes[:import_notes]))
-      expect(record.dsl_last_update).to      be_present
     end
 
     def stringified(hash)

data/lib/quby/questionnaires/deserializer.rb

@@ -20,7 +20,6 @@ module Quby
           questionnaire.licensor = json.fetch("licensor")
           questionnaire.language = json.fetch("language").try(:to_sym)
           questionnaire.renderer_version = json.fetch("renderer_version")
-          questionnaire.last_update = Time.zone.parse(json.fetch("last_update"))
           questionnaire.last_author = json.fetch("last_author")
           questionnaire.extra_css = json.fetch("extra_css")
           questionnaire.allow_switch_to_bulk = json.fetch("allow_switch_to_bulk")
@@ -363,6 +362,8 @@ module Quby
         base_args = {
           title: chart_json.fetch("title"),
           plottables: chart_json.fetch("plottables").map do |plottable_json|
+
+            binding.pry if plottable_json.is_a? String
             Quby::Questionnaires::Entities::Charting::Plottable.new(
               plottable_json.fetch("key").to_sym,
               label: plottable_json.fetch("label"),

data/lib/quby/questionnaires/dsl.rb

@@ -5,14 +5,14 @@ module Quby
     module DSL
       # Deprecated, precompile elsewhere and use from_json
       def self.build_from_definition(definition)
-        compiled = Quby::Compiler.compile(definition.key, definition.sourcecode, lookup_tables: {}, path: definition.path, last_update: definition.timestamp)
+        compiled = Quby::Compiler.compile(definition.key, definition.sourcecode, lookup_tables: {}, path: definition.path)
         data = JSON.parse(compiled[:outputs][:quby_frontend_v1].content)
         Deserializer.from_json(data)
       end
 
       # Deprecated, precompile elsewhere and use from_json
       def self.build(key, sourcecode = nil, timestamp: nil, &block)
-        compiled = Quby::Compiler.compile(key, sourcecode, lookup_tables: {}, last_update: timestamp, &block)
+        compiled = Quby::Compiler.compile(key, sourcecode, lookup_tables: {}, &block)
         data = JSON.parse(compiled[:outputs][:quby_frontend_v1].content)
         Deserializer.from_json(data)
       end

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

@@ -19,8 +19,6 @@ module Quby
         attr_reader :view_id
         attr_reader :input_key
 
-        attr_reader :start_chosen
-
         def initialize(key, question, options = {})
           @key         = key
           @question    = question

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

@@ -29,11 +29,10 @@ module Quby
 
         RESPONDENT_TYPES = %i( profess patient parent second_parent teacher caregiver )
 
-        def initialize(key, attributes = {}, last_update: Time.now)
+        def initialize(key, attributes = {})
           @key = key
           @attributes = attributes
           @sbg_domains = []
-          @last_update = Time.at(last_update.to_i)
           @score_calculations = {}.with_indifferent_access
           @charts = Charting::Charts.new
           @fields = Fields.new(self)
@@ -91,7 +90,6 @@ module Quby
 
         attr_accessor :last_author
         attr_accessor :allow_hotkeys # allow hotkeys for :all views, just :bulk views (default), or :none for never
-        attr_accessor :last_update
 
         attr_accessor :charts
 

data/lib/quby/questionnaires/repos/bundle_disk_repo.rb

@@ -23,7 +23,7 @@ module Quby
         def find(key)
           fail(QuestionnaireNotFound, key) unless exists?(key)
           json = read(key)
-          timestamp = Time.zone.parse(json["last_update"])
+          timestamp = File.mtime(questionnaire_path(key))
           Entities::Definition.new(key: key, path: questionnaire_path(key), json: json, timestamp: timestamp)
         end
 
@@ -33,7 +33,7 @@ module Quby
         end
 
         def timestamp(key)
-          Time.zone.parse(read(key)["last_update"])
+          File.mtime(questionnaire_path(key))
         end
 
         private

data/lib/quby/version.rb

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