ember-learn/guides-source

This repository contains the Ember.js Guides

Ember Guides Source

This repository contains the written content for the Ember.js Guides. Contributors can file issues and submit pull requests (PRs) to help improve everyone's learning experience.

Looking for repositories for the other parts of emberjs.com? Check out website, ember-api-docs, super-rentals tutorial, statusboard, deprecation-app, and styleguide.

Contributing

Welcome and thanks for your help!

First-time contributors are encouraged to look at issues that are labeled help wanted or good first issue. If you have questions or want a buddy to pair with, you can join the #dev-ember-learning channel in the Ember Community Discord.

Please see CONTRIBUTING.md for additional instructions on how to format your work and submit a PR.

Project layout

The Ember Guides content is written in Markdown. Each minor version of Ember has its own directory within /guides.

In general, your PR should make edits to only the files in the /guides/release directory, which corresponds to the latest version of Ember. Exceptions may include fixing broken links and typos in older versions of the Ember Guides.

If you run ember serve, the Markdown files are turned into HTML to create an app. We use the following addons to make this happen:

• ember-styleguide
• guidemaker
• guidemaker-ember-template

Local development

NOTE: This project uses Volta to ensure the correct Node.js and NPM version is used during local development.

To run the Ember Guides app locally, type these commands into your terminal.

git clone git://github.com/ember-learn/guides-source.git

cd guides-source
npm install
ember serve

Afterwards, visit http://localhost:4200 in your browser.

Note: On Mac, if you get the error Error: EMFILE: too many open files, watch, try installing Watchman. Install Homebrew if you don't have it. Then, in your terminal, run brew install watchman.

Running tests

Use npm test to run tests locally. In addition to the Ember app, we check for broken links.

npm test

Linting and spellchecking

The guides are spellchecked and linted for Markdown consistency. You can check your edits by running,

npm run lint:md

Linting and spellchecking must pass or they will fail in CI (continuous integration). See CONTRIBUTING.md for more information on linting and spellchecking.

Internal and external links

Testing of internal and external links can be performed using three commands:

# Run all test scripts in `/node-tests` except those located
# in `/node-tests/local`. In particular, this command checks
# all internal links across all versions of the Guides.
npm run test:node

# Run all test scripts in `/node-tests/local`. In particular,
# this command checks all external links in the release version
# of the Guides. 
npm run test:node-local

# When checking external links in the release version, don't
# check links to the API docs (https://api.emberjs.com).
npm run test:node-local-exclude-api-urls

guides-source's Issues

Show how to do arrays/objects in an Ember Data model

This page shows how to do type transforms. But what about if a record has a deeply nested read-only object or array? New learners might think they need to make relationships and child models, and this gets difficult quickly, however there is a simple solution.

Add a note and an example of read-only arrays and nested objects in Ember Data:

location: DS.attr() // a read-only object
tags: DS.attr() // a read-only array

{{model.location.latitude}}

Make the Controllers section more helpful

There's not much on https://guides.emberjs.com/current/controllers - they are not distinguishable from routes or components in this explanation.

Try to help someone new understand, “where and when should I use a Controller?”

You can base content off this blog post. The relevant sections are “the essentials” and “when you should make a controller”. I wrote a lot about Query Parameters but we can just link to the Routing section of the guides instead.

The end result should be at maximum twice the current length.

Unwanted trailing slashes on services page

There are some unwanted trailing slashes on guides page causing errors when using that part of the code. Tried to paste it and confirmed that it does not work, also checked the official guides-source repository and the trailing slashes are not there.

The trailing slashes come after the 'location' and 'element' words.

getMapElement(location) {
    let camelizedLocation = camelize(location/); 
    let element = this.get(`cachedMaps.${camelizedLocation}`);
    if (!element/) {
      element = this.createMapElement();
      this.get('mapUtil').createMap(element, location/);
      this.set(`cachedMaps.${camelizedLocation}`, element/);
    }
    return element;
  },

Link: https://github.com/ember-learn/guides-source/blob/master/guides/v3.1.0/tutorial/service.md

Actions change API without a description

This section https://guides.emberjs.com/release/templates/actions/#toc_modifying-the-actions-first-parameter changes from the element modifier version of actions to the closure version (? - should probably also give a name to the two types so users know what to say/search for) without even a sentence about why, what the difference is, when to use which, and the caveats. This makes actions quite confusing for people just starting with the framework.

404 error clicking on old-version-warning btn link on v1.10.0

