metadata_presenter 2.4.1 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fafa1e61048b9b7413e3ca929cb725362609c7c77a58dd7a29b761da21ceb65
-  data.tar.gz: 368cc444a674ffbddbfdaf287bc6ae2518759d1cc3e7e5865cadeff8a80241d7
+  metadata.gz: e206021a09261b7ed5628f794767a935f94c89315a9a2da0771e0e8b0a3f7d10
+  data.tar.gz: 82fdc1a08806381b692198e17f1d9e600d876a8ee1313947738ffbfb9585c2c1
 SHA512:
-  metadata.gz: ace08c6cb80c4497d948971a089593cca09a4959b639a6ff2e139d7eb2269c694ae0fa80d56e867690e46f3b5faceb4bef5717e035b9d7728d4481a9ae80d3d0
-  data.tar.gz: 94759926ab0e16acc146fb7ae3ba147cb5e72bac08d0c4297e30a3fb913d1fbee385027c305b3f8343f5a08a634020eaa5a1c5e746c293471fa2e4f2284ad636
+  metadata.gz: 1cd644e56226d865e3f1d903e06b0b82bb606bb981f6b32510670a5d2ae5e262e890c9ff5d65e77796c07715e184b4fb772e2a3cd4a648c851c558d6aa12eea9
+  data.tar.gz: 75524d74b558b8f64b9cd31f3c2125ba94df8744e6ca7afa9ab49f0c499f29c91bbe2428c81f61f12e35c3156539b122f921637280b8a97d84bb8afff7f615dd

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
+      return @ordered unless @ordered.empty?
+
+      @ordered = make_grid
+      add_columns
+      add_rows
+      add_by_coordinates
+      insert_expression_spacers
+      trim_spacers
+
+      @ordered
+    end
+
+    def ordered_flow
+      @ordered_flow ||=
+        build.flatten.reject { |obj| obj.is_a?(MetadataPresenter::Spacer) }
+    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/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

data/app/views/metadata_presenter/page/exit.html.erb

@@ -0,0 +1,29 @@
+<div class="fb-main-grid-wrapper" data-fb-pagetype="<%= @page.type %>">
+  <div class="govuk-grid-row">
+    <div class="govuk-grid-column-two-thirds">
+
+      <%= render 'metadata_presenter/attribute/section_heading' %>
+
+      <h1 class="fb-editable govuk-heading-xl"
+          data-fb-content-id="page[heading]"
+          data-fb-content-type="element">
+        <%= @page.heading %>
+      </h1>
+
+      <%= render 'metadata_presenter/attribute/lede' %>
+
+      <%= form_for @page_answers, as: :answers, url: @page.url, method: :post do |f| %>
+
+        <%= render partial: 'metadata_presenter/component/components',
+                   locals: {
+                     f: f,
+                     components: @page.components,
+                     tag: nil,
+                     classes: nil,
+                     input_components: @page.supported_input_components,
+                     content_components: @page.supported_content_components
+                   } %>
+      <% end %>
+    </div>
+  </div>
+</div>

data/config/initializers/supported_components.rb

@@ -12,6 +12,10 @@ Rails.application.config.supported_components =
       input: %w(),
       content: %w(content)
     },
+    exit: {
+      input: %w(),
+      content: %w(content)
+    },
     multiplequestions: {
       input: %w(text textarea number date radios checkboxes),
       content: %w(content)

data/default_metadata/page/exit.json

@@ -0,0 +1,9 @@
+{
+  "_id": "page.exit",
+  "_type": "page.exit",
+  "section_heading": "",
+  "heading": "Title",
+  "lede": "",
+  "components": [],
+  "url": ""
+}