quby 4.0.4 → 5.0.0

data/lib/quby/questionnaires/dsl.rb

@@ -1,27 +1,24 @@
 # frozen_string_literal: true
 
-require 'quby/questionnaires/dsl/base'
-require 'quby/questionnaires/dsl/helpers'
-require 'quby/questionnaires/dsl/questionnaire_builder'
-
 module Quby
   module Questionnaires
     module DSL
+      # Deprecated, precompile elsewhere and use from_json
       def self.build_from_definition(definition)
-        Entities::Questionnaire.new(definition.key, last_update: definition.timestamp).tap do |questionnaire|
-          builder = QuestionnaireBuilder.new(questionnaire)
-          builder.instance_eval(definition.sourcecode, definition.path) if definition.sourcecode
-          questionnaire.callback_after_dsl_enhance_on_questions
-        end
+        compiled = Quby::Compiler.compile(definition.key, definition.sourcecode, seeds: [], lookup_tables: {}, path: definition.path, last_update: definition.timestamp)
+        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)
-        Entities::Questionnaire.new(key, last_update: timestamp).tap do |questionnaire|
-          builder = QuestionnaireBuilder.new(questionnaire)
-          builder.instance_eval(sourcecode, key) if sourcecode
-          builder.instance_eval(&block) if block
-          questionnaire.callback_after_dsl_enhance_on_questions
-        end
+        compiled = Quby::Compiler.compile(key, sourcecode, seeds: [], lookup_tables: {}, last_update: timestamp, &block)
+        data = JSON.parse(compiled[:outputs][:quby_frontend_v1].content)
+        Deserializer.from_json(data)
+      end
+
+      def self.from_json(hash)
+        Deserializer.from_json(hash)
       end
     end
   end

data/lib/quby/questionnaires/entities.rb

@@ -13,6 +13,7 @@ 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'

data/lib/quby/questionnaires/entities/charting/line_chart.rb

@@ -27,10 +27,33 @@ module Quby
             self.clinically_relevant_change = clinically_relevant_change
           end
 
+          def baseline
+            @baseline_proc ||= make_baseline_proc
+          end
+
           def tonality=(value)
             fail "Invalid tonality: #{value}" unless [:higher_is_better, :lower_is_better].include?(value)
             @tonality = value
           end
+
+          private
+
+          def make_baseline_proc
+            return unless @baseline
+
+            case @baseline
+            when Hash
+              ->(age, gender) {
+                age_match = @baseline.find { |age_range, _v| age && age_range === age }
+                hash_by_gender = (age_match&.last || @baseline.stringify_keys["default"])
+
+                gender_match = hash_by_gender.find {|gender_key, _v| gender && gender_key.to_s == gender.to_s }
+                gender_match&.last || hash_by_gender.stringify_keys['default']
+              }
+            else
+              ->(age, gender) { @baseline }
+            end
+          end
         end
       end
     end

data/lib/quby/questionnaires/entities/charting/overview_chart.rb

@@ -11,7 +11,9 @@ module Quby
           # @return Integer
           attr_accessor :y_max
 
-          def initialize
+          def initialize(subscore: nil, y_max: nil)
+            self.subscore = subscore
+            self.y_max = y_max
           end
         end
       end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'active_model'
-require 'quby/questionnaires/services/definition_validator'
 
 module Quby
   module Questionnaires
@@ -10,16 +9,15 @@ module Quby
         extend  ActiveModel::Naming
         include ActiveModel::Validations
 
-        attr_accessor :key, :sourcecode, :timestamp, :path
+        attr_accessor :key, :sourcecode, :json, :timestamp, :path
 
-        def initialize(key:, path:, sourcecode: "", timestamp: nil)
+        def initialize(key:, path:, sourcecode: "", json: nil, timestamp: nil)
           @path = path
           @key = key
           @sourcecode = sourcecode
+          @json = json
           @timestamp = timestamp
         end
-
-        validates_with Services::DefinitionValidator
       end
     end
   end

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

@@ -35,11 +35,6 @@ module Quby
           new_answer_keys = Set.new(question.answer_keys)
           new_input_keys  = Set.new(question.input_keys)
 
-          # This is probably the best place to ensure that keys don't collide. However,our current set of questionnaires
-          # does have a few collisions between +v_1+ option +a9+ and its subquestion +v_1_a9+, so we have excluded
-          # those questionnaires from this check through @questionnaire.check_key_clashes.
-          check_key_clashes(new_answer_keys, new_input_keys) if @questionnaire.check_key_clashes
-
           @question_hash[question.key] = question
           @input_keys.merge(new_input_keys)
           @answer_keys.merge(new_answer_keys)
