metadata_presenter 2.3.6 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fde1f4b73263207626fb0693406115b7bf5d6c0e5a8f59624260cb25a3e38158
-  data.tar.gz: 3487fe9c01196f349cc4a84020cfb43246ecce2e123b01a65c727ce296967a53
+  metadata.gz: 5bd3891b62938a67dd025d49a96098778ad66221bf62cb2351002906e78aa4b4
+  data.tar.gz: 9dba99d36da50beea7a209d27f3371e4e814776d86d609436ac500c6d91cbd14
 SHA512:
-  metadata.gz: 6d1e5ec205720fa0a197885e5e5a989891a4566ea9c2a1eddae179352c10a2f6060805306c403a50d007da34a80e556dc73b7b9f1c40b63363d2fd4f65bc96e1
-  data.tar.gz: 36362beca9e5110383893160eefaafe612dada9a429acc8db94749113c3f921a84ff3581d1074b16f43d0f9bb8cdc91463b20591a8389cd28032415668d23a8a
+  metadata.gz: c8c2dde3ca3e374e0f50eebc881a64fe676f4d6fa0156ab73e26e79e0c9a19292c4c21d55665171441c52af3c56a6472783365df050246ba7e583da89db112ce
+  data.tar.gz: c114dddbf37af9e800c9eb6c4601d6f250175efd1b35f9159a728edb0c3239357f6f35b281bd1280792101d669885e6f48218ffdeca876edbfbf5af5f0f9051e

data/app/controllers/metadata_presenter/answers_controller.rb

@@ -3,6 +3,7 @@ module MetadataPresenter
     before_action :check_page_exists
 
     def create
+      @previous_answers = reload_user_data.deep_dup
       @page_answers = PageAnswers.new(page, answers_params)
 
       upload_files if upload?
@@ -28,8 +29,9 @@ module MetadataPresenter
       next_page = NextPage.new(
         service: service,
         session: session,
-        user_data: load_user_data,
-        current_page_url: page_url
+        user_data: reload_user_data,
+        current_page_url: page_url,
+        previous_answers: @previous_answers
       ).find
 
       if next_page.present?

data/app/controllers/metadata_presenter/engine_controller.rb

@@ -5,6 +5,14 @@ module MetadataPresenter
     helper MetadataPresenter::ApplicationHelper
     default_form_builder GOVUKDesignSystemFormBuilder::FormBuilder
 
