quby-compiler 0.2.1

data/lib/quby/compiler/dsl/charting/chart_builder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities'
+
+module Quby
+  module Compiler
+    module DSL
+      class ChartBuilder
+        # rubocop:disable AccessorMethodName
+        def self.set_chart_class(chart_class)
+          @chart_class = chart_class
+        end
+        # rubocop:enable AccessorMethodName
+
+        def self.chart_class
+          @chart_class
+        end
+
+        def initialize(questionnaire, key, options = {})
+          @chart = self.class.chart_class.new(key, options)
+          @questionnaire = questionnaire
+        end
+
+        def title(title)
+          @chart.title = title
+        end
+
+        def range(range)
+          @chart.y_range = range
+        end
+
+        def tick_interval(tick_interval)
+          @chart.tick_interval = tick_interval
+        end
+
+        def y_categories(y_categories)
+          @chart.y_categories = y_categories
+        end
+
+        def y_range_categories(*y_range_categories)
+          @chart.y_range_categories = RangeCategories.new(*y_range_categories).as_range_hash
+        end
+
+        def plotband(from, to, color)
+          @chart.plotbands << {from: from, to: to, color: color}
+        end
+
+        def plotline(value, color)
+          @chart.plotlines << {value: value, color: color}
+        end
+
+        def plot(key, options = {})
+          unless plottable = @questionnaire.find_plottable(key)
+            fail "Questionnaire #{@questionnaire.key} chart #{@chart.key} references unknown score or question #{key}"
+          end
+
+          configure_options plottable, options
+
+          @chart.plottables << Entities::Charting::Plottable.new(plottable.key, options)
+        end
+
+        def chart_type(type)
+          @chart.chart_type = type
+        end
+
+        def build(&block)
+          instance_eval(&block)
+          validate!
+          @chart
+        end
+
+        def validate!
+          if @chart.y_categories.present? && @chart.y_range.present? &&
+             @chart.y_range != (0..(@chart.y_categories.count - 1))
+            fail ArgumentError, 'Y_categories size and range do not match'
+          end
+
+          true
+        end
+
+        private
+
+        def configure_options(plottable, options)
+          case plottable
+          when Entities::ScoreCalculation
+            options.reverse_merge! plottable.options
+          when Entities::Question
+            options[:label] ||= plottable.title
+          end
+          options[:questionnaire_key] = @questionnaire.key
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/charting/line_chart_builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/charting/line_chart'
+require_relative 'chart_builder'
+
+module Quby
+  module Compiler
+    module DSL
+      class LineChartBuilder < ChartBuilder
+        set_chart_class(Entities::Charting::LineChart)
+
+        def y_axis_label(label)
+          @chart.y_label = label
+        end
+
+        def tonality(value)
+          @chart.tonality = value
+        end
+
+        def baseline(value)
+          @chart.baseline = value
+        end
+
+        def clinically_relevant_change(value)
+          @chart.clinically_relevant_change = value
+        end
+
+        def validate!
+          fail "Chart #{@chart.key} has no range specified" unless @chart.y_range
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/charting/overview_chart_builder.rb

