atv-rails 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d84f86aa0661eeaa68ce6f720ffd8a04616596e4fa3f7c8eea46507259072be
-  data.tar.gz: a86828ce059aeac19e2c215d5cfc51e7668409e658f9d3867e545bbe3efffeed
+  metadata.gz: 62607ef7dc7cbea06ec251592fe5fe9f0c76921573059a61c4f1bf5f1d40dac1
+  data.tar.gz: ae1c07fdebafe198fc55a6154b9d3c23124142371490acceec49c15ad495fdb8
 SHA512:
-  metadata.gz: 8f09e35d71323af026a459de667e0e739a1c15d51e32d7f2753256ae8c7aec5c137d1a41b92909a855c11c36b6dd9c33594d0e1ae81d96e5ee562bfa923632cd
-  data.tar.gz: 93987bc549e43b72b3b1f48b34d21cfeb13d8046dcb7630948c44f95a4532a217cb154891a0af200602ea9c4032b20df83dba9a93d4affc5ff4cfe8bf8568836
+  metadata.gz: 0a80e9a1de4c5bbd1d9e01af0b1778adadedc7b8ddc51b6d8b8c4e900c6e4a443ef9f62edf25b03ba9ba557b6fedd4017dfbe102623d997ab3c1aad73b2d451f
+  data.tar.gz: 159a2ad890ce7bf69260b053a5d671c24a0395a9d576109f9c744984077bdcfb2726619f633ffc987420b028d60015cd0b87c50973884aa86a2ddf3e976ab0b9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Timothy Breitkreutz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# ATV::Rails
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "atv-rails"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install atv-rails
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/app/assets/atv-min.js

