quby-compiler 0.5.41 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e4ea90302f4838a9b7c5f87f6dbd4d27c4966ec54dafc9448168635c32584ec
-  data.tar.gz: 371f50e287667c40f77897d9edc791367cc55d646efa561ca4cf526d8ca4e056
+  metadata.gz: 9aa19b0ae3da964273f613a8705e3b63e699dc14fc9793f67e13b891f5e6f42f
+  data.tar.gz: 8b2e41485f4d05711ea4098f1bbc23fdfe6e43fac6764047760434bbc04c41b3
 SHA512:
-  metadata.gz: 3a472cbc39f53181e19b6b9385537e3d15efb9f65cd20c33eb28d3bfff16e8fab4361c5d1df511a58ae14d3c7ccf2ff37046145cd0089db13ede18dbe3a59290
-  data.tar.gz: 9d073a016dc4407b0ef0b39d2ac4691ac18d99c4e37fbfd5a87a5f794db2db82ed9079fe31b78de0930053faf4213eef50ec3c73aca6c81d858f4b9509093bf5
+  metadata.gz: 127e6a879195d5ee84994016e53e7dbb99cb5a188023df2156e708f1e7ca57464d589b7c49adbae203acefbd1ad2eaecf943fa069466d82209a624f477f611dd
+  data.tar.gz: 5256bfbd80fa05c961cd7cfd0c59c78c35fa6b24fb3581534a7a10d926f58ab5432cdc674ee9ad9abd5262981657f6d164914229a2c28c0a6d836372fff5a08a

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.6.0
+
+* dsl:
+  * Add translate_into
+  * Allow translations to be passed to the compiler.
+  * Allow keys on panels/text/inner_titles.q
+  * Add i18n_key to question_options/slider-labels.
+* Prettify all json files.  
+* New export locale_#{lang}.json if translate_into is present.
+* quby2.json: 
+  * Added translations, also if questionnaire is not translatable yet.
+
 # 0.5.41
 
 * dsl: 

data/exe/quby-compile

@@ -30,6 +30,16 @@ end
 
 lookup_tables = Quby::Compiler::Entities::LookupTables.new(lookup_tables_path)
 
+def translations_in(path)
+  translation_files = Dir.glob(File.join(File.dirname(path), "#{Quby::Compiler::LOCALE_FILE_PREFIX}*.json"))
+  
+  translation_files.to_h { |file_path|
+    filename = File.basename(file_path, '.json')
+    language_key = filename.delete_prefix(Quby::Compiler::LOCALE_FILE_PREFIX)
+    [language_key, JSON.parse(File.read(file_path))]
+  }
+end
+
 validation_errors_found = false
 paths.each do |path|
   puts "Compiling #{path}"
@@ -45,7 +55,7 @@ paths.each do |path|
     next # let's not create new output files for questionnaires with errors
   end
 
-  compiled = Quby::Compiler.compile(key, sourcecode, path: path, lookup_tables: lookup_tables)
+  compiled = Quby::Compiler.compile(key, sourcecode, path: path, lookup_tables: lookup_tables, translations: translations_in(path))
 
   FileUtils.mkdir_p(File.join(output_path, key))
   compiled[:outputs].each do |type, output|

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

@@ -25,8 +25,8 @@ module Quby
           info_block.html = value
         end
 
-        def html(value)
-          info_block.items << Entities::Text.new('', html_content: value.to_s)
+        def html(value, key: fallback_key)
+          info_block.items << Entities::Text.new('', html_content: value.to_s, key:)
         end
 
         def question(key, **options, &block)
@@ -47,6 +47,14 @@ module Quby
             super
           end
         end
+
+        private
+
+        def fallback_key
+          raise "Item without key in #{info_block.key}" if questionnaire.translatable?
+
+          "#{info_block.key}_item_#{info_block.items.size}"
+        end
       end
     end
   end

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

@@ -23,21 +23,24 @@ module Quby
           @panel.title = value
         end
 
-        def text(value, options = {})
-          @panel.items << Entities::Text.new(value.to_s, options)
+        # value deprecated, used named md attr instead.
+        def text(value=nil, key: fallback_key, md: value, html: nil, **options)
+          @panel.items << Entities::Text.new(key:, md:, html_content: html, **options)
         end
 