When navigating to Views: Inserting Views in Templates v1.10.0, the VIEW v3.1.0 link returns a 404 error.

Error message in the response..

Error: Ember Data Request GET /content/v3.1.0/views/inserting-views-in-templates/index.json returned a 404 Payload (Empty Content-Type)

should the object model guide talk about factory registration?

I'd like to report a shortcoming I've noticed in the guide, and suggest adding a further-reading link between two of its pages. I don't understand the issue well enough to suggest another edit.

While adding the router service to an event-handler object (EmberObject subclass) I got the error Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container, which seems similar to https://stackoverflow.com/questions/34970881/inject-a-service-into-an-ember-object-not-an-ember-controller

Everything else on the event handler has been working ok with the import and create approach, but when I tried to load in the router service I hit the error.
The assert is useful, and has helped me figure out what to do next, but it seems like the guide should cover this. Instead it only talks about using create.

Explaining why this is needed or different from import/create would be great (maybe transcribing @locks's stackoverflow post), but it'd be simpler to put something short at the bottom of classes and instances suggesting further reading of dependency injection or even registering singletons vs non-singletons as further reading.

Quest: Transition guides documentation to use angle bracket invocation (rfc 311)

See RFC 311

This is a placeholder for a quest issue for converting the guides to introduce and explain angle bracket component invocation to ember developers.

Naming conventions page

A number of place on the web* link to a "naming conventions" page at https://emberjs.com/guides/concepts/naming-conventions/ however such a page doesn't exist. Searching for a current version of that doc doesn't seem to turn up anything -- the latest version that I've found comes from v1.13: https://guides.emberjs.com/v1.13.0/getting-started/naming-conventions/

Given Ember's emphasis on convention-over-configuration, it would be useful to have a single, canonical reference for these what conventions are (especially when some of them, like :model-name_id-style naming of dynamic segments aren't entirely intuitive).

