resolve merge conflicts with main

Author: adrienpoly

.circleci/config.yml

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -eux
+
+package-name() {
+  node -e "
+    const package = JSON.parse(fs.readFileSync('package.json'))
+    console.log(package.name)
+  "
+}
+
+rewrite-package-json() {
+  ARCHIVE_URL="https://github.com/${DEV_BUILD_REPO_NAME}/archive" \
+  PACKAGE_LIST="$package_list" node -e "
+    const url = process.env.ARCHIVE_URL
+    const sha = process.env.GITHUB_SHA.slice(0, 7)
+    const package = JSON.parse(fs.readFileSync('package.json'))
+    if (package.dependencies) {
+      const packageNames = JSON.parse(process.env.PACKAGE_LIST).map(_ => _.name)
+      for (const name in package.dependencies)
+        if (packageNames.indexOf(name) != -1)
+          package.dependencies[name] = url + '/' + name + '/' + sha + '.tar.gz'
+      fs.writeFileSync('package.json', JSON.stringify(package))
+    }
+  "
+}
+
+DEV_BUILD_REPO_NAME="hotwired/dev-builds"
+DEV_BUILD_ORIGIN_URL="https://${1}@github.com/${DEV_BUILD_REPO_NAME}.git"
+BUILD_PATH="$HOME/publish-dev-build"
+
+cd "$GITHUB_WORKSPACE"
+
+_IFS="$IFS"
+IFS=$'\n'
+package_list="$(yarn -s lerna list --no-private --json 2>/dev/null)"
+package_paths=( $(yarn -s lerna exec --no-private pwd 2>/dev/null) )
+IFS="$_IFS"
+
+name="$(git log -n 1 --format=format:%cn)"
+email="$(git log -n 1 --format=format:%ce)"
+subject="$(git log -n 1 --format=format:%s)"
+date="$(git log -n 1 --format=format:%ai)"
+url="https://github.com/${GITHUB_REPOSITORY}/tree/${GITHUB_SHA}"
+
+for package_path in "${package_paths[@]}"; do
+  pushd "$package_path"
+    package_name="$(package-name)"
+    tag="${package_name}/${GITHUB_SHA:0:7}"
+    message="$tag $subject"$'\n'$'\n'"$url"
+  popd
+
+  mkdir -p "$BUILD_PATH"
+
+  pushd "$BUILD_PATH"
+    git init .
+    git remote add origin "$DEV_BUILD_ORIGIN_URL"
+    git symbolic-ref HEAD refs/heads/publish-dev-build
+
+    shopt -s nullglob
+      cp -R "$package_path"/{*.json,*.js,dist} . || true
+    shopt -u nullglob
+    rewrite-package-json
+    git add .
+
+    GIT_AUTHOR_DATE="$date" GIT_COMMITTER_DATE="$date" \
+    GIT_AUTHOR_NAME="$name" GIT_COMMITTER_NAME="$name" \
+    GIT_AUTHOR_EMAIL="$email" GIT_COMMITTER_EMAIL="$email" \
+      git commit -m "$message"
+
+    git tag "$tag"
+    [ "$GITHUB_REF" != "refs/heads/main" ] || git tag -f "${package_name}/latest"
+    git push -f --tags
+  popd
+
+  rm -fr "$BUILD_PATH"
+done
+
+echo done

.github/scripts/publish-dev-build