-        def html(value)
-          @panel.items << Entities::Text.new('', html_content: value.to_s)
+        # deprecated for translated questionnaires, use `text html: ..` instead.
+        def html(value, key: fallback_key)
+          @panel.items << Entities::Text.new(key:, html_content: value.to_s)
         end
 
-        def raw_html(value)
-          @panel.items << Entities::Text.new('', raw_content: value.to_s)
+        # Deprecated for quby2.
+        def raw_html(value="", key: fallback_key)
+          @panel.items << Entities::Text.new(key:, raw_content: value.to_s)
         end
 
-        def video(*urls, **options)
+        def video(*urls, key: fallback_key, **options)
           video_html = video_tag(*urls, **options)
-          @panel.items << Entities::Text.new('', raw_content: video_html)
+          @panel.items << Entities::Text.new(key:, raw_content: video_html)
         end
 
         def default_question_options(**options)
@@ -86,6 +89,14 @@ module Quby
         def respond_to_missing?(method_name, include_private = false)
           @custom_methods.key?(method_name) || super
         end
+
+        private
+
+        def fallback_key
+          raise "Item without key in #{@panel.key}" if @questionnaire.translatable?
+
+          "#{@panel.key}_item_#{@panel.items.size}"
+        end
       end
     end
   end

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

@@ -95,6 +95,11 @@ module Quby
           @questionnaire.abortable = true
         end
 
+        # No args to generate locale file for original language.
+        def translatable_into(*languages)
+          @questionnaire.translatable_into = languages.map(&:to_s)
+        end
+
         def allow_hotkeys(type = :all)
           @questionnaire.allow_hotkeys = type
         end
@@ -105,7 +110,7 @@ module Quby
         end
 
         def language(language)
-          @questionnaire.language = language
+          @questionnaire.language = language.to_s
         end
 
         def respondent_types(*respondent_types)
@@ -183,8 +188,9 @@ module Quby
           @questionnaire.anonymous_conditions = @questionnaire.anonymous_conditions.new(hide_values_from_professionals: value)
         end
 
-        def panel(title = nil, options = {}, &block)
-          panel = PanelBuilder.build(title, **options, **default_panel_options, &block)
+        def panel(title = nil, key: nil, **options, &block)
+          key ||= "p_#{@questionnaire.panels.size}"
+          panel = PanelBuilder.build(title, key:, **options, **default_panel_options, &block)
           @questionnaire.add_panel(panel)
         end
 
@@ -209,7 +215,7 @@ module Quby
 
         # Short-circuit the question command to perform an implicit panel
         def question(key, **options, &block)
-          panel(nil, default_panel_options) do
+          panel(nil, **default_panel_options) do
             question(key, questionnaire: @questionnaire, **@default_question_options, **options, &block)
           end
         end

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

@@ -107,6 +107,10 @@ module Quby
         end
 
         module Labeling
+          def labels_i18n_key(value)
+            @question.labels_i18n_key = value
+          end
+
           def label(value)
             @question.labels << value
           end
@@ -172,8 +176,9 @@ module Quby
         end
 
         module InnerTitles
-          def inner_title(value)
-            question_option = Entities::QuestionOption.new(nil, @question, inner_title: true, description: value)
+          def inner_title(value, key: nil)
+            key ||= "i_t_#{@question.options.size}"
+            question_option = Entities::QuestionOption.new(key, @question, inner_title: true, description: value)
             @question.options << question_option
           end
         end

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

@@ -25,7 +25,7 @@ module Quby
         end
 
         def text(value, **options)
-          @table.items << Entities::Text.new(value.to_s, options)
+          @table.items << Entities::Text.new(value.to_s, key: nil, **options)
         end
 
         def question(key, **options, &block)

data/lib/quby/compiler/dsl.rb

@@ -16,9 +16,9 @@ module Quby
         end
       end
 
-      def self.build(key, sourcecode = nil, path: nil, lookup_tables: {}, &block)
+      def self.build(key, sourcecode = nil, path: nil, lookup_tables: {},&block)
         Entities::Questionnaire.new(key).tap do |questionnaire|
