quby-compiler 0.2.1

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/item'
+require 'quby/markdown_parser'
+
+module Quby
+  module Compiler
+    module Entities
+      class Text < Item
+        attr_reader :str
+        attr_accessor :display_in
+        attr_accessor :html_content
+
+        # In case of being displayed inside a table, amount of columns/rows to span
+        attr_accessor :col_span
+        attr_accessor :row_span
+
+        def initialize(str, options = {})
+          if options[:html_content]
+            options[:raw_content] = "<div class='item text'>" + options[:html_content] + "</div>"
+          end
+          super(options)
+          @str = str
+          @html_content = options[:html_content]
+          @display_in = options[:display_in] || [:paged]
+          @col_span = options[:col_span] || 1
+          @row_span = options[:row_span] || 1
+        end
+
+        def as_json(options = {})
+          super().merge(text: text)
+        end
+
+        def html
+          @html_content || text
+        end
+
+        def text
+          @text ||= Quby::MarkdownParser.new(str).to_html
+        end
+
+        def key
+          't0'
+        end
+
+        def type
+          "text"
+        end
+
+        def validate_answer(answer_hash)
+          true
+        end
+
+        def ==(other)
+          case other.class
+          when String
+            text == other
+          when self.class
+            text == other.text
+          else
+            false
+          end
+        end
+
+        def to_s
+          text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      class Textvar < Struct.new(:key, :description, :default, :depends_on_flag)
+        # rubocop:disable ParameterLists
+        def initialize(key:, description:, default: nil, depends_on_flag: nil)
+          default = "{{#{key}}}" unless default
+          super(key, description, default, depends_on_flag)
+        end
+        # rubocop:enable ParameterLists
+
+        def to_codebook(_options = {})
+          output = []
+          output << "#{key} Textvariabele"
+          output << description
+          output.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Quby
+  module Compiler
+    module Entities
+      class Validation
+        attr_reader :config
+
+        def initialize(config)
+          @config = config
+        end
+
+        def type
+          config[:type]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'active_model/model'
+
+module Quby
+  module Compiler
+    module Entities
+      class Version
+        include ActiveModel::Model
+
+        # @return [Integer]
+        attr_accessor :number
+
+        # @return [String]
+        attr_accessor :release_notes
+
+        # @return [Boolean]
+        attr_accessor :regenerate_outcome
+
+        # @return [Boolean]
+        attr_accessor :deactivate_answers
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Quby
+  module Compiler
+    module Entities
+      class VisibilityRule
+        def self.from(question)
+          [].tap do |rules|
+            # Transform "default invisible" into just being hidden by itself,
+            # since any other question showing it will take precedence anyway.
+            if question.default_invisible
+              rules << new(condition: { type: :always, field_key: question.key },
+                           action: { type: :hide_question, field_key: question.key })
+            end
+
+            case question.type
+            when :radio, :scale, :select
+              question.options.each do |option|
+                rules.concat rules_for_option(question, option, type: :equal)
+              end
+            when :check_box
+              question.options.each do |option|
+                rules.concat rules_for_option(question, option, type: :contains)
+              end
+            end
+          end
+        end
+
+        def self.rules_for_option(question, option, type:)
+          [].tap do |rules|
+            option.shows_questions.each do |shows_question|
+              rules << new(condition: { type: type, field_key: question.key, value: option.key },
+                           action: { type: :show_question, field_key: shows_question })
+            end
+
+            option.hides_questions.each do |hides_question|
+              rules << new(condition: { type: type, field_key: question.key, value: option.key },
+                           action: { type: :hide_question, field_key: hides_question })
+            end
+          end
+        end
+
+        def self.from_flag(flag)
+          condition = { type: "flag_equal", flag_key: flag.key, value: flag.trigger_on }
+
+          [].tap do |rules|
+            flag.shows_questions.each do |question_key|
+              rules << VisibilityRule.new(condition: condition, action: { type: "show_question", field_key: question_key })
+            end
+
+            flag.hides_questions.each do |question_key|
+              rules << VisibilityRule.new(condition: condition, action: { type: "hide_question", field_key: question_key })
+            end
+          end
+        end
+
+        attr_reader :condition, :action
+
+        def initialize(condition:, action:)
+          @condition = condition
+          @action = action
+        end
+
+        def as_json
+          {
+            condition: condition.transform_keys { |key| key.to_s.camelize(:lower) },
+            action: action.transform_keys { |key| key.to_s.camelize(:lower) },
+          }
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/instance.rb

