hecks 3.5.0 → 3.6.0

data/lib/hecks/projections/site/table/checks.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../edge/pattern"
+require_relative "navigation_checks"
 
 module Hecks
   module Projections
@@ -12,8 +13,6 @@ module Hecks
         # prefix that is not.
         class Checks
           SWITCH_ID = /\A[a-z][a-z0-9_]*\z/
-          FRAGMENT = /\A[A-Za-z0-9][\w:.-]*\z/
-          PUBLIC_MENUS = %w[desktop mobile footer].freeze
 
           # The navigation slots a row sits in.
           #
@@ -31,6 +30,7 @@ module Hecks
             @rows = rows
             @links = links
             @problems = problems
+            @navigation = NavigationChecks.new(problems)
           end
 
           # @return [void]
@@ -38,7 +38,7 @@ module Hecks
             check_duplicate_paths
             check_switches
             @rows.each { |row| check_row(row) }
-            @links.each { |link| check_link(link) }
+            @links.each { |link| @navigation.check_link(link) }
             check_unique((@rows + @links).filter_map(&:admin_key), "admin key")
             check_unique(@rows.map(&:source).grep(/\Aglobal:/), "source")
           end
@@ -47,28 +47,33 @@ module Hecks
 
           def check_duplicate_paths
             seen = Hash.new { |hash, path| hash[path] = [] }
-            @rows.each do |row|
-              [row.path, *row.aliases].compact.each do |path|
-                problem(path, "is declared twice") if seen[path].any? { |other| other.verbs.intersect?(row.verbs) }
-                seen[path] << row
-              end
-            end
+            @rows.each { |row| [row.path, *row.aliases].compact.each { |path| claim(seen, row, path) } }
+          end
+
+          def claim(seen, row, path)
+            problem(path, "is declared twice") if seen[path].any? { |other| other.verbs.intersect?(row.verbs) }
+            seen[path] << row
           end
 
           def check_switches
             @rows.reject { |row| row.switch.empty? }.group_by(&:switch).each do |id, rows|
-              next if rows.map(&:off).uniq.size == 1
-
-              problem("switch #{id}", "is on for #{rows.reject(&:off).map(&:path).join(', ')} and off for the rest")
+              check_switch_agreement(id, rows)
             end
           end
 
+          def check_switch_agreement(id, rows)
+            return if rows.map(&:off).uniq.size == 1
+
+            problem("switch #{id}", "is on for #{rows.reject(&:off).map(&:path).join(", ")} and off for the rest")
+          end
+
           def check_row(row)
             path = row.path.to_s
             problem(path, "must start with /") unless path.start_with?("/")
             check_switch(row, path)
             check_redirect(row, path)
-            check_navigation(row, path)
+            check_aliases(row, path)
+            @navigation.check_row(row, path)
             check_indexing(row, path)
             check_beneath_prefix(row, path)
             return unless row.preview == "draft" && row.source == "none"
@@ -86,45 +91,15 @@ module Hecks
           def check_redirect(row, path)
             targeted = %w[redirect rewrite].include?(row.kind)
             problem(path, "is a #{row.kind} and needs redirect_to") if targeted && row.redirect_to.to_s.empty?
-            if !targeted && row.redirect_to
-              problem(path, "has redirect_to but is a #{row.kind}; only a redirect or rewrite has a target")
-            end
-            return if row.aliases.empty? || row.kind == "page"
-
-            problem(path, "has aliases but is a #{row.kind}; aliases redirect to a page")
-          end
+            return unless !targeted && row.redirect_to
 
-          def check_navigation(row, path)
-            slots = self.class.navigation(row)
-            return if slots.empty?
-
-            unless row.verbs.include?("GET")
-              problem(path, "sits in the navigation but answers #{row.verbs.join(',')}; a link is a GET")
-            end
-            problem(path, "sits in the navigation and has a parameter") if path.match?(/[:*]/)
-            problem(path, "sits in the navigation and has no label") if row.label.to_s.empty?
-            check_heading(row, path)
-            check_menu_audience(row, path, slots)
+            problem(path, "has redirect_to but is a #{row.kind}; only a redirect or rewrite has a target")
           end
 