-          builder = QuestionnaireBuilder.new(questionnaire, lookup_tables: lookup_tables)
+          builder = QuestionnaireBuilder.new(questionnaire, lookup_tables:)
           builder.instance_eval(sourcecode, path || key) if sourcecode
           builder.instance_eval(&block) if block
           questionnaire.callback_after_dsl_enhance_on_questions

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

@@ -10,14 +10,15 @@ module Quby
         extend  ActiveModel::Naming
         include ActiveModel::Validations
 
-        attr_accessor :key, :sourcecode, :timestamp, :path, :lookup_tables
+        attr_accessor :key, :sourcecode, :timestamp, :path, :lookup_tables, :translations
 
-        def initialize(key:, path:, sourcecode: "", timestamp: nil, lookup_tables: {})
+        def initialize(key:, path:, sourcecode: "", timestamp: nil, lookup_tables: {}, translations: {})
           @path = path
           @key = key
           @sourcecode = sourcecode
           @timestamp = timestamp
           @lookup_tables = lookup_tables
+          @translations = translations
         end
 
         validates_with Services::DefinitionValidator

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

@@ -20,7 +20,7 @@ module Quby
         attr_accessor :description
         attr_accessor :context_description
 
-        attr_accessor :labels
+        attr_accessor :labels, :labels_i18n_key
 
         # What kind of question is this?
         attr_accessor :type
@@ -171,7 +171,8 @@ module Quby
           @lines = options[:lines] || 6
           @cols = options[:cols] || 40
           @default_invisible = options[:default_invisible] || false
-          @labels ||= []
+          @labels = []
+          @labels_i18n_key = nil
           @css_vars = options[:css_vars]
           @indent = options[:indent]
 
@@ -252,7 +253,7 @@ module Quby
             answer_keys
           else
             # Some options don't have a key (inner_title), they are stripped
-            all_options.map { |opt| opt.input_key }.compact
+            all_options.reject(&:inner_title?).map{ |opt| opt.input_key }
           end
         end
 

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

@@ -8,12 +8,14 @@ module Quby
         include ::Quby::InspectExcept.new(:@question, :@questions)
 
         attr_reader :key
+        attr_reader :i18n_key
         attr_reader :label
         attr_reader :options
 
-        def initialize(key, label:)
+        def initialize(key, label:, i18n_key: nil)
           @key = key
           @label = label
+          @i18n_key = i18n_key
           @options = []
         end
 

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

@@ -30,6 +30,7 @@ module Quby
         attr_reader :question
         attr_reader :view_id
         attr_reader :input_key
+        attr_reader :i18n_key
 
         def initialize(key, question, options = {})
           @key         = key
@@ -48,6 +49,7 @@ module Quby
 
           @input_key = (question.type == :check_box ? @key : "#{question.key}_#{key}".to_sym)
           @view_id   = "answer_#{input_key}"
+          @i18n_key  = options[:i18n_key]
         end
 
         def inner_title?

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

@@ -43,7 +43,8 @@ module Quby
           @panels = []
           @flags = {}.with_indifferent_access
           @textvars = {}.with_indifferent_access
-          @language = :nl
+          @language = 'nl'
+          @translatable_into = nil
           @respondent_types = []
           @tags = []
           @check_key_clashes = true
@@ -87,6 +88,7 @@ module Quby
         attr_reader   :license
         attr_accessor :licensor
         attr_accessor :language
+        attr_accessor :translatable_into
         attr_accessor :respondent_types
         attr_reader :tags # tags= is manually defined below
         attr_accessor :outcome_regeneration_requested_at
@@ -218,6 +220,10 @@ module Quby
           fields.key_in_use?(key) || score_calculations.key?(key)
         end
 
+        def translatable?
+          !translatable_into.nil?
+        end
+
         def add_score_calculation(builder)
           if score_calculations.key?(builder.key)
             fail InputKeyAlreadyDefined, "Score key `#{builder.key}` already defined."

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

@@ -56,7 +56,7 @@ module Quby
 
           def answer_keys
             # Some options don't have a key (inner_title), they are stripped.
-            options.map { |opt| opt.input_key }.compact
+            options.reject(&:inner_title?).map { |opt| opt.input_key }
           end
         end
       end

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

@@ -13,13 +13,17 @@ module Quby
         # In case of being displayed inside a table, amount of columns/rows to span
         attr_accessor :col_span
         attr_accessor :row_span
