quby 4.0.4 → 5.0.0.pre1

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

@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/dsl/panel_builder'
-require 'quby/questionnaires/dsl/table_builder'
-require 'quby/questionnaires/dsl/question_builder'
-require 'quby/questionnaires/dsl/score_builder'
-require 'quby/questionnaires/dsl/charting/line_chart_builder'
-require 'quby/questionnaires/dsl/charting/radar_chart_builder'
-require 'quby/questionnaires/dsl/charting/bar_chart_builder'
-require 'quby/questionnaires/dsl/charting/overview_chart_builder'
-
-require_relative 'standardized_panel_generators'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class QuestionnaireBuilder
-        prepend CallsCustomMethods
-        include StandardizedPanelGenerators
-        include Helpers
-
-        def initialize(target_instance)
-          @questionnaire = target_instance
-          @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 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 version(key, notes)
-          # nothing, for forward compatibility with v5 (quby-compiler)
-        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 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)
-          # nothing, for forwards compatibility with v5 (quby-compiler)
-        end
-
-        def add_lookup_tree(key, levels:, tree:)
-          @questionnaire.lookup_tables[key] = Quby::TableBackend::RangeTree.new(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)
-          s = ScoreBuilder.new(key, options, &block)
-          @questionnaire.add_score_calculation s.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)
-          @questionnaire.add_score_schema(key, options[:label], schema) if schema.present?
-          variable(key, options.reverse_merge(score: true), &block)
-        end
-
-        def score_schema(key, label, options)
-          @questionnaire.add_score_schema(key, label, options)
-        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

data/lib/quby/questionnaires/dsl/questions/base.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-module Quby
-  module Questionnaires
-    module DSL
-      module Questions
-        class Base < ::Quby::Questionnaires::DSL::Base
-          attr_reader :key
-          attr_reader :title
-          attr_reader :type
-          attr_reader :questionnaire
-
-          def initialize(key, options = {})
-            @questionnaire = options[:questionnaire]
-          end
-
-          def build
-            @question
-          end
-
-          def title(value)
-            @question.title = value
-          end
-
-          def context_free_title(value)
-            @question.context_free_title = value
-          end
-
-          def description(value)
-            @question.description = value
-          end
-
-          def presentation(value)
-            @question.presentation = value
-          end
-
-          def hidden(value = true)
-            @question.hidden = value
-          end
-
-          def depends_on(keys)
-            @question.set_depends_on(keys)
-          end
-
-          def default_position(value)
-            @question.default_position = value
-          end
-
-          def validates_presence_of_answer(options = {})
-            @question.validations ||= []
-            @question.validations << {type: :requires_answer}.reverse_merge(options)
-          end
-        end
-
-        module RegexpValidations
-          def validates_format_with(regexp, options = {})
-            @question.validations ||= []
-            @question.validations << {type: :regexp, matcher: regexp}.reverse_merge(options)
-          end
-        end
-
-        module MinMaxValidations
-          def validates_minimum(value, options = {})
-            subtype = @question.type == :date ? :date : :number
-            @question.validations ||= []
-            @question.validations << {type: :minimum, value: value, subtype: subtype}.reverse_merge(options)
-          end
-
-          def validates_maximum(value, options = {})
-            subtype = @question.type == :date ? :date : :number
-            @question.validations ||= []
-            @question.validations << {type: :maximum, value: value, subtype: subtype}.reverse_merge(options)
-          end
-
-          def validates_in_range(range, options = {})
-            subtype = @question.type == :date ? :date : :number
-            @question.validations ||= []
-            @question.validations << {type: :minimum, value: range.first, subtype: subtype}.reverse_merge(options)
-            @question.validations << {type: :maximum, value: range.last, subtype: subtype}.reverse_merge(options)
-          end
-        end
-
-        module Labeling
-          def label(value)
-            @question.labels << value
-          end
-
-          # deprecated
-          def left_label(value)
-            @question.labels.unshift(value)
-          end
-
-          # deprecated
-          def right_label(value)
-            @question.labels << value
-          end
-        end
-
-        module MultipleChoice
-          def option(key, options = {}, &block)
-            question_option = Entities::QuestionOption.new(key, @question, options)
-            if @questionnaire.key_in_use?(question_option.input_key) || @question.key_in_use?(question_option.input_key)
-              fail "#{questionnaire.key}:#{@question.key}:#{question_option.key}: " \
-                    "A question or option with input key #{question_option.input_key} is already defined."
-            end
-
-            @question.options << question_option
-            instance_eval(&block) if block
-          end
-        end
-
-        module Subquestions
-          def initialize(key, options = {}, &block)
-            super
-            @default_question_options = options[:default_question_options] || {}
-            @title_question = nil
-          end
-
-          def build
-            if @title_question
-              @question.options.last.questions << @title_question
-              @title_question = nil
-            end
-
-            super
-          end
-
-          def title_question(key, options = {}, &block)
-            options = @default_question_options.merge({depends_on: @question.key,
-                                                       questionnaire: @questionnaire,
-                                                       parent: @question,
-                                                       presentation: :next_to_title,
-                                                       allow_blank_titles: @question.allow_blank_titles}.merge(options))
-
-            check_question_keys_uniqueness key, options, @questionnaire
-
-            question = QuestionBuilder.build(key, options, &block)
-
-            @questionnaire.register_question(question)
-            @title_question = question
-          end
-
-          def question(key, options = {}, &block)
-            options = @default_question_options.merge(options)
-                                               .merge(questionnaire: @questionnaire,
-                                                      parent: @question,
-                                                      parent_option_key: @question.options.last.key)
-
-            check_question_keys_uniqueness key, options, @questionnaire
-
-            question = QuestionBuilder.build(key, options, &block)
-
-            @questionnaire.register_question(question)
-            @question.options.last.questions << question
-          end
-        end
-
-        module InnerTitles
-          def inner_title(value)
-            question_option = Entities::QuestionOption.new(nil, @question, inner_title: true, description: value)
-            @question.options << question_option
-          end
-        end
-
-        module Units
-          def unit(value)
-            @question.unit = value
-          end
-        end
-
-        module Sizes
-          def size(value)
-            @question.size = value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/quby/questionnaires/dsl/questions/checkbox_question_builder.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Quby
-  module Questionnaires
-    module DSL
-      module Questions
-        class CheckboxQuestionBuilder < Base
-          include MultipleChoice
-          include Subquestions
-          include InnerTitles
-
-          def initialize(key, options = {}, &block)
-            super
-            @question = Entities::Questions::CheckboxQuestion.new(key, options)
-          end
-        end
-      end
-    end
-  end
-end