hecks 3.4.1 → 3.5.0

data/lib/hecks/projections/site/payload/specs.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hecks
+  module Projections
+    module Site
+      module Payload
+        # The TypeScript the content system drives each aggregate with: its input type, how an input
+        # goes over the wire, how the host's state reads back into one, and the lifecycle the domain
+        # allows. The decisions that turn these into commands are in the lifecycle module, which the
+        # specs only describe.
+        module Specs
+          BANNER = "// Generated by hecks site site_projection.project_site. Do not edit."
+
+          module_function
+
+          # @param aggregates [Array<Model::Aggregate>] the aggregates to drive
+          # @param lifecycle [String] the import path of the lifecycle module
+          # @param hecks [String] the import path of the module that talks to the host
+          # @return [String] the module
+          def render(aggregates, lifecycle:, hecks:)
+            body = aggregates.map { |agg| aggregate(agg) }.join("\n\n")
+            [BANNER, header(aggregates, lifecycle, hecks), helpers(aggregates), body].reject(&:empty?).join("\n\n") << "\n"
+          end
+
+          def header(aggregates, lifecycle, hecks)
+            imports = %w[instancesOf] + (uses?(aggregates, :integer) ? %w[whole] : [])
+            names = %w[optionalValue statusOf unwrap unwrapList wrapped] + %w[type\ Instance type\ Spec type\ Wire]
+            <<~TS.chomp
+              import { #{imports.join(', ')} } from #{hecks.to_json};
+              import { #{names.join(', ')} } from #{lifecycle.to_json};
+            TS
+          end
+
+          def helpers(aggregates)
+            <<~TS.chomp
+              const list = (items: string[]) => items.map(wrapped);
+              const orNull = (value: unknown) => unwrap(value);#{composite_reader(aggregates)}
+            TS
+          end
+
+          def composite_reader(aggregates)
+            return "" unless uses?(aggregates, :composite)
+
+            <<~TS.chomp.prepend("\n")
+              const text = (value: unknown) => (typeof value === "string" ? value : "");
+            TS
+          end
+
+          def uses?(aggregates, shape) = aggregates.any? { |agg| agg.attrs.any? { |attr| attr.shape == shape } }
+
+          def aggregate(agg)
+            [heading(agg), composites(agg), input_type(agg), state_type(agg), composite_readers(agg), spec(agg)]
+              .reject(&:empty?).join("\n\n")
+          end
+
+          def heading(agg) = "// ---- #{agg.noun} ----"
+
+          def composites(agg)
+            agg.attrs.select { |attr| attr.shape == :composite }.map do |attr|
+              fields = attr.parts.map { |part| "  #{part.ts}: string;" }.join("\n")
+              "export interface #{attr.type} {\n#{fields}\n}"
+            end.join("\n\n")
+          end
+
+          def input_type(agg)
+            fields = agg.attrs.map { |attr| "  #{attr.ts}: #{ts_type(attr)};" }.join("\n")
+            "export interface #{agg.noun}Input {\n#{fields}\n}"
+          end
+
+          def state_type(agg) = "export type #{agg.noun}State = #{agg.noun}Input & Instance;"
+
+          def ts_type(attr)
+            base = if attr.shape == :integer
+                     "number"
+                   else
+                     (attr.shape == :composite ? attr.type : "string")
+                   end
+            return "#{base}[]" if attr.list
+
+            attr.optional ? "#{base} | null" : base
+          end
+
+          def composite_readers(agg)
+            agg.attrs.select { |attr| attr.shape == :composite }.map do |attr|
+              parts = attr.parts.map { |part| "#{part.ts}: text(s.#{part.name})" }.join(", ")
+              <<~TS.chomp
+                const #{reader(agg, attr)} = (value: unknown): #{attr.type}[] =>
+                  Array.isArray(value) ? value.map((raw) => { const s = (raw ?? {}) as Record<string, unknown>; return { #{parts} }; }) : [];
+              TS
+            end.join("\n\n")
+          end
+
+          def reader(agg, attr) = "#{agg.noun[0].downcase}#{agg.noun[1..]}#{attr.ts[0].upcase}#{attr.ts[1..]}From"
+
+          def spec(agg)
+            var = "#{agg.noun[0].downcase}#{agg.noun[1..]}"
+            <<~TS.chomp
+              export const #{var}Spec: Spec<#{agg.noun}State, #{agg.noun}Input> = {
+                aggregate: #{agg.fqn.to_json},
+                read: (answer) =>
+                  instancesOf(answer, #{agg.fqn.to_json}).map(([#{agg.identity}, s]) => ({
+                    #{agg.identity},
+                    status: statusOf(s),
+              #{reads(agg)}
+                  })),
+                toInput: ({ status: _status, ...input }) => input,
+                fields: (input): Wire => ({
+              #{writes(agg)}
+                }),
+                create: { verb: #{agg.create[:verb].to_json}, status: #{agg.create[:status].to_json} },
+                edges: #{edges(agg.edges)},
+              };
+            TS
+          end
+
+          def others(agg) = agg.attrs.reject { |attr| attr.name == agg.identity }
+
+          def reads(agg)
+            others(agg).map { |attr| "      #{attr.ts}: #{read(agg, attr)}," }.join("\n")
+          end
+
+          def read(agg, attr)
+            return "#{reader(agg, attr)}(s.#{attr.name})" if attr.shape == :composite
+            return "unwrapList(s.#{attr.name})" if attr.list
+            return "whole(s.#{attr.name}, #{attr.wire_key.to_json})" if attr.shape == :integer
+
+            attr.optional ? "orNull(s.#{attr.name})" : "orNull(s.#{attr.name}) ?? \"\""
+          end
+
+          def writes(agg)
+            others(agg).map { |attr| "    #{write(attr)}," }.join("\n")
+          end
+
+          def write(attr)
+            name = attr.name
+            case attr.shape
+            when :composite then composite_write(attr)
+            when :integer then optional_write(attr, "{ #{attr.wire_key}: input.#{attr.ts} }", "input.#{attr.ts} != null")
+            else
+              return "#{name}: list(input.#{attr.ts})" if attr.list
+
+              scalar_write(attr)
+            end
+          end
+
+          def composite_write(attr)
+            parts = attr.parts.map { |part| "#{part.name}: item.#{part.ts}" }.join(", ")
+            "#{attr.name}: input.#{attr.ts}.map((item) => ({ #{parts} }))"
+          end
+
+          def scalar_write(attr)
+            if attr.wire_key == "value"
+              return "#{attr.name}: wrapped(input.#{attr.ts})" unless attr.optional
+
+              return "...optionalValue(#{attr.name.to_json}, input.#{attr.ts})"
+            end
+            optional_write(attr, "{ #{attr.wire_key}: input.#{attr.ts} }", "input.#{attr.ts}")
+          end
+
+          def optional_write(attr, wire, present)
+            return "#{attr.name}: #{wire}" unless attr.optional
+
+            "...(#{present} ? { #{attr.name}: #{wire} } : {})"
+          end
+
+          def edges(edges)
+            rows = edges.map do |status, moves|
+              inner = moves.map { |verb, target| "#{verb}: #{target.to_json}" }.join(", ")
+              "    #{status}: { #{inner} },"
+            end
+            "{\n#{rows.join("\n")}\n  }"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../../projector"
+require_relative "root_rows"
+require_relative "payload/model"
+require_relative "payload/specs"
+require_relative "payload/fields"
+require_relative "payload/lifecycle"
+
+module Hecks
+  module Projections
+    module Site
+      # What the content system needs to drive a domain's aggregates, from the domain itself: the
+      # lifecycle module, a spec per aggregate (its input, its wire form, its lifecycle edges and
+      # the
+      # command that creates it) and the Payload field definitions with the readers that turn a
+      # saved
+      # document back into an input.
+      #
+      # A `Payload` row names the domain, its chapter and where the files go; `PayloadField` rows
+      # say what
+      # the editor needs that an attribute's shape cannot (a date picker, a choice list, an upload,
+      # a
+      # relation). The domain stays free of the content system: it is read, never annotated.
+      module PayloadDriver
+        extend Projector::Target
+
+        projects_as :payload_driver, emits: :files
+
+        # The `Payload` row.
+        PAYLOAD = RootRows.new("Payload",
+                               fields:   { domain: String, chapter: String, out: String, hecks: String, helpers: String,
+skip: String },
+                               required: %i[domain chapter],
+                               defaults: { out: "cms/src/generated", hecks: "cms/src/driver/hecks",
+                                           helpers: "cms/src/collections/hooks/content", skip: "" })
+
+        # A `PayloadField` row: what the editor needs for one attribute (or `attribute.part` of a
+        # composite).
+        FIELD = RootRows.new("PayloadField",
+                             fields: { aggregate: String, attribute: String, field: String, kind: String, options: String,
+                                       relation: String, via: String, label: String, description: String,
+                                       required: [TrueClass, FalseClass],
+                                       default: String },
+                             required: %i[aggregate attribute], many: true)
+
+        module_function
+
+        # @param bluebook [Bluebook::Chapter] the chapter that declares the route table and the rows
+        # @param options [Hash{Symbol => Object}] `:domain_chapter` the domain's chapter, or nil
+        # @return [Hash{String => String}] each file's path relative to the project root to its
+        #   text;
+        #   empty when the project declares no `Payload` row
+        # @raise [Table::Invalid] when a row is refused
+        # @raise [ArgumentError] when an aggregate cannot be driven or a row names what is not there
+        def call(bluebook:, options: {})
+          row = PAYLOAD.read(bluebook).first
+          return {} unless row
+
+          chapter = options.fetch(:domain_chapter)
+          aggregates = Payload::Model.read(chapter, skip: row[:skip].split(",").map(&:strip))
+          raise ArgumentError, "the #{chapter.name} chapter has no aggregate with a lifecycle to drive" if aggregates.empty?
+
+          files(row, aggregates, FIELD.read(bluebook))
+        end
+
+        def files(row, aggregates, rows)
+          out = row[:out]
+          roles = aggregates.map(&:role).uniq
+          if roles.size > 1
+            raise ArgumentError,
+                  "the driven aggregates' commands declare roles #{roles.inspect}; the driver acts as one"
+          end
+
+          from_driver = ->(path) { relative(path, "#{out}/driver") }
+          from_collections = ->(path) { relative(path, "#{out}/collections") }
+          { "#{out}/driver/lifecycle.ts"   => Payload::Lifecycle.render(role: roles.first, hecks: from_driver.call(row[:hecks])),
+            "#{out}/driver/specs.ts"       => Payload::Specs.render(aggregates, lifecycle: "./lifecycle",
+                                                                                hecks:     from_driver.call(row[:hecks])),
+            "#{out}/collections/fields.ts" => Payload::Fields.render(aggregates, rows: rows, specs: "../driver/specs",
+                                                                     helpers: from_collections.call(row[:helpers])) }
+        end
+
+        # @return [String] `path` as an import from `dir`, both relative to the project root
+        def relative(path, dir)
+          target = Pathname.new(path).relative_path_from(Pathname.new(dir)).to_s
+          target.start_with?(".") ? target : "./#{target}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "table"
+
+module Hecks
+  module Projections
+    module Site
+      # Reads and checks the rows a project declares beside its route table for the files at the
+      # project's root, one row object at a time: the fields it may carry, the Ruby class each
+      # takes, which are required and what the others default to.
+      #
+      # A row that is refused raises `Table::Invalid` naming every problem, so a project sees all of
+      # them at once.
+      class RootRows
+        # @param object [String] the value object the rows are declared in
+        # @param fields [Hash{Symbol => Class, Array<Class>}] the fields a row may carry, by class
+        # @param required [Array<Symbol>] the fields a row must carry
+        # @param defaults [Hash{Symbol => Object}] what a field takes when the row omits it
+        # @param many [Boolean] whether the project may declare more than one row
+        def initialize(object, fields:, required: [], defaults: {}, many: false)
+          @object = object
+          @fields = fields
+          @required = required
+          @defaults = defaults
+          @many = many
+        end
+
+        # @param chapter [Bluebook::Chapter] the chapter that declares the route table
+        # @return [Array<Hash{Symbol => Object}>] each checked row, defaults filled; empty when the
+        #   chapter declares none
+        # @raise [Table::Invalid] when a row is refused
+        def read(chapter)
+          members = Table.rows_of(chapter, @object)
+          problems = []
+          problems << "a project declares one #{@object} row, not #{members.size}" if members.size > 1 && !@many
+          rows = members.each_with_index.map { |member, index| check(member, index, problems) }
+          return rows if problems.empty?
+
+          raise Table::Invalid, "the #{@object} rows are refused:\n#{problems.map { |line| "  - #{line}" }.join("\n")}"
+        end
+
+        private
+
+        def check(member, index, problems)
+          label = "#{@object} row #{index + 1}"
+          unknown = member.keys - @fields.keys
+          problems << "#{label} has no field #{unknown.join(', ')}; fields are #{@fields.keys.join(', ')}" if unknown.any?
+          (@required - member.keys).each { |field| problems << "#{label} needs #{field}" }
+          typed = member.slice(*@fields.keys).select do |field, value|
+            kinds = Array(@fields.fetch(field))
+            kinds.any? { |kind| value.is_a?(kind) } ||
+              (problems << "#{label} has #{field} #{value.inspect}; it is a #{kinds.join(' or ')}")
+          end
+          @defaults.merge(typed)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../projector"
+require_relative "admin"
+require_relative "routes_ts"
+
+module Hecks
+  module Projections
+    module Site
+      # A site's admin sign-in as one dependency-free TypeScript module, `admin.ts`.
+      #
+      # The module is what a site's middleware and pages need to ask the domain host who is signed
+      # in and whether that person may use the admin pages: the session cookie's settings, a check
+      # that the host's membership list holds the person as an admin, a gate that decides a path
+      # from the route table's `auth` column, and the hand-off to the content system. It imports the
+      # route table module beside it and nothing else, so it loads under Node and any bundler.
+      #
+      # The text is a pure function of the `Admin` row and the extension: nothing in it names a
+      # time or a machine, so regenerating from the same row changes nothing.
+      module SiteAdmin
+        extend Projector::Target
+
+        projects_as :site_admin, emits: :files
+
+        module_function
+
+        # Renders `admin.ts` for a project that declares an admin row.
+        #
+        # @param bluebook [Bluebook::Chapter] the chapter that declares the route table
+        # @param options [Hash{Symbol => Object}] `:admin` (Admin) the checked admin row, or nil;
+        #   `:extension` (String) the extension the routes module is written with, `ts` by default
+        # @return [Hash{String => String}] `"admin.ts"` to its text; empty with no admin row
+        def call(bluebook:, options: {})
+          admin = options[:admin]
+          return {} if admin.nil?
+
+          { "admin.ts" => render(admin, options.fetch(:extension, "ts")) }
+        end
+
+        # @param admin [Admin] a checked admin row
+        # @param extension [String] the extension of the route table module
+        # @return [String] the module's text, ending in a newline
+        def render(admin, extension)
+          [RoutesTs::BANNER, header, imports(extension), settings(admin), memo, helpers].join("\n\n") << "\n"
+        end
+
+        def header
+          <<~TS.chomp
+            // The admin sign-in of this site, projected from its bluebook's Admin row and Route rows. Change the
+            // rows and run `hecks site site_projection.project_site`; with `--check` it fails when this file is out of date.
+          TS
+        end
+
+        def imports(extension)
+          %(import { MIDDLEWARE, ROUTES, matchesPath } from "./routes.#{extension}";)
+        end
+
+        def settings(admin)
+          setting = admin.setting
+          fields = {
+            sessionCookie: setting.session_cookie, sessionMaxAge: setting.session_max_age,
+            hostEnv: setting.host_env, hostDefault: setting.host_default, roles: admin.roles,
+            accountPath: setting.account_path, membersPath: setting.members_path,
+            ssoTokenPath: setting.sso_token_path, ssoTarget: setting.sso_target, login: setting.login,
+            sso: setting.sso, verdictTtlMs: setting.verdict_ttl_ms, timeoutMs: setting.timeout_ms
+          }
+          body = fields.map { |key, value| "  #{key}: #{RoutesTs.literal(value)}," }
+          "/** What the sign-in is built from: the project's Admin row, defaults filled. */\n" \
+            "export const ADMIN = {\n#{body.join("\n")}\n} as const;"
+        end
+
+        def memo
+          <<~TS.chomp
+            const MAX_REMEMBERED = 500;
+
+            /** Remembers each key's answer for the verdict TTL; callers that arrive while it loads share it, and a failure is never kept. */
+            function remember<V>(load: (key: string) => Promise<V>) {
+              const values = new Map<string, { at: number; value: V }>();
+              const running = new Map<string, Promise<V>>();
+              return {
+                get(key: string): Promise<V> {
+                  const hit = values.get(key);
+                  if (hit && Date.now() - hit.at < ADMIN.verdictTtlMs) return Promise.resolve(hit.value);
+                  const shared = running.get(key);
+                  if (shared) return shared;
+                  const started: Promise<V> = load(key)
+                    .then((value) => {
+                      if (running.get(key) === started) {
+                        values.delete(key);
+                        values.set(key, { at: Date.now(), value });
+                        if (values.size > MAX_REMEMBERED) values.delete(values.keys().next().value as string);
+                      }
+                      return value;
+                    })
+                    .finally(() => {
+                      if (running.get(key) === started) running.delete(key);
+                    });
+                  running.set(key, started);
+                  return started;
+                },
+                forget(): void {
+                  values.clear();
+                  running.clear();
+                },
+              };
+            }
+          TS
+        end
+
+        def helpers
+          [configuration, membership, sessions, verdicts, handoff, routing, gate].join("\n\n")
+        end
+
+        def configuration
+          <<~'TS'.chomp
+            export interface AdminSettings {
+              /** The domain host's address, when not read from the environment variable the Admin row names. */
+              host?: string;
+              /** The fetch to use, for tests. */
+              fetch?: typeof fetch;
+            }
+
+            let settings: AdminSettings = {};
+
+            /** Sets the host or the fetch, and forgets every remembered verdict. */
+            export function configureAdmin(next: AdminSettings): void {
+              settings = next;
+              forgetAdminSessions();
+            }
+
+            function hostUrl(): string {
+              const named = settings.host ?? (typeof process !== "undefined" ? process.env[ADMIN.hostEnv] : undefined);
+              return (named || ADMIN.hostDefault).replace(/\/+$/, "");
+            }
+
+            function askHost(path: string, cookieValue: string): Promise<Response> {
+              return (settings.fetch ?? fetch)(`${hostUrl()}${path}`, {
+                headers: { Cookie: `${ADMIN.sessionCookie}=${cookieValue}` },
+                signal: AbortSignal.timeout(ADMIN.timeoutMs),
+              });
+            }
+          TS
+        end
+
+        def membership
+          <<~TS.chomp
+            export interface MemberRow {
+              email?: unknown;
+              role?: unknown;
+              disabled?: unknown;
+            }
+
+            /** True when `email` (any case) is a member holding one of the admin roles and not disabled. */
+            export function isActiveAdmin(members: MemberRow[], email: string): boolean {
+              const wanted = email.trim().toLowerCase();
+              return members.some(
+                (member) =>
+                  typeof member.email === "string" &&
+                  member.email.trim().toLowerCase() === wanted &&
+                  (ADMIN.roles as readonly unknown[]).includes(member.role) &&
+                  member.disabled !== true,
+              );
+            }
+          TS
+        end
+
+        def sessions
+          <<~TS.chomp
+            /** A signed-in admin and the membership list that vouched for them. */
+            export interface AdminSession {
+              email: string;
+              members: unknown[];
+            }
+
+            async function fetchAccountEmail(cookieValue: string): Promise<string | null> {
+              const res = await askHost(ADMIN.accountPath, cookieValue);
+              if (!res.ok) return null;
+              const data = await res.json();
+              return typeof data.email === "string" ? data.email : null;
+            }
+
+            async function fetchAdminSession(cookieValue: string): Promise<AdminSession | null> {
+              const [email, membersRes] = await Promise.all([
+                fetchAccountEmail(cookieValue),
+                askHost(ADMIN.membersPath, cookieValue),
+              ]);
+              if (!email || !membersRes.ok) return null;
+              const members = await membersRes.json();
+              return Array.isArray(members) && isActiveAdmin(members, email) ? { email, members } : null;
+            }
+          TS
+        end
+
+        def verdicts
+          <<~TS.chomp
+            const accountEmails = remember(fetchAccountEmail);
+            const adminSessions = remember(fetchAdminSession);
+
+            /** Drops every remembered verdict, for after this process changes a member. */
+            export function forgetAdminSessions(): void {
+              accountEmails.forget();
+              adminSessions.forget();
+            }
+
+            /** The signed-in person's email, or null when the cookie is absent or the host does not know it. */
+            export async function currentAccountEmail(cookieValue: string | undefined): Promise<string | null> {
+              return cookieValue ? accountEmails.get(cookieValue) : null;
+            }
+
+            /** The signed-in person and the membership list when they hold an admin role, else null. */
+            export async function currentAdminSession(cookieValue: string | undefined): Promise<AdminSession | null> {
+              return cookieValue ? adminSessions.get(cookieValue) : null;
+            }
+
+            /** The signed-in person's email when they may use the admin pages, else null. */
+            export async function currentAdminEmail(cookieValue: string | undefined): Promise<string | null> {
+              return (await currentAdminSession(cookieValue))?.email ?? null;
+            }
+          TS
+        end
+
+        def handoff
+          <<~TS.chomp
+            /**
+             * Where the hand-off to the CMS sends a person: the CMS's own sign-in endpoint with a short-lived
+             * token from the host, or the login page when there is no session or the host refuses the token.
+             * `to` is a path inside the CMS to open once signed in; the CMS checks it.
+             */
+            export async function ssoRedirect(cookieValue: string | undefined, to?: string | null): Promise<string> {
+              if (!cookieValue) return ADMIN.login;
+              const res = await askHost(ADMIN.ssoTokenPath, cookieValue);
+              if (!res.ok) return ADMIN.login;
+              const { token } = await res.json();
+              const params = new URLSearchParams({ token });
+              if (to) params.set("to", to);
+              return `${ADMIN.ssoTarget}?${params}`;
+            }
+          TS
+        end
+
+        def routing
+          <<~'TS'.chomp
+            /**
+             * How specific a route pattern is: the characters that are not a wildcard or a `:name` parameter,
+             * so `/admin-login` outranks `/admin*` and `/admin.html` outranks `/:slug.html`.
+             */
+            function specificity(pattern: string): number {
+              return pattern.replace(/:[A-Za-z_]\w*/g, "").replace(/\*/g, "").length;
+            }
+
+            /**
+             * The route that describes a path: the most specific match. Between routes equally specific the
+             * `admin` one wins, so a tie never lets a visitor through; after that, the first listed.
+             */
+            function routeFor(pathname: string): (typeof ROUTES)[number] | undefined {
+              let best: (typeof ROUTES)[number] | undefined;
+              for (const candidate of ROUTES) {
+                if (!matchesPath(candidate.path, pathname)) continue;
+                if (best === undefined) {
+                  best = candidate;
+                  continue;
+                }
+                const more = specificity(candidate.path) - specificity(best.path);
+                if (more > 0 || (more === 0 && candidate.auth === "admin" && best.auth !== "admin")) best = candidate;
+              }
+              return best;
+            }
+          TS
+        end
+
+        def gate
+          <<~TS.chomp
+            export type AdminGate = { allow: true } | { allow: false; status: 401 } | { allow: false; redirect: string };
+
+            /**
+             * Whether a request may go on. The most specific route that matches the path decides (see `routeFor`): an `admin`
+             * route, or any path under the draft-preview prefix, needs an admin session. A preview without
+             * one is refused with 401 and nothing else; any other admin path is sent to the login page.
+             */
+            export async function adminGate(pathname: string, cookieValue: string | undefined): Promise<AdminGate> {
+              const previewing = pathname.startsWith(MIDDLEWARE.preview.prefix + "/");
+              if (routeFor(pathname)?.auth !== "admin" && !previewing) return { allow: true };
+              if (await currentAdminEmail(cookieValue)) return { allow: true };
+              return previewing ? { allow: false, status: 401 } : { allow: false, redirect: ADMIN.login };
+            }
+          TS
+        end
+      end
+    end
+  end
+end