quby-compiler 0.2.1

data/lib/quby/compiler/dsl/standardized_panel_generators.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# rubocop:disable LineLength
+
+module Quby
+  module Compiler
+    module DSL
+      module StandardizedPanelGenerators
+        def start_panel
+          panel do
+            text "Welkom bij deze vragenlijst"
+          end
+        end
+
+        def end_panel
+          panel do
+            text "*Bedankt voor het invullen van deze vragenlijst.*<br>
+  * U kunt uw antwoorden downloaden door op de knop &#39;Download als PDF&#39; te klikken. Dit bestand is ook geschikt om af te drukken.<br>
+  * Sla de antwoorden op door op de &#39;Klaar&#39;-knop onderaan te klikken. Daarna kunt u uw antwoorden niet meer wijzigen."
+          end
+        end
+
+        def informal_end_panel
+          panel do
+            text "*Bedankt voor het invullen van deze vragenlijst.*<br>
+  * Je kan je antwoorden downloaden door op de knop &#39;Download als PDF&#39; te klikken. Dit bestand is ook geschikt om af te drukken.<br>
+  * Sla de antwoorden op door op de &#39;Klaar&#39;-knop onderaan te klikken. Daarna kun je je antwoorden niet meer wijzigen."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/table_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities'
+
+module Quby
+  module Compiler
+    module DSL
+      class TableBuilder
+        prepend CallsCustomMethods
+        include Helpers
+
+        def initialize(panel, options = {})
+          @panel = panel
+          @table = Entities::Table.new(options)
+          @default_question_options = options[:default_question_options] || {}
+          @panel.items << @table
+        end
+
+        def title(value)
+          @table.title = value
+        end
+
+        def description(value)
+          @table.description = value
+        end
+
+        def text(value, options = {})
+          @table.items << Entities::Text.new(value.to_s, options)
+        end
+
+        def question(key, options = {}, &block)
+          options = @default_question_options.merge(options)
+                                             .merge(table: @table,
+                                                    questionnaire: @panel.questionnaire)
+
+          check_question_keys_uniqueness key, options, @panel.questionnaire
+          fail "You can't create a slider in a table at the moment" if options[:as] == :slider
+
+          question = QuestionBuilder.build(key, options, &block)
+
+          @panel.questionnaire.register_question(question)
+          @table.items << question
+          @panel.items << question
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'quby/compiler/entities/lookup_tables'
+
+require 'quby/compiler/entities/definition'
+require 'quby/compiler/entities/questionnaire'
+require 'quby/compiler/entities/version'
+require 'quby/compiler/entities/question_option'
+require 'quby/compiler/entities/item'
+require 'quby/compiler/entities/score_calculation'
+
+require 'quby/compiler/entities/subscore_schema'
+require 'quby/compiler/entities/score_schema'
+
+require 'quby/compiler/entities/fields'
+
+require 'quby/compiler/entities/charting/charts'
+require 'quby/compiler/entities/charting/chart'
+require 'quby/compiler/entities/charting/line_chart'
+require 'quby/compiler/entities/charting/bar_chart'
+require 'quby/compiler/entities/charting/radar_chart'
+require 'quby/compiler/entities/charting/plottable'
+
+require 'quby/compiler/entities/panel'
+require 'quby/compiler/entities/text'
+require 'quby/compiler/entities/table'
+
+require 'quby/compiler/entities/outcome_table'
+
+require 'quby/compiler/entities/question'
+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'

