quby-compiler 0.2.1

data/lib/quby/compiler/services/quby_proxy.rb

@@ -0,0 +1,405 @@
+# rubocop:disable all
+require "active_support/all"
+require 'roqua/core_ext/enumerable/sort_by_alphanum'
+require 'quby/compiler/services/seed_diff'
+
+module Quby
+  module Compiler
+    module Services
+      class QubyProxy
+        HEADERS = { value: "Score",
+                    interpretation: "Interpretatie",
+                    clin_interp: "Klinisch",
+                    norm: "Norm",
+                    tscore: "T-Score",
+                    dimensie: "Dimensie",
+                    mean: "Gemiddelde" }
+
+        attr_reader :questionnaire, :options
+
+        def initialize(questionnaire, options)
+          @questionnaire = questionnaire
+          @options = options
+        end
+
+        def generate(seed)
+          question_titles = generate_question_titles
+          d_qtypes = {}
+          vars = []
+          @hidden_questions = {} # hash containing questions hidden by other questions
+
+          for question in questions_flat
+            if question.hidden && question.type != :check_box
+              d_qtypes[question.key.to_s] = { depends: :present } unless options[:without_depends]
+            end
+            unless question.hidden && (question.type == :check_box || question.type == :hidden)
+              vars << question.key.to_s
+            end
+
+            case question.type
+            when :radio, :scale
+              handle_scale(question, question_titles, d_qtypes, vars)
+            when :select
+              d_qtypes[question.key.to_s] = { type: :discrete }
+              for option in question.options
+                d_qtypes[question.key.to_s][option.value.to_s] = strip_p_tag(option.context_free_description || "") unless option.placeholder
+              end
+              update_hidden_questions_for(question)
+            when :check_box
+              d_qtypes[question.key.to_s] = { type: :check_box }
+              question.options.each do |option|
+                next if option.inner_title
+                vars << option.key.to_s
+                if question.hidden
+                  question_titles[option.key.to_s] = strip_tags question.context_free_title
+                end
+                value = 1
+                option_type = { type: :discrete }
+                option_type[value.to_s] = (option.context_free_description || "")
+                option_type[:depends] = { values: [value, value.to_s].uniq, variable: option.key.to_s } unless options[:without_depends]
+                d_qtypes[option.key.to_s] = option_type
+                values = [value, value.to_s].uniq
+                handle_subquestions(question, question_titles, d_qtypes, vars, option, values, option.key.to_s)
+              end
+              update_hidden_questions_for(question, for_checkbox: true)
+            when :textarea
+              d_qtypes[question.key.to_s] = { type: :text_field }
+            when :string, :integer, :float
+              handle_textfield(question, d_qtypes)
+            when :date
+              d_qtypes[question.key.to_s] = question.components.each_with_object({ type: :date }) do |component, hash|
+                key = question.send("#{component}_key")
+                vars << key.to_s
+                hash[component] = key.to_s
+              end
+            when :hidden
+              if question.options.blank? # string
+                question_titles[question.key.to_s] = strip_tags question.context_free_title
+                vars << question.key.to_s unless vars.include? question.key.to_s
+                d_qtypes[question.key.to_s] = { type: :text }
+                d_qtypes[question.key.to_s][:depends] = :present unless options[:without_depends]
+              else
+                no_keys = true
+                values = []
+                question.options.each do |option|
+                  if option.value # scale or radio
+                    vars << question.key.to_s unless vars.include? question.key.to_s
+                    next if option.inner_title
+                    d_qtypes[question.key.to_s] ||= { type: :scale }
+                    values << option.value.to_s
+                    d_qtypes[question.key.to_s][option.value.to_s] = strip_p_tag(option.context_free_description || "")
+                    # TODO: missing sub-questions
+                  else # check_box
+                    d_qtypes[question.key.to_s] ||= { type: :check_box }
+                    no_keys = false
+                    question_titles[option.key.to_s] = strip_tags question.context_free_title
+                    vars << option.key.to_s
+                    value = option.value || 1
+                    option_type = { type: :discrete }
+                    option_type[value.to_s] = (option.context_free_description || "")
+                    option_type[:depends] = { values: [value, value.to_s].uniq, variable: option.key.to_s } unless options[:without_depends]
+                    d_qtypes[option.key.to_s] = option_type
+                    # TODO: missing sub-questions
+                  end
+                end
+                if no_keys # scale or radio
+                  d_qtypes[question.key.to_s][:depends] = { values: values, variable: question.key.to_s } unless options[:without_depends]
+                  question_titles[question.key.to_s] = strip_tags question.context_free_title
+                end
+              end
+            else
+              fail "WARNING: Unimplemented type #{question.type}."
+            end
+
+            update_dqtypes_depends(d_qtypes, question, options)
+          end
+
+          seed["quests"] = sort_nested_hash(question_titles)
+          seed["d_qtypes"] = sort_nested_hash(d_qtypes)
+          seed["name"] = questionnaire.title
+          seed["short_description"] = questionnaire.short_description unless questionnaire.short_description.blank?
+          seed["description"] = questionnaire.description unless questionnaire.description.blank?
+
+          # this approach preserves the order of vars as much as possible, adding new vars to the end of the list
+          old_vars = (seed["vars"]&.split(",") || []).map(&:to_s)
+          new_vars = vars.map(&:to_s)
+          seed["vars"] = ((old_vars & new_vars) | new_vars).join(",")
+
+          scores = process_scores
+
+          seed["properties"] ||= {}
+          # headers outcome (humanized)
+          seed["properties"][:score_headers] = scores[:headers]
+          # headers data-export
+          seed["properties"][:score_keys] = scores[:keys]
+          # score names outcome (humanized)
+          seed["properties"][:score_labels] = scores[:labels]
+
+          seed["properties"].merge!(@options[:properties]) if @options.key?(:properties)
+          seed["properties"] = sort_nested_hash(seed["properties"])
+
+          data = {"key" => seed["key"] || options[:roqua_key] || questionnaire.key, "remote_id" => questionnaire.key}
+          attrs = %w(name vars quests d_qtypes properties short_description)
+          attrs.sort.each do |name|
+            data[name] = seed[name]
+          end
+
+          data
+        end
+
+        def update_hidden_questions_for(question, for_checkbox: false)
+          shows = question.options.each_with_object({}) do |option, shows|
+            next if option.inner_title
+            for key in option.shows_questions
+              skey = key.to_s
+              if for_checkbox
+                # is another checkbox option already showing the target question?
+                if shows.key?(skey)
+                  # then set the target's depends on :present, since we cannot represent depending on multiple variables
+                  shows[skey] = :present
+                else
+                  shows[skey] = { values: ["1", 1], variable: option.key.to_s }
+                end
+              else
+                shows[skey] ||= { values: [], variable: question.key.to_s }
+                shows[skey][:values] |= [option.value.to_s, option.value]
+              end
+            end
+          end
+          for skey, show in shows
+            # if a different question is already showing the same question, we cannot register a dependency on both questions
+            # (the 'variable' attribute accepts only 1 key). Thus it is better to show the question based on presence of
+            # an answer instead of on the depended question's answers.
+            if @hidden_questions.has_key?(skey)
+              @hidden_questions[skey] = :present
+            else
+              @hidden_questions[skey] = show
+            end
+          end
+        end
+
+        def update_dqtypes_depends(d_qtypes, question, options)
+          if hidden = @hidden_questions[question.key.to_s]
+            d_qtypes[question.key.to_s][:depends] ||= hidden unless options[:without_depends]
+          end
+        end
+
+        def generate_question_titles
+          question_titles = {}
+
+          for question in questions_flat
+            unless question.hidden && (question.type == :check_box || question.type == :hidden)
+              title = question.context_free_title || question.description || ""
+              question_titles[question.key.to_s] = strip_tags(title)
+            end
+          end
+
+          question_titles
+        end
+
+        def questions_flat
+          @questions_flat ||= questionnaire.panels.map do |panel|
+            panel.items.select { |item| item.is_a? Quby::Compiler::Entities::Question }
+          end.flatten.compact
+        end
+
+        def handle_subquestions(question, quests, d_qtypes, vars, option, values, key)
+          option.questions.each do |quest|
+            if quest.presentation == :next_to_title && ![:string, :integer, :float].include?(quest.type)
+              fail "unsupported title question type"
+            end
+            case quest.type
+            when :string, :integer, :float
+              subquestion(question, quests, d_qtypes, vars, quest, values, key)
+            when :textarea
+              sub_textfield(question, quests, d_qtypes, vars, quest, values, key)
+            when :radio
+              sub_radio(question, quests, d_qtypes, vars, quest, values, key)
+            when :date
+              sub_date(question, quests, d_qtypes, vars, quest, values, key)
+            else
+              fail "Unimplemented type #{quest.type} for sub_question"
+            end
+          end
+        end
+
+        def subquestion(question, quests, d_qtypes, vars, quest, values, key)
+          d_qtypes[quest.key.to_s] = { type: :text }
+          unless options[:without_depends]
+            if quest.presentation == :next_to_title
+              # make title questons dependent on themselves so we don't have to dig into quby's depends relations
+              # which sometimes refer to some of the parent's options, but not always the correct ones
+              d_qtypes[quest.key.to_s][:depends] = :present
+            else
+              d_qtypes[quest.key.to_s][:depends] = { values: values, variable: key }
+            end
+          end
+          d_qtypes[quest.key.to_s][:label] = quest.unit unless quest.unit.blank?
+          quests[quest.key.to_s] = strip_tags(quest.context_free_title || "")
+          vars << quest.key.to_s
+        end
+
+        def sub_textfield(question, quests, d_qtypes, vars, quest, values, key)
+          d_qtypes[quest.key.to_s] = { type: :text_field }
+          d_qtypes[quest.key.to_s][:depends] = { values: values, variable: key } unless options[:without_depends]
+          quests[quest.key.to_s] = strip_tags(quest.context_free_title || "")
+          vars << quest.key.to_s
+        end
+
+        def sub_radio(question, quests, d_qtypes, vars, quest, values, key)
+          d_qtypes[quest.key.to_s] = { type: :scale }
+          d_qtypes[quest.key.to_s][:depends] = { values: values, variable: key } unless options[:without_depends]
+          quests[quest.key.to_s] = strip_tags(quest.context_free_title || "")
+          for option in quest.options
+            next if option.inner_title
+            d_qtypes[quest.key.to_s][option.value.to_s] = strip_p_tag(option.context_free_description || "")
+          end
+          vars << quest.key.to_s
+          update_hidden_questions_for(quest)
+        end
+
+        def sub_date(question, quests, d_qtypes, vars, quest, values, key)
+          d_qtypes[quest.key.to_s] = quest.components.each_with_object({ type: :date }) do |component, hash|
+            key = quest.send("#{component}_key")
+            vars << key
+            hash[component] = key.to_s
+          end
+          quests[quest.key.to_s] = strip_tags(quest.context_free_title || "")
+        end
+
+        def handle_scale(question, quests, d_qtypes, vars)
+          d_qtypes[question.key.to_s] = { type: :scale }
+          values = []
+          update_hidden_questions_for(question)
+          for option in question.options
+            next if option.inner_title
+            d_qtypes[question.key.to_s][option.value.to_s] = strip_p_tag(option.context_free_description || "")
+            values << option.value.to_s
+            key = question.key.to_s
+            handle_subquestions(question, quests, d_qtypes, vars, option, [option.value.to_s], key)
+          end
+        end
+
+        def handle_textfield(question, d_qtypes)
+          d_qtypes[question.key.to_s] = { type: :text }
+          d_qtypes[question.key.to_s][:label] = question.unit unless question.unit.blank?
+        end
+
+        def strip_p_tag(text)
+          text.gsub(/^<p>(.*)<\/p>\n?$/, "\\1")
+        end
+
+        def process_scores
+          scores_from_schemas
+        end
+      
+        def scores_from_schemas
+          score_headers = [] # headers outcome (humanized name for subscores)
+          score_keys    = [] # headers data-export (not all of it, just the score_subscore part, shortened)
+          score_labels  = [] # score names outcome (humanized name for score as a whole)
+      
+          questionnaire.score_schemas.values.each do |score_schema|
+            score_labels << score_schema.label
+            score_keys << score_schema.subscore_schemas.map do |subschema|
+              hash = {
+                key: subschema.key,
+                header: subschema.export_key.to_s # a shortened key used as PART OF the csv export column headers
+              }
+              if subschema.only_for_export
+                hash.merge(hidden: true)
+              else
+                hash
+              end
+            end
+      
+            headers = score_schema.subscore_schemas.map(&:label)
+            score_headers += headers - score_headers
+          end
+      
+          {
+            headers: score_headers,
+            keys: score_keys,
+            labels: score_labels
+          }
+        end
+      
+        class ShortenKeysUniq
+          def initialize
+            @seen_results = []
+          end
+
+          def shorten_one(key)
+            key = key.to_s
+            limit = 2
+            shortened_key = nil
+            loop do
+              shortened_key = key[0..limit]
+              if key[limit] == "_"
+                limit += 1
+                next
+              end
+              break unless @seen_results.include?(shortened_key)
+              raise "duplicate key, #{key}" if shortened_key.length == key.length
+              limit += 1
+            end
+
+            @seen_results << shortened_key
+            shortened_key
+          end
+
+          def shorten_two(first_key, second_key)
+            first_key = first_key.to_s
+            second_key = second_key.to_s
+            first_limit = [2, first_key.length - 1].min
+            second_limit = 0
+            shortened_key = nil
+            loop do
+              shortened_key = "#{first_key[0..first_limit]}_#{second_key[0..second_limit]}"
+              if first_key[first_limit] == "_"
+                first_limit += 1
+                next
+              end
+              if second_key[second_limit] == "_"
+                second_limit += 1
+                next
+              end
+              break unless @seen_results.include?(shortened_key)
+              raise "duplicate key, #{first_key}_#{second_key}" if first_limit == (first_key.length - 1) &&
+                                                                   second_limit == (second_key.length - 1)
+
+              if second_limit == (second_key.length - 1)
+                first_limit += 1
+                second_limit = 0
+              else
+                second_limit += 1
+              end
+            end
+
+            @seen_results << shortened_key
+            shortened_key
+          end
+        end
+
+        def sort_nested_hash(obj)
+          case obj
+          when Hash
+            obj.transform_values { |v| sort_nested_hash(v) }
+               .sort_by_alphanum { |k, _v| k.to_s }
+               .to_h
+          when Array
+            obj.map { |v| sort_nested_hash(v) }
+          else
+            obj
+          end
+        end
+
+
+        private
+
+        def self.keys_for_score(score)
+          score.map { |subscore| subscore[:key] }
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/services/seed_diff.rb

