quby-compiler 0.2.1

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class CheckboxQuestion < Question
+          # checkbox option that checks all other options on check
+          attr_accessor :check_all_option
+
+          # checkbox option that unchecks all other options on check
+          attr_accessor :uncheck_all_option
+
+          # checkbox option that allows to select a maximum amount of checkboxes
+          attr_accessor :maximum_checked_allowed
+
+          # checkbox option that forces to select a minimum amount of checkboxes
+          attr_accessor :minimum_checked_required
+
+          def initialize(key, options = {})
+            super
+
+            @check_all_option         = options[:check_all_option]
+            @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
+            options.each_with_object(key => context_free_title) do |option, hash|
+              next if option.input_key.blank?
+              hash[option.input_key] = "#{context_free_title} - #{option.description}"
+            end.with_indifferent_access
+          end
+
+          def claimed_keys
+            [key]
+          end
+
+          def answer_keys
+            # Some options don't have a key (inner_title), they are stripped.
+            options.map { |opt| opt.input_key }.compact
+          end
+
+          def as_json(options = {})
+            super.merge(options: @options.as_json)
+          end
+
+          def to_codebook(questionnaire, opts = {})
+            options.map do |option|
+              option.to_codebook(questionnaire, opts)
+            end.compact.join("\n\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class DateQuestion < Question
+          POSSIBLE_COMPONENTS = %i( day month year hour minute )
+          COMPONENT_KEYS = Hash[POSSIBLE_COMPONENTS.zip %w( dd mm yyyy hh ii)]
+          COMPONENT_PLACEHOLDERS = Hash[POSSIBLE_COMPONENTS.zip %w( DD MM YYYY hh mm)]
+          DEFAULT_COMPONENTS = %i( day month year )
+
+          # For optionally giving year, month and day fields of dates their own keys
+          POSSIBLE_COMPONENTS.each do |component|
+            attr_accessor "#{component}_key".to_sym
+          end
+
+          # @!attribute [r] components
+          #   @return [Array<Symbol>] date parts to show
+          # @!attribute [r] required_components
+          #   @return [Array<Symbol>] date parts that are required if the question is required or partly filled out.
+          attr_accessor :components, :required_components, :optional_components
+
+          def initialize(key, options = {})
+            super
+
+            @components = options[:components] || DEFAULT_COMPONENTS
+            @required_components = options[:required_components] || @components
+            @optional_components = @components - @required_components
+
+            components.each do |component|
+              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
+            [key] + answer_keys
+          end
+
+          def answer_keys
+            components.map do |component|
+              send("#{component}_key").to_sym
+            end
+          end
+
+          def variable_descriptions
+            components.each_with_object(key => context_free_title) do |component, hash|
+              key = send("#{component}_key")
+              hash[key] = "#{context_free_title} (#{I18n.t component})"
+            end.with_indifferent_access
+          end
+
+          def as_json(options = {})
+            component_keys = components.each_with_object({}) do |component, hash|
+              hash["#{component}Key"] = send("#{component}_key")
+            end
+            super.merge(components: components).merge(component_keys)
+          end
+
+          def to_codebook(questionnaire, opts = {})
+            output = []
+            components.each do |component|
+              output << "#{codebook_key(send("#{component}_key"), questionnaire, opts)} " \
+              "#{type}_#{component} #{codebook_output_range}"
+              output << "\"#{title}\"" unless title.blank?
+              output << options.map(&:to_codebook).join("\n") unless options.blank?
+              output << ""
+            end
+            output.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/deprecated_question.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class DeprecatedQuestion < Question
+          def hidden?
+            true
+          end
+
+          def as_json(options = {})
+            super.merge(options: @options.as_json)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/float_question.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class FloatQuestion < Question
+          def size
+            @size || 30
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/integer_question.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class IntegerQuestion < Question
+          def size
+            @size || 30
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/radio_question.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class RadioQuestion < Question
+          def as_json(options = {})
+            super.merge(options: @options.as_json)
+          end
+
+          def codebook_output_type
+            :radio
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/select_question.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class SelectQuestion < Question
+          def as_json(options = {})
+            super.merge(options: @options.as_json)
+          end
+
+          def codebook_output_type
+            :radio
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/string_question.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class StringQuestion < Question
+          def as_json(options = {})
+            super.merge(autocomplete: @autocomplete, size: @size || 30)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/entities/questions/text_question.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      module Questions
+        class TextQuestion < Question
+          def as_json(options = {})
+            super.merge(autocomplete: @autocomplete, lines: lines, cols: cols)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module Entities
+      class ScoreCalculation
+        attr_accessor :key, :label, :sbg_key, :options, :calculation
+
+        def initialize(key, options, &block)
+          @key = key
+          @label = options[:label]
+          @sbg_key = options[:sbg_key]
+          @options = options
+          @calculation = block
+        end
+
+        def score
+          @options[:score]
+        end
+
+        def completion
+          @options[:completion]
+        end
+
+        def action
+          @options[:action]
+        end
+
+        def sourcecode
+          options[:ruby_string] || calculation&.to_proc&.source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Quby
+  module Compiler
+    module Entities
+      # ScoreSchema instances describe score definitions.
+      #
+      # Score definitions are blocks of ruby code that return a hash of score results based on a questionnaire
+      # response (answer). These schemas describe the purpose and form of the scores. Each key-value pair of the result
+      # hash is called a subscore.
+      # The :value subscore is treated as the main score result. Subscores are usually identified by their 'export_key'.
+      # The score value's export_key is usually set to a shortened version of the main score key.
+      class ScoreSchema < Dry::Struct
+        # The key of the corresponding score in the questionnaire definition
+        attribute :key, Types::Symbol
+        # A label describing the general purpose of the score
+        attribute :label, Types::String
+        # An array of SubscoreSchemas describing each key that can be returned in the result hash of a score.
+        attribute :subscore_schemas, Types::Array(Entities::SubscoreSchema)
+
+        def export_key_labels
+          subscore_schemas.map { |schema| [schema.export_key, schema.label] }.to_h.with_indifferent_access
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Quby
+  module Compiler
+    module Entities
+      # SubscoreSchema instances describe each key that could be returned in a score result hash
+      class SubscoreSchema < Dry::Struct
+        # The key this subscore has in the hash returned by the score
+        attribute :key, Types::Symbol
+        # The description of this subscore in the context of the score, like 'Mean', 'T-Score' or 'Interpretation'
+        attribute :label, Types::String
+        # The shortened key that will used as the field/column name for csv and oru exports,
+        # excluding the questionnaire key part
+        attribute :export_key, Types::Symbol
+        # [Optional] Whether this score will only be exported through oru/api/data exports, but not shown in interfaces
+        attribute :only_for_export?, Types::Bool
+        # [Optional] The key of the variable definition used to calculate the subscore result.
+        attribute :calculation_key?, Types::Symbol
+        # [Optional argument] The name of the outcome table where this subscore should be shown. Used for cases where scores
+        # differ in subscores too much to be shown as one table. By default, all scores end up in the `:main` table.
+        attribute :outcome_table, Types::Symbol.default(:main).meta(omittable: true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities/item'
+
+module Quby
+  module Compiler
+    module Entities
+      class Table < Item
+        attr_accessor :columns
+        attr_accessor :items
+
+        attr_accessor :title
+        attr_accessor :description
+
+        # Whether the question options in this table should show their descriptions
+        attr_accessor :show_option_desc
+
+        def initialize(options = {})
+          @columns = options[:columns]
+          @title = options[:title]
+          @description = options[:description]
+          @show_option_desc = options[:show_option_desc] || false
+          @items = []
+        end
+
+        def item_table
+          rows
+          @item_table
+        end
+
+        # FIXME: code to be ashamed of
+        # rubocop:disable CyclomaticComplexity, Metrics/MethodLength
+        def rows
+          return @rows if @rows
+          @item_table = [[]]
+          @rows = [[[]]]
+          filled_columns = 0
+          filled_rows = 0
+          row_items = 0
+
+          skips = []
+          items.each do |item|
+
+            skips.delete_if do |row_span, skip_cols_at, skip_cols_length|
+              next true if row_span == 1
+              if skip_cols_length > 0 and filled_columns == skip_cols_at
+                filled_columns += skip_cols_length
+                skip_cols_length.times do
+                  @item_table[filled_rows] << nil
+                  @rows[filled_rows][row_items] << nil
+                end
+                if filled_columns >= columns and item != items.last
+                  filled_rows += 1
+                  filled_columns = 0
+                  row_items = 0
+                  @rows << [[]]
+                  @item_table << []
+                  skips.map! do |new_row_span, new_skip_cols_at, new_skip_cols_length|
+                    [new_row_span - 1, new_skip_cols_at, new_skip_cols_length]
+                  end
+                end
+                if filled_columns != 0 and item != items.last
+                  row_items += 1
+                  @rows[filled_rows] << []
+                end
+                next row_span - 1 == 1
+              end
+            end
+
+            if item.is_a?(Text) || !([:check_box, :radio, :scale].include? item.type)
+              if item.row_span > 1
+                skips << [item.row_span, filled_columns, item.col_span]
+              end
+
+              @item_table[filled_rows] << item
+              @rows[filled_rows][row_items] << item
+              filled_columns += item.col_span
+
+              if filled_columns >= columns and item != items.last
+                filled_rows += 1
+                filled_columns = 0
+                row_items = 0
+                @rows << [[]]
+                @item_table << []
+              end
+              if filled_columns != 0 and item != items.last
+                row_items += 1
+                @rows[filled_rows] << []
+              end
+
+            else # is :check_box, :radio or :scale question
+              if item.row_span > 1
+                skips << [item.row_span, filled_columns, item.options.length]
+              end
+
+              @item_table[filled_rows] << item
+              if item.options.length <= columns # multiple questions on one row
+                item.options.each do |opt|
+                  @rows[filled_rows][row_items] << opt
+                  filled_columns += 1
+
+                  if filled_columns >= columns and item != items.last
+                    filled_rows += 1
+                    filled_columns = 0
+                    row_items = 0
+                    @rows << [[]]
+                    @item_table << []
+                  end
+                end
+                if filled_columns != 0 and item != items.last
+                  row_items += 1
+                  @rows[filled_rows] << []
+                end
+              else # one question's options split over multiple rows, ordered row wise
+                opt_len = item.options.length
+                col_len = (opt_len / columns.to_f).ceil
+                (0...col_len).each do |j|
+                  (0...columns).each do |i|
+                    break if j + i * col_len >= opt_len
+                    @rows[filled_rows][row_items] << item.options[j + i * col_len]
+                    filled_columns += 1
+                    if filled_columns == columns
+                      filled_rows += 1
+                      filled_columns = 0
+                      @rows << [[]]
+                      @item_table << [item]
+                    end
+                  end
+                end
+              end
+            end
+          end
+          @rows
+        end
+        # rubocop:enable CyclomaticComplexity, Metrics/MethodLength
+
+        def type
+          "table"
+        end
+      end
+    end
+  end
+end