data/lib/quby/compiler/entities/charting/bar_chart.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/charting/chart'
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class BarChart < Chart
+          def initialize(key, **kwargs)
+            super(key, **kwargs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/charting/chart.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class Chart
+          # @return [Symbol]
+          attr_accessor :key
+
+          # @return [String]
+          attr_accessor :title
+
+          # @return [Array]
+          attr_accessor :plottables
+
+          # If y_categories are defined, plottable values should correspond to
+          # values from this array and the graph will be plotted with
+          # corresponding y axis categories example (icl_r):
+          #
+          #   ["Zeer laag", "Laag", "Gemiddeld", "Hoog", "Zeer Hoog"]
+          #
+          # (caution, capitalization oddity)
+          #
+          # NB: only implemented for bar charts on the roqua side
+          #
+          # @return [Array]
+          attr_accessor :y_categories
+
+          # If y_range_categories are defined, plottable values should fall in
+          # the ranges that compose the keys of this hash. The chart will label
+          # these ranges of y_values with the corresponding value in the hash
+          # on the y axis. For example:
+          #
+          #   {
+          #     (0.0...30.0) => "Zeer laag",
+          #     (30.0...40.0) => "Laag",
+          #     (40.0...60.0) => "Gemiddeld",
+          #     (60.0...70.0) => "Hoog",
+          #     (70.0..100.0) => "Zeer hoog"
+          #   }
+          #
+          # NB: .. is inclusive the last value in the range, ... is exclusive.
+          #
+          # ChartBuilder#y_range_categories massages its parameters into this
+          # format. Only implemented for line charts on the RoQua side.
+          #
+          # @return [Hash<Range, String>]
+          attr_accessor :y_range_categories
+
+          # @return [Symbol]
+          attr_accessor :chart_type
+
+          # @return [Range]
+          attr_accessor :y_range
+
+          # @return [Float]
+          attr_accessor :tick_interval
+
+          # @return [Array]
+          attr_accessor :plotbands
+
+          # @return [Array]
+          attr_accessor :plotlines
+
+          def initialize(key, title: nil, plottables: nil, y_categories: nil, y_range_categories: nil, chart_type: nil, y_range: nil, tick_interval: nil, plotbands: nil, plotlines: nil)
+            self.key = key.to_sym
+            self.title = title
+            self.plottables = plottables || []
+            self.y_categories = y_categories
+            self.y_range_categories = y_range_categories
+            self.chart_type = chart_type
+            self.y_range = y_range
+            self.tick_interval = tick_interval
+            self.plotbands = plotbands || []
+            self.plotlines = plotlines || []
+          end
+
+          def type
+            self.class.name.to_s.demodulize.underscore
+          end
+
+          def y_range
+            @y_range || @y_range = default_y_range
+          end
+
+          def chart_type=(value)
+            @chart_type = value&.to_sym
+          end
+
+          def default_y_range
+            # when there are y_categories, the y_range should match the
+            # number of categories (validated in chart_builder#validate!)
+            (0..(y_categories.count - 1)) if y_categories.present?
+            # otherwise, nil is allowed as a y_range
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/charting/charts.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class Charts
+          include Enumerable
+
+          def initialize
+            @charts = []
+          end
+
+          def overview
+            @overview_chart
+          end
+
+          def overview=(chart)
+            @overview_chart = chart
+          end
+
+          def add(chart)
+            fail "Duplicate chart: #{chart.key} already exists!" if find(chart.key)
+            @charts << chart
+          end
+
+          def find(key)
+            @charts.find { |i| i.key == key }
+          end
+
+          def each(*args, &block)
+            @charts.each(*args, &block)
+          end
+
+          def size
+            @charts.size
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/charting/chart'
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class LineChart < Chart
+          # @return [String]
+          attr_accessor :y_label
+
+          # @return [Symbol]
+          attr_accessor :tonality
+
+          # @return [Proc]
+          attr_accessor :baseline
+
+          # @return [Float]
+          attr_accessor :clinically_relevant_change
+
+          def initialize(key, y_label: nil, tonality: :lower_is_better, baseline: nil, clinically_relevant_change: nil, **kwargs)
+            super(key, **kwargs)
+            self.y_label = y_label
+            self.tonality = tonality
+            self.baseline = baseline
+            self.clinically_relevant_change = clinically_relevant_change
+          end
+
+          def tonality=(value)
+            fail "Invalid tonality: #{value}" unless [:higher_is_better, :lower_is_better].include?(value)
+            @tonality = value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require_relative 'chart'
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class OverviewChart < Chart
+          # @return Symbol
+          attr_accessor :subscore
+
+          # @return Integer
+          attr_accessor :y_max
+
+          def initialize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/charting/plottable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class Plottable  < Struct.new(:key, :label, :plotted_key, :questionnaire_key, :global)
+          def initialize(key, options = {})
+            key         = key
+            label       = options[:label]
+            plotted_key = options.fetch(:plotted_key) { :value }
+            global      = options[:global]
+            questionnaire_key = options[:questionnaire_key]
+            super(key, label, plotted_key, questionnaire_key, global)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/charting/radar_chart.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/charting/chart'
+
+module Quby
+  module Compiler
+    module Entities
+      module Charting
+        class RadarChart < Chart
+          def initialize(key, **kwargs)
+            super(key, **kwargs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'quby/compiler/services/definition_validator'
+
+module Quby
+  module Compiler
+    module Entities
+      class Definition
+        extend  ActiveModel::Naming
+        include ActiveModel::Validations
+
+        attr_accessor :key, :sourcecode, :timestamp, :path
+
+        def initialize(key:, path:, sourcecode: "", timestamp: nil)
+          @path = path
+          @key = key
+          @sourcecode = sourcecode
+          @timestamp = timestamp
+        end
+
+        validates_with Services::DefinitionValidator
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Quby
+  module Compiler
+    module Entities
+      class Fields
+        attr_reader :question_hash
+
+        # hash of all options from input_key to the QuestionOption.
+        # Used by including applications to lookup the definition of e.g. a check_box question.
+        attr_reader :option_hash
+
+        # An +answer_key+ is a key that will exist in the values hash of an answer. This means that answer keys for
+        # radio's will be just the question key, and answer keys for checkboxes will be the keys of all the options.
+        # These are the POST parameters when submitting the form, and so they must be globally unique or we won't know
+        # which question the received data belongs to.
+        attr_reader :answer_keys
+
+        # An +input_key+ is a key that uniquely identifies a single <input> tag. For radios, every radio option will
+        # have its own input key. This is needed because option keys must be globally unique so that they can be
+        # targeted by :depends_on relations.
+        attr_reader :input_keys
+
+        def initialize(questionnaire)
+          @question_hash = HashWithIndifferentAccess.new
+          @option_hash   = HashWithIndifferentAccess.new
+          @answer_keys   = Set.new
+          @input_keys    = Set.new
+          @questionnaire = questionnaire
+        end
+
+        def add(question)
+          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)
+          question.options.each do |option|
+            @option_hash[option.input_key] = option
+          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
+
+        # Given a list of question and option keys returns a list of input-keys. If a given key is a question-key,
+        # adds the question.input_keys If a given key is an option-input-key it adds the given key. Raises an error
+        # if a key is not defined.
+        def expand_input_keys(keys)
+          keys.reduce([]) do |ikeys, key|
+            if question_hash.key?(key)
+              ikeys += question_hash[key].input_keys
+            elsif input_keys.include?(key.to_sym)
+              ikeys << key
+            else
+              fail Entities::Questionnaire::UnknownInputKey, "Unknown input key #{key}"
+            end
+          end
+        end
+
+        # returns a human readable string description given a key of a question,
+        # question component (date components, checkbox options), score, flag or textvar
+        def description_for_variable(key)
+          # for questionnaires where we do not check_key_clashes we cannot reliably retrace the variable keys,
+          # since they contain conflicts between option keys and question keys
+          # in order to be safe we return a string explaining the issue
+          return "No description due to question/option key clash" if option_hash.key?(key) && question_hash.key?(key)
+
+          variable_description(key)
+        end
+
+        def as_json
+          question_hash
+        end
+
+        private
+
+        # warning, will contain a result even if option/answer key clashes exist for a given key
+        def variable_description(key)
+          @question_variable_descriptions ||= @questionnaire.questions
+                                                            .map(&:variable_descriptions)
+                                                            .reduce({}, &:merge!)
+          @question_variable_descriptions[key] ||
+            score_descriptions[key] ||
+            @questionnaire.flags[key]&.variable_description ||
+            @questionnaire.textvars[key]&.description
+        end
+
+        def score_descriptions
+          @score_variable_descriptions ||=
+            @questionnaire.score_schemas.values.map do |score_schema|
+              score_schema.subscore_schemas.map do |subschema|
+                [subschema.export_key, "#{score_schema.label} #{subschema.label}"]
+              end
+            end.flatten(1).to_h.with_indifferent_access
+        end
+      end
+    end
+  end
+end