@@ -0,0 +1,31 @@
+require 'quby/compiler/entities/charting/overview_chart'
+require_relative 'chart_builder'
+
+module Quby
+  module Compiler
+    module DSL
+      class OverviewChartBuilder < ChartBuilder
+        set_chart_class(Entities::Charting::OverviewChart)
+
+        def initialize(questionnaire, options = {})
+          @questionnaire = questionnaire
+          @chart = self.class.chart_class.new
+        end
+
+        def subscore(key)
+          @chart.subscore = key
+        end
+
+        def y_max(value)
+          @chart.y_max = value
+        end
+
+        def validate!
+          fail ArgumentError, "subscore not specified" unless @chart.subscore.present?
+          fail ArgumentError, "y_max not specified" unless @chart.y_max.present?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/charting/radar_chart_builder.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/charting/radar_chart'
+require_relative 'chart_builder'
+
+module Quby
+  module Compiler
+    module DSL
+      class RadarChartBuilder < ChartBuilder
+        set_chart_class(Entities::Charting::RadarChart)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Helpers
+        include ActionView::Helpers::TagHelper
+        include ActionView::Helpers::OutputSafetyHelper
+
+        def image_tag(source, options = {})
+          tag.img(options.reverse_merge(src: source, alt: image_alt(source)))
+        end
+
+        # Copied from ActionController::Base.helpers.image_alt, because it will be removed from Rails 6.0, but we want
+        # to keep using this functionality
+        def image_alt(source)
+          File.basename(source, ".*").sub(/-[[:xdigit:]]{32,64}\z/, "").tr("-_", " ").capitalize
+        end
+
+        def check_question_keys_uniqueness(key, options, questionnaire)
+          keys = QuestionBuilder.build(key, options).claimed_keys
+          if keys.any? { |k| questionnaire.key_in_use? k }
+            fail "#{questionnaire.key}:#{key}: A question or option with input key #{key} is already defined."
+          end
+        end
+
+        def video_tag(*urls, poster: nil, autoplay: false, loop: false)
+          # assume the file extension is the video format
+          # otherwise, the host's declared mime type is used to figure out compatibility
+          # which is usually wrong
+          sources = urls.map { |url| [url, url.match(/[^\.]*\z/)&.[](0).downcase] }
+          sources.each { |_url, ext| raise 'unknown video url file extension' unless %w[mp4 webm].include?(ext) }
+
+          options = {
+            width: '100%',
+            preload: 'none',
+            poster: poster,
+            loop: loop,
+            autoplay: autoplay,
+            muted: autoplay,
+            controls: ''
+          }
+
+          content = sources.map { |url, ext| tag.source src: url, type: "video/#{ext}" }
+            .append(I18n.t('video_not_supported'))
+            .yield_self(&tag.method(:safe_join))
+
+          content_tag(:video, content, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities'
+
+module Quby
+  module Compiler
+    module DSL
+      class PanelBuilder < Base
+        attr_reader :title
+        attr_reader :questionnaire
+
+        def initialize(title, options = {})
+          @panel = Entities::Panel.new(options.merge(title: title, items: []))
+          @default_question_options = options[:default_question_options] || {}
+          @questionnaire = options[:questionnaire]
+          @custom_methods = options[:custom_methods] || {}
+        end
+
+        def build
+          @panel
+        end
+
+        def title(value)
+          @panel.title = value
+        end
+
+        def text(value, options = {})
+          @panel.items << Entities::Text.new(value.to_s, options)
+        end
+
+        def html(value)
+          @panel.items << Entities::Text.new('', html_content: value.to_s)
+        end
+
+        def raw_html(value)
+          @panel.items << Entities::Text.new('', raw_content: value.to_s)
+        end
+
+        def video(*urls, **options)
+          video_html = video_tag *urls, **options
+          @panel.items << Entities::Text.new('', raw_content: video_html)
+        end
+
+        def default_question_options(options = {})
+          @default_question_options = @default_question_options.merge(options)
+        end
+
+        def question(key, options = {}, &block)
+          options = @default_question_options.merge(options).merge(questionnaire: @panel.questionnaire)
+
+          check_question_keys_uniqueness key, options, @questionnaire
+
+          question = QuestionBuilder.build(key, options, &block)
+
+          @questionnaire.register_question(question)
+          @panel.items << question
+        end
+
+        def table(options = {}, &block)
+          table_builder = TableBuilder.new(@panel, options.merge(questionnaire: @panel.questionnaire,
+                                                                 default_question_options: @default_question_options,
+                                                                 custom_methods: @custom_methods))
+          table_builder.instance_eval(&block) if block
+        end
+
+        def method_missing(method_sym, *args, &block)
+          if @custom_methods.key? method_sym
+            instance_exec(*args, &@custom_methods[method_sym])
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @custom_methods.key?(method_name) || super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities'
+
+require 'quby/compiler/dsl/questions/base'
+require 'quby/compiler/dsl/questions/checkbox_question_builder'
+require 'quby/compiler/dsl/questions/date_question_builder'
+require 'quby/compiler/dsl/questions/deprecated_question_builder'
+require 'quby/compiler/dsl/questions/float_question_builder'
+require 'quby/compiler/dsl/questions/integer_question_builder'
+require 'quby/compiler/dsl/questions/radio_question_builder'
+require 'quby/compiler/dsl/questions/select_question_builder'
+require 'quby/compiler/dsl/questions/string_question_builder'
+require 'quby/compiler/dsl/questions/text_question_builder'
+
+module Quby
+  module Compiler
+    module DSL
+      module QuestionBuilder
+        include Helpers
+        BUILDERS = {
+          'string'    => Questions::StringQuestionBuilder,
+          'textarea'  => Questions::TextQuestionBuilder,
+          'integer'   => Questions::IntegerQuestionBuilder,
+          'float'     => Questions::FloatQuestionBuilder,
+          'radio'     => Questions::RadioQuestionBuilder,
+          'scale'     => Questions::RadioQuestionBuilder,
+          'select'    => Questions::SelectQuestionBuilder,
+          'check_box' => Questions::CheckboxQuestionBuilder,
+          'date'      => Questions::DateQuestionBuilder,
+          'hidden'    => Questions::DeprecatedQuestionBuilder
+        }
+
+        def self.build(key, options = {}, &block)
+          BUILDERS.fetch(options.fetch(:type).to_s).build(key, options, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/dsl/panel_builder'
+require 'quby/compiler/dsl/table_builder'
+require 'quby/compiler/dsl/question_builder'
+require 'quby/compiler/dsl/score_builder'
+require 'quby/compiler/dsl/charting/line_chart_builder'
+require 'quby/compiler/dsl/charting/radar_chart_builder'
+require 'quby/compiler/dsl/charting/bar_chart_builder'
+require 'quby/compiler/dsl/charting/overview_chart_builder'
+
+require_relative 'standardized_panel_generators'
+
+module Quby
+  module Compiler
+    module DSL
+      class QuestionnaireBuilder
+        prepend CallsCustomMethods
+        include StandardizedPanelGenerators
+        include Helpers
+
+        def initialize(target_instance, lookup_tables: nil)
+          @questionnaire = target_instance
+          @lookup_tables = lookup_tables
+          @default_question_options = {}
+          @custom_methods = {}
+        end
+
+        def leave_page_alert(text)
+          @questionnaire.leave_page_alert = text
+        end
+
+        def key(key)
+          # no-op, key is now passed in to Questionnaire constructor
+        end
+
+        def roqua_keys(*keys)
+          @questionnaire.roqua_keys = keys
+        end
+
+        def seeds_patch(value)
+          @questionnaire.seeds_patch = value
+        end
+
+        def do_not_check_key_clashes
+          @questionnaire.check_key_clashes = false
+        end
+
+        def do_not_check_score_keys_consistency
+          @questionnaire.check_score_keys_consistency = false
+        end
+
+        def do_not_validate_html
+          @questionnaire.validate_html = false
+        end
+
+        def title(title)
+          @questionnaire.title = title
+        end
+
+        def description(description)
+          @questionnaire.description = description
+        end
+
+        def outcome_description(description)
+          @questionnaire.outcome_description = description
+        end
+
+        def short_description(description)
+          @questionnaire.short_description = description
+        end
+
+        def sbg_key(sbg_key)
+          @questionnaire.sbg_key = sbg_key
+        end
+
+        def sbg_domain(sbg_code, outcome:, from: nil, till: nil, sbg_key: nil, primary: false)
+          @questionnaire.sbg_domains << {
+            sbg_code: sbg_code,
+            from: from,
+            till: till,
+            outcome: outcome,
+            sbg_key: sbg_key || @questionnaire.sbg_key,
+            primary: primary
+          }
+        end
+
+        def abortable
+          @questionnaire.abortable = true
+        end
+
+        def allow_hotkeys(type = :all)
+          @questionnaire.allow_hotkeys = type
+        end
+
+        def license(type, licensor: nil)
+          @questionnaire.license  = type
+          @questionnaire.licensor = licensor
+        end
+
+        def language(language)
+          @questionnaire.language = language
+        end
+
+        def respondent_types(*respondent_types)
+          @questionnaire.respondent_types = respondent_types
+        end
+
+        def tags(*tags)
+          @questionnaire.tags = tags
+        end
+
+        def version(number, release_notes:, regenerate_outcome: false, deactivate_answers: false)
+          @questionnaire.versions << Entities::Version.new(
+            number: number,
+            release_notes: release_notes,
+            regenerate_outcome: regenerate_outcome,
+            deactivate_answers: deactivate_answers
+          )
+        end
+
+        def outcome_regeneration_requested_at(timestamp)
+          @questionnaire.outcome_regeneration_requested_at = timestamp
+        end
+
+        def deactivate_answers_requested_at(timestamp)
+          @questionnaire.deactivate_answers_requested_at = timestamp
+        end
+
+        def enable_previous_questionnaire_button
+          @questionnaire.enable_previous_questionnaire_button = true
+        end
+
+        def renderer_version(version)
+          @questionnaire.renderer_version = version
+        end
+
+        def css(value)
+          @questionnaire.extra_css += value
+        end
+
+        def allow_switch_to_bulk(value=true)
+          @questionnaire.allow_switch_to_bulk = value
+        end
+
+        def default_answer_value(value)
+          @questionnaire.default_answer_value = value
+        end
+
+        def panel(title = nil, options = {}, &block)
+          panel = PanelBuilder.build(title, options.merge(default_panel_options), &block)
+          @questionnaire.add_panel(panel)
+        end
+
+        def custom_method(key, &block)
+          if PanelBuilder.new(nil, custom_methods: @custom_methods).respond_to? key
+            fail 'Custom method trying to override existing method'
+          end
+          @custom_methods[key] = block
+        end
+
+        def import_lookup_tree(key)
+          @questionnaire.lookup_tables[key] = @lookup_tables.fetch(key)
+        end
+
+        def add_lookup_tree(key, levels:, tree:)
+          @questionnaire.lookup_tables[key] = {levels: levels, tree: tree}
+        end
+
+        def default_question_options(options = {})
+          @default_question_options.merge!(options)
+        end
+
+        # Short-circuit the question command to perform an implicit panel
+        def question(key, options = {}, &block)
+          panel(nil, default_panel_options) do
+            question(key, @default_question_options.merge(options).merge(questionnaire: @questionnaire), &block)
+          end
+        end
+
+        # Short-circuit the text command to perform an implicit panel
+        def text(value, options = {})
+          panel(nil, default_panel_options) do
+            text(value, options)
+          end
+        end
+
+        # Short-circuit the table command to perform an implicit panel
+        def table(options = {}, &block)
+          panel(nil, default_panel_options) do
+            table(options, &block)
+          end
+        end
+
+        # variable :totaal do
+        #   # Plain old Ruby code here, executed in the scope of the answer
+        #   # variables are private to the score calculation
+        #   q01 + q02 + q03
+        # end
+        def variable(key, options = {}, &block)
+          @questionnaire.add_score_calculation ScoreBuilder.new(key, options, &block).build
+        end
+
+        def score(key, options = {}, &block)
+          @questionnaire.errors.add "Score #{key}", 'misses label in score call' if options[:label].blank?
+          schema = options.delete(:schema)
+          score_schema(key, options[:label], schema) if schema.present?
+          variable(key, options.reverse_merge(score: true), &block)
+        end
+
+        def score_schema(key, label, options = nil, &block)
+          if block
+            schema, calculations = ScoreSchemaBuilder.build(key: key, label: label, &block)
+            @questionnaire.add_score_schema schema
+            calculations.each do |calculation|
+              @questionnaire.add_score_calculation calculation
+            end
+          else
+            @questionnaire.add_score_schema Entities::ScoreSchema.new key: key,
+                                                                      label: label,
+                                                                      subscore_schemas: options
+          end
+        end
+
+        def attention(options = {}, &block)
+          variable(:attention, options.reverse_merge(action: true), &block)
+        end
+
+        def alarm(options = {}, &block)
+          variable(:alarm, options.reverse_merge(action: true), &block)
+        end
+
+        def completion(options = {}, &block)
+          variable(:completion, options.reverse_merge(completion: true), &block)
+        end
+
+        def overview_chart(*args, &block)
+          raise "Cannot define more than one overview chart" if @questionnaire.charts.overview.present?
+          builder = OverviewChartBuilder.new(@questionnaire, *args)
+          @questionnaire.charts.overview = builder.build(&block)
+        end
+
+        def line_chart(*args, &block)
+          builder = LineChartBuilder.new(@questionnaire, *args)
+          @questionnaire.add_chart(builder.build(&block))
+        end
+
+        def bar_chart(*args, &block)
+          builder = BarChartBuilder.new(@questionnaire, *args)
+          @questionnaire.add_chart(builder.build(&block))
+        end
+
+        def radar_chart(*args, &block)
+          builder = RadarChartBuilder.new(@questionnaire, *args)
+          @questionnaire.add_chart(builder.build(&block))
+        end
+
+        def flag(flag_options)
+          @questionnaire.add_flag flag_options
+        end
+
+        def textvar(textvar_options)
+          @questionnaire.add_textvar textvar_options
+        end
+
+        def outcome_table(table_options)
+          @questionnaire.add_outcome_table table_options
+        end
+
+        private
+
+        def default_panel_options
+          {questionnaire: @questionnaire, default_question_options: @default_question_options,
+           custom_methods: @custom_methods}
+        end
+      end
+    end
+  end
+end