@@ -0,0 +1 @@
+const t="0.1.8";function importMap(){return JSON.parse(document.querySelector("script[type='importmap']").innerText).imports}const e=/[\-_]/;function pascalize(t){return t.split(e).map((t=>t.charAt(0).toUpperCase()+t.slice(1))).join("")}function dasherize(t){return t.replace(/_/g,"-")}const n=/,[\s+]/;function allVariants(...t){const e=t.filter((t=>Boolean(t)));return e.length===0?[]:dashVariants(...e).flatMap((t=>[t,`${t}s`]))}function dashVariants(t,...n){function dashOrUnderscore(t){const n=t||"";return e.test(n)?[dasherize(n),n.replace(/-/g,"_")]:[n]}const r=dashOrUnderscore(t);return n.length<1?r:dashVariants(...n).flatMap((t=>r.flatMap((e=>[`${e}-${t}`,`${e}_${t}`]))))}function variantSelectors(t,...e){return allVariants("data",...e).flatMap((e=>Array.from(t.querySelectorAll(`[${e}]`)).map((t=>[t,e]))))}function errorReport(t){t?.message?.includes("JSON")||console.error(`ATV: ${t}`)}function actionsFor(t,e,r=null){let o=[];const c=/[()]/;function parseAction(t,e){let i;let a=[];let[s,l]=t.split(/[\s]*[\-=]>[\s]*/);if(l){let[t,n]=l.split("#");n?e=t:n=t;i=n}else i=s;const[f,u]=i.split(c);if(u){i=f;a=u.split(n);try{a=JSON.parse(`[${u}]`)}catch(t){errorReport(t)}s=s.split("(")[0]}if(!r||s===r){if(!e){e=i;i=s}o.push({controller:dasherize(e),event:s,method:i,parameters:a})}}function actionSplit(t,e){let n=0;let r=[];Array.from(t).forEach((function(t){if(t!==","||n!==0){r.push(t);t==="("?n+=1:t===")"&&(n-=1)}else{e(r.join("").trim());r=[]}}));const o=r.join("").trim();n!==0&&console.error(`badly formed parameters: ${t}`);o&&e(o)}e.getAttributeNames().forEach((function(n){const r=new RegExp(`^data[_-]${t}[_-]?action[s]?`);const o=new RegExp(`^data[_-]${t}[_-]?(.*[^-_])[_-]?action[s]?`);let c;let i=n.match(o);if(i)c=i[1];else{c=null;i=n.match(r)}if(!i)return;let a=e.getAttribute(n);if(a){try{a=JSON.parse(a).join(",")}catch(t){errorReport(t)}actionSplit(a,(t=>parseAction(t,c)))}}));return o}function attributeKeysFor(t,e){if(!t||!t.getAttributeNames)return[];const n=new RegExp(`${e}s?$`,"i");return t.getAttributeNames().filter((t=>n.test(t)))}function attributesFor(t,e){return attributeKeysFor(t,e).map((e=>t.getAttribute(e)))}const r=new Set;const o=new Map;const c=new Map;let i=new Map;function findOrInitalize(t,e,n,r=null){t.has(e)||t.set(e,new Map);t.get(e).has(n)||t.get(e).set(n,r??new Map);return t.get(e).get(n)}function withModule(t,e){let n=`${t}_atv`;const r=importMap();Object.keys(r).forEach((function(e){dasherize(e).includes(`/${t}-atv`)&&(n=r[e])}));import(n).then((function(t){e(t)})).catch((function(t){console.error(`Loading ${n} failed:`,t)}))}function activate(e="atv"){if(i.has(e))return;const a=document.body;const s=allVariants("data",e,"controller").map((t=>`[${t}]`)).join(",");function outOfScope(t,e,r){if(!t||t.nodeType==="BODY")return true;const o=t.closest(s);if(!o)return true;let c=false;attributesFor(o,"controller").forEach((function(t){const i=t.split(n).map((t=>dasherize(t)));c=i.includes(r)?!(o===e):outOfScope(o.parentNode,e,r)}));return c}const l=!document.querySelector(`[data-${e}-report="true"]`);function report(n,r,o){l||n<1||console.log([["ATV:",`(${e})`,r,`[${Number(i.get(e)?.size)}]`].join(" "),`${o}: ${n}`,`v${t}`].join(" / "))}function createController(t,a){let s;let l={};let f={};r.add(a);function getActions(){return s}function registerActions(t){const n=findOrInitalize(i,e,t);let r=new Set;function collectElements(t){const[e]=t;r.add(e)}variantSelectors(t,e,a,"action").forEach(collectElements);variantSelectors(t,e,"action").forEach(collectElements);Array.from(r).forEach((function(r){const c=actionsFor(e,r);const i=new Set(c.map((t=>t.event)));i.forEach((function(i){const s=c.find((t=>t.event===i));if(s?.controller!==a)return;function invokeNext(e,o){if(o.length<1)return;const c=o[0];if(c.event===i&&!outOfScope(r,t,c.controller)){const t=n.get(c.controller).getActions();const r=t[c.method];if(r){const t=r(e.target,e,c.parameters);if(t===false)return}}return o.length>1?invokeNext(e,o.slice(1)):void 0}const handler=t=>invokeNext(t,c);const l=findOrInitalize(o,e,r);if(!l.get(i)){r.addEventListener(i,handler);l.set(i,handler)}}))}))}function refresh(){function refreshTargets(t,r){const o={};function collectionKeys(t){return[`all${pascalize(t)}`,`${t}s`]}variantSelectors(t.parentNode,e,a,"target").forEach((function(e){const[r,c]=e;r.getAttribute(c).split(n).forEach((function(e){const[n,c]=collectionKeys(e);if(!(l[e]===r||l[n]&&l[n].includes(r)||outOfScope(r,t,a))){if(l[n]){l[n].push(r);l[c].push(r)}else if(l[e]){l[n]=[l[e],r];l[c]=[l[e],r]}else l[e]=r;o[e]||(o[e]=[]);o[e].push(r)}}))}));r();Object.keys(o).forEach((function(t){const n=s[`${t}TargetConnected`];n&&o[t].forEach(n);const r=s[`${t}TargetDisconnected`];r&&o[t].forEach((function(n){findOrInitalize(c,e,n,[]).push((function(){const[e,o]=collectionKeys(t);let c=l[e]?.indexOf(n);c&&l[e].splice(c,1);c=l[o]?.indexOf(n);c&&l[o].splice(c,1);l[t]===n&&(l[e]?l[t]=l[e][0]:delete l[e]);r(n)}))}))}))}function refreshValues(t){allVariants("data",e,a,"value").forEach((function(e){const n=t.getAttribute(e);n&&[n,`{${n}}`].forEach((function(t){try{Object.assign(f,JSON.parse(t))}catch(t){errorReport(t)}}))}))}withModule(a,(function(e){refreshTargets(t,(function(){refreshValues(t);const n=e.connect(l,f,t,controllerBySelectorAndName);s=typeof n==="function"?n():n;registerActions(t)}))}))}const u=Object.freeze({getActions:getActions,refresh:refresh});return u}function registerControllers(t){findOrInitalize(i,e,t);attributesFor(t,"controller").forEach((function(r){r.split(n).forEach((function(n){const r=dasherize(n);const o=i.get(e).get(t).get(r)||createController(t,r);o.refresh();i.get(e).get(t).set(r,o)}))}))}function updateControllers(t){let n=Number(i.get(e)?.size);const r=new Set;t.matches(s)&&r.add(t);t.querySelectorAll(s).forEach((t=>r.add(t)));r.forEach(registerControllers);report(i.get(e).size-n,"controllers","found")}updateControllers(a);const f=new MutationObserver(domWatcher);function controllerBySelectorAndName(t,n,r){document.querySelectorAll(t).forEach((function(t){let o=findOrInitalize(i,e,t)?.get(n);o&&r({actions:o.getActions()})}))}function domWatcher(t,n){function cleanup(t){if(t.nodeName!=="BODY"&&t.nodeName!=="HTML"&&t.nodeName!=="#document"){cleanTargets(t);t.querySelectorAll(s).forEach(cleanActions);cleanActions(t)}else{n.disconnect();i=new Map}function cleanTargets(t){t&&t.children.length>0&&Array.from(t.children).forEach(cleanTargets);const n=c.get(e)?.get(t);if(n){n.forEach((t=>t()));n.splice(0,n.length)}}function cleanActions(t){const n=findOrInitalize(i,e,t);if(n){n.forEach((function(t){const e=t.getActions().disconnect;e&&e()}));i.get(e).delete(t)}}}function controllerFor(t,n){if(t&&t!==document.body)return findOrInitalize(i,e,t)?.get(n)||controllerFor(t.parentNode,n)}function updateTargets(t){Array.from(r).forEach((function(n){controllerFor(t,n)?.refresh();variantSelectors(t,e,n,"target").forEach((function(t){controllerFor(t[0],n)?.refresh()}))}))}function HTMLElements(t){return Boolean(t.classList)}t.forEach((function(t){t.type==="childList"&&Array.from(t.removedNodes).filter(HTMLElements).forEach((t=>cleanup(t)))}));t.forEach((function(t){t.type==="childList"&&Array.from(t.addedNodes).filter(HTMLElements).forEach((function(t){updateTargets(t);updateControllers(t)}))}))}const u={childList:true,subtree:true};f.observe(document,u)}export{activate,t as version};