+    def reload_user_data
+      if defined? super
+        super
+      else
+        load_user_data
+      end
+    end
+
     def back_link
       previous_page = PreviousPage.new(
         service: service,

data/app/models/metadata_presenter/flow.rb

@@ -16,6 +16,10 @@ module MetadataPresenter
       metadata['next']['default']
     end
 
+    def all_destination_uuids
+      conditionals.map(&:next).append(default_next)
+    end
+
     def conditionals
       Array(metadata['next']['conditionals']).map do |conditional_metadata|
         Conditional.new(conditional_metadata)

data/app/models/metadata_presenter/grid.rb

@@ -0,0 +1,203 @@
+module MetadataPresenter
+  class Spacer < OpenStruct
+  end
+
+  class Grid
+    def initialize(service)
+      @service = service
+      @ordered = []
+      @routes = []
+      @traversed = []
+      @coordinates = setup_coordinates
+    end
+
+    ROW_ZERO = 0
+
+    def build
+      @ordered = make_grid
+      add_columns
+      add_rows
+      add_by_coordinates
+      trim_spacers
+      insert_expression_spacers
+
+      @ordered
+    end
+
+    def ordered_flow
+      @ordered_flow ||= begin
+        flow = @ordered.empty? ? build.flatten : @ordered.flatten
+        flow.reject { |obj| obj.is_a?(MetadataPresenter::Spacer) }
+      end
+    end
+
+    def ordered_pages
+      ordered_flow.reject(&:branch?)
+    end
+
+    private
+
+    attr_reader :service
+    attr_accessor :ordered, :traversed, :routes, :coordinates
+
+    def setup_coordinates
+      service.flow.keys.index_with { |_uuid| { row: nil, column: nil } }
+    end
+
+    def route_from_start
+      @route_from_start ||=
+        MetadataPresenter::Route.new(
+          service: service,
+          traverse_from: service.start_page.uuid
+        )
+    end
+
+    def make_grid
+      traverse_all_routes
+
+      rows = @routes.map(&:row).max
+      columns = @routes.map { |r| r.column + r.flow_uuids.count }.max
+      columns.times.map { rows.times.map { MetadataPresenter::Spacer.new } }
+    end
+
+    def traverse_all_routes
+      # Always traverse the route that begins from the start page first and get
+      # the potential routes from any branching points that exist.
+      route_from_start.traverse
+      @routes.append(route_from_start)
+      traversed_routes = route_from_start.routes
+
+      index = 0
+      until traversed_routes.empty?
+        if index > total_potential_routes
+          ActiveSupport::Notifications.instrument(
+            'exceeded_total_potential_routes',
+            message: 'Exceeded total number of potential routes'
+          )
+          break
+        end
+
+        route = traversed_routes.shift
+        @routes.append(route)
+
+        # Every route exiting a branching point needs to be traversed and any
+        # additional routes from other branching points collected and then also
+        # traversed.
+        route.traverse
+        traversed_routes |= route.routes
+
+        index += 1
+      end
+    end
+
+    def add_columns
+      @routes.each do |route|
+        route.flow_uuids.each.with_index(route.column) do |uuid, column|
+          column_number = @coordinates[uuid][:column]
+          if column_number.nil? || column > column_number
+            @coordinates[uuid][:column] = column
+          end
+        end
+      end
+    end
+
+    def add_rows
+      @routes.each do |route|
+        route.flow_uuids.each do |uuid|
+          next if @traversed.include?(uuid)
+
+          @coordinates[uuid][:row] = route.row if @coordinates[uuid][:row].nil?
+
+          update_route_rows(route, uuid)
+          @traversed.push(uuid)
+        end
+      end
+    end
+
+    # Each Route object has a starting row. Each Route object has no knowledge
+    # of other potential routes and pages/branches that may or may not exist in
+    # them. The starting row may need to change dependent upon what has been
+    # traversed in other routes.
+    def update_route_rows(route, uuid)
+      flow_object = service.flow_object(uuid)
+      if flow_object.branch? && route.row > ROW_ZERO
+        destinations = routes_exiting_branch(flow_object)
+        destinations.each.with_index(route.row) do |destination_uuid, row|
+          @routes.each do |r|
+            r.row = row if r.traverse_from == destination_uuid
+          end
+        end
+      end
+    end
+
+    def add_by_coordinates
+      @coordinates.each do |uuid, position|
+        # If row and column are nil then the object is detached
+        next if position[:row].nil? || position[:column].nil?
+
+        flow_object = service.flow_object(uuid)
+        @ordered[position[:column]][position[:row]] = flow_object
+      end
+    end
+
+    # Find the very last MetadataPresenter::Flow object in every column and
+    # remove any Spacer objects after that.
+    def trim_spacers
+      @ordered.each_with_index do |column, index|
+        last_index_of = column.rindex { |item| item.is_a?(MetadataPresenter::Flow) }
+        @ordered[index] = @ordered[index][0..last_index_of]
+      end
+    end
+
+    # Each branch has a certain number of exits that require their own line
+    # and arrow. Insert any spacers into the necessary row in the column after
+    # the one the branch is located in.
+    def insert_expression_spacers
+      service.branches.each do |branch|
+        position = @coordinates[branch.uuid]
+        next if position[:row].nil? || position[:column].nil? # detached branch
+
+        next_column = position[:column] + 1
+        uuids = []
+        exiting_destinations_from_branch(branch).each.with_index(position[:row]) do |uuid, row|
+          if uuids.include?(uuid)
+            @ordered[next_column].insert(row, MetadataPresenter::Spacer.new)
+          end
+
+          uuids.push(uuid) unless uuids.include?(uuid)
+        end
+      end
+    end
+
+    # The frontend requires that expressions of type 'or' get there own line and
+    # arrow. 'and' expression types continue to be grouped together.
+    # Return the UUIDs of the destinations exiting a branch and allow duplicates
+    # if the expression type is an 'or'.
+    def exiting_destinations_from_branch(branch)
+      destination_uuids = branch.conditionals.map do |conditional|
+        if conditional.type == 'or'
+          conditional.expressions.map(&:next)
+        else
+          conditional.next
+        end
+      end
+      destination_uuids.flatten
+    end
+
+    # Any destinations exiting the branch that have not already been traversed.
+    def routes_exiting_branch(branch)
+      branch.all_destination_uuids.reject { |uuid| @traversed.include?(uuid) }
+    end
+
+    # Deliberately not including the default next for each branch as when row
+    # zero is created it takes the first available conditional for each branch.
+    # The remaining are then used to create route objects. Therefore the total
+    # number of remaining routes will be the same as the total of all the branch
+    # conditionals.
+    # Add 1 additional route as that represents the route_from_start.
+    def total_potential_routes
+      @total_potential_routes ||=
+        service.branches.sum { |branch| branch.conditionals.size } + 1
+    end
+  end
+end

data/app/models/metadata_presenter/next_page.rb

@@ -1,7 +1,7 @@
 module MetadataPresenter
   class NextPage
     include ActiveModel::Model
-    attr_accessor :service, :session, :user_data, :current_page_url
+    attr_accessor :service, :session, :user_data, :current_page_url, :previous_answers
 
     def find
       return check_answers_page if return_to_check_your_answer?
@@ -11,17 +11,53 @@ module MetadataPresenter
       else
         service.find_page_by_uuid(current_page_flow.default_next)
       end
+    ensure
+      session[:return_to_check_your_answer] = nil
     end
 
     private
 
     def check_answers_page
-      session[:return_to_check_your_answer] = nil
       service.pages.find { |page| page.type == 'page.checkanswers' }
     end
 
     def return_to_check_your_answer?
-      session[:return_to_check_your_answer].present?
+      session[:return_to_check_your_answer].present? &&
+        components_not_used_for_branching_and_answers_unchanged?
+    end
+
+    def components_not_used_for_branching_and_answers_unchanged?
+      components_not_used_for_branching? && answers_unchanged?
+    end
+
+    def components_not_used_for_branching?
+      expressions.none? { |expression| component_ids.include?(expression) }
+    end
+
+    def answers_unchanged?
+      components = current_page_components.select do |component|
+        component.uuid.in?(expressions.map(&:component))
+      end
+
+      components.all? do |component|
+        user_data[component.id] == previous_answers[component.id]
+      end
+    end
+
+    def component_ids
+      current_page_components.map(&:id)
+    end
+
+    def current_page_components
+      current_page.components
+    end
+
+    def expressions
+      collection = service.branches.map do |branch|
+        branch.conditionals.map(&:expressions)
+      end
+
+      collection.flatten
     end
 
     def conditionals?

data/app/models/metadata_presenter/page.rb

@@ -13,6 +13,12 @@ module MetadataPresenter
       add_extra_component
     ].freeze
     QUESTION_PAGES = %w[page.singlequestion page.multiplequestions].freeze
