Maybe we can use a tool like this one to automate the merge of the docs PR when the code PR is merged
@documentation-team we now have two different cases of documentation tasks that require more than simple “API” updates:
- The Slot and Fill pattern.
- The Analytics packages. Think about how do you want to approach this and let us know
It doesn’t need to be the final process, we can start trying things out until we find one that suits both teams, of course.
A good first step would be creating an issue here for each one of these topics → https://github.com/frontity/docs/issues so you or any developer can add there any info you think it should be taken into account
From there we can start a conversation about each topic and create proper docs
Regarding “Slot and Fill” there’s this PR → https://github.com/frontity/docs/pull/90
When @Michael gets all the info I think some related docs about the “The Slot and Fill pattern” could emerge from that PR
Oh, I like it! Creating an issue would be way simpler than the workflow we have now, even for “API” updates. That way the dev-team wouldn’t depend on you to be able to merge the code PR.
We could have a label to mark the issues that are meant to be created with priority to keep code <-> docs in sync, and you could use that label to prioritize your tasks.
This would mean that instead of the somehow difficult process that we have now where we need to assign you in our PR, wait for you to create a Doc PR and finally mark the task as complete, it would be as simple as completing this task:
- [ ] Open an issue in the Documentation repo (and link it here).
We can use labels and even the description to complete the issue with useful information for the devrel team.
What do you think guys?
Yes, I think it’s much simple in this way
We have this labels already created to assign a priority to these issues.
Maybe you can just directly assign these issues a label →
priority: 2 high (along with any other labels you think it may help locate the issue better)
I have edited the PR template to reflect this change: https://github.com/frontity/frontity/commit/ca1414f89102d002f2a79f57e4b58759229d98b0
I have updated the workflow description in the WIKI:
Hey guys, I’d love if you could check out this PR and give feedback here about how the TSDocs for the
types.ts file of a Frontity package can look like.
- What do you think?
- Do you do something different?
- Is it useful for you?
- Do you want us to do something different?
I tried to do a simple change to a markdown file in my local environment and
prettier introduced a lot of changes to the format: https://github.com/frontity/docs/commit/16e81a482e23b28aec36485c58195e0df94328b5
I’ve reviewed the PR that @luisherranz has made:
I think it looks great, I have only noticed one thing that I think we should all agree on.
In TSDocs or in Documentation, when describing a method, I think we should be adding the
() after the method name. Right now, we write it like (examples from current TSDocs):
An object that will be used in each call to the REST API when using
actions.source.fetchwith the default handlers.
Usually returned from
api.get, but can also be the one returned by
Especially in the second example, it might not be clear to a new user that
fetch are both methods and not some kind of getter or flag.
We’re not using prettier for code examples in markdown files. But I think we should.
We should add a prettier configuration file so we all use the same prettier configuration in the docs.
Which one are you using for frontity code?
Prettier without any configuration. It’s already in the package.json
You can add it to your
pre-commit hook if you want, using lint-staged using
prettier --write (https://github.com/okonet/lint-staged#running-multiple-commands-in-a-sequence)
Optionally, you can configure VS Code to run
prettier on file save with the “Format on save” option.
WordPress does it with the @since tag. For example:
/** * Checks if a block can be read. * * @since 5.0.0 * * @param WP_Post $post Post object that backs the block. * @return bool Whether the block can be read. */
In our case, it is not going to be that simple, because we don’t know the exact version that is going to be next, depending on the type of bump (minor or patch).
One idea would be to populate it with a
NEXT tag, for example, and run a script that replaces all the
NEXT tags with the bumped version of each package before the release.
We commit this:
/** * Do something. * * @since NEXT */
And a script does a commit before the release, once the
package.json files have been updated to replace all the
@since NEXT found with the
/** * Do something. * * @since 1.13.1 */
Maybe to not overengineer it we could use an
@after tag and add the current version.
For example, this means that this API is not available in version
1.13.1 or below. It is not as nice, but the final information is the same.
/** * Do something. * * @after 1.13.1 */
Any other ideas?
yeah, I think that’s really nice!
I think maybe it’s not even worth automating right now, because it might be more effort than it’s worth at the moment and it would be easier to just update the
@since tags manually after a release.
I think that the Final Implementation should in almost all cases be sufficient to create documentation based on it. In fact, I have lately used mostly the same text in both the github issue of the docs and the Final Implementation, for example when implementing
Thus, I propose that we centralize all the details in the Final Implemention post that would normally go into the github issue in the Docs repo. The issue in the github docs should then include just:
- the link to the PR
- the link to the FD
- any (optional) notes to the DevRel team about the feature that are beyond the scope of the FD. Those may be something like: “Let’s create a new section in the docs for this feature”, for example.
Totally agree @mmczaplinski Our end goal should be to improve the Final implementation post, with everything needed, so it is enough to fully understand each feature.
I like that. Let’s keep as much information as possible in the FDs
What is the status of this? Is this information available for all the methods yet? Is this somethings that is going to be applied gradually from now on?
Regarding API Reference documentation I finished checking what is going to be the new site for these docs → https://api.frontity.org/
For that review I have applied prettier to all the docs and included that in the pre-commit hook (so prettier will be automatically applied on every commit)
I have also created in the WIKI some Guidelines for API reference docs with the criteria I’ve followed to document every piece of information (syntax, arguments, types, is mandatory, …). These guidelines takes into account the constraints we have for working with gitbook.
Any feedback on these guidelines (how to properly document API) will be appreciated
None yet to be honest. We’ll try to make a decision this month when all the dev team is back from holidays (cc: @santosguillamot).
It looks great to me Juanma
@juanma now that the DevReal team is going to lead the development of the starter themes, I have a question for you: Will you use the same TSDocs standard that we use for the rest of the Frontity packages, or do you prefer to use another comment format/standard?
I am asking because we have our
eslint configured to require TSDocs for the theme files, and each time we edit a file we need to add proper TSDocs for the whole file (we are doing it that way to add TSDocs to our codebase progressively). So if you don’t plan to use TSDocs for the starter themes, it doesn’t make sense that we spend time with that, does it?