@@ -0,0 +1,116 @@
+module Quby
+  module Compiler
+    module Services
+      class SeedDiff
+        def format_patch(reference, candidate, path:)
+          @reference_for_debugging = reference
+          @candidate_for_debugging = candidate
+          format_polymorph_patch(reference, candidate, path: path)
+        end
+
+        def apply_patch(object, patch)
+          return object if patch.nil?
+          apply_polymorphic(object, patch, path: "")
+        end
+
+        private
+
+        def format_polymorph_patch(reference, candidate, path:)
+          if reference.class != candidate.class && !candidate.nil? && !depends_relation?(path)
+            raise "Incompatible types at #{path}: #{reference.class} and #{candidate.class}"
+          end
+
+          case reference
+          when Hash
+            case candidate
+            when Hash
+              format_hash_patch(reference, candidate, path: path)
+            else
+              reference
+            end
+          when Array
+            format_array_patch(reference, candidate, path: path)
+          when String, Symbol, true, false
+            reference
+          else
+            raise "Cannot patch #{reference.class} yet."
+          end
+        end
+
+        def format_hash_patch(reference, candidate, path:)
+          return reference if candidate.nil?
+
+          patch = {}
+
+          reference.keys.each do |key|
+            if reference[key] != candidate[key]
+              patch[key] = format_polymorph_patch(reference[key], candidate[key], path: path + ".#{key}")
+            end
+          end
+
+          patch
+        end
+
+        def format_array_patch(reference, candidate, path:)
+          return reference if candidate.nil?
+
+          patch = { __patch_type__: "array" }
+
+          reference.each_with_index do |reference_elm, idx|
+            if reference_elm != candidate[idx]
+              patch[idx] = reference_elm
+            end
+          end
+
+          if candidate.size > reference.size
+            patch[:__patch_trim__] = reference.size
+          end
+
+          patch
+        end
+
+        def apply_polymorphic(object, patch, path:)
+          if patch.is_a?(Hash) && patch[:__patch_type__] == "array"
+            apply_array(object, patch, path: path)
+          elsif patch.is_a?(Hash)
+            apply_hash(object, patch, path: path)
+          else
+            patch
+          end
+        rescue Exception => e
+          puts "path: #{path}"
+          raise
+        end
+
+        def apply_hash(object, patch, path:)
+          object = {} unless object.is_a?(Hash)
+
+          patch.each do |key, value|
+            object[key] = apply_polymorphic(object[key], value, path: path + ".#{key}")
+          end
+
+          object
+        end
+
+        def apply_array(object, patch, path:)
+          object ||= []
+
+          patch.each do |key, val|
+            next if key == :__patch_type__ || key == :__patch_trim__
+            object[key] = val
+          end
+
+          if patch[:__patch_trim__]
+            object = object.slice(0, patch[:__patch_trim__])
+          end
+
+          object
+        end
+
+        def depends_relation?(path)
+          path.end_with?(".depends")
+        end
+      end
+    end
+  end
+end