@@ -48,16 +43,6 @@ module Quby
           end
         end
 
-        def check_key_clashes(new_answer_keys, new_input_keys)
-          if @answer_keys.intersect?(new_answer_keys)
-            fail "Duplicate answer keys: #{@answer_keys.intersection(new_answer_keys).inspect}"
-          end
-
-          if @input_keys.intersect?(new_input_keys)
-            fail "Duplicate input keys: #{@input_keys.intersection(new_input_keys).inspect}"
-          end
-        end
-
         def key_in_use?(key)
           @question_hash.key?(key) || input_keys.include?(key.to_sym)
         end

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

@@ -8,8 +8,6 @@ module Quby
       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}
@@ -140,7 +138,7 @@ module Quby
           @description = options[:description]
           @display_modes = options[:display_modes]
           @presentation = options[:presentation]
-          @validations = []
+          @validations = options[:validations] || []
           @parent = options[:parent]
           @hidden = options[:hidden]
           @table = options[:table]
@@ -150,12 +148,13 @@ module Quby
           @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]
+          @sets_textvar = options[:sets_textvar]
           @unit = options[:unit]
           @lines = options[:lines] || 6
           @cols = options[:cols] || 40
           @default_invisible = options[:default_invisible] || false
-          @labels ||= []
+          @labels = options[:labels] || []
+          @size = options[:size]
 
           @col_span = options[:col_span] || 1
           @row_span = options[:row_span] || 1
@@ -169,16 +168,6 @@ module Quby
           @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
@@ -186,17 +175,6 @@ module Quby
             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
 
@@ -212,12 +190,11 @@ module Quby
           @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}"
+        def extra_data
+          result = @extra_data
+          result = result.merge(:"depends-on" => @depends_on.to_json) if @depends_on
+          result = result.merge(:placeholder => @options.find { |option| option.placeholder }&.key)
+          result
         end
 
         def col_span

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

@@ -29,8 +29,9 @@ module Quby
 
         RESPONDENT_TYPES = %i( profess patient parent second_parent teacher caregiver )
 
-        def initialize(key, last_update: Time.now)
+        def initialize(key, attributes = {}, last_update: Time.now)
           @key = key
+          @attributes = attributes
           @sbg_domains = []
           @last_update = Time.at(last_update.to_i)
           @score_calculations = {}.with_indifferent_access
@@ -54,6 +55,8 @@ module Quby
           @lookup_tables = {}
         end
 
+        attr_reader :attributes
+
         attr_accessor :key
         attr_accessor :title
         attr_accessor :description
@@ -136,20 +139,6 @@ module Quby
           end
         end
 
-        def callback_after_dsl_enhance_on_questions
-          question_hash.each_value do |q|
-            q.run_callbacks :after_dsl_enhance
-          end
-          ensure_scores_have_schemas if Quby::Settings.require_score_schemas
-        end
-
-        def ensure_scores_have_schemas
-          missing_schemas = scores.map(&:key).map(&:to_s) - score_schemas.keys
-          missing_schemas.each do |key|
-            errors.add "Score #{key}", 'is missing a score schema'
-          end
-        end
-
         def validate_questions
           question_hash.each_value do |q|
             unless q.valid?

data/lib/quby/questionnaires/entities/questions/checkbox_question.rb

@@ -24,30 +24,6 @@ module Quby
             @uncheck_all_option       = options[:uncheck_all_option]
             @maximum_checked_allowed  = options[:maximum_checked_allowed]
             @minimum_checked_required = options[:minimum_checked_required]
-
-            if @check_all_option
-              @validations << {type: :not_all_checked,
-                               check_all_key: @check_all_option,
-                               explanation: options[:error_explanation]}
-            end
-
-            if @uncheck_all_option
-              @validations << {type: :too_many_checked,
-                               uncheck_all_key: @uncheck_all_option,
-                               explanation: options[:error_explanation]}
-            end
-
-            if @maximum_checked_allowed
-              @validations << {type: :maximum_checked_allowed,
-                               maximum_checked_value: @maximum_checked_allowed,
-                               explanation: options[:error_explanation]}
-            end
-
-            if @minimum_checked_required
-              @validations << {type: :minimum_checked_required,
-                               minimum_checked_value: @minimum_checked_required,
-                               explanation: options[:error_explanation]}
-            end
           end
 
           def variable_descriptions

