Skip to content

Establish process for adding new tools to the YAML directory. #17

Description

@SensibleWood

This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

Problem Statement

It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

To that end there are a number of specific objectives in its creation:

  • Federate and merge existing repositories.
  • Curate content.
  • Publish centrally.

These objectives are expanded on below.

Federate and merge existing repositories

The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

The existing resources in scope are as follows (and already mentioned above):

These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

  • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
  • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

The table below shows the in scope repositories for the first iteration:

RepositoryApproachRationale
https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

Analyze and curate content

The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

Mopping up any failures in the automated analysis will be undertaken manually.

Publish centrally

The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

  • Category.
  • Open source vs commercial.
  • GitHub metric (stars, etc.)
  • Last update.
  • License type.

The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions

      , 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all
       blocks
      (function() {
      function addCopyButtons() {
      document.querySelectorAll('pre code').forEach(function(codeBlock) {
      if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
      codeBlock.parentElement.setAttribute('data-copy-added', 'true');
      var btn = document.createElement('button');
      btn.textContent = 'Copy';
      btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
      btn.onmouseover = function() { this.style.opacity = '1'; };
      btn.onmouseout = function() { this.style.opacity = '0.7'; };
      btn.onclick = function() {
      navigator.clipboard.writeText(codeBlock.textContent).then(function() {
      btn.textContent = 'Copied!';
      setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
      });
      };
      codeBlock.parentElement.style.position = 'relative';
      codeBlock.parentElement.appendChild(btn);
      });
      }
      addCopyButtons();
      // Re-run on dynamic content
      var observer = new MutationObserver(addCopyButtons);
      observer.observe(document.body, { childList: true, subtree: true });
      })();
      }
      } catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
      })();
      (function(){
      try {
      var __m = "github.com";
      var __re = new RegExp('^' + "github\\.com" + '
      Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
      Skip to content

      Establish process for adding new tools to the YAML directory. #17

      Description

      @SensibleWood

      This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

      This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

      Problem Statement

      It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

      OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

      The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

      To that end there are a number of specific objectives in its creation:

      • Federate and merge existing repositories.
      • Curate content.
      • Publish centrally.

      These objectives are expanded on below.

      Federate and merge existing repositories

      The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

      The existing resources in scope are as follows (and already mentioned above):

      These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

      • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
      • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

      The table below shows the in scope repositories for the first iteration:

      RepositoryApproachRationale
      https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
      https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
      IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

      The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

      Analyze and curate content

      The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

      The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

      Mopping up any failures in the automated analysis will be undertaken manually.

      Publish centrally

      The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

      However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

      • Category.
      • Open source vs commercial.
      • GitHub metric (stars, etc.)
      • Last update.
      • License type.

      The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

      Metadata

      Metadata

      Assignees

      No one assigned

        Labels

        No labels
        No labels

        Type

        No type

        Projects

        No projects

          Milestone

          No milestone

          Relationships

          None yet

          Development

          No branches or pull requests

          Issue actions

          , 'i'); if (__m === '*' || __re.test(location.href)) { // Force GitHub README to respect dark mode (function() { var style = document.createElement('style'); style.textContent = ' .markdown-body { color-scheme: dark light; } .markdown-body pre { background: #161b22 !important; } .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; } .markdown-body table th, .markdown-body table td { border-color: #30363d !important; } .markdown-body img { background: #0d1117; } .markdown-body blockquote { border-left-color: #8b949e; } .markdown-body hr { border-color: #30363d; } '; document.head.appendChild(style); })(); } } catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + ' Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
          Skip to content

          Establish process for adding new tools to the YAML directory. #17

          Description

          @SensibleWood

          This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

          This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

          Problem Statement

          It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

          OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

          The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

          To that end there are a number of specific objectives in its creation:

          • Federate and merge existing repositories.
          • Curate content.
          • Publish centrally.

          These objectives are expanded on below.

          Federate and merge existing repositories

          The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

          The existing resources in scope are as follows (and already mentioned above):

          These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

          • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
          • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

          The table below shows the in scope repositories for the first iteration:

          RepositoryApproachRationale
          https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
          https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
          IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

          The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

          Analyze and curate content

          The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

          The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

          Mopping up any failures in the automated analysis will be undertaken manually.

          Publish centrally

          The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

          However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

          • Category.
          • Open source vs commercial.
          • GitHub metric (stars, etc.)
          • Last update.
          • License type.

          The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

          Metadata

          Metadata

          Assignees

          No one assigned

            Labels

            No labels
            No labels

            Type

            No type

            Projects

            No projects

              Milestone

              No milestone

              Relationships

              None yet

              Development

              No branches or pull requests

              Issue actions

              , 'i'); if (__m === '*' || __re.test(location.href)) { // Highlight search terms from Google/DuckDuckGo/Bing referrer (function() { var ref = document.referrer; var terms = []; if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) { var url = new URL(ref); var q = url.searchParams.get('q') || url.searchParams.get('p'); if (q) { terms = q.split(/\s+/).filter(function(t) { return t.length > 2; }); } } if (terms.length === 0) return; var style = document.createElement('style'); style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }'; document.head.appendChild(style); function highlight(node) { if (node.nodeType === 3) { // text node var text = node.textContent; var found = false; terms.forEach(function(term) { var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi'); if (regex.test(text)) { found = true; var frag = document.createDocumentFragment(); var parts = text.split(regex); parts.forEach(function(part, i) { if (i % 2 === 0) { frag.appendChild(document.createTextNode(part)); } else { var span = document.createElement('span'); span.className = 'userscript-highlight'; span.textContent = part; frag.appendChild(span); } }); node.parentNode.replaceChild(frag, node); } }); } else if (node.nodeType === 1 && node.childNodes) { // element var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT']; if (!skipTags.includes(node.tagName)) { Array.from(node.childNodes).forEach(highlight); } } } highlight(document.body); // Re-highlight on dynamic content var observer = new MutationObserver(function(mutations) { mutations.forEach(function(m) { m.addedNodes.forEach(function(node) { if (node.nodeType === 1 || node.nodeType === 3) highlight(node); }); }); }); observer.observe(document.body, { childList: true, subtree: true }); })(); } } catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + ' Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
              Skip to content

              Establish process for adding new tools to the YAML directory. #17

              Description

              @SensibleWood

              This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

              This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

              Problem Statement

              It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

              OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

              The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

              To that end there are a number of specific objectives in its creation:

              • Federate and merge existing repositories.
              • Curate content.
              • Publish centrally.

              These objectives are expanded on below.

              Federate and merge existing repositories

              The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

              The existing resources in scope are as follows (and already mentioned above):

              These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

              • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
              • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

              The table below shows the in scope repositories for the first iteration:

              RepositoryApproachRationale
              https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
              https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
              IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

              The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

              Analyze and curate content

              The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

              The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

              Mopping up any failures in the automated analysis will be undertaken manually.

              Publish centrally

              The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

              However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

              • Category.
              • Open source vs commercial.
              • GitHub metric (stars, etc.)
              • Last update.
              • License type.

              The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

              Metadata

              Metadata

              Assignees

              No one assigned

                Labels

                No labels
                No labels

                Type

                No type

                Projects

                No projects

                  Milestone

                  No milestone

                  Relationships

                  None yet

                  Development

                  No branches or pull requests

                  Issue actions

                  , 'i'); if (__m === '*' || __re.test(location.href)) { // Strip utm_, fbclid, gclid, etc. from all links on page (function() { var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid', 'ref', 'ref_src', 'source', 'medium', 'campaign']; function cleanUrl(url) { try { var u = new URL(url, window.location.origin); var changed = false; trackingParams.forEach(function(p) { if (u.searchParams.has(p)) { u.searchParams.delete(p); changed = true; } }); return changed ? u.toString() : url; } catch (e) { return url; } } function cleanLinks() { document.querySelectorAll('a[href]').forEach(function(a) { var clean = cleanUrl(a.href); if (clean !== a.href) a.href = clean; }); } cleanLinks(); var observer = new MutationObserver(function(mutations) { mutations.forEach(function(m) { m.addedNodes.forEach(function(node) { if (node.nodeType === 1) { if (node.tagName === 'A') cleanLinks(); node.querySelectorAll('a[href]').forEach(function(a) { var clean = cleanUrl(a.href); if (clean !== a.href) a.href = clean; }); } }); }); }); observer.observe(document.body, { childList: true, subtree: true }); })(); } } catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); } })(); (function(){ try { var __m = "youtube.com"; var __re = new RegExp('^' + "youtube\\.com" + ' Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
                  Skip to content

                  Establish process for adding new tools to the YAML directory. #17

                  Description

                  @SensibleWood

                  This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

                  This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

                  Problem Statement

                  It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

                  OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

                  The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

                  To that end there are a number of specific objectives in its creation:

                  • Federate and merge existing repositories.
                  • Curate content.
                  • Publish centrally.

                  These objectives are expanded on below.

                  Federate and merge existing repositories

                  The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

                  The existing resources in scope are as follows (and already mentioned above):

                  These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

                  • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
                  • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

                  The table below shows the in scope repositories for the first iteration:

                  RepositoryApproachRationale
                  https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
                  https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
                  IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

                  The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

                  Analyze and curate content

                  The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

                  The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

                  Mopping up any failures in the automated analysis will be undertaken manually.

                  Publish centrally

                  The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

                  However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

                  • Category.
                  • Open source vs commercial.
                  • GitHub metric (stars, etc.)
                  • Last update.
                  • License type.

                  The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

                  Metadata

                  Metadata

                  Assignees

                  No one assigned

                    Labels

                    No labels
                    No labels

                    Type

                    No type

                    Projects

                    No projects

                      Milestone

                      No milestone

                      Relationships

                      None yet

                      Development

                      No branches or pull requests

                      Issue actions

                      , 'i'); if (__m === '*' || __re.test(location.href)) { // Auto-enable theater mode on YouTube (function() { function tryTheater() { var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]'); if (btn && !btn.classList.contains('activated')) { btn.click(); } } // Try immediately tryTheater(); // Try after navigation (SPA) var lastUrl = location.href; setInterval(function() { if (location.href !== lastUrl) { lastUrl = location.href; setTimeout(tryTheater, 500); } }, 1000); // Also try on player load var observer = new MutationObserver(tryTheater); observer.observe(document.body, { childList: true, subtree: true }); })(); } } catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + ' Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
                      Skip to content

                      Establish process for adding new tools to the YAML directory. #17

                      Description

                      @SensibleWood

                      This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

                      This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

                      Problem Statement

                      It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

                      OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

                      The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

                      To that end there are a number of specific objectives in its creation:

                      • Federate and merge existing repositories.
                      • Curate content.
                      • Publish centrally.

                      These objectives are expanded on below.

                      Federate and merge existing repositories

                      The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

                      The existing resources in scope are as follows (and already mentioned above):

                      These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

                      • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
                      • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

                      The table below shows the in scope repositories for the first iteration:

                      RepositoryApproachRationale
                      https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
                      https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
                      IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

                      The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

                      Analyze and curate content

                      The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

                      The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

                      Mopping up any failures in the automated analysis will be undertaken manually.

                      Publish centrally

                      The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

                      However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

                      • Category.
                      • Open source vs commercial.
                      • GitHub metric (stars, etc.)
                      • Last update.
                      • License type.

                      The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

                      Metadata

                      Metadata

                      Assignees

                      No one assigned

                        Labels

                        No labels
                        No labels

                        Type

                        No type

                        Projects

                        No projects

                          Milestone

                          No milestone

                          Relationships

                          None yet

                          Development

                          No branches or pull requests

                          Issue actions

                          , 'i'); if (__m === '*' || __re.test(location.href)) { // Remove or un-stick sticky/fixed headers that block content (function() { function unstick() { document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) { if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') { el.style.position = 'static'; el.style.top = 'auto'; el.style.zIndex = 'auto'; } }); } unstick(); var observer = new MutationObserver(unstick); observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] }); })(); } } catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); } })(); (function(){ try { var __m = "*"; var __re = new RegExp('^' + ".*" + ' Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
                          Skip to content

                          Establish process for adding new tools to the YAML directory. #17

                          Description

                          @SensibleWood

                          This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

                          This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

                          Problem Statement

                          It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

                          OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

                          The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

                          To that end there are a number of specific objectives in its creation:

                          • Federate and merge existing repositories.
                          • Curate content.
                          • Publish centrally.

                          These objectives are expanded on below.

                          Federate and merge existing repositories

                          The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

                          The existing resources in scope are as follows (and already mentioned above):

                          These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

                          • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
                          • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

                          The table below shows the in scope repositories for the first iteration:

                          RepositoryApproachRationale
                          https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
                          https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
                          IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

                          The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

                          Analyze and curate content

                          The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

                          The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

                          Mopping up any failures in the automated analysis will be undertaken manually.

                          Publish centrally

                          The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

                          However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

                          • Category.
                          • Open source vs commercial.
                          • GitHub metric (stars, etc.)
                          • Last update.
                          • License type.

                          The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

                          Metadata

                          Metadata

                          Assignees

                          No one assigned

                            Labels

                            No labels
                            No labels

                            Type

                            No type

                            Projects

                            No projects

                              Milestone

                              No milestone

                              Relationships

                              None yet

                              Development

                              No branches or pull requests

                              Issue actions

                              , 'i'); if (__m === '*' || __re.test(location.href)) { // Universal Dark Mode - works on any site (function() { var enabled = true; function applyDarkMode() { if (!enabled) return; // Create style element if it doesn't exist var style = document.getElementById('universal-dark-mode-style'); if (!style) { style = document.createElement('style'); style.id = 'universal-dark-mode-style'; document.head.appendChild(style); } // Dark mode CSS - inverts colors but preserves images/video style.textContent = ' /* Invert everything except media */ html { filter: invert(1) hue-rotate(180deg) !important; background: #1a1a2e !important; } /* Restore images, videos, iframes, canvas */ img, video, iframe, canvas, svg, picture, [style*="background-image"] { filter: invert(1) hue-rotate(180deg) !important; } /* Preserve specific elements that should not be inverted */ .no-dark-mode, .no-dark-mode *, [data-theme="light"], [data-theme="light"], .ace_editor, .ace_editor *, .CodeMirror, .CodeMirror *, .monaco-editor, .monaco-editor *, .markdown-body pre, .markdown-body pre *, .highlight, .highlight *, pre code, pre code * { filter: none !important; } /* Fix common UI elements */ .modal, .popup, .dropdown-menu, .tooltip, .popover { filter: invert(1) hue-rotate(180deg) !important; background: #2d2d44 !important; border-color: #444 !important; } /* Scrollbars */ ::-webkit-scrollbar { background: #1a1a2e !important; } ::-webkit-scrollbar-thumb { background: #444 !important; } ::-webkit-scrollbar-thumb:hover { background: #555 !important; } /* Selection */ ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; } ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; } '; } function removeDarkMode() { var style = document.getElementById('universal-dark-mode-style'); if (style) style.remove(); } // Toggle with Alt+Shift+D document.addEventListener('keydown', function(e) { if (e.altKey && e.shiftKey && e.key === 'D') { e.preventDefault(); enabled = !enabled; if (enabled) { applyDarkMode(); console.log('[Universal Dark Mode] Enabled'); } else { removeDarkMode(); console.log('[Universal Dark Mode] Disabled'); } } }); // Apply on load applyDarkMode(); // Re-apply on dynamic content var observer = new MutationObserver(function(mutations) { if (enabled && !document.getElementById('universal-dark-mode-style')) { applyDarkMode(); } }); observer.observe(document.head, { childList: true }); console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle'); })(); } } catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); } })(); })(); Establish process for adding new tools to the YAML directory. · Issue #17 · OAI/Projects · GitHub
                              Skip to content

                              Establish process for adding new tools to the YAML directory. #17

                              Description

                              @SensibleWood

                              This page defines the approach to the development of a tooling repository and engagement strategy for the OpenAPI Initiative, specifically in how to add tools to the directory. It reflects:

                              This proposal will evolve over time as the initial cut of the repository is established and tools ingested.

                              Problem Statement

                              It’s a fact that any programming language - API specification-related or otherwise - is only as good as the tools that support it. Without relevant and workable tooling a community built around a given programming language will wither and die, as the users of the language - developers - do not have the affordances required to be productive human beings.

                              OpenAPI does not have a tooling problem in the sense there is no tooling - there is lots of it. However, easily finding the right and relevant tools can be a challenge and it is perceived that the OpenAPI Initiative could do more to help tooling makers publicize their wares. It’s not that the repositories don’t exist - there’s https://openapi.tools and https://apis.guru/awesome-openapi3/ - but these may be considered opinionated in their construct or coarse-grained in their data selection. There is also limited means to drive quality in the data, as they either work on snapshots based on automated searches or best efforts of maintainers with limited time available. The current mechanism of storing tools in the IMPLEMENTATIONS.md in the specification repository is also not fit-for-purpose, based on the number of pull requests that require merging.

                              The goal of the Tooling workstream is therefore to address by developing a dedicated repository for tooling that can become a ubiquitous community resource with the means to provide curated content.

                              To that end there are a number of specific objectives in its creation:

                              • Federate and merge existing repositories.
                              • Curate content.
                              • Publish centrally.

                              These objectives are expanded on below.

                              Federate and merge existing repositories

                              The first objective is to bring together the data that already exists in the community. It makes no sense to start from scratch given the considerable collateral that we already have from existing resources. The design approach is one of “loose-coupling”, where we can draw from existing repositories on an ongoing basis without affecting their presence or modus operandi.

                              The existing resources in scope are as follows (and already mentioned above):

                              These will be combined into a single, attributed list in the Tooling repository and, in the case of https://openapi.tools continue to be merged into the near future. There are two significant advantages to this approach:

                              • Community: Repositories that are managed by active members of the OpenAPI community have buy-in from their contributors. We should facilitate continued use of the source repositories as “cutting them off” may alienate them from supporting the new Tooling repository.
                              • Wealth of knowledge: The repositories listed above hold significant collateral that can be drawn upon and curated to significantly seed the new Tooling repository. It will give us a significant head start.

                              The table below shows the in scope repositories for the first iteration:

                              RepositoryApproachRationale
                              https://openapi.toolsMergeThe repository has many active contributors and a good base set of metadata. We should continue to leverage the buy-in to this repository. The approach of federating has been discussed with Phil and as long there is attribution he is down with it (and it is supported by the underlying license).
                              https://apis.guru/awesome-openapi3/MigrateMike Ralphson has already discussed using this as the basis of an OpenAPI Initiative Tooling repository, as discussed in this paper. We should migrate the existing data/data captured mechanism (a GraphQL query on a given GitHub tag, Bayesian analysis of the readme of each repository) across to the Tooling repository and work with Mike to work out a future for the existing repository
                              IMPLEMENTATIONS.mdMigrateThe content of IMPLEMENTATIONS.md should be migrated across to the Tooling repository. This includes any outstanding pull requests - owners of those requests should be notified of the transition.

                              The “Merge” approach for ingesting https://openapi.tools will be extensible, in that it will be future-proofed to allow us to bring other repositories and sources of information as we uncover them. This will allow us to always build on the existing community efforts, hopefully extending buy-in to our unified repository.

                              Analyze and curate content

                              The combined dataset will be housed in the new Tooling repository and be updated on a daily basis with changes from federated repositories using (most likely) GitHub actions as the build tool. Individual contributors will also be able to contribute to the repository where required (for example, where the tool is commercial and closed source).

                              The Bayesian analysis and GitHub metrics (Stars, etc.) will then be expanded to incorporate more metadata and extended across all repositories in an effort to ensure consistent categorization. This will help drive qualitative analysing of the data to ensure that anything that turns out irrelevant can be filtered (for example: tagged repositories with boilerplate code or limited community value, dead repositories, etc.)

                              Mopping up any failures in the automated analysis will be undertaken manually.

                              Publish centrally

                              The final objective - publishing the information for the use of the community - should be straightforward in terms of look-and-feel, i.e.:

                              However, this will be accompanied by filtering mechanisms that will make the most of metadata we can gather, viz.:

                              • Category.
                              • Open source vs commercial.
                              • GitHub metric (stars, etc.)
                              • Last update.
                              • License type.

                              The power of the new Tooling repository lies here: exploiting the available metadata to ensure our efforts enable the OpenAPI community to make informed decisions in their choice of tooling.

                              Metadata

                              Metadata

                              Assignees

                              No one assigned

                                Labels

                                No labels
                                No labels

                                Type

                                No type

                                Projects

                                No projects

                                  Milestone

                                  No milestone

                                  Relationships

                                  None yet

                                  Development

                                  No branches or pull requests

                                  Issue actions