quby-compiler 0.2.1

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class Base < ::Quby::Compiler::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
+
+          # TODO not referenced in definitions?
+          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/compiler/dsl/questions/checkbox_question_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    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

data/lib/quby/compiler/dsl/questions/date_question_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class DateQuestionBuilder < Base
+          include MinMaxValidations
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::DateQuestion.new(key, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/questions/deprecated_question_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class DeprecatedQuestionBuilder < Base
+          include MultipleChoice
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::DeprecatedQuestion.new(key, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/questions/float_question_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class FloatQuestionBuilder < Base
+          include MinMaxValidations
+          include Labeling
+          include Units
+          include Sizes
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::FloatQuestion.new(key, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/questions/integer_question_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class IntegerQuestionBuilder < Base
+          include MinMaxValidations
+          include Labeling
+          include Units
+          include Sizes
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::IntegerQuestion.new(key, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/questions/radio_question_builder.rb

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

data/lib/quby/compiler/dsl/questions/select_question_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class SelectQuestionBuilder < Base
+          include MultipleChoice
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::SelectQuestion.new(key, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/questions/string_question_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class StringQuestionBuilder < Base
+          include RegexpValidations
+          include Units
+          include Sizes
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::StringQuestion.new(key, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/questions/text_question_builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Quby
+  module Compiler
+    module DSL
+      module Questions
+        class TextQuestionBuilder < Base
+          include RegexpValidations
+
+          def initialize(key, options = {}, &block)
+            super
+            @question = Entities::Questions::TextQuestion.new(key, options)
+          end
+
+          def lines(value)
+            @question.lines = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/score_builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'quby/compiler/entities'
+
+module Quby
+  module Compiler
+    module DSL
+      class ScoreBuilder
+        attr_reader :key
+        attr_reader :calculation
+
+        def initialize(key, options = {}, &block)
+          @score = Entities::ScoreCalculation.new(key, options, &block)
+        end
+
+        def build
+          @score
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/dsl/score_schema_builder.rb

@@ -0,0 +1,53 @@
+require 'quby/compiler/entities'
+
+module Quby
+  module Compiler
+    module DSL
+      class ScoreSchemaBuilder < Base
+        def initialize(key:, label:, &block)
+          @score_key = key
+          @score_label = label
+          @subschema_params = []
+          @generated_calculations = []
+        end
+
+        def build
+          score_schema = Entities::ScoreSchema.new key: @score_key,
+                                                   label: @score_label,
+                                                   subscore_schemas: @subschema_params
+          [score_schema, @generated_calculations + [generate_score_calculation(score_schema)]]
+        end
+
+        def subscore(key, label, **options, &block)
+          if block
+            # Generate a key to go with the subscore calculation made from the given block and save it inside the schema
+            calculation_key = :"_#{@score_key}.#{key}"
+            calculation = Entities::ScoreCalculation.new calculation_key,
+                                                         label: "#{@score_label} #{label}",
+                                                         &block
+            @generated_calculations << calculation
+            options.merge!(calculation_key: calculation_key)
+          end
+          @subschema_params << options.merge(key: key, label: label)
+        end
+
+        private
+
+        def generate_score_calculation(score_schema)
+          inner_hash_string = score_schema.subscore_schemas.map do |subschema|
+            ":#{subschema.key} => score(:'#{subschema.calculation_key}')"
+          end.join(",\n  ")
+          # method-source can only grab whole lines of implementation. For regular questionnaires
+          # this means calculation.sourcecode includes the surrounding score/attention/completion/etc. call.
+          # This surrounding call will be stripped after reading in the source in quby.
+          # We add a fake `score do` call around this generated implementation so the stripping will work correctly
+          score_code_string = "score do\n  {#{inner_hash_string}}\nend"
+          Entities::ScoreCalculation.new score_schema.key,
+                                         label: score_schema.label,
+                                         score: true,
+                                         ruby_string: score_code_string
+        end
+      end
+    end
+  end
+end