fetch_util 0.5.2 → 0.6.0

data/lib/fetch_util/browser/site_stabilization/gerrit_change_product_state_script.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritChangeProductStateScript
+        private
+
+        def gerrit_change_product_state_script
+          <<~'JS'
+            const stateKey = "__fetchUtilGerritChange";
+            const pathname = (location.pathname || "").replace(/\/+$/, "");
+            const marker = pathname.lastIndexOf('/+/');
+            if (marker < 1) return { matched: false };
+
+            const tail = pathname.slice(marker + 3).split("/").filter(Boolean);
+            if (tail.length < 1 || tail.length > 2 || !/^\d+$/.test(tail[0]) ||
+                (tail[1] && !/^\d+$/.test(tail[1]))) return { matched: false };
+
+            const beforeMarker = pathname.slice(0, marker);
+            const baseNode = document.querySelector("base[href]");
+            let prefix = "";
+            if (baseNode) {
+              try {
+                const baseUrl = new URL(baseNode.getAttribute("href"), location.href);
+                if (baseUrl.origin === location.origin) prefix = baseUrl.pathname.replace(/\/+$/, "");
+              } catch (_error) { prefix = ""; }
+            }
+
+            let projectPath = beforeMarker;
+            if (projectPath.indexOf("/c/") === 0) {
+              projectPath = projectPath.slice(3);
+            } else {
+              const cMarker = projectPath.indexOf("/c/");
+              if (cMarker >= 0) {
+                prefix = projectPath.slice(0, cMarker);
+                projectPath = projectPath.slice(cMarker + 3);
+              } else {
+                if (prefix && projectPath.indexOf(prefix + "/") === 0) projectPath = projectPath.slice(prefix.length);
+                projectPath = projectPath.replace(/^\/+/, "");
+              }
+            }
+
+            try { projectPath = decodeURIComponent(projectPath); }
+            catch (_error) { return { matched: false }; }
+            if (!projectPath || projectPath.split("/").some((part) => !part || part === "." || part === "..")) {
+              return { matched: false };
+            }
+
+            const description = document.querySelector('meta[name="description"]');
+            const descriptionMatch = /^Gerrit Code Review$/i.test((description && description.content || "").trim());
+            const appMatch = !!document.querySelector("gr-app");
+            const footerMatch = Array.from(document.querySelectorAll("footer, [role='contentinfo']")).some(
+              (node) => /Powered by Gerrit Code Review/i.test((node.textContent || "").trim())
+            );
+            const assetMatch = Array.from(document.querySelectorAll("script[src], link[href]")).some((node) => {
+              const value = node.getAttribute("src") || node.getAttribute("href") || "";
+              if (!/\/polygerrit_ui\/.*\/gr-app\.js(?:$|[?#])/i.test(value)) return false;
+              try { return new URL(value, location.href).origin === location.origin; } catch (_error) { return false; }
+            });
+            const preloadMatch = Array.from(document.querySelectorAll("link[href]")).some((node) => {
+              const value = node.getAttribute("href") || "";
+              if (!/\/changes\/[^/?]+\/(?:detail|comments)(?:$|[?])/i.test(value)) return false;
+              try { return new URL(value, location.href).origin === location.origin; } catch (_error) { return false; }
+            });
+            const product = descriptionMatch && appMatch && (footerMatch || assetMatch || preloadMatch);
+            if (!product) return { matched: true, product: false };
+
+            const number = tail[0];
+            const patchset = tail[1] || null;
+            const changePath = beforeMarker + "/+/" + number;
+            const apiPath = (prefix || "") + "/changes/" + encodeURIComponent(projectPath + "~" + number);
+            const routeKey = [location.origin, changePath, patchset || ""].join(":");
+            const existing = window[stateKey];
+            if (existing && existing.routeKey === routeKey) {
+              return {
+                matched: true,
+                product: true,
+                status: existing.status || "",
+                signature: [existing.status, existing.messageCount || 0, existing.commentCount || 0,
+                  existing.fileCount || 0].join(":")
+              };
+            }
+
+            const route = {
+              project: projectPath,
+              number: number,
+              patchset: patchset,
+              changePath: changePath,
+              apiPath: apiPath
+            };
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_change_request_state_script.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritChangeRequestStateScript
+        private
+
+        def gerrit_change_request_state_script
+          <<~'JS'
+            const prepared = { status: "loading", product: true, routeKey: routeKey, route: route };
+            window[stateKey] = prepared;
+
+            const requestJson = async (suffix) => {
+              const url = new URL(apiPath + suffix, location.origin);
+              if (url.origin !== location.origin) throw new Error("cross-origin Gerrit API route");
+              const response = await fetch(url.href, {
+                credentials: "same-origin",
+                headers: { Accept: "application/json" }
+              });
+              if (!response.ok) throw new Error("Gerrit API returned " + response.status);
+              const text = await response.text();
+              const value = JSON.parse(text.replace(/^\)\]\}'(?:\r?\n)?/, ""));
+              if (!value || typeof value !== "object" || Array.isArray(value)) {
+                throw new Error("invalid Gerrit API payload");
+              }
+              return value;
+            };
+            const selectedRevision = route.patchset || "current";
+            Promise.all([
+              requestJson("/detail?o=ALL_REVISIONS&o=ALL_COMMITS&o=DETAILED_LABELS&o=DETAILED_ACCOUNTS&o=MESSAGES"),
+              requestJson("/comments?enable-context=true&context-padding=3"),
+              requestJson("/revisions/" + encodeURIComponent(selectedRevision) + "/files/")
+            ]).then(([detail, comments, files]) => {
+              if (window[stateKey] !== prepared || prepared.status !== "loading") return;
+              if (String(detail._number || "") !== number || !detail.project || detail.project !== projectPath) {
+                throw new Error("Gerrit API change identity mismatch");
+              }
+              const selectedExists = !route.patchset || Object.values(detail.revisions || {}).some(
+                (revision) => String(revision && revision._number || "") === route.patchset
+              );
+              if (!selectedExists) throw new Error("Gerrit API patch set identity mismatch");
+              const countComments = (collection) => Object.keys(collection || {}).reduce(
+                (total, path) => total + (Array.isArray(collection[path]) ? collection[path].length : 0), 0
+              );
+              window[stateKey] = {
+                status: "ready",
+                product: true,
+                routeKey: routeKey,
+                route: route,
+                detail: detail,
+                comments: comments,
+                files: files,
+                messageCount: Array.isArray(detail.messages) ? detail.messages.length : 0,
+                commentCount: countComments(comments),
+                fileCount: Object.keys(files).length
+              };
+            }).catch((error) => {
+              if (window[stateKey] !== prepared || prepared.status !== "loading") return;
+              window[stateKey] = {
+                status: "failed",
+                product: true,
+                routeKey: routeKey,
+                route: route,
+                reason: String(error && error.message || error || "Gerrit preparation failed")
+              };
+            });
+
+            return { matched: true, product: true, status: "loading", signature: "loading" };
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_change_stabilization.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritChangeStabilization
+        GERRIT_CHANGE_STABILIZATION_PROFILE = {
+          host: true,
+          path_query: ->(uri) { uri.path.match?(%r{/\+/\d+(?:/\d+)?/?\z}) },
+          strategy: :stabilize_gerrit_change,
+          fallthrough: true,
+          notes: "Prepare product-matched Gerrit change REST resources.",
+          tests: "spec/fetch_util/browser_stabilization_spec.rb"
+        }.freeze
+
+        private
+
+        def stabilize_gerrit_change(page, deadline: stabilization_deadline)
+          state = nil
+          ready = retry_until_timeout(
+            capped_timeout(10.0, deadline: deadline),
+            interval: 0.1,
+            deadline: deadline
+          ) do
+            state = gerrit_change_state(page)
+            return false if state.is_a?(Hash) && (state["product"] == false || state["status"] == "failed")
+
+            state.is_a?(Hash) && state["status"] == "ready"
+          end
+          fail_gerrit_change_preparation(page) if !ready && state.is_a?(Hash) && state["status"] == "loading"
+          settle_after_stabilization(0.25, deadline: deadline) if ready
+          ready
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_change_state.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritChangeState
+        include GerritChangeProductStateScript
+        include GerritChangeRequestStateScript
+
+        private
+
+        def gerrit_change_state(page)
+          safe_evaluate(page, gerrit_change_state_script, default: nil)
+        end
+
+        def fail_gerrit_change_preparation(page)
+          safe_evaluate(page, <<~'JS', default: false)
+            (() => {
+              const prepared = window.__fetchUtilGerritChange;
+              if (!prepared || prepared.status !== "loading") return false;
+              prepared.status = "failed";
+              prepared.reason = "Gerrit preparation timed out";
+              return true;
+            })()
+          JS
+        end
+
+        def gerrit_change_state_script
+          <<~JS
+            (() => {
+              #{gerrit_change_product_state_script}
+              #{gerrit_change_request_state_script}
+            })()
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_file_resource_fetch_state_script.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritFileResourceFetchStateScript
+        private
+
+        def gerrit_file_resource_fetch_state_script
+          <<~'JS'
+            const requestJson = async (suffix) => {
+              const url = new URL(apiPath + suffix, location.origin);
+              if (url.origin !== location.origin) throw new Error("cross-origin Gerrit API route");
+              const response = await fetch(url.href, {
+                credentials: "same-origin",
+                headers: { Accept: "application/json" }
+              });
+              if (!response.ok) throw new Error("Gerrit API returned " + response.status);
+              const text = await response.text();
+              const value = JSON.parse(text.replace(/^\)\]\}'(?:\r?\n)?/, ""));
+              if (!value || typeof value !== "object" || Array.isArray(value)) {
+                throw new Error("invalid Gerrit API payload");
+              }
+              return value;
+            };
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_file_resource_product_state_script.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritFileResourceProductStateScript
+        private
+
+        def gerrit_file_resource_product_state_script
+          gerrit_file_resource_route_state_script + <<~'JS'
+            const description = document.querySelector('meta[name="description"]');
+            const descriptionMatch = /^Gerrit Code Review$/i.test((description && description.content || "").trim());
+            const appMatch = !!document.querySelector("gr-app");
+            const footerMatch = Array.from(document.querySelectorAll("footer, [role='contentinfo']")).some(
+              (node) => /Powered by Gerrit Code Review/i.test((node.textContent || "").trim())
+            );
+            const assetMatch = Array.from(document.querySelectorAll("script[src], link[href]")).some((node) => {
+              const value = node.getAttribute("src") || node.getAttribute("href") || "";
+              if (!/\/polygerrit_ui\/.*\/gr-app\.js(?:$|[?#])/i.test(value)) return false;
+              try { return new URL(value, location.href).origin === location.origin; } catch (_error) { return false; }
+            });
+            const preloadMatch = Array.from(document.querySelectorAll("link[href]")).some((node) => {
+              const value = node.getAttribute("href") || "";
+              if (!/\/changes\/[^/?]+\/(?:detail|comments)(?:$|[?])/i.test(value)) return false;
+              try { return new URL(value, location.href).origin === location.origin; } catch (_error) { return false; }
+            });
+            const product = descriptionMatch && appMatch && (footerMatch || assetMatch || preloadMatch);
+            if (!product) return { matched: true, product: false };
+
+            let comparisonKind = "implicit";
+            let comparisonValue = null;
+            if (base != null) {
+              if (Number(base) > 0) {
+                comparisonKind = "patchset";
+                comparisonValue = base;
+              } else if (Number(base) < 0) {
+                comparisonKind = "parent";
+                comparisonValue = String(Math.abs(Number(base)));
+              } else {
+                comparisonKind = "auto_merge";
+              }
+            }
+
+            const changePath = beforeMarker + "/+/" + number;
+            const apiPath = (prefix || "") + "/changes/" + encodeURIComponent(projectPath + "~" + number);
+            const routeKey = [location.origin, changePath, selector, filePath].join(":");
+            const existing = window[stateKey];
+            if (existing && existing.routeKey === routeKey) {
+              return {
+                matched: true,
+                product: true,
+                status: existing.status || "",
+                signature: [existing.status, existing.fileCount || 0, existing.commentCount || 0,
+                  existing.diffBlockCount || 0, existing.firstParentDiffBlockCount || 0].join(":")
+              };
+            }
+
+            const route = {
+              project: projectPath,
+              number: number,
+              patchset: target,
+              selector: selector,
+              target: target,
+              base: base,
+              comparison: comparisonKind,
+              comparisonValue: comparisonValue,
+              filePath: filePath,
+              changePath: changePath,
+              apiPath: apiPath
+            };
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_file_resource_request_state_script.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritFileResourceRequestStateScript
+        private
+
+        def gerrit_file_resource_request_state_script
+          gerrit_file_resource_fetch_state_script + gerrit_file_resource_validation_state_script + <<~'JS'
+            const prepared = { status: "loading", product: true, routeKey: routeKey, route: route };
+            window[stateKey] = prepared;
+
+            const comparisonQuery = new URLSearchParams();
+            if (route.comparison === "patchset") comparisonQuery.set("base", route.comparisonValue);
+            if (route.comparison === "parent") comparisonQuery.set("parent", route.comparisonValue);
+            const query = comparisonQuery.toString();
+            const filesSuffix = "/revisions/" + encodeURIComponent(route.target) + "/files/" +
+              (query ? "?" + query : "");
+
+            Promise.all([
+              requestJson("/detail?o=ALL_REVISIONS&o=ALL_COMMITS&o=DETAILED_LABELS&o=DETAILED_ACCOUNTS&o=MESSAGES"),
+              requestJson("/comments?enable-context=true&context-padding=3"),
+              requestJson(filesSuffix)
+            ]).then(async ([detail, comments, files]) => {
+              if (window[stateKey] !== prepared || prepared.status !== "loading") return;
+              if (String(detail._number || "") !== route.number || detail.project !== route.project) {
+                throw new Error("Gerrit API change identity mismatch");
+              }
+              if (!objectRecord(detail.revisions)) throw new Error("invalid Gerrit revisions payload");
+              if (!Object.values(comments).every(
+                (records) => Array.isArray(records) && records.every(objectRecord)
+              )) throw new Error("invalid Gerrit comments payload");
+              if (!Object.values(files).every(objectRecord)) throw new Error("invalid Gerrit files payload");
+              const revisions = Object.values(detail.revisions || {});
+              const targetRevision = revisions.find(
+                (revision) => String(revision && revision._number || "") === route.target
+              );
+              if (!targetRevision) throw new Error("Gerrit API target patch set identity mismatch");
+              if (route.comparison === "patchset" && !revisions.some(
+                (revision) => String(revision && revision._number || "") === route.comparisonValue
+              )) throw new Error("Gerrit API base patch set identity mismatch");
+              if (route.comparison === "parent" &&
+                  (!targetRevision.commit || !Array.isArray(targetRevision.commit.parents) ||
+                    targetRevision.commit.parents.length < Number(route.comparisonValue))) {
+                throw new Error("Gerrit API parent identity mismatch");
+              }
+
+              let filePath = route.filePath;
+              if (!Object.prototype.hasOwnProperty.call(files, filePath)) {
+                filePath = Object.keys(files).find((path) => files[path] && files[path].old_path === route.filePath);
+              }
+              if (!filePath || !files[filePath]) throw new Error("Gerrit API file identity mismatch");
+
+              const diffQuery = new URLSearchParams(comparisonQuery);
+              diffQuery.set("context", "ALL");
+              const encodedFile = encodeURIComponent(filePath);
+              const diff = await requestJson("/revisions/" + encodeURIComponent(route.target) +
+                "/files/" + encodedFile + "/diff?" + diffQuery.toString());
+              validateDiff(diff, filePath);
+              let firstParentDiff = null;
+              if (route.comparison === "implicit" && targetRevision.commit &&
+                  Array.isArray(targetRevision.commit.parents) && targetRevision.commit.parents.length > 1) {
+                const firstParentQuery = new URLSearchParams();
+                firstParentQuery.set("parent", "1");
+                firstParentQuery.set("context", "ALL");
+                firstParentDiff = await requestJson("/revisions/" + encodeURIComponent(route.target) +
+                  "/files/" + encodedFile + "/diff?" + firstParentQuery.toString());
+                validateDiff(firstParentDiff, filePath);
+              }
+              if (window[stateKey] !== prepared || prepared.status !== "loading") return;
+              const countComments = Object.keys(comments || {}).reduce(
+                (total, path) => total + (Array.isArray(comments[path]) ? comments[path].length : 0), 0
+              );
+              window[stateKey] = {
+                status: "ready",
+                product: true,
+                routeKey: routeKey,
+                route: route,
+                detail: detail,
+                comments: comments,
+                files: files,
+                filePath: filePath,
+                requestedFilePath: route.filePath,
+                file: files[filePath],
+                diff: diff,
+                firstParentDiff: firstParentDiff,
+                fileCount: Object.keys(files).length,
+                commentCount: countComments,
+                diffBlockCount: Array.isArray(diff.content) ? diff.content.length : 0,
+                firstParentDiffBlockCount: firstParentDiff && Array.isArray(firstParentDiff.content)
+                  ? firstParentDiff.content.length : 0
+              };
+            }).catch((error) => {
+              if (window[stateKey] !== prepared || prepared.status !== "loading") return;
+              window[stateKey] = {
+                status: "failed",
+                product: true,
+                routeKey: routeKey,
+                route: route,
+                reason: String(error && error.message || error || "Gerrit file preparation failed")
+              };
+            });
+
+            return { matched: true, product: true, status: "loading", signature: "loading" };
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_file_resource_route_state_script.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritFileResourceRouteStateScript
+        private
+
+        def gerrit_file_resource_route_state_script
+          <<~'JS'
+            const stateKey = "__fetchUtilGerritFileResource";
+            const pathname = (location.pathname || "").replace(/\/+$/, "");
+            const marker = pathname.lastIndexOf('/+/');
+            if (marker < 1) return { matched: false };
+
+            const tail = pathname.slice(marker + 3).split("/");
+            if (tail.length < 3 || !/^\d+$/.test(tail[0])) return { matched: false };
+            const selector = tail[1];
+            const comparison = selector.match(/^(-?[1-9]\d*|0)\.\.([1-9]\d*)$/);
+            const targetOnly = selector.match(/^([1-9]\d*)$/);
+            if (!comparison && !targetOnly) return { matched: false };
+
+            const number = tail[0];
+            const target = comparison ? comparison[2] : targetOnly[1];
+            const base = comparison ? comparison[1] : null;
+            const rawFilePath = tail.slice(2).join("/");
+            let filePath;
+            try { filePath = decodeURIComponent(rawFilePath); }
+            catch (_error) { return { matched: false }; }
+            const fileParts = filePath.split("/");
+            const magicPath = fileParts[0] === "" && fileParts.length === 2 && fileParts[1];
+            if (!filePath || fileParts.some((part, index) => !part && !(index === 0 && magicPath)) ||
+                fileParts.some((part) => part === "." || part === "..")) return { matched: false };
+
+            const beforeMarker = pathname.slice(0, marker);
+            const baseNode = document.querySelector("base[href]");
+            let prefix = "";
+            if (baseNode) {
+              try {
+                const baseUrl = new URL(baseNode.getAttribute("href"), location.href);
+                if (baseUrl.origin === location.origin) prefix = baseUrl.pathname.replace(/\/+$/, "");
+              } catch (_error) { prefix = ""; }
+            }
+
+            let projectPath = beforeMarker;
+            if (prefix && projectPath.indexOf(prefix + "/") === 0) {
+              projectPath = projectPath.slice(prefix.length);
+            }
+            if (projectPath.indexOf("/c/") === 0) {
+              projectPath = projectPath.slice(3);
+            } else {
+              const cMarker = projectPath.indexOf("/c/");
+              if (cMarker >= 0) {
+                prefix = projectPath.slice(0, cMarker);
+                projectPath = projectPath.slice(cMarker + 3);
+              } else {
+                projectPath = projectPath.replace(/^\/+/, "");
+              }
+            }
+
+            try { projectPath = decodeURIComponent(projectPath); }
+            catch (_error) { return { matched: false }; }
+            if (!projectPath || projectPath.split("/").some((part) => !part || part === "." || part === "..")) {
+              return { matched: false };
+            }
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_file_resource_stabilization.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritFileResourceStabilization
+        GERRIT_FILE_RESOURCE_STABILIZATION_PROFILE = {
+          host: true,
+          path_query: ->(uri) { uri.path.match?(%r{/\+/\d+/(?:-?\d+\.\.)?\d+/.+}) },
+          strategy: :stabilize_gerrit_file_resource,
+          fallthrough: true,
+          notes: "Prepare product-matched Gerrit file diff REST resources.",
+          tests: "spec/fetch_util/browser_stabilization_spec.rb"
+        }.freeze
+
+        private
+
+        def stabilize_gerrit_file_resource(page, deadline: stabilization_deadline)
+          state = nil
+          ready = retry_until_timeout(
+            capped_timeout(10.0, deadline: deadline),
+            interval: 0.1,
+            deadline: deadline
+          ) do
+            state = gerrit_file_resource_state(page)
+            return false if state.is_a?(Hash) && (state["product"] == false || state["status"] == "failed")
+
+            state.is_a?(Hash) && state["status"] == "ready"
+          end
+          fail_gerrit_file_resource_preparation(page) if !ready && state.is_a?(Hash) && state["status"] == "loading"
+          settle_after_stabilization(0.25, deadline: deadline) if ready
+          ready
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/gerrit_file_resource_state.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module GerritFileResourceState
+        include GerritFileResourceRouteStateScript
+        include GerritFileResourceProductStateScript
+        include GerritFileResourceFetchStateScript
+        include GerritFileResourceValidationStateScript
+        include GerritFileResourceRequestStateScript
+
+        private
+
+        def gerrit_file_resource_state(page)
+          safe_evaluate(page, gerrit_file_resource_state_script, default: nil)
+        end
+
+        def fail_gerrit_file_resource_preparation(page)
+          safe_evaluate(page, <<~'JS', default: false)
+            (() => {
+              const prepared = window.__fetchUtilGerritFileResource;
+              if (!prepared || prepared.status !== "loading") return false;
+              prepared.status = "failed";
+              prepared.reason = "Gerrit file preparation timed out";
+              return true;
+            })()
+          JS
+        end
+
+        def gerrit_file_resource_state_script
+          <<~JS
+            (() => {
+              #{gerrit_file_resource_product_state_script}
+              #{gerrit_file_resource_request_state_script}
+            })()
+          JS
+        end
+      end
+    end
+  end
+end