veragem 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 128228dcd7c502914864f545a3f08eebcec11a836fa0955269d6e3da81ed099f
+  data.tar.gz: '072395d027bb7849364754b89ea554b15bae49334130c09ac3637c7fd041e7ca'
+SHA512:
+  metadata.gz: 413a5e94dae20bdb6ea0fec365aa90973705fef6fa7e846b4b4e16aa84e28eac08fd03e9a6561b231aa4617f789337f348dea7cd1c7359c66fa1258b7d382e38
+  data.tar.gz: 99cc7a2a3f4717bc158c92879da21f9d44afda306579086945c5dab4dbd3bdfc691536da20ecc17fd162785956d98f7dcabf2c25164110a090432897f422195e

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this project are documented in this file, generated by
+[git-cliff](https://git-cliff.org) from its commits; versions follow
+[Semantic Versioning](https://semver.org).
+
+## [0.1.0](https://github.com/veralvx/veragem/tree/v0.1.0) - 2026-10-26
+
+### Features
+
+- Bundle veragem, a Ruby gem generator as a Bundler plugin
+- template: Rubocop-packaging, and RuboCop's project index (rubydex)
+- template: The gem as a Nix package, and a command's OCI image
+- template: A dependency review of pull requests, and RuboCop's offences annotated
+- template: A Dependabot bump gets RuboCop's safe corrections as a commit
+- template: Dependabot proposes a release once it is a week old
+- template: The workflows and Dependabot's configuration audited by zizmor
+
+### Fixes
+
+- Refuse names the template cannot generate, read git config as bytes
+- template: Release without unused steps, docs as the tools behave
+- Long namespaced command lines, tool names, isolated git config test
+- Refuse names whose modules a gem's tools would meet as classes
+- Check a name's modules in Bundler's process and a sandboxed Ruby
+- template: The Nix package's metadata read whole, its image's environment set
+- Signatures as narrow as the code, comments that match it
+- Refuse the names a gem's own tools would break, and harden the release
+- A command line's modules clash-free, every conventional commit listed
+- A generated gem's constants found as its code means them
+- A name RubyGems reads as its own is refused; `d-bus` passes its checks
+- template: The dependency review advisory and exact, RuboCop's corrections as a patch
+- template: The autocorrection's commit runs its checks, bounded and recoverable
+- template: The autocorrection's re-run, refused push and paths, as said
+- template: The bump's corrections committed, their checks run on approval
+- template: Only the job that pushes keeps its checkout's token
+
+### Documentation
+
+- template: The dependency review needs the dependency graph on
+- The README names the bumps' RuboCop corrections [skip ci]
+- The README opens with what veragem is, its name rules a list
+- template: The README shows what the command prints
+- Tighter documents and comments, nothing they say lost
+- template: A gem's own signatures load with the Steepfile's library
+
+### Tests
+
+- A temporary experiment, a GITHUB_TOKEN push to this pull request
+- The experiment's push, made with GITHUB_TOKEN
+- The GITHUB_TOKEN push experiment again, no review rule in force
+- The experiment's push, made with GITHUB_TOKEN
+

data/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 veralvx
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/LICENSE-MIT

@@ -0,0 +1,7 @@
+Copyright 2026 veralvx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+# veragem
+
+A Bundler plugin that generates a Ruby gem with its toolchain wired up: the Ruby counterpart of
+the [templates](https://github.com/veralvx/templates) repository's Python and Rust templates.
+`bundle gem` gives a gemspec, a Rakefile, Minitest and RuboCop; `bundle veragem NAME` gives that
+and the rest:
+
+- **Ruby 4.0** or later, `required_ruby_version` and CI alike.
+- **Types**: Steep checks `lib/` against the signatures in `sig/`, its strictest diagnostics on;
+  TypeProf infers signatures to start them from, and its editor support is configured.
+- **Lint and format**: RuboCop with every new cop, rubocop-minitest, rubocop-packaging,
+  rubocop-performance and rubocop-rake; the project is indexed first (rubydex), so the cops that see
+  across files do. In CI, offences are annotated on the pull request and a failed run's summary
+  holds the safe corrections as a patch; a Dependabot bump the new cops fail gets them as a commit,
+  then merges as any bump once you approve its runs (`rubocop-autocorrect.yml`, no token to set).
+- **Tests**: Minitest, a property test with [pbt](https://github.com/ohbarye/pbt), and SimpleCov's
+  `strict` profile: every line, branch and method of `lib/` covered.
+- **Security**: bundler-audit over `Gemfile.lock`, daily in CI; a pull request's new gems and
+  actions reviewed for their licences and advisories (`dependency-review.yml`, advisory, as in the
+  Python and Rust templates); zizmor over the workflows and Dependabot's configuration; Dependabot
+  for the gems, the actions and the flake, a release proposed once a week old.
+- **Commits and releases**: Conventional Commits (cocogitto, in CI and opt-in git hooks), a
+  changelog written by git-cliff at each release, `rake "bump[minor]"` then Bundler's own
+  `rake release`; the tag publishes to RubyGems by Trusted Publishing, no API key stored, and makes
+  the GitHub release.
+- **Nix**: a flake with the development shell (Ruby and every tool the checks run), the gem as a
+  package (`nix build`), `nix fmt`, and checks for the Nix, the shell scripts, the workflows and
+  the package. With `--exe`, `nix run` runs the command, and its OCI image (`nix build .#image`)
+  is published to GHCR at each release (`image.yml`), as in the Python and Rust templates.
+- dprint for the Markdown and TOML, an `.editorconfig`, the community documents (`CONTRIBUTING.md`,
+  `AGENTS.md`, `SECURITY.md`, `CODE_OF_CONDUCT.md`), issue and pull request templates.
+
+In the generated gem, `bundle exec rake` runs the Ruby checks, as CI does;
+`bundle exec rake checks` runs everything CI runs.
+
+## Install
+
+Ruby 4.0 or later, then:
+
+```sh
+bundle plugin install veragem
+```
+
+Run outside a project, it installs for your user, and `bundle veragem` then works anywhere. From
+the repository instead: `bundle plugin install veragem --git https://github.com/veralvx/veragem`
+(or `--path` a local checkout).
+
+## Usage
+
+```sh
+bundle veragem my_gem   # and --author, --github where git config has no user.name, github.user
+cd my_gem
+bin/setup               # the gems, and Gemfile.lock written
+git add .
+git commit -m "chore: initial commit from veragem"
+bundle exec rake checks # its tools: the generated CONTRIBUTING.md's, or `nix develop`'s
+```
+
+| Option              | Default                             | Goes into                                       |
+| ------------------- | ----------------------------------- | ----------------------------------------------- |
+| `NAME`              | --                                  | the gem, its module, its files: as `bundle gem` |
+| `--exe`             | a library alone                     | a command line: `exe/NAME`, `lib/NAME/cli.rb`   |
+| `--license=LICENSE` | `dual` (MIT OR Apache-2.0)          | `mit`, `apache` or `dual`: the gemspec, LICENSE |
+| `--author=NAME`     | `git config user.name` (required)   | the gemspec, the licence's copyright line       |
+| `--email=EMAIL`     | `git config user.email` (optional)  | the gemspec, the code of conduct                |
+| `--github=USER`     | `git config github.user` (required) | the homepage, the repository's links            |
+| `--summary=TEXT`    | `A Ruby gem.`                       | the gemspec, the README, the module's comment   |
+
+The name follows `bundle gem`'s rules, lower-case: `my_gem` is `MyGem` in `lib/my_gem.rb`, `my-gem`
+is `My::Gem` in `lib/my/gem.rb`. Refused before anything is written, a name:
+
+- whose module is already defined, by Ruby, Bundler, Rake or Minitest, or by its top-level library
+  where this Ruby has one (`set`, `option_parser`, `date-holidays`: Date is a class);
+- whose file would shadow a library this Ruby has (`json`: lib/json.rb);
+- whose module its tests or `gem build` would take for Minitest's or RubyGems' own
+  (`lifecycle_hooks`, `date_like`);
+- that `bundle gem` would refuse or mangle (`1gem`, `my--gem`);
+- one of the Gemfile's own tools (`rubocop-rake`);
+- `test_helper`, whose lib/test_helper.rb would shadow the tests', or one that would write a
+  template file twice (`helper`: test/test_helper.rb);
+- longer than 40 characters or deeper than 4 modules (the generated code's lines fit RuboCop's);
+- with `--exe`, whose module is CLI or VERSION (`my-c_l_i`: its command line would find another
+  first).
+
+The summary is plain text: written into the README as given, Markdown in it is dprint's to check.
+As `bundle gem` does, veragem makes the git repository and adds the files, and runs no
+`bundle install`: `bin/setup` writes the lock, to commit. The generated `CONTRIBUTING.md` lists
+the first steps: the repository's settings, RubyGems' pending trusted publisher.
+
+## What you get
+
+```
+NAME.gemspec          the gem: its version from lib/NAME/version.rb, its files lib/, sig/, exe/
+Gemfile               the gemspec, then the tools; Gemfile.lock pins them (written by bin/setup)
+Rakefile              `rake`: RuboCop, Steep, the tests; `rake checks`: what CI runs;
+                      `rake "bump[level]"`, `rake release`; `rake -T` lists them all
+Steepfile, sig/       the types; typeprof.conf.jsonc, TypeProf's editor support
+.rubocop.yml          RuboCop and its extensions
+lib/, test/           starter code: typed, documented, every line and branch tested
+bin/setup, bin/console
+flake.nix, flake.lock the dev shell, the package (and the command's image), `nix fmt`, the checks
+.githooks/            opt-in (`rake hooks`): the quick checks before a commit, Conventional Commits
+cliff.toml, cog.toml  git-cliff's changelog, cocogitto's commit checks
+dprint.json, .editorconfig
+.github/              CI, the flake, bundler-audit, the dependency review, the release (and the
+                      image), the style checks, Dependabot, its auto-merge and its bumps'
+                      RuboCop corrections; issue and pull request templates
+README, CONTRIBUTING, AGENTS, SECURITY, CODE_OF_CONDUCT, LICENSE-MIT / LICENSE-APACHE
+```
+
+The Gemfile leaves the development tools unconstrained: the lock pins them at the versions current
+when `bin/setup` first runs, and Dependabot moves it. They need no development group: the built gem
+holds neither the Gemfile nor the lock, its dependencies the gemspec's alone. The dev shell gives
+Ruby and the other tools; the gems are Bundler's, from the lock CI installs from too (nixpkgs
+packages few of them, and older).
+
+## How it is verified
+
+- The plugin's own tests (`bundle exec rake`): the name rules (`bundle gem`'s constant, as a
+  property), the options, every file of each kind and licence rendered, parsed and kept executable,
+  the gemspec read back, the values written as given whatever the locale.
+- The harness here is the template's: this repository's Gemfile, Rakefile, workflows, hooks, flake
+  and tools' configuration are the template's own files, byte for byte (`test/test_sync.rb`), so
+  the template's are checked in place by this repository's checks, and a command line's own
+  (`image.yml`) by the smoke test's command gem.
+- The smoke test (`dev/smoke.sh`, `smoke.yml`, weekly too): the plugin installed from this checkout
+  generates a gem of each kind and licence, and each passes its own `rake checks` and builds.
+
+## Contributing
+
+[CONTRIBUTING.md](CONTRIBUTING.md) (the tools, the checks, the template, the release),
+[AGENTS.md](AGENTS.md) (the rules), [SECURITY.md](SECURITY.md),
+[CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).
+
+## License
+
+Licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
+
+at your option.
+
+The generated gems are yours: their licence is the one you choose at generation.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in
+the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without
+any additional terms or conditions.

data/lib/veragem/generator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+
+module Veragem
+  # Writes a Project's gem from template/: each `.erb` file rendered, every other copied, each with
+  # its mode; then a git repository, its files added, as `bundle gem` leaves one.
+  module Generator
+    # __dir__ is nil only in code evaluated from a string, never in a required file
+    TEMPLATE = File.expand_path("../../template", __dir__) # steep:ignore ArgumentTypeMismatch
+    # The files a command line alone needs: its code, its test, its OCI image's workflow.
+    EXE = %w[exe/%name%.erb lib/%path%/cli.rb.erb test/test_cli.rb.erb .github/workflows/image.yml
+             .github/image-registries.sh].freeze
+    # git's variables that point it at another repository (`git rev-parse --local-env-vars`, but the
+    # configuration given with `git -c`), which a git hook sets: unset, the repository is the gem's.
+    GIT_LOCAL = %w[GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_CONFIG GIT_OBJECT_DIRECTORY GIT_DIR GIT_WORK_TREE
+                   GIT_IMPLICIT_WORK_TREE GIT_GRAFT_FILE GIT_INDEX_FILE GIT_NO_REPLACE_OBJECTS GIT_REPLACE_REF_BASE
+                   GIT_PREFIX GIT_SHALLOW_FILE GIT_COMMON_DIR].to_h { [it, nil] }.freeze
+    # Each LICENSE-* file's SPDX identifier.
+    LICENSE_FILES = { "LICENSE-MIT.erb" => "MIT", "LICENSE-APACHE.erb" => "Apache-2.0" }.freeze
+
+    # Each template file the project takes, and its path in the gem.
+    def self.files(project)
+      skipped = skipped(project)
+      files = Dir.glob("**/*", File::FNM_DOTMATCH, base: TEMPLATE).sort.to_h { [it, path_of(it, project)] }
+      files.reject! { |file, _| skipped.include?(file) || File.directory?(File.join(TEMPLATE, file)) }
+      check(project, files.values)
+      check_command(project)
+      files
+    end
+
+    # A name can be a tool's, which the Gemfile would name twice, or a template file's: `helper`'s
+    # test would be test/test_helper.rb.
+    def self.check(project, paths)
+      raise Error, "invalid gem name #{project.name}: the Gemfile's own tool" if tools.include?(project.name)
+
+      clash = paths.tally.find { |_, count| count > 1 }
+      raise Error, "invalid gem name #{project.name}: it would write #{clash[0]} twice" if clash
+    end
+
+    # A command line names the gem's module from within it, <Gem>::CLI, whose constant lookup finds
+    # CLI and VERSION first: the gem's module cannot be named either.
+    def self.check_command(project)
+      innermost = project.modules.last
+      return unless project.exe && %w[CLI VERSION].include?(innermost)
+
+      raise Error, "invalid gem name #{project.name}: its command line would find another #{innermost} " \
+                   "before its module"
+    end
+
+    # The gems template/Gemfile names.
+    def self.tools = File.read(File.join(TEMPLATE, "Gemfile")).scan(/^gem "([^"]+)"/).flatten
+
+    # The files another kind or licence takes.
+    def self.skipped(project)
+      licenses = LICENSE_FILES.reject { |_, spdx| project.licenses.include?(spdx) }.keys
+      project.exe ? licenses : licenses + EXE
+    end
+
+    def self.path_of(file, project)
+      file.delete_suffix(".erb").gsub("%name%", project.name).gsub("%path%", project.path)
+          .gsub("%underscored%", project.underscored)
+    end
+
+    # Into +target+, a new directory: a failure, an interrupt included, leaves none behind.
+    def self.generate(project, target)
+      raise Error, "#{target} already exists" if File.exist?(target) || File.symlink?(target)
+
+      files = files(project)
+      Dir.mkdir(target)
+      removed_unless_done(target) do
+        files.each { |file, path| write(File.join(TEMPLATE, file), File.join(target, path), project) }
+        git(target, "init", "--quiet", "--initial-branch=main")
+        git(target, "add", "--all")
+      end
+    rescue SystemCallError => e
+      raise Error, e.message
+    end
+
+    def self.removed_unless_done(target)
+      done = false
+      begin
+        yield
+        done = true
+      ensure
+        FileUtils.rm_rf(target) unless done
+      end
+    end
+
+    def self.write(source, destination, project)
+      FileUtils.mkdir_p(File.dirname(destination))
+      File.binwrite(destination, source.end_with?(".erb") ? render(source, project) : File.binread(source))
+      return unless File.executable?(source)
+
+      # executable where readable, as `chmod +x` under the umask
+      mode = File.stat(destination).mode
+      File.chmod(mode | ((mode & 0o444) >> 2), destination)
+    end
+
+    def self.render(source, project)
+      ERB.new(File.read(source, encoding: Encoding::UTF_8), trim_mode: "-").result(project.instance_eval { binding })
+    end
+
+    def self.git(dir, *args)
+      system(GIT_LOCAL, "git", *args, chdir: dir) or raise Error, "git #{args.join(" ")} failed in #{dir}"
+    end
+  end
+end

data/lib/veragem/name.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Veragem
+  # A gem's name, checked: `bundle gem`'s rules, and what the gem's files and tools would meet.
+  module Name
+    # `bundle gem`'s names, lower-case: words of letters and digits joined by `_` (one constant,
+    # `my_gem` is MyGem) or `-` (a namespace, `my-gem` is My::Gem), each constant a letter first.
+    PATTERN = /\A[a-z][a-z0-9]*(?:_[a-z0-9]+)*(?:-[a-z][a-z0-9]*(?:_[a-z0-9]+)*)*\z/
+
+    # Its modules, as `bundle gem` names them: `my-gem_tools`' My, GemTools.
+    def self.modules(name) = name.split("-").map { |word| word.split("_").map(&:capitalize).join }
+
+    # +name+, or an Error saying why a gem cannot have it.
+    def self.check(name)
+      unless PATTERN.match?(name)
+        raise Error, "invalid gem name #{name.inspect}: lower-case words of letters and digits, each a " \
+                     "letter first after a dash, joined by _ or - (my_gem, my-gem)"
+      end
+      # the generated code's lines within RuboCop's 120 columns
+      if name.length > 40 || name.count("-") > 3
+        raise Error, "invalid gem name #{name}: at most 40 characters and 4 modules deep"
+      end
+      # lib/test_helper.rb would shadow the tests' own (Minitest's -Ilib:test)
+      raise Error, "invalid gem name #{name}: its lib/test_helper.rb would shadow the tests'" if name == "test_helper"
+
+      check_modules(name)
+      name
+    end
+
+    # The gem writes lib/<path>.rb, `module` for each of its modules, and tests that name the first.
+    def self.check_modules(name)
+      nestings = nestings_of(name)
+      shadowed, found, *kinds = probe(library_of(name), name.tr("-", "/"), nestings)
+      check_shadowing(name, shadowed.to_s, found.to_s)
+      check_defined(name, nestings.zip(kinds).take_while { |_, kind| !kind.to_s.empty? }, nestings.last)
+    end
+
+    # Its lib/<path>.rb, first on the load path, must not shadow a library its tools require
+    # (lib/json.rb, JSON's); its tests' classes, Minitest::Test's, and its gemspec, which `gem build`
+    # evaluates in Gem::Specification, must find its module, not one of theirs (`lifecycle_hooks`:
+    # Minitest::Test::LifecycleHooks).
+    def self.check_shadowing(name, shadowed, found)
+      unless shadowed.empty?
+        raise Error, "invalid gem name #{name}: its lib/#{name.tr("-", "/")}.rb would shadow #{shadowed}"
+      end
+      raise Error, "invalid gem name #{name}: #{found} for its module" unless found.empty?
+    end
+
+    # The +defined+ nestings, outermost first, each with its class: the gem's own module, +innermost+,
+    # one defined already (Comparable) would reopen; an outer one that is a class (Set, Logger), it
+    # could not open.
+    def self.check_defined(name, defined, innermost)
+      raise Error, "invalid gem name #{name}: #{innermost} is already defined" if defined.last&.first == innermost
+
+      outer = defined.find { |_, kind| kind != "Module" }
+      raise Error, "invalid gem name #{name}: #{outer[0]} is a #{outer[1]}, not a module" if outer
+    end
+
+    # The gem's top-level library: `date-holidays`' date
+    def self.library_of(name) = name.split("-").fetch(0)
+
+    # My, My::Gem
+    def self.nestings_of(name) = modules(name).then { |modules| (1..modules.size).map { modules.first(it).join("::") } }
+
+    # The child: no stdin, a scratch directory, its arguments cleared before the libraries load, their
+    # own output kept from the answers, no exit hooks.
+    PROBE = <<~RUBY
+      library, path, *nestings = ARGV
+      first = nestings.fetch(0)
+      ARGV.clear
+      answers = $stdout.dup
+      $stdout.reopen($stderr)
+      ["bundler", "bundler/cli", "rake", "minitest", library].each do |feature|
+        require feature
+      rescue StandardError, ScriptError
+        nil
+      end
+      answers.puts($LOAD_PATH.resolve_feature_path(path)&.last)
+      readers = { "its tests" => defined?(Minitest::Test) && Minitest::Test, "gem build" => Gem::Specification }
+      found = readers.filter_map do |reader, context|
+        owner = context && (context.ancestors - Object.ancestors).find { it.const_defined?(first, false) }
+        "\#{reader} would find \#{owner}::\#{first}" if owner
+      end
+      answers.puts(found.first)
+      nestings.each { answers.puts(Object.const_defined?(it, false) ? Object.const_get(it, false).class : "") }
+      answers.flush
+      exit!(0)
+    RUBY
+    private_constant :PROBE
+
+    # The file +path+ already requires, what a Minitest::Test or Gem::Specification finds for the
+    # first of +nestings+, then each nesting's class -- Module, Class... --, each "" when none, where
+    # the gem meets them: in Bundler's CLI, which reads its gemspec (bin/setup's `bundle install`),
+    # in Rake and Minitest, and with its top-level +library+ (`date-holidays`: date), which its tools
+    # may require. Asked of a Ruby of its own, so the answer is the same however this one was
+    # started. Its answers come only once the libraries are loaded, then the child exits: one fewer
+    # is a failure.
+    def self.probe(library, path, nestings)
+      command = [RbConfig.ruby, "-e", PROBE, library, path, *nestings]
+      answers = Dir.mktmpdir do |dir|
+        IO.popen(Bundler.unbundled_env, command, unsetenv_others: true, in: File::NULL, err: File::NULL, chdir: dir,
+                 &:readlines)
+      end
+      raise Error, "could not check #{library}'s modules" unless answers.size == nestings.size + 2
+
+      answers.map(&:chomp)
+    end
+  end
+end