@@ -0,0 +1,29 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
+      with:
+        node-version: '12.4.0'
+    - uses: actions/cache@v2
+      with:
+        path: |
+          node_modules
+          */*/node_modules
+        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+
+    - run: yarn install
+
+    - name: Test
+      run: yarn test
+
+    - name: Publish dev build
+      run: .github/scripts/publish-dev-build '${{ secrets.DEV_BUILD_GITHUB_TOKEN }}'
+      if: ${{ github.event_name == 'push' }}

.github/workflows/ci.yml

@@ -1 +1 @@
-12.4.0
+16.2.0

.node-version

@@ -2,7 +2,7 @@
 
 ### A modest JavaScript framework for the HTML you already have
 
-Stimulus is a JavaScript framework with modest ambitions. It doesn't seek to take over your entire front-end—in fact, it's not concerned with rendering HTML at all. Instead, it's designed to augment your HTML with just enough behavior to make it shine. Stimulus pairs beautifully with [Turbolinks](https://github.com/turbolinks/turbolinks) to provide a complete solution for fast, compelling applications with a minimal amount of effort.
+Stimulus is a JavaScript framework with modest ambitions. It doesn't seek to take over your entire front-end—in fact, it's not concerned with rendering HTML at all. Instead, it's designed to augment your HTML with just enough behavior to make it shine. Stimulus pairs beautifully with [Turbo](https://turbo.hotwire.dev) to provide a complete solution for fast, compelling applications with a minimal amount of effort.
 
 How does it work? Sprinkle your HTML with controller, target, and action attributes:
 
@@ -32,25 +32,25 @@ export default class extends Controller {
 }
 ```
 
-Stimulus continuously watches the page, kicking in as soon as attributes appear or disappear. It works with any update to the DOM, regardless of whether it comes from a full page load, a Turbolinks page change, or an Ajax request. Stimulus manages the whole lifecycle.
+Stimulus continuously watches the page, kicking in as soon as attributes appear or disappear. It works with any update to the DOM, regardless of whether it comes from a full page load, a [Turbo](https://turbo.hotwire.dev) page change, or an Ajax request. Stimulus manages the whole lifecycle.
 
-You can write your first controller in five minutes by following along in the [Stimulus Handbook](https://stimulusjs.org/handbook/introduction).
+You can write your first controller in five minutes by following along in the [Stimulus Handbook](https://stimulus.hotwire.dev/handbook/introduction).
 
-You can read more about why we created this new framework in [The Origin of Stimulus](https://stimulusjs.org/handbook/origin).
+You can read more about why we created this new framework in [The Origin of Stimulus](https://stimulus.hotwire.dev/handbook/origin).
 
 ## Installing Stimulus
 
 Stimulus integrates with the [webpack](https://webpack.js.org/) asset packager to automatically load controller files from a folder in your app.
 
 You can use Stimulus with other asset packaging systems, too. And if you prefer no build step at all, just drop a `<script>` tag on the page and get right down to business.
 
-See the [Installation Guide](https://stimulusjs.org/handbook/installing) for detailed instructions.
+See the [Installation Guide](https://stimulus.hotwire.dev/handbook/installing) for detailed instructions.
 
 ## Getting Help & Contributing Back
 
-Looking for the docs? Once you've read through the Handbook, consult the [Stimulus Reference](https://stimulusjs.org/reference/controllers) for API details.
+Looking for the docs? Once you've read through the Handbook, consult the [Stimulus Reference](https://stimulus.hotwire.dev/reference/controllers) for API details.
 
-Have a question about Stimulus? Connect with other Stimulus developers on the [Stimulus Discourse](https://discourse.stimulusjs.org/) community forum.
+Have a question about Stimulus? Connect with other Stimulus developers on the [Hotwire Discourse](https://discuss.hotwire.dev/) community forum.
 
 Find a bug? Head over to our [issue tracker](https://github.com/stimulusjs/stimulus/issues) and we'll do our best to help. We love pull requests, too!
 
@@ -60,7 +60,7 @@ We expect all Stimulus contributors to abide by the terms of our [Code of Conduc
 
 Stimulus is [MIT-licensed](LICENSE.md) open-source software from [Basecamp](https://basecamp.com/), the creators of [Ruby on Rails](http://rubyonrails.org).
 
-Continuous integration is generously provided by open-source grants from [CircleCI](https://circleci.com) and [Sauce Labs](https://saucelabs.com/open-source).
+Continuous integration VMs generously provided by [Sauce Labs](https://saucelabs.com/open-source).
 
 ---
 

README.md

@@ -17,19 +17,19 @@ And it’s also not to say that the proliferation of single-page JavaScript appl
 
 We wanted Basecamp to feel like that too. As though we had followed the herd and rewritten everything with client-side rendering or gone full-native on mobile.
 
-This desire led us to a two-punch solution: [Turbolinks](https://github.com/turbolinks/turbolinks) and Stimulus.
+This desire led us to a two-punch solution: [Turbo](https://turbo.hotwire.dev) and Stimulus.
 
-### Turbolinks up high, Stimulus down low
+### Turbo up high, Stimulus down low
 
-Before I get to Stimulus, our new modest JavaScript framework, allow me to recap the proposition of Turbolinks.
+Before I get to Stimulus, our new modest JavaScript framework, allow me to recap the proposition of Turbo.
 
-Turbolinks descends from an approach called [pjax](https://github.com/defunkt/jquery-pjax), developed at GitHub. The basic concept remains the same. The reason full-page refreshes often feel slow is not so much because the browser has to process a bunch of HTML sent from a server. Browsers are really good and really fast at that. And in most cases, the fact that an HTML payload tends to be larger than a JSON payload doesn’t matter either (especially with gzipping). No, the reason is that CSS and JavaScript has to be reinitialized and reapplied to the page again. Regardless of whether the files themselves are cached. This can be pretty slow if you have a fair amount of CSS and JavaScript.
+Turbo descends from an approach called [pjax](https://github.com/defunkt/jquery-pjax), developed at GitHub. The basic concept remains the same. The reason full-page refreshes often feel slow is not so much because the browser has to process a bunch of HTML sent from a server. Browsers are really good and really fast at that. And in most cases, the fact that an HTML payload tends to be larger than a JSON payload doesn’t matter either (especially with gzipping). No, the reason is that CSS and JavaScript has to be reinitialized and reapplied to the page again. Regardless of whether the files themselves are cached. This can be pretty slow if you have a fair amount of CSS and JavaScript.
 
-To get around this reinitialization, Turbolinks maintains a persistent process, just like single-page applications do. But largely an invisible one. It intercepts links and loads new pages via Ajax. The server still returns fully-formed HTML documents.
+To get around this reinitialization, Turbo maintains a persistent process, just like single-page applications do. But largely an invisible one. It intercepts links and loads new pages via Ajax. The server still returns fully-formed HTML documents.
 
 This strategy alone can make most actions in most applications feel really fast (if they’re able to return server responses in 100-200ms, which is eminently possible with caching). For Basecamp, it sped up the page-to-page transition by ~3x. It gives the application that feel of responsiveness and fluidity that was a massive part of the appeal for single-page applications.
 
-But Turbolinks alone is only half the story. The coarsely grained one. Below the grade of a full page change lies all the fine-grained fidelity within a single page. The behavior that shows and hides elements, copies content to a clipboard, adds a new todo to a list, and all the other interactions we associate with a modern web application.
+But Turbo alone is only half the story. The coarsely grained one. Below the grade of a full page change lies all the fine-grained fidelity within a single page. The behavior that shows and hides elements, copies content to a clipboard, adds a new todo to a list, and all the other interactions we associate with a modern web application.
 
 Prior to Stimulus, Basecamp used a smattering of different styles and patterns to apply these sprinkles. Some code was just a pinch of jQuery, some code was a similarly sized pinch of vanilla JavaScript, and some again was larger object-oriented subsystems. They all usually worked off explicit event handling hanging off a `data-behavior` attribute.
 
@@ -50,7 +50,7 @@ It’s designed to read as a progressive enhancement when you look at the HTML i
 
 You can read that and have a pretty good idea of what’s going on. Even without knowing anything about Stimulus or looking at the controller code itself. It’s almost like pseudocode. That’s very different from reading a slice of HTML that has an external JavaScript file apply event handlers to it. It also maintains the separation of concerns that has been lost in many contemporary JavaScript frameworks.
 
-As you can see, Stimulus doesn’t bother itself with creating the HTML. Rather, it attaches itself to an existing HTML document. The HTML is, in the majority of cases, rendered on the server either on the page load (first hit or via Turbolinks) or via an Ajax request that changes the DOM.
+As you can see, Stimulus doesn’t bother itself with creating the HTML. Rather, it attaches itself to an existing HTML document. The HTML is, in the majority of cases, rendered on the server either on the page load (first hit or via Turbo) or via an Ajax request that changes the DOM.
 
 Stimulus is concerned with manipulating this existing HTML document. Sometimes that means adding a CSS class that hides an element or animates it or highlights it. Sometimes it means rearranging elements in groupings. Sometimes it means manipulating the content of an element, like when we transform UTC times that can be cached into local times that can be displayed.
 
@@ -63,7 +63,7 @@ This makes Stimulus very different from the majority of contemporary JavaScript
 
 Stimulus also differs on the question of state. Most frameworks have ways of maintaining state within JavaScript objects, and then render HTML based on that state. Stimulus is the exact opposite. State is stored in the HTML, so that controllers can be discarded between page changes, but still reinitialize as they were when the cached HTML appears again.
 
-It really is a remarkably different paradigm. One that I’m sure many veteran JavaScript developers who’ve been used to work with contemporary frameworks will scoff at. And hey, scoff away. If you’re happy with the complexity and effort it takes to maintain an application within the maelstrom of, say, React + Redux, then Turbolinks + Stimulus will not appeal to you.
+It really is a remarkably different paradigm. One that I’m sure many veteran JavaScript developers who’ve been used to work with contemporary frameworks will scoff at. And hey, scoff away. If you’re happy with the complexity and effort it takes to maintain an application within the maelstrom of, say, React + Redux, then Turbo + Stimulus will not appeal to you.
 
 If, on the other hand, you have nagging sense that what you’re working on does not warrant the intense complexity and application separation such contemporary techniques imply, then you’re likely to find refuge in our approach.
 
@@ -74,7 +74,7 @@ At Basecamp we’ve used this architecture across several different versions of
 
 In fact, it feels like the same kind of secret sauce we had at Basecamp when we developed [Ruby on Rails](https://rubyonrails.org/). The sense that contemporary mainstream approaches are needlessly convoluted, and that we can do more, faster, with far less.
 
-Furthermore, you don’t even have to choose. Stimulus and Turbolinks work great in conjunction with other, heavier approaches. If 80% of your application does not warrant the big rig, consider using our two-pack punch for that. Then roll out the heavy machinery for the part of your application that can really benefit from it.
+Furthermore, you don’t even have to choose. Stimulus and Turbo work great in conjunction with other, heavier approaches. If 80% of your application does not warrant the big rig, consider using our two-pack punch for that. Then roll out the heavy machinery for the part of your application that can really benefit from it.
 
 At Basecamp, we have and do use several heavier-duty approaches when the occasion calls for it. Our calendars tend to use client-side rendering. Our text editor is [Trix](https://trix-editor.org/), a fully formed text processor that wouldn’t make sense as a set of Stimulus controllers.
 

docs/handbook/00_the_origin_of_stimulus.md

@@ -8,16 +8,16 @@ The best way to learn how Stimulus works is to build a simple controller. This c
 
 ## Prerequisites
 
-To follow along, you'll need a running copy of the [`stimulus-starter`](https://github.com/stimulusjs/stimulus-starter) project, which is a preconfigured blank slate for exploring Stimulus.
+To follow along, you'll need a running copy of the [`stimulus-starter`](https://github.com/hotwired/stimulus-starter) project, which is a preconfigured blank slate for exploring Stimulus.
 
-We recommend [remixing `stimulus-starter` on Glitch](https://glitch.com/edit/#!/import/git?url=https://github.com/stimulusjs/stimulus-starter.git) so you can work entirely in your browser without installing anything:
+We recommend [remixing `stimulus-starter` on Glitch](https://glitch.com/edit/#!/import/git?url=https://github.com/hotwired/stimulus-starter.git) so you can work entirely in your browser without installing anything:
 
-[![Remix on Glitch](https://cdn.glitch.com/2703baf2-b643-4da7-ab91-7ee2a2d00b5b%2Fremix-button.svg)](https://glitch.com/edit/#!/import/git?url=https://github.com/stimulusjs/stimulus-starter.git)
+[![Remix on Glitch](https://cdn.glitch.com/2703baf2-b643-4da7-ab91-7ee2a2d00b5b%2Fremix-button.svg)](https://glitch.com/edit/#!/import/git?url=https://github.com/hotwired/stimulus-starter.git)
 
 Or, if you'd prefer to work from the comfort of your own text editor, you'll need to clone and set up `stimulus-starter`:
 
 ```
-$ git clone https://github.com/stimulusjs/stimulus-starter.git
+$ git clone https://github.com/hotwired/stimulus-starter.git
 $ cd stimulus-starter
 $ yarn install
 $ yarn start

docs/handbook/02_hello_stimulus.md

@@ -6,7 +6,7 @@ permalink: /handbook/managing-state
 
 Most contemporary frameworks encourage you to keep state in JavaScript at all times. They treat the DOM as a write-only rendering target, reconciled by client-side templates consuming JSON from the server.
 
-Stimulus takes a different approach. A Stimulus application's state lives as attributes in the DOM; controllers themselves are largely stateless. This approach makes it possible to work with HTML from anywhere—the initial document, an Ajax request, a Turbolinks visit, or even another JavaScript library—and have associated controllers spring to life automatically without any explicit initialization step.
+Stimulus takes a different approach. A Stimulus application's state lives as attributes in the DOM; controllers themselves are largely stateless. This approach makes it possible to work with HTML from anywhere—the initial document, an Ajax request, a Turbo visit, or even another JavaScript library—and have associated controllers spring to life automatically without any explicit initialization step.
 
 ## Building a Slideshow