cut a v2.1.0 release (#2354)

closes #2342

.circleci/config.yml

@@ -0,0 +1,259 @@
+version: 2
+
+jobs:
+  npm-install:
+    docker:
+      - image: circleci/node:8
+    steps:
+      - checkout
+
+      - restore_cache:
+          keys:
+          - v2-dependencies-{{ checksum "package.json" }}
+          # fallback to using the latest cache if no exact match is found
+          - v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - save_cache:
+          paths:
+            - node_modules
+          key: v2-dependencies-{{ checksum "package.json" }}
+
+  main:
+    docker:
+      - image: circleci/node:8
+      - image: redis
+    steps:
+      - checkout
+
+      - restore_cache:
+          key: v2-dependencies-{{ checksum "package.json" }}
+          # https://github.com/badges/shields/issues/1937
+          key: v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Linter
+          when: always
+          command: npm run lint
+
+      - run:
+          name: Server unit tests
+          when: always
+          command: npm run test:js:server
+
+      - run:
+          name: Integration tests
+          when: always
+          command: npm run test:integration
+
+      - run:
+          name: Tests for gh-badges package
+          when: always
+          command: npm run test:js:package
+
+      - run:
+          name: 'Prettier check (quick fix: `npm run prettier`)'
+          when: always
+          command: npm run prettier-check
+
+  main@node-latest:
+    docker:
+      - image: circleci/node:latest
+      - image: redis
+    steps:
+      - checkout
+
+      - restore_cache:
+          key: v2-dependencies-{{ checksum "package.json" }}
+          # https://github.com/badges/shields/issues/1937
+          key: v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Linter
+          when: always
+          command: npm run lint
+
+      - run:
+          name: Server unit tests
+          when: always
+          command: npm run test:js:server
+
+      - run:
+          name: Integration tests
+          when: always
+          command: npm run test:integration
+
+      - run:
+          name: Tests for gh-badges package
+          when: always
+          command: npm run test:js:package
+
+      - run:
+          name: 'Prettier check (quick fix: `npm run prettier`)'
+          when: always
+          command: npm run prettier-check
+
+  danger:
+    docker:
+      - image: circleci/node:8
+    steps:
+      - checkout
+
+      - restore_cache:
+          key: v2-dependencies-{{ checksum "package.json" }}
+          # https://github.com/badges/shields/issues/1937
+          key: v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Danger
+          when: always
+          command: npm run danger ci
+
+  frontend:
+    docker:
+      - image: circleci/node:8
+    steps:
+      - checkout
+
+      - restore_cache:
+          key: v2-dependencies-{{ checksum "package.json" }}
+          # https://github.com/badges/shields/issues/1937
+          key: v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Frontend unit tests
+          when: always
+          command: npm run test:js:frontend
+
+      - run:
+          name: Frontend build completes successfully
+          when: always
+          command: npm run build
+
+  services:
+    docker:
+      - image: circleci/node:8
+    steps:
+      - checkout
+
+      - run:
+          name: Prepare service tests
+          command: |
+            mkdir private
+            echo "{\"gh_token\":\"$GITHUB_TOKEN\"}" > private/secret.json
+
+      - restore_cache:
+          key: v2-dependencies-{{ checksum "package.json" }}
+          # https://github.com/badges/shields/issues/1937
+          key: v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Identify services tagged in the PR title
+          command: |
+            if [[ ! -z $CI_PULL_REQUEST ]]; then
+              npm run test:services:pr:prepare
+            else
+              echo 'This is not a pull request. Skipping.'
+            fi
+
+      - run:
+          name: Run tests for tagged services
+          command: |
+            if [[ ! -z $CI_PULL_REQUEST ]]; then
+              npm run test:services:pr:run
+            else
+              echo 'This is not a pull request. Skipping.'
+            fi
+
+  services@node-latest:
+    docker:
+      - image: circleci/node:latest
+    steps:
+      - checkout
+
+      - run:
+          name: Prepare service tests
+          command: |
+            mkdir private
+            echo "{\"gh_token\":\"$GITHUB_TOKEN\"}" > private/secret.json
+
+      - restore_cache:
+          key: v2-dependencies-{{ checksum "package.json" }}
+          # https://github.com/badges/shields/issues/1937
+          key: v2-dependencies-
+
+      - run:
+          name: Install dependencies
+          command: npm install
+
+      - run:
+          name: Identify services tagged in the PR title
+          command: |
+            if [[ ! -z $CI_PULL_REQUEST ]]; then
+              npm run test:services:pr:prepare
+            else
+              echo 'This is not a pull request. Skipping.'
+            fi
+
+      - run:
+          name: Run tests for tagged services
+          command: |
+            if [[ ! -z $CI_PULL_REQUEST ]]; then
+              npm run test:services:pr:run
+            else
+              echo 'This is not a pull request. Skipping.'
+            fi
+
+workflows:
+  version: 2
+
+  on-commit:
+    jobs:
+      - npm-install:
+          filters:
+            branches:
+              ignore: gh-pages
+      - main:
+          requires:
+            - npm-install
+      - main@node-latest:
+          requires:
+            - npm-install
+      - frontend:
+          requires:
+            - npm-install
+      - services:
+          requires:
+            - npm-install
+      - services@node-latest:
+          requires:
+            - npm-install
+      - danger:
+          requires:
+            - npm-install
+          filters:
+            branches:
+              ignore: /dependabot\/.*/

.dockerignore

@@ -0,0 +1,4 @@
+node_modules/
+shields.env
+.git/
+.gitignore

.eslintignore

@@ -0,0 +1,3 @@
+/build
+/coverage
+/__snapshots__

.eslintrc-frontend.yml

@@ -0,0 +1,24 @@
+env:
+  browser: true
+
+plugins:
+  - import
+
+parser: "babel-eslint"
+
+parserOptions:
+  sourceType: "module"
+
+extends:
+  - "standard-jsx"
+  - "standard-react"
+  - "./.eslintrc.yml"
+
+settings:
+  react:
+    version: "16.4"
+
+rules:
+  no-console: "error"
+
+  import/extensions: ["error", "never", { "json": "always" }]

.eslintrc.yml

@@ -0,0 +1,49 @@
+extends:
+  - standard
+  - prettier
+
+env:
+  node: true
+  mocha: true
+
+parserOptions:
+  # Override eslint-config-standard, which incorrectly sets this to "module",
+  # though that setting is only for ES6 modules, not CommonJS modules.
+  sourceType: "script"
+
+plugins:
+  - mocha
+  - no-extension-in-require
+  - "chai-friendly"
+
+rules:
+  # Disable some rules from eslint:recommended.
+  no-console: "off"
+  no-empty: ["error", { "allowEmptyCatch": true }]
+  # Allow unused parameters. In callbacks, removing them seems to obscure
+  # what the functions are doing.
+  no-unused-vars: ["error", {"args": "none"}]
+
+  # These should be disabled by eslint-config-prettier, but are not.
+  spaced-comment: "off"
+  standard/object-curly-even-spacing: "off"
+  one-var: "off"
+
+  # Shields additions.
+  no-var: "error"
+  prefer-const: "error"
+  strict: "error"
+  arrow-body-style: ["error", "as-needed"]
+  no-extension-in-require/main: "error"
+  object-shorthand: ["error", "properties"]
+  prefer-template: "error"
+  promise/prefer-await-to-then: "error"
+
+  # Mocha-related.
+  mocha/no-exclusive-tests: "error"
+  mocha/no-mocha-arrows: "error"
+  mocha/prefer-arrow-callback: "error"
+
+  # Chai friendly.
+  no-unused-expressions: "off"
+  chai-friendly/no-unused-expressions: "error"

.github/ISSUE_TEMPLATE/1_Bug_report.md

@@ -0,0 +1,26 @@
+---
+name: 🐛 Bug Report
+about: Report errors and problems
+
+---
+
+Are you experiencing an issue with...
+ - [ ] [shields.io](https://shields.io/#/)
+ - [ ] My own instance
+ - [ ] [gh-badges NPM package](https://www.npmjs.com/package/gh-badges)
+
+:beetle: **Description**
+<!-- A clear and concise description of the problem. -->
+
+:link: **Link to the badge**
+<!--
+If you are reporting a problem with a specific badge on shields.io,
+provide a link to a badge demonstrating the error
+-->
+
+:bulb: **Possible Solution**
+<!--- Optional: only if you have suggestions on a fix/reason for the bug -->
+
+
+<!-- Love Shields? Please consider donating $10 to sustain our activities:
+👉  https://opencollective.com/shields -->

.github/ISSUE_TEMPLATE/2_Badge_request.md

@@ -0,0 +1,28 @@
+---
+name: 💡 Badge Request
+about: Ideas for new badges
+
+---
+
+:clipboard: **Description**
+<!--
+A clear and concise description of the new badge.
+
+- Which service is this badge for e.g: GitHub, Travis CI
+- What sort of information should this badge show?
+  Provide an example in plain text e.g: "version | v1.01" or as a static badge
+  (static badge generator can be found at https://shields.io)
+-->
+
+:link: **Data**
+<!--
+Where can we get the data from?
+
+- Is there a public API?
+- Does the API requires an API key?
+- Link to the API documentation.
+-->
+
+
+<!-- Love Shields? Please consider donating $10 to sustain our activities:
+👉  https://opencollective.com/shields -->

.github/ISSUE_TEMPLATE/3_Feature_request.md

@@ -0,0 +1,12 @@
+---
+name: 💡 Feature Request
+about: Ideas for other new features or improvements
+
+---
+
+:clipboard: **Description**
+<!-- A clear and concise description of the new feature. -->
+
+
+<!-- Love Shields? Please consider donating $10 to sustain our activities:
+👉  https://opencollective.com/shields -->

.github/ISSUE_TEMPLATE/4_Support_question.md

@@ -0,0 +1,17 @@
+---
+name: ❓ Support Question
+about: Ask a question about shields.io
+
+---
+
+:question: **Question**
+<!--
+Ask your question clearly and concisely.
+
+#support on our [Discord](https://discordapp.com/invite/HjJCwm5)
+is also a great place to ask questions and get help
+-->
+
+
+<!-- Love Shields? Please consider donating $10 to sustain our activities:
+👉  https://opencollective.com/shields -->

.github/probot.js

@@ -0,0 +1,10 @@
+on('pull_request.closed')
+  .filter(context => context.payload.pull_request.merged)
+  .filter(
+    context =>
+      context.payload.pull_request.head.ref.slice(0, 11) !== 'dependabot/'
+  )
+  .filter(context => context.payload.pull_request.base.ref === 'master')
+  .comment(`This pull request was merged to [{{ pull_request.base.ref }}]({{ repository.html_url }}/tree/{{ pull_request.base.ref }}) branch. This change is now waiting for deployment, which will usually happen within a few days. Stay tuned by joining our \`#ops\` channel on [Discord](https://discordapp.com/invite/HjJCwm5)!
+  
+After deployment, changes are copied to [gh-pages]({{ repository.html_url }}/tree/gh-pages) branch: ![](https://img.shields.io/github/commit-status/{{ repository.full_name }}/gh-pages/{{ pull_request.merge_commit_sha }}.svg?label=deploy%20status)`)

.gitignore

@@ -4,11 +4,10 @@
 /coverage.html
 /redis
 /ServerScript
-/secret.json
-/.github-user-tokens.json
-
-# Installed npm modules
-node_modules
+/private
+/index.html
+/shields.env
+gh-badges/package-lock.json
 
 # Folder view configuration files
 .DS_Store
@@ -18,6 +17,78 @@ Desktop.ini
 ._*
 Thumbs.db
 
+# eclipse
+.project
+.settings
+
 # Files that might appear on external disks
 .Spotlight-V100
 .Trashes
+
+# Jetbrains
+/.idea
+
+# Created by https://www.gitignore.io/api/node
+
+### Node ###
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Typescript v1 declaration files
+typings/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+# Temporary build artifacts.
+/build
+.next
+badge-examples.json
+supported-features.json

.nycrc.json

@@ -0,0 +1,16 @@
+{
+  "reporter": ["lcov"],
+  "all": true,
+  "exclude": [
+    "**/*.spec.js",
+    "**/*.integration.js",
+    "dangerfile.js",
+    "services/**/*.tester.js",
+    "test-fixtures",
+    "scripts",
+    "coverage",
+    "build"
+  ],
+  "silent": true,
+  "clean": false
+}

.prettierignore

@@ -0,0 +1,8 @@
+package.json
+package-lock.json
+/__snapshots__
+/.next
+/build
+/coverage
+**/*.md
+private/*.json

.prettierrc.yml

@@ -0,0 +1,4 @@
+semi: false
+singleQuote: true
+trailingComma: es5
+bracketSpacing: true

.travis.yml

@@ -1,18 +0,0 @@
-before_install:
-  - sudo apt-get update -myqq
-  - sudo apt-get install libcairo2-dev libjpeg8-dev libpango1.0-dev libgif-dev build-essential g++
-language: node_js
-node_js:
-  - 6
-
-branches:
-  only:
-    - master
-
-notifications:
-  email:
-    - thaddee.tyl@gmail.com
-  irc: "irc.freenode.org#shields"
-
-git:
-  depth: 10

CNAME

@@ -1 +0,0 @@
-shields.io

CONTRIBUTING.md

@@ -1,65 +1,165 @@
-# Contribution Guidelines
+Contributing to Shields
+=======================
 
-This is the home of Shields.io, home to the badge design specification, API documentation, and server code for Badges as a Service.
+Shields is a community project. We invite your participation through
+financial contributions, issues, and pull requests!
 
-We invite participation through [GitHub Issues][], which we use much like a discussion forum. This repository should only contain non-implementation specific topics: specifications, design, and the web site.
 
-## This implementation
+Ways you can help
+-----------------
 
-Please see [INSTALL.md][] for information on how to start contributing code to
-shields.io.
+### Financial contributions
 
-[INSTALL.md]: ./INSTALL.md
+We welcome financial contributions in full transparency on our
+[open collective](https://opencollective.com/shields). Anyone can file an
+expense. If the expense makes sense for the development of the community, it
+will be "merged" into the ledger of our open collective by the core
+contributors and the person who filed the expense will be reimbursed.
 
-Note that the root gets redirected to <http://shields.io>.
-For testing purposes, you can go to `http://localhost/try.html`.
-You should modify that file. The "real" root, `http://localhost/index.html`,
-gets generated from the `try.html` file with a `make website`.
+### Contributing code
 
-## Ground rules
+This project has quite a backlog of suggestions! If you're new to the project,
+maybe you'd like to open a pull request to address one of them:
+
+[![GitHub issues by-label](https://img.shields.io/github/issues/badges/shields/good%20first%20issue.svg)](https://github.com/badges/shields/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
+
+### Contributing documentation
+
+You can help by improving the project's usage and developer instructions.
+
+- When you read the documentation, you can fix mistakes and add your own thoughts.
+- When your pull request follows the documentation but the practice changed,
+  consider pointing this out and change the documentation for the next person.
+
+### Helping others
+
+You can help with code review, which reduces bugs, and over time has a
+wonderful side effect of making the code more readable and therefore more
+approachable. It's also a great way to teach and learn. Feel free to jump in!
+Be welcoming, appreciative, and helpful. You can perform first reviews of
+simple changes, like badge additions. These are usually tagged with
+[service badge][service badge PR tag].
+
+Please review [these impeccable guidelines][code review guidelines].
+
+You can monitor [issues][] and the [chat room][], and help other people who
+have questions about contributing to Shields, or using it for their projects.
+
+Feel free to reach out to one of the [maintainers][]
+if you need help getting started.
+
+[service badge PR tag]: https://github.com/badges/shields/pulls?q=is%3Apr+is%3Aopen+label%3Aservice-badge
+[code review guidelines]: http://amyciavolino.com/assets/MindfulCommunicationInCodeReviews.pdf
+[issues]: https://github.com/badges/shields/issues
+[chat room]: https://discordapp.com/invite/HjJCwm5
+[maintainers]: https://github.com/badges/shields#project-leaders
+
+### Suggesting improvements
+
+There are _a lot_ of suggestions on file. You can help by weighing in on these
+suggestions, which helps convey community need to other contributors who might
+pick them up.
+
+There is no need to post a new comment. Just add a :thumbsup: or :heart: to
+the top post.
+
+If you have a suggestion of your own, [search the open issues][issues]. If you
+don't see it, feel free to [open a new issue][open an issue].
+
+[open an issue]: https://github.com/badges/shields/issues/new/choose
+
+### Spreading the word
+
+Feel free to star the repository. This will help increase the visibility of the project, therefore attracting more users and contributors to Shields!
+
+We're also asking for [one-time $10 donations](https://opencollective.com/shields) from developers who use and love Shields, please spread the word!
+
+Getting help
+------------
+
+There are three places to get help:
+
+1. If you're new to the project, a good place to start is the [tutorial][].
+2. If you need help getting started or implementing a change, [open an issue][]
+   with your question. We promise it's okay to do that. If there is already an
+   issue open for the feature you're working on, you can post there.
+3. You can also join the [chat room][] and ask your question there.
+
+[tutorial]: doc/TUTORIAL.md
+
+
+Badge guidelines
+----------------
+
+- Shields.io hosts integrations for services which are primarily
+  used by developers or which are widely used by developers
+- The left-hand side of a badge should not advertise. It should be a lowercase *noun*
+  succinctly describing the meaning of the right-hand side.
+- Query parameters must be *declared by the service*. See `request-handler.js`.
+- Except for badges using the `social` style, logos should be *turned off by
+  default*.
+
+
+Badge URLs
+----------
 
-- The left-hand side of a badge should not advertize. It should be a noun
-  describing succinctly the meaning of the right-hand-side data.
-- New query parameters (such as `?label=` or `?style=`) should apply to any
-  requested badge. They must be registered in the cache (see `LruCache` in
-  `server.js`).
 - The format of new badges should be of the form
-  `/VENDOR/SUBVENDOR-BADGE-SPECIFIC/PARAMETERS.format`. For instance,
-  `https://img.shields.io/gitter/room/nwjs/nw.js.svg`. The vendor is gitter, the
+  `/SERVICE/NOUN/PARAMETERS/QUALIFIERS.format`. For instance,
+  `/gitter/room/nwjs/nw.js.svg`. The vendor is gitter, the
   badge is for rooms, the parameter is nwjs/nw.js, and the format is svg.
-
-## Implementations
-
-The main implementation, available at <http://shields.io>, has its code located in this repository.
-
-Other systems that produce badges following the same design, hosted elsewhere, are listed below.
-
-| website / AP                      | language   | issues                       |
-| --------------------------------- | ---------- | ---------------------------- |
-| shielded                          | JavaScript | [shielded][shielded issues]  |
-| [buckler.repl.ca][]               | Go         | [buckler][buckler issues]    |
-| old img.shields.io (discontinued) | Python     | [img.shields.io-old][]       |
-| DotBadge                          | C#         | [DotBadge](https://github.com/rebornix/DotBadge/issues) |
-
-Please report **bugs** and discuss implementation specific concerns (performance characteristics, etc.) in the repository for the respective implementation.
-
-## Adding support for a service
-
-Please [open an issue][new issue] if you'd like to use Shields badges for a project that isn't yet supported.
+- For services which require a hostname, the badge should be of the form
+  `/SERVICE/SCHEME/HOST/NOUN/PARAMETERS/QUALIFIERS.format`. For instance,
+  `/discourse/https/discourse.example.com/topics.svg`.
 
 
-[shields.io]: http://shields.io/
-[website]: https://github.com/badges/shields/tree/gh-pages
-[GitHub Issues]: https://github.com/badges/shields/issues
-[new issue]: https://github.com/badges/shields/issues/new
+Coding guidelines
+-----------------
 
-[img.shields.io]: http://img.shields.io/
-[gh-badges issues]: https://github.com/badges/shields/issues
-[primary]: https://github.com/badges/shields/issues/94
+### Prettier
 
-[shielded issues]: https://github.com/badges/shielded/issues
+This project formats its source code using Prettier. The most enjoyable way to
+use Prettier is to let is format code for you when you save. You can [integrate
+it into your editor][integrate prettier].
 
-[buckler.repl.ca]: http://buckler.repl.ca/
-[buckler issues]: https://github.com/badges/buckler/issues
+Whether you integrate it into your editor or not, a pre-commit hook will run
+Prettier before a commit by default.
 
-[img.shields.io-old]: https://github.com/badges/img.shields.io-old/issues
+[integrate prettier]: https://prettier.io/docs/en/editors.html
+
+### Tests
+
+When adding or changing a service [please write tests][service-tests].
+
+When opening a pull request, include your service name in brackets in the pull
+request title. That way, those service tests will run in CI.
+
+e.g. **[Travis] Fix timeout issues**
+
+When changing other code, please add unit tests.
+
+To run the integration tests, you must have redis installed and in your PATH.
+Use `brew install redis`, `yum install redis`, etc. The test runner will
+start the server automatically.
+
+[service-tests]: https://github.com/badges/shields/blob/master/doc/service-tests.md
+
+### Code organization
+
+Function declarations are placed in `lib/`, not directly in `server.js`.
+
+
+Logos
+-----
+
+We support a wide range of logos via [SimpleIcons][] and encourage you to [contribute logos to that project][simple-icons github].
+
+We also accept logos directly. In general, we do this only when we have a corresponding badge on the homepage, (e.g. the Eclipse logo because we support service badges for the Eclipse Marketplace). We may also approve logos for tools widely used by developers (e.g. our Slack logo). We will happily consider all requests, but don't expect systematic approval, it's at the discretion of the maintainers.
+
+Please minimize checked-in SVG files through [SVGO][]. You can use [svgomg][].
+
+If you want to use a logo that does not meet our guidelines, a custom logo can be passed in a URL parameter by base64 encoding it. For example this badge ![](https://img.shields.io/badge/play-station-blue.svg?logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZlcnNpb249IjEiIHdpZHRoPSI2MDAiIGhlaWdodD0iNjAwIj48cGF0aCBkPSJNMTI5IDExMWMtNTUgNC05MyA2Ni05MyA3OEwwIDM5OGMtMiA3MCAzNiA5MiA2OSA5MWgxYzc5IDAgODctNTcgMTMwLTEyOGgyMDFjNDMgNzEgNTAgMTI4IDEyOSAxMjhoMWMzMyAxIDcxLTIxIDY5LTkxbC0zNi0yMDljMC0xMi00MC03OC05OC03OGgtMTBjLTYzIDAtOTIgMzUtOTIgNDJIMjM2YzAtNy0yOS00Mi05Mi00MmgtMTV6IiBmaWxsPSIjZmZmIi8+PC9zdmc+) could be generated by calling: https://img.shields.io/badge/play-station-blue.svg?logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZlcnNpb249IjEiIHdpZHRoPSI2MDAiIGhlaWdodD0iNjAwIj48cGF0aCBkPSJNMTI5IDExMWMtNTUgNC05MyA2Ni05MyA3OEwwIDM5OGMtMiA3MCAzNiA5MiA2OSA5MWgxYzc5IDAgODctNTcgMTMwLTEyOGgyMDFjNDMgNzEgNTAgMTI4IDEyOSAxMjhoMWMzMyAxIDcxLTIxIDY5LTkxbC0zNi0yMDljMC0xMi00MC03OC05OC03OGgtMTBjLTYzIDAtOTIgMzUtOTIgNDJIMjM2YzAtNy0yOS00Mi05Mi00MmgtMTV6IiBmaWxsPSIjZmZmIi8+PC9zdmc+
+
+[simpleicons]: https://simpleicons.org/
+[simple-icons github]: https://github.com/simple-icons/simple-icons
+[SVGO]: https://github.com/svg/svgo
+[svgomg]: https://jakearchibald.github.io/svgomg/

Dockerfile

@@ -1,3 +1,21 @@
-FROM node:0.12-onbuild
-ENV INFOSITE http://shields.io
+FROM node:8.9.4-alpine
+
+RUN apk add --no-cache gettext imagemagick librsvg git
+
+RUN mkdir -p /usr/src/app
+RUN mkdir /usr/src/app/private
+WORKDIR /usr/src/app
+
+ARG NODE_ENV
+ENV NODE_ENV $NODE_ENV
+COPY package.json /usr/src/app/
+RUN npm install
+COPY . /usr/src/app
+RUN npm run build
+RUN npm prune --production
+RUN npm cache clean --force
+
+CMD envsubst < secret.tpl.json > ./private/secret.json \
+ && node server
+
 EXPOSE 80

INSTALL.md

@@ -1,170 +0,0 @@
-# GitHub badges in SVG format
-
-[![npm version](http://img.shields.io/npm/v/gh-badges.svg)](https://npmjs.org/package/gh-badges)
-
-![coverage](https://rawgithub.com/badges/shields/master/coverage.svg)
-
-[![build status](http://img.shields.io/travis/badges/gh-badges.svg)](https://travis-ci.org/badges/gh-badges)
-
-Make your own badges [here][badges]! (Quick guide: `https://img.shields.io/badge/left-right-f39f37.svg`.)
-
-[badges]: <http://shields.io/#your-badge>
-
-# Install the API
-
-```bash
-npm install gh-badges
-```
-
-```js
-var badge = require('gh-badges');
-// Optional step, to have accurate text width computation.
-badge.loadFont('/path/to/Verdana.ttf', function(err) {
-  badge({ text: ["build", "passed"], colorscheme: "green", template: "flat" },
-    function(svg, err) {
-      // svg is a String of your badge.
-    });
-});
-```
-
-# Use the CLI
-
-```bash
-npm install -g gh-badges
-badge build passed :green .png > mybadge.png
-# Stored a PNG version of your badge on disk.
-```
-
-# Start the Server
-To run the server you will need the following executables on your Path:
-- [PhantomJS](http://www.phantomjs.org/)
-
-On an OS X machine, [Homebrew](brew.sh) is a good package manager that will
-allow you to install that.
-
-On Ubuntu / Debian: `sudo apt-get install phantomjs`.
-
-```bash
-git clone https://github.com/badges/shields.git
-cd shields
-npm install  # You may need sudo for this.
-sudo node server
-```
-
-The server uses port 80 by default, which requires `sudo` permissions.
-There are two ways to provide an alternate port:
-
-```bash
-PORT=8080 node server
-node server 8080
-```
-
-The root gets redirected to <http://shields.io>.
-For testing purposes, you can go to `http://localhost/try.html`.
-You should modify that file. The "real" root, `http://localhost/index.html`,
-gets generated from the `try.html` file.
-
-# Format
-
-The format is the following:
-
-```js
-{
-  /* Textual information shown, in order. */
-  "text": [ "build", "passed" ],
-  "format": "svg",  // Also supports "json".
-  "colorscheme": "green",
-  /* … Or… */
-  "colorA": "#555",
-  "colorB": "#4c1",
-  /* See template/ for a list of available templates.
-     Each offers a different visual design. */
-  "template": "flat"
-}
-```
-
-# Defaults
-
-If you want to add a colorscheme, head to `colorscheme.json`. Each scheme has a
-name and a [CSS/SVG color][] for the color used in the first box (for the first
-piece of text, field `colorA`) and for the one used in the second box (field
-`colorB`).
-
-[CSS/SVG color]: http://www.w3.org/TR/SVG/types.html#DataTypeColor
-
-```js
-"green": {
-  "colorB": "#4c1"
-}
-```
-
-Both `colorA` and `colorB` have default values. Usually, the first box uses the
-same dark grey, so you can rely on that default value by not providing a
-`"colorA"` field (such as above).
-
-You can also use the `"colorA"` and `"colorB"` fields directly in the badges if
-you don't want to make a color scheme for it. In that case, remove the
-`"colorscheme"` field altogether.
-
-# Making your Heroku badge server
-
-Once you have installed the [Heroku Toolbelt][]:
-
-[Heroku Toolbelt]: https://toolbelt.heroku.com/
-
-```bash
-heroku login
-heroku create your-app-name
-heroku config:set BUILDPACK_URL=https://github.com/mojodna/heroku-buildpack-multi.git#build-env
-cp /path/to/Verdana.ttf .
-make deploy
-heroku open
-```
-
-# Docker
-
-You can build and run the server locally using Docker. First build an image:
-
-```console
-$ docker build -t shields ./
-Sending build context to Docker daemon 3.923 MB
-Step 0 : FROM node:0.12.7-onbuild
-…
-Removing intermediate container c4678889953f
-Successfully built 4471b442c220
-```
-
-Then run the container:
-
-```console
-$ docker run --rm -p 8080:80 shields
-
-> gh-badges@1.1.2 start /usr/src/app
-> node server.js
-
-http://[::1]:80/try.html
-```
-
-Assuming Docker is running locally, you should be able to get to the application at http://localhost:8080/try.html. If you run Docker in a virtual machine (such as boot2docker or Docker Machine) then you will need to replace `localhost` with the actual IP address of that virtual machine.
-
-# Main Server Sysadmin
-
-- DNS round-robin between https://vps197850.ovh.net/try.html and https://vps244529.ovh.net/try.html.
-- Self-signed TLS certificates, but `img.shields.io` is behind CloudFlare, which provides signed certificates.
-- Using node v0.12.7 because later versions, combined with node-canvas, give inaccurate badge measurements.
-- Using forever (the node monitor) to automatically restart the server when it crashes.
-
-See https://github.com/badges/ServerScript for helper admin scripts.
-
-# Links
-
-See <https://github.com/h5bp/lazyweb-requests/issues/150> for a story of the
-project's inception.
-
-This is also available as a gem `badgerbadgerbadger`, [code here][gem].
-
-[gem]: https://github.com/badges/badgerbadgerbadger
-
-# License
-
-All work here is licensed CC0.

LICENSE

@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>

LICENSE.md

@@ -1,33 +0,0 @@
-# DEDICATED TO THE PUBLIC DOMAIN
-
-Shields has been dedicated to the public domain. It is protected by the Creative Commons CC0 Universal Public Domain Dedication license. You can read the entire license below or at http://creativecommons.org/publicdomain/zero/1.0/deed.en.
-
-# CC0 UNIVERSAL PUBLIC DOMAIN DEDICATION LICENSE
-
-## Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
-a. the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
-b. moral rights retained by the original author(s) and/or performer(s);
-c. publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
-rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
-d. rights protecting the extraction, dissemination, use and reuse of data in a Work;
-e. database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
-f. other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
-a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
-b. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
-c. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
-d. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.

Makefile

@@ -1,53 +1,76 @@
-all: website favicon test
+SHELL:=/bin/bash
 
-UNAME_S := $(shell uname -s)
-ifeq ($(UNAME_S),Linux)
-	SED=sed -r
-	NEWLINE=$\n
-endif
-ifeq ($(UNAME_S),Darwin)
-	SED=sed -E
-	NEWLINE=$$'\n'
-endif
+SERVER_TMP=${TMPDIR}shields-server-deploy
+FRONTEND_TMP=${TMPDIR}shields-frontend-deploy
 
-favicon:
-	node gh-badge.js '' '' '#bada55' .png > favicon.png
+# This branch is reserved for the deploy process and should not be used for
+# development. The deploy script will clobber it. To avoid accidentally
+# pushing secrets to GitHub, this branch is configured to reject pushes.
+WORKING_BRANCH=server-deploy-working-branch
+
+all: website test
 
 website:
-	cat try.html | $(SED) "s,(<img src=')(/[^'\?]+)',\1https://img.shields.io\2?maxAge=2592000'," \
-		| $(SED) "s,(<img src=')(/[^'\?]+\?[^']+)',\1https://img.shields.io\2\&maxAge=2592000'," \
-		| $(SED) "s,<span id='imgUrlPrefix'>,&https://img.shields.io," \
-		| $(SED) "s,var origin = '';,var origin = 'https://img.shields.io';," \
-		| $(SED) "s,<style>,<!-- WARNING: THIS FILE WAS GENERATED FROM try.html -->\\"$(NEWLINE)"<style>," > index.html
+	LONG_CACHE=false npm run build
 
-deploy: deploy-s0 deploy-s1 deploy-gh-pages
+deploy: deploy-s0 deploy-s1 deploy-s2 clean-server-deploy deploy-gh-pages deploy-gh-pages-clean
 
-deploy-s0:
-	git add -f Verdana.ttf
-	git add -f secret.json
-	git commit -m'MUST NOT BE ON GITHUB'
-	git push -f s0 HEAD:master
-	git reset HEAD~1
-	git checkout master
+deploy-s0: prepare-server-deploy push-s0
+deploy-s1: prepare-server-deploy push-s1
+deploy-s2: prepare-server-deploy push-s2
 
-deploy-s1:
-	git add -f Verdana.ttf
-	git add -f secret.json
-	git commit -m'MUST NOT BE ON GITHUB'
-	git push -f s1 HEAD:master
-	git reset HEAD~1
-	git checkout master
+prepare-server-deploy: website
+	# Ship a copy of the front end to each server for debugging.
+	# https://github.com/badges/shields/issues/1220
+	rm -rf ${SERVER_TMP}
+	git worktree prune
+	git worktree add -B ${WORKING_BRANCH} ${SERVER_TMP}
+	cp -r build ${SERVER_TMP}
+	git -C ${SERVER_TMP} add -f build/
+	git -C ${SERVER_TMP} commit --no-verify -m '[DEPLOY] Add frontend for debugging'
+	mkdir -p ${SERVER_TMP}/private
+	cp private/secret-production.json ${SERVER_TMP}/private/secret.json
+	git -C ${SERVER_TMP} add -f private/secret.json
+	git -C ${SERVER_TMP} commit --no-verify -m '[DEPLOY] MUST NOT BE ON GITHUB'
+
+clean-server-deploy:
+	rm -rf ${SERVER_TMP}
+	git worktree prune
+
+push-s0:
+	git push -f s0 ${WORKING_BRANCH}:master
+
+push-s1:
+	git push -f s1 ${WORKING_BRANCH}:master
+
+push-s2:
+	git push -f s2 ${WORKING_BRANCH}:master
 
 deploy-gh-pages:
-	(git checkout -B gh-pages && \
-	git merge master && \
-	git push -f origin gh-pages:gh-pages) || git checkout master
-	git checkout master
+	rm -rf ${FRONTEND_TMP}
+	git worktree prune
+	LONG_CACHE=true \
+		BASE_URL=https://img.shields.io \
+		NEXT_ASSET_PREFIX=https://shields.io \
+		npm run build
+	git worktree add -B gh-pages ${FRONTEND_TMP}
+	git -C ${FRONTEND_TMP} ls-files | xargs git -C ${FRONTEND_TMP} rm
+	git -C ${FRONTEND_TMP} commit --no-verify -m '[DEPLOY] Completely clean the index'
+	cp -r build/* ${FRONTEND_TMP}
+	cp favicon.png ${FRONTEND_TMP}
+	echo shields.io > ${FRONTEND_TMP}/CNAME
+	touch ${FRONTEND_TMP}/.nojekyll
+	git -C ${FRONTEND_TMP} add .
+	git -C ${FRONTEND_TMP} commit --no-verify -m '[DEPLOY] Add built site'
+	git push -f origin gh-pages
+
+deploy-gh-pages-clean:
+	rm -rf ${FRONTEND_TMP}
+	git worktree prune
 
 deploy-heroku:
-	git add -f Verdana.ttf
-	git add -f secret.json
-	git commit -m'MUST NOT BE ON GITHUB'
+	git add -f private/secret.json build/
+	git commit --no-verify -m'MUST NOT BE ON GITHUB'
 	git push -f heroku HEAD:master
 	git reset HEAD~1
 	(git checkout -B gh-pages && \
@@ -55,18 +78,7 @@ deploy-heroku:
 	git push -f origin gh-pages:gh-pages) || git checkout master
 	git checkout master
 
-setup:
-	curl http://download.redis.io/releases/redis-2.8.8.tar.gz >redis.tar.gz \
-	&& tar xf redis.tar.gz \
-	&& rm redis.tar.gz \
-	&& mv redis-2.8.8 redis \
-	&& cd redis \
-	&& make
-
-redis:
-	./redis/src/redis-server
-
 test:
 	npm test
 
-.PHONY: all favicon website deploy deploy-s0 deploy-s1 deploy-gh-pages deploy-heroku setup redis test
+.PHONY: all website deploy prepare-server-deploy clean-server-deploy deploy-s0 deploy-s1 deploy-s2 push-s0 push-s1 push-s2 deploy-gh-pages deploy-gh-pages-clean deploy-heroku setup redis test

Procfile

@@ -0,0 +1 @@
+web: node server

README.md

@@ -1,96 +1,232 @@
 <p align="center">
-    <img src="https://rawgit.com/badges/shields/master/logo.svg"
-         height="130">
+    <img src="https://rawgit.com/badges/shields/master/static/logo.svg"
+        height="130">
 </p>
 <p align="center">
-    <a href="https://www.gratipay.com/Shields/">
-        <img src="https://img.shields.io/gratipay/team/shields.svg"
-             alt="Gratipay">
-    </a>
-    <a href="https://npmjs.org/package/gh-badges">
-        <img src="https://img.shields.io/npm/v/gh-badges.svg"
-             alt="npm version">
-    </a>
-    <a href="https://travis-ci.org/badges/shields">
-        <img src="https://img.shields.io/travis/badges/shields.svg"
-             alt="build status">
-    </a>
+    <a href="#backers" alt="Backers on Open Collective">
+        <img src="https://opencollective.com/shields/backers/badge.svg" /></a>
+    <a href="#sponsors" alt="Sponsors on Open Collective">
+        <img src="https://opencollective.com/shields/sponsors/badge.svg" /></a>
+    <a href="https://circleci.com/gh/badges/shields/tree/master">
+        <img src="https://img.shields.io/circleci/project/github/badges/shields/master.svg"
+            alt="build status"></a>
+    <a href="https://circleci.com/gh/badges/daily-tests">
+        <img src="https://img.shields.io/circleci/project/github/badges/daily-tests.svg?label=daily%20tests"
+            alt="daily build status"></a>
+    <a href="https://coveralls.io/github/badges/shields">
+        <img src="https://img.shields.io/coveralls/github/badges/shields.svg"
+            alt="coverage"></a>
+    <a href="https://github.com/badges/shields/compare/gh-pages...master">
+        <img src="https://img.shields.io/github/commits-since/badges/shields/gh-pages.svg?label=commits%20to%20be%20deployed"
+            alt="commits to be deployed"></a>
+    <a href="https://lgtm.com/projects/g/badges/shields/alerts/">
+        <img src="https://img.shields.io/lgtm/alerts/g/badges/shields.svg?logo=lgtm&logoWidth=18"
+            alt="Total alerts"/></a>
+    <a href="https://discord.gg/HjJCwm5">
+        <img src="https://img.shields.io/discord/308323056592486420.svg?logo=discord"
+            alt="chat on Discord"></a>
+    <a href="https://twitter.com/intent/follow?screen_name=shields_io">
+        <img src="https://img.shields.io/twitter/follow/shields_io.svg?style=social&logo=twitter"
+            alt="follow on Twitter"></a>
 </p>
-<p align="center"><sup><strong>An image server for legible and concise information. Our <a href="http://shields.io/">Homepage</a> | <a href="https://twitter.com/shields_io">Twitter</a></strong></sup></p>
 
-* **[INSTALL](INSTALL.md)** – installation instructions.
-* **[CONTRIBUTING](CONTRIBUTING.md)** – project contribution guidelines.
-* **[SPECIFICATION](spec/SPECIFICATION.md)** – spec for the visual design of Shields badges.
-* **[LICENSE](LICENSE.md)** – public domain dedication.
+This is home to [Shields.io][shields.io], a service for concise, consistent,
+and legible badges in SVG and raster format, which can easily be included in
+GitHub readmes or any other web page. The service supports dozens of
+continuous integration services, package registries, distributions, app
+stores, social networks, code coverage services, and code analysis services.
+Every month it serves over 470 million images.
 
-Make your own badges [here][badges]! (Quick guide: `https://img.shields.io/badge/left-right-f39f37.svg`.)
+This repo hosts:
 
-[badges]: <http://shields.io/#your-badge>
+* The [Shields.io][shields.io] frontend and server code
+* An [NPM library for generating badges][gh-badges]
+    * [documentation][gh-badges-docs]
+    * [changelog][gh-badges-changelog]
+* The [badge design specification][badge-spec]
 
-## Solving the problem
-Many GitHub repositories sport badges for things like:
-<table>
-  <tr>
-    <td><a href="https://travis-ci.org/"><strong>Travis CI</strong></a><p><sup>(build status)</sup></p></td>
-    <td><img src="http://f.cl.ly/items/2H233M0I0T43313c3h0C/Screen%20Shot%202013-01-30%20at%202.45.30%20AM.png" alt="Travis CI badge"></td>
-  </tr>
-  <tr>
-    <td><a href="https://gemnasium.com/"><strong>Gemnasium</strong></a><p><sup>(dependency checks)</sup></p></td>
-    <td><img src="http://f.cl.ly/items/2j1D2R0q2C3s1x2y3k09/Screen%20Shot%202013-01-30%20at%202.46.10%20AM.png" alt="Gemnasium badge"></td>
-  </tr>
-  <tr>
-    <td><a href="http://codeclimate.com"><strong>Code Climate</strong></a><p><sup>(static analysis)</sup></p></td>
-    <td><img src="http://f.cl.ly/items/0H2O1A3q2b3j1D2i0M3j/Screen%20Shot%202013-01-30%20at%202.46.47%20AM.png" alt="Code Climate badge"></td>
-  </tr>
-  <tr>
-    <td><a href="http://rubygems.org"><strong>RubyGems</strong></a><p><sup>(released gem version)</sup></p></td>
-    <td><img src="http://f.cl.ly/items/443X21151h1V301s2s3a/Screen%20Shot%202013-01-30%20at%202.47.10%20AM.png" alt="RubyGems badge"></td>
-  </tr>
-</table>
 
-As you can see from the zoomed 400% versions of these badges above, nobody is (really) using the same badge file and at normal size, they're hardly legible. Worst of all, they're completely inconsistent. The information provided isn't of the same kind on each badge. The context is blurry, which doesn't make for a straightforward understanding of how these badges are relevant to the project they're attached to and what information they provide.
+[shields.io]: https://shields.io/
+[gh-badges]: https://www.npmjs.com/package/gh-badges
+[badge-spec]: https://github.com/badges/shields/tree/master/spec
+[gh-badges-docs]: https://github.com/badges/shields/tree/master/gh-badges/README.md
+[gh-badges-changelog]: https://github.com/badges/shields/tree/master/gh-badges/CHANGELOG.md
 
-## The Shields solution
-As you can see below, without increasing the footprint of these badges, I've tried to increase legibility and coherence, removing useless text to decrease the horizontal length in the (likely) scenario that more of these badge thingies crop up on READMEs all across the land.
 
-![Badge design](spec/proportions.png)
+Examples
+--------
 
-This badge design corresponds to an old and now deprecated version which has since been replaced by beautiful and scalable SVG versions that can be found on [shields.io](http://shields.io).
+* code coverage percentage: ![coverage](https://img.shields.io/badge/coverage-80%25-yellowgreen.svg?maxAge=2592000)
+* stable release version: ![version](https://img.shields.io/badge/version-1.2.3-blue.svg?maxAge=2592000)
+* package manager release: ![gem](https://img.shields.io/badge/gem-2.2.0-blue.svg?maxAge=2592000)
+* status of third-party dependencies: ![dependencies](https://img.shields.io/badge/dependencies-out%20of%20date-orange.svg?maxAge=2592000)
+* static code analysis grade: ![codacy](https://img.shields.io/badge/codacy-B-green.svg?maxAge=2592000)
+* [SemVer](https://semver.org/) version observance: ![semver](https://img.shields.io/badge/semver-2.0.0-blue.svg?maxAge=2592000)
+* amount of [Liberapay](https://liberapay.com/) donations per week: ![receives](https://img.shields.io/badge/receives-2.00%20USD%2Fweek-yellow.svg?maxAge=2592000)
+* Python package downloads: ![downloads](https://img.shields.io/badge/downloads-13k%2Fmonth-brightgreen.svg?maxAge=2592000)
+* Chrome Web Store extension rating: ![rating](https://img.shields.io/badge/rating-★★★★☆-brightgreen.svg?maxAge=2592000)
+* [Uptime Robot](https://uptimerobot.com) percentage: ![uptime](https://img.shields.io/badge/uptime-100%25-brightgreen.svg?maxAge=2592000)
 
-## Examples
-What kind of metadata can you convey using badges?
-* test build status: `build | failing`
-* code coverage percentage: `coverage | 80%`
-* stable release version: `version | 1.2.3`
-* package manager release: `gem | 1.2.3`
-* status of third-party dependencies: `dependencies | out-of-date`
-* static code analysis GPA: `code climate | 3.8`
-* [SemVer](http://semver.org/) version observance: `semver | 2.0.0`
-* amount of [Gratipay](http://gratipay.com) donations per week: `tips | $2/week`
+[Make your own badges!][custom badges]
+(Quick example: `https://img.shields.io/badge/left-right-f39f37.svg`)
 
-## Services using the Shields standard
-* [Badger](https://github.com/badges/badgerbadgerbadger)
-* [badges2svg](https://github.com/bfontaine/badges2svg)
-* [Codacy](https://www.codacy.com)
-* [Code Climate](https://codeclimate.com/changelog/510d4fde56b102523a0004bf)
-* [Coveralls](https://coveralls.io/)
-* [Forkability](http://basicallydan.github.io/forkability/)
-* [Gemnasium](http://support.gemnasium.com/forums/236528-general/suggestions/5518400-use-svg-for-badges-so-they-still-look-sharp-on-r)
-* [GoDoc](https://godoc.org/)
-* [PHPPackages](https://phppackages.org)
-* [Read the Docs](https://readthedocs.org/)
-* [reposs](https://github.com/rexfinn/reposs)
-* [ruby-gem-downloads-badge](https://github.com/bogdanRada/ruby-gem-downloads-badge/)
-* [Scrutinizer](https://scrutinizer-ci.com/)
-* [Semaphore](https://semaphoreapp.com)
-* [Travis CI](https://github.com/travis-ci/travis-ci/issues/630#issuecomment-38054967)
-* [Version Badge](http://badge.fury.io/)
-* [VersionEye](https://www.versioneye.com/)
+Browse a [complete list of badges][shields.io].
 
-# Legal
+[custom badges]: http://shields.io/#your-badge
 
-All assets and code are under the [CC0 LICENSE](LICENSE.md) and in the public
+
+Contributing
+------------
+
+Shields is a community project. We invite your participation through issues
+and pull requests! You can peruse the [contributing guidelines][contributing].
+
+When adding or changing a service [please add tests][service-tests].
+
+This project has quite a backlog of suggestions! If you're new to the project,
+maybe you'd like to open a pull request to address one of them:
+
+[![GitHub issues by-label](https://img.shields.io/github/issues/badges/shields/good%20first%20issue.svg)](https://github.com/badges/shields/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
+
+You can read a [tutorial on how to add a badge][tutorial].
+
+[service-tests]: https://github.com/badges/shields/blob/master/doc/service-tests.md
+[tutorial]: doc/TUTORIAL.md
+[contributing]: CONTRIBUTING.md
+
+
+Development
+-----------
+
+1. Install Node 8 or later. You can use the [package manager][] of your choice.
+   Tests need to pass in Node 8 and 9.
+2. Clone this repository.
+3. Run `npm install` to install the dependencies.
+4. Run `npm run build` to build the frontend.
+5. Run `npm start` to start the server.
+6. Open `http://[::]:8080/` to view the home page.
+
+To generate the frontend using production cache settings &ndash; that is,
+badge preview URIs with `maxAge` &ndash; run `LONG_CACHE=true npm run build`.
+
+To analyze the frontend bundle, run `npm install webpack-bundle-analyzer` and
+then `ANALYZE=true npm start`.
+
+[Snapshot tests][] ensure we don't inadvertently make changes that affect the
+SVG or JSON output. When deliberately changing the output, run
+`SNAPSHOT_DRY=1 npm run test:js:server` to preview changes to the saved
+snapshots, and `SNAPSHOT_UPDATE=1 npm run test:js:server` to update them.
+
+The server can be configured to use [Sentry][] ([configuration][sentry configuration]) and [Prometheus][] ([configuration][prometheus configuration]).
+
+Daily tests, including a full run of the service tests and overall code coverage, are run via [badges/daily-tests][daily-tests].
+
+[package manager]: https://nodejs.org/en/download/package-manager/
+[snapshot tests]: https://glebbahmutov.com/blog/snapshot-testing/
+[Prometheus]: https://prometheus.io/
+[prometheus configuration]: doc/self-hosting.md#prometheus
+[Sentry]: https://sentry.io/
+[sentry configuration]: doc/self-hosting.md#sentry
+[daily-tests]: https://github.com/badges/daily-tests
+
+Hosting your own server
+-----------------------
+
+There is documentation about [hosting your own server][self-hosting].
+
+[self-hosting]: doc/self-hosting.md
+
+
+History
+-------
+
+b.adge.me was the original website for this service. Heroku back then had a
+thing which made it hard to use a toplevel domain with it, hence the odd
+domain. It used code developed in 2013 from a library called
+[gh-badges][old-gh-badges], both developed by [Thaddée Tyl][espadrine].
+The project merged with shields.io by making it use the b.adge.me code
+and closed b.adge.me.
+
+The original badge specification was developed in 2013 by
+[Olivier Lacan][olivierlacan]. It was inspired by the Travis CI and similar
+badges (there were a lot fewer, back then). In 2014 Thaddée Tyl redesigned
+it with help from a Travis CI employee and convinced everyone to switch to
+it. The old design is what today is called the plastic style; the new one
+is the flat style.
+
+You can read more about [the project's inception][thread],
+[the motivation of the SVG badge specification][motivation], and
+[the specification itself][spec].
+
+[olivierlacan]: https://github.com/olivierlacan
+[espadrine]: https://github.com/espadrine
+[old-gh-badges]: https://github.com/badges/gh-badges
+[motivation]: spec/motivation.md
+[spec]: spec/SPECIFICATION.md
+[thread]: https://github.com/h5bp/lazyweb-requests/issues/150
+
+
+Project leaders
+---------------
+
+[espadrine](https://github.com/espadrine) is the sysadmin.
+
+These contributors donate time on a consistent basis to help guide and
+maintain the project:
+
+* [chris48s](https://github.com/chris48s)
+* [Daniel15](https://github.com/Daniel15)
+* [espadrine](https://github.com/espadrine)
+* [paulmelnikow](https://github.com/paulmelnikow)
+* [platan](https://github.com/platan)
+* [PyvesB](https://github.com/PyvesB)
+* [RedSparr0w](https://github.com/RedSparr0w)
+
+
+Related projects
+----------------
+
+- [badgerbadgerbadger gem][gem]
+- [pybadges python library][pybadges]
+
+[gem]: https://github.com/badges/badgerbadgerbadger
+[pybadges]: https://github.com/google/pybadges
+
+License
+-------
+
+All assets and code are under the [CC0 LICENSE](LICENSE) and in the public
 domain unless specified otherwise.
 
-The assets in `logo/` are trademarks of their respective companies and are under
-their terms and license.
+The assets in `logo/` are trademarks of their respective companies and are
+under their terms and license.
+
+## Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+<a href="https://github.com/badges/shields/graphs/contributors"><img src="https://opencollective.com/shields/contributors.svg?width=890" /></a>
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/shields#backer)]
+
+<a href="https://opencollective.com/shields#backers" target="_blank"><img src="https://opencollective.com/shields/backers.svg?width=890"></a>
+
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/shields#sponsor)]
+
+<a href="https://opencollective.com/shields/sponsor/0/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/1/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/2/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/3/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/4/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/5/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/6/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/7/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/8/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/shields/sponsor/9/website" target="_blank"><img src="https://opencollective.com/shields/sponsor/9/avatar.svg"></a>
+
+

__snapshots__/make-badge.spec.js

@@ -0,0 +1,26 @@
+exports['The badge generator SVG should always produce the same SVG (unless we have changed something!) 1'] = `
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="90" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="90" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h45v20H0z"/><path fill="#4c1" d="M45 0h45v20H45z"/><path fill="url(#b)" d="M0 0h90v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110"> <text x="235" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="350">cactus</text><text x="235" y="140" transform="scale(.1)" textLength="350">cactus</text><text x="665" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="350">grown</text><text x="665" y="140" transform="scale(.1)" textLength="350">grown</text></g> </svg>
+`
+
+exports['The badge generator JSON should always produce the same JSON (unless we have changed something!) 1'] = `
+{
+  "name": "cactus",
+  "value": "grown"
+}
+`
+
+exports['The badge generator badges with logos should always produce the same badge shields GitHub logo default color (#333333) 1'] = `
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="113" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="113" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h54v20H0z"/><path fill="#4c1" d="M54 0h59v20H54z"/><path fill="url(#b)" d="M0 0h113v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110"><image x="5" y="3" width="14" height="14" xlink:href="github"/> <text x="365" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="270">label</text><text x="365" y="140" transform="scale(.1)" textLength="270">label</text><text x="825" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="490">message</text><text x="825" y="140" transform="scale(.1)" textLength="490">message</text></g> </svg>
+`
+
+exports['The badge generator badges with logos should always produce the same badge shields GitHub logo custom color (whitesmoke) 1'] = `
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="113" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="113" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h54v20H0z"/><path fill="#4c1" d="M54 0h59v20H54z"/><path fill="url(#b)" d="M0 0h113v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110"><image x="5" y="3" width="14" height="14" xlink:href="github"/> <text x="365" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="270">label</text><text x="365" y="140" transform="scale(.1)" textLength="270">label</text><text x="825" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="490">message</text><text x="825" y="140" transform="scale(.1)" textLength="490">message</text></g> </svg>
+`
+
+exports['The badge generator badges with logos should always produce the same badge simple-icons javascript logo default color (#F7DF1E) 1'] = `
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="113" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="113" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h54v20H0z"/><path fill="#4c1" d="M54 0h59v20H54z"/><path fill="url(#b)" d="M0 0h113v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110"><image x="5" y="3" width="14" height="14" xlink:href="javascript"/> <text x="365" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="270">label</text><text x="365" y="140" transform="scale(.1)" textLength="270">label</text><text x="825" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="490">message</text><text x="825" y="140" transform="scale(.1)" textLength="490">message</text></g> </svg>
+`
+
+exports['The badge generator badges with logos should always produce the same badge simple-icons javascript logo custom color (rgba(46,204,113,0.8)) 1'] = `
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="113" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="113" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h54v20H0z"/><path fill="#4c1" d="M54 0h59v20H54z"/><path fill="url(#b)" d="M0 0h113v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110"><image x="5" y="3" width="14" height="14" xlink:href="javascript"/> <text x="365" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="270">label</text><text x="365" y="140" transform="scale(.1)" textLength="270">label</text><text x="825" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="490">message</text><text x="825" y="140" transform="scale(.1)" textLength="490">message</text></g> </svg>
+`

app.json

@@ -0,0 +1,25 @@
+{
+  "name": "Shields",
+  "description": "Concise, consistent, and legible badges in SVG and raster format.",
+  "keywords": [
+    "badge",
+    "github",
+    "svg",
+    "status"
+  ],
+  "website": "https://shields.io/",
+  "repository": "https://github.com/badges/shields",
+  "logo": "http://shields.io/favicon.png",
+  "env": {
+    "NPM_CONFIG_PRODUCTION": {
+      "description": "Configure whether devDependencies are installed (they are needed for the build).",
+      "value": "false"
+    }
+  },
+  "formation": {
+    "web": {
+      "quantity": 1,
+      "size": "free"
+    }
+  }
+}

badge.js

@@ -1,102 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-var SVGO = require('svgo');
-var dot = require('dot');
-var measureTextWidth = require('./measure-text');
-
-// cache templates.
-var templates = {};
-var templateFiles = fs.readdirSync(path.join(__dirname, 'templates'));
-dot.templateSettings.strip = false;  // Do not strip whitespace.
-templateFiles.forEach(function(filename) {
-  if (filename[0] === '.') { return; }
-  var templateData = fs.readFileSync(
-    path.join(__dirname, 'templates', filename)).toString();
-  var extension = filename.split('.').pop();
-  var style = filename.slice(0, -(('-template.' + extension).length));
-  templates[style + '-' + extension] = dot.template(templateData);
-});
-
-function escapeXml(s) {
-  return s.replace(/&/g, '&')
-          .replace(/</g, '&lt;')
-          .replace(/>/g, '&gt;')
-          .replace(/"/g, '&quot;')
-          .replace(/'/g, '&apos;');
-}
-function capitalize(s) {
-  return s[0].toUpperCase() + s.slice(1);
-}
-function addEscapers(data) {
-  data.escapeXml = escapeXml;
-  data.capitalize = capitalize;
-}
-
-var colorscheme = require(path.join(__dirname, 'colorscheme.json'));
-
-function optimize(string, callback) {
-  var svgo = new SVGO();
-  svgo.optimize(string, callback);
-}
-
-function makeImage(data, cb) {
-  if (data.format !== 'json') {
-    data.format = 'svg';
-  }
-  if (!(data.template + '-' + data.format in templates)) {
-    data.template = 'default';
-  }
-  if (data.colorscheme) {
-    var pickedColorscheme = colorscheme[data.colorscheme];
-    if (!pickedColorscheme) {
-      pickedColorscheme = colorscheme.red;
-    }
-    data.colorA = pickedColorscheme.colorA;
-    data.colorB = pickedColorscheme.colorB;
-  }
-  // Logo.
-  data.logoWidth = +data.logoWidth || (data.logo? 14: 0);
-  data.logoPadding = (data.logo? 3: 0);
-  // String coercion.
-  data.text[0] = '' + data.text[0];
-  data.text[1] = '' + data.text[1];
-  if (data.text[0].length === 0) {
-    data.logoPadding = 0;
-  }
-
-  var textWidth1 = (measureTextWidth(data.text[0])|0);
-  var textWidth2 = (measureTextWidth(data.text[1])|0);
-  // Increase chances of pixel grid alignment.
-  if (textWidth1 % 2 === 0) { textWidth1++; }
-  if (textWidth2 % 2 === 0) { textWidth2++; }
-  data.widths = [
-    textWidth1 + 10 + data.logoWidth + data.logoPadding,
-    textWidth2 + 10,
-  ];
-  if (data.links === undefined) {
-    data.links = ['', ''];
-  } else {
-    for (var i = 0; i < data.links.length; i++) {
-      data.links[i] = escapeXml(data.links[i]);
-    }
-  }
-
-  var template = templates[data.template + '-' + data.format];
-  addEscapers(data);
-  try {
-    var result = template(data);
-  } catch(e) {
-    cb('', e);
-    return;
-  }
-
-  if (data.format === 'json') {
-    cb(result);
-  } else {
-    // Run the SVG through SVGO.
-    optimize(result, function(object) { cb(object.data); });
-  }
-}
-
-module.exports = makeImage;
-module.exports.loadFont = measureTextWidth.loadFont;

coverage.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="110" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><mask id="a"><rect width="110" height="20" rx="3" fill="#fff"/></mask><g mask="url(#a)"><path fill="#555" d="M0 0h63v20H0z"/><path fill="#dfb317" d="M63 0h47v20H63z"/><path fill="url(#b)" d="M0 0h110v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11"><text x="31.5" y="15" fill="#010101" fill-opacity=".3">coverage</text><text x="31.5" y="14">coverage</text><text x="85.5" y="15" fill="#010101" fill-opacity=".3">76.8%</text><text x="85.5" y="14">76.8%</text></g></svg>

dangerfile.js

@@ -0,0 +1,170 @@
+'use strict'
+
+// Have you identified a contributing guideline that should be included here?
+// Please open a pull request!
+//
+// To test changes to this file, pick a PR to test against, then run
+// `./node_modules/.bin/danger pr pr-url`
+// Note that the line numbers in the runtime errors are incorrecr.
+
+const { danger, fail, message, warn } = require('danger')
+const chainsmoker = require('chainsmoker')
+const { default: noTestShortcuts } = require('danger-plugin-no-test-shortcuts')
+
+const fileMatch = chainsmoker({
+  created: danger.git.created_files,
+  modified: danger.git.modified_files,
+  createdOrModified: danger.git.modified_files.concat(danger.git.created_files),
+  deleted: danger.git.deleted_files,
+})
+
+const documentation = fileMatch(
+  '**/*.md',
+  'lib/all-badge-examples.js',
+  'frontend/components/usage.js'
+)
+const server = fileMatch('server.js')
+const serviceTests = fileMatch('services/**/*.tester.js')
+const helpers = fileMatch(
+  'lib/**/*.js',
+  '!**/*.spec.js',
+  '!lib/all-badge-examples.js'
+)
+const logos = fileMatch('logo/*.svg')
+const helperTests = fileMatch('lib/**/*.spec.js')
+const packageJson = fileMatch('package.json')
+const packageLock = fileMatch('package-lock.json')
+const capitals = fileMatch('**/*[A-Z]*.js')
+const underscores = fileMatch('**/*_*.js')
+const targetBranch = danger.github.pr.base.ref
+
+message(
+  [
+    ':sparkles: Thanks for your contribution to Shields, ',
+    `@${danger.github.pr.user.login}!`,
+  ].join('')
+)
+
+if (targetBranch !== 'master') {
+  const message = `This PR targets \`${targetBranch}\``
+  const idea = 'It is likely that the target branch should be `master`'
+  warn(`${message} - <i>${idea}</i>`)
+}
+
+if (documentation.createdOrModified) {
+  message(
+    [
+      'Thanks for contributing to our documentation. ',
+      'We :heart: our [documentarians](http://www.writethedocs.org/)!',
+    ].join('')
+  )
+}
+
+if (packageJson.modified && !packageLock.modified) {
+  const message = 'This PR modified `package.json`, but not `package-lock.json`'
+  const idea = 'Perhaps you need to run `npm install`?'
+  warn(`${message} - <i>${idea}</i>`)
+}
+
+if (server.modified && !serviceTests.createdOrModified) {
+  warn(
+    [
+      'This PR modified the server but none of the service tests. <br>',
+      "That's okay so long as it's refactoring existing code. ",
+      'Otherwise, please consider adding tests to the service: ',
+      '[How-to](https://github.com/badges/shields/blob/master/doc/service-tests.md#readme)',
+    ].join('')
+  )
+}
+
+if (helpers.created && !helperTests.created) {
+  warn(
+    [
+      'This PR added helper modules in `lib/` but not accompanying tests. <br>',
+      'Generally helper modules should have their own tests.',
+    ].join('')
+  )
+} else if (helpers.createdOrModified && !helperTests.createdOrModified) {
+  warn(
+    [
+      'This PR modified helper functions in `lib/` but not accompanying tests. <br>',
+      "That's okay so long as it's refactoring existing code.",
+    ].join('')
+  )
+}
+
+if (logos.created) {
+  message(
+    [
+      ':art: Thanks for submitting a logo. <br>',
+      'Please ensure your contribution follows our ',
+      '[guidance](https://github.com/badges/shields/blob/master/CONTRIBUTING.md#logos) ',
+      'for logo submissions.',
+    ].join('')
+  )
+}
+
+if (capitals.created || underscores.created) {
+  fail(
+    [
+      'JavaScript source files should be named with `kebab-case` ',
+      '(dash-separated lowercase).',
+    ].join('')
+  )
+}
+
+const allFiles = danger.git.created_files.concat(danger.git.modified_files)
+
+allFiles.forEach(file => {
+  // eslint-disable-next-line promise/prefer-await-to-then
+  danger.git.diffForFile(file).then(diff => {
+    if (/\+.*assert[(.]/.test(diff.diff)) {
+      warn(
+        [
+          `Found 'assert' statement added in \`${file}\`. <br>`,
+          'Please ensure tests are written using Chai ',
+          '[expect syntax](http://chaijs.com/guide/styles/#expect)',
+        ].join('')
+      )
+    }
+  })
+})
+
+function onlyUnique(value, index, self) {
+  return self.indexOf(value) === index
+}
+
+const affectedServices = allFiles
+  .map(file => {
+    const match = file.match(/^services\/(.+)\/.+\.service.js$/)
+    return match ? match[1] : undefined
+  })
+  .filter(Boolean)
+  .filter(onlyUnique)
+
+const testedServices = allFiles
+  .map(file => {
+    const match = file.match(/^services\/(.+)\/.+\.tester.js$/)
+    return match ? match[1] : undefined
+  })
+  .filter(Boolean)
+  .filter(onlyUnique)
+
+affectedServices.forEach(service => {
+  if (testedServices.indexOf(service) === -1) {
+    warn(
+      [
+        `This PR modified service code for <kbd>${service}</kbd> but not its test code. <br>`,
+        "That's okay so long as it's refactoring existing code.",
+      ].join('')
+    )
+  }
+})
+
+// Prevent merging exclusive services tests.
+noTestShortcuts({
+  testFilePredicate: filePath => filePath.endsWith('.tester.js'),
+  patterns: {
+    only: ['only()'],
+  },
+})

doc/TUTORIAL.md

@@ -0,0 +1,309 @@
+Tutorial on how to add a badge for a service
+============================================
+
+This tutorial should help you add a service to shields.io in form of a badge.
+You will need to learn to use JavaScript, git and Github.
+Please [improve the tutorial](https://github.com/badges/shields/edit/master/doc/TUTORIAL.md) while you read it.
+
+(1) Reading
+-----------
+
+You should read [CONTRIBUTING.md](../CONTRIBUTING.md)
+
+You can also read previous
+[merged pull-requests with the 'service-badge' label](https://github.com/badges/shields/pulls?utf8=%E2%9C%93&q=is%3Apr+label%3Aservice-badge+is%3Amerged)
+to see how other people implemented their badges.
+
+(2) Setup
+---------
+
+You should have [git](https://git-scm.com/) installed.
+If you do not, [install git](https://www.linode.com/docs/development/version-control/how-to-install-git-on-linux-mac-and-windows/)
+and learn about the [Github workflow](http://try.github.io/).
+
+1. [Fork](https://github.com/badges/shields/fork) this repository.
+2. Clone the fork
+   `git clone git@github.com:YOURGITHUBUSERNAME/shields.git`
+3. `cd shields`
+4. Install npm and other required packages (Ubuntu 16.10)
+   `sudo apt-get install npm nodejs-legacy curl imagemagick`
+5. Install all packages
+   `npm install`
+6. Run the server
+   `npm start`
+7. Visit the website to check the front-end is loaded:
+   [http://127.0.0.1:3000/](http://127.0.0.1:3000/)
+
+(3) Open an Issue
+-----------------
+
+Before you want to implement your service, you may want to [open an issue](https://github.com/badges/shields/issues/new?template=2_Badge_request.md) and describe what you have in mind:
+- What is the badge for?
+- Which API do you want to use?
+
+You may additionally proceed to say what you want to work on.
+This information allows other humans to help and build on your work.
+
+(4) Implementing
+----------------
+
+### (4.1) Structure and Layout
+
+Service badge code is stored in the [/services](https://github.com/badges/shields/tree/master/services/) directory.
+Each service has a directory for its files:
+
+* In files ending with `.service.js`, you can find the code which generates
+  the badge and handles requests.
+  Sometimes, code for a service can be re-used.
+  This might be the case when you add a badge for an API which is already used
+  by other badges.
+
+  Replace `SERVICENAME` with your service name in the following:
+  * For services with a single badge, the badge code will generally be stored in
+    `/services/SERVICENAME/SERVICENAME.service.js`.  
+    If you add a badge for a new API, create a new directory.
+
+    Example: [wercker](https://github.com/badges/shields/tree/master/services/wercker)
+
+  * For service families with multiple badges we usually store the code for each
+    badge in its own file like this:
+    * `/services/SERVICENAME/SERVICENAME-downloads.service.js`
+    * `/services/SERVICENAME/SERVICENAME-version.service.js` etc.
+
+    Example: [ruby gems](https://github.com/badges/shields/tree/master/services/gem)
+
+* In files ending with `.tester.js`, you can find the code which uses
+  the shields server to test if the badges are generated correctly.
+  There is a [chapter on Tests][write tests].
+
+### (4.2) Our First Badge
+
+All service badge classes inherit from [BaseService] or another class which extends it.
+Other classes implement useful behavior on top of [BaseService].
+
+* [BaseJsonService](https://github.com/badges/shields/blob/master/services/base-json.js)
+  implements methods for performing requests to a JSON API and schema validation.
+* [BaseXmlService](https://github.com/badges/shields/blob/master/services/base-xml.js)
+  implements methods for performing requests to an XML API and schema validation.
+* If you are contributing to a *service family*, you may define a common super
+  class for the badges or one may already exist.
+
+[BaseService]: https://github.com/badges/shields/blob/master/services/base.js
+
+As a first step we will look at the code for an example which generates a badge without contacting an API.
+
+```js
+'use strict'                                         // (1)
+
+const BaseService = require('../base')               // (2)
+
+module.exports = class Example extends BaseService { // (3)
+
+  static get route() {                                 // (4)
+    return {
+      base: 'example',
+      pattern: ':text',
+    }
+  }
+
+  async handle({ text }) {                           // (5)
+    return {
+      label: 'example',
+      message: text,
+      color: 'blue',
+    }
+  }
+}
+```
+
+Description of the code:
+
+1. We declare strict mode at the start of each file. This prevents certain classes of error such as undeclared variables.
+2. Our service badge class will extend `BaseService` so we need to require it. We declare variables with `const` and `let` in preference to `var`.
+3. Our module must export a class which extends `BaseService`
+4. `route()` declares a route. We declare getters as `static`.
+    * `base` defines the static part of the route.
+    * `pattern` defines the variable part of the route. It can include any
+      number of named parameters. These are converted into
+      regular expressions by [`path-to-regexp`][path-to-regexp].
+5. All badges must implement the `async handle()` function. This is called to invoke our code. Note that the signature of `handle()` will match the capturing group defined in `route()` Because we're capturing a single variable called `text` our function signature is `async handle({ text })`. Although in this simple case, we aren't performing any asynchronous calls, `handle()` would usually spend some time blocked on I/O. We use the `async`/`await` pattern for asynchronous code. Our `handle()` function returns an object with 3 properties:
+    * `label`: the text on the left side of the badge
+    * `message`: the text on the right side of the badge - here we are passing through the parameter we captured in the route regex
+    * `color`: the background color of the right side of the badge
+
+The process of turning this object into an image is handled automatically by the `BaseService` class.
+
+To try out this example badge:
+
+1. Copy and paste this code into a new file in `/services/example/example.service.js`
+2. Quit the running server with `Control+C`.
+3. Start the server again.
+   `npm start`
+4. Visit the badge at <http://[::]:8080/example/foo.svg>.
+   It should look like this: ![](https://img.shields.io/badge/example-foo-blue.svg)
+
+[path-to-regexp]: https://github.com/pillarjs/path-to-regexp#parameters
+
+### (4.3) Querying an API
+
+The example above was completely static. In order to make a useful service badge we will need to get some data from somewhere. The most common case is that we will query an API which serves up some JSON data, but other formats (e.g: XML) may be used.
+
+This example is based on the [Ruby Gems version](https://github.com/badges/shields/blob/master/services/gem/gem-version.service.js) badge:
+
+```js
+'use strict'                                                    // (1)
+
+const BaseJsonService = require('../base-json')                 // (2)
+const { renderVersionBadge } = require('../../lib/version')     // (3)
+
+const Joi = require('joi')                                      // (4)
+const schema = Joi.object({                                     // (4)
+  version: Joi.string().required(),                             // (4)
+}).required()                                                   // (4)
+
+module.exports = class GemVersion extends BaseJsonService {     // (5)
+
+  static get route() {                                          // (6)
+    return {
+      base: 'gem/v',
+      pattern: ':gem',
+    }
+  }
+
+  static get defaultBadgeData() {                               // (7)
+    return { label: 'gem' }
+  }
+
+  async handle({ gem }) {                                       // (8)
+    const { version } = await this.fetch({ gem })
+    return this.constructor.render({ version })
+  }
+
+  async fetch({ gem }) {                                        // (9)
+    return this._requestJson({
+      schema,
+      url: `https://rubygems.org/api/v1/gems/${gem}.json`,
+    })
+  }
+
+  static render({ version }) {                                  // (10)
+    return renderVersionBadge({ version })
+  }
+
+}
+```
+
+Description of the code:
+1. As with the first example, we declare strict mode at the start of each file.
+2. Our badge will query a JSON API so we will extend `BaseJsonService` instead of `BaseService`. This contains some helpers to reduce the need for boilerplate when calling a JSON API.
+3. In this case we are making a version badge, which is a common pattern. Instead of directly returning an object in this badge we will use a helper function to format our data consistently. There are a variety of helper functions to help with common tasks in `/lib`. Some useful generic helpers can be found in:
+    * [color-formatters.js](https://github.com/badges/shields/blob/master/lib/color-formatters.js)
+    * [licenses.js](https://github.com/badges/shields/blob/master/lib/licenses.js)
+    * [text-formatters.js](https://github.com/badges/shields/blob/master/lib/text-formatters.js)
+    * [version.js](https://github.com/badges/shields/blob/master/lib/version.js)
+4. We perform input validation by defining a schema which we expect the JSON we receive to conform to. This is done using [Joi](https://github.com/hapijs/joi). Defining a schema means we can ensure the JSON we receive meets our expectations and throw an error if we receive unexpected input without having to explicitly code validation checks. The schema also acts as a filter on the JSON object. Any properties we're going to reference need to be validated, otherwise they will be filtered out. In this case our schema declares that we expect to recieve an object which must have a property called 'status', which is a string.
+5. Our module exports a class which extends `BaseJsonService`
+6. As with our previous badge, we need to declare a route. This time we will capture a variable called `gem`.
+7. We can use `defaultBadgeData()` to set a default `color`, `logo` and/or `label`. If `handle()` doesn't return any of these keys, we'll use the default. Instead of explicitly setting the label text when we return a badge object, we'll use `defaultBadgeData()` here to define it declaratively.
+8. Our bage must implement the `async handle()` function. Because our URL pattern captures a variable called `gem`, our function signature is `async handle({ gem })`. We usually separate the process of generating a badge into 2 stages or concerns: fetch and render. The `fetch()` function is responsible for calling an API endpoint to get data. The `render()` function formats the data for display. In a case where there is a lot of calculation or intermediate steps, this pattern may be thought of as fetch, transform, render and it might be necessary to define some helper functions to assist with the 'transform' step.
+9. The `async fetch()` method is responsible for calling an API endpoint to get data. Extending `BaseJsonService` gives us the helper function `_requestJson()`. Note here that we pass the schema we defined in step 4 as an argument. `_requestJson()` will deal with validating the response against the schema and throwing an error if necessary.
+    * `_requestJson()` automatically adds an Accept header, checks the status code, parses the response as JSON, and returns the parsed response.
+    * `_requestJson()` uses [request](https://github.com/request/request) to perform the HTTP request. Options can be passed to request, including method, query string, and headers. If headers are provided they will override the ones automatically set by `_requestJson()`. There is no need to specify json, as the JSON parsing is handled by `_requestJson()`. See the `request` docs for [supported options](https://github.com/request/request#requestoptions-callback).
+    * Error messages corresponding to each status code can be returned by passing a dictionary of status codes -> messages in `errorMessages`.
+    * A more complex call to `_requestJson()` might look like this:
+        ```js
+        return this._requestJson({
+          schema: mySchema,
+          url,
+          options: { qs: { branch: 'master' } },
+          errorMessages: {
+            401: 'private application not supported',
+            404: 'application not found',
+          },
+        })
+        ```
+10. The `static render()` method is responsible for formatting the data for display. `render()` is a pure function so we can make it a `static` method. By convention we declare functions which don't reference `this` as `static`. We could explicitly return an object here, as we did in the previous example. In this case, we will hand the version string off to `renderVersionBadge()` which will format it consistently and set an appropriate color. Because `renderVersionBadge()` doesn't return a `label` key, the default label we defined in `defaultBadgeData()` will be used when we generate the badge.
+
+This code allows us to call this URL <https://img.shields.io/gem/v/formatador.svg> to generate this badge: ![](https://img.shields.io/gem/v/formatador.svg)
+
+It is also worth considering the code we _haven't_ written here. Note that our example doesn't contain any explicit error handling code, but our badge handles errors gracefully. For example, if we call https://img.shields.io/gem/v/does-not-exist.svg we render a 'not found' badge ![](https://img.shields.io/gem/v/does-not-exist.svg) because https://rubygems.org/api/v1/gems/this-package-does-not-exist.json returns a `404 Not Found` status code. When dealing with well-behaved APIs, some of our error handling will be handled implicitly in `BaseJsonService`.
+
+Specifically `BaseJsonService` will handle the following errors for us:
+
+* API does not respond
+* API responds with a non-`200 OK` status code
+* API returns a response which can't be parsed as JSON
+* API returns a response which doesn't validate against our schema
+
+Sometimes it may be necessary to manually throw an exception to deal with a non-standard error condition. If so, standard exceptions can be imported from [errors.js](https://github.com/badges/shields/blob/master/services/errors.js) and thrown.
+
+### (4.4) Adding an Example to the Front Page
+
+Once we have implemented our badge, we can add it to the index so that users can discover it. We will do this by adding a couple of additional methods to our class.
+
+
+```js
+module.exports = class GemVersion extends BaseJsonService {
+
+  // ...
+
+  static get category() {                                       // (1)
+    return 'version'
+  }
+
+  static get examples() {                                       // (2)
+    return [
+      {                                                         // (3)
+        title: 'Gem',
+        namedParams: { gem: 'formatador' },
+        staticExample: this.render({ version: '2.1.0' }),
+        keywords: ['ruby'],
+      },
+    ]
+  }
+
+}
+```
+
+1. The `category()` property defines which heading in the index our example will appear under.
+2. The examples property defines an array of examples. In this case the array will contain a single object, but in some cases it is helpful to provide multiple usage examples.
+3. Our example object should contain the following properties:
+    * `title`: Descriptive text that will be shown next to the badge
+    * `namedParams`: Provide a valid example of params we can substitute into
+      the pattern. In this case we need a valid ruby gem, so we've picked [formatador](https://rubygems.org/gems/formatador).
+    * `staticExample`: On the index page we want to show an example badge, but for performance reasons we want that example to be generated without making an API call. `staticExample` should be populated by calling our `render()` method with some valid data.
+    * `keywords`: If we want to provide additional keywords other than the title, we can add them here. This helps users to search for relevant badges.
+
+Save, run `npm start`, and you can see it [locally](http://127.0.0.1:3000/).
+
+### (4.5) Write Tests <!-- Change the link below when you change the heading -->
+[write tests]: #45-write-tests 
+
+When creating a badge for a new service or changing a badge's behavior, tests
+should be included. They serve several purposes:
+
+1. They speed up future contributors when they are debugging or improving a
+   badge.
+2. If a contributors like to change your badge, chances are, they forget
+   edge cases and break your code.
+   Tests may give hints in such cases.
+3. The contributor and reviewer can easily verify the code works as
+   intended.
+4. When a badge stops working on the live server, maintainers can find out
+   right away.
+
+There is a dedicated [tutorial for tests in the service-tests folder](service-tests.md).
+Please follow it to include tests on your pull-request.
+
+## (5) Create a Pull Request
+
+Once you have implemented a new badge:
+* Before submitting your changes, please review the [coding guidelines](https://github.com/badges/shields/blob/master/CONTRIBUTING.md#coding-guidelines).
+* [Create a pull-request](https://help.github.com/articles/creating-a-pull-request/) to propose your changes.
+* CI will check the tests pass and that your code conforms to our coding standards.
+* We also use [Danger](https://danger.systems/) to check for some common problems. The first comment on your pull request will be posted by a bot. If there are any errors or warnings raised, please review them.
+* One of the
+[maintainers](https://github.com/badges/shields/blob/master/README.md#project-leaders)
+will review your contribution.
+* We'll work with you to progress your contribution suggesting improvements if necessary. Although there are some occasions where a contribution is not appropriate, if your contribution conforms to our [guidelines](https://github.com/badges/shields/blob/master/CONTRIBUTING.md#badge-guidelines) we'll aim to work towards merging it. The majority of pull requests adding a service badge are merged.
+* If your contribution is merged, the final comment on the pull request will be an automated post which you can monitor to tell when your contribution has been deployed to production.

doc/production-hosting.md

@@ -0,0 +1,38 @@
+Production hosting
+==================
+
+Server secrets
+--------------
+
+Some services require the use of secret tokens or passwords. Those are stored
+in `private/secret.json` which is not checked into the repository.
+
+These settings are currently set on the production server:
+
+- bintray_apikey
+- bintray_user
+- gh_client_id
+- gh_client_secret
+- gh_token
+- gitter_dev_secret
+- shieldsIps
+- shieldsSecret
+- sl_insight_apiToken
+- sl_insight_userUuid
+
+(Gathered from `cat private/secret.json | jq keys | grep -o '".*"' | sed 's/"//g'`.)
+
+The `secret.tpl.json` is a template file used by the Docker container to set the secrets based on
+environment variables.
+
+Main Server Sysadmin
+--------------------
+
+- Servers in DNS round-robin:
+  - s0: 192.99.59.72 (vps71670.vps.ovh.ca)
+  - s1: 51.254.114.150 (vps244529.ovh.net)
+  - s2: 149.56.96.133 (vps117870.vps.ovh.ca)
+- Self-signed TLS certificates, but `img.shields.io` is behind CloudFlare, which provides signed certificates.
+- Using systemd to automatically restart the server when it crashes.
+
+See https://github.com/badges/ServerScript for helper admin scripts.

doc/self-hosting.md

@@ -0,0 +1,214 @@
+Hosting your own Shields server
+===============================
+
+Installation
+------------
+
+You will need Node 8 or later, which you can install using a
+[package manager][].
+
+On Ubuntu / Debian:
+
+```sh
+curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -; sudo apt-get install -y nodejs
+```
+
+```sh
+git clone https://github.com/badges/shields.git
+cd shields
+npm install  # You may need sudo for this.
+```
+
+[package manager]: https://nodejs.org/en/download/package-manager/
+
+
+Build the frontend
+------------------
+
+```sh
+LONG_CACHE=true npm run build
+```
+
+
+Start the server
+----------------
+
+```sh
+sudo node server
+```
+
+The server uses port 80 by default, which requires `sudo` permissions.
+
+There are two ways to provide an alternate port:
+
+```sh
+PORT=8080 node server
+node server 8080
+```
+
+The root gets redirected to https://shields.io.
+
+For testing purposes, you can go to `http://localhost/`.
+
+
+Heroku
+------
+
+Once you have installed the [Heroku Toolbelt][]:
+
+```bash
+heroku login
+heroku create your-app-name
+heroku config:set BUILDPACK_URL=https://github.com/mojodna/heroku-buildpack-multi.git#build-env
+make deploy
+heroku open
+```
+
+[Heroku Toolbelt]: https://toolbelt.heroku.com/
+
+
+Docker
+------
+
+You can build and run the server locally using Docker. First build an image:
+
+```console
+$ docker build -t shields .
+Sending build context to Docker daemon 3.923 MB
+…
+Successfully built 4471b442c220
+```
+
+Optionally, create a file called `shields.env` that contains the needed
+configuration. See [shields.example.env][shields.example.env] for an example.
+
+Then run the container:
+
+```console
+$ docker run --rm -p 8080:80 --name shields shields
+# or if you have shields.env file, run the following instead
+$ docker run --rm -p 8080:80 --env-file shields.env --name shields shields
+
+> gh-badges@1.1.2 start /usr/src/app
+> node server.js
+
+http://[::1]/
+```
+
+Assuming Docker is running locally, you should be able to get to the
+application at http://localhost:8080/.
+
+If you run Docker in a virtual machine (such as boot2docker or Docker Machine)
+then you will need to replace `localhost` with the IP address of that virtual
+machine.
+
+[shields.example.env]: ../shields.example.env
+
+
+Zeit Now
+--------
+
+To deploy using Zeit Now:
+
+```console
+npm run build  # Not sure why, but this needs to be run before deploying.
+now
+```
+
+## Persistence
+
+To enable Redis-backed GitHub token persistence, point `REDIS_URL` to your
+Redis installation.
+
+Server secrets
+--------------
+
+You can add your own server secrets in `private/secret.json`.
+
+Because of Github rate limits, you will need to provide a token, or else badges
+will stop working once you hit 60 requests per hour, the
+[unauthenticated rate limit][github rate limit].
+
+You can [create a personal access token][personal access tokens] through the
+Github website. When you create the token, you can choose to give read access
+to your repositories. If you do that, your self-hosted Shields installation
+will have access to your private repositories.
+
+```
+{
+  "gh_token": "..."
+}
+```
+
+When a `gh_token` is specified, it is used in place of the Shields token
+rotation logic.
+
+You can also give your self-hosted Shields installation access to private npm
+packages by [generating an npm token] and using that for the `npm_token` value.
+
+[github rate limit]: https://developer.github.com/v3/#rate-limiting
+[personal access tokens]: https://github.com/settings/tokens
+[generating an npm token]: https://docs.npmjs.com/getting-started/working_with_tokens
+
+Separate frontend hosting
+-------------------------
+
+If you want to host the frontend on a separate server, such as cloud storage
+or a CDN, you can do that.
+
+First, build the frontend, pointing `BASE_URL` to your server.
+
+```sh
+LONG_CACHE=true BASE_URL=https://your-server.example.com npm run build
+```
+
+Then copy the contents of the `build/` folder to your static hosting / CDN.
+
+There are also a couple settings you should configure on the server.
+
+If you want to use server suggestions, you should also set `ALLOWED_ORIGIN`:
+
+```sh
+ALLOWED_ORIGIN=http://my-custom-shields.s3.amazonaws.com,https://my-custom-shields.s3.amazonaws.com
+```
+
+This should be a comma-separated list of allowed origin headers. They should
+not have paths or trailing slashes.
+
+To help out users, you can make the Shields server redirect the server root.
+Set the `REDIRECT_URI` environment variable:
+
+```sh
+REDIRECT_URI=http://my-custom-shields.s3.amazonaws.com/
+```
+
+Sentry
+------
+
+In order to enable integration with [Sentry](https://sentry.io), you need your own [Sentry DSN](https://docs.sentry.io/quickstart/#configure-the-dsn). It’s an URL in format `https://{PUBLIC_KEY}:{SECRET_KEY}@sentry.io/{PROJECT_ID}`.
+
+### How to obtain the Sentry DSN
+
+1. [Sign up](https://sentry.io/pricing/) for Sentry
+2. Log in to Sentry
+3. Create a new project for Node.js
+4. You should see [Sentry DSN](https://docs.sentry.io/quickstart/#configure-the-dsn) for your project. Sentry DSN can be found by navigating to \[Project Name] -> Project Settings -> Client Keys (DSN) as well.
+
+Start the server using the Sentry DSN. You can set it:
+- by `SENTRY_DSN` environment variable
+```
+sudo SENTRY_DSN=https://xxx:yyy@sentry.io/zzz node server
+```
+
+- or by `sentry_dsn` secret property defined in `private/secret.json`
+```
+sudo node server
+```
+
+### Prometheus
+Shields uses [prom-client](https://github.com/siimon/prom-client) to provide [default metrics](https://prometheus.io/docs/instrumenting/writing_clientlibs/#standard-and-runtime-collectors). These metrics are disabled by default.
+You can enable them by `METRICS_PROMETHEUS_ENABLED` environment variable. Moreover access to metrics resource is blocked for requests from any IP address by default. You can provide a regular expression with allowed IP addresses by `METRICS_PROMETHEUS_ALLOWED_IPS` environment variable.
+```bash
+METRICS_PROMETHEUS_ENABLED=true METRICS_PROMETHEUS_ALLOWED_IPS="^127\.0\.0\.1$" npm start
+```
+Metrics are available at `/metrics` resource.

doc/service-tests.md

@@ -0,0 +1,312 @@
+Service tests
+=============
+
+When creating a badge for a new service or changing a badge's behavior,
+automated tests should be included. They serve three purposes:
+
+1. The contributor and reviewer can easily verify the code works as
+   intended.
+
+2. When a badge stops working due to an upstream API, maintainers can find out
+   right away.
+
+3. They speed up future contributors when they are debugging or improving a
+   badge.
+
+Test should cover:
+
+1. Valid behavior
+2. Optional parameters like tags or branches
+3. Any customized error handling
+4. If a non-trivial validator is defined, include tests for malformed responses
+
+
+Tutorial
+--------
+
+Before getting started, set up a development environment by following the
+[setup instructions](https://github.com/badges/shields/blob/master/doc/TUTORIAL.md#2-setup)
+
+We will write some tests for the [Wercker Build service](https://github.com/badges/shields/blob/master/services/wercker/wercker.service.js)
+
+### (1) Boilerplate
+
+The code for our badge is in `services/wercker/wercker.service.js`. Tests for this badge should be stored in `services/wercker/wercker.tester.js`.
+
+We'll start by adding some boilerplate to our file:
+
+```js
+'use strict'
+
+const Joi = require('joi')                                      // 1
+
+const createServiceTester = require('../create-service-tester') // 2
+const t = createServiceTester()                                 // 2
+
+module.exports = t                                              // 3
+```
+
+1. Import [Joi][] We'll use this to make assertions. This is the same library we use to define schema for validation in the main badge class.
+2. If our `.service.js` module exports a single class, we can `require('../create-service-tester')` and use convention to create a `ServiceTester` object. Calling `createServiceTester()` inside `services/wercker/wercker.tester.js` will create a `ServiceTester` object configured for the service exported in `services/wercker/wercker.service.js`. We will add our tests to this `ServiceTester` object `t`.
+3. `t` is exported from the module.
+
+### (2) Our First Test Case
+
+First we'll add a test for the typical case:
+
+```js
+const { isBuildStatus } = require('../test-validators')
+
+t.create('Build status')                     // 1
+  .get('/build/wercker/go-wercker-api.json') // 2
+  .expectJSONTypes(                          // 3
+    Joi.object().keys({                      // 4
+      name: 'build',                         // 5
+      value: isBuildStatus,                  // 6
+    })
+  )
+```
+
+1. The `create()` method adds a new test to the tester object.
+The chained-on calls come from the API testing framework [IcedFrisby][].
+Here's a [longer example][] and the complete [API guide][IcedFrisby API].
+2. We use the `get()` method to request a badge. There are several points to consider here:
+    * We need a real project to test against. In this case we have used [wercker/go-wercker-api](https://app.wercker.com/wercker/go-wercker-api/runs) but we could have chosen any stable project.
+    * Note that when we call our badge, we are allowing it to communicate with an external service without mocking the reponse. We write tests which interact with external services, which is unusual practice in unit testing. We do this because one of the purposes of service tests is to notify us if a badge has broken due to an upstream API change. For this reason it is important for at least one test to call the live API without mocking the interaction.
+    * All badges on shields can be requested in a number of formats. As well as calling https://img.shields.io/wercker/build/wercker/go-wercker-api.svg to generate ![](https://img.shields.io/wercker/build/wercker/go-wercker-api.svg) we can also call https://img.shields.io/wercker/build/wercker/go-wercker-api.json to request the same content as JSON. When writing service tests, we request the badge in JSON format so it is easier to make assertions about the content.
+    * We don't need to explicitly call `/wercker/build/wercker/go-wercker-api.json` here, only `/build/wercker/go-wercker-api.json`. When we create a tester object with `createServiceTester()` the URL base defined in our service class (in this case `/wercker`) is used as the base URL for any requests made by the tester object.
+3. `expectJSONTypes()` is an IcedFrisby method which accepts a [Joi][] schema.
+Joi is a validation library that is build into IcedFrisby which you can use to
+match based on a set of allowed strings, regexes, or specific values. You can
+refer to their [API reference][Joi API].
+4. `Joi.object().keys()` defines a Joi object schema containing some defined keys
+5. We expect `name` to be a string literal `"build"`
+6. Because this test depends on a live service, we don't want our test to depend on our API call returning a particular build status. Instead we should perform a "picture check" to assert that the badge data conforms to an expected pattern. Our test should not depend on the status of the example project's build, but should fail if trying to generate the badge throws an error, or if there is a breaking change to the upstream API. In this case we will use a pre-defined regular expression to check that the badge value looks like a build status. [services/test-validators.js](https://github.com/badges/shields/blob/master/services/test-validators.js) defines a number of useful validators we can use. Many of the common badge types (version, downloads, rank, etc.) already have validators defined here.
+
+When defining an IcedFrisby test, typically you would invoke the `toss()`
+method, to register the test. This is not necessary, because the Shields test
+harness will call it for you.
+
+[IcedFrisby]: https://github.com/MarkHerhold/IcedFrisby
+[longer example]: https://github.com/MarkHerhold/IcedFrisby/#show-me-some-code
+[IcedFrisby API]: https://github.com/MarkHerhold/IcedFrisby/blob/master/API.md
+[Joi]: https://github.com/hapijs/joi
+[Joi API]: https://github.com/hapijs/joi/blob/master/API.md
+
+### (3) Running the Tests
+
+Lets run the test we have written:
+
+```
+npm run test:services -- --only=wercker
+```
+
+The `--only=` option indicates which service or services you want to test. You
+can provide a comma-separated list here.
+
+The `--` tells the NPM CLI to pass the remaining arguments through to the test
+runner.
+
+Here's the output:
+
+```
+Server is starting up: http://lib/service-test-runner/cli.js:80/
+  Wercker
+    Build status
+      ✓
+        [ GET /build/wercker/go-wercker-api.json ] (572ms)
+
+  1 passing (1s)
+```
+
+That's looking good!
+
+Sometimes if we have a failing test, it is useful to be able to see some logging output to help work out why the test is failing. We can do that by calling `npm run test:services:trace`. Try running
+
+```
+npm run test:services:trace -- --only=wercker
+```
+
+to run the test with some additional debug output.
+
+### (4) Writing More Tests
+
+We should write tests cases for valid paths through our code. The Wercker badge supports an optional branch parameter so we'll add a second test for a branch build.
+
+```js
+t.create('Build status (with branch)')
+  .get('/build/wercker/go-wercker-api/master.json')
+  .expectJSONTypes(
+    Joi.object().keys({
+      name: 'build',
+      value: isBuildStatus,
+    })
+  )
+```
+
+```
+Server is starting up: http://lib/service-test-runner/cli.js:80/
+  Wercker
+    Build status
+      ✓
+        [ GET /build/wercker/go-wercker-api.json ] (572ms)
+    Build status (with branch)
+      ✓
+        [ GET /build/wercker/go-wercker-api/master.json ] (368ms)
+
+  2 passing (1s)
+```
+
+Once we have multiple tests, sometimes it is useful to run only one test. We can do this using the `--fgrep` argument. For example:
+
+```
+npm run test:services -- --only="wercker" --fgrep="Build status (with branch)"
+```
+
+Having covered the typical and custom cases, we'll move on to errors. We should include a test for the 'not found' response and also tests for any other cusom error handling. The Wercker integration defines a custom error condition for 401 as well as a custom 404 message:
+
+```js
+errorMessages: {
+  401: 'private application not supported',
+  404: 'application not found',
+}
+```
+
+First we'll add a test for a project which will return a 404 error:
+
+```js
+t.create('Build status (application not found)')
+  .get('/build/some-project/that-doesnt-exist.json')
+  .expectJSON({ name: 'build', value: 'application not found' })
+```
+
+In this case we are expecting an object literal instead of a pattern so we should use `expectJSON()` instead of `expectJSONTypes()`. This is more concise and gives us a more helpful error message if the test fails.
+
+We also want to include a test for the 'private application not supported' case. One way to do this would be to find another example of a private project which is unlikely to change. For example:
+
+```js
+t.create('Build status (private application)')
+  .get('/build/wercker/blueprint.json')
+  .expectJSON({ name: 'build', value: 'private application not supported' })
+```
+
+## (5) Mocking Responses
+
+If we didn't have a stable example of a private project, another approach would be to mock the response. An alternative test for the 'private application' case might look like:
+
+```js
+t.create('Build status (private application)')
+  .get('/build/wercker/go-wercker-api.json')
+  .intercept(nock => nock('https://app.wercker.com/api/v3/applications/')
+    .get('/wercker/go-wercker-api/builds?limit=1')
+    .reply(401)
+  )
+  .expectJSON({ name: 'build', value: 'private application not supported' })
+```
+
+This will intercept the request and provide our own mock response.
+We use the `intercept()` method provided by the
+[icedfrisby-nock plugin][icedfrisby-nock]. It takes a setup function,
+which returns an interceptor, and exposes the full API of the HTTP mocking
+library [Nock][].
+
+Nock is fussy. All parts of a request must match perfectly for the mock to
+take effect, including the HTTP method (in this case GET), scheme (https), host,
+and path.
+
+[icedfrisby-nock]: https://github.com/paulmelnikow/icedfrisby-nock#usage
+[Nock]: https://github.com/node-nock/nock
+
+Our test suite should also include service tests which receive a known value from the API. For example, in the `render()` method of our service, there is some logic which sets the badge color based on the build status:
+
+```js
+static render({ status, result }) {
+  if (status === 'finished') {
+    if (result === 'passed') {
+      return { message: 'passing', color: 'brightgreen' }
+    } else {
+      return { message: result, color: 'red' }
+    }
+  }
+  return { message: status }
+}
+```
+
+We can also use nock to intercept API calls to return a known response body.
+
+```js
+const { colorScheme } = require('../test-helpers')
+
+t.create('Build passed (mocked)')
+  .get('/build/wercker/go-wercker-api.json?style=_shields_test')
+  .intercept(nock =>
+    nock('https://app.wercker.com/api/v3/applications/')
+      .get('/wercker/go-wercker-api/builds?limit=1')
+      .reply(200, [{ status: 'finished', result: 'passed' }])
+  )
+  .expectJSON({ name: 'build', value: 'passing', colorB: colorScheme.brightgreen })
+
+t.create('Build failed (mocked)')
+  .get('/build/wercker/go-wercker-api.json?style=_shields_test')
+  .intercept(nock =>
+    nock('https://app.wercker.com/api/v3/applications/')
+      .get('/wercker/go-wercker-api/builds?limit=1')
+      .reply(200, [{ status: 'finished', result: 'failed' }])
+  )
+  .expectJSON({ name: 'build', value: 'failed', colorB: colorScheme.red })
+```
+
+Note that in these tests, we are passing the URL parameter `?style=_shields_test`. This returns a JSON response which also contains the color. This is helpful in a case like this when we want to test custom color logic, but it is only necessary to explicitly test color values if our badge implements custom logic for setting the badge colors. Using the `colorScheme` test helper here allows us to test against named colors instead of literal hex values, so we can write
+
+```js
+.expectJSON({ name: 'build', value: 'failed', colorB: colorScheme.red })
+```
+
+instead of
+
+```js
+.expectJSON({ name: 'build', value: 'passing', colorB: '#e05d44' })
+```
+
+Code coverage
+-------------
+
+By checking code coverage, we can make sure we've covered all our bases.
+
+We can generate a coverage report and open it:
+
+```
+npm run coverage:test:services -- --only=wercker
+npm run coverage:report:open
+```
+
+Pull requests
+-------------
+
+The affected service ids should be included in brackets in the pull request
+title. That way, Travis will run those service tests. When a pull request
+affects multiple services, they should be separated with spaces. The test
+runner is case-insensitive, so they should be capitalized for readability.
+
+For example:
+
+- [Travis] Fix timeout issues
+- [Travis Sonar] Support user token authentication
+- Add tests for [CRAN] and [CPAN]
+
+
+Getting help
+------------
+
+If you have questions about how to write your tests, please open an issue. If
+there's already an issue open for the badge you're working on, you can post a
+comment there instead.
+
+
+Further reading
+---------------
+
+- [IcedFrisby API][]
+- [Joi API][]
+- [icedfrisby-nock][]
+- [Nock API](https://github.com/node-nock/nock#use)

doc/users.md

@@ -0,0 +1,50 @@
+# Notable Projects Using Shields
+
+- https://github.com/AFNetworking/AFNetworking
+- https://github.com/angular/angular.js
+- https://github.com/ansible/ansible
+- https://github.com/apple/swift
+- https://github.com/atom/atom
+- https://github.com/babel/babel
+- https://github.com/bevacqua/dragula
+- https://github.com/bower/bower
+- https://github.com/chartjs/Chart.js
+- https://github.com/creationix/nvm
+- https://github.com/discourse/discourse
+- https://github.com/docker/docker
+- https://github.com/electron/electron
+- https://github.com/elm-lang/core
+- https://github.com/emberjs/ember.js
+- https://github.com/expressjs/express
+- https://github.com/facebook/react
+- https://github.com/FortAwesome/Font-Awesome
+- https://github.com/gitlabhq/gitlabhq
+- https://github.com/gulpjs/gulp
+- https://github.com/h5bp/html5-boilerplate
+- https://github.com/jakubroztocil/httpie
+- https://github.com/jekyll/jekyll
+- https://github.com/kennethreitz/requests
+- https://github.com/kubernetes/kubernetes
+- https://github.com/laravel/laravel
+- https://github.com/less/less.js 
+- https://github.com/Microsoft/TypeScript
+- https://github.com/Microsoft/vscode
+- https://github.com/mitchellh/vagrant
+- https://github.com/Modernizr/Modernizr
+- https://github.com/moment/moment
+- https://github.com/mrdoob/three.js
+- https://github.com/necolas/normalize.css
+- https://github.com/nodejs/node
+- https://github.com/plataformatec/devise
+- https://github.com/postcss/postcss
+- https://github.com/rails/rails
+- https://github.com/reactjs/redux
+- https://github.com/socketio/socket.io
+- https://github.com/tensorflow/tensorflow
+- https://github.com/TryGhost/Ghost
+- https://github.com/twbs/bootstrap
+- https://github.com/videojs/video.js
+- https://github.com/vuejs/vue
+- https://github.com/webpack/webpack
+- https://github.com/yarnpkg/yarn
+- https://github.com/zurb/foundation-sites

frontend/.eslintrc.yml

@@ -0,0 +1 @@
+extends: '../.eslintrc-frontend.yml'

frontend/components/badge-examples.js

@@ -0,0 +1,149 @@
+import React from 'react'
+import { Link } from 'react-router-dom'
+import PropTypes from 'prop-types'
+import classNames from 'classnames'
+import resolveBadgeUrl from '../lib/badge-url'
+
+const Badge = ({
+  title,
+  exampleUrl,
+  previewUrl,
+  urlPattern,
+  documentation,
+  baseUrl,
+  longCache,
+  shouldDisplay = () => true,
+  onClick,
+}) => {
+  const handleClick = onClick
+    ? () =>
+        onClick({
+          title,
+          exampleUrl,
+          previewUrl,
+          urlPattern,
+          documentation,
+        })
+    : undefined
+
+  const previewImage = previewUrl ? (
+    <img
+      className={classNames('badge-img', { clickable: onClick })}
+      onClick={handleClick}
+      src={resolveBadgeUrl(previewUrl, baseUrl, { longCache })}
+      alt=""
+    />
+  ) : (
+    '\u00a0'
+  ) // non-breaking space
+  const resolvedExampleUrl = resolveBadgeUrl(
+    urlPattern || previewUrl,
+    baseUrl,
+    { longCache: false }
+  )
+
+  if (shouldDisplay()) {
+    return (
+      <tr>
+        <th
+          className={classNames({ clickable: onClick })}
+          onClick={handleClick}
+        >
+          {title}:
+        </th>
+        <td>{previewImage}</td>
+        <td>
+          <code
+            className={classNames({ clickable: onClick })}
+            onClick={handleClick}
+          >
+            {resolvedExampleUrl}
+          </code>
+        </td>
+      </tr>
+    )
+  }
+  return null
+}
+Badge.propTypes = {
+  title: PropTypes.string.isRequired,
+  exampleUrl: PropTypes.string,
+  previewUrl: PropTypes.string,
+  urlPattern: PropTypes.string,
+  documentation: PropTypes.string,
+  baseUrl: PropTypes.string,
+  longCache: PropTypes.bool.isRequired,
+  shouldDisplay: PropTypes.func,
+  onClick: PropTypes.func.isRequired,
+}
+
+const Category = ({ category, examples, baseUrl, longCache, onClick }) => {
+  if (examples.filter(example => example.shouldDisplay()).length === 0) {
+    return null
+  }
+  return (
+    <div>
+      <Link to={`/examples/${category.id}`}>
+        <h3 id={category.id}>{category.name}</h3>
+      </Link>
+      <table className="badge">
+        <tbody>
+          {examples.map(badgeData => (
+            <Badge
+              key={badgeData.key}
+              {...badgeData}
+              baseUrl={baseUrl}
+              longCache={longCache}
+              onClick={onClick}
+            />
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+}
+Category.propTypes = {
+  category: PropTypes.shape({
+    id: PropTypes.string.isRequired,
+    name: PropTypes.string.isRequired,
+  }).isRequired,
+  examples: PropTypes.arrayOf(
+    PropTypes.shape({
+      title: PropTypes.string.isRequired,
+      exampleUrl: PropTypes.string,
+      previewUrl: PropTypes.string,
+      urlPattern: PropTypes.string,
+      documentation: PropTypes.string,
+    })
+  ).isRequired,
+  baseUrl: PropTypes.string,
+  longCache: PropTypes.bool.isRequired,
+  onClick: PropTypes.func.isRequired,
+}
+
+const BadgeExamples = ({ categories, baseUrl, longCache, onClick }) => (
+  <div>
+    {categories.map((categoryData, i) => (
+      <Category
+        key={i}
+        {...categoryData}
+        baseUrl={baseUrl}
+        longCache={longCache}
+        onClick={onClick}
+      />
+    ))}
+  </div>
+)
+BadgeExamples.propTypes = {
+  categories: PropTypes.arrayOf(
+    PropTypes.shape({
+      category: Category.propTypes.category,
+      examples: Category.propTypes.examples,
+    })
+  ),
+  baseUrl: PropTypes.string,
+  longCache: PropTypes.bool.isRequired,
+  onClick: PropTypes.func.isRequired,
+}
+
+export { Badge, BadgeExamples }

frontend/components/dynamic-badge-maker.js

@@ -0,0 +1,102 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+import { dynamicBadgeUrl } from '../lib/badge-url'
+
+export default class DynamicBadgeMaker extends React.Component {
+  static propTypes = {
+    baseUrl: PropTypes.string,
+  }
+
+  state = {
+    datatype: '',
+    label: '',
+    url: '',
+    query: '',
+    color: '',
+    prefix: '',
+    suffix: '',
+  }
+
+  makeBadgeUrl() {
+    const { datatype, label, url, query, color, prefix, suffix } = this.state
+    const { baseUrl: baseUrl = document.location.href } = this.props
+    return dynamicBadgeUrl(baseUrl, datatype, label, url, query, {
+      color,
+      prefix,
+      suffix,
+    })
+  }
+
+  handleSubmit(e) {
+    e.preventDefault()
+    document.location = this.makeBadgeUrl()
+  }
+
+  get isValid() {
+    const { datatype, label, url, query } = this.state
+    return datatype && label && url && query
+  }
+
+  render() {
+    return (
+      <form onSubmit={e => this.handleSubmit(e)}>
+        <select
+          className="short"
+          value={this.state.datatype}
+          onChange={event => this.setState({ datatype: event.target.value })}
+        >
+          <option value="" disabled>
+            data type
+          </option>
+          <option value="json">json</option>
+          <option value="xml">xml</option>
+          <option value="yaml">yaml</option>
+        </select>{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.label}
+          onChange={event => this.setState({ label: event.target.value })}
+          placeholder="label"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.url}
+          onChange={event => this.setState({ url: event.target.value })}
+          placeholder="url"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.query}
+          onChange={event => this.setState({ query: event.target.value })}
+          placeholder="query"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.color}
+          onChange={event => this.setState({ color: event.target.value })}
+          placeholder="color"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.prefix}
+          onChange={event => this.setState({ prefix: event.target.value })}
+          placeholder="prefix"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.suffix}
+          onChange={event => this.setState({ suffix: event.target.value })}
+          placeholder="suffix"
+        />{' '}
+        {}
+        <button disabled={!this.isValid}>Make Badge</button>
+      </form>
+    )
+  }
+}

frontend/components/examples-page.js

@@ -0,0 +1,109 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+import Meta from './meta'
+import Header from './header'
+import SuggestionAndSearch from './suggestion-and-search'
+import SearchResults from './search-results'
+import MarkupModal from './markup-modal'
+import Usage from './usage'
+import Footer from './footer'
+import { baseUrl, longCache } from '../constants'
+
+export default class ExamplesPage extends React.Component {
+  constructor(props) {
+    super(props)
+    this.state = {
+      category: props.match.params.id,
+      query: null,
+      example: null,
+      searchReady: true,
+    }
+    this.searchTimeout = 0
+    this.renderSearchResults = this.renderSearchResults.bind(this)
+    this.searchQueryChanged = this.searchQueryChanged.bind(this)
+  }
+
+  static propTypes = {
+    match: PropTypes.object.isRequired,
+  }
+
+  searchQueryChanged(query) {
+    this.setState({ searchReady: false })
+    /*
+    Add a small delay before showing search results
+    so that we wait until the user has stipped typing
+    before we start loading stuff.
+
+    This
+    a) reduces the amount of badges we will load and
+    b) stops the page from 'flashing' as the user types, like this:
+    https://user-images.githubusercontent.com/7288322/42600206-9b278470-85b5-11e8-9f63-eb4a0c31cb4a.gif
+    */
+    window.clearTimeout(this.searchTimeout)
+    this.searchTimeout = window.setTimeout(() => {
+      this.setState({
+        searchReady: true,
+        query,
+      })
+    }, 500)
+  }
+
+  renderSearchResults() {
+    if (this.state.searchReady) {
+      if (this.state.query != null && this.state.query.length === 1) {
+        return <div>Search term must have 2 or more characters</div>
+      } else {
+        return (
+          <SearchResults
+            category={this.state.category}
+            query={this.state.query}
+            clickHandler={example => {
+              this.setState({ example })
+            }}
+          />
+        )
+      }
+    } else {
+      return <div>searching...</div>
+    }
+  }
+
+  render() {
+    return (
+      <div>
+        <Meta />
+        <Header />
+        <MarkupModal
+          example={this.state.example}
+          onRequestClose={() => {
+            this.setState({ example: null })
+          }}
+          baseUrl={baseUrl}
+          key={this.state.example}
+        />
+        <section>
+          <SuggestionAndSearch
+            queryChanged={this.searchQueryChanged}
+            onBadgeClick={example => {
+              this.setState({ example })
+            }}
+            baseUrl={baseUrl}
+            longCache={longCache}
+          />
+          <a className="donate" href="https://opencollective.com/shields">
+            donate
+          </a>
+        </section>
+        {this.renderSearchResults()}
+        <Usage baseUrl={baseUrl} longCache={longCache} />
+        <Footer baseUrl={baseUrl} />
+        <style jsx>{`
+          .donate {
+            text-decoration: none;
+            color: rgba(0, 0, 0, 0.1);
+          }
+        `}</style>
+      </div>
+    )
+  }
+}

frontend/components/footer.js

@@ -0,0 +1,61 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+import resolveUrl from '../lib/resolve-url'
+
+const Footer = ({ baseUrl }) => (
+  <section>
+    <h2 id="like-this">Like This?</h2>
+
+    <p>
+      <object
+        data={resolveUrl(
+          '/twitter/follow/shields_io.svg?style=social&label=Follow',
+          baseUrl
+        )}
+        alt="Follow @shields_io"
+      />{' '}
+      {}
+      <a href="https://opencollective.com/shields" alt="Donate to us!">
+        <img src="https://opencollective.com/shields/backers/badge.svg?style=social" />
+      </a>{' '}
+      {}
+      <a href="https://opencollective.com/shields" alt="Donate to us!">
+        <img src="https://opencollective.com/shields/sponsors/badge.svg?style=social" />
+      </a>{' '}
+      {}
+      <object
+        data={resolveUrl(
+          '/github/forks/badges/shields.svg?style=social&label=Fork',
+          baseUrl
+        )}
+        alt="Fork on GitHub"
+      />{' '}
+      {}
+      <object
+        data={resolveUrl(
+          '/discord/308323056592486420.svg?style=social&label=Chat&link=https://discord.gg/HjJCwm5',
+          baseUrl
+        )}
+        alt="chat on Discord"
+      />
+    </p>
+
+    <p>
+      What is your favorite badge service to use?
+      <br />
+      <a href="https://github.com/badges/shields/blob/master/CONTRIBUTING.md">
+        Tell us
+      </a>{' '}
+      and we might bring it to you!
+    </p>
+
+    <p className="spaced-row">
+      <a href="https://status.shields.io/">Status</a>
+      <a href="https://github.com/badges/shields/">GitHub</a>
+    </p>
+  </section>
+)
+export default Footer
+Footer.propTypes = {
+  baseUrl: PropTypes.string.isRequired,
+}

frontend/components/header.js

@@ -0,0 +1,23 @@
+import { Link } from 'react-router-dom'
+import React from 'react'
+
+export default () => (
+  <section>
+    <Link to="/">
+      <img alt="Shields.io" src="/static/logo.svg" />
+    </Link>
+
+    <hr className="spacing" />
+
+    <p className="highlights">
+      Pixel-perfect &nbsp; Retina-ready &nbsp; Fast &nbsp; Consistent &nbsp;
+      Hackable &nbsp; No tracking
+    </p>
+
+    <style jsx>{`
+      .highlights {
+        font-style: italic;
+      }
+    `}</style>
+  </section>
+)

frontend/components/markup-modal.js

@@ -0,0 +1,190 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+import Modal from 'react-modal'
+import ClickToSelect from '@mapbox/react-click-to-select'
+import resolveBadgeUrl from '../lib/badge-url'
+import generateAllMarkup from '../lib/generate-image-markup'
+import { advertisedStyles } from '../../supported-features.json'
+
+export default class MarkupModal extends React.Component {
+  static propTypes = {
+    example: PropTypes.shape({
+      title: PropTypes.string.isRequired,
+      exampleUrl: PropTypes.string,
+      previewUrl: PropTypes.string,
+      urlPattern: PropTypes.string,
+      documentation: PropTypes.string,
+      link: PropTypes.string,
+    }),
+    baseUrl: PropTypes.string.isRequired,
+    onRequestClose: PropTypes.func.isRequired,
+  }
+
+  state = {
+    exampleUrl: null,
+    badgeUrl: null,
+    link: '',
+    style: 'flat',
+  }
+
+  constructor(props) {
+    super(props)
+
+    // Transfer `badgeUrl` and `link` into state so they can be edited by the
+    // user.
+    const { example, baseUrl } = props
+    if (example) {
+      const { exampleUrl, urlPattern, previewUrl, link } = example
+      this.state = {
+        ...this.state,
+        exampleUrl: exampleUrl
+          ? resolveBadgeUrl(exampleUrl, baseUrl || window.location.href)
+          : null,
+        badgeUrl: resolveBadgeUrl(
+          urlPattern || previewUrl,
+          baseUrl || window.location.href
+        ),
+        link: !link ? '' : link,
+      }
+    }
+  }
+
+  get isOpen() {
+    return this.props.example !== null
+  }
+
+  generateCompleteBadgeUrl() {
+    const { baseUrl } = this.props
+    const { badgeUrl, style } = this.state
+
+    return resolveBadgeUrl(
+      badgeUrl,
+      baseUrl || window.location.href,
+      // Default style doesn't need to be specified.
+      style === 'flat' ? undefined : { style }
+    )
+  }
+
+  generateMarkup() {
+    if (!this.isOpen) {
+      return {}
+    }
+
+    const { title } = this.props.example
+    const { link } = this.state
+    const completeBadgeUrl = this.generateCompleteBadgeUrl()
+    return generateAllMarkup(completeBadgeUrl, link, title)
+  }
+
+  renderDocumentation() {
+    if (!this.isOpen) {
+      return null
+    }
+
+    const { documentation } = this.props.example
+    return documentation ? (
+      <div>
+        <h4>Documentation</h4>
+        <div dangerouslySetInnerHTML={{ __html: documentation }} />
+      </div>
+    ) : null
+  }
+
+  render() {
+    const { markdown, reStructuredText, asciiDoc } = this.generateMarkup()
+
+    const completeBadgeUrl = this.isOpen
+      ? this.generateCompleteBadgeUrl()
+      : undefined
+
+    return (
+      <Modal
+        isOpen={this.isOpen}
+        onRequestClose={this.props.onRequestClose}
+        contentLabel="Example Modal"
+      >
+        <form action="">
+          <p>
+            <img className="badge-img" src={completeBadgeUrl} />
+          </p>
+          <p>
+            <label>
+              Link&nbsp;
+              <input
+                type="url"
+                value={this.state.link}
+                onChange={event => {
+                  this.setState({ link: event.target.value })
+                }}
+              />
+            </label>
+          </p>
+          <p>
+            <label>
+              Image&nbsp;
+              <input
+                type="url"
+                value={this.state.badgeUrl}
+                onChange={event => {
+                  this.setState({ badgeUrl: event.target.value })
+                }}
+              />
+            </label>
+          </p>
+          {this.state.exampleUrl && (
+            <p>
+              Example&nbsp;
+              <ClickToSelect>
+                <input
+                  className="code clickable"
+                  readOnly
+                  value={this.state.exampleUrl}
+                />
+              </ClickToSelect>
+            </p>
+          )}
+          <p>
+            <label>
+              Style&nbsp;
+              <select
+                value={this.state.style}
+                onChange={event => {
+                  this.setState({ style: event.target.value })
+                }}
+              >
+                {advertisedStyles.map(style => (
+                  <option key={style} value={style}>
+                    {style}
+                  </option>
+                ))}
+              </select>
+            </label>
+          </p>
+          <p>
+            Markdown&nbsp;
+            <ClickToSelect>
+              <input className="code clickable" readOnly value={markdown} />
+            </ClickToSelect>
+          </p>
+          <p>
+            reStructuredText&nbsp;
+            <ClickToSelect>
+              <input
+                className="code clickable"
+                readOnly
+                value={reStructuredText}
+              />
+            </ClickToSelect>
+          </p>
+          <p>
+            AsciiDoc&nbsp;
+            <ClickToSelect>
+              <input className="code clickable" readOnly value={asciiDoc} />
+            </ClickToSelect>
+          </p>
+          {this.renderDocumentation()}
+        </form>
+      </Modal>
+    )
+  }
+}

frontend/components/meta.js

@@ -0,0 +1,21 @@
+import React from 'react'
+import Head from 'next/head'
+
+const description = `We serve fast and scalable informational images as badges
+for GitHub, Travis CI, Jenkins, WordPress and many more services. Use them to
+track the state of your projects, or for promotional purposes.`
+
+export default () => (
+  <Head>
+    <title>Shields.io: Quality metadata badges for open source projects</title>
+    <meta charSet="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <meta name="description" content={description} />
+    <link rel="icon" type="image/png" href="favicon.png" />
+    <link href="/static/main.css" rel="stylesheet" />
+    <link
+      href="https://fonts.googleapis.com/css?family=Lekton"
+      rel="stylesheet"
+    />
+  </Head>
+)

frontend/components/search-results.js

@@ -0,0 +1,53 @@
+import React from 'react'
+import { Link } from 'react-router-dom'
+import PropTypes from 'prop-types'
+import { BadgeExamples } from './badge-examples'
+import badgeExampleData from '../../badge-examples.json'
+import { prepareExamples, predicateFromQuery } from '../lib/prepare-examples'
+import { baseUrl, longCache } from '../constants'
+
+export default class SearchResults extends React.Component {
+  static propTypes = {
+    category: PropTypes.string,
+    query: PropTypes.string,
+    clickHandler: PropTypes.func.isRequired,
+  }
+
+  prepareExamples(category) {
+    const examples = category
+      ? badgeExampleData.filter(example => example.category.id === category)
+      : badgeExampleData
+    return prepareExamples(examples, () => predicateFromQuery(this.props.query))
+  }
+
+  renderExamples() {
+    return (
+      <BadgeExamples
+        categories={this.preparedExamples}
+        onClick={this.props.clickHandler}
+        baseUrl={baseUrl}
+        longCache={longCache}
+      />
+    )
+  }
+
+  renderCategoryHeadings() {
+    return this.preparedExamples.map((category, i) => (
+      <Link to={`/examples/${category.category.id}`} key={category.category.id}>
+        <h3 id={category.category.id}>{category.category.name}</h3>
+      </Link>
+    ))
+  }
+
+  render() {
+    this.preparedExamples = this.prepareExamples(this.props.category)
+
+    if (this.props.category) {
+      return this.renderExamples()
+    } else if (this.props.query == null || this.props.query.length === 0) {
+      return this.renderCategoryHeadings()
+    } else {
+      return this.renderExamples()
+    }
+  }
+}

frontend/components/static-badge-maker.js

@@ -0,0 +1,71 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+import { staticBadgeUrl } from '../lib/badge-url'
+
+export default class StaticBadgeMaker extends React.Component {
+  static propTypes = {
+    baseUrl: PropTypes.string,
+  }
+
+  state = {
+    subject: '',
+    status: '',
+    color: '',
+  }
+
+  handleSubmit(e) {
+    e.preventDefault()
+
+    const { baseUrl } = this.props
+    const { subject, status, color } = this.state
+    const badgeUrl = staticBadgeUrl(
+      baseUrl || window.location.href,
+      subject,
+      status,
+      color
+    )
+
+    document.location = badgeUrl
+  }
+
+  render() {
+    return (
+      <form onSubmit={e => this.handleSubmit(e)}>
+        <input
+          className="short"
+          value={this.state.subject}
+          onChange={event => this.setState({ subject: event.target.value })}
+          placeholder="subject"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.status}
+          onChange={event => this.setState({ status: event.target.value })}
+          placeholder="status"
+        />{' '}
+        {}
+        <input
+          className="short"
+          value={this.state.color}
+          onChange={event => this.setState({ color: event.target.value })}
+          list="default-colors"
+          placeholder="color"
+        />{' '}
+        {}
+        <datalist id="default-colors">
+          <option value="brightgreen" />
+          <option value="green" />
+          <option value="yellowgreen" />
+          <option value="yellow" />
+          <option value="orange" />
+          <option value="red" />
+          <option value="lightgrey" />
+          <option value="blue" />
+        </datalist>{' '}
+        {}
+        <button>Make Badge</button>
+      </form>
+    )
+  }
+}

frontend/components/suggestion-and-search.js

@@ -0,0 +1,119 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+import fetchPonyfill from 'fetch-ponyfill'
+import debounce from 'lodash.debounce'
+import { Badge } from './badge-examples'
+import resolveUrl from '../lib/resolve-url'
+
+export default class SuggestionAndSearch extends React.Component {
+  static propTypes = {
+    queryChanged: PropTypes.func.isRequired,
+    onBadgeClick: PropTypes.func.isRequired,
+    baseUrl: PropTypes.string.isRequired,
+    longCache: PropTypes.bool.isRequired,
+  }
+
+  constructor(props) {
+    super(props)
+    this.queryChangedDebounced = debounce(props.queryChanged, 50, {
+      leading: true,
+    })
+  }
+
+  state = {
+    isUrl: false,
+    inProgress: false,
+    projectUrl: null,
+    suggestions: [],
+  }
+
+  queryChanged(query) {
+    const isUrl = query.startsWith('https://') || query.startsWith('http://')
+    this.setState({
+      isUrl,
+      projectUrl: isUrl ? query : null,
+    })
+
+    this.queryChangedDebounced(query)
+  }
+
+  getSuggestions() {
+    this.setState({ inProgress: true }, async () => {
+      const { baseUrl } = this.props
+      const { projectUrl } = this.state
+
+      const url = resolveUrl('/$suggest/v1', baseUrl, { url: projectUrl })
+
+      const fetch = window.fetch || fetchPonyfill
+      const res = await fetch(url)
+      let suggestions
+      try {
+        const json = await res.json()
+        // This doesn't validate the response. The default value here prevents
+        // a crash if the server returns {"err":"Disallowed"}.
+        suggestions = json.badges || []
+      } catch (e) {
+        suggestions = []
+      }
+
+      this.setState({ inProgress: false, suggestions })
+    })
+  }
+
+  renderSuggestions() {
+    const { baseUrl, longCache } = this.props
+    const { suggestions } = this.state
+
+    if (suggestions.length === 0) {
+      return null
+    }
+
+    return (
+      <table className="badge">
+        <tbody>
+          {suggestions.map(({ name, link, badge }, i) => (
+            // TODO We need to deal with `link`.
+            <Badge
+              key={i}
+              title={name}
+              previewUrl={badge}
+              onClick={() =>
+                this.props.onBadgeClick({
+                  title: name,
+                  previewUrl: badge,
+                  link,
+                })
+              }
+              baseUrl={baseUrl}
+              longCache={longCache}
+            />
+          ))}
+        </tbody>
+      </table>
+    )
+  }
+
+  render() {
+    return (
+      <section>
+        <form action="javascript:void 0" autoComplete="off">
+          <input
+            onChange={event => this.queryChanged(event.target.value)}
+            autofill="off"
+            autoFocus
+            placeholder="search / project URL"
+          />
+          <br />
+          <button
+            onClick={event => this.getSuggestions(event.target.value)}
+            disabled={this.state.inProgress}
+            hidden={!this.state.isUrl}
+          >
+            Suggest badges
+          </button>
+        </form>
+        {this.renderSuggestions()}
+      </section>
+    )
+  }
+}

frontend/components/usage.js

@@ -0,0 +1,287 @@
+import React, { Fragment } from 'react'
+import PropTypes from 'prop-types'
+import StaticBadgeMaker from './static-badge-maker'
+import DynamicBadgeMaker from './dynamic-badge-maker'
+import { staticBadgeUrl } from '../lib/badge-url'
+import { advertisedStyles, logos } from '../../supported-features.json'
+
+export default class Usage extends React.PureComponent {
+  static propTypes = {
+    baseUrl: PropTypes.string.isRequired,
+    longCache: PropTypes.bool.isRequired,
+  }
+
+  renderColorExamples() {
+    const { baseUrl, longCache } = this.props
+    const colors = [
+      'brightgreen',
+      'green',
+      'yellowgreen',
+      'yellow',
+      'orange',
+      'red',
+      'lightgrey',
+      'blue',
+      'ff69b4',
+    ]
+    return (
+      <p>
+        {colors.map((color, i) => (
+          <Fragment key={i}>
+            <img
+              className="badge-img"
+              src={staticBadgeUrl(baseUrl, 'color', color, color, {
+                longCache,
+              })}
+              alt={color}
+            />{' '}
+            {}
+          </Fragment>
+        ))}
+      </p>
+    )
+  }
+
+  renderStyleExamples() {
+    const { baseUrl, longCache } = this.props
+    return (
+      <table className="badge-img">
+        <tbody>
+          {advertisedStyles.map((style, i) => {
+            const badgeUrl = staticBadgeUrl(baseUrl, 'style', style, 'green', {
+              logo: 'appveyor',
+              longCache,
+              style,
+            })
+            return (
+              <tr key={i}>
+                <td>
+                  <img className="badge-img" src={badgeUrl} alt={style} />
+                </td>
+                <td>
+                  <code>{badgeUrl}</code>
+                </td>
+              </tr>
+            )
+          })}
+        </tbody>
+      </table>
+    )
+  }
+
+  static renderNamedLogos() {
+    const renderLogo = logo => (
+      <span className="nowrap" key={logo}>
+        {logo}
+      </span>
+    )
+    const [first, ...rest] = logos
+    return [renderLogo(first)].concat(
+      rest.reduce((result, logo) => result.concat([', ', renderLogo(logo)]), [])
+    )
+  }
+
+  render() {
+    const { baseUrl } = this.props
+    return (
+      <section>
+        <h2 id="your-badge">Your Badge</h2>
+
+        <h3 id="static-badge">Static</h3>
+        <StaticBadgeMaker baseUrl={baseUrl} />
+
+        <hr className="spacing" />
+
+        <p>
+          <code>
+            {baseUrl}
+            /badge/&lt;SUBJECT&gt;-&lt;STATUS&gt;-&lt;COLOR&gt;.svg
+          </code>
+        </p>
+        <table className="centered">
+          <tbody>
+            <tr>
+              <td>
+                Dashes <code>--</code>
+              </td>
+              <td>→</td>
+              <td>
+                <code>-</code> Dash
+              </td>
+            </tr>
+            <tr>
+              <td>
+                Underscores <code>__</code>
+              </td>
+              <td>→</td>
+              <td>
+                <code>_</code> Underscore
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>_</code> or Space <code>&nbsp;</code>
+              </td>
+              <td>→</td>
+              <td>
+                <code>&nbsp;</code> Space
+              </td>
+            </tr>
+          </tbody>
+        </table>
+
+        {this.renderColorExamples()}
+
+        <h3 id="dynamic-badge">Dynamic</h3>
+
+        <DynamicBadgeMaker baseUrl={baseUrl} />
+
+        <p>
+          <code>
+            /badge/dynamic/json.svg?url=&lt;URL&gt;&amp;label=&lt;LABEL&gt;&amp;query=&lt;
+            <a
+              href="https://www.npmjs.com/package/jsonpath"
+              target="_BLANK"
+              title="JSONdata syntax"
+            >
+              $.DATA.SUBDATA
+            </a>
+            &gt;&amp;colorB=&lt;COLOR&gt;&amp;prefix=&lt;PREFIX&gt;&amp;suffix=&lt;SUFFIX&gt;
+          </code>
+        </p>
+        <p>
+          <code>
+            /badge/dynamic/xml.svg?url=&lt;URL&gt;&amp;label=&lt;LABEL&gt;&amp;query=&lt;
+            <a
+              href="https://www.npmjs.com/package/xpath"
+              target="_BLANK"
+              title="XPath syntax"
+            >
+              //data/subdata
+            </a>
+            &gt;&amp;colorB=&lt;COLOR&gt;&amp;prefix=&lt;PREFIX&gt;&amp;suffix=&lt;SUFFIX&gt;
+          </code>
+        </p>
+        <p>
+          <code>
+            /badge/dynamic/yaml.svg?url=&lt;URL&gt;&amp;label=&lt;LABEL&gt;&amp;query=&lt;
+            <a
+              href="https://www.npmjs.com/package/jsonpath"
+              target="_BLANK"
+              title="JSONdata syntax"
+            >
+              $.DATA.SUBDATA
+            </a>
+            &gt;&amp;colorB=&lt;COLOR&gt;&amp;prefix=&lt;PREFIX&gt;&amp;suffix=&lt;SUFFIX&gt;
+          </code>
+        </p>
+
+        <hr className="spacing" />
+
+        <h2 id="styles">Styles</h2>
+
+        <p>
+          The following styles are available. Flat is the default. Examples are
+          shown with an optional logo:
+        </p>
+        {this.renderStyleExamples()}
+
+        <p>
+          Here are a few other parameters you can use: (connecting several with
+          "&" is possible)
+        </p>
+        <table className="usage">
+          <tbody>
+            <tr>
+              <td>
+                <code>?label=healthinesses</code>
+              </td>
+              <td>
+                Override the default left-hand-side text (
+                <a href="https://developer.mozilla.org/en-US/docs/Glossary/percent-encoding">
+                  URL-Encoding
+                </a>
+                {} needed for spaces or special characters!)
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>?logo=appveyor</code>
+              </td>
+              <td>
+                Insert one of the named logos from (
+                {this.constructor.renderNamedLogos()}) or{' '}
+                <a href="https://simpleicons.org/" target="_BLANK">
+                  simple-icons
+                </a>
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>?logo=data:image/png;base64,…</code>
+              </td>
+              <td>Insert custom logo image (≥ 14px high)</td>
+            </tr>
+            <tr>
+              <td>
+                <code>?logoColor=violet</code>
+              </td>
+              <td>
+                Set the color of the logo (hex, rgb, rgba, hsl, hsla and css
+                named colors supported)
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>?logoWidth=40</code>
+              </td>
+              <td>Set the horizontal space to give to the logo</td>
+            </tr>
+            <tr>
+              <td>
+                <code>?link=http://left&amp;link=http://right</code>
+              </td>
+              <td>
+                Specify what clicking on the left/right of a badge should do
+                (esp. for social badge style)
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>?colorA=abcdef</code>
+              </td>
+              <td>
+                Set background of the left part (hex, rgb, rgba, hsl, hsla and
+                css named colors supported)
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>?colorB=fedcba</code>
+              </td>
+              <td>
+                Set background of the right part (hex, rgb, rgba, hsl, hsla and
+                css named colors supported)
+              </td>
+            </tr>
+            <tr>
+              <td>
+                <code>?maxAge=3600</code>
+              </td>
+              <td>
+                Set the HTTP cache lifetime in secs (rules are applied to infer
+                a default value on a per-badge basis, any values specified below
+                the default will be ignored)
+              </td>
+            </tr>
+          </tbody>
+        </table>
+
+        <p>
+          We support <code>.svg</code>, <code>.json</code>, <code>.png</code>{' '}
+          and a few others, but use them responsibly.
+        </p>
+      </section>
+    )
+  }
+}

frontend/constants.js

@@ -0,0 +1,6 @@
+import envFlag from 'node-env-flag'
+
+const baseUrl = process.env.BASE_URL
+const longCache = envFlag(process.env.LONG_CACHE, false)
+
+export { baseUrl, longCache }

frontend/lib/badge-url.js

@@ -0,0 +1,52 @@
+import resolveUrl from './resolve-url'
+import { staticBadgeUrl as makeStaticBadgeUrl } from '../../lib/make-badge-url'
+
+export default function resolveBadgeUrl(
+  url,
+  baseUrl,
+  { longCache, style, queryParams: inQueryParams } = {}
+) {
+  const outQueryParams = Object.assign({}, inQueryParams)
+  if (longCache) {
+    outQueryParams.maxAge = '2592000'
+  }
+  if (style) {
+    outQueryParams.style = style
+  }
+  return resolveUrl(url, baseUrl, outQueryParams)
+}
+
+export function staticBadgeUrl(baseUrl, label, message, color, options) {
+  const path = makeStaticBadgeUrl({ label, message, color })
+  return resolveUrl(path, baseUrl, options)
+}
+
+// Options can include: { prefix, suffix, color, longCache, style, queryParams }
+export function dynamicBadgeUrl(
+  baseUrl,
+  datatype,
+  label,
+  dataUrl,
+  query,
+  { prefix, suffix, color, queryParams = {}, ...rest } = {}
+) {
+  Object.assign(queryParams, {
+    label,
+    url: dataUrl,
+    query,
+  })
+
+  if (color) {
+    queryParams.colorB = color
+  }
+  if (prefix) {
+    queryParams.prefix = prefix
+  }
+  if (suffix) {
+    queryParams.suffix = suffix
+  }
+
+  const outOptions = Object.assign({ queryParams }, rest)
+
+  return resolveBadgeUrl(`/badge/dynamic/${datatype}.svg`, baseUrl, outOptions)
+}

frontend/lib/badge-url.spec.js

@@ -0,0 +1,51 @@
+import { test, given } from 'sazerac'
+import resolveBadgeUrl, { staticBadgeUrl, dynamicBadgeUrl } from './badge-url'
+
+const resolveBadgeUrlWithLongCache = (url, baseUrl) =>
+  resolveBadgeUrl(url, baseUrl, { longCache: true })
+
+describe('Badge URL functions', function() {
+  test(resolveBadgeUrl, () => {
+    given('/badge/foo-bar-blue.svg', undefined).expect(
+      '/badge/foo-bar-blue.svg'
+    )
+    given('/badge/foo-bar-blue.svg', 'http://example.com').expect(
+      'http://example.com/badge/foo-bar-blue.svg'
+    )
+  })
+
+  test(resolveBadgeUrlWithLongCache, () => {
+    given('/badge/foo-bar-blue.svg', undefined).expect(
+      '/badge/foo-bar-blue.svg?maxAge=2592000'
+    )
+    given('/badge/foo-bar-blue.svg', 'http://example.com').expect(
+      'http://example.com/badge/foo-bar-blue.svg?maxAge=2592000'
+    )
+  })
+
+  test(staticBadgeUrl, () => {
+    given('http://img.example.com', 'foo', 'bar', 'blue', {
+      style: 'plastic',
+    }).expect('http://img.example.com/badge/foo-bar-blue.svg?style=plastic')
+  })
+
+  test(dynamicBadgeUrl, () => {
+    const dataUrl = 'http://example.com/foo.json'
+    const query = '$.bar'
+    const prefix = 'value: '
+
+    given('http://img.example.com', 'json', 'foo', dataUrl, query, {
+      prefix,
+      style: 'plastic',
+    }).expect(
+      [
+        'http://img.example.com/badge/dynamic/json.svg',
+        '?label=foo',
+        `&url=${encodeURIComponent(dataUrl)}`,
+        `&query=${encodeURIComponent(query)}`,
+        `&prefix=${encodeURIComponent(prefix)}`,
+        '&style=plastic',
+      ].join('')
+    )
+  })
+})

frontend/lib/generate-image-markup.js

@@ -0,0 +1,75 @@
+export function markdown(badgeUrl, link, title) {
+  const withoutLink = `![${title || ''}](${badgeUrl})`
+  if (link) {
+    return `[${withoutLink}](${link})`
+  } else {
+    return withoutLink
+  }
+}
+
+export function reStructuredText(badgeUrl, link, title) {
+  let result = `.. image:: ${badgeUrl}`
+  if (title) {
+    result += `   :alt: ${title}`
+  }
+  if (link) {
+    result += `   :target: ${link}`
+  }
+  return result
+}
+
+function quoteAsciiDocAttribute(attr) {
+  if (typeof attr === 'string') {
+    const withQuotesEscaped = attr.replace(/"/g, '\\"')
+    return `"${withQuotesEscaped}"`
+  } else if (attr == null) {
+    return 'None'
+  } else {
+    return attr
+  }
+}
+
+// lodash.mapvalues is huge!
+function mapValues(obj, iteratee) {
+  const result = {}
+  for (const k in obj) {
+    result[k] = iteratee(obj[k])
+  }
+  return result
+}
+
+export function renderAsciiDocAttributes(positional, named) {
+  // http://asciidoc.org/userguide.html#X21
+  const needsQuoting =
+    positional.some(attr => attr.includes(',')) || Object.keys(named).length > 0
+
+  if (needsQuoting) {
+    positional = positional.map(attr => quoteAsciiDocAttribute(attr))
+    named = mapValues(named, attr => quoteAsciiDocAttribute(attr))
+  }
+
+  const items = positional.concat(
+    Object.entries(named).map(([k, v]) => `${k}=${v}`)
+  )
+
+  if (items.length) {
+    return `[${items.join(',')}]`
+  } else {
+    return ''
+  }
+}
+
+export function asciiDoc(badgeUrl, link, title) {
+  const positional = title ? [title] : []
+  const named = link ? { link } : {}
+  const attrs = renderAsciiDocAttributes(positional, named)
+  return `image:${badgeUrl}${attrs}`
+}
+
+export default function generateAllMarkup(badgeUrl, link, title) {
+  // This is a wee bit "clever". It runs each of the three functions on the
+  // parameters provided, and returns the result in an object.
+  return mapValues({ markdown, reStructuredText, asciiDoc }, fn =>
+    fn(badgeUrl, link, title)
+  )
+}

frontend/lib/prepare-examples.js

@@ -0,0 +1,45 @@
+import escapeStringRegexp from 'escape-string-regexp'
+
+export function exampleMatchesRegex(example, regex) {
+  const { title, keywords } = example
+  const haystack = [title].concat(keywords).join(' ')
+  return regex.test(haystack)
+}
+
+export function predicateFromQuery(query) {
+  if (query) {
+    const escaped = escapeStringRegexp(query)
+    const regex = new RegExp(escaped, 'i') // Case-insensitive.
+    return example => exampleMatchesRegex(example, regex)
+  } else {
+    return () => true
+  }
+}
+
+export function mapExamples(categories, iteratee) {
+  return (
+    categories
+      .map(({ category, examples }) => ({
+        category,
+        examples: iteratee(examples),
+      }))
+      // Remove empty categories.
+      .filter(({ category, examples }) => examples.length > 0)
+  )
+}
+
+export function prepareExamples(categories, predicateProvider) {
+  let nextKey = 0
+  return mapExamples(categories, examples =>
+    examples.map(example =>
+      Object.assign(
+        {
+          shouldDisplay: () => predicateProvider()(example),
+          // Assign each example a unique ID.
+          key: nextKey++,
+        },
+        example
+      )
+    )
+  )
+}

frontend/lib/prepare-examples.spec.js

@@ -0,0 +1,18 @@
+import { test, given, forCases } from 'sazerac'
+import { predicateFromQuery } from './prepare-examples'
+
+describe('Badge example functions', function() {
+  const exampleMatchesQuery = (example, query) =>
+    predicateFromQuery(query)(example)
+
+  test(exampleMatchesQuery, () => {
+    forCases([given({ title: 'node version' }, 'npm')]).expect(false)
+
+    forCases([
+      given({ title: 'node version', keywords: ['npm'] }, 'node'),
+      given({ title: 'node version', keywords: ['npm'] }, 'npm'),
+      // https://github.com/badges/shields/issues/1578
+      given({ title: 'c++ is the best language' }, 'c++'),
+    ]).expect(true)
+  })
+})

frontend/lib/resolve-url.js

@@ -0,0 +1,14 @@
+// I played with build-url and url-resolve-browser and neither of them did the
+// right thing. Previously this was based on url-path, which patched around
+// the URL API. This caused problems in Firefox 57, but only in the production
+// build.
+import { resolve, parse, format } from 'url'
+
+// baseUrl and queryParams are optional.
+export default function resolveUrl(url, baseUrl, queryParams) {
+  const resolved = baseUrl ? resolve(baseUrl, url) : url
+  const parsed = parse(resolved, /* parseQueryString */ true)
+  parsed.query = Object.assign({}, parsed.query, queryParams)
+  delete parsed.search
+  return format(parsed)
+}

frontend/lib/resolve-url.spec.js

@@ -0,0 +1,29 @@
+import { test, given, forCases } from 'sazerac'
+import resolveUrl from './resolve-url'
+
+describe('URL resolver', function() {
+  test(resolveUrl, () => {
+    forCases([
+      given('/foo/bar'),
+      given('/foo/bar', '/'),
+      given('/foo/bar', '/baz'),
+      given('/foo/bar', '/baz/'),
+      given('/foo/bar', ''),
+      given('/foo/bar', undefined),
+    ]).expect('/foo/bar')
+
+    given('foo/bar', '/baz/').expect('/baz/foo/bar')
+
+    forCases([
+      given('http://foo/bar'),
+      given('bar', 'http://foo/'),
+      given('/bar', 'http://foo/'),
+    ]).expect('http://foo/bar')
+
+    given('/foo/bar', '/baz', { baz: 'bazinga' }).expect('/foo/bar?baz=bazinga')
+
+    given('/foo/bar?thing=1', undefined, { other: '2' }).expect(
+      '/foo/bar?thing=1&other=2'
+    )
+  })
+})

gh-badge.js

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-var path = require('path');
-var badge = require(path.join(__dirname, 'badge.js'));
-var svg2img = require(path.join(__dirname, 'svg-to-img.js'));
-var colorscheme = require(path.join(__dirname, 'colorscheme.json'));
-if (process.argv.length < 4) {
-  console.log('Usage: badge subject status [:colorscheme] [.output] [@style]');
-  console.log('Or:    badge subject status right-color [left-color] [.output] [@style]');
-  console.log();
-  console.log('  colorscheme: one of '
-      + Object.keys(colorscheme).join(', ') + '.');
-  console.log('  left-color, right-color:');
-  console.log('    #xxx (three hex digits)');
-  console.log('    #xxxxxx (six hex digits)');
-  console.log('    color (CSS color)');
-  console.log('  output:');
-  console.log('    svg, png, jpg, or gif');
-  console.log();
-  console.log('Eg: badge cactus grown :green @flat');
-  console.log();
-  process.exit();
-}
-
-// Find a format specifier.
-var format = 'svg';
-var style = '';
-for (var i = 4; i < process.argv.length; i++) {
-  if (process.argv[i][0] === '.') {
-    format = process.argv[i].slice(1);
-    process.argv.splice(i, 1);
-    continue;
-  }
-  if (process.argv[i][0] === '@') {
-    style = process.argv[i].slice(1);
-    process.argv.splice(i, 1);
-    continue;
-  }
-}
-
-var subject = process.argv[2];
-var status = process.argv[3];
-var color = process.argv[4] || ':green';
-var colorA = process.argv[5];
-
-var badgeData = {text: [subject, status], format: format};
-if (style) {
-  badgeData.template = style;
-}
-
-if (color[0] === ':') {
-  color = color.slice(1);
-  if (colorscheme[color] == null) {
-    // Colorscheme not found.
-    console.error('Invalid color scheme.');
-    process.exit(1);
-  }
-  badgeData.colorscheme = color;
-} else {
-  badgeData.colorB = color;
-  if (colorA) { badgeData.colorA = colorA; }
-}
-
-badge(badgeData, function produceOutput(svg) {
-  if (/png|jpg|gif/.test(format)) {
-    svg2img(svg, format, process.stdout);
-  } else {
-    console.log(svg);
-  }
-});

gh-badges/.npmignore

@@ -0,0 +1,2 @@
+lib/make-badge-test-helpers.js
+lib/**/*.spec.js

gh-badges/CHANGELOG.md

@@ -0,0 +1,140 @@
+# Changelog
+
+## 2.1.0
+
+gh-badges v2.1.0 implements a new text width measurer which uses a lookup table, removing the dependency
+on PDFKit. It is no longer necessary to provide a local copy of Verdana for accurate text width computation.
+
+As such, the `fontPath` and `precomputeWidths` parameters are now deprecated. The recommended call to create an instance of `BadgeFactory` is now
+
+```js
+const bf = new BadgeFactory()
+```
+
+For backwards compatibility you can still construct an instance of `BadgeFactory` with a call like
+
+```js
+const bf = new BadgeFactory({ fontPath: '/path/to/Verdana.ttf', precomputeWidths: true })
+```
+
+However, the function will issue a warning.
+
+To clear the warning, change the code to:
+
+```js
+const bf = new BadgeFactory()
+```
+
+These arguments will be removed in a future release.
+
+To upgrade from v1.3.0, change your code from:
+
+```js
+const badge = require('gh-badges')
+
+const format = {
+  text: ['build', 'passed'],
+  colorscheme: 'green',
+  template: 'flat',
+}
+
+badge.loadFont('/path/to/Verdana.ttf', err => {
+  badge(format, (svg, err) => {
+    // svg is a string containing your badge
+  })
+})
+```
+
+to:
+
+```js
+const { BadgeFactory } = require('gh-badges')
+
+const bf = new BadgeFactory()
+
+const format = {
+  text: ['build', 'passed'],
+  colorscheme: 'green',
+  template: 'flat',
+}
+
+const svg = bf.create(format)
+```
+
+### Other changes in this release:
+
+* Remove unnecessary dependencies
+* Documentation improvements
+
+## 2.0.0 - 2018-11-09
+
+gh-badges v2.0.0 declares a new public interface which is synchronous.
+If your version 1.3.0 code looked like this:
+
+```js
+const badge = require('gh-badges')
+
+const format = {
+  text: ['build', 'passed'],
+  colorscheme: 'green',
+  template: 'flat',
+}
+
+badge.loadFont('/path/to/Verdana.ttf', err => {
+  badge(format, (svg, err) => {
+    // svg is a string containing your badge
+  })
+})
+```
+
+To upgrade to version 2.0.0, refactor you code to:
+
+```js
+const { BadgeFactory } = require('gh-badges')
+
+const bf = new BadgeFactory({ fontPath: '/path/to/Verdana.ttf' })
+
+const format = {
+  text: ['build', 'passed'],
+  colorscheme: 'green',
+  template: 'flat',
+}
+
+const svg = bf.create(format)
+```
+
+You can generate badges without a copy of Verdana, however font width computation is approximate and badges may be distorted.
+
+```js
+const bf = new BadgeFactory({ fallbackFontPath: 'Helvetica' })
+```
+
+
+## 1.3.0 - 2016-09-07
+
+Add support for optionally specifying the path to `Verdana.ttf`. In earlier versions, the file needed to be in the directory containing Shields.
+
+Without font path:
+
+```js
+const badge = require('gh-badges')
+
+badge({ text: [ 'build', 'passed' ], colorscheme: 'green' },
+  (svg, err) => {
+    // svg is a string containing your badge
+  })
+```
+
+With font path:
+
+```js
+const badge = require('gh-badges')
+
+// Optional step, to have accurate text width computation.
+badge.loadFont('/path/to/Verdana.ttf', err => {
+  badge({ text: ['build', 'passed'], colorscheme: 'green', template: 'flat' },
+    (svg, err) => {
+      // svg is a string containing your badge
+    })
+})
+```

gh-badges/LICENSE

@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>

gh-badges/README.md

@@ -0,0 +1,86 @@
+# gh-badges
+
+[![npm version](https://img.shields.io/npm/v/gh-badges.svg)](https://npmjs.org/package/gh-badges)
+[![npm license](https://img.shields.io/npm/l/gh-badges.svg)](https://npmjs.org/package/gh-badges)
+
+## Installation
+
+```sh
+npm install gh-badges
+```
+
+## Usage
+
+### On the console
+
+```sh
+npm install -g gh-badges
+badge build passed :green .png > mybadge.png
+```
+
+### As a library
+
+```js
+const { BadgeFactory } = require('gh-badges')
+
+const bf = new BadgeFactory()
+
+const format = {
+  text: ['build', 'passed'],
+  colorscheme: 'green',
+  template: 'flat',
+}
+
+const svg = bf.create(format)
+```
+
+## Format
+
+The format is the following:
+
+```js
+{
+  text: [ 'build', 'passed' ],  // Textual information shown, in order
+
+  format: 'svg',  // Also supports json
+
+  colorscheme: 'green',
+  // or ...
+  colorA: '#555',
+  colorB: '#4c1',
+
+  // See templates/ for a list of available templates.
+  // Each offers a different visual design.
+  template: 'flat',
+}
+```
+
+### See also
+
+- [colorscheme.json](./lib/colorscheme.json) for the `colorscheme` option
+- [templates/](./templates) for the `template` option
+
+
+## Defaults
+
+If you want to use a colorscheme, head to `lib/colorscheme.json`. Each scheme
+has a name and a [CSS/SVG color][] for the color used in the first box (for the
+first piece of text, field `colorA`) and for the one used in the second box
+(field `colorB`).
+
+[CSS/SVG color]: http://www.w3.org/TR/SVG/types.html#DataTypeColor
+
+```js
+"green": {
+  "colorB": "#4c1"
+}
+```
+
+Both `colorA` and `colorB` have default values. Usually, the first box uses the
+same dark grey, so you can rely on that default value by not providing a
+`"colorA"` field (such as above).
+
+You can also use the `"colorA"` and `"colorB"` fields directly in the badges if
+you don't want to make a color scheme for it. In that case, remove the
+`"colorscheme"` field altogether.
+

gh-badges/lib/badge-cli.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const makeBadge = require('./make-badge')
+const svg2img = require('./svg-to-img')
+const colorscheme = require('./colorscheme.json')
+
+if (process.argv.length < 4) {
+  console.log('Usage: badge subject status [:colorscheme] [.output] [@style]')
+  console.log(
+    'Or:    badge subject status right-color [left-color] [.output] [@style]'
+  )
+  console.log()
+  console.log(`  colorscheme: one of ${Object.keys(colorscheme).join(', ')}.`)
+  console.log('  left-color, right-color:')
+  console.log('    #xxx (three hex digits)')
+  console.log('    #xxxxxx (six hex digits)')
+  console.log('    color (CSS color)')
+  console.log('  output:')
+  console.log('    svg, png, jpg, or gif')
+  console.log()
+  console.log('Eg: badge cactus grown :green @flat')
+  console.log()
+  process.exit()
+}
+
+// Find a format specifier.
+let format = 'svg'
+let style = ''
+for (let i = 4; i < process.argv.length; i++) {
+  if (process.argv[i][0] === '.') {
+    format = process.argv[i].slice(1)
+    process.argv.splice(i, 1)
+    continue
+  }
+  if (process.argv[i][0] === '@') {
+    style = process.argv[i].slice(1)
+    process.argv.splice(i, 1)
+    continue
+  }
+}
+
+const subject = process.argv[2]
+const status = process.argv[3]
+let color = process.argv[4] || ':green'
+const colorA = process.argv[5]
+
+const badgeData = { text: [subject, status], format }
+if (style) {
+  badgeData.template = style
+}
+
+if (color[0] === ':') {
+  color = color.slice(1)
+  if (colorscheme[color] == null) {
+    // Colorscheme not found.
+    console.error('Invalid color scheme.')
+    process.exit(1)
+  }
+  badgeData.colorscheme = color
+} else {
+  badgeData.colorB = color
+  if (colorA) {
+    badgeData.colorA = colorA
+  }
+}
+
+async function main() {
+  const svg = makeBadge(badgeData)
+
+  if (/png|jpg|gif/.test(format)) {
+    const data = await svg2img(svg, format)
+    process.stdout.write(data)
+  } else {
+    console.log(svg)
+  }
+}
+
+;(async () => {
+  try {
+    await main()
+  } catch (e) {
+    console.error(e)
+    process.exit(1)
+  }
+})()

gh-badges/lib/badge-cli.spec.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const path = require('path')
+const isPng = require('is-png')
+const isSvg = require('is-svg')
+const { spawn } = require('child-process-promise')
+
+const { expect, use } = require('chai')
+use(require('chai-string'))
+use(require('sinon-chai'))
+
+function runCli(args) {
+  return spawn('node', [path.join(__dirname, 'badge-cli.js'), ...args], {
+    capture: ['stdout'],
+  })
+}
+
+describe('The CLI', function() {
+  it('should provide a help message', async function() {
+    const { stdout } = await runCli([])
+    expect(stdout).to.startWith('Usage')
+  })
+
+  it('should produce default badges', async function() {
+    const { stdout } = await runCli(['cactus', 'grown'])
+    expect(stdout)
+      .to.satisfy(isSvg)
+      .and.to.include('cactus')
+      .and.to.include('grown')
+  })
+
+  it('should produce colorschemed badges', async function() {
+    const { stdout } = await runCli(['cactus', 'grown', ':green'])
+    expect(stdout).to.satisfy(isSvg)
+  })
+
+  it('should produce right-color badges', async function() {
+    const { stdout } = await runCli(['cactus', 'grown', '#abcdef'])
+    expect(stdout)
+      .to.satisfy(isSvg)
+      .and.to.include('#abcdef')
+  })
+
+  it('should produce PNG badges', async function() {
+    const child = runCli(['cactus', 'grown', '.png'])
+
+    // The buffering done by `child-process-promise` doesn't seem correctly to
+    // handle binary data.
+    let chunk
+    child.childProcess.stdout.once('data', data => {
+      chunk = data
+    })
+
+    await child
+
+    expect(chunk).to.satisfy(isPng)
+  })
+})

gh-badges/lib/index.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const makeBadge = require('./make-badge')
+
+class BadgeFactory {
+  constructor(options) {
+    if (options !== undefined) {
+      console.error(
+        'BadgeFactory: Constructor options are deprecated and will be ignored'
+      )
+    }
+  }
+
+  /**
+   * Create a badge
+   *
+   * @param {object} format - Object specifying badge data
+   * @param {string[]} format.text
+   * @param {string} format.colorscheme
+   * @param {string} format.colorA
+   * @param {string} format.colorB
+   * @param {string} format.format
+   * @param {string} format.template
+   * @return {string} Badge in SVG or JSON format
+   * @see https://github.com/badges/shields/tree/master/gh-badges/README.md
+   */
+  create(format) {
+    return makeBadge(format)
+  }
+}
+
+module.exports = {
+  BadgeFactory,
+}

gh-badges/lib/index.spec.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { expect } = require('chai')
+const { BadgeFactory } = require('./index')
+const isSvg = require('is-svg')
+
+const bf = new BadgeFactory()
+
+describe('BadgeFactory class', function() {
+  it('should produce badge with valid input', function() {
+    expect(
+      bf.create({
+        text: ['build', 'passed'],
+        format: 'svg',
+        colorscheme: 'green',
+        template: 'flat',
+      })
+    ).to.satisfy(isSvg)
+  })
+})

gh-badges/lib/lru-cache.js

@@ -0,0 +1,138 @@
+'use strict'
+
+// In-memory KV, remove the oldest data when the capacity is reached.
+
+const typeEnum = {
+  unit: 0,
+  heap: 1,
+}
+
+function CacheSlot(key, value) {
+  this.key = key
+  this.value = value
+  this.older = null // Newest slot that is older than this slot.
+  this.newer = null // Oldest slot that is newer than this slot.
+}
+
+function Cache(capacity, type) {
+  if (!(this instanceof Cache)) {
+    return new Cache(capacity, type)
+  }
+  type = type || 'unit'
+  this.capacity = capacity
+  this.type = typeEnum[type]
+  this.cache = new Map() // Maps cache keys to CacheSlots.
+  this.newest = null // Newest slot in the cache.
+  this.oldest = null
+}
+
+Cache.prototype = {
+  set: function addToCache(cacheKey, cached) {
+    let slot = this.cache.get(cacheKey)
+    if (slot === undefined) {
+      slot = new CacheSlot(cacheKey, cached)
+      this.cache.set(cacheKey, slot)
+    }
+    this.makeNewest(slot)
+    const numItemsToRemove = this.limitReached()
+    if (numItemsToRemove > 0) {
+      for (let i = 0; i < numItemsToRemove; i++) {
+        this.removeOldest()
+      }
+    }
+  },
+
+  get: function getFromCache(cacheKey) {
+    const slot = this.cache.get(cacheKey)
+    if (slot !== undefined) {
+      this.makeNewest(slot)
+      return slot.value
+    }
+  },
+
+  has: function hasInCache(cacheKey) {
+    return this.cache.has(cacheKey)
+  },
+
+  makeNewest: function makeNewestSlot(slot) {
+    const previousNewest = this.newest
+    if (previousNewest === slot) {
+      return
+    }
+    const older = slot.older
+    const newer = slot.newer
+
+    if (older !== null) {
+      older.newer = newer
+    } else if (newer !== null) {
+      this.oldest = newer
+    }
+    if (newer !== null) {
+      newer.older = older
+    }
+    this.newest = slot
+
+    if (previousNewest !== null) {
+      slot.older = previousNewest
+      slot.newer = null
+      previousNewest.newer = slot
+    } else {
+      // If previousNewest is null, the cache used to be empty.
+      this.oldest = slot
+    }
+  },
+
+  removeOldest: function removeOldest() {
+    const cacheKey = this.oldest.key
+    if (this.oldest !== null) {
+      this.oldest = this.oldest.newer
+      if (this.oldest !== null) {
+        this.oldest.older = null
+      }
+    }
+    this.cache.delete(cacheKey)
+  },
+
+  // Returns the number of elements to remove if we're past the limit.
+  limitReached: function heuristic() {
+    if (this.type === typeEnum.unit) {
+      // Remove the excess.
+      return Math.max(0, this.cache.size - this.capacity)
+    } else if (this.type === typeEnum.heap) {
+      if (getHeapSize() >= this.capacity) {
+        console.log('LRU HEURISTIC heap:', getHeapSize())
+        // Remove half of them.
+        return this.cache.size >> 1
+      } else {
+        return 0
+      }
+    } else {
+      console.error(`Unknown heuristic '${this.type}' for LRU cache.`)
+      return 1
+    }
+  },
+
+  clear: function() {
+    this.cache.clear()
+    this.newest = null
+    this.oldest = null
+  },
+}
+
+// In bytes.
+let heapSize
+let heapSizeTimeout
+function getHeapSize() {
+  if (heapSizeTimeout == null) {
+    // Compute the heap size every 60 seconds.
+    heapSizeTimeout = setInterval(computeHeapSize, 60 * 1000)
+    return computeHeapSize()
+  } else {
+    return heapSize
+  }
+}
+function computeHeapSize() {
+  return (heapSize = process.memoryUsage().heapTotal)
+}
+
+module.exports = Cache

gh-badges/lib/lru-cache.spec.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const { expect } = require('chai')
+const LRU = require('./lru-cache')
+
+function expectCacheSlots(cache, keys) {
+  expect(cache.cache.size).to.equal(keys.length)
+
+  const slots = keys.map(k => cache.cache.get(k))
+
+  const first = slots[0]
+  const last = slots.slice(-1)[0]
+
+  expect(cache.oldest).to.equal(first)
+  expect(cache.newest).to.equal(last)
+
+  expect(first.older).to.be.null
+  expect(last.newer).to.be.null
+
+  for (let i = 0; i + 1 < slots.length; ++i) {
+    const current = slots[i]
+    const next = slots[i + 1]
+    expect(current.newer).to.equal(next)
+    expect(next.older).to.equal(current)
+  }
+}
+
+describe('The LRU cache', function() {
+  it('should support being called without new', function() {
+    const cache = LRU(1)
+    expect(cache).to.be.an.instanceof(LRU)
+  })
+
+  it('should support a zero capacity', function() {
+    const cache = new LRU(0)
+    cache.set('key', 'value')
+    expect(cache.cache.size).to.equal(0)
+  })
+
+  it('should support a one capacity', function() {
+    const cache = new LRU(1)
+    cache.set('key1', 'value1')
+    expectCacheSlots(cache, ['key1'])
+    cache.set('key2', 'value2')
+    expectCacheSlots(cache, ['key2'])
+    expect(cache.get('key1')).to.be.undefined
+    expect(cache.get('key2')).to.equal('value2')
+  })
+
+  it('should remove the oldest element when reaching capacity', function() {
+    const cache = new LRU(2)
+
+    cache.set('key1', 'value1')
+    cache.set('key2', 'value2')
+    cache.set('key3', 'value3')
+    cache.cache.get('key1')
+
+    expectCacheSlots(cache, ['key2', 'key3'])
+    expect(cache.cache.get('key1')).to.be.undefined
+    expect(cache.get('key1')).to.be.undefined
+    expect(cache.get('key2')).to.equal('value2')
+    expect(cache.get('key3')).to.equal('value3')
+  })
+
+  it('should make sure that resetting a key in cache makes it newest', function() {
+    const cache = new LRU(2)
+
+    cache.set('key', 'value')
+    cache.set('key2', 'value2')
+
+    expectCacheSlots(cache, ['key', 'key2'])
+
+    cache.set('key', 'value')
+
+    expectCacheSlots(cache, ['key2', 'key'])
+  })
+
+  describe('getting a key in the cache', function() {
+    context('when the requested key is oldest', function() {
+      it('should leave the keys in the expected order', function() {
+        const cache = new LRU(2)
+        cache.set('key1', 'value1')
+        cache.set('key2', 'value2')
+
+        expectCacheSlots(cache, ['key1', 'key2'])
+
+        expect(cache.get('key1')).to.equal('value1')
+
+        expectCacheSlots(cache, ['key2', 'key1'])
+      })
+    })
+
+    context('when the requested key is newest', function() {
+      it('should leave the keys in the expected order', function() {
+        const cache = new LRU(2)
+        cache.set('key1', 'value1')
+        cache.set('key2', 'value2')
+
+        expect(cache.get('key2')).to.equal('value2')
+
+        expectCacheSlots(cache, ['key1', 'key2'])
+      })
+    })
+
+    context('when the requested key is in the middle', function() {
+      it('should leave the keys in the expected order', function() {
+        const cache = new LRU(3)
+        cache.set('key1', 'value1')
+        cache.set('key2', 'value2')
+        cache.set('key3', 'value3')
+
+        expectCacheSlots(cache, ['key1', 'key2', 'key3'])
+
+        expect(cache.get('key2')).to.equal('value2')
+
+        expectCacheSlots(cache, ['key1', 'key3', 'key2'])
+      })
+    })
+  })
+
+  it('should clear', function() {
+    // Set up.
+    const cache = new LRU(2)
+    cache.set('key1', 'value1')
+    cache.set('key2', 'value2')
+
+    // Confidence check.
+    expect(cache.get('key1')).to.equal('value1')
+    expect(cache.get('key2')).to.equal('value2')
+
+    // Run.
+    cache.clear()
+
+    // Test.
+    expect(cache.get('key1')).to.be.undefined
+    expect(cache.get('key2')).to.be.undefined
+    expect(cache.cache.size).to.equal(0)
+  })
+})

gh-badges/lib/make-badge.js

@@ -0,0 +1,192 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const SVGO = require('svgo')
+const dot = require('dot')
+const anafanafo = require('anafanafo')
+const isCSSColor = require('is-css-color')
+
+// cache templates.
+const templates = {}
+const templateFiles = fs.readdirSync(path.join(__dirname, '..', 'templates'))
+dot.templateSettings.strip = false // Do not strip whitespace.
+templateFiles.forEach(async filename => {
+  if (filename[0] === '.') {
+    return
+  }
+  const templateData = fs
+    .readFileSync(path.join(__dirname, '..', 'templates', filename))
+    .toString()
+  const extension = path.extname(filename).slice(1)
+  const style = filename.slice(0, -`-template.${extension}`.length)
+  // Compile the template. Necessary to always have a working template.
+  templates[`${style}-${extension}`] = dot.template(templateData)
+  if (extension === 'svg') {
+    // Substitute dot code.
+    const mapping = new Map()
+    let mappingIndex = 1
+    const untemplatedSvg = templateData.replace(/{{.*?}}/g, match => {
+      // Weird substitution that currently works for all templates.
+      const mapKey = `99999990${mappingIndex}.1`
+      mappingIndex++
+      mapping.set(mapKey, match)
+      return mapKey
+    })
+
+    const svgo = new SVGO()
+    const { data, error } = await svgo.optimize(untemplatedSvg)
+
+    if (error !== undefined) {
+      console.error(
+        `Template ${filename}: ${error}\n` +
+          '  Generated untemplated SVG:\n' +
+          `---\n${untemplatedSvg}---\n`
+      )
+      return
+    }
+
+    // Substitute dot code back.
+    let svg = data
+    const unmappedKeys = []
+    mapping.forEach((value, key) => {
+      let keySubstituted = false
+      svg = svg.replace(RegExp(key, 'g'), () => {
+        keySubstituted = true
+        return value
+      })
+      if (!keySubstituted) {
+        unmappedKeys.push(key)
+      }
+    })
+    if (unmappedKeys.length > 0) {
+      console.error(
+        `Template ${filename} has unmapped keys ` +
+          `${unmappedKeys.join(', ')}.\n` +
+          '  Generated untemplated SVG:\n' +
+          `---\n${untemplatedSvg}\n---\n` +
+          '  Generated template:\n' +
+          `---\n${svg}\n---\n`
+      )
+      return
+    }
+
+    templates[`${style}-${extension}`] = dot.template(svg)
+  }
+})
+
+function escapeXml(s) {
+  if (s === undefined || typeof s !== 'string') {
+    return undefined
+  } else {
+    return s
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&apos;')
+  }
+}
+
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+// check if colorA/B is a colorscheme else check if it's a valid css3 color else return undefined and let the badge assign the default color
+function assignColor(color = '', colorschemeType = 'colorB') {
+  if (definedColorschemes[color] !== undefined) {
+    return definedColorschemes[color][colorschemeType] || undefined
+  } else if (isCSSColor(color)) {
+    return color
+  } else {
+    return undefined
+  }
+}
+
+const definedColorschemes = require(path.join(__dirname, 'colorscheme.json'))
+
+function makeBadge({
+  format,
+  template,
+  text,
+  colorscheme,
+  colorA,
+  colorB,
+  logo,
+  logoPosition,
+  logoWidth,
+  links = ['', ''],
+}) {
+  // String coercion.
+  text = text.map(value => `${value}`)
+
+  if (format !== 'json') {
+    format = 'svg'
+  }
+
+  if (!(`${template}-${format}` in templates)) {
+    template = format === 'svg' ? 'flat' : 'default'
+  }
+  if (template.startsWith('popout')) {
+    if (logo) {
+      logoPosition =
+        logoPosition <= 10 && logoPosition >= -10 ? logoPosition : 0
+      logoWidth = +logoWidth || 32
+    } else {
+      template = template.replace('popout', 'flat')
+    }
+  }
+  if (template === 'social') {
+    text[0] = capitalize(text[0])
+  } else if (template === 'for-the-badge') {
+    text = text.map(value => value.toUpperCase())
+  }
+
+  // colorA/B have a higher priority than colorscheme
+  colorA = colorA || colorscheme || undefined
+  colorB = colorB || colorscheme || undefined
+  colorA = assignColor(colorA, 'colorA')
+  colorB = assignColor(colorB, 'colorB')
+
+  const [left, right] = text
+  let leftWidth = (anafanafo(left) / 10) | 0
+  // Increase chances of pixel grid alignment.
+  if (leftWidth % 2 === 0) {
+    leftWidth++
+  }
+  let rightWidth = (anafanafo(right) / 10) | 0
+  // Increase chances of pixel grid alignment.
+  if (rightWidth % 2 === 0) {
+    rightWidth++
+  }
+
+  logoWidth = +logoWidth || (logo ? 14 : 0)
+
+  let logoPadding
+  if (left.length === 0) {
+    logoPadding = 0
+  } else {
+    logoPadding = logo ? 3 : 0
+  }
+
+  const context = {
+    text: [left, right],
+    escapedText: text.map(escapeXml),
+    widths: [leftWidth + 10 + logoWidth + logoPadding, rightWidth + 10],
+    links: links.map(escapeXml),
+    logo,
+    logoPosition,
+    logoWidth,
+    logoPadding,
+    colorA,
+    colorB,
+    escapeXml,
+  }
+
+  const templateFn = templates[`${template}-${format}`]
+
+  // The call to template() can raise an exception.
+  return templateFn(context)
+}
+
+module.exports = makeBadge

gh-badges/lib/make-badge.spec.js

@@ -0,0 +1,210 @@
+'use strict'
+
+const { test, given, forCases } = require('sazerac')
+const { expect } = require('chai')
+const snapshot = require('snap-shot-it')
+const eol = require('eol')
+const isSvg = require('is-svg')
+const makeBadge = require('./make-badge')
+const colorschemes = require('./colorscheme.json')
+
+function testColor(color = '') {
+  return JSON.parse(
+    makeBadge({
+      text: ['name', 'Bob'],
+      colorB: color,
+      format: 'json',
+      template: '_shields_test',
+    })
+  ).colorB
+}
+
+describe('The badge generator', function() {
+  describe('color test', function() {
+    test(testColor, () => {
+      // valid hex
+      given('#4c1').expect('#4c1')
+      given('#4C1').expect('#4C1')
+      given('#abc123').expect('#abc123')
+      given('#ABC123').expect('#ABC123')
+      // valid rgb(a)
+      given('rgb(0,128,255)').expect('rgb(0,128,255)')
+      given('rgba(0,128,255,0)').expect('rgba(0,128,255,0)')
+      // valid hsl(a)
+      given('hsl(100, 56%, 10%)').expect('hsl(100, 56%, 10%)')
+      given('hsla(25,20%,0%,0.1)').expect('hsla(25,20%,0%,0.1)')
+      // either a css named color or colorscheme
+      given('papayawhip').expect('papayawhip')
+      given('red').expect(colorschemes['red'].colorB)
+      given('green').expect(colorschemes['green'].colorB)
+      given('blue').expect(colorschemes['blue'].colorB)
+      given('yellow').expect(colorschemes['yellow'].colorB)
+
+      forCases(
+        // invalid hex
+        given('#123red'), // contains letter above F
+        given('#red'), // contains letter above F
+        given('123456'), // contains no # symbol
+        given('123'), // contains no # symbol
+        // invalid rgb(a)
+        given('rgb(220,128,255,0.5)'), // has alpha
+        given('rgba(0,0,255)'), // no alpha
+        // invalid hsl(a)
+        given('hsl(360,50%,50%,0.5)'), // has alpha
+        given('hsla(0,50%,101%)'), // no alpha
+        // neither a css named color nor colorscheme
+        given('notacolor'),
+        given('bluish'),
+        given('almostred'),
+        given('brightmaroon'),
+        given('cactus')
+      ).expect(undefined)
+    })
+  })
+
+  describe('SVG', function() {
+    it('should produce SVG', function() {
+      const svg = makeBadge({ text: ['cactus', 'grown'], format: 'svg' })
+      expect(svg)
+        .to.satisfy(isSvg)
+        .and.to.include('cactus')
+        .and.to.include('grown')
+    })
+
+    it('should always produce the same SVG (unless we have changed something!)', function() {
+      const svg = makeBadge({ text: ['cactus', 'grown'], format: 'svg' })
+      snapshot(svg)
+    })
+  })
+
+  describe('JSON', function() {
+    it('should always produce the same JSON (unless we have changed something!)', function() {
+      const json = makeBadge({ text: ['cactus', 'grown'], format: 'json' })
+      const jsonWithLFEndings = eol.lf(json)
+      snapshot(jsonWithLFEndings)
+    })
+
+    it('should replace unknown json template with "default"', function() {
+      const jsonBadgeWithUnknownStyle = makeBadge({
+        text: ['name', 'Bob'],
+        format: 'json',
+        template: 'unknown_style',
+      })
+      const jsonBadgeWithDefaultStyle = makeBadge({
+        text: ['name', 'Bob'],
+        format: 'json',
+        template: 'default',
+      })
+      expect(jsonBadgeWithUnknownStyle).to.equal(jsonBadgeWithDefaultStyle)
+      expect(JSON.parse(jsonBadgeWithUnknownStyle)).to.deep.equal({
+        name: 'name',
+        value: 'Bob',
+      })
+    })
+
+    it('should replace unknown svg template with "flat"', function() {
+      const jsonBadgeWithUnknownStyle = makeBadge({
+        text: ['name', 'Bob'],
+        format: 'svg',
+        template: 'unknown_style',
+      })
+      const jsonBadgeWithDefaultStyle = makeBadge({
+        text: ['name', 'Bob'],
+        format: 'svg',
+        template: 'flat',
+      })
+      expect(jsonBadgeWithUnknownStyle)
+        .to.equal(jsonBadgeWithDefaultStyle)
+        .and.to.satisfy(isSvg)
+    })
+  })
+
+  describe('"for-the-badge" template badge generation', function() {
+    // https://github.com/badges/shields/issues/1280
+    it('numbers should produce a string', function() {
+      const svg = makeBadge({
+        text: [1998, 1999],
+        format: 'svg',
+        template: 'for-the-badge',
+      })
+      expect(svg)
+        .to.include('1998')
+        .and.to.include('1999')
+    })
+
+    it('lowercase/mixedcase string should produce uppercase string', function() {
+      const svg = makeBadge({
+        text: ['Label', '1 string'],
+        format: 'svg',
+        template: 'for-the-badge',
+      })
+      expect(svg)
+        .to.include('LABEL')
+        .and.to.include('1 STRING')
+    })
+  })
+
+  describe('"social" template badge generation', function() {
+    it('should produce capitalized string for badge key', function() {
+      const svg = makeBadge({
+        text: ['some-key', 'some-value'],
+        format: 'svg',
+        template: 'social',
+      })
+      expect(svg)
+        .to.include('Some-key')
+        .and.to.include('some-value')
+    })
+
+    // https://github.com/badges/shields/issues/1606
+    it('should handle empty strings used as badge keys', function() {
+      const svg = makeBadge({
+        text: ['', 'some-value'],
+        format: 'json',
+        template: 'social',
+      })
+      expect(svg)
+        .to.include('""')
+        .and.to.include('some-value')
+    })
+  })
+  describe('badges with logos should always produce the same badge', function() {
+    it('shields GitHub logo default color (#333333)', function() {
+      const svg = makeBadge({
+        text: ['label', 'message'],
+        format: 'svg',
+        logo: 'github',
+      })
+      snapshot(svg)
+    })
+
+    it('shields GitHub logo custom color (whitesmoke)', function() {
+      const svg = makeBadge({
+        text: ['label', 'message'],
+        format: 'svg',
+        logo: 'github',
+        logoColor: 'whitesmoke',
+      })
+      snapshot(svg)
+    })
+
+    it('simple-icons javascript logo default color (#F7DF1E)', function() {
+      const svg = makeBadge({
+        text: ['label', 'message'],
+        format: 'svg',
+        logo: 'javascript',
+      })
+      snapshot(svg)
+    })
+
+    it('simple-icons javascript logo custom color (rgba(46,204,113,0.8))', function() {
+      const svg = makeBadge({
+        text: ['label', 'message'],
+        format: 'svg',
+        logo: 'javascript',
+        logoColor: 'rgba(46,204,113,0.8)',
+      })
+      snapshot(svg)
+    })
+  })
+})

gh-badges/lib/svg-to-img.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const { promisify } = require('util')
+const gm = require('gm')
+const LruCache = require('./lru-cache')
+
+const imageMagick = gm.subClass({ imageMagick: true })
+
+// The following is an arbitrary limit (~1.5MB, 1.5kB/image).
+const imgCache = new LruCache(1000)
+
+async function svgToImg(svg, format) {
+  const cacheIndex = `${format}${svg}`
+
+  if (imgCache.has(cacheIndex)) {
+    return imgCache.get(cacheIndex)
+  }
+
+  const svgBuffer = Buffer.from(
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>${svg}`
+  )
+
+  const chain = imageMagick(svgBuffer, `image.${format}`)
+    .density(90)
+    .background(format === 'jpg' ? '#FFFFFF' : 'none')
+    .flatten()
+  const toBuffer = chain.toBuffer.bind(chain)
+
+  const data = await promisify(toBuffer)(format)
+
+  imgCache.set(cacheIndex, data)
+  return data
+}
+
+module.exports = svgToImg
+
+// To simplify testing.
+module.exports._imgCache = imgCache
+module.exports._imageMagick = imageMagick

gh-badges/lib/svg-to-img.spec.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { expect } = require('chai')
+const isPng = require('is-png')
+const sinon = require('sinon')
+const svg2img = require('./svg-to-img')
+const makeBadge = require('./make-badge')
+
+describe('The rasterizer', function() {
+  let cacheGet
+  beforeEach(function() {
+    cacheGet = sinon.spy(svg2img._imgCache, 'get')
+  })
+  afterEach(function() {
+    cacheGet.restore()
+  })
+
+  it('should produce PNG', async function() {
+    const svg = makeBadge({ text: ['cactus', 'grown'], format: 'svg' })
+    const data = await svg2img(svg, 'png')
+    expect(data).to.satisfy(isPng)
+  })
+
+  it('should cache its results', async function() {
+    const svg = makeBadge({ text: ['will-this', 'be-cached?'], format: 'svg' })
+    const data1 = await svg2img(svg, 'png')
+    expect(data1).to.satisfy(isPng)
+    expect(cacheGet).not.to.have.been.called
+    const data2 = await svg2img(svg, 'png')
+    expect(data2).to.satisfy(isPng)
+    expect(cacheGet).to.have.been.calledOnce
+  })
+})

gh-badges/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "gh-badges",
+  "version": "2.1.0",
+  "description": "Shields.io badge library",
+  "keywords": [
+    "GitHub",
+    "badge",
+    "SVG",
+    "image",
+    "shields.io"
+  ],
+  "main": "lib/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/badges/shields.git"
+  },
+  "author": "Thaddée Tyl <thaddee.tyl@gmail.com>",
+  "license": "CC0-1.0",
+  "bugs": {
+    "url": "https://github.com/badges/shields/issues"
+  },
+  "homepage": "http://shields.io",
+  "bin": {
+    "badge": "lib/badge-cli.js"
+  },
+  "engines": {
+    "node": ">= 8",
+    "npm": ">= 5"
+  },
+  "collective": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/shields",
+    "logo": "https://opencollective.com/opencollective/logo.txt"
+  },
+  "dependencies": {
+    "anafanafo": "^0.1.0",
+    "dot": "~1.1.2",
+    "gm": "^1.23.0",
+    "is-css-color": "^1.0.0",
+    "svgo": "~1.1.1"
+  },
+  "scripts": {
+    "test": "echo 'Run tests from parent dir'; false"
+  }
+}

gh-badges/templates/_shields_test-template.json

@@ -0,0 +1,10 @@
+{
+{{?it.colorA}}
+  "colorA": {{=JSON.stringify(it.colorA)}},
+{{?}}
+{{?it.colorB}}
+  "colorB": {{=JSON.stringify(it.colorB)}},
+{{?}}
+  "name": {{=JSON.stringify(it.text[0])}},
+  "value": {{=JSON.stringify(it.text[1])}}
+}

gh-badges/templates/flat-square-template.svg

@@ -0,0 +1,25 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=(it.widths[0] -= it.text[0].length ? 0 : (it.logo ? (it.colorA ? 0 : 7) : 11))+it.widths[1]}}" height="20">
+  <g shape-rendering="crispEdges">
+    <rect width="{{=it.widths[0]}}" height="20" fill="{{=it.escapeXml(it.text[0].length || it.logo && it.colorA ? (it.colorA||"#555") : (it.colorB||"#4c1"))}}"/>
+    <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="20" fill="{{=it.escapeXml(it.colorB||"#4c1")}}"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
+    {{?it.logo}}
+      <image x="5" y="3" width="{{=it.logoWidth}}" height="14" xlink:href="{{=it.logo}}"/>
+    {{?}}
+    {{?it.text[0].length}}
+        <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="140" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    {{?}}
+    <text x="{{=(it.widths[0]+it.widths[1]/2-(it.text[0].length ? 1 : 0 ))*10}}" y="140" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+  </g>
+  {{?(it.links[0] && it.links[0].length)}}
+    <a target="_blank" xlink:href="{{=it.links[0]}}">
+      <rect width="{{=it.widths[0]}}" height="20" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+  {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}
+    <a target="_blank" xlink:href="{{=it.links[1] || it.links[0]}}">
+      <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="20" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+</svg>

gh-badges/templates/flat-template.svg

@@ -0,0 +1,39 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=(it.widths[0] -= it.text[0].length ? 0 : (it.logo ? (it.colorA ? 0 : 7) : 11))+it.widths[1]}}" height="20">
+  <linearGradient id="smooth" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+
+  <clipPath id="round">
+    <rect width="{{=it.widths[0]+it.widths[1]}}" height="20" rx="3" fill="#fff"/>
+  </clipPath>
+
+  <g clip-path="url(#round)">
+    <rect width="{{=it.widths[0]}}" height="20" fill="{{=it.escapeXml(it.text[0].length || it.logo && it.colorA ? (it.colorA||"#555") : (it.colorB||"#4c1"))}}"/>
+    <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="20" fill="{{=it.escapeXml(it.colorB||"#4c1")}}"/>
+    <rect width="{{=it.widths[0]+it.widths[1]}}" height="20" fill="url(#smooth)"/>
+  </g>
+
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
+    {{?it.logo}}
+      <image x="5" y="3" width="{{=it.logoWidth}}" height="14" xlink:href="{{=it.logo}}"/>
+    {{?}}
+    {{?it.text[0].length}}
+        <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="150" fill="#010101" fill-opacity=".3" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+        <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="140" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    {{?}}
+    <text x="{{=(it.widths[0]+it.widths[1]/2-(it.text[0].length ? 1 : 0 ))*10}}" y="150" fill="#010101" fill-opacity=".3" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+    <text x="{{=(it.widths[0]+it.widths[1]/2-(it.text[0].length ? 1 : 0 ))*10}}" y="140" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+  </g>
+
+  {{?(it.links[0] && it.links[0].length)}}
+    <a target="_blank" xlink:href="{{=it.links[0]}}">
+      <rect width="{{=it.widths[0]}}" height="20" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+  {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}
+    <a target="_blank" xlink:href="{{=it.links[1] || it.links[0]}}">
+      <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="20" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+</svg>

gh-badges/templates/for-the-badge-template.svg

@@ -0,0 +1,25 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=(it.widths[0] -= it.text[0].length ? -(10+(it.text[0].length*1.5)) : (it.logo ? (it.colorA ? -7 : 7) : 11))+(it.widths[1]+=(10+(it.text[1].length*2)))}}" height="28">
+  <g shape-rendering="crispEdges">
+    <rect width="{{=it.widths[0]}}" height="28" fill="{{=it.escapeXml(it.text[0].length || it.logo && it.colorA ? (it.colorA||"#555") : (it.colorB||"#4c1"))}}"/>
+    <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="28" fill="{{=it.escapeXml(it.colorB||"#4c1")}}"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="100">
+    {{?it.logo}}
+      <image x="9" y="7" width="{{=it.logoWidth}}" height="14" xlink:href="{{=it.logo}}"/>
+    {{?}}
+    {{?it.text[0].length}}
+      <text x="{{=((it.widths[0]+it.logoWidth+it.logoPadding)/2)*10}}" y="175" transform="scale(0.1)" textLength="{{=(it.widths[0]-(24+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    {{?}}
+    <text x="{{=(it.widths[0]+it.widths[1]/2)*10}}" y="175" font-weight="bold" transform="scale(0.1)" textLength="{{=(it.widths[1]-24)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+  </g>
+  {{?(it.text[0].length && it.links[0] && it.links[0].length)}}
+    <a target="_blank" xlink:href="{{=it.links[0]}}">
+      <rect width="{{=it.widths[0]}}" height="28" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+  {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}
+    <a target="_blank" xlink:href="{{=it.links[1] || it.links[0]}}">
+      <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="28" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+</svg>

gh-badges/templates/plastic-template.svg

@@ -0,0 +1,41 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=(it.widths[0] -= it.text[0].length ? 0 : (it.logo ? (it.colorA ? 0 : 7) : 11))+it.widths[1]}}" height="18">
+  <linearGradient id="smooth" x2="0" y2="100%">
+    <stop offset="0"  stop-color="#fff" stop-opacity=".7"/>
+    <stop offset=".1" stop-color="#aaa" stop-opacity=".1"/>
+    <stop offset=".9" stop-color="#000" stop-opacity=".3"/>
+    <stop offset="1"  stop-color="#000" stop-opacity=".5"/>
+  </linearGradient>
+
+  <clipPath id="round">
+    <rect width="{{=it.widths[0]+it.widths[1]}}" height="18" rx="4" fill="#fff"/>
+  </clipPath>
+
+  <g clip-path="url(#round)">
+    <rect width="{{=it.widths[0]}}" height="18" fill="{{=it.escapeXml(it.text[0].length || it.logo && it.colorA ? (it.colorA||"#555") : (it.colorB||"#4c1"))}}"/>
+    <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="18" fill="{{=it.escapeXml(it.colorB||"#4c1")}}"/>
+    <rect width="{{=it.widths[0]+it.widths[1]}}" height="18" fill="url(#smooth)"/>
+  </g>
+
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
+    {{?it.logo}}
+      <image x="5" y="3" width="{{=it.logoWidth}}" height="14" xlink:href="{{=it.logo}}"/>
+    {{?}}
+    {{?it.text[0].length}}
+        <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="140" fill="#010101" fill-opacity=".3" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+        <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="130" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    {{?}}
+    <text x="{{=(it.widths[0]+it.widths[1]/2-(it.text[0].length ? 1 : 0))*10}}" y="140" fill="#010101" fill-opacity=".3" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+    <text x="{{=(it.widths[0]+it.widths[1]/2-(it.text[0].length ? 1 : 0))*10}}" y="130" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+  </g>
+
+  {{?(it.links[0] && it.links[0].length)}}
+    <a target="_blank" xlink:href="{{=it.links[0]}}">
+      <rect width="{{=it.widths[0]}}" height="18" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+  {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}
+    <a target="_blank" xlink:href="{{=it.links[1] || it.links[0]}}">
+      <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="18" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+</svg>

gh-badges/templates/popout-square-template.svg

@@ -0,0 +1,23 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=(it.widths[0] -= it.text[0].length ? 0 : (it.logo ? (it.colorA ? 0 : 6) : 11))+it.widths[1]}}" height="40">
+  <g shape-rendering="crispEdges">
+    <rect width="{{=it.widths[0]}}" y="{{=10-it.logoPosition}}" height="20" fill="{{=it.escapeXml(it.text[0].length || it.logo && it.colorA ? (it.colorA||"#555") : (it.colorB||"#4c1"))}}"/>
+    <rect x="{{=it.widths[0]}}" y="{{=10-it.logoPosition}}" width="{{=it.widths[1]}}" height="20" fill="{{=it.escapeXml(it.colorB||"#4c1")}}"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
+    {{?it.logo}}
+      <image x="5" y="3" width="{{=it.logoWidth}}" height="32" xlink:href="{{=it.logo}}"/>
+    {{?}}
+    <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="{{=(24-it.logoPosition)*10}}" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    <text x="{{=(it.widths[0]+it.widths[1]/2-1)*10}}" y="{{=(24-it.logoPosition)*10}}" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+  </g>
+  {{?(it.links[0] && it.links[0].length)}}
+    <a xlink:href="{{=it.links[0]}}">
+      <rect width="{{=it.widths[0]}}" height="40" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+  {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}
+    <a xlink:href="{{=it.links[1] || it.links[0]}}">
+      <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="40" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+</svg>

gh-badges/templates/popout-template.svg

@@ -0,0 +1,37 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=(it.widths[0] -= it.text[0].length ? 0 : (it.logo ? (it.colorA ? 0 : 6) : 11))+it.widths[1]}}" height="40">
+  <linearGradient id="smooth" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+
+  <clipPath id="round">
+    <rect width="{{=it.widths[0]+it.widths[1]}}" y="{{=10-it.logoPosition}}" height="20" rx="3" fill="#fff"/>
+  </clipPath>
+
+  <g clip-path="url(#round)">
+    <rect width="{{=it.widths[0]}}" y="{{=10-it.logoPosition}}" height="20" fill="{{=it.escapeXml(it.text[0].length || it.logo && it.colorA ? (it.colorA||"#555") : (it.colorB||"#4c1"))}}"/>
+    <rect x="{{=it.widths[0]}}" y="{{=10-it.logoPosition}}" width="{{=it.widths[1]}}" height="20" fill="{{=it.escapeXml(it.colorB||"#4c1")}}"/>
+    <rect width="{{=it.widths[0]+it.widths[1]}}" y="{{=10-it.logoPosition}}" height="20" fill="url(#smooth)"/>
+  </g>
+
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
+    {{?it.logo}}
+      <image x="5" y="3" width="{{=it.logoWidth}}" height="32" xlink:href="{{=it.logo}}"/>
+    {{?}}
+    <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="{{=(25-it.logoPosition)*10}}" fill="#010101" fill-opacity=".3" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    <text x="{{=(((it.widths[0]+it.logoWidth+it.logoPadding)/2)+1)*10}}" y="{{=(24-it.logoPosition)*10}}" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    <text x="{{=(it.widths[0]+it.widths[1]/2-1)*10}}" y="{{=(25-it.logoPosition)*10}}" fill="#010101" fill-opacity=".3" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+    <text x="{{=(it.widths[0]+it.widths[1]/2-1)*10}}" y="{{=(24-it.logoPosition)*10}}" transform="scale(0.1)" textLength="{{=(it.widths[1]-10)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+  </g>
+
+  {{?(it.links[0] && it.links[0].length)}}
+    <a xlink:href="{{=it.links[0]}}">
+      <rect width="{{=it.widths[0]}}" height="40" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+  {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}
+    <a xlink:href="{{=it.links[1] || it.links[0]}}">
+      <rect x="{{=it.widths[0]}}" width="{{=it.widths[1]}}" height="40" fill="rgba(0,0,0,0)"/>
+    </a>
+  {{?}}
+</svg>

gh-badges/templates/social-template.svg

@@ -0,0 +1,39 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{{=it.widths[0]+1 + (it.text[1] && it.text[1].length > 0 ? it.widths[1]+2 : 0)}}" height="20">
+  {{it.widths[1]-=4;}}
+  <style type="text/css"><![CDATA[
+    a #llink:hover { fill:url(#b); stroke:#ccc; }
+    a #rlink:hover { fill:#4183C4; }
+  ]]></style>
+  <linearGradient id="a" x2="0" y2="100%">
+    <stop offset="0" stop-color="#fcfcfc" stop-opacity="0"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <linearGradient id="b" x2="0" y2="100%">
+    <stop offset="0" stop-color="#ccc" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <g stroke="#d5d5d5">
+    <rect stroke="none" fill="#fcfcfc" x="0.5" y="0.5" width="{{=it.widths[0]}}" height="19" rx="2"/>
+    {{?(it.text[1] && it.text[1].length)}}
+    <rect y="0.5" x="{{=it.widths[0]+6.5}}" width="{{=it.widths[1]}}" height="19" rx="2" fill="#fafafa"/>
+    <rect x="{{=it.widths[0]+6}}" y="7.5" width="0.5" height="5" stroke="#fafafa"/>
+    <path d="M{{=it.widths[0]+6.5}} 6.5 l-3 3v1 l3 3" stroke="d5d5d5" fill="#fafafa"/>
+    {{?}}
+  </g>
+  {{?it.logo}}
+    <image x="5" y="3" width="{{=it.logoWidth}}" height="14" xlink:href="{{=it.logo}}"/>
+  {{?}}
+  <g fill="#333" text-anchor="middle" font-family="Helvetica Neue,Helvetica,Arial,sans-serif" font-weight="700" font-size="110px" line-height="14px">
+    <text x="{{=((it.widths[0]+it.logoWidth+it.logoPadding)/2)*10}}" y="150" fill="#fff" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    <text x="{{=((it.widths[0]+it.logoWidth+it.logoPadding)/2)*10}}" y="140" transform="scale(0.1)" textLength="{{=(it.widths[0]-(10+it.logoWidth+it.logoPadding))*10}}" lengthAdjust="spacing">{{=it.escapedText[0]}}</text>
+    {{?(it.text[1] && it.text[1].length)}}
+      <text x="{{=(it.widths[0]+it.widths[1]/2+6)*10}}" y="150" fill="#fff" transform="scale(0.1)" textLength="{{=(it.widths[1]-8)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+      {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}<a target="_blank" xlink:href="{{=it.links[1] || it.links[0]}}">{{?}}
+        <text id="rlink" x="{{=(it.widths[0]+it.widths[1]/2+6)*10}}" y="140" transform="scale(0.1)" textLength="{{=(it.widths[1]-8)*10}}" lengthAdjust="spacing">{{=it.escapedText[1]}}</text>
+      {{?(it.links[0] && it.links[0].length || it.links[1] && it.links[1].length)}}</a>{{?}}
+    {{?}}
+  </g>
+  {{?(it.links[0] && it.links[0].length)}}<a target="_blank" xlink:href="{{=it.links[0]}}">{{?}}
+      <rect id="llink" stroke="#d5d5d5" fill="url(#a)" x="0.5" y="0.5" width="{{=it.widths[0]}}" height="19" rx="2"/>
+  {{?(it.links[0] && it.links[0].length)}}</a>{{?}}
+</svg>

lib/all-badge-examples.js

@@ -0,0 +1,454 @@
+'use strict'
+
+const { loadServiceClasses } = require('../services')
+
+const allBadgeExamples = [
+  {
+    category: {
+      id: 'build',
+      name: 'Build',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'chat',
+      name: 'Chat',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'dependencies',
+      name: 'Dependencies',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'size',
+      name: 'Size',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'downloads',
+      name: 'Downloads',
+    },
+    examples: [
+      {
+        title: 'Chocolatey',
+        previewUrl: '/chocolatey/dt/scriptcs.svg',
+      },
+      {
+        title: 'NuGet',
+        previewUrl: '/nuget/dt/Microsoft.AspNetCore.Mvc.svg',
+      },
+      {
+        title: 'MyGet',
+        previewUrl: '/myget/mongodb/dt/MongoDB.Driver.Core.svg',
+      },
+      {
+        title: 'MyGet tenant',
+        previewUrl:
+          '/dotnet.myget/dotnet-coreclr/dt/Microsoft.DotNet.CoreCLR.svg',
+      },
+      {
+        title: 'PowerShell Gallery',
+        previewUrl: '/powershellgallery/dt/ACMESharp.svg',
+      },
+      {
+        title: 'Crates.io',
+        previewUrl: '/crates/d/rustc-serialize.svg',
+        keywords: ['Rust'],
+      },
+      {
+        title: 'Crates.io',
+        previewUrl: '/crates/dv/rustc-serialize.svg',
+        keywords: ['Rust'],
+      },
+      {
+        title: 'Puppet Forge',
+        previewUrl: '/puppetforge/dt/camptocamp/openldap.svg',
+      },
+      {
+        title: 'Mozilla Add-on',
+        previewUrl: '/amo/d/dustman.svg',
+        keywords: ['amo', 'firefox'],
+      },
+      {
+        title: 'Visual Studio Marketplace',
+        previewUrl: '/vscode-marketplace/d/ritwickdey.LiveServer.svg',
+        keywords: ['vscode-marketplace'],
+      },
+      {
+        title: 'JetBrains ReSharper plugins',
+        previewUrl: '/resharper/dt/ReSharper.Nuke.svg',
+        keywords: ['jetbrains', 'plugin'],
+      },
+    ],
+  },
+  {
+    category: {
+      id: 'funding',
+      name: 'Funding',
+    },
+    examples: [
+      {
+        title: 'Chrome Web Store',
+        previewUrl:
+          '/chrome-web-store/price/ogffaloegjglncjfehdfplabnoondfjo.svg',
+        keywords: ['chrome'],
+      },
+    ],
+  },
+  {
+    category: {
+      id: 'issue-tracking',
+      name: 'Issue Tracking',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'license',
+      name: 'License',
+    },
+    examples: [
+      {
+        title: 'Crates.io',
+        previewUrl: '/crates/l/rustc-serialize.svg',
+        keywords: ['Rust'],
+      },
+      {
+        title: 'Packagist',
+        previewUrl: '/packagist/l/doctrine/orm.svg',
+        keywords: ['PHP'],
+      },
+      {
+        title: 'Bower',
+        previewUrl: '/bower/l/bootstrap.svg',
+      },
+      {
+        title: 'CPAN',
+        previewUrl: '/cpan/l/Config-Augeas.svg',
+        keywords: ['perl'],
+      },
+      {
+        title: 'CRAN',
+        previewUrl: '/cran/l/devtools.svg',
+        keywords: ['R'],
+      },
+      {
+        title: 'DUB',
+        previewUrl: '/dub/l/vibe-d.svg',
+        keywords: ['dub'],
+      },
+    ],
+  },
+  {
+    category: {
+      id: 'rating',
+      name: 'Rating',
+    },
+    examples: [
+      {
+        title: 'Chrome Web Store',
+        previewUrl:
+          '/chrome-web-store/rating/ogffaloegjglncjfehdfplabnoondfjo.svg',
+        keywords: ['chrome'],
+      },
+      {
+        title: 'Chrome Web Store',
+        previewUrl:
+          '/chrome-web-store/stars/ogffaloegjglncjfehdfplabnoondfjo.svg',
+        keywords: ['chrome'],
+      },
+      {
+        title: 'Chrome Web Store',
+        previewUrl:
+          '/chrome-web-store/rating-count/ogffaloegjglncjfehdfplabnoondfjo.svg',
+        keywords: ['chrome'],
+      },
+      {
+        title: 'Mozilla Add-on',
+        previewUrl: '/amo/rating/dustman.svg',
+        keywords: ['amo', 'firefox'],
+      },
+      {
+        title: 'Mozilla Add-on',
+        previewUrl: '/amo/stars/dustman.svg',
+        keywords: ['amo', 'firefox'],
+      },
+      {
+        title: 'Plugin on redmine.org',
+        previewUrl:
+          '/redmine/plugin/rating/redmine_xlsx_format_issue_exporter.svg',
+        keywords: ['redmine', 'plugin'],
+      },
+      {
+        title: 'Plugin on redmine.org',
+        previewUrl:
+          '/redmine/plugin/stars/redmine_xlsx_format_issue_exporter.svg',
+        keywords: ['redmine', 'plugin'],
+      },
+      {
+        title: 'Vaadin Directory',
+        previewUrl: '/vaadin-directory/rating/vaadinvaadin-grid.svg',
+        keywords: ['vaadin-directory', 'vaadin directory', 'rating'],
+      },
+      {
+        title: 'Vaadin Directory',
+        previewUrl: '/vaadin-directory/stars/vaadinvaadin-grid.svg',
+        keywords: ['vaadin-directory', 'vaadin directory', 'star', 'stars'],
+      },
+      {
+        title: 'Vaadin Directory',
+        previewUrl: '/vaadin-directory/rating-count/vaadinvaadin-grid.svg',
+        keywords: [
+          'vaadin-directory',
+          'vaadin directory',
+          'rating-count',
+          'rating count',
+        ],
+      },
+      {
+        title: 'Visual Studio Marketplace',
+        previewUrl: '/vscode-marketplace/r/ritwickdey.LiveServer.svg',
+        keywords: ['vscode-marketplace'],
+      },
+      {
+        title: 'StackExchange',
+        previewUrl: '/stackexchange/tex/r/951.svg',
+      },
+    ],
+  },
+  {
+    category: {
+      id: 'social',
+      name: 'Social',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'version',
+      name: 'Version',
+    },
+    examples: [
+      {
+        title: 'LuaRocks',
+        previewUrl: '/luarocks/v/mpeterv/luacheck.svg',
+        keywords: ['lua'],
+      },
+      {
+        title: 'Hackage',
+        previewUrl: '/hackage/v/lens.svg',
+      },
+      {
+        title: 'Crates.io',
+        previewUrl: '/crates/v/rustc-serialize.svg',
+        keywords: ['Rust'],
+      },
+      {
+        title: 'Packagist',
+        previewUrl: '/packagist/v/symfony/symfony.svg',
+        keywords: ['PHP'],
+      },
+      {
+        title: 'Packagist Pre Release',
+        previewUrl: '/packagist/vpre/symfony/symfony.svg',
+        keywords: ['PHP'],
+      },
+      {
+        title: 'NuGet',
+        previewUrl: '/nuget/v/Nuget.Core.svg',
+      },
+      {
+        title: 'NuGet Pre Release',
+        previewUrl: '/nuget/vpre/Microsoft.AspNet.Mvc.svg',
+      },
+      {
+        title: 'MyGet',
+        previewUrl: '/myget/mongodb/v/MongoDB.Driver.Core.svg',
+      },
+      {
+        title: 'MyGet Pre Release',
+        previewUrl: '/myget/yolodev/vpre/YoloDev.Dnx.FSharp.svg',
+      },
+      {
+        title: 'MyGet tenant',
+        previewUrl:
+          '/dotnet.myget/dotnet-coreclr/v/Microsoft.DotNet.CoreCLR.svg',
+      },
+      {
+        title: 'Chocolatey',
+        previewUrl: '/chocolatey/v/git.svg',
+      },
+      {
+        title: 'PowerShell Gallery',
+        previewUrl: '/powershellgallery/v/Zyborg.Vault.svg',
+      },
+      {
+        title: 'Puppet Forge',
+        previewUrl: '/puppetforge/v/vStone/percona.svg',
+      },
+      {
+        title: 'Sonatype Nexus (Releases)',
+        previewUrl:
+          '/nexus/r/https/oss.sonatype.org/com.google.guava/guava.svg',
+      },
+      {
+        title: 'Sonatype Nexus (Snapshots)',
+        previewUrl:
+          '/nexus/s/https/oss.sonatype.org/com.google.guava/guava.svg',
+      },
+      {
+        title: 'CPAN',
+        previewUrl: '/cpan/v/Config-Augeas.svg',
+        keywords: ['perl'],
+      },
+      {
+        title: 'CRAN',
+        previewUrl: '/cran/v/devtools.svg',
+        keywords: ['R'],
+      },
+      {
+        title: 'DUB',
+        previewUrl: '/dub/v/vibe-d.svg',
+        keywords: ['dub'],
+      },
+      {
+        title: 'Chrome Web Store',
+        previewUrl: '/chrome-web-store/v/ogffaloegjglncjfehdfplabnoondfjo.svg',
+        keywords: ['chrome'],
+      },
+      {
+        title: 'Mozilla Add-on',
+        previewUrl: '/amo/v/dustman.svg',
+        keywords: ['amo', 'firefox'],
+      },
+      {
+        title: 'Visual Studio Marketplace',
+        previewUrl: '/vscode-marketplace/v/ritwickdey.LiveServer.svg',
+        keywords: ['vscode-marketplace'],
+      },
+
+      {
+        title: 'JetBrains ReSharper Plugins',
+        previewUrl: '/resharper/v/ReSharper.Nuke.svg',
+      },
+      {
+        title: 'JetBrains ReSharper Plugins Pre-release',
+        previewUrl: '/resharper/vpre/ReSharper.Nuke.svg',
+      },
+      {
+        title: 'Vaadin Directory',
+        previewUrl: '/vaadin-directory/v/vaadinvaadin-grid.svg',
+        keywords: [
+          'vaadin-directory',
+          'vaadin directory',
+          'version',
+          'latest version',
+        ],
+      },
+    ],
+  },
+  {
+    category: {
+      id: 'platform-support',
+      name: 'Platform & Version Support',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'monitoring',
+      name: 'Monitoring',
+    },
+    examples: [],
+  },
+  {
+    category: {
+      id: 'other',
+      name: 'Other',
+    },
+    examples: [
+      {
+        title: 'Puppet Forge',
+        previewUrl: '/puppetforge/e/camptocamp/openssl.svg',
+      },
+      {
+        title: 'Puppet Forge',
+        previewUrl: '/puppetforge/f/camptocamp/openssl.svg',
+      },
+      {
+        title: 'Puppet Forge',
+        previewUrl: '/puppetforge/rc/camptocamp.svg',
+      },
+      {
+        title: 'Puppet Forge',
+        previewUrl: '/puppetforge/mc/camptocamp.svg',
+      },
+      {
+        title: 'Chrome Web Store',
+        previewUrl:
+          '/chrome-web-store/users/ogffaloegjglncjfehdfplabnoondfjo.svg',
+        keywords: ['chrome'],
+      },
+      {
+        title: 'Mozilla Add-on',
+        previewUrl: '/amo/users/dustman.svg',
+        keywords: ['amo', 'firefox'],
+      },
+      {
+        title: 'Vaadin Directory',
+        previewUrl: '/vaadin-directory/status/vaadinvaadin-grid.svg',
+        keywords: ['vaadin-directory', 'vaadin directory', 'status'],
+      },
+      {
+        title: 'Vaadin Directory',
+        previewUrl: '/vaadin-directory/release-date/vaadinvaadin-grid.svg',
+        keywords: [
+          'vaadin-directory',
+          'vaadin directory',
+          'date',
+          'latest release date',
+        ],
+      },
+      {
+        title: 'StackExchange',
+        previewUrl: '/stackexchange/stackoverflow/t/augeas.svg',
+      },
+    ],
+  },
+]
+
+function findCategory(wantedCategory) {
+  return allBadgeExamples.find(
+    thisCat => thisCat.category.id === wantedCategory
+  )
+}
+
+function loadExamples() {
+  loadServiceClasses().forEach(ServiceClass => {
+    const prepared = ServiceClass.prepareExamples()
+    if (prepared.length === 0) {
+      return
+    }
+    const category = findCategory(ServiceClass.category)
+    if (category === undefined) {
+      throw Error(
+        `Unknown category ${ServiceClass.category} referenced in ${
+          ServiceClass.name
+        }`
+      )
+    }
+    category.examples = category.examples.concat(prepared)
+  })
+}
+loadExamples()
+
+module.exports = allBadgeExamples
+module.exports.findCategory = findCategory

lib/all-badge-examples.spec.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const { expect } = require('chai')
+
+const allBadgeExamples = require('./all-badge-examples')
+
+describe('The badge examples', function() {
+  it('should include AppVeyor, which is added automatically', function() {
+    const { examples } = allBadgeExamples.findCategory('build')
+
+    const appVeyorBuildExamples = examples
+      .filter(ex => ex.title.includes('AppVeyor'))
+      .filter(ex => !ex.title.includes('tests'))
+
+    expect(appVeyorBuildExamples).to.deep.equal([
+      {
+        title: 'AppVeyor',
+        exampleUrl: '/appveyor/ci/gruntjs/grunt.svg',
+        previewUrl: '/badge/build-passing-brightgreen.svg',
+        urlPattern: '/appveyor/ci/:user/:repo.svg',
+        documentation: undefined,
+        keywords: undefined,
+      },
+      {
+        title: 'AppVeyor branch',
+        exampleUrl: '/appveyor/ci/gruntjs/grunt/master.svg',
+        previewUrl: '/badge/build-passing-brightgreen.svg',
+        urlPattern: '/appveyor/ci/:user/:repo/:branch.svg',
+        documentation: undefined,
+        keywords: undefined,
+      },
+    ])
+  })
+})

lib/analytics.js

@@ -0,0 +1,148 @@
+'use strict'
+
+const fs = require('fs')
+const { URL } = require('url')
+
+// We can either use a process-wide object regularly saved to a JSON file,
+// or a Redis equivalent (for multi-process / when the filesystem is unreliable.
+let redis
+let useRedis = false
+if (process.env.REDISTOGO_URL) {
+  const { port, hostname, password } = new URL(process.env.REDISTOGO_URL)
+  redis = require('redis').createClient(port, hostname)
+  redis.auth(password)
+  useRedis = true
+}
+
+let analytics = {}
+let autosaveIntervalId
+
+const analyticsPath = process.env.SHIELDS_ANALYTICS_FILE || './analytics.json'
+
+function performAutosave() {
+  const contents = JSON.stringify(analytics)
+  if (useRedis) {
+    redis.set(analyticsPath, contents)
+  } else {
+    fs.writeFileSync(analyticsPath, contents)
+  }
+}
+
+function scheduleAutosaving() {
+  const analyticsAutoSavePeriod = 10000
+  autosaveIntervalId = setInterval(performAutosave, analyticsAutoSavePeriod)
+}
+
+// For a clean shutdown.
+function cancelAutosaving() {
+  if (autosaveIntervalId) {
+    clearInterval(autosaveIntervalId)
+    autosaveIntervalId = null
+  }
+  performAutosave()
+}
+
+function defaultAnalytics() {
+  const analytics = Object.create(null)
+  // In case something happens on the 36th.
+  analytics.vendorMonthly = new Array(36)
+  resetMonthlyAnalytics(analytics.vendorMonthly)
+  analytics.rawMonthly = new Array(36)
+  resetMonthlyAnalytics(analytics.rawMonthly)
+  analytics.vendorFlatMonthly = new Array(36)
+  resetMonthlyAnalytics(analytics.vendorFlatMonthly)
+  analytics.rawFlatMonthly = new Array(36)
+  resetMonthlyAnalytics(analytics.rawFlatMonthly)
+  analytics.vendorFlatSquareMonthly = new Array(36)
+  resetMonthlyAnalytics(analytics.vendorFlatSquareMonthly)
+  analytics.rawFlatSquareMonthly = new Array(36)
+  resetMonthlyAnalytics(analytics.rawFlatSquareMonthly)
+  return analytics
+}
+
+function load() {
+  const defaultAnalyticsObject = defaultAnalytics()
+  if (useRedis) {
+    redis.get(analyticsPath, (err, value) => {
+      if (err == null && value != null) {
+        // if/try/return trick:
+        // if error, then the rest of the function is run.
+        try {
+          analytics = JSON.parse(value)
+          // Extend analytics with a new value.
+          for (const key in defaultAnalyticsObject) {
+            if (!(key in analytics)) {
+              analytics[key] = defaultAnalyticsObject[key]
+            }
+          }
+          return
+        } catch (e) {
+          console.error('Invalid Redis analytics, resetting.')
+          console.error(e)
+        }
+      }
+      analytics = defaultAnalyticsObject
+    })
+  } else {
+    // Not using Redis.
+    try {
+      analytics = JSON.parse(fs.readFileSync(analyticsPath))
+      // Extend analytics with a new value.
+      for (const key in defaultAnalyticsObject) {
+        if (!(key in analytics)) {
+          analytics[key] = defaultAnalyticsObject[key]
+        }
+      }
+    } catch (e) {
+      if (e.code !== 'ENOENT') {
+        console.error('Invalid JSON file for analytics, resetting.')
+        console.error(e)
+      }
+      analytics = defaultAnalyticsObject
+    }
+  }
+}
+
+let lastDay = new Date().getDate()
+function resetMonthlyAnalytics(monthlyAnalytics) {
+  for (let i = 0; i < monthlyAnalytics.length; i++) {
+    monthlyAnalytics[i] = 0
+  }
+}
+function incrMonthlyAnalytics(monthlyAnalytics) {
+  try {
+    const currentDay = new Date().getDate()
+    // If we changed month, reset empty days.
+    while (lastDay !== currentDay) {
+      // Assumption: at least a hit a month.
+      lastDay = (lastDay + 1) % monthlyAnalytics.length
+      monthlyAnalytics[lastDay] = 0
+    }
+    monthlyAnalytics[currentDay]++
+  } catch (e) {
+    console.error(e.stack)
+  }
+}
+
+function noteRequest(queryParams, match) {
+  incrMonthlyAnalytics(analytics.vendorMonthly)
+  if (queryParams.style === 'flat') {
+    incrMonthlyAnalytics(analytics.vendorFlatMonthly)
+  } else if (queryParams.style === 'flat-square') {
+    incrMonthlyAnalytics(analytics.vendorFlatSquareMonthly)
+  }
+}
+
+function setRoutes(server) {
+  server.ajax.on('analytics/v1', (json, end) => {
+    end(analytics)
+  })
+}
+
+module.exports = {
+  load,
+  scheduleAutosaving,
+  cancelAutosaving,
+  noteRequest,
+  setRoutes,
+}

lib/badge-data.js

@@ -0,0 +1,162 @@
+'use strict'
+
+const isCSSColor = require('is-css-color')
+const logos = require('./load-logos')()
+const simpleIcons = require('./load-simple-icons')()
+const { svg2base64, isDataUri } = require('./logo-helper')
+const colorschemes = require('../gh-badges/lib/colorscheme.json')
+
+function toArray(val) {
+  if (val === undefined) {
+    return []
+  } else if (Object(val) instanceof Array) {
+    return val
+  } else {
+    return [val]
+  }
+}
+
+function prependPrefix(s, prefix) {
+  if (s === undefined) {
+    return undefined
+  }
+
+  s = `${s}`
+
+  if (s.startsWith(prefix)) {
+    return s
+  } else {
+    return prefix + s
+  }
+}
+
+function isHexColor(s = '') {
+  return /^([\da-f]{3}){1,2}$/i.test(s)
+}
+
+function makeColor(color) {
+  if (isHexColor(color)) {
+    return `#${color}`
+  } else if (colorschemes[color] !== undefined) {
+    return colorschemes[color].colorB
+  } else if (isCSSColor(color)) {
+    return color
+  } else {
+    return undefined
+  }
+}
+
+function makeColorB(defaultColor, overrides) {
+  return makeColor(overrides.colorB || defaultColor)
+}
+
+function setBadgeColor(badgeData, color) {
+  if (isHexColor(color)) {
+    badgeData.colorB = `#${color}`
+    delete badgeData.colorscheme
+  } else if (colorschemes[color] !== undefined) {
+    badgeData.colorscheme = color
+    delete badgeData.colorB
+  } else if (isCSSColor(color)) {
+    badgeData.colorB = color
+    delete badgeData.colorscheme
+  } else {
+    badgeData.colorscheme = 'red'
+    delete badgeData.colorB
+  }
+  return badgeData
+}
+
+function makeLabel(defaultLabel, overrides) {
+  return `${
+    overrides.label === undefined
+      ? (defaultLabel || '').toLowerCase()
+      : overrides.label
+  }`
+}
+
+function getShieldsIcon(icon = '', color = '') {
+  icon = typeof icon === 'string' ? icon.toLowerCase() : ''
+  if (!logos[icon]) {
+    return undefined
+  }
+  color = makeColor(color)
+  return color
+    ? logos[icon].svg.replace(/fill="(.+?)"/g, `fill="${color}"`)
+    : logos[icon].base64
+}
+
+function getSimpleIcon(icon = '', color = null) {
+  icon = typeof icon === 'string' ? icon.toLowerCase().replace(/ /g, '-') : ''
+  if (!simpleIcons[icon]) {
+    return undefined
+  }
+  color = makeColor(color)
+  return color
+    ? simpleIcons[icon].svg.replace('<svg', `<svg fill="${color}"`)
+    : simpleIcons[icon].base64
+}
+
+function makeLogo(defaultNamedLogo, overrides) {
+  if (overrides.logo === undefined) {
+    return svg2base64(
+      getShieldsIcon(defaultNamedLogo, overrides.logoColor) ||
+        getSimpleIcon(defaultNamedLogo, overrides.logoColor)
+    )
+  }
+
+  // +'s are replaced with spaces when used in query params, this returns them to +'s, then removes remaining whitespace - #1546
+  const maybeDataUri = prependPrefix(overrides.logo, 'data:')
+    .replace(/ /g, '+')
+    .replace(/\s/g, '')
+
+  if (isDataUri(maybeDataUri)) {
+    return maybeDataUri
+  } else {
+    return svg2base64(
+      getShieldsIcon(overrides.logo, overrides.logoColor) ||
+        getSimpleIcon(overrides.logo, overrides.logoColor)
+    )
+  }
+}
+
+// Generate the initial badge data. Pass the URL query parameters, which
+// override the default label.
+//
+// The following parameters are supported:
+//
+//   - label
+//   - style
+//   - logo
+//   - logoWidth
+//   - link
+//   - colorA
+//   - colorB
+//   - maxAge
+//
+// Note: maxAge is handled by cache(), not this function.
+function makeBadgeData(defaultLabel, overrides) {
+  return {
+    text: [makeLabel(defaultLabel, overrides), 'n/a'],
+    colorscheme: 'lightgrey',
+    template: overrides.style,
+    logo: makeLogo(undefined, overrides),
+    logoPosition: +overrides.logoPosition,
+    logoWidth: +overrides.logoWidth,
+    links: toArray(overrides.link),
+    colorA: makeColor(overrides.colorA),
+    colorB: makeColor(overrides.colorB),
+  }
+}
+
+module.exports = {
+  toArray,
+  prependPrefix,
+  isHexColor,
+  makeLabel,
+  makeLogo,
+  makeBadgeData,
+  makeColor,
+  makeColorB,
+  setBadgeColor,
+}

lib/badge-data.spec.js

@@ -0,0 +1,109 @@
+'use strict'
+
+const { expect } = require('chai')
+const { test, given, forCases } = require('sazerac')
+const {
+  prependPrefix,
+  isHexColor,
+  makeLabel,
+  makeLogo,
+  makeBadgeData,
+  makeColor,
+  setBadgeColor,
+} = require('./badge-data')
+
+describe('Badge data helpers', function() {
+  test(prependPrefix, () => {
+    given('data:image/svg+xml;base64,PHN2ZyB4bWxu', 'data:').expect(
+      'data:image/svg+xml;base64,PHN2ZyB4bWxu'
+    )
+    given('foobar', 'data:').expect('data:foobar')
+    given(undefined, 'data:').expect(undefined)
+  })
+
+  test(isHexColor, () => {
+    forCases([given('f00bae'), given('4c1')]).expect(true)
+    forCases([given('f00bar'), given(''), given(undefined)]).expect(false)
+  })
+
+  test(makeLabel, () => {
+    given('my badge', {}).expect('my badge')
+    given('My bAdge', {}).expect('my badge')
+    given('my badge', { label: 'no, my badge' }).expect('no, my badge')
+    given('my badge', { label: 'no, MY badge' }).expect('no, MY badge')
+    given('my badge', { label: false }).expect('false')
+    given('my badge', { label: 0 }).expect('0')
+    given('my badge', { label: '' }).expect('')
+  })
+
+  test(makeLogo, () => {
+    forCases([
+      given('gratipay', { logo: 'image/svg+xml;base64,PHN2ZyB4bWxu' }),
+      given('gratipay', { logo: 'data:image/svg+xml;base64,PHN2ZyB4bWxu' }),
+      given('gratipay', { logo: 'data:image/svg xml;base64,PHN2ZyB4bWxu' }),
+      given('gratipay', { logo: 'data:image/svg+xml;base64,PHN2ZyB\n4bWxu' }),
+    ]).expect('data:image/svg+xml;base64,PHN2ZyB4bWxu')
+    forCases([given('gratipay', { logo: '' }), given(undefined, {})]).expect(
+      undefined
+    )
+    given('gratipay', {}).assert(
+      'should not be empty',
+      v => expect(v).not.to.be.empty
+    )
+  })
+
+  test(makeBadgeData, () => {
+    given('my badge', {
+      label: 'no, my badge',
+      style: 'flat-square',
+      logo: 'image/svg+xml;base64,PHN2ZyB4bWxu',
+      logoPosition: 10,
+      logoWidth: '25',
+      link: 'https://example.com/',
+      colorA: 'blue',
+      colorB: 'f00bae',
+    }).expect({
+      text: ['no, my badge', 'n/a'],
+      colorscheme: 'lightgrey',
+      template: 'flat-square',
+      logo: 'data:image/svg+xml;base64,PHN2ZyB4bWxu',
+      logoPosition: 10,
+      logoWidth: 25,
+      links: ['https://example.com/'],
+      colorA: '#007ec6',
+      colorB: '#f00bae',
+    })
+  })
+
+  test(makeColor, () => {
+    given('red').expect('#e05d44')
+    given('blue').expect('#007ec6')
+    given('4c1').expect('#4c1')
+    given('f00f00').expect('#f00f00')
+    given('papayawhip').expect('papayawhip')
+    given('purple').expect('purple')
+  })
+
+  test(setBadgeColor, () => {
+    given({}, 'red').expect({ colorscheme: 'red' })
+    given({}, 'f00f00').expect({ colorB: '#f00f00' })
+    given({ colorB: '#f00f00', colorscheme: 'blue' }, 'red').expect({
+      colorscheme: 'red',
+    })
+    given({ colorB: '#f00f00', colorscheme: 'blue' }, 'blue').expect({
+      colorscheme: 'blue',
+    })
+    given({ colorB: '#f00f00', colorscheme: 'blue' }, 'papayawhip').expect({
+      colorB: 'papayawhip',
+    })
+    given({ colorB: '#f00f00', colorscheme: 'blue' }, 'purple').expect({
+      colorB: 'purple',
+    })
+    given({ colorB: '#b00b00', colorscheme: 'blue' }, '4c1').expect({
+      colorB: '#4c1',
+    })
+    given({ colorB: '#b00b00', colorscheme: 'blue' }, 'f00f00').expect({
+      colorB: '#f00f00',
+    })
+  })
+})

lib/color-formatters.js

@@ -0,0 +1,117 @@
+/**
+ * Commonly-used functions for determining the colour to use for a badge,
+ * including colours based off download count, version number, etc.
+ */
+'use strict'
+
+const moment = require('moment')
+
+function version(version) {
+  if (typeof version !== 'string' && typeof version !== 'number') {
+    throw new Error(`Can't generate a version color for ${version}`)
+  }
+  version = `${version}`
+  let first = version[0]
+  if (first === 'v') {
+    first = version[1]
+  }
+  if (first === '0' || /alpha|beta|snapshot|dev|pre/i.test(version)) {
+    return 'orange'
+  } else {
+    return 'blue'
+  }
+}
+
+function downloadCount(downloads) {
+  return floorCount(downloads, 10, 100, 1000)
+}
+
+function coveragePercentage(percentage) {
+  return floorCount(percentage, 80, 90, 100)
+}
+
+function floorCount(value, yellow, yellowgreen, green) {
+  if (value <= 0) {
+    return 'red'
+  } else if (value < yellow) {
+    return 'yellow'
+  } else if (value < yellowgreen) {
+    return 'yellowgreen'
+  } else if (value < green) {
+    return 'green'
+  } else {
+    return 'brightgreen'
+  }
+}
+
+function letterScore(score) {
+  if (score === 'A') {
+    return 'brightgreen'
+  } else if (score === 'B') {
+    return 'green'
+  } else if (score === 'C') {
+    return 'yellowgreen'
+  } else if (score === 'D') {
+    return 'yellow'
+  } else if (score === 'E') {
+    return 'orange'
+  } else {
+    return 'red'
+  }
+}
+
+function colorScale(steps, colors, reversed) {
+  if (steps === undefined) {
+    throw Error('When invoking colorScale, steps should be provided.')
+  }
+
+  const defaultColors = {
+    1: ['red', 'brightgreen'],
+    2: ['red', 'yellow', 'brightgreen'],
+    3: ['red', 'yellow', 'green', 'brightgreen'],
+    4: ['red', 'yellow', 'yellowgreen', 'green', 'brightgreen'],
+    5: ['red', 'orange', 'yellow', 'yellowgreen', 'green', 'brightgreen'],
+  }
+
+  if (typeof colors === 'undefined') {
+    if (steps.length in defaultColors) {
+      colors = defaultColors[steps.length]
+    } else {
+      throw Error(`No default colors for ${steps.length} steps.`)
+    }
+  }
+
+  if (steps.length !== colors.length - 1) {
+    throw Error(
+      'When colors are provided, there should be n + 1 colors for n steps.'
+    )
+  }
+
+  if (reversed) {
+    colors = Array.from(colors).reverse()
+  }
+
+  return value => {
+    const stepIndex = steps.findIndex(step => value < step)
+
+    // For the final step, stepIndex is -1, so in all cases this expression
+    // works swimmingly.
+    return colors.slice(stepIndex)[0]
+  }
+}
+
+function age(date) {
+  const colorByAge = colorScale([7, 30, 180, 365, 730], undefined, true)
+  const daysElapsed = moment().diff(moment(date), 'days')
+  return colorByAge(daysElapsed)
+}
+
+module.exports = {
+  version,
+  downloadCount,
+  coveragePercentage,
+  floorCount,
+  letterScore,
+  colorScale,
+  age,
+}

lib/color-formatters.spec.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const { test, given, forCases } = require('sazerac')
+const { expect } = require('chai')
+const {
+  coveragePercentage,
+  colorScale,
+  letterScore,
+  age,
+  version,
+} = require('./color-formatters')
+
+describe('Color formatters', function() {
+  const byPercentage = colorScale([Number.EPSILON, 80, 90, 100])
+
+  test(byPercentage, () => {
+    given(-1).expect('red')
+    given(0).expect('red')
+    given(0.5).expect('yellow')
+    given(1).expect('yellow')
+    given(50).expect('yellow')
+    given(80).expect('yellowgreen')
+    given(85).expect('yellowgreen')
+    given(90).expect('green')
+    given(100).expect('brightgreen')
+    given(101).expect('brightgreen')
+
+    forCases(
+      [-1, 0, 0.5, 1, 50, 80, 85, 90, 100, 101].map(v =>
+        given(v).expect(coveragePercentage(v))
+      )
+    ).should("return '%s', for parity with coveragePercentage()")
+  })
+
+  context('when reversed', function() {
+    test(colorScale([7, 30, 180, 365, 730], undefined, true), () => {
+      given(3).expect('brightgreen')
+      given(7).expect('green')
+      given(10).expect('green')
+      given(60).expect('yellowgreen')
+      given(250).expect('yellow')
+      given(400).expect('orange')
+      given(800).expect('red')
+    })
+  })
+
+  test(letterScore, () => {
+    given('A').expect('brightgreen')
+    given('B').expect('green')
+    given('C').expect('yellowgreen')
+    given('D').expect('yellow')
+    given('E').expect('orange')
+    given('F').expect('red')
+    given('Z').expect('red')
+  })
+
+  const monthsAgo = months => {
+    const result = new Date()
+    // This looks wack but it works.
+    result.setMonth(result.getMonth() - months)
+    return result
+  }
+  test(age, () => {
+    given(Date.now())
+      .describe('when given the current timestamp')
+      .expect('brightgreen')
+    given(new Date())
+      .describe('when given the current Date')
+      .expect('brightgreen')
+    given(new Date(2001, 1, 1))
+      .describe('when given a Date many years ago')
+      .expect('red')
+    given(monthsAgo(2))
+      .describe('when given a Date two months ago')
+      .expect('yellowgreen')
+    given(monthsAgo(15))
+      .describe('when given a Date 15 months ago')
+      .expect('orange')
+  })
+
+  test(version, () => {
+    forCases([given('1.0'), given(9), given(1.0)]).expect('blue')
+
+    forCases([
+      given(0.1),
+      given('0.9'),
+      given('1.0-Beta'),
+      given('1.1-alpha'),
+      given('6.0-SNAPSHOT'),
+      given('1.0.1-dev'),
+      given('2.1.6-prerelease'),
+    ]).expect('orange')
+
+    expect(() => version(null)).to.throw(
+      Error,
+      "Can't generate a version color for null"
+    )
+    expect(() => version(undefined)).to.throw(
+      Error,
+      "Can't generate a version color for undefined"
+    )
+    expect(() => version(true)).to.throw(
+      Error,
+      "Can't generate a version color for true"
+    )
+    expect(() => version({})).to.throw(
+      Error,
+      "Can't generate a version color for [object Object]"
+    )
+  })
+})

lib/deprecated-services.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const deprecatedServices = {
+  gittip: new Date('2017-12-29'),
+  gratipay: new Date('2017-12-29'),
+  gemnasium: new Date('2018-05-15'),
+  snap: new Date('2018-01-23'),
+  'snap-ci': new Date('2018-01-23'),
+  cauditor: new Date('2018-02-15'),
+  dotnetstatus: new Date('2018-04-01'),
+  magnumci: new Date('2018-07-08'),
+  bithound: new Date('2018-07-08'),
+  versioneye: new Date('2018-08-20'),
+  issuestats: new Date('2018-09-01'),
+  libscore: new Date('2018-09-22'),
+}
+
+module.exports = {
+  deprecatedServices,
+}

lib/deprecation-helpers.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const { Deprecated } = require('../services/errors')
+
+function enforceDeprecation(effectiveDate) {
+  if (Date.now() >= effectiveDate.getTime()) {
+    throw new Deprecated()
+  }
+}
+
+module.exports = {
+  enforceDeprecation,
+}

lib/deprecation-helpers.spec.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { expect } = require('chai')
+const { Deprecated } = require('../services/errors')
+const { enforceDeprecation } = require('./deprecation-helpers')
+
+describe('enforceDeprecation', function() {
+  it('throws Deprecated for a date in the past', function() {
+    expect(() => enforceDeprecation(new Date())).to.throw(Deprecated)
+  })
+
+  it('does not throw for a date in the future', function() {
+    expect(() =>
+      enforceDeprecation(new Date(Date.now() + 10000))
+    ).not.to.throw()
+  })
+})

lib/error-helper.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const {
+  NotFound,
+  InvalidResponse,
+  Inaccessible,
+} = require('../services/errors')
+const defaultErrorMessages = {
+  404: 'not found',
+}
+
+const checkErrorResponse = function(badgeData, err, res, errorMessages = {}) {
+  errorMessages = { ...defaultErrorMessages, ...errorMessages }
+  if (err != null) {
+    badgeData.text[1] = 'inaccessible'
+    badgeData.colorscheme = 'red'
+    return true
+  } else if (errorMessages[res.statusCode] !== undefined) {
+    badgeData.text[1] = errorMessages[res.statusCode]
+    badgeData.colorscheme = 'lightgrey'
+    return true
+  } else if (res.statusCode !== 200) {
+    badgeData.text[1] = 'invalid'
+    badgeData.colorscheme = 'lightgrey'
+    return true
+  } else {
+    return false
+  }
+}
+
+checkErrorResponse.asPromise = function(errorMessages = {}) {
+  return async function({ buffer, res }) {
+    errorMessages = { ...defaultErrorMessages, ...errorMessages }
+    if (res.statusCode === 404) {
+      throw new NotFound({ prettyMessage: errorMessages[404] })
+    } else if (res.statusCode !== 200) {
+      const underlying = Error(
+        `Got status code ${res.statusCode} (expected 200)`
+      )
+      const props = { underlyingError: underlying }
+      if (errorMessages[res.statusCode] !== undefined) {
+        props.prettyMessage = errorMessages[res.statusCode]
+      }
+      if (res.statusCode >= 500) {
+        throw new Inaccessible(props)
+      }
+      throw new InvalidResponse(props)
+    }
+    return { buffer, res }
+  }
+}
+
+module.exports = {
+  checkErrorResponse,
+}

lib/error-helper.spec.js

@@ -0,0 +1,152 @@
+'use strict'
+
+const { expect } = require('chai')
+const { checkErrorResponse } = require('./error-helper')
+const {
+  NotFound,
+  InvalidResponse,
+  Inaccessible,
+} = require('../services/errors')
+
+describe('Standard Error Handler', function() {
+  it('makes inaccessible badge', function() {
+    const badgeData = { text: [] }
+    expect(checkErrorResponse(badgeData, 'something other than null', {})).to.be
+      .true
+    expect(badgeData.text[1]).to.equal('inaccessible')
+    expect(badgeData.colorscheme).to.equal('red')
+  })
+
+  it('makes not found badge', function() {
+    const badgeData = { text: [] }
+    expect(checkErrorResponse(badgeData, null, { statusCode: 404 })).to.be.true
+    expect(badgeData.text[1]).to.equal('not found')
+    expect(badgeData.colorscheme).to.equal('lightgrey')
+  })
+
+  it('makes not found badge with custom error', function() {
+    const badgeData = { text: [] }
+    expect(
+      checkErrorResponse(
+        badgeData,
+        null,
+        { statusCode: 404 },
+        { 404: 'custom message' }
+      )
+    ).to.be.true
+    expect(badgeData.text[1]).to.equal('custom message')
+    expect(badgeData.colorscheme).to.equal('lightgrey')
+  })
+
+  it('makes invalid badge', function() {
+    const badgeData = { text: [] }
+    expect(checkErrorResponse(badgeData, null, { statusCode: 500 })).to.be.true
+    expect(badgeData.text[1]).to.equal('invalid')
+    expect(badgeData.colorscheme).to.equal('lightgrey')
+  })
+
+  it('return false on 200 status', function() {
+    expect(checkErrorResponse({ text: [] }, null, { statusCode: 200 })).to.be
+      .false
+  })
+})
+
+describe('async error handler', function() {
+  context('when status is 200', function() {
+    it('passes through the inputs', async function() {
+      const args = { buffer: 'buffer', res: { statusCode: 200 } }
+      expect(await checkErrorResponse.asPromise()(args)).to.deep.equal(args)
+    })
+  })
+
+  context('when status is 404', function() {
+    const res = { statusCode: 404 }
+
+    it('throws NotFound', async function() {
+      try {
+        await checkErrorResponse.asPromise()({ res })
+        expect.fail('Expected to throw')
+      } catch (e) {
+        expect(e).to.be.an.instanceof(NotFound)
+        expect(e.message).to.equal('Not Found')
+        expect(e.prettyMessage).to.equal('not found')
+      }
+    })
+
+    it('displays the custom not found message', async function() {
+      const notFoundMessage = 'no goblins found'
+      try {
+        await checkErrorResponse.asPromise({ 404: notFoundMessage })({ res })
+        expect.fail('Expected to throw')
+      } catch (e) {
+        expect(e).to.be.an.instanceof(NotFound)
+        expect(e.message).to.equal('Not Found: no goblins found')
+        expect(e.prettyMessage).to.equal('no goblins found')
+      }
+    })
+  })
+
+  context('when status is 4xx', function() {
+    it('throws InvalidResponse', async function() {
+      const res = { statusCode: 499 }
+      try {
+        await checkErrorResponse.asPromise()({ res })
+        expect.fail('Expected to throw')
+      } catch (e) {
+        expect(e).to.be.an.instanceof(InvalidResponse)
+        expect(e.message).to.equal(
+          'Invalid Response: Got status code 499 (expected 200)'
+        )
+        expect(e.prettyMessage).to.equal('invalid')
+      }
+    })
+
+    it('displays the custom error message', async function() {
+      const res = { statusCode: 403 }
+      try {
+        await checkErrorResponse.asPromise({
+          403: 'access denied',
+        })({ res })
+        expect.fail('Expected to throw')
+      } catch (e) {
+        expect(e).to.be.an.instanceof(InvalidResponse)
+        expect(e.message).to.equal(
+          'Invalid Response: Got status code 403 (expected 200)'
+        )
+        expect(e.prettyMessage).to.equal('access denied')
+      }
+    })
+  })
+
+  context('when status is 5xx', function() {
+    it('throws Inaccessible', async function() {
+      const res = { statusCode: 503 }
+      try {
+        await checkErrorResponse.asPromise()({ res })
+        expect.fail('Expected to throw')
+      } catch (e) {
+        expect(e).to.be.an.instanceof(Inaccessible)
+        expect(e.message).to.equal(
+          'Inaccessible: Got status code 503 (expected 200)'
+        )
+        expect(e.prettyMessage).to.equal('inaccessible')
+      }
+    })
+
+    it('displays the custom error message', async function() {
+      const res = { statusCode: 500 }
+      try {
+        await checkErrorResponse.asPromise({
+          500: 'server overloaded',
+        })({ res })
+        expect.fail('Expected to throw')
+      } catch (e) {
+        expect(e).to.be.an.instanceof(Inaccessible)
+        expect(e.message).to.equal(
+          'Inaccessible: Got status code 500 (expected 200)'
+        )
+        expect(e.prettyMessage).to.equal('server overloaded')
+      }
+    })
+  })
+})

lib/fs-token-persistence.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const fsos = require('fsos')
+const githubAuth = require('./github-auth')
+const TokenPersistence = require('./token-persistence')
+
+class FsTokenPersistence extends TokenPersistence {
+  constructor({ path }) {
+    super()
+    this.path = path
+  }
+
+  async initialize() {
+    let contents
+    try {
+      contents = await fsos.get(this.path)
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        contents = '[]'
+      } else {
+        throw e
+      }
+    }
+
+    const tokens = JSON.parse(contents)
+    tokens.forEach(tokenString => {
+      githubAuth.addGithubToken(tokenString)
+    })
+  }
+
+  async save() {
+    const tokens = githubAuth.getAllTokenIds()
+    await fsos.set(this.path, JSON.stringify(tokens))
+  }
+
+  async onTokenAdded(token) {
+    await this.save()
+  }
+
+  async onTokenRemoved(token) {
+    await this.save()
+  }
+}
+
+module.exports = FsTokenPersistence

lib/fs-token-persistence.spec.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const fs = require('fs')
+const tmp = require('tmp')
+const readFile = require('fs-readfile-promise')
+const { expect } = require('chai')
+const FsTokenPersistence = require('./fs-token-persistence')
+const githubAuth = require('./github-auth')
+
+describe('File system token persistence', function() {
+  beforeEach(githubAuth.removeAllTokens)
+  afterEach(githubAuth.removeAllTokens)
+
+  let path, persistence
+  beforeEach(function() {
+    path = tmp.tmpNameSync()
+    persistence = new FsTokenPersistence({ path })
+  })
+
+  context('when the file does not exist', function() {
+    it('does nothing', async function() {
+      await persistence.initialize()
+      expect(githubAuth.getAllTokenIds()).to.deep.equal([])
+    })
+
+    it('saving creates an empty file', async function() {
+      await persistence.initialize()
+
+      await persistence.save()
+
+      const json = JSON.parse(await readFile(path))
+      expect(json).to.deep.deep.equal([])
+    })
+  })
+
+  context('when the file exists', function() {
+    const initialTokens = ['a', 'b', 'c'].map(char => char.repeat(40))
+
+    beforeEach(async function() {
+      fs.writeFileSync(path, JSON.stringify(initialTokens))
+    })
+
+    it('loads the contents', async function() {
+      await persistence.initialize()
+      expect(githubAuth.getAllTokenIds()).to.deep.equal(initialTokens)
+    })
+
+    context('when tokens are added', function() {
+      it('saves the change', async function() {
+        const newToken = 'e'.repeat(40)
+        const expected = initialTokens.slice()
+        expected.push(newToken)
+
+        await persistence.initialize()
+        githubAuth.addGithubToken(newToken)
+        await persistence.noteTokenAdded(newToken)
+
+        const savedTokens = JSON.parse(await readFile(path))
+        expect(savedTokens).to.deep.equal(expected)
+      })
+    })
+
+    context('when tokens are removed', function() {
+      it('saves the change', async function() {
+        const expected = Array.from(initialTokens)
+        const toRemove = expected.pop()
+
+        await persistence.initialize()
+
+        githubAuth.rmGithubToken(toRemove)
+        await persistence.noteTokenRemoved(toRemove)
+
+        const savedTokens = JSON.parse(await readFile(path))
+        expect(savedTokens).to.deep.equal(expected)
+      })
+    })
+  })
+})

lib/github-auth.js

@@ -1,167 +1,60 @@
-var querystring = require('querystring');
-var request = require('request');
-var autosave = require('json-autosave');
-var serverSecrets;
-try {
-  // Everything that cannot be checked in but is useful server-side
-  // is stored in this JSON data.
-  serverSecrets = require('../secret.json');
-} catch(e) {}
-var githubUserTokens;
-var githubUserTokensFile = '.github-user-tokens.json';
-autosave(githubUserTokensFile, {data:[]}).then(function(f) {
-  githubUserTokens = f;
-  for (var i = 0; i < githubUserTokens.data.length; i++) {
-    addGithubToken(githubUserTokens.data[i]);
-  }
-}).catch(function(e) { console.error('Could not create ' + githubUserTokensFile); });
+'use strict'
 
-function setRoutes(server) {
-  server.route(/^\/github-auth$/, function(data, match, end, ask) {
-    if (!(serverSecrets && serverSecrets.gh_client_id)) {
-      return end('This server is missing GitHub client secrets.');
-    }
-    var query = querystring.stringify({
-      client_id: serverSecrets.gh_client_id,
-      redirect_uri: 'https://img.shields.io/github-auth/done',
-    });
-    ask.res.statusCode = 302;  // Found.
-    ask.res.setHeader('Location', 'https://github.com/login/oauth/authorize?' + query);
-    end('');
-  });
+const { EventEmitter } = require('events')
+const crypto = require('crypto')
+const queryString = require('query-string')
+const serverSecrets = require('./server-secrets')
+const mapKeys = require('lodash.mapkeys')
 
-  server.route(/^\/github-auth\/done$/, function(data, match, end, ask) {
-    if (!(serverSecrets && serverSecrets.gh_client_id && serverSecrets.gh_client_secret)) {
-      return end('This server is missing GitHub client secrets.');
-    }
-    if (!data.code) {
-      return end('GitHub OAuth authentication failed to provide a code.');
-    }
-    var options = {
-      url: 'https://github.com/login/oauth/access_token',
-      headers: {
-        'Content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
-        'User-Agent': 'Shields.io',
-      },
-      form: querystring.stringify({
-        client_id: serverSecrets.gh_client_id,
-        client_secret: serverSecrets.gh_client_secret,
-        code: data.code,
-      }),
-      method: 'POST',
-    };
-    request(options, function(err, res, body) {
-      if (err != null) { return end('The connection to GitHub failed.'); }
-      try {
-        var content = querystring.parse(body);
-      } catch(e) { return end('The GitHub OAuth token could not be parsed.'); }
-      var token = content.access_token;
-      if (!token) {
-        return end('The GitHub OAuth process did not return a user token.');
-      }
-      console.log('GitHub OAuth: ' + token);
-
-      ask.res.setHeader('Content-Type', 'text/html');
-      end('<p>Shields.io has received your app-specific GitHub user token. ' +
-          'You can revoke it by going to ' +
-          '<a href="https://github.com/settings/applications">GitHub</a>.</p>' +
-          '<p>Until you do, you have now increased the rate limit for GitHub ' +
-          'requests going through Shields.io. GitHub-related badges are ' +
-          'therefore more robust.</p>' +
-          '<p>Thanks for contributing to a smoother experience for ' +
-          'everyone!</p>' +
-          '<p><a href="/">Back to the website</a></p>');
-
-      sendTokenToAllServers(token)
-      .catch(function(e) {
-        console.error('GitHub user token transmission failed:', e);
-      });
-    });
-  });
-
-  server.route(/^\/github-auth\/add-token$/, function(data, match, end, ask) {
-    console.log('GitHub add token called with', JSON.stringify(data));
-    if (data.shieldsSecret !== serverSecrets.shieldsSecret) {
-      // An unknown entity tries to connect. Let the connection linger for a minute.
-      return setTimeout(function() { end('Invalid secret.'); }, 60000);
-    }
-    addGithubToken(data.token);
-    end('Thanks!');
-  });
-};
-
-function sendTokenToAllServers(token) {
-  var ips = serverSecrets.shieldsIps;
-  return Promise.all(ips.map(function(ip) {
-    return new Promise(function(resolve, reject) {
-      var options = {
-        url: 'https://' + ip + '/github-auth/add-token',
-        method: 'POST',
-        form: {
-          shieldsSecret: serverSecrets.shieldsSecret,
-          token: token,
-        },
-        // We target servers by IP, and we use HTTPS. Assuming that
-        // 1. Internet routers aren't hacked, and
-        // 2. We don't unknowingly lose our IP to someone else,
-        // we're not leaking people's and our information.
-        // (If we did, it would have no impact, as we only ask for a token,
-        // no GitHub scope. The malicious entity would only be able to use
-        // our rate limit pool.)
-        // FIXME: use letsencrypt.
-        strictSSL: false,
-      };
-      request(options, function(err, res, body) {
-        if (err != null) { return reject('Posting the GitHub user token failed: ' + err.stack); }
-        resolve();
-      });
-    });
-  }));
-}
-
-// Track rate limit requests remaining.
+const userTokenRateLimit = 12500
 
+let githubUserTokens = []
 // Ideally, we would want priority queues here.
-var reqRemaining = new Map();  // From token to requests remaining.
-var reqReset = new Map();  // From token to timestamp.
+const reqRemaining = new Map() // From token to requests remaining.
+const reqReset = new Map() // From token to timestamp.
+
+const emitter = new EventEmitter()
+
+// Personal tokens allow access to GitHub private repositories.
+// You can manage your personal GitHub token at
+// <https://github.com/settings/tokens>.
+if (serverSecrets && serverSecrets.gh_token) {
+  addGithubToken(serverSecrets.gh_token)
+}
 
 // token: client token as a string.
 // reqs: number of requests remaining.
 // reset: timestamp when the number of remaining requests is reset.
 function setReqRemaining(token, reqs, reset) {
-  reqRemaining.set(token, reqs);
-  reqReset.set(token, reset);
+  reqRemaining.set(token, reqs)
+  reqReset.set(token, reset)
 }
 
 function rmReqRemaining(token) {
-  reqRemaining.delete(token);
-  reqReset.delete(token);
+  reqRemaining.delete(token)
+  reqReset.delete(token)
 }
 
 function utcEpochSeconds() {
-  return ((Date.now() / 1000) >>> 0);
+  return (Date.now() / 1000) >>> 0
 }
 
-var userTokenRateLimit = 12500;
-
 // Return false if the token cannot reasonably be expected to perform
 // a GitHub request.
 function isTokenUsable(token, now) {
-  var reqs = reqRemaining.get(token);
-  var reset = reqReset.get(token);
+  const reqs = reqRemaining.get(token)
+  const reset = reqReset.get(token)
   // We don't want to empty more than 3/4 of a user's rate limit.
-  var hasRemainingReqs = reqs > (userTokenRateLimit / 4);
-  var isBeyondRateLimitReset = reset < now;
-  return hasRemainingReqs || isBeyondRateLimitReset;
+  const hasRemainingReqs = reqs > userTokenRateLimit / 4
+  const isBeyondRateLimitReset = reset < now
+  return hasRemainingReqs || isBeyondRateLimitReset
 }
 
 // Return a list of tokens (as strings) which can be used for a GitHub request,
 // with a reasonable chance that the request will succeed.
 function usableTokens() {
-  var now = utcEpochSeconds();
-  return githubUserTokens.data.filter(function(token) {
-    return isTokenUsable(token, now);
-  });
+  const now = utcEpochSeconds()
+  return githubUserTokens.filter(token => isTokenUsable(token, now))
 }
 
 // Retrieve a user token if there is one for which we believe there are requests
@@ -170,84 +63,151 @@ function getReqRemainingToken() {
   // Go through the user tokens.
   // Among usable ones, use the one with the highest number of remaining
   // requests.
-  var tokens = usableTokens();
-  var highestReq = -1;
-  var highestToken;
-  for (var i = 0; i < tokens.length; i++) {
-    var token = tokens[i];
-    var reqs = reqRemaining.get(token);
+  const tokens = usableTokens()
+  let highestReq = -1
+  let highestToken
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+    const reqs = reqRemaining.get(token)
     if (reqs > highestReq) {
-      highestReq = reqs;
-      highestToken = token;
+      highestReq = reqs
+      highestToken = token
     }
   }
-  return highestToken;
+  return highestToken
 }
 
 function addGithubToken(token) {
   // A reset date of 0 has to be in the past.
-  setReqRemaining(token, userTokenRateLimit, 0);
+  setReqRemaining(token, userTokenRateLimit, 0)
   // Insert it only if it is not registered yet.
-  if (githubUserTokens.data.indexOf(token) === -1) {
-    githubUserTokens.data.push(token);
+  if (githubUserTokens.indexOf(token) === -1) {
+    githubUserTokens.push(token)
   }
+  emitter.emit('token-added', token)
 }
 
 function rmGithubToken(token) {
-  rmReqRemaining(token);
+  rmReqRemaining(token)
   // Remove it only if it is in there.
-  var idx = githubUserTokens.data.indexOf(token);
+  const idx = githubUserTokens.indexOf(token)
   if (idx >= 0) {
-    githubUserTokens.data.splice(idx, 1);
+    githubUserTokens.splice(idx, 1)
   }
 }
 
-// Personal tokens allow access to GitHub private repositories.
-// You can manage your personal GitHub token at
-// <https://github.com/settings/tokens>.
-if (serverSecrets && serverSecrets.gh_token) {
-  addGithubToken(serverSecrets.gh_token);
+// Convert an ES6 Map to an object.
+function mapToObject(map) {
+  const result = {}
+  for (const [k, v] of map) {
+    result[k] = v
+  }
+  return result
 }
 
+// Compute a one-way hash of the input string.
+function sha(str) {
+  return crypto
+    .createHash('sha256')
+    .update(str, 'utf-8')
+    .digest('hex')
+}
+
+function getAllTokenIds() {
+  return githubUserTokens.slice()
+}
+
+function removeAllTokens() {
+  githubUserTokens = []
+}
+
+function serializeDebugInfo(options) {
+  // Apply defaults.
+  const { sanitize } = Object.assign({ sanitize: true }, options)
+
+  const unsanitized = {
+    tokens: githubUserTokens,
+    reqRemaining: mapToObject(reqRemaining),
+    reqReset: mapToObject(reqReset),
+    utcEpochSeconds: utcEpochSeconds(),
+    sanitized: false,
+  }
+
+  if (sanitize) {
+    return {
+      tokens: unsanitized.tokens.map(k => sha(k)),
+      reqRemaining: mapKeys(unsanitized.reqRemaining, (v, k) => sha(k)),
+      reqReset: mapKeys(unsanitized.reqReset, (v, k) => sha(k)),
+      utcEpochSeconds: unsanitized.utcEpochSeconds,
+      sanitized: true,
+    }
+  } else {
+    return unsanitized
+  }
+}
+
+// When a global gh_token is configured, use that in place of our shields.io
+// token-cycling logic. This produces more predictable behavior when a token
+// is provided, and more predictable failures if that token is exhausted.
+//
+// You can manage your personal GitHub token at https://github.com/settings/tokens
+const globalToken = (serverSecrets || {}).gh_token
+
 // Act like request(), but tweak headers and query to avoid hitting a rate
 // limit.
 function githubRequest(request, url, query, cb) {
-  query = query || {};
+  query = query || {}
   // A special User-Agent is required:
   // http://developer.github.com/v3/#user-agent-required
-  var headers = {
+  const headers = {
     'User-Agent': 'Shields.io',
-    'Accept': 'application/vnd.github.v3+json',
-  };
-  var githubToken = getReqRemainingToken();
+    Accept: 'application/vnd.github.v3+json',
+  }
+
+  const githubToken =
+    globalToken === undefined ? getReqRemainingToken() : globalToken
 
   if (githubToken != null) {
     // Typically, GitHub user tokens grants us 12500 req/hour.
-    headers['Authorization'] = 'token ' + githubToken;
+    headers['Authorization'] = `token ${githubToken}`
   } else if (serverSecrets && serverSecrets.gh_client_id) {
     // Using our OAuth App secret grants us 5000 req/hour
     // instead of the standard 60 req/hour.
-    query.client_id = serverSecrets.gh_client_id;
-    query.client_secret = serverSecrets.gh_client_secret;
+    query.client_id = serverSecrets.gh_client_id
+    query.client_secret = serverSecrets.gh_client_secret
   }
 
-  var qs = querystring.stringify(query);
-  if (qs) { url += '?' + qs; }
-  request(url, {headers: headers}, function(err, res, buffer) {
-    if (githubToken != null) {
-      if (res.statusCode === 401) {  // Unauthorized.
-        rmGithubToken(githubToken);
+  const qs = queryString.stringify(query)
+  if (qs) {
+    url += `?${qs}`
+  }
+
+  request(url, { headers }, (err, res, buffer) => {
+    if (globalToken !== null && githubToken !== null && err === null) {
+      if (res.statusCode === 401) {
+        // Unauthorized.
+        rmGithubToken(githubToken)
+        emitter.emit('token-removed', githubToken)
       } else {
-        var remaining = +res.headers['x-ratelimit-remaining'];
+        const remaining = +res.headers['x-ratelimit-remaining']
         // reset is in UTC epoch seconds.
-        var reset = +res.headers['x-ratelimit-reset'];
-        setReqRemaining(githubToken, remaining, reset);
-        if (remaining === 0) { return; }  // Hope for the best in the cache.
+        const reset = +res.headers['x-ratelimit-reset']
+        setReqRemaining(githubToken, remaining, reset)
+        if (remaining === 0) {
+          return
+        } // Hope for the best in the cache.
       }
     }
-    cb(err, res, buffer);
-  });
+    cb(err, res, buffer)
+  })
 }
 
-exports.setRoutes = setRoutes;
-exports.request = githubRequest;
+module.exports = {
+  request: githubRequest,
+  serializeDebugInfo,
+  addGithubToken,
+  rmGithubToken,
+  getAllTokenIds,
+  removeAllTokens,
+  emitter,
+}

lib/in-process-server-test-helpers.js

@@ -0,0 +1,69 @@
+/**
+ * Helpers to run a Shields server in process.
+ *
+ * Usage:
+ * let server;
+ * before('Start running the server', function () {
+ *   this.timeout(5000);
+ *   server = serverHelpers.start();
+ * });
+ * after('Shut down the server', function () { serverHelpers.stop(server); });
+ */
+
+'use strict'
+
+const config = require('./test-config')
+const serverConfig = require('./server-config')
+
+let startCalled = false
+
+/**
+ * Start the server.
+ *
+ * @param {Number} port number (optional)
+ * @return {Object} The scoutcamp instance
+ */
+function start() {
+  if (startCalled) {
+    throw Error(
+      'Because of the way Shields works, you can only use this ' +
+        'once per node process. Once you call stop(), the game is over.'
+    )
+  }
+  startCalled = true
+
+  // Modifying config is a bit dirty, but it works, and avoids making bigger
+  // changes to server.js.
+  serverConfig.bind = {
+    host: 'localhost',
+    port: config.port,
+  }
+  const server = require('../server')
+  return server
+}
+
+/**
+ * Reset the server, to avoid or reduce side effects between tests.
+ *
+ * @param {Object} server instance
+ */
+function reset(server) {
+  server.reset()
+}
+
+/**
+ * Stop the server.
+ *
+ * @param {Object} server instance
+ */
+async function stop(server) {
+  if (server) {
+    await server.stop()
+  }
+}
+
+module.exports = {
+  start,
+  reset,
+  stop,
+}

lib/licenses.js

@@ -0,0 +1,97 @@
+'use strict'
+
+const { toArray } = require('./badge-data')
+
+const licenseTypes = {
+  // permissive licenses - not public domain and not copyleft
+  permissive: {
+    spdxLicenseIds: [
+      'AFL-3.0',
+      'Apache-2.0',
+      'Artistic-2.0',
+      'BSD-2-Clause',
+      'BSD-3-Clause',
+      'BSD-3-Clause-Clear',
+      'BSL-1.0',
+      'CC-BY-4.0',
+      'ECL-2.0',
+      'ISC',
+      'MIT',
+      'MS-PL',
+      'NCSA',
+      'PostgreSQL',
+      'Zlib',
+    ],
+    color: 'green',
+    priority: '2',
+  },
+  // copyleft licenses require 'Disclose source' (https://choosealicense.com/appendix/#disclose-source)
+  // or 'Same license' (https://choosealicense.com/appendix/#same-license)
+  copyleft: {
+    spdxLicenseIds: [
+      'AGPL-3.0',
+      'CC-BY-SA-4.0',
+      'EPL-1.0',
+      'EUPL-1.1',
+      'GPL-2.0',
+      'GPL-3.0',
+      'LGPL-2.1',
+      'LGPL-3.0',
+      'LPPL-1.3c',
+      'MPL-2.0',
+      'MS-RL',
+      'OFL-1.1',
+      'OSL-3.0',
+    ],
+    color: 'orange',
+    priority: '1',
+  },
+  // public domain licenses do not require 'License and copyright notice' (https://choosealicense.com/appendix/#include-copyright)
+  'public-domain': {
+    spdxLicenseIds: ['CC0-1.0', 'Unlicense', 'WTFPL'],
+    color: '7cd958',
+    priority: '3',
+  },
+}
+
+const licenseToColorMap = {}
+Object.keys(licenseTypes).forEach(licenseType => {
+  const { spdxLicenseIds, color, priority } = licenseTypes[licenseType]
+  spdxLicenseIds.forEach(license => {
+    licenseToColorMap[license] = { color, priority }
+  })
+})
+const defaultLicenseColor = 'lightgrey'
+const licenseToColor = spdxId => {
+  if (!Array.isArray(spdxId)) {
+    return (
+      (licenseToColorMap[spdxId] && licenseToColorMap[spdxId].color) ||
+      defaultLicenseColor
+    )
+  }
+  const licenseType = spdxId
+    .filter(i => licenseToColorMap[i])
+    .map(i => licenseToColorMap[i])
+    .reduce((a, b) => (a.priority > b.priority ? a : b), {
+      color: defaultLicenseColor,
+      priority: 0,
+    })
+  return licenseType.color
+}
+
+function renderLicenseBadge({ license, licenses }) {
+  if (licenses === undefined) {
+    licenses = toArray(license)
+  }
+
+  if (licenses.length === 0) {
+    return { message: 'missing', color: 'red' }
+  }
+
+  return {
+    message: licenses.join(', '),
+    color: licenseToColor(licenses),
+  }
+}
+
+module.exports = { licenseToColor, renderLicenseBadge }

lib/licenses.spec.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const { test, given, forCases } = require('sazerac')
+const { licenseToColor, renderLicenseBadge } = require('./licenses')
+
+describe('license helpers', function() {
+  test(licenseToColor, () => {
+    given('MIT').expect('green')
+    given('MPL-2.0').expect('orange')
+    given('Unlicense').expect('7cd958')
+    given('unknown-license').expect('lightgrey')
+    given(null).expect('lightgrey')
+
+    given(['CC0-1.0', 'MPL-2.0']).expect('7cd958')
+    given(['MPL-2.0', 'CC0-1.0']).expect('7cd958')
+    given(['MIT', 'MPL-2.0']).expect('green')
+    given(['MPL-2.0', 'MIT']).expect('green')
+    given(['OFL-1.1', 'MPL-2.0']).expect('orange')
+    given(['MPL-2.0', 'OFL-1.1']).expect('orange')
+    given(['CC0-1.0', 'MIT', 'MPL-2.0']).expect('7cd958')
+    given(['UNKNOWN-1.0', 'MIT']).expect('green')
+    given(['UNKNOWN-1.0', 'UNKNOWN-2.0']).expect('lightgrey')
+  })
+
+  test(renderLicenseBadge, () => {
+    forCases([
+      given({ license: undefined }),
+      given({ licenses: [] }),
+      given({}),
+    ]).expect({
+      message: 'missing',
+      color: 'red',
+    })
+    forCases([
+      given({ license: 'WTFPL' }),
+      given({ licenses: ['WTFPL'] }),
+    ]).expect({
+      message: 'WTFPL',
+      color: '7cd958',
+    })
+    given({ licenses: ['MPL-2.0', 'MIT'] }).expect({
+      message: 'MPL-2.0, MIT',
+      color: 'green',
+    })
+  })
+})

lib/load-logos.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const { svg2base64 } = require('./logo-helper')
+
+function loadLogos() {
+  // Cache svg logos from disk in base64 string
+  const logos = {}
+  const logoDir = path.join(__dirname, '..', 'logo')
+  const logoFiles = fs.readdirSync(logoDir)
+  logoFiles.forEach(filename => {
+    if (filename[0] === '.') {
+      return
+    }
+    // filename is eg, github.svg
+    const svg = fs.readFileSync(`${logoDir}/${filename}`).toString()
+    const base64 = svg2base64(svg)
+
+    // eg, github
+    const name = filename.slice(0, -'.svg'.length).toLowerCase()
+    logos[name] = {
+      svg,
+      base64,
+    }
+  })
+  return logos
+}
+
+module.exports = loadLogos