@@ -0,0 +1,72 @@
+module Quby
+  module Compiler
+    class Instance
+      attr_reader :lookup_tables
+
+      def initialize(lookup_tables:)
+        @lookup_tables = lookup_tables
+      end
+
+      def compile(key:, sourcecode:, seeds:, path: nil, last_update: nil, &block)
+        if block # defined in block for tests
+          questionnaire = DSL.build(key, path: path, &block)
+        else # sourcecode given as string
+          tempfile = Tempfile.new(key)
+          questionnaire = Entities::Questionnaire.new(key, last_update: last_update)
+          Thread.current["quby-questionnaire-loading"] = Quby::Compiler::DSL::QuestionnaireBuilder.new(questionnaire, lookup_tables: lookup_tables)
+
+          tempfile.puts "Thread.current['quby-questionnaire-loading'].instance_eval do"
+          tempfile.puts sourcecode
+          tempfile.puts "end"
+          tempfile.flush
+
+          load tempfile.path
+          Thread.current['quby-questionnaire-loading'] = nil
+
+          questionnaire.callback_after_dsl_enhance_on_questions
+        end
+
+        {
+          outputs: {
+            definition: Output.new(
+              key: :definition,
+              filename: "definition.rb",
+              content: sourcecode,
+            ),
+            roqua: Output.new(
+              key: :roqua,
+              filename: "roqua.json",
+              content: Outputs::RoquaSerializer.new(questionnaire).to_json,
+            ),
+            seeds: Output.new(
+              key: :seeds,
+              filename: "seeds.yml",
+              content: YAML.dump(Outputs::SeedSerializer.new(questionnaire, seeds).generate),
+            ),
+            quby_frontend_v1: Output.new(
+              key: :quby_frontend_v1,
+              filename: "quby-frontend-v1.json",
+              content: Outputs::QubyFrontendV1Serializer.new(questionnaire).to_json,
+            ),
+            quby_frontend_v2: Output.new(
+              key: :quby_frontend_v2,
+              filename: "quby-frontend-v2.json",
+              content: Outputs::QubyFrontendV2Serializer.new(questionnaire).to_json,
+            ),
+          },
+        }
+      ensure
+        # We can only close and remove the file once serializers have finished.
+        # The serializers need the file in order to grab the source for score blocks
+        tempfile&.close
+        tempfile&.unlink
+      end
+
+      def validate(key:, sourcecode:)
+        definition = Entities::Definition.new(key: key, sourcecode: sourcecode, path: "validating '#{key}'")
+        definition.valid?
+        definition
+      end
+    end
+  end
+end

data/lib/quby/compiler/output.rb

@@ -0,0 +1,13 @@
+module Quby
+  module Compiler
+    class Output
+      attr_reader :key, :filename, :content
+
+      def initialize(key:, filename:, content:)
+        @key = key
+        @filename = filename
+        @content = content
+      end
+    end
+  end
+end

data/lib/quby/compiler/outputs.rb

@@ -0,0 +1,4 @@
+require 'quby/compiler/outputs/roqua_serializer'
+require 'quby/compiler/outputs/seed_serializer'
+require 'quby/compiler/outputs/quby_frontend_v1_serializer'
+require 'quby/compiler/outputs/quby_frontend_v2_serializer'

data/lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb

@@ -0,0 +1,362 @@
+require 'method_source'
+
+module Quby
+  module Compiler
+    module Outputs
+      class QubyFrontendV1Serializer
+        attr_reader :questionnaire
+
+        def initialize(questionnaire)
+          @questionnaire = questionnaire
+        end
+
+        def panels
+          questionnaire.panels.map do |panel|
+            {
+              key: panel.key,
+              title: panel.title,
+              items: panel.items.reject { |item| item.respond_to?(:table) && item.table }.map { |item| item_as_json(item) }
+            }
+          end
+        end
+
+        def item_as_json(item)
+          case item
+          when Quby::Compiler::Entities::Text
+            text_as_json(item)
+          when Quby::Compiler::Entities::Question
+            question_as_json(item)
+          when Quby::Compiler::Entities::Table
+            table_as_json(item)
+          end
+        end
+
+        def text_as_json(text)
+          {
+            type: 'text',
+            str: text.str,
+            html_content: text.html_content,
+            display_in: text.display_in,
+            col_span: text.col_span,
+            row_span: text.row_span,
+            raw_content: text.raw_content,
+            switch_cycle: text.switch_cycle,
+          }
+        end
+
+        def table_as_json(table)
+          {
+            type: 'table',
+            columns: table.columns,
+            title: table.title,
+            description: table.description,
+            show_option_desc: table.show_option_desc,
+            items: table.items.map { |item| item_as_json(item) }
+          }
+        end
+
+        def question_as_json(question)
+          base_options = {
+            type: 'question',
+            question_type: question.type,
+            key: question.key,
+            title: question.title,
+            context_free_title: question.context_free_title,
+            description: question.description,
+            presentation: question.presentation,
+            hidden: question.hidden,
+            depends_on: question.depends_on,
+            default_position: question.default_position,
+            col_span: question.col_span,
+            row_span: question.row_span,
+            validations: question.validations.map {|validation| validation_as_json(validation) },
+            raw_content: question.raw_content,
+            switch_cycle: question.switch_cycle,
+
+            sbg_key: question.sbg_key,
+            allow_duplicate_option_values: question.allow_duplicate_option_values,
+            allow_blank_titles: question.allow_blank_titles,
+            as: question.as,
+            display_modes: question.display_modes,
+            autocomplete: question.autocomplete,
+            show_values: question.show_values,
+            deselectable: question.deselectable,
+            disallow_bulk: question.disallow_bulk,
+            score_header: question.score_header,
+            sets_textvar: question.sets_textvar,
+            default_invisible: question.default_invisible,
+            question_group: question.question_group,
+            group_minimum_answered: question.group_minimum_answered,
+            group_maximum_answered: question.group_maximum_answered,
+            value_tooltip: question.input_data[:value_tooltip],
+
+            parent_option_key: question.parent_option_key,
+          }
+
+          case question
+          when Quby::Compiler::Entities::Questions::CheckboxQuestion
+            base_options.merge(
+              options: question.options.map { |option| option_as_json(option) },
+              check_all_option: question.check_all_option,
+              uncheck_all_option: question.uncheck_all_option,
+              maximum_checked_allowed: question.maximum_checked_allowed,
+              minimum_checked_required: question.minimum_checked_required
+            )
+          when Quby::Compiler::Entities::Questions::DateQuestion
+            base_options.merge(
+              components: question.components,
+              required_components: question.required_components,
+              year_key: question.year_key,
+              month_key: question.month_key,
+              day_key: question.day_key,
+              hour_key: question.hour_key,
+              minute_key: question.minute_key,
+            )
+          when Quby::Compiler::Entities::Questions::DeprecatedQuestion
+            base_options.merge(
+              options: question.options.map { |option| option_as_json(option) }
+            )
+          when Quby::Compiler::Entities::Questions::FloatQuestion
+            base_options.merge(
+              labels: question.labels,
+              unit: question.unit,
+              size: question.size,
+            )
+          when Quby::Compiler::Entities::Questions::IntegerQuestion
+            base_options.merge(
+              labels: question.labels,
+              unit: question.unit,
+              size: question.size,
+            )
+          when Quby::Compiler::Entities::Questions::RadioQuestion
+            base_options.merge(
+              options: question.options.map { |option| option_as_json(option) }
+            )
+          when Quby::Compiler::Entities::Questions::SelectQuestion
+            base_options.merge(
+              options: question.options.map { |option| option_as_json(option) }
+            )
+          when Quby::Compiler::Entities::Questions::StringQuestion
+            base_options.merge(
+              unit: question.unit,
+              size: question.size,
+            )
+          when Quby::Compiler::Entities::Questions::TextQuestion
+            base_options.merge(
+              lines: question.lines
+            )
+          else
+            raise "Unknown item type"
+          end
+        end
+
+        def validation_as_json(validation)
+          case validation[:type]
+          when :requires_answer
+            validation.slice(:type, :explanation)
+          when :answer_group_minimum, :answer_group_maximum
+            validation.slice(:type, :explanation, :group, :value)
+          when :valid_integer, :valid_float
+            validation.slice(:type, :explanation)
+          when :valid_date
+            validation.slice(:type, :explanation, :subtype).merge(value_type: validation[:value].class.to_s)
+          when :minimum, :maximum
+            validation.slice(:type, :explanation, :value, :subtype).merge(value_type: validation[:value].class.to_s)
+          when :too_many_checked
+            validation.slice(:type, :explanation, :uncheck_all_key)
+          when :minimum_checked_required
+            validation.slice(:type, :explanation, :minimum_checked_value)
+          when :maximum_checked_allowed
+            validation.slice(:type, :explanation, :maximum_checked_value)
+          when :regexp
+            validation.slice(:type, :explanation).merge(matcher: validation.fetch(:matcher).source)
+          when :not_all_checked
+            validation.slice(:type, :explanation, :check_all_key)
+          else
+            raise "Unknown validation type: #{validation.inspect}"
+          end
+        end
+
+        def option_as_json(option)
+          {
+            key: option.key,
+            value: option.value,
+            description: option.description,
+            context_free_description: option.context_free_description,
+            questions: option.questions.map {|question| question_as_json(question)},
+            inner_title: option.inner_title,
+            hides_questions: option.hides_questions,
+            shows_questions: option.shows_questions,
+            hidden: option.hidden,
+            placeholder: option.placeholder,
+          }
+        end
+
+        def score_calculations
+          questionnaire.score_calculations.transform_values do |score_calculation|
+            {
+              key: score_calculation.key,
+              label: score_calculation.label,
+              sbg_key: score_calculation.sbg_key,
+              options: score_calculation.options,
+              sourcecode: score_calculation.sourcecode
+            }
+          end
+        end
+
+        def score_schemas
+          questionnaire.score_schemas.transform_values do |schema|
+            {
+              key: schema.key,
+              label: schema.label,
+              subscore_schemas: schema.subscore_schemas.map do |subschema|
+                {
+                  key: subschema.key,
+                  label: subschema.label,
+                  export_key: subschema.export_key,
+                  only_for_export: subschema.only_for_export
+                }
+              end
+            }
+          end
+        end
+
+        def charts
+          {
+            overview: questionnaire.charts.overview && {
+              subscore: questionnaire.charts.overview.subscore,
+              y_max: questionnaire.charts.overview.y_max,
+            },
+            others: questionnaire.charts.map do |chart|
+              case chart
+              when Quby::Compiler::Entities::Charting::LineChart
+                {
+                  y_label: chart.y_label,
+                  tonality: chart.tonality,
+                  baseline: YAML.dump(chart.baseline),
+                  clinically_relevant_change: chart.clinically_relevant_change,
+                }
+              when Quby::Compiler::Entities::Charting::OverviewChart
+                {
+                  subscore: chart.subscore,
+                  y_max: chart.y_max,
+                }
+              else
+                {}
+              end.merge(
+                key: chart.key,
+                type: chart.type,
+                title: chart.title,
+                plottables: chart.plottables,
+                y_categories: chart.y_categories,
+                y_range_categories: chart.y_range_categories,
+                chart_type: chart.chart_type,
+                y_range: range_as_json(chart.y_range),
+                tick_interval: chart.tick_interval,
+                plotbands: chart.plotbands,
+                plotlines: chart.plotlines
+              )
+            end
+          }
+        end
+
+        def flags
+          questionnaire.flags.transform_values do |flag|
+            {
+              key: flag.key,
+              description_true: flag.description_true,
+              description_false: flag.description_false,
+              description: flag.description,
+              internal: flag.internal,
+              trigger_on: flag.trigger_on,
+              shows_questions: flag.shows_questions,
+              hides_questions: flag.hides_questions,
+              depends_on: flag.depends_on,
+              default_in_interface: flag.default_in_interface,
+            }
+          end
+        end
+
+        def textvars
+          questionnaire.textvars.transform_values do |textvar|
+            {
+              key: textvar.key,
+              description: textvar.description,
+              default: textvar.default,
+              depends_on_flag: textvar.depends_on_flag,
+            }
+          end
+        end
+
+        def lookup_tables
+          # TODO: Figure out something better. For now, no interest in walking a tree and converting Range objects to something JSON-able.
+          YAML.dump(questionnaire.lookup_tables)
+        end
+
+        def outcome_tables
+          # TODO DOes not seem to be used in definitions?
+          questionnaire.outcome_tables.map do |outcome_table|
+            {
+              key: outcome_table.key,
+              score_keys: outcome_table.score_keys,
+              subscore_keys: outcome_table.subscore_keys,
+              name: outcome_table.name,
+              default_collapsed: outcome_table.default_collapsed,
+            }
+          end
+        end
+
+        def as_json(options = {})
+          {
+            key: questionnaire.key,
+            title: questionnaire.title,
+            description: questionnaire.description,
+            outcome_description: questionnaire.outcome_description,
+            short_description: questionnaire.short_description,
+            abortable: questionnaire.abortable,
+            enable_previous_questionnaire_button: questionnaire.enable_previous_questionnaire_button,
+            default_answer_value: questionnaire.default_answer_value,
+            leave_page_alert: questionnaire.leave_page_alert,
+            allow_hotkeys: questionnaire.allow_hotkeys,
+            license: questionnaire.license,
+            licensor: questionnaire.licensor,
+            language: questionnaire.language,
+            renderer_version: questionnaire.renderer_version,
+            last_update: questionnaire.last_update,
+            last_author: questionnaire.last_author,
+            extra_css: questionnaire.extra_css,
+            allow_switch_to_bulk: questionnaire.allow_switch_to_bulk,
+
+            panels: panels,
+            score_calculations: score_calculations,
+            score_schemas: score_schemas,
+            flags: flags,
+            textvars: textvars,
+            lookup_tables: lookup_tables,
+
+            # belong to roqua domain, but for now they're here too:
+            roqua_keys: questionnaire.roqua_keys,
+            sbg_key: questionnaire.sbg_key,
+            sbg_domains: questionnaire.sbg_domains,
+            outcome_regeneration_requested_at: questionnaire.outcome_regeneration_requested_at,
+            deactivate_answers_requested_at: questionnaire.deactivate_answers_requested_at,
+            respondent_types: questionnaire.respondent_types,
+            tags: questionnaire.tags.to_h.keys,
+            charts: charts,
+            outcome_tables: outcome_tables,
+          }
+        end
+
+        def range_as_json(range)
+          return unless range
+
+          {
+            begin: range.begin,
+            end: range.end,
+            exclude_end: range.exclude_end?
+          }
+        end
+      end
+    end
+  end
+end