Was removing this section from the guides an active decision, or just a casualty of all the changes around the 2.0 release that was never rectified? (or was it moved somewhere else and I just haven't found it?)

*: eg https://stackoverflow.com/questions/21027814/why-are-ember-route-parameters-underscore-style and https://github.com/Wikia/guidelines/tree/master/Ember#naming-conventions

migrated from emberjs/website#3422

edit: looks like there was a proposal to remove it in emberjs/guides#91 but there wasn't really a decision other than to deal with it post-2.0

Re-add documentation for custom test helpers

There used to be documentation on creating custom test helpers. These no longer worked (though were still included) in v3.0, but have been removed in v3.1

These should be updated to be compatible with the testing changes in v3. Specifically: before v3.0, it used to be that to make a helper available to testing code, you'd import it into tests/helpers/start-app.js. Now that the testing reorg with 3.0 has removed that file, I'm not sure where should those imports go.

I've also opened an issue on the ember-cli docs: ember-cli/ember-cli.github.io#211

Rework the Models intro

I'm going to attempt this. Again.

https://guides.emberjs.com/release/models/

Goals:

• Clear distinction between Ember and Ember Data
• Explain what Ember Data is
• Clear distinction between model hooks and Models models
• Mergeable PRs, this time.

Explain how to transition between Routes

We should add a section to Defining your routes that very briefly explains how to move between routes, and link to the API docs

There are 3 main ways:

• this.transitionTo or transitionToRoute from a route
• using the Router Service
• link to in a template

Remove jQuery

The motivation for this change is best described by @acorncom:

The goal here is to dog food the approach, find snags early prior to it being common and help pave the path for the community. Because although not having jQuery in your app isn’t ever going to be required, it’s the type of thing that would be nice to first allow (and down the road might become the new default blueprint at some point in the future). Plus, we’ll want to point folks interested in doing this type of change toward learning team apps.

For more info see the conversation on #38

Dead Link at footer

https://guides.emberjs.com/logos/

When I click the logos on the footer it leads to this page which displays nothing.

Edit:I noticed all the links in the footer displays nothing

[2.18] Code examples for Testing seem different from reality

I am quite confused here and presumably looking to be told why I am wrong. I have been reviewing the guides for Testing, but none of the code examples match what is generated in my ember app. This has been very confusing for me because the code examples on the guides look way more legit.

For example, I am reviewing this page on writing acceptance tests. The code example on the page is as follows:

// tests/acceptance/login-test.js

import { module, test } from 'qunit';
import { visit } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';

module('Acceptance | login', function(hooks) {
  setupApplicationTest(hooks);

  test('visiting /login', async function(assert) {
    await visit('/login');
    assert.equal(currentURL(), '/login');
  });
});

However, if I generate exactly the same test locally I get the following:

// tests/acceptance/login-test.js

import { test } from 'qunit';
import moduleForAcceptance from 'my-app/tests/helpers/module-for-acceptance';

moduleForAcceptance('Acceptance | login');

test('visiting /login', function(assert) {
  visit('/login');

  andThen(function() {
    assert.equal(currentURL(), '/login');
  });
});

I can see this output in the guides up to 2.17 but they seem to change at 2.18.
Digging around, I have found the blueprints source in the Ember.js repo, but much to my dismay, the blueprints agree with what is being generated locally. In fact, the blueprints agree with me even on latest release 3.3.0-beta4.

What are the testing guides on about?

Create a test that verifies search is working

Ideally this is high-level, and ignorant of the implementation details (like Algolia).

If we can use an acceptance test in this repo that hits the actual Algolia endpoint, that would be ideal. I'm not sure if this can run from Travis, in containers etc.

If not, we'll have to think of something else.

Component testing guide.

locationService is not in scope in the component here:

https://github.com/ember-learn/guides-source/blame/master/guides/v3.1.0/testing/testing-components.md#L435-L437

discussion of pushing records into store using wrong method

https://guides.emberjs.com/v3.1.0/models/pushing-records-into-the-store/
The page discusses using store.push but the code example at the end uses pushPayload:

I expect the documentation to be consistent or explain the different semantics of the methods.
This issue relates to #20.
I can PR with the approved correction.

invoking-actions-directly-on-component-collaborators bad example

https://guides.emberjs.com/release/components/triggering-changes-with-actions/#toc_invoking-actions-directly-on-component-collaborators

Hi hope this is the right place for this. At the bottom of the section is a service app/services/messaging.js that has an actions hash with a method, sendMessage on it. sendMessage should not be in an actions hash, it should just be directly accessible on the service itself. I tried implementing this as is and it didn't work. I moved my method out of the actions hash and it started working.

Update guide source repo links in "toc_reporting-a-problem"

We need to update the links in https://guides.emberjs.com/v3.1.0/#toc_reporting-a-problem before going live.

Write a friendlier introduction to the Objects guide

When someone is done with the tutorial, the first thing they read is this. It's very confusing to beginners and right away, makes us look dated, because ES2015 is hardly new 😆

To-do:

• take out the reference to ES2015 being "new"
• write a better introduction. Imagine someone is reading this on day-one of Ember! New learners are probably the only people who look at this page.
• only make changes to the markdown file for the latest version of the guides

A more friendly introduction could hit these points, but these are just suggestions, so feel free to take a different direction:

• One of the first things you'll notice when you generate JavaScript files in Ember is that most of the code you will write goes inside of an object.
• While an Ember Object might look a lot like an ES2015 JavaScript class, it has some special powers.
• The most important is that an Ember Object can be watched for changes
• (description of what is meant here)

Repair bad line breaks and missing version #s in links

I'm working on this one. Related to ember-learn/guides-app#4

make sure there is a newline between the end of the paragraph and the references of referential style links in guides-source. This causes an issue with the markdown renderer that breaks the link. Alternatively, this could be fixed upstream: https://www.npmjs.com/package/ember-cli-showdown

fix all cases where there is a newline between ancor and link because this breaks the link e.g. click [here]\n(https://emberjs.com

some self-referential links often don't work because they are missing versions.

What is that, you say? Time for some RegEx?

Make this sentence easier to understand: "Ember components are used to encapsulate markup and style into reusable content."

This sentence in the guides would be difficult for non-native English speakers and new developers:

Ember components are used to encapsulate markup and style into reusable content.

Change this sentence so it is said more plainly, even if it takes more words. "Encapsulate" is the main issue.

Make your changes to only the markdown file for the latest version of Ember.

If you are an experienced Ember dev and you want to do this issue, when you are done, see if you can find another small change that would be good for a new contributor to do, and open an issue on it! Thanks!

Searching the v3.2 doc

It looks like the v3.2 doc hasn't been scrapped by algolia yet (https://github.com/algolia/docsearch).

Requests to algolia return empty payloads when POST payload includesfacetFilters: [["version:v3.2.0"]]"}.

Any thought on how the indexing may be triggered?

documentation link not working on ember test guide

Please go the link https://guides.emberjs.com/v3.1.0/testing/acceptance/

click on visit() helper . it is going no where

@abdullah2891

OP: emberjs/ember.js#16636

Runloop guides are out of date

The guides for the runloop (version 3.4) are quite out of date. They refer to things that no longer exist, such as Ember.run.queues (there are still queues but they are no longer accessible on Ember.run and there is an embedded demo app here: https://s3.amazonaws.com/emberjs.com/run-loop-guide/index.html

That demo app uses an extremely old version of Ember (1.3.2+pre.25108e91).

Not sure what to do here, because it seems a sizable portion of the docs on the runloop are no longer applicable. Perhaps we should just remove the misleading information for now?

Run link checker on later versions of Ember Guides

When I fixed all the links, it went as far as 2.17. We need to run link-checker.js on later versions before merging them in.

Add a loading template for page transitions

incorrect comment about jQuery.ajax returning a Promise

The async routing section on promises has a comment that states:

Note: jQuery AJAX methods return promises

This is incorrect. The jQuery API indicates $.getJSON and other low level methods return the jqXHR type. I think the code in this example should be updated with a modern example. This would avoid the overhead of teaching the potentially confusing history and semantics behind jQuery's request utilities.

Typo in guides/v3.2.0/tutorial/subroutes.md line 229

Just a random "/" in the code, made a change on pull request #96

Add one sentence to say what a helper is

This section on handlebars mentions helpers without saying what they are. Add one sentence to give new learners an idea, so they don't have to dig into handlebars docs. You might find a good definition in the API docs, or you could use this definition from the "built-in helpers" guide, which is "A helper is usually a simple function that can be used in any template."

Here is the section

Keep in mind that someone would likely read this definition before they get to Components.

Please only make changes to the markdown files for the latest version of Ember.

If you are an experienced Ember dev and you want to do this issue, when you are done, see if you can find another small change that would be good for a new contributor to do, and open an issue on it! Thanks!

Rework "Defining a Component Subclass"

I don't really understand what this section is trying to say. Do you know? Add or edit to make it easier to understand!

Defining a component subclass

Please make changes to only the markdown file for the latest version of Ember. I can't provide more guidance on how to rewrite this, but if you drop by the learning team channel in Discord, others may have more ideas. Link to join

patch release of the guides source and deployment instructions

• clone the repo/make sure you have the latest
• npm install -g np
• npm login <--- by someone who has the permissions. Ask an admin to add more people. link to add people
• np
• choose "minor"
• In about 5 mins, look for a dependabot PR on guides-app and merge it example and merge it after tests pass
• open the heroku pipeline. Do not click promote to production! In the production column, click on the arrows icon, choose deploy a branch, and master

Guides also have a few hiccups in IE11

The version drop-down isn't working at all in IE11. Loading the initial page, I saw Object doesn't support property or method 'includes' so I suspect something, (maybe the select addon?) wasn't polyfilled during the build.

IE11 also had a little problem with the "Installing Ember" page. The URL path was "getting-started/" rather than "getting-started/something" (which seems suspicious anyway), but IE compounded the inconsistency by sticking "index" on the end of it, which resulted in a blank page - not a 404, but a blank, white page. This doesn't happen with other pages.

Because with that page, I still got the same exception when it loaded, it was obviously starting to do something. I suspect maybe it had trouble finding content for the false"index" page and displayed nothing instead.

So maybe there's an issue for handling of "missing content" as well that might extend beyond IE11. Not sure.

Describe how computed props works with objects in more detail

When we get to https://guides.emberjs.com/release/object-model/computed-properties/#toc_multiple-dependents-on-the-same-object we don’t seem to specify that computed doesn’t work directly on an object but has to be pointed to props inside that object. To newcomers this can be trippy since they might wonder why they can't compute on the object itself.

delete

Explain when to use `index` routes

Problem:
It's unclear what to actually use index routes for. We can add some more details to the Guides on this.

To do:

• add more detail to the Index Routes section. Only make changes to the markdown file for the latest version of Ember.

Suggestions collected from Discord chat:

• "I explain this by relating it to index.html. If you make a request to https://emberjs.com, what file are you requesting? -- index. This has helped people understand why it's implicit (we don't need this.route('index', { path: ''}), and why it exists at every non-leaf-level node of the routing hierarchy."
• Be precise with talking about parent/child hierarchy. Technically an index route is a child route, like posts/index and posts/1 so it's inaccurate to say that an index is a place to put content that should not be rendered on child routes. (Although that's my mental model)
• "what makes index special? It's implicitly created for you whenever there are child routes in your router.js. It has a path of '', and is thus great for rendering stuff on "folders" within your routing hierarchy"

maybe instead we could do something like:

Here's a routing structure with

/posts/123/author
/posts/123/comments

What happens when a user visits /posts/123? We'll need to create a new route for this. Let's call it index for now.

this.route('post', { path: 'posts/:id' }, function () {
   this.route('index', { path: '' });
});

(some development of templates/post/index.hbs)
Hey, it turns out, we can remove this thing from router.js. Ember gives it to you for free
basically make it explicit, and then demonstrate that it's implicit
easier to explain while it's explicit

How you know you have improved it
Someone asked this question on Stack Overflow, and there was no great place to link them to in the Guides for an answer. If your work would help them, it's an improvement!

I have a quick question Here, I am new to Ember and it looks really exciting, I would like to have multiple routes in my web application, but when I click on a route it redirects the outlet to ONLY this NEW page "route", I don’t want the old page + content of the new page.. Any Ideas how to do that?

Tutorial lacks an index.md

tchan reported this as an invalid link: https://guides.emberjs.com/release/tutorial/.

The same bug persists when a version is selected. However, similar links work fine, like https://guides.emberjs.com/release/routing/.

I think this happens because Tutorial lacks an index.md. However, we can't just change the filename of the entry point file, because if anyone has linked to it, then we break those links 🤔

So maybe the action here is to make a "new" index.md that contains some intro information... hmm.

Consider changing the length of the `description` meta-data

This is a continuation from a conversation I had with @sivakumar-kailasam in #135

Currently, the description is limited to 260 characters because of a default in ember-meta /cc @rwwagner90

The main point of the conversation was this:

I remembered it was to a max limit around 300 (moz.com/learn/seo/meta-description).

Quest - Improvements to teaching Ember Data

Let's teach Ember Data better! Developers face three main hurdles when learning Ember Data, and by completing the issues linked below, we can improve the learning story. The challenges at a high level are:

1. Not knowing where the line is between Ember and Ember Data
2. Hard to know which API methods to use when
3. Fundamental misunderstanding of the point of serializers, as a way to turn any response into JSON:API

Here's how we'll overcome these. PRs should branch from master and target master for a merge.

• Find the places in the Guides where Ember Data functions are referenced, outside of the "Ember Data" section of the guides. Add an explicit note that the example uses Ember Data, and maybe a link to that part of the Guides or API docs.
• Show sample req and res objects/spec for different adapters/serializers
• Replace "customizing" language for serializers. I think we could simplify the mental model for everyone by teaching more about what a serializer is and how to write one instead of focusing on “customizing”
• Focus serializer explanations around most useful API methods. There are only 3 necessary methods, only 2 of which are “happy path”. Those methods are normalizeResponse serialize and pushPayload, and each can be described in an ideal world as “a pure function that converts from non-json-api to json-api or vice-versa”. The 2 happy path methods are normalizeResponse and serialize
• make sure distinction between model and record is clear. record for instances and ModelClass for the class
• better intro explaining what adapters are
• overall, gradually align on json-api terminology within ember-data, e.g. instead of saying record say resource and resource-identifier
• provide a proper intro to Ember Data in the Guides
• Split out Ember Data into its own Guide (way down the road, after we do the same for Tutorials)

Helpful terminology definitions:

• store: a cache for records
• Model: a schema class used when instantiating a record
• Adapter: a request-manager: it takes instructions on what to find and manages the process of making an API request and returning the response. Essentially an abstraction over fetch.
• Serializer: a formatter used to convert your API responses into json-api format if they are not already (caveat, needs to be a subset of json-api (camelCase member names and dasherized, singularized types)
• finders: a utility method for chaining together request => format data => update cache
• records (e.g. instances of Models) - think of them as “remote state”. A record is some data that lives outside of the lifecycle of the application, e.g. on your server

Explain how to pass actions and then use actions that have been passed

There are a few different ways to pass actions in Ember. We don't realllly teach them in the Guides, though it's covered in the Tutorial.

To do:

• link to this section on passing actions to components from here
• include a note that actions can't be passed down from a route, only from a controller or another component

Changes should only be made to the markdown files for the latest version of Ember.

Link to the section on Query Parameters from the Controller guide

The opening paragraph of Controllers should mention that they are the place to define routing query parameters, and link to this page

You should only make changes to the markdown file for the latest version of the guides.

If you are an experienced contributor, when you are done with this issue, please look for another small change that would be good for a new contributor, and open an issue on it. Thanks!

Providing an offline experience

We could provide users with a button that could download content in the background & cache it via service workers so that they can read whatever version of docs they were viewing even when they go offline.

Link to ember-auto-import in "Managing Dependencies"

We don't actually show new devs how to use npm packages. We should.

This is somewhat the domain of ember-cli instead, but I think in the interim, we should link to ember-auto-import in the managing dependencies guide. The explanation should be clear that there are many valid approaches to loading in dependencies, but it's the easiest for new developers.

I asked Ed about this a while back and he's fine with it.

To do:

• link to ember auto import and add a very brief explanation (2-3 sentences). See if you can do this without creating a new heading
• make changes to only the markdown file for the latest ember version

Nested routes can't find top level loading substates

Seems that the documentation is missed an important part of the bubble mechanism in loading substate.

It says that a loading substate is bubble up to root level loading.hbs, but really only render the route-level loading template.

Here is the original issue:
emberjs/ember.js#12367

Stubbing services

https://guides.emberjs.com/release/testing/testing-components/#toc_stubbing-services

As per discussion on slack (hopefully it hasn't disappeared) https://embercommunity.slack.com/archives/C045C9ABM/p1528120489000077 , the code snippets on updating values on a service is outdated and perhaps should be something like (if there's a more ember-matic way i'd be curious to know as well)

    const locationService = this.owner.lookup('location-service');
    locationService.set('city', 'Melbourne');

The code snippets also look a bit funky as well

@jenweber

Add basic meta-data implementation - must include canonical URL

There are some things that we can do to implement interesting/useful metadata into this application for things like sharing on Twitter, Slack posting etc which we may get "for free" as soon as we look at the metadata 😂

The only requirement for this issue to be considered complete is to have every page point to the corresponding /release/ URL in the canonical metadata. This will greatly improve the SEO for the guides 💪

Guides should recommend custom inflector rules be put in initializers instead of models

The official ember docs currently recommend custom inflector rules be added to app/models, which seems like an odd place and can introduce bugs if the inflector rules are not properly loaded before a user interacts with the store. I consulted with @runspired, and we agreed that a better place for such global setup to live would be in app/initializers.

Say explicitly what kind of Query Parameters are being taught

It's common for new learners to confuse API request query parameters (Ember Data) with routing query parameters.

Add a couple sentences to the intro section of Query Params to indicate that in web development, query params can be one of two things, either in the url or for making API requests. In Ember, these are two separate concepts. Link to Ember Data query params rather than explaining what they are. It's important that we don't make readers more confused.

Please make changes to only the markdown files for the latest Ember version.

Guides have a few hiccups with older versions of Edge.

With the Anniversary Edition of Windows 10, Edge doesn't display the dropdown of the version selector. Clicking the dropdown shows an empty list and the version appears as blank after that. Also, the black background for the example text isn't showing, making the examples hard to read.

Both issues occur on:

Microsoft Edge 38.14393.2068.0
Microsoft EdgeHTML 14.14393

But it works in:

Microsoft Edge 42.17134.1.0
Microsoft EdgeHTML 17.17134

I dug around a little. While poised on object ember619 - the article panel - the browser reports an unhandled exception Object doesn't support property or method 'ToString' in didRender of guides-app/components/es-form/es-textfield. Maybe something's getting fouled up there and interrupting it before it can populate the dropdown of the sidebar. It hits this once on the quick start page and sometimes more than once on each of the other pages I tried. And, yes, 'ToString' in the error has a capital T.

The other problem I noticed in passing. The examples with a header, like the HBS one on the Quick Start page, have the expected black background, but the plain examples, like the one with cd ember-quickstart \n ember serve, have no background, leaving strangely ghostly outline text. Comparing with more recent Edge, the <pre> tag in the old one has class line-numbers but no language-bash.

Hopefully, @sivakumar-kailasam, this will give you a head start. Many thanks!

How should we manage creating new version folders?

Current behavior:
When we make a new folder of versions, we risk creating more work/losing valuable work when open PRs are still pointed at earlier versions. We also lose the git history.

Desired behavior:
We don't need to duplicate work when a new version is cut.

Options:

• merge or close PRs before making a new version
• make a "current" folder that holds the next version, and PRs always go there
• ???