data/lib/quby/questionnaires/entities/questions/date_question.rb

@@ -32,14 +32,6 @@ module Quby
               component_key = options[:"#{component}_key"] || "#{key}_#{COMPONENT_KEYS[component]}"
               instance_variable_set("@#{component}_key", component_key.to_sym)
             end
-
-            add_date_validation(options[:error_explanation])
-          end
-
-          def add_date_validation(explanation)
-            @validations << {type: :valid_date,
-                             subtype: :"valid_date_#{components.sort.join('_')}",
-                             explanation: explanation}
           end
 
           def claimed_keys

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

@@ -3,15 +3,52 @@
 module Quby
   module Questionnaires
     module Entities
+      # method_source gem gives us the full score source code including the initial `score() do` DSL call.
+      # This module helps strip off that outer DSL call.
+      module StripOuterScoreCall
+        def self.score(*args, &block)
+          block
+        end
+
+        def self.variable(*args, &block)
+          block
+        end
+
+        def self.attention(*args, &block)
+          block
+        end
+
+        def self.alarm(*args, &block)
+          block
+        end
+
+        def self.completion(*args, &block)
+          block
+        end
+
+        def self.subscore(*args, &block)
+          block
+        end
+      end
+
       class ScoreCalculation
-        attr_accessor :key, :label, :sbg_key, :options, :calculation
+        attr_accessor :key, :label, :sbg_key, :options
 
         def initialize(key, options, &block)
           @key = key
           @label = options[:label]
           @sbg_key = options[:sbg_key]
-          @options = options
-          @calculation = block
+          @options = options[:options] || options # TODO remove `|| options`
+          @sourcecode = options[:sourcecode]
+          @block = block
+        end
+
+        def calculation
+          if @block
+            @block
+          else
+            StripOuterScoreCall.instance_eval(@sourcecode)
+          end
         end
 
         def score

data/lib/quby/questionnaires/repos.rb

@@ -6,6 +6,7 @@ module Quby
       autoload :Base, 'quby/questionnaires/repos/base'
       autoload :MemoryRepo, 'quby/questionnaires/repos/memory_repo'
       autoload :DiskRepo, 'quby/questionnaires/repos/disk_repo'
+      autoload :BundleDiskRepo, 'quby/questionnaires/repos/bundle_disk_repo'
 
       QuestionnaireNotFound = Class.new(StandardError)
       DuplicateQuestionnaire = Class.new(StandardError)

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'quby/questionnaires/repos'
+require 'quby/questionnaires'
+
+module Quby
+  module Questionnaires
+    module Repos
+      class BundleDiskRepo < Base
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+          @questionnaire_cache = {}
+        end
+
+        def keys
+          Dir[File.join(path, "*.rb")].map do |filename|
+            File.basename(filename, '.rb')
+          end
+        end
+
+        def find(key)
+          fail(QuestionnaireNotFound, key) unless exists?(key)
+          json = read(key)
+          timestamp = Time.zone.parse(json["last_update"])
+          Entities::Definition.new(key: key, path: questionnaire_path(key), json: json, timestamp: timestamp)
+        end
+
+        def exists?(key)
+          questionnaire_path = questionnaire_path(key)
+          File.exist?(questionnaire_path)
+        end
+
+        def timestamp(key)
+          Time.zone.parse(read(key)["last_update"])
+        end
+
+        private
+
+        def read(key)
+          JSON.parse(File.read(questionnaire_path(key)))
+        end
+
+        def questionnaire_path(key)
+          File.join(path,key, "quby-frontend-v1.json")
+        end
+      end
+    end
+  end
+end

data/lib/quby/table_backend/range_tree.rb

@@ -2,8 +2,6 @@
 
 # A lookup tree to find values by multiple arguments.
 #
-# Created by LookupTable from a csv file or by add_lookup_tree from dsl.
-#
 # Example tree:
 # Inhibitie:
 #   male:
@@ -36,27 +34,6 @@ module Quby::TableBackend
       @tree = tree
     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
-      new(levels: levels, tree: tree)
-    end
-
-
     # Given a parameters hash that contains a value or range for every
     # level in the tree, find and return the normscore.
     # ie. `lookup({age: 10, raw: 5, scale: 'Inhibitie', gender: 'male'})` => 39
@@ -67,34 +44,6 @@ module Quby::TableBackend
 
     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
-
     # All parameters must be present to do a lookup but the order does not matter.
     def validate_parameters(parameters)
       if @levels[0...-1].sort != parameters.keys.map(&:to_s).sort