+    USES_HEADING = %w[
+      page.content
+      page.checkanswers
+      page.confirmation
+      page.multiplequestions
+    ].freeze
 
     def editable_attributes
       to_h.reject { |k, _| k.in?(NOT_EDITABLE) }
@@ -87,8 +93,7 @@ module MetadataPresenter
     private
 
     def heading?
-      Array(components).size != 1 ||
-        type.in?(['page.content', 'page.checkanswers', 'page.confirmation'])
+      type.in?(USES_HEADING) || Array(components).size != 1
     end
 
     def to_components(node_components, collection:)

data/app/models/metadata_presenter/route.rb

@@ -0,0 +1,76 @@
+module MetadataPresenter
+  class Route
+    attr_reader :traverse_from
+    attr_accessor :flow_uuids, :routes, :row, :column
+
+    def initialize(service:, traverse_from:, row: 0, column: 0)
+      @service = service
+      @traverse_from = traverse_from
+      @row = row
+      @column = column
+      @routes = []
+      @flow_uuids = []
+    end
+
+    def traverse
+      @flow_uuid = traverse_from
+
+      index = column
+      until @flow_uuid.blank?
+        if index > service.flow.size
+          ActiveSupport::Notifications.instrument(
+            'exceeded_total_flow_objects',
+            message: 'Exceeded total number of flow objects'
+          )
+          break
+        end
+
+        @flow_uuids.push(@flow_uuid) unless @flow_uuids.include?(@flow_uuid)
+        flow_object = service.flow_object(@flow_uuid)
+
+        if flow_object.branch?
+          destinations = destination_uuids(flow_object)
+          # Take the first conditional destination and follow that until the end
+          # of the route.
+          @flow_uuid = destinations.shift
+
+          # The remaining conditional destinations and the branch's default next
+          # (otherwise) will be the starting point for a new Route object to be
+          # traversed.
+          # The default behaviour is that the next destination will be on the row
+          # below this current route's row. This can be changed under certain
+          # conditions in the Grid model.
+          # Each of the destinations need to be placed in the column after the
+          # current column.
+          row_number = row + 1
+          column_number = index + 1
+          destinations.each do |uuid|
+            @routes.push(
+              MetadataPresenter::Route.new(
+                service: service,
+                traverse_from: uuid,
+                row: row_number,
+                column: column_number
+              )
+            )
+            row_number += 1
+          end
+        else
+          @flow_uuid = flow_object.default_next
+        end
+
+        index += 1
+      end
+
+      @flow_uuids
+    end
+
+    private
+
+    attr_reader :service
+
+    def destination_uuids(flow_object)
+      flow_object.conditionals.map(&:next).push(flow_object.default_next)
+    end
+  end
+end