+        attr_accessor :key
 
-        def initialize(str, options = {})
+        # str is deprecated, use named md instead.
+        # str fallback to empty string for quby1 compatibility.
+        def initialize(str="", key:, md: nil, **options)
           if options[:html_content]
             options[:raw_content] = "<div class='item text'>" + options[:html_content] + "</div>"
           end
           super(options)
-          @str = str
+          @key = key
+          @str = md || str
           @html_content = options[:html_content]
           @display_in = options[:display_in] || [:paged]
           @col_span = options[:col_span] || 1
@@ -35,13 +39,10 @@ module Quby
         end
 
         def text
+          return "" if str.blank?
           @text ||= Quby::Compiler::MarkdownParser.new(str).to_html
         end
 
-        def key
-          't0'
-        end
-
         def type
           "text"
         end

data/lib/quby/compiler/instance.rb

@@ -7,24 +7,25 @@ module Quby
         @lookup_tables = lookup_tables
       end
 
-      def compile(key:, sourcecode:, path: nil, &block)
-        if block # defined in block for tests
-          questionnaire = DSL.build(key, path: path, &block)
-        else # sourcecode given as string
-          tempfile = Tempfile.new([key, '.rb'])
-          questionnaire = Entities::Questionnaire.new(key)
-          Thread.current["quby-questionnaire-loading"] = Quby::Compiler::DSL::QuestionnaireBuilder.new(questionnaire, lookup_tables: lookup_tables)
+      def compile(key:, sourcecode:, path: nil, translations: {}, &block)
+        questionnaire = \
+          if block # defined in block for tests
+            DSL.build(key, path:, &block)
+          elsif path # sourcecode given as string
+            definition = Entities::Definition.new(key:, sourcecode:, path: path || "validating '#{key}'", lookup_tables:, translations:)
+            DSL.build_from_definition(definition) # this will also validate the definition, and raise if it is invalid. We can rescue this in the caller to return the validation errors in a structured way.
+          else
+            tempfile = Tempfile.create([key, '.rb'])
+            tempfile.write(sourcecode)
+            tempfile.close
+            definition = Entities::Definition.new(key:, sourcecode:, path: tempfile.path, lookup_tables:, translations:)
+            DSL.build_from_definition(definition) # this will also validate the definition, and
+          end
 
