quby 4.0.3 → 5.0.0.pre1

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

@@ -1,31 +0,0 @@
-require 'quby/questionnaires/entities/charting/overview_chart'
-require_relative 'chart_builder'
-
-module Quby
-  module Questionnaires
-    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/questionnaires/dsl/charting/radar_chart_builder.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities/charting/radar_chart'
-require_relative 'chart_builder'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class RadarChartBuilder < ChartBuilder
-        set_chart_class(Entities::Charting::RadarChart)
-
-        def plotline(value, color)
-          @chart.plotlines << {value: value, color: color, width: 1, zIndex: 3}
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Quby
-  module Questionnaires
-    module DSL
-      module Helpers
-        def image_tag(*args)
-          options = args.extract_options!
-
-          ActionController::Base.helpers.image_tag(
-            *args, options.reverse_merge(alt: image_alt(args.first))
-          )
-        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) }
-
-          ActionController::Base.helpers.tag.video\
-            width: '100%',
-            preload: 'none',
-            poster: poster,
-            loop: loop,
-            autoplay: autoplay,
-            muted: autoplay,
-            controls: '' do |tag|
-              sources.map { |url, ext| tag.source src: url, type: "video/#{ext}" }
-                .append(I18n.t('video_not_supported'))
-                .yield_self(&tag.method(:safe_join))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities'
-
-module Quby
-  module Questionnaires
-    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/questionnaires/dsl/question_builder.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities'
-
-require 'quby/questionnaires/dsl/questions/base'
-require 'quby/questionnaires/dsl/questions/checkbox_question_builder'
-require 'quby/questionnaires/dsl/questions/date_question_builder'
-require 'quby/questionnaires/dsl/questions/deprecated_question_builder'
-require 'quby/questionnaires/dsl/questions/float_question_builder'
-require 'quby/questionnaires/dsl/questions/integer_question_builder'
-require 'quby/questionnaires/dsl/questions/radio_question_builder'
-require 'quby/questionnaires/dsl/questions/select_question_builder'
-require 'quby/questionnaires/dsl/questions/string_question_builder'
-require 'quby/questionnaires/dsl/questions/text_question_builder'
-
-module Quby
-  module Questionnaires
-    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/questionnaires/dsl/questionnaire_builder.rb

@@ -1,252 +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 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 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