data/app/assets/javascripts/atv.js

@@ -0,0 +1,659 @@
+/*global
+  console, document, MutationObserver
+*/
+/*jslint white*/
+
+//
+// ATV.js: Actions, Targets, Values
+//
+// Super vanilla JS / Lightweight alternative to stimulus without "class"
+// overhead and binding nonsense, just the actions, targets, and values
+// Also more forgiving with hyphens and underscores.
+
+// The MIT License (MIT)
+
+// Copyright (c) 2024 Timothy Breitkreutz
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+const version = "0.1.8";
+
+// To dynamically load up the ATV javascripts if needed
+function importMap() {
+  return JSON.parse(
+    document.querySelector("script[type='importmap']").innerText
+  ).imports;
+}
+
+/* ----------------- HELPER FUNCTIONS ------------------ */
+
+/* Variant in the context of ATV means either dash-case or snake_case */
+const variantPattern = /[\-_]/;
+
+function pascalize(string) {
+  return string
+    .split(variantPattern)
+    .map((str) => str.charAt(0).toUpperCase() + str.slice(1))
+    .join("");
+}
+
+function dasherize(string) {
+  return string.replace(/_/g, "-");
+}
+
+const deCommaPattern = /,[\s+]/;
+
+/* The following methods returns combinations of the given list
+ * connected with dashes and underscores.  For many examples see
+ * test/system/unit_test.rb
+ */
+function allVariants(...words) {
+  const parts = words.filter((arg) => Boolean(arg));
+  if (parts.length === 0) {
+    return [];
+  }
+  return dashVariants(...parts).flatMap((string) => [string, `${string}s`]);
+}
+
+function dashVariants(firstWord, ...words) {
+  function dashOrUnderscore(input) {
+    const string = input || "";
+    if (variantPattern.test(string)) {
+      return [dasherize(string), string.replace(/-/g, "_")];
+    }
+    return [string];
+  }
+  const first = dashOrUnderscore(firstWord);
+  if (words.length < 1) {
+    return first;
+  }
+  return dashVariants(...words).flatMap((str2) =>
+    first.flatMap((str1) => [`${str1}-${str2}`, `${str1}_${str2}`])
+  );
+}
+
+/* Returns a list of selectors to use for given name list */
+function variantSelectors(container, ...words) {
+  return allVariants("data", ...words).flatMap((variant) =>
+    Array.from(container.querySelectorAll(`[${variant}]`)).map((element) => [
+      element,
+      variant
+    ])
+  );
+}
+
+/* JSON is parsed aggressively and relies on "try" */
+function errorReport(ex) {
+  if (ex?.message?.includes("JSON")) {
+    return;
+  }
+  console.error(`ATV: ${ex}`);
+}
+
+/*
+ * Gets all action declarations for an element, returns an array of structures.
+ */
+function actionsFor(prefix, element, onlyEvent = null) {
+  let result = [];
+  const paramSeparator = /[()]/;
+
+  // Parse a single action part, controller is passed in
+  // if derived from the attribute key
+  function parseAction(action, controller) {
+    let method;
+    let parameters = [];
+    let [event, rightSide] = action.split(/[\s]*[\-=]>[\s]*/);
+
+    // Figure out what to do with the part on the right of the "=> blah#blah"
+    if (rightSide) {
+      let [innerController, methodCall] = rightSide.split("#");
+      if (methodCall) {
+        controller = innerController;
+      } else {
+        methodCall = innerController;
+      }
+      method = methodCall;
+    } else {
+      method = event;
+    }
+    const [methodName, params] = method.split(paramSeparator);
+    if (params) {
+      method = methodName;
+      parameters = params.split(deCommaPattern);
+      try {
+        parameters = JSON.parse(`[${params}]`);
+      } catch (ex) {
+        errorReport(ex);
+      }
+      event = event.split("(")[0];
+    }
+    // Sometimes we only care about a given event name passed in.
+    if (onlyEvent && event !== onlyEvent) {
+      return;
+    }
+    if (!controller) {
+      controller = method;
+      method = event;
+    }
+    result.push({
+      controller: dasherize(controller),
+      event,
+      method,
+      parameters
+    });
+  }
+
+  // Split on commas as long as they are not inside parameter lists.
+  function actionSplit(string, callback) {
+    let paramDepth = 0;
+    let accumulator = [];
+    Array.from(string).forEach(function (char) {
+      if (char === "," && paramDepth === 0) {
+        callback(accumulator.join("").trim());
+        accumulator = [];
+        return;
+      }
+      accumulator.push(char);
+      if (char === "(") {
+        paramDepth += 1;
+      } else if (char === ")") {
+        paramDepth -= 1;
+      }
+    });
+    const last = accumulator.join("").trim();
+    if (paramDepth !== 0) {
+      console.error(`badly formed parameters: ${string}`);
+    }
+    if (last) {
+      callback(last);
+    }
+  }
+
+  element.getAttributeNames().forEach(function (name) {
+    const unqualified = new RegExp(`^data[_-]${prefix}[_-]?action[s]?`);
+    const qualified = new RegExp(
+      `^data[_-]${prefix}[_-]?(.*[^-_])[_-]?action[s]?`
+    );
+
+    let controller;
+    let matched = name.match(qualified);
+    if (matched) {
+      controller = matched[1];
+    } else {
+      controller = null;
+      matched = name.match(unqualified);
+    }
+    if (!matched) {
+      return;
+    }
+    let list = element.getAttribute(name);
+    if (list) {
+      try {
+        list = JSON.parse(list).join(",");
+      } catch (ex) {
+        errorReport(ex);
+      }
+      actionSplit(list, (action) => parseAction(action, controller));
+    }
+  });
+  return result;
+}
+
+function attributeKeysFor(element, type) {
+  if (!element || !element.getAttributeNames) {
+    return [];
+  }
+  const regex = new RegExp(`${type}s?$`, "i");
+  return element.getAttributeNames().filter((name) => regex.test(name));
+}
+
+// Returns a list of attributes for the type (controller, target, action, etc.)
+function attributesFor(element, type) {
+  return attributeKeysFor(element, type).map((name) =>
+    element.getAttribute(name)
+  );
+}
+
+const allControllerNames = new Set();
+const allEventListeners = new Map();
+const allTargets = new Map();
+let allControllers = new Map();
+
+// The three maps above all have the same structure: prefix
+// first (atv, etc.), then element, then a Map of those things.
+function findOrInitalize(map, prefix, element, initial = null) {
+  if (!map.has(prefix)) {
+    map.set(prefix, new Map());
+  }
+  if (!map.get(prefix).has(element)) {
+    map.get(prefix).set(element, initial ?? new Map());
+  }
+  return map.get(prefix).get(element);
+}
+
+/* Look for the controllers in the importmap or just try to load them */
+function withModule(name, callback) {
+  let importmapName = `${name}_atv`;
+  const map = importMap();
+  Object.keys(map).forEach(function (source) {
+    if (dasherize(source).includes(`/${name}-atv`)) {
+      importmapName = map[source]; // There should only be one
+    }
+  });
+  import(importmapName)
+    .then(function (module) {
+      callback(module);
+    })
+    .catch(function (ex) {
+      console.error(`Loading ${importmapName} failed:`, ex);
+    });
+}
+
+/* ----------------- Main Activation Function ------------------ */
+
+function activate(prefix = "atv") {
+  if (allControllers.has(prefix)) {
+    return;
+  }
+  const root = document.body;
+
+  // Provide selector for any controllers given a prefix
+
+  const controllersSelector = allVariants("data", prefix, "controller")
+    .map((selector) => `[${selector}]`)
+    .join(",");
+
+  // To allow for nesting controllers:
+  // skip if it's not the nearest enclosing controller
+  function outOfScope(element, root, name) {
+    if (!element || element.nodeType === "BODY") {
+      return true;
+    }
+    const closestRoot = element.closest(controllersSelector);
+    if (!closestRoot) {
+      return true;
+    }
+    let out = false;
+    attributesFor(closestRoot, "controller").forEach(function (attr) {
+      const list = attr.split(deCommaPattern).map((str) => dasherize(str));
+      if (list.includes(name)) {
+        out = !(closestRoot === root);
+      } else {
+        out = outOfScope(closestRoot.parentNode, root, name);
+      }
+    });
+    return out;
+  }
+
+  // Optional console output mainly for development
+  const quiet = !document.querySelector(`[data-${prefix}-report="true"]`);
+  function report(count, type, action) {
+    if (quiet || count < 1) {
+      return;
+    }
+    console.log(
+      [
+        [
+          "ATV:",
+          `(${prefix})`,
+          type,
+          `[${Number(allControllers.get(prefix)?.size)}]`
+        ].join(" "),
+        `${action}: ${count}`,
+        `v${version}`
+      ].join(" / ")
+    );
+  }
+
+  /* ----------------- Controller Factory ------------------ */
+
+  function createController(root, name) {
+    let actions;
+    let targets = {};
+    let values = {};
+    allControllerNames.add(name);
+
+    function getActions() {
+      return actions;
+    }
+
+    function registerActions(root) {
+      const controllers = findOrInitalize(allControllers, prefix, root);
+
+      let elements = new Set();
+      function collectElements(item) {
+        const [element] = item;
+        elements.add(element);
+      }
+      variantSelectors(root, prefix, name, "action").forEach(collectElements);
+      variantSelectors(root, prefix, "action").forEach(collectElements);
+
+      // Find each element that has this type of controller
+      Array.from(elements).forEach(function (element) {
+        // Get action definitions
+        const list = actionsFor(prefix, element);
+        // Collect the events
+        const eventNames = new Set(list.map((action) => action.event));
+        // Make one handler for each event type
+        eventNames.forEach(function (eventName) {
+          const firstForEvent = list.find(
+            (action) => action.event === eventName
+          );
+          if (firstForEvent?.controller !== name) {
+            return;
+          }
+
+          function invokeNext(event, actions) {
+            if (actions.length < 1) {
+              return;
+            }
+            const action = actions[0];
+            if (
+              action.event === eventName &&
+              !outOfScope(element, root, action.controller)
+            ) {
+              const callbacks = controllers.get(action.controller).getActions();
+              const callback = callbacks[action.method];
+              if (callback) {
+                const result = callback(event.target, event, action.parameters);
+                if (result === false) {
+                  return;
+                }
+              }
+            }
+            if (actions.length > 1) {
+              return invokeNext(event, actions.slice(1));
+            }
+          }
+
+          const handler = (event) => invokeNext(event, list);
+          const events = findOrInitalize(allEventListeners, prefix, element);
+          if (events.get(eventName)) {
+            return;
+          }
+          element.addEventListener(eventName, handler);
+          events.set(eventName, handler);
+        });
+      });
+    }
+
+    // Update the in-memory controller from the DOM
+    function refresh() {
+      function refreshTargets(root, middle) {
+        const addedTargets = {};
+        function collectionKeys(key) {
+          return [`all${pascalize(key)}`, `${key}s`];
+        }
+
+        variantSelectors(root.parentNode, prefix, name, "target").forEach(
+          function (item) {
+            const [element, variant] = item;
+            element
+              .getAttribute(variant)
+              .split(deCommaPattern)
+              .forEach(function (key) {
+                const [allKey, pluralKey] = collectionKeys(key);
+                if (
+                  targets[key] === element ||
+                  (targets[allKey] && targets[allKey].includes(element)) ||
+                  outOfScope(element, root, name)
+                ) {
+                  return;
+                }
+                if (targets[allKey]) {
+                  targets[allKey].push(element);
+                  targets[pluralKey].push(element);
+                } else if (targets[key]) {
+                  targets[allKey] = [targets[key], element];
+                  targets[pluralKey] = [targets[key], element];
+                  // delete targets[key];
+                } else {
+                  targets[key] = element;
+                }
+                if (!addedTargets[key]) {
+                  addedTargets[key] = [];
+                }
+                addedTargets[key].push(element);
+              });
+          }
+        );
+        middle();
+        // This part needs to happen after the controller "activate".
+        Object.keys(addedTargets).forEach(function (key) {
+          const connectedCallback = actions[`${key}TargetConnected`];
+          if (connectedCallback) {
+            addedTargets[key].forEach(connectedCallback);
+          }
+          const disconnectedCallback = actions[`${key}TargetDisconnected`];
+          if (disconnectedCallback) {
+            addedTargets[key].forEach(function (element) {
+              findOrInitalize(allTargets, prefix, element, []).push(
+                function () {
+                  const [allKey, pluralKey] = collectionKeys(key);
+                  let index = targets[allKey]?.indexOf(element);
+                  if (index) {
+                    targets[allKey].splice(index, 1);
+                  }
+                  index = targets[pluralKey]?.indexOf(element);
+                  if (index) {
+                    targets[pluralKey].splice(index, 1);
+                  }
+                  if (targets[key] === element) {
+                    if (targets[allKey]) {
+                      targets[key] = targets[allKey][0];
+                    } else {
+                      delete targets[allKey];
+                    }
+                  }
+                  disconnectedCallback(element);
+                }
+              );
+            });
+          }
+        });
+      }
+
+      function refreshValues(element) {
+        allVariants("data", prefix, name, "value").forEach(function (variant) {
+          const data = element.getAttribute(variant);
+          if (!data) {
+            return;
+          }
+          [data, `{${data}}`].forEach(function (json) {
+            try {
+              Object.assign(values, JSON.parse(json));
+            } catch (ex) {
+              errorReport(ex);
+            }
+          });
+        });
+      }
+
+      // Note that with module includes a promise return so this part finishes
+      // asynchronously.
+      withModule(name, function (module) {
+        refreshTargets(root, function () {
+          refreshValues(root);
+          const invoked = module.connect(
+            targets,
+            values,
+            root,
+            controllerBySelectorAndName
+          );
+          // Allow for returning an collection of actions or
+          // a function returning a collection of actions
+          if (typeof invoked === "function") {
+            actions = invoked();
+          } else {
+            actions = invoked;
+          }
+          registerActions(root);
+        });
+      });
+    }
+
+    /** The public controller object */
+    const controller = Object.freeze({
+      getActions,
+      refresh
+    });
+    return controller;
+  }
+
+  function registerControllers(root) {
+    findOrInitalize(allControllers, prefix, root);
+
+    attributesFor(root, "controller").forEach(function (attribute) {
+      attribute.split(deCommaPattern).forEach(function (controllerName) {
+        const name = dasherize(controllerName);
+        const controller =
+          allControllers.get(prefix).get(root).get(name) ||
+          createController(root, name);
+        controller.refresh();
+        allControllers.get(prefix).get(root).set(name, controller);
+      });
+    });
+  }
+
+  function updateControllers(root) {
+    let initialCount = Number(allControllers.get(prefix)?.size);
+    const elements = new Set();
+    if (root.matches(controllersSelector)) {
+      elements.add(root);
+    }
+    root
+      .querySelectorAll(controllersSelector)
+      .forEach((element) => elements.add(element));
+    elements.forEach(registerControllers);
+
+    report(
+      allControllers.get(prefix).size - initialCount,
+      "controllers",
+      "found"
+    );
+  }
+
+  updateControllers(root);
+
+  const observer = new MutationObserver(domWatcher);
+
+  /* --- Provided to client code to talk to other controllers --- */
+  function controllerBySelectorAndName(selector, name, callback) {
+    document.querySelectorAll(selector).forEach(function (element) {
+      let controller = findOrInitalize(allControllers, prefix, element)?.get(
+        name
+      );
+      if (controller) {
+        callback({
+          actions: controller.getActions()
+        });
+      }
+    });
+  }
+
+  /* ------------ React to DOM changes for this prefix --------------- */
+
+  function domWatcher(records, observer) {
+    function cleanup(node) {
+      // Hard reset
+      if (
+        node.nodeName === "BODY" ||
+        node.nodeName === "HTML" ||
+        node.nodeName === "#document"
+      ) {
+        observer.disconnect();
+        allControllers = new Map();
+        return;
+      }
+      // Inner DOM reset
+      function cleanTargets(element) {
+        if (element && element.children.length > 0) {
+          Array.from(element.children).forEach(cleanTargets);
+        }
+        const disconnectors = allTargets.get(prefix)?.get(element);
+        if (disconnectors) {
+          disconnectors.forEach((callback) => callback());
+          disconnectors.splice(0, disconnectors.length);
+        }
+      }
+      function cleanActions(element) {
+        const controllers = findOrInitalize(allControllers, prefix, element);
+        if (controllers) {
+          controllers.forEach(function (controller) {
+            const disconnect = controller.getActions().disconnect;
+            if (disconnect) {
+              disconnect();
+            }
+          });
+          allControllers.get(prefix).delete(element);
+        }
+      }
+      cleanTargets(node);
+      node.querySelectorAll(controllersSelector).forEach(cleanActions);
+      cleanActions(node);
+    }
+
+    function controllerFor(element, name) {
+      if (!element || element === document.body) {
+        return;
+      }
+      return (
+        findOrInitalize(allControllers, prefix, element)?.get(name) ||
+        controllerFor(element.parentNode, name)
+      );
+    }
+
+    function updateTargets(element) {
+      Array.from(allControllerNames).forEach(function (name) {
+        controllerFor(element, name)?.refresh();
+        variantSelectors(element, prefix, name, "target").forEach(
+          function (item) {
+            controllerFor(item[0], name)?.refresh();
+          }
+        );
+      });
+    }
+
+    function HTMLElements(node) {
+      return Boolean(node.classList);
+    }
+    records.forEach(function (mutation) {
+      if (mutation.type === "childList") {
+        Array.from(mutation.removedNodes)
+          .filter(HTMLElements)
+          .forEach((node) => cleanup(node));
+      }
+    });
+    records.forEach(function (mutation) {
+      if (mutation.type === "childList") {
+        Array.from(mutation.addedNodes)
+          .filter(HTMLElements)
+          .forEach(function (node) {
+            updateTargets(node);
+            updateControllers(node);
+          });
+      }
+    });
+  }
+
+  const config = { childList: true, subtree: true };
+  observer.observe(document, config);
+}
+
+export { activate, version };