-          tempfile.puts "Thread.current['quby-questionnaire-loading'].instance_eval do"
-          tempfile.puts sourcecode
-          tempfile.puts "end"
-          tempfile.flush
-
-          load tempfile.path
-          Thread.current['quby-questionnaire-loading'] = nil
-
-          questionnaire.callback_after_dsl_enhance_on_questions
-        end
+        original_locale = Outputs::LocaleSerializer.new(questionnaire).as_json
+        all_translations = translations.clone \
+          .delete_if { |k, _| !questionnaire.translatable_into&.include?(k) } \
+          .merge(questionnaire.language => original_locale)
 
         {
           outputs: {
@@ -36,7 +37,7 @@ module Quby
             roqua: Output.new(
               key: :roqua,
               filename: "roqua.json",
-              content: Outputs::RoquaSerializer.new(questionnaire).to_json,
+              content: JSON.pretty_generate(Outputs::RoquaSerializer.new(questionnaire).as_json),
             ),
             seeds: Output.new(
               key: :seeds,
@@ -46,24 +47,28 @@ module Quby
             quby_frontend_v1: Output.new(
               key: :quby_frontend_v1,
               filename: "quby-frontend-v1.json",
-              content: Outputs::QubyFrontendV1Serializer.new(questionnaire).to_json,
+              content: JSON.pretty_generate(Outputs::QubyFrontendV1Serializer.new(questionnaire).as_json),
             ),
             quby_frontend_v2: Output.new(
               key: :quby_frontend_v2,
               filename: "quby-frontend-v2.json",
-              content: Outputs::QubyFrontendV2Serializer.new(questionnaire).to_json,
+              content: JSON.pretty_generate(Outputs::QubyFrontendV2Serializer.new(questionnaire, translations: all_translations).as_json),
+            ),
+            locale: questionnaire.translatable? && Output.new(
+              key: :locale,
+              filename: "#{LOCALE_FILE_PREFIX}#{questionnaire.language}.json",
+              content: JSON.pretty_generate(original_locale),
             ),
           },
         }
       ensure
         # We can only close and remove the file once serializers have finished.
         # The serializers need the file in order to grab the source for score blocks
-        tempfile&.close
-        tempfile&.unlink
+        File.unlink(tempfile&.path) if tempfile
       end
 
-      def validate(key:, sourcecode:)
-        definition = Entities::Definition.new(key: key, sourcecode: sourcecode, path: "validating '#{key}'", lookup_tables: lookup_tables)
+      def validate(key:, sourcecode:, translations: {})
+        definition = Entities::Definition.new(key:, sourcecode:, path: "validating '#{key}'", lookup_tables:, translations:)
         definition.valid?
         definition
       end

data/lib/quby/compiler/outputs/locale_serializer.rb

@@ -0,0 +1,153 @@
+module Quby
+  module Compiler
+    module Outputs
+      # We use Quby2 serialializer for html sanitization, since it's largest set we allow.
+      class LocaleSerializer
+        def initialize(questionnaire)
+          @questionnaire = questionnaire
+          @quby_frontend_v2_serializer = QubyFrontendV2Serializer.new(questionnaire)
+        end
+
+        delegate_missing_to :@questionnaire
+
+        def as_json(options = {})
+          {
+            key: key,
+            title: title,
+            short_description: short_description,
+            footer: @quby_frontend_v2_serializer.footer,
+            **panel_locale_values,
+            **validations_locale_values,
+          }.compact
+        end
+
+        def panel_locale_values
+          @questionnaire.panels.flat_map { |panel|
+            items_locale_values(panel.items, panel: panel)
+          }.reduce(:merge)
+        end
+
+        def items_locale_values(items, panel:)
+          items.flat_map { |item|
+            case item
+            when Quby::Compiler::Entities::Text
+              { "#{panel.key}.#{item.key}" => item.html }
+            when Quby::Compiler::Entities::Question
+              questions_for_question(item).flat_map { |question|
+                question_locale_values(question, panel:)
+              }
+            when Quby::Compiler::Entities::InfoBlock
+              info_block_locale_values(item, panel:)
+            when Quby::Compiler::Entities::Table
+              {} # quby1 only, doesn't use translations.
+            else
+              raise "Unknown panel item type #{item.class} for locale serialization"
+            end
+          }.reduce(:merge) || {} # reduce is nil when no items.
+        end
+
+        def info_block_locale_values(info_block, panel:)
+          {
+            "#{info_block.key}.html" => info_block.html,
+            **items_locale_values(info_block.items, panel: panel),
+          }
+        end
+
+        def question_locale_values(question, panel:)
+          v2_question = @quby_frontend_v2_serializer.question(question) or return {} # type hidden
+          res = {
+            "#{question.key}.title" => v2_question[:title],
+            "#{question.key}.context_free_title" => question.context_free_title, # Might be useful if we want to translate in roqua as well.
+            "#{question.key}.description" => v2_question[:description],
+            "#{question.key}.context_description" => v2_question[:contextDescription], # Might be useful if we want to translate in roqua as well.
+            **question_type_specific_values(question),
+          }
+        rescue
+          puts question.key
+          raise
+        end
+
+        def question_type_specific_values(question)
+          as_type = question.as || question.type
+          case question.as || question.type
+          when :slider
+            slider_label_locale_values(question: question, panel: nil)
+          when :split_to_units
+            split_to_units_question(question)
+          when :radio, :check_box, :select, :scale
+            options_locale_values(question: question)
+          when :integer, :float
+            {"#{question.key}.unit" => question.unit}
+          when :string, :textarea, :date, :country_select
+            {}
+          else
+            raise "Unknown question as #{as_type} for locale serialization"
+          end
+        end
+
+        def options_locale_values(question:)
+          question.options.map { |option, res|
+            option_locale_values(option, question:)
+          }.reduce(:merge)
+        end
+
+        def option_locale_values(option, question:)
+          base_key = option.i18n_key || "#{question.key}.#{option.key}"
+          if option.is_a?(Quby::Compiler::Entities::QuestionOptgroup)
+            {
+               "#{base_key}.label" => option.label, # no html
+               **option.options.map { option_locale_values(_1, question:) }.reduce(:merge)
+            }
+          elsif option.inner_title
+            {
+               "#{base_key}.html" => @quby_frontend_v2_serializer.inner_title_as_json(option, 0)[:html]
+            }
+          elsif option.placeholder
+            {"#{question.key}.placeholder" => option.label || option.description}
+          else
+            v2_option = @quby_frontend_v2_serializer.option_as_json(option)
+            {
+               "#{base_key}.label" => v2_option[:label],
+               "#{base_key}.description" => v2_option[:description],
+               "#{base_key}.context_free_description" => option.context_free_description,
+            }
+          end
+        end
+
+        def slider_label_locale_values(question:, panel:)
+          return {} unless question.as == :slider && question.labels.present?
+
+          base_key = question.labels_i18n_key || "#{question.key}.labels"
+          question.labels.each_with_index.to_h { |label, idx|
+            ["#{base_key}.#{idx}", label]
+          }
+        end
+
+        def split_to_units_question(question)
+          return unless question.type != :split_to_units
+          return {} unless question.conversions.present? # Units without conversions are translated by quby2. 
+
+          question.units.to_h { |unit|
+            ["#{question.key}.units.#{unit.to_s.gsub(/[^a-zA-Z]/, "")}", unit.to_s]
+          }
+        end
+
+        def questions_for_question(question)
+          questions = [question]
+          questions << question.title_question if question.title_question
+          questions + question.options&.flat_map do |option|
+            option.questions # We only allow subquestions one level deep.
+          end
+        end
+
+        def validations_locale_values
+          @questionnaire.validations.select { |validation|
+            validation.config[:explanation].present?
+          }.to_h { |validation|
+            ["#{validation.config[:field_key]}.validation.#{validation.type}.explanation", validation.config[:explanation]]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb

@@ -192,7 +192,7 @@ module Quby
 
         def option_as_json(option)
           {
-            key: option.key,
+            key: (option.key unless option.inner_title?),
             value: option.value,
             description: option.label ? "#{option.label} #{option.description}" : option.description,
             context_free_description: option.context_free_description,

data/lib/quby/compiler/outputs/quby_frontend_v2_serializer.rb

@@ -4,8 +4,9 @@ module Quby
   module Compiler
     module Outputs
       class QubyFrontendV2Serializer
-        def initialize(questionnaire)
+        def initialize(questionnaire, translations: {})
           @questionnaire = questionnaire
+          @translations = translations
         end
 
         delegate_missing_to :@questionnaire
@@ -28,6 +29,7 @@ module Quby
             sexpVariables: sexp_variables,
             cssVars: css_vars,
             versionNumber: version_number,
+            translations: translations,
           }.compact.tap do |json|
             validate_all_questions_in_a_panel_question_keys(json)
           end
@@ -41,8 +43,13 @@ module Quby
           raise "Not all questions are listed in a panel['questionKeys']: #{missings.join(",")}."
         end
 
+        def footer
+          handle_html(@questionnaire.footer, type: :prose, v1_markdown: false)
+        end
+
         def panel(panel)
           {
+            key: panel.key,
             title: panel.title,
             items: panel.items.map { panel_item(_1) }.compact,
             questionKeys: question_keys_for_panel(panel) # added instead of calculated in js, so we can validate completeness.
@@ -52,7 +59,7 @@ module Quby
         def panel_item(item)
           case item
           when Quby::Compiler::Entities::Text
-            { type: 'html', html: handle_html(item.html, type: :prose, v1_markdown: false) }
+            { type: 'html', key: item.key, html: handle_html(item.html, type: :prose, v1_markdown: false) }
           when Quby::Compiler::Entities::Question
             return if item.table # things inside a table are added to the table, AND ALSO to the panel. skip them.
             { type: 'question', key: item.key }
@@ -267,7 +274,7 @@ module Quby
         def inner_title_as_json(option, idx)
           {
             type: 'html',
-            key: "i-t-#{idx}",
+            key: option.key,
             html: handle_html(option.description)
           }
         end
@@ -316,6 +323,18 @@ module Quby
           end
         end
 
+        def translations
+          @translations.clone \
+            .transform_values { |translations|
+              translations.clone.delete_if { |key, _v|
+                key.ends_with?("context_free_title") \
+                || key.ends_with?("context_free_description") \
+                || key == "short_description"
+              } \
+              .transform_keys! { |k| k.to_s.split('.').tap{ _1[-1] = _1[-1].camelize(:lower) }.join('.') }
+            }
+        end
+
         def depends_on(validation_hsh)
           question = @questionnaire.question_hash[validation_hsh['fieldKey']]
           return unless question.depends_on.present?

data/lib/quby/compiler/outputs.rb

@@ -1,4 +1,5 @@
 require 'quby/compiler/outputs/roqua_serializer'
 require 'quby/compiler/outputs/seed_serializer'
 require 'quby/compiler/outputs/quby_frontend_v1_serializer'
-require 'quby/compiler/outputs/quby_frontend_v2_serializer'
+require 'quby/compiler/outputs/quby_frontend_v2_serializer'
+require 'quby/compiler/outputs/locale_serializer'

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

@@ -31,6 +31,7 @@ module Quby
           validate_checkbox_options(questionnaire)
           validate_visiblity_rules(questionnaire)
           validate_quby2_unsupported_features(questionnaire)
+          validate_locales(questionnaire:, definition:)
         # Some compilation errors are Exceptions (pure syntax errors) and some StandardErrors (NameErrors)
         rescue Exception => exception # rubocop:disable Lint/RescueException
           definition.errors.add(:sourcecode, message: "Questionnaire error: #{definition.key}\n" \
@@ -492,6 +493,26 @@ scores_schema tables to the resulting seed."
             end
           end
         end
+
+        def validate_locales(questionnaire:, definition:)
+          return unless ENV['QUBY_VALIDATE_LOCALES'] == 'true' # fail on questionnaire branch, but not in quby admin.
+          return unless questionnaire.translatable_into.present?
+
+          source = Outputs::LocaleSerializer.new(questionnaire).as_json.stringify_keys
+
+          definition.translations.each do |language, translations|
+            next if language == questionnaire.language
+
+            missing_keys = source.keys - translations.keys
+            unless missing_keys.empty?
+              fail "Missing translations for keys #{missing_keys.join(', ')} in locale #{language}."
+            end
+            extra_keys = translations.keys - source.keys
+            unless extra_keys.empty?
+              fail "Extra translations for keys #{extra_keys.join(', ')} in locale #{language}."
+            end
+          end
+        end            
       end
     end
   end

data/lib/quby/compiler/version.rb

@@ -1,5 +1,5 @@
 module Quby
   module Compiler
-    VERSION = "0.5.41"
+    VERSION = "0.6.0"
   end
 end

data/lib/quby/compiler.rb

@@ -28,19 +28,23 @@ require 'quby/compiler/outputs'
 
 module Quby
   module Compiler
-    def self.compile(key, sourcecode, path: nil, lookup_tables:, &block)
+    LOCALE_FILE_PREFIX = 'locale-'.freeze
+
+    def self.compile(key, sourcecode, path: nil, lookup_tables:, translations: {}, &block)
       Quby::Compiler::Instance.new(lookup_tables: lookup_tables).compile(
         key: key,
         sourcecode: sourcecode,
         path: path,
+        translations: translations,
         &block
       )
     end
 
-    def self.validate(key, sourcecode, lookup_tables:)
-      Quby::Compiler::Instance.new(lookup_tables: lookup_tables).validate(
+    def self.validate(key, sourcecode, lookup_tables:, translations: {})
+      Quby::Compiler::Instance.new(lookup_tables:).validate(
         key: key,
         sourcecode: sourcecode,
+        translations:,
       )
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quby-compiler
 version: !ruby/object:Gem::Version
-  version: 0.5.41
+  version: 0.6.0
 platform: ruby
 authors:
 - Marten Veldthuis
@@ -230,6 +230,7 @@ files:
 - lib/quby/compiler/markdown_parser.rb
 - lib/quby/compiler/output.rb
 - lib/quby/compiler/outputs.rb
+- lib/quby/compiler/outputs/locale_serializer.rb
 - lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb
 - lib/quby/compiler/outputs/quby_frontend_v2_serializer.rb
 - lib/quby/compiler/outputs/roqua_serializer.rb