Merge pull request #2103 from alphagov/use-erb-templates-for-questions

Allow questions to use ERB templates

Author: floehopper

app/presenters/checkbox_question_presenter.rb

@@ -4,7 +4,7 @@ def response_labels(values)
       if value == SmartAnswer::Question::Checkbox::NONE_OPTION
         value.to_s
       else
-        translate_option(value)
+        render_option(value)
       end
     end
   end

app/presenters/flow_registration_presenter.rb

@@ -35,17 +35,18 @@ def description
 
   NODE_PRESENTER_METHODS = [:title, :body, :hint]
 
+  module MethodMissingHelper
+    def method_missing(method, *args, &block)
+      MethodMissingObject.new(method, parent_method = nil, blank_to_s = true)
+    end
+  end
+
   def indexable_content
     HTMLEntities.new.decode(
       text = @flow.questions.inject([start_node.body]) { |acc, node|
-        pres = QuestionPresenter.new(@i18n_prefix, node)
+        pres = QuestionPresenter.new(@i18n_prefix, node, nil, helpers: [MethodMissingHelper])
         acc.concat(NODE_PRESENTER_METHODS.map { |method|
-          begin
-            pres.send(method)
-          rescue I18n::MissingInterpolationArgument
-            # We can't do much about this, so we ignore these text nodes
-            nil
-          end
+          pres.send(method)
         })
       }.compact.join(" ").gsub(/(?:<[^>]+>|\s)+/, " ")
     )

app/presenters/question_presenter.rb

@@ -6,56 +6,106 @@ class QuestionPresenter < NodePresenter
     :translate_option
   ] => :@renderer
 
+  delegate use_erb_template?: :@node
+
   def initialize(i18n_prefix, node, state = nil, options = {})
     super(i18n_prefix, node, state)
-    @renderer = options[:renderer] || SmartAnswer::I18nRenderer.new(
-      i18n_prefix: @i18n_prefix,
-      node: @node,
-      state: @state
-    )
+    @renderer = options[:renderer]
+    helpers = options[:helpers] || []
+    if use_erb_template?
+      @renderer ||= SmartAnswer::ErbRenderer.new(
+        template_directory: @node.template_directory.join('questions'),
+        template_name: @node.filesystem_friendly_name,
+        locals: @state.to_hash,
+        helpers: helpers
+      )
+    else
+      @renderer ||= SmartAnswer::I18nRenderer.new(
+        i18n_prefix: @i18n_prefix,
+        node: @node,
+        state: @state
+      )
+    end
   end
 
   def title
-    translate!('title', rescue_exception: false)
+    if use_erb_template?
+      @renderer.single_line_of_content_for(:title)
+    else
+      translate!('title', rescue_exception: false)
+    end
   end
 
   def error
     if @state.error.present?
-      translate!(@state.error.to_sym) || error_message || I18n.translate('flow.defaults.error_message')
+      error_message_for(@state.error) || error_message_for('error_message') || I18n.translate('flow.defaults.error_message')
     end
   end
 
-  def error_message
-    translate!('error_message')
+  def error_message_for(key)
+    if use_erb_template?
+      message = @renderer.single_line_of_content_for(key.to_sym)
+      message.blank? ? nil : message
+    else
+      translate!(key)
+    end
   end
 
   def hint
-    translate!('hint')
+    if use_erb_template?
+      @renderer.single_line_of_content_for(:hint)
+    else
+      translate!('hint')
+    end
   end
 
   def label
-    translate!('label')
+    if use_erb_template?
+      @renderer.single_line_of_content_for(:label)
+    else
+      translate!('label')
+    end
   end
 
   def suffix_label
-    translate!('suffix_label')
+    if use_erb_template?
+      @renderer.single_line_of_content_for(:suffix_label)
+    else
+      translate!('suffix_label')
+    end
   end
 
   def has_labels?
     label.present? || suffix_label.present?
   end
 
   def body(html: true)
-    translate_and_render('body', html: html)
+    if use_erb_template?
+      @renderer.content_for(:body, html: html)
+    else
+      translate_and_render('body', html: html)
+    end
   end
 
   def post_body
-    translate_and_render('post_body', html: true)
+    if use_erb_template?
+      @renderer.content_for(:post_body, html: true)
+    else
+      translate_and_render('post_body', html: true)
+    end
   end
 
   def options
     @node.options.map do |option|
-      OpenStruct.new(label: translate_option(option), value: option)
+      OpenStruct.new(label: render_option(option), value: option)
+    end
+  end
+
+  def render_option(key)
+    if use_erb_template?
+      @renderer.option_text(key.to_sym)
+    else
+      translate_option(key)
     end
   end
 

lib/graph_presenter.rb

@@ -74,34 +74,15 @@ def word_wrap(text, line_width = 40)
     end * "\n"
   end
 
-  def allow_missing_interpolations(&block)
-    old = I18n.config.missing_interpolation_argument_handler
-    I18n.config.missing_interpolation_argument_handler = ->(key) { "((#{key}))" }
-    block.call
-  ensure
-    I18n.config.missing_interpolation_argument_handler = old
-  end
-
-  def i18n_prefix(node)
-    "flow.#{@flow.name}.#{node.name}"
-  end
-
-  def node_title(node)
-    allow_missing_interpolations do
-      I18n.translate!("#{i18n_prefix(node)}.title", {})
+  module MethodMissingHelper
+    def method_missing(method, *args, &block)
+      MethodMissingObject.new(method)
     end