-          def check_heading(item, path)
-            return unless item.mobile_heading
-            return problem(path, "has a mobile_heading but no mobile_order") if item.mobile_order.nil?
-
-            problem(path, "has an empty mobile_heading") if item.mobile_heading.strip.empty?
-          end
+          def check_aliases(row, path)
+            return if row.aliases.empty? || row.kind == "page"
 
-          def check_link(link)
-            path = "NavLink #{link.path}"
-            slots = self.class.navigation(link)
-            problem(path, "sits in no navigation; give it nav_order, mobile_order, footer_column or admin_key") if slots.empty?
-            problem(path, "has a parameter; a link is to one page") if link.path.to_s.match?(/[:*]/)
-            problem(path, "has no label") if link.label.to_s.empty?
-            if link.fragment && !link.fragment.match?(FRAGMENT)
-              problem(path, "has fragment #{link.fragment.inspect}; a fragment is an element id, written without #")
-            end
-            check_heading(link, path)
-            check_menu_audience(link, path, slots)
+            problem(path, "has aliases but is a #{row.kind}; aliases redirect to a page")
           end
 
           # A public route under a prefix that is not public (the sign-in page beside the admin
@@ -133,22 +108,18 @@ module Hecks
           def check_beneath_prefix(row, path)
             return if row.auth != "public" || row.explicit_cache || row.path.nil?
 
-            pattern = Edge::Pattern.edge(row.path)
-            prefix = @rows.find do |other|
-              other.auth != "public" && other.path && Edge::Pattern.strictly_covers?(Edge::Pattern.edge(other.path), pattern)
-            end
+            prefix = non_public_prefix(row)
             return unless prefix
 
             problem(path, "is public but sits beneath #{prefix.path}, which is #{prefix.auth}; " \
                           "name its cache class (cache: \"no_store\" for a sign-in page) to say that is meant")
           end
 
-          def check_menu_audience(row, path, slots)
-            public_slots = slots & PUBLIC_MENUS
-            if row.auth != "public" && public_slots.any?
-              problem(path, "is an admin page in the #{public_slots.join(' and ')} navigation")
+          def non_public_prefix(row)
+            pattern = Edge::Pattern.edge(row.path)
+            @rows.find do |other|
+              other.auth != "public" && other.path && Edge::Pattern.strictly_covers?(Edge::Pattern.edge(other.path), pattern)
             end
-            problem(path, "is public and sits in the admin navigation") if row.auth == "public" && slots.include?("admin")
           end
 
           def check_indexing(row, path)

data/lib/hecks/projections/site/table/link_builder.rb

@@ -33,18 +33,27 @@ module Hecks
             fields = checked_fields(member, label)
             target = @rows.find { |row| row.path == fields[:path] && row.verbs.include?("GET") }
             problem(label, "points at no route that answers GET; declare the route first") unless target
-            link = Link.new(**fields, off: target ? target.off : false, switch: target ? target.switch : "",
-                                      auth: target ? target.auth : "public")
+            fill_orders(Link.new(**fields, **route_facts(target)))
+          end
+
+          private
+
+          # What a link copies from the route it points at; a link to no route is on and public.
+          def route_facts(target)
+            return { off: false, switch: "", auth: "public" } unless target
+
+            { off: target.off, switch: target.switch, auth: target.auth }
+          end
+
+          def fill_orders(link)
             link.footer_order ||= 0 if link.footer_column
             link.admin_order ||= 0 if link.admin_key
             link
           end
 
-          private
-
           def checked_fields(member, label)
             member.each_key do |key|
-              problem(label, "has no field #{key}; fields are #{FIELDS.keys.join(', ')}") unless FIELDS.key?(key)
+              problem(label, "has no field #{key}; fields are #{FIELDS.keys.join(", ")}") unless FIELDS.key?(key)
             end
             known = member.slice(*FIELDS.keys)
             known.each do |key, value|