data/lib/atv/rails/railtie.rb

@@ -0,0 +1,6 @@
+module ATV
+  module Rails
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/atv/rails/version.rb

@@ -0,0 +1,5 @@
+module ATV
+  module Rails
+    VERSION = "0.0.3"
+  end
+end

data/lib/atv/rails.rb

@@ -0,0 +1,8 @@
+require "atv/rails/version"
+require "atv/rails/railtie"
+
+module ATV
+  module Rails
+    # Your code goes here...
+  end
+end

data/lib/install/importmap.rb

@@ -0,0 +1,8 @@
+# Assumes stimulus is already installed
+
+say "Copying ATV Rails JavaScript"
+copy_file "#{__dir__}/app/javascript/controllers/atv-rails.js", "app/javascript/controllers/atv-rails.js"
+
+say "Pin ATV"
+say %(Appending: pin "@sbrew.com/atv")
+append_to_file "config/importmap.rb", %(pin "atv", to: "@sbrew.com--atv.js"\n)

data/lib/tasks/atv/rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :atv_rails do
+#   # Task goes here
+# end

metadata

@@ -1,26 +1,53 @@
 --- !ruby/object:Gem::Specification
 name: atv-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
-- Tim Breitkreutz
+- Timothy Breitkreutz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-02 00:00:00.000000000 Z
-dependencies: []
-description: Gem to provide ATV for rails
-email: tim@sbrew.com
+date: 2024-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.1
+description:
+email:
+- tim@sbrew.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/atv_helpers.rb
-homepage: https://rubygems.org/gems/atv-rails
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/atv-min.js
+- app/assets/javascripts/atv.js
+- lib/atv/rails.rb
+- lib/atv/rails/railtie.rb
+- lib/atv/rails/version.rb
+- lib/install/importmap.rb
+- lib/tasks/atv/rails_tasks.rake
+homepage: https://www.sbrew.com/atv
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://www.sbrew.com/atv
+  source_code_uri: https://github.com/timbreitkreutz/atv-rails
+  changelog_uri: https://github.com/timbreitkreutz/atv-rails/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -36,8 +63,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Actions, Targets, Values for Rails JavaScript
+summary: Functional JavaScript for Rails.
 test_files: []

data/lib/atv_helpers.rb

@@ -1,7 +0,0 @@
-module AtvHelpers
-  def atv_controller(name, element = "div") 
-    tag.send(element, "data-atv-controller=#{name.dasherize}") do 
-      yield if block_given?
-    end
-  end
-end