-  rescue I18n::MissingTranslationData
-    ""
   end
 
-  def translate_option(node, option)
-    allow_missing_interpolations do
-      begin
-        I18n.translate!("flow.#{@flow.name}.options.#{option}")
-      rescue I18n::MissingTranslationData
-        I18n.translate("#{i18n_prefix(node)}.options.#{option}")
-      end
-    end
+  def node_title(node)
+    presenter = QuestionPresenter.new(nil, node, nil, helpers: [MethodMissingHelper])
+    presenter.title
   end
 
   def presenter

lib/method_missing_object.rb

@@ -0,0 +1,19 @@
+class MethodMissingObject
+  def initialize(method, parent_method = nil, blank_to_s = false)
+    @method = method
+    @parent_method = parent_method
+    @blank_to_s = blank_to_s
+  end
+
+  def method_missing(method, *args, &block)
+    MethodMissingObject.new(method, parent_method = self, blank_to_s = @blank_to_s)
+  end
+
+  def description
+    @parent_method ? "#{@parent_method.description}.#{@method}" : @method
+  end
+
+  def to_s
+    @blank_to_s ? "" : "<%= #{description} %>".html_safe
+  end
+end

lib/smart_answer/erb_renderer.rb

@@ -1,11 +1,22 @@
 module SmartAnswer
   class ErbRenderer
+    module QuestionOptionsHelper
+      def options(options = nil)
+        if options
+          @options = options
+        else
+          @options || {}
+        end
+      end
+    end
+
     def initialize(template_directory:, template_name:, locals: {}, helpers: [])
       @template_directory = template_directory
       @template_name = template_name
       @locals = locals
       @view = ActionView::Base.new([@template_directory])
       helpers.each { |helper| @view.extend(helper) }
+      @view.extend(QuestionOptionsHelper)
     end
 
     def single_line_of_content_for(key)
@@ -18,6 +29,11 @@ def content_for(key, html: true)
       html ? GovspeakPresenter.new(content).html : normalize_blank_lines(content).html_safe
     end
 
+    def option_text(key)
+      rendered_view
+      @view.options.fetch(key)
+    end
+
     def erb_template_path
       @template_directory.join(erb_template_name)
     end

lib/smart_answer/flow.rb

@@ -48,36 +48,40 @@ def status(s = nil)
       @status
     end
 
+    def use_erb_templates_for_questions
+      @use_erb_templates_for_questions = true
+    end
+
     def multiple_choice(name, options = {}, &block)
-      add_node Question::MultipleChoice.new(self, name, options, &block)
+      add_question(Question::MultipleChoice, name, options, &block)
     end
 
     def country_select(name, options = {}, &block)
-      add_node Question::CountrySelect.new(self, name, options, &block)
+      add_question(Question::CountrySelect, name, options, &block)
     end
 
-    def date_question(name, &block)
-      add_node Question::Date.new(self, name, &block)
+    def date_question(name, options = {}, &block)
+      add_question(Question::Date, name, options, &block)
     end
 
     def value_question(name, options = {}, &block)
-      add_node Question::Value.new(self, name, options, &block)
+      add_question(Question::Value, name, options, &block)
     end
 
-    def money_question(name, &block)
-      add_node Question::Money.new(self, name, &block)
+    def money_question(name, options = {}, &block)
+      add_question(Question::Money, name, options, &block)
     end
 
-    def salary_question(name, &block)
-      add_node Question::Salary.new(self, name, &block)
+    def salary_question(name, options = {}, &block)
+      add_question(Question::Salary, name, options, &block)
     end
 
-    def checkbox_question(name, &block)
-      add_node Question::Checkbox.new(self, name, &block)
+    def checkbox_question(name, options = {}, &block)
+      add_question(Question::Checkbox, name, options, &block)
     end
 
-    def postcode_question(name, &block)
-      add_node Question::Postcode.new(self, name, &block)
+    def postcode_question(name, options = {}, &block)
+      add_question(Question::Postcode, name, options, &block)
     end
 
     def outcome(name, &block)
@@ -130,9 +134,15 @@ def normalize_responses(responses)
     class InvalidStatus < StandardError; end
 
     private
-      def add_node(node)
-        raise "Node #{node.name} already defined" if node_exists?(node)
-        @nodes << node
-      end
+
+    def add_question(klass, name, options = {}, &block)
+      options.reverse_merge!(use_erb_template: @use_erb_templates_for_questions)
+      add_node klass.new(self, name, options, &block)
+    end
+
+    def add_node(node)
+      raise "Node #{node.name} already defined" if node_exists?(node)
+      @nodes << node
+    end
   end
 end

lib/smart_answer/node.rb

@@ -21,6 +21,10 @@ def to_s
       name.to_s
     end
 
+    def filesystem_friendly_name
+      to_s.sub(/\?$/, '')
+    end
+
     def calculate(variable_name, &block)
       @calculations << Calculation.new(variable_name, &block)
     end

lib/smart_answer/question/base.rb

@@ -12,6 +12,7 @@ def initialize(flow, name, options = {}, &block)
         @permitted_next_nodes = []
         @predicate_stack = []
         @predicates = {}
+        @uses_erb_template = options[:use_erb_template]
         super
       end
 
@@ -126,6 +127,10 @@ def question?
         true
       end
 
+      def use_erb_template?
+        @uses_erb_template
+      end
+
     private
       def permitted_next_node?(next_node)
         @permitted_next_nodes.include?(next_node)