data/lib/hecks/projections/site/table/navigation_checks.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      class Table
+        # What a row or an extra link in the navigation must satisfy: a GET with a label and no
+        # parameter, a heading only where it has a mobile slot, and a menu its audience may see.
+        class NavigationChecks
+          FRAGMENT = /\A[A-Za-z0-9][\w:.-]*\z/
+          PUBLIC_MENUS = %w[desktop mobile footer].freeze
+
+          # @param problems [Array<String>] collects each problem found, one line each
+          def initialize(problems)
+            @problems = problems
+          end
+
+          # @param row [Row] a row whose defaults are filled in
+          # @param path [String] the row's path, as the problems name it
+          # @return [void]
+          def check_row(row, path)
+            slots = Checks.navigation(row)
+            return if slots.empty?
+
+            unless row.verbs.include?("GET")
+              problem(path, "sits in the navigation but answers #{row.verbs.join(",")}; a link is a GET")
+            end
+            problem(path, "sits in the navigation and has a parameter") if path.match?(/[:*]/)
+            problem(path, "sits in the navigation and has no label") if row.label.to_s.empty?
+            check_heading(row, path)
+            check_menu_audience(row, path, slots)
+          end
+
+          # @param link [Link] an extra navigation entry
+          # @return [void]
+          def check_link(link)
+            path = "NavLink #{link.path}"
+            slots = Checks.navigation(link)
+            problem(path, "sits in no navigation; give it nav_order, mobile_order, footer_column or admin_key") if slots.empty?
+            check_link_target(link, path)
+            check_heading(link, path)
+            check_menu_audience(link, path, slots)
+          end
+
+          private
+
+          def check_link_target(link, path)
+            problem(path, "has a parameter; a link is to one page") if link.path.to_s.match?(/[:*]/)
+            problem(path, "has no label") if link.label.to_s.empty?
+            return unless link.fragment && !link.fragment.match?(FRAGMENT)
+
+            problem(path, "has fragment #{link.fragment.inspect}; a fragment is an element id, written without #")
+          end
+
+          def check_heading(item, path)
+            return unless item.mobile_heading
+            return problem(path, "has a mobile_heading but no mobile_order") if item.mobile_order.nil?
+
+            problem(path, "has an empty mobile_heading") if item.mobile_heading.strip.empty?
+          end
+
+          def check_menu_audience(row, path, slots)
+            public_slots = slots & PUBLIC_MENUS
+            if row.auth != "public" && public_slots.any?
+              problem(path, "is an admin page in the #{public_slots.join(" and ")} navigation")
+            end
+            problem(path, "is public and sits in the admin navigation") if row.auth == "public" && slots.include?("admin")
+          end
+
+          def problem(label, text) = @problems << "#{label} #{text}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/table/row_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "row_defaults"
+
 module Hecks
   module Projections
     module Site
@@ -49,25 +51,31 @@ module Hecks
             fields = checked_fields(member, label)
             source = fields[:source] || "none"
             path = fields[:path] || derived_path(source)
-            label = path || label
-            check_source(label, source)
+            check_source(path || label, source)
+            finish(build_row(fields, path, source), path || label)
+          end
+
+          private
+
+          def build_row(fields, path, source)
             verbs = fields.delete(:methods)
             edge_verbs = fields.delete(:edge_methods)
-            row = Row.new(**fields, verbs: verbs, edge_verbs: edge_verbs, path: path, source: source,
-                                    explicit_cache: !fields[:cache].nil?,
-                                    kind: fields[:kind] || default_kind(source), auth: fields[:auth] || "public",
-                                    origin: fields[:origin] || default_origin(source))
-            fill_defaults(row)
+            Row.new(**fields, verbs: verbs, edge_verbs: edge_verbs, path: path, source: source,
+                              explicit_cache: !fields[:cache].nil?,
+                              kind: fields[:kind] || RowDefaults.kind(source), auth: fields[:auth] || "public",
+                              origin: fields[:origin] || RowDefaults.origin(source))
+          end
+
+          def finish(row, label)
+            RowDefaults.fill(row)
             check_values(row, label)
             problem(label, "needs a path") if row.path.nil?
             row
           end
 
-          private
-
           def checked_fields(member, label)
             member.each_key do |key|
-              problem(label, "has no field #{key}; fields are #{FIELDS.keys.join(', ')}") unless FIELDS.key?(key)
+              problem(label, "has no field #{key}; fields are #{FIELDS.keys.join(", ")}") unless FIELDS.key?(key)
             end
             known = member.slice(*FIELDS.keys)
             known.each { |key, value| check_type(label, key, value) }
@@ -78,13 +86,9 @@ module Hecks
             expected = FIELDS.fetch(key)
             return if expected == :bool ? [true, false].include?(value) : value.is_a?(expected)
 
-            problem(label, "has #{key} #{value.inspect}; #{key} is #{expected == :bool ? 'true or false' : "a #{expected}"}")
+            problem(label, "has #{key} #{value.inspect}; #{key} is #{expected == :bool ? "true or false" : "a #{expected}"}")
           end
 
-          def default_kind(source) = source.match?(DERIVED_SOURCE) ? "endpoint" : "page"
-
-          def default_origin(source) = source.match?(DERIVED_SOURCE) ? "domain" : "website"
-
           # A `command:` or `query:` source leaves the path to the forms scheme,
           # `/Chapter/Aggregate/Verb`.
           def derived_path(source)
@@ -92,57 +96,31 @@ module Hecks
             "/#{match[2]}/#{match[3]}/#{match[4]}"
           end
 
-          def fill_defaults(row)
-            row.off = false if row.off.nil?
-            row.compress = true if row.compress.nil?
-            row.cdn = true if row.cdn.nil?
-            row.render ||= row.kind == "page" ? "prerender" : "ssr"
-            row.verbs = list(row.verbs || (row.source.start_with?("command:") ? "POST" : "GET"))
-            row.edge_verbs = row.edge_verbs.nil? ? row.verbs : list(row.edge_verbs)
-            row.aliases = list(row.aliases)
-            row.cache ||= default_cache(row)
-            row.indexable = indexable_by_default?(row) if row.indexable.nil?
-            fill_slots(row)
-          end
-
-          def fill_slots(row)
-            row.preview ||= "public"
-            row.switch ||= ""
-            row.footer_order ||= 0 if row.footer_column
-            row.admin_order ||= 0 if row.admin_key
-          end
-
-          def list(text) = text.to_s.split(",").map(&:strip).reject(&:empty?)
-
-          def default_cache(row)
-            return "no_store" if row.auth != "public" || row.kind == "endpoint"
-
-            row.origin == "assets" ? "immutable" : "page"
-          end
-
-          def indexable_by_default?(row) = row.kind == "page" && row.auth == "public" && !row.off
-
           def check_values(row, label)
             VOCABULARY.each_key do |field|
               next if @vocabulary.fetch(field).include?(row[field])
 
-              problem(label, "has #{field} #{row[field].inspect}; #{field} is one of #{@vocabulary.fetch(field).join(', ')}")
+              problem(label, "has #{field} #{row[field].inspect}; #{field} is one of #{@vocabulary.fetch(field).join(", ")}")
             end
             check_verbs(row, label)
           end
 
           def check_verbs(row, label)
             { "method" => row.verbs, "edge method" => row.edge_verbs }.each do |what, verbs|
-              verbs.each do |verb|
-                next if @vocabulary.fetch(:http_method).include?(verb)
-
-                problem(label, "has #{what} #{verb.inspect}; methods are #{@vocabulary.fetch(:http_method).join(', ')}")
-              end
+              check_known_verbs(label, what, verbs)
             end
             return if (row.verbs - row.edge_verbs).empty?
 
-            problem(label, "has edge_methods #{row.edge_verbs.join(',')}, which leave out its methods " \
-                           "#{(row.verbs - row.edge_verbs).join(',')}; the edge must allow every verb the route answers")
+            problem(label, "has edge_methods #{row.edge_verbs.join(",")}, which leave out its methods " \
+                           "#{(row.verbs - row.edge_verbs).join(",")}; the edge must allow every verb the route answers")
+          end
+
+          def check_known_verbs(label, what, verbs)
+            verbs.each do |verb|
+              next if @vocabulary.fetch(:http_method).include?(verb)
+
+              problem(label, "has #{what} #{verb.inspect}; methods are #{@vocabulary.fetch(:http_method).join(", ")}")
+            end
           end
 
           def check_source(label, source)

data/lib/hecks/projections/site/table/row_defaults.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      class Table
+        # The values a row takes when its declaration leaves them out: what its source implies for
+        # kind, origin and verbs, and what its kind and auth imply for render, cache and indexing.
+        module RowDefaults
+          module_function
+
+          # @param source [String] the row's source
+          # @return [String] `endpoint` for a command or query source, else `page`
+          def kind(source) = source.match?(RowBuilder::DERIVED_SOURCE) ? "endpoint" : "page"
+
+          # @param source [String] the row's source
+          # @return [String] `domain` for a command or query source, else `website`
+          def origin(source) = source.match?(RowBuilder::DERIVED_SOURCE) ? "domain" : "website"
+
+          # Fills every field a row may leave undeclared, in the order each depends on the last.
+          #
+          # @param row [Row] the row, with its kind, auth, origin and source set
+          # @return [void]
+          def fill(row)
+            fill_flags(row)
+            fill_lists(row)
+            row.cache ||= default_cache(row)
+            row.indexable = indexable_by_default?(row) if row.indexable.nil?
+            fill_slots(row)
+          end
+
+          def fill_flags(row)
+            row.off = false if row.off.nil?
+            row.compress = true if row.compress.nil?
+            row.cdn = true if row.cdn.nil?
+            row.render ||= row.kind == "page" ? "prerender" : "ssr"
+          end
+
+          def fill_lists(row)
+            row.verbs = list(row.verbs || (row.source.start_with?("command:") ? "POST" : "GET"))
+            row.edge_verbs = row.edge_verbs.nil? ? row.verbs : list(row.edge_verbs)
+            row.aliases = list(row.aliases)
+          end
+
+          def fill_slots(row)
+            row.preview ||= "public"
+            row.switch ||= ""
+            row.footer_order ||= 0 if row.footer_column
+            row.admin_order ||= 0 if row.admin_key
+          end
+
+          def list(text) = text.to_s.split(",").map(&:strip).reject(&:empty?)
+
+          def default_cache(row)
+            return "no_store" if row.auth != "public" || row.kind == "endpoint"
+
+            row.origin == "assets" ? "immutable" : "page"
+          end
+
+          def indexable_by_default?(row) = row.kind == "page" && row.auth == "public" && !row.off
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/table.rb

@@ -43,7 +43,7 @@ module Hecks
           return holders.first if holders.one?
 
           raise Invalid, "#{holders.size} chapters declare a value_object \"#{ROW_OBJECT}\": " \
-                         "#{holders.map(&:name).join(', ')}; a project has one route table"
+                         "#{holders.map(&:name).join(", ")}; a project has one route table"
         end
 
         # Reads and checks one chapter's route table.
@@ -88,16 +88,20 @@ module Hecks
         # @raise [Invalid] when a row is refused
         def initialize(members, vocabulary:, registry: nil, links: [])
           problems = []
-          builder = RowBuilder.new(vocabulary: vocabulary, registry: registry, problems: problems)
-          @rows = members.each_with_index.map { |member, index| builder.call(member, index) }
-          link_builder = LinkBuilder.new(@rows, problems)
-          @links = links.each_with_index.map { |member, index| link_builder.call(member, index) }
+          @rows = build_all(members, RowBuilder.new(vocabulary: vocabulary, registry: registry, problems: problems))
+          @links = build_all(links, LinkBuilder.new(@rows, problems))
           Checks.new(@rows, problems, links: @links).call
           return if problems.empty?
 
           raise Invalid, "the route table is refused:\n#{problems.map { |line| "  - #{line}" }.join("\n")}"
         end
 
+        # @param members [Array<Hash{Symbol => Object}>] declared rows or links
+        # @param builder [#call] a `RowBuilder` or `LinkBuilder`
+        # @return [Array<Row, Link>] what the builder makes of each, in order
+        def build_all(members, builder) = members.each_with_index.map { |member, index| builder.call(member, index) }
+        private :build_all
+
         # The navigation slots a row or link sits in.
         #
         # @param row [Row, Link] a row or link

data/lib/hecks/projections/vocabulary.rb

@@ -25,6 +25,39 @@ module Hecks
         # be the table the framework loads with.
       RUBY
 
+      # The generated file, with `@@ROWS@@` standing for the table entries.
+      TEMPLATE = <<~RUBY.freeze
+        #{HEADER}
+        module Hecks
+          module Vocabulary
+            TABLES = {
+        @@ROWS@@
+            }.freeze
+
+            # The terms — the first field of each row, which for a
+            # one-field vocabulary is the whole of it. Derived once and
+            # frozen rather than mapped per call: these are constant
+            # tables, and a constant that allocates a new array every
+            # time it is read is not one.
+            TERMS = TABLES.transform_values { |rows| rows.map { |row| row.values.first }.freeze }.freeze
+
+            module_function
+
+            # Refuses an unknown name rather than answering nil: a set
+            # the language does not declare is a typo, not an empty set.
+            def fetch(name) = TERMS.fetch(name)
+
+            # The rows whole, for the vocabularies that carry more than
+            # a term — Comparison's own algebra, RefusalTemplate's text.
+            def rows(name) = TABLES.fetch(name)
+
+            def symbols(name) = fetch(name).map(&:to_sym)
+
+            def names = TABLES.keys
+          end
+        end
+      RUBY
+
       module_function
 
       # The projector protocol; `options` is unused.
@@ -62,37 +95,7 @@ module Hecks
           "      #{name.inspect} => [\n#{members.map { |row| "        #{row.inspect}.freeze" }.join(",\n")}\n      ].freeze"
         end
 
-        <<~RUBY
-          #{HEADER}
-          module Hecks
-            module Vocabulary
-              TABLES = {
-          #{rows.join(",\n")}
-              }.freeze
-
-              # The terms — the first field of each row, which for a
-              # one-field vocabulary is the whole of it. Derived once and
-              # frozen rather than mapped per call: these are constant
-              # tables, and a constant that allocates a new array every
-              # time it is read is not one.
-              TERMS = TABLES.transform_values { |rows| rows.map { |row| row.values.first }.freeze }.freeze
-
-              module_function
-
-              # Refuses an unknown name rather than answering nil: a set
-              # the language does not declare is a typo, not an empty set.
-              def fetch(name) = TERMS.fetch(name)
-
-              # The rows whole, for the vocabularies that carry more than
-              # a term — Comparison's own algebra, RefusalTemplate's text.
-              def rows(name) = TABLES.fetch(name)
-
-              def symbols(name) = fetch(name).map(&:to_sym)
-
-              def names = TABLES.keys
-            end
-          end
-        RUBY
+        TEMPLATE.sub("@@ROWS@@") { rows.join(",\n") }
       end
     end
   end

data/lib/hecks/projector/cli_audience.rb

@@ -0,0 +1,42 @@
+module Hecks
+  module Projector
+    # What a launcher's help leaves out and points at for whoever typed the line: the aggregates
+    # only a maintainer of a hecks checkout runs, and the attached chapters worth a line each.
+    # `CliProjector` renders the help; the runner decides the audience (`Doors::LauncherOptions`).
+    module CliAudience
+      module_function
+
+      # The specs whose aggregate the audience does not run.
+      def without_hidden(specs, hide)
+        hidden = Array(hide)
+        hidden.empty? ? specs : specs.reject { |_, spec| hidden.include?(spec[:group]) }
+      end
+
+      # The attached chapters the help points at, one line each, under the call that opens them.
+      #
+      # @param chapters [Array<Array(String, String)>, nil] each chapter's word and its summary
+      def chapter_lines(program, chapters)
+        return [] if Array(chapters).empty?
+
+        width = chapters.map { |word, _| word.length }.max
+        ["", "chapters (`#{program} <chapter>` lists a chapter's own commands and queries):",
+         *chapters.map { |word, summary| "  #{word.ljust(width)}  #{clipped(summary)}".rstrip }]
+      end
+
+      # A summary cut to one terminal line, at a word, with an ellipsis where it was cut.
+      def clipped(text, limit = 96)
+        return text if text.length <= limit
+
+        "#{text[0, limit].sub(/\s+\S*\z/, "")}…"
+      end
+
+      # The line saying the commands for working on hecks itself were left out and how to list
+      # them, or no line when none were.
+      def maintainer_hint(program, count)
+        return [] unless count.positive?
+
+        ["  #{program} --maintainer           also list the #{count} commands and queries for working on hecks itself"]
+      end
+    end
+  end
+end