create-ruby-gem 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e3d2670ee80eb59448b75a05e221c84b1c07ffb190d09266ce43a1891797cf5
+  data.tar.gz: e2d3ecac59aa5046b697f003979e9c7b9a95fb2f434af157f703724111b42cf0
+SHA512:
+  metadata.gz: 2c3c8820df470199ae8a162decdb72c96d8e9010bbce025270acc5c230ba260491855d50a68b4b35d1a6054363d7cf20d2223eb622312330e5b6a4aa52805f47
+  data.tar.gz: f2771d980f19ece12debdb81d7613889e1e59c715641782753e561c57cc6adba4a1bc13d6c48084095deba8f1f5a79c50bd4e0775ed0336138e654e4a5cdb654

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
+and [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-02-10
+
+### Added
+
+- Interactive wizard for `bundle gem` with back/edit/cancel flow, command summary, and preset save prompt.
+- Preset commands: `--list-presets`, `--show-preset`, `--delete-preset`, and `--preset` for non-interactive creation.
+- Runtime diagnostics: `--doctor` and `--version`.
+- Static Bundler compatibility matrix with explicit unsupported-version errors.
+- Integration tests that execute real `bundle gem` runs in temporary directories.
+- CI matrix testing Bundler versions across Ruby 3.2–4.0.
+- YARD documentation for all source files.
+- Production-ready README with compatibility matrix, CLI reference, and preset examples.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Leonid Svyatov
+
+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,150 @@
+# create-ruby-gem [![Gem Version](https://img.shields.io/gem/v/create-ruby-gem)](https://rubygems.org/gems/create-ruby-gem) [![CI](https://github.com/svyatov/create-ruby-gem/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/svyatov/create-ruby-gem/actions?query=workflow%3ACI)
+
+> Create Ruby gems with an interactive CLI wizard, which remembers your choices! No more `bundle gem` flags look-ups 🙌
+
+## Table of Contents
+
+- [Supported Versions](#supported-versions)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Interactive Wizard](#interactive-wizard)
+- [Preset System](#preset-system)
+- [Compatibility Matrix](#compatibility-matrix)
+- [Configuration](#configuration)
+- [CLI Reference](#cli-reference)
+- [Development](#development)
+- [Contributing](#contributing)
+- [Changelog](#changelog)
+- [Versioning](#versioning)
+- [License](#license)
+
+## Supported Versions
+
+Ruby 3.2+ and Bundler 2.4+ are required.
+
+## Installation
+
+```bash
+gem install create-ruby-gem
+```
+
+## Quick Start
+
+```bash
+create-ruby-gem my_awesome_gem
+```
+
+The wizard detects your Ruby and Bundler versions, walks you through every supported option, shows a summary of the `bundle gem` command it will run, and lets you edit or confirm before executing.
+
+## Interactive Wizard
+
+Running `create-ruby-gem <name>` starts the step-by-step wizard:
+
+1. **Version detection** — detects Ruby, RubyGems, and Bundler versions at runtime.
+2. **Option filtering** — shows only options your Bundler version supports (see [Compatibility Matrix](#compatibility-matrix)).
+3. **Smart defaults** — uses your last-used choices as defaults, falling back to Bundler's own settings.
+4. **Back-navigation** — press `Ctrl+B` to revisit the previous step.
+5. **Summary** — displays the exact `bundle gem` command with color-coded arguments.
+6. **Edit-again loop** — choose "edit again" to change options, or "create" to execute.
+7. **Preset save prompt** — after creation, optionally save your choices as a named preset.
+
+Press `Ctrl+C` at any time to exit.
+
+## Preset System
+
+Save, load, and manage option presets:
+
+```bash
+# Save options as a preset during gem creation
+create-ruby-gem my_gem --save-preset oss-defaults
+
+# Create a gem using a saved preset (non-interactive)
+create-ruby-gem my_gem --preset oss-defaults
+
+# List all saved presets
+create-ruby-gem --list-presets
+
+# Show a preset's options
+create-ruby-gem --show-preset oss-defaults
+
+# Delete a preset
+create-ruby-gem --delete-preset oss-defaults
+```
+
+## Compatibility Matrix
+
+Options available depend on your Bundler version. The wizard automatically hides unsupported options.
+
+| Option | Bundler 2.4–2.x | Bundler 3.x | Bundler 4.x |
+|--------|:---:|:---:|:---:|
+| `--exe` / `--no-exe` | ✓ | ✓ | ✓ |
+| `--coc` / `--no-coc` | ✓ | ✓ | ✓ |
+| `--changelog` / `--no-changelog` | — | ✓ | ✓ |
+| `--ext` | c | c | c, go, rust |
+| `--git` | ✓ | ✓ | ✓ |
+| `--github-username` | ✓ | ✓ | ✓ |
+| `--mit` / `--no-mit` | ✓ | ✓ | ✓ |
+| `--test` | minitest, rspec, test-unit | minitest, rspec, test-unit | minitest, rspec, test-unit |
+| `--ci` | circle, github, gitlab | circle, github, gitlab | circle, github, gitlab |
+| `--linter` | — | rubocop, standard | rubocop, standard |
+| `--edit` | ✓ | ✓ | ✓ |
+| `--bundle` / `--no-bundle` | ✓ | ✓ | ✓ |
+
+## Configuration
+
+Config is stored at `~/.config/create-ruby-gem/config.yml` (or `$XDG_CONFIG_HOME/create-ruby-gem/config.yml`).
+
+The file contains:
+
+- `version` — schema version (currently `1`)
+- `last_used` — the options from your most recent gem creation
+- `presets` — named option sets saved via `--save-preset` or the post-creation prompt
+
+## CLI Reference
+
+| Flag | Description |
+|------|-------------|
+| `<name>` | Gem name (prompted interactively if omitted) |
+| `--preset NAME` | Use a saved preset (non-interactive) |
+| `--save-preset NAME` | Save the selected options as a preset |
+| `--list-presets` | List all saved preset names |
+| `--show-preset NAME` | Show a preset's options |
+| `--delete-preset NAME` | Delete a saved preset |
+| `--dry-run` | Print the `bundle gem` command without executing |
+| `--bundler-version VERSION` | Override the detected Bundler version |
+| `--doctor` | Print runtime versions and supported options |
+| `--version` | Print the create-ruby-gem version |
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `bundle exec rake` to run the tests and linter.
+You can also run `bin/console` for an interactive prompt.
+
+```bash
+bundle exec rake          # tests + rubocop (default task)
+bundle exec rake spec     # tests only
+bundle exec rake yard     # generate YARD docs into doc/
+exe/create-ruby-gem            # run the CLI locally
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Make your changes and run tests (`bundle exec rake`)
+4. Commit using [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) format (`git commit -m 'feat: add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a detailed history of changes, following [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format.
+
+## Versioning
+
+This project follows [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/create-ruby-gem

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  nil
+end
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'create_ruby_gem'
+
+exit(CreateRubyGem::CLI.start(ARGV))

data/lib/create_ruby_gem/cli.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module CreateRubyGem
+  # Main entry point that orchestrates the entire create-ruby-gem flow.
+  #
+  # Parses CLI flags, detects runtime versions, runs the interactive wizard
+  # (or loads a preset), builds the +bundle gem+ command, and executes it.
+  # All collaborators are injected via constructor for testability.
+  #
+  # @example Run from the command line
+  #   CreateRubyGem::CLI.start(ARGV)
+  class CLI
+    # Constructs and runs a CLI instance with the given arguments.
+    #
+    # @param argv [Array<String>] command-line arguments
+    # @param out [IO] standard output stream
+    # @param err [IO] standard error stream
+    # @param store [Config::Store] configuration persistence
+    # @param detector [Detection::Runtime] runtime version detector
+    # @param runner [Runner, nil] command runner (built from +out+ if nil)
+    # @param prompter [UI::Prompter, nil] user interaction handler
+    # @param palette [UI::Palette, nil] color palette for terminal output
+    # @return [Integer] exit code (0 on success, non-zero on failure)
+    def self.start(
+      argv = ARGV,
+      out: $stdout,
+      err: $stderr,
+      store: Config::Store.new,
+      detector: Detection::Runtime.new,
+      runner: nil,
+      prompter: nil,
+      palette: nil
+    )
+      instance = new(
+        argv: argv,
+        out: out,
+        err: err,
+        store: store,
+        detector: detector,
+        runner: runner || Runner.new(out: out),
+        prompter: prompter,
+        palette: palette
+      )
+      instance.run
+    end
+
+    # @param argv [Array<String>] command-line arguments
+    # @param out [IO] standard output stream
+    # @param err [IO] standard error stream
+    # @param store [Config::Store] configuration persistence
+    # @param detector [Detection::Runtime] runtime version detector
+    # @param runner [Runner] command runner
+    # @param prompter [UI::Prompter, nil] user interaction handler
+    # @param palette [UI::Palette, nil] color palette for terminal output
+    def initialize(argv:, out:, err:, store:, detector:, runner:, prompter:, palette:)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @store = store
+      @detector = detector
+      @runner = runner
+      @prompter = prompter
+      @palette = palette || UI::Palette.new
+      @options = {}
+    end
+
+    # Runs the CLI: parses flags, dispatches to the appropriate action,
+    # and returns an exit code.
+    #
+    # @return [Integer] exit code (0 success, 1 error, 130 interrupt)
+    def run
+      parse_options!
+
+      validate_top_level_flags!
+
+      return print_version if @options[:version]
+      return doctor if @options[:doctor]
+      return list_presets if @options[:list_presets]
+      return show_preset if @options[:show_preset]
+      return delete_preset if @options[:delete_preset]
+
+      runtime_versions = resolved_runtime_versions
+      compatibility_entry = Compatibility::Matrix.for(runtime_versions.bundler)
+      builder = CommandBuilder.new(compatibility_entry: compatibility_entry)
+      bundler_defaults = Detection::BundlerDefaults.new.detect
+      last_used = symbolize_keys(@store.last_used)
+
+      gem_name = resolve_gem_name!
+      selected_options =
+        if @options[:preset]
+          load_preset_options!
+        else
+          run_interactive_wizard!(
+            gem_name: gem_name,
+            builder: builder,
+            compatibility_entry: compatibility_entry,
+            last_used: last_used,
+            runtime_versions: runtime_versions,
+            bundler_defaults: bundler_defaults
+          )
+        end
+
+      Options::Validator.new(compatibility_entry).validate!(gem_name: gem_name, options: selected_options)
+      command = builder.build(gem_name: gem_name, options: selected_options)
+      @runner.run!(command, dry_run: @options[:dry_run])
+      @store.save_last_used(selected_options)
+      save_preset_if_requested(selected_options)
+      0
+    rescue OptionParser::ParseError, Error => e
+      @err.puts(e.message)
+      1
+    rescue Interrupt
+      @err.puts(::CLI::UI.fmt('{{green:See ya!}}'))
+      130
+    end
+
+    private
+
+    attr_reader :palette
+
+    # @return [void]
+    def parse_options!
+      OptionParser.new do |parser|
+        parser.on('--preset NAME') { |value| @options[:preset] = value }
+        parser.on('--save-preset NAME') { |value| @options[:save_preset] = value }
+        parser.on('--list-presets') { @options[:list_presets] = true }
+        parser.on('--show-preset NAME') { |value| @options[:show_preset] = value }
+        parser.on('--delete-preset NAME') { |value| @options[:delete_preset] = value }
+        parser.on('--doctor') { @options[:doctor] = true }
+        parser.on('--version') { @options[:version] = true }
+        parser.on('--dry-run') { @options[:dry_run] = true }
+        parser.on('--bundler-version VERSION') { |value| @options[:bundler_version] = value }
+      end.parse!(@argv)
+    end
+
+    # @raise [ValidationError] if conflicting flags are combined
+    # @return [void]
+    def validate_top_level_flags!
+      conflicting_create_action = @options[:preset] || @options[:save_preset] || !@argv.empty?
+      query_action = @options[:list_presets] || @options[:show_preset]
+      if query_action && (@options[:delete_preset] || conflicting_create_action)
+        raise ValidationError, 'Preset query options cannot be combined with other actions'
+      end
+
+      if @options[:delete_preset] && conflicting_create_action
+        raise ValidationError, '--delete-preset cannot be combined with create actions'
+      end
+
+      if @options[:doctor] && (query_action || @options[:delete_preset] || conflicting_create_action)
+        raise ValidationError, '--doctor cannot be combined with other actions'
+      end
+
+      conflicting_action = @options[:doctor] || query_action
+      conflicting_action ||= @options[:delete_preset]
+      conflicting_action ||= conflicting_create_action
+      return unless @options[:version] && conflicting_action
+
+      raise ValidationError, '--version cannot be combined with other actions'
+    end
+
+    # @return [Integer] exit code
+    def print_version
+      @out.puts(VERSION)
+      0
+    end
+
+    # Prints runtime version info and supported options.
+    #
+    # @return [Integer] exit code
+    def doctor
+      runtime_versions = resolved_runtime_versions
+      @out.puts("ruby: #{runtime_versions.ruby}")
+      @out.puts("rubygems: #{runtime_versions.rubygems}")
+      @out.puts("bundler: #{runtime_versions.bundler}")
+      entry = Compatibility::Matrix.for(runtime_versions.bundler)
+      options = Options::Catalog::ORDER.select { |key| entry.supports_option?(key) }
+      @out.puts("supported options: #{options.join(', ')}")
+      0
+    rescue UnsupportedBundlerVersionError => e
+      @err.puts(e.message)
+      1
+    end
+
+    # @return [Integer] exit code
+    def list_presets
+      @store.preset_names.each { |name| @out.puts(name) }
+      0
+    end
+
+    # @return [Integer] exit code
+    # @raise [ValidationError] if the preset does not exist
+    def show_preset
+      preset = @store.preset(@options[:show_preset])
+      raise ValidationError, "Preset not found: #{@options[:show_preset]}" unless preset
+
+      @out.puts(@options[:show_preset])
+      preset.sort.each { |key, value| @out.puts("  #{key}: #{value.inspect}") }
+      0
+    end
+
+    # @return [Integer] exit code
+    def delete_preset
+      @store.delete_preset(@options[:delete_preset])
+      0
+    end
+
+    # @return [String] gem name from argv or interactive prompt
+    # @raise [ValidationError] if gem name is required but missing
+    def resolve_gem_name!
+      gem_name = @argv.shift
+      return gem_name if gem_name && !gem_name.empty?
+
+      raise ValidationError, 'Gem name is required when --preset is provided' if @options[:preset]
+
+      prompter.text('Gem name:', allow_empty: false)
+    end
+
+    # @return [Hash{Symbol => Object}] preset options
+    # @raise [ValidationError] if the preset does not exist
+    def load_preset_options!
+      preset = @store.preset(@options[:preset])
+      raise ValidationError, "Preset not found: #{@options[:preset]}" unless preset
+
+      symbolize_keys(preset)
+    end
+
+    # Runs the interactive wizard loop with summary + edit-again flow.
+    #
+    # @param gem_name [String]
+    # @param builder [CommandBuilder]
+    # @param compatibility_entry [Compatibility::Matrix::Entry]
+    # @param last_used [Hash{Symbol => Object}]
+    # @param runtime_versions [Detection::RuntimeInfo]
+    # @param bundler_defaults [Hash{Symbol => Object}]
+    # @return [Hash{Symbol => Object}] selected options
+    def run_interactive_wizard!(
+      gem_name:,
+      builder:,
+      compatibility_entry:,
+      last_used:,
+      runtime_versions:,
+      bundler_defaults:
+    )
+      defaults = last_used
+      prompter.frame('Controls') do
+        prompter.say("Press #{palette.color(:control_back, 'Ctrl+B')} to go back one step.")
+        prompter.say("Press #{palette.color(:control_exit, 'Ctrl+C')} to exit.")
+      end
+      loop do
+        selected_options = Wizard.new(
+          compatibility_entry: compatibility_entry,
+          defaults: defaults,
+          bundler_defaults: bundler_defaults,
+          prompter: prompter
+        ).run
+
+        command = builder.build(gem_name: gem_name, options: selected_options)
+        show_summary(
+          command: command,
+          runtime_versions: runtime_versions
+        )
+        action = prompter.choose('Next step', options: ['create', 'edit again'], default: 'create')
+        return selected_options if action == 'create'
+
+        defaults = selected_options
+      end
+    end
+
+    # @param command [Array<String>]
+    # @param runtime_versions [Detection::RuntimeInfo]
+    # @return [void]
+    def show_summary(command:, runtime_versions:)
+      command_name = command.first(2).join(' ')
+      gem_name = command[2].to_s
+      args = command[3..] || []
+
+      prompter.frame('create-ruby-gem summary') do
+        runtime_line = "#{palette.color(:summary_label, 'Runtime:')} "
+        runtime_line += format_runtime_versions(runtime_versions)
+        prompter.say(runtime_line)
+        command_line = "#{palette.color(:command_base, command_name)} "
+        command_line += palette.color(:command_gem, gem_name)
+        command_line += " #{format_args(args)}" unless args.empty?
+        prompter.say("#{palette.color(:summary_label, 'Command:')} #{command_line}")
+      end
+    end
+
+    # @param runtime_versions [Detection::RuntimeInfo]
+    # @return [String]
+    def format_runtime_versions(runtime_versions)
+      [
+        ['ruby', runtime_versions.ruby],
+        ['rubygems', runtime_versions.rubygems],
+        ['bundler', runtime_versions.bundler]
+      ].map do |name, version|
+        "#{palette.color(:runtime_name, name)} #{palette.color(:runtime_value, version.to_s)}"
+      end.join(', ')
+    end
+
+    # @param args [Array<String>]
+    # @return [String]
+    def format_args(args)
+      args.map { |argument| format_argument(argument) }.join(' ')
+    end
+
+    # @param argument [String]
+    # @return [String]
+    def format_argument(argument)
+      return palette.color(:arg_value, argument) unless argument.start_with?('--')
+      return palette.color(:arg_name, argument) unless argument.include?('=')
+
+      name, value = argument.split('=', 2)
+      "#{palette.color(:arg_name, name)}#{palette.color(:arg_eq, '=')}#{palette.color(:arg_value, value)}"
+    end
+
+    # @param selected_options [Hash{Symbol => Object}]
+    # @return [void]
+    def save_preset_if_requested(selected_options)
+      if @options[:save_preset]
+        @store.save_preset(@options[:save_preset], selected_options)
+        return
+      end
+
+      return if @options[:preset]
+      return unless prompter.confirm('Save these options as a preset?', default: false)
+
+      preset_name = prompter.text('Preset name:', allow_empty: false)
+      @store.save_preset(preset_name, selected_options)
+    end
+
+    # @param hash [Hash{String => Object}]
+    # @return [Hash{Symbol => Object}]
+    def symbolize_keys(hash)
+      hash.transform_keys(&:to_sym)
+    end
+
+    # @return [Detection::RuntimeInfo]
+    def resolved_runtime_versions
+      if @options[:bundler_version]
+        return Detection::RuntimeInfo.new(
+          ruby: Gem::Version.new(RUBY_VERSION),
+          rubygems: Gem::Version.new(Gem::VERSION),
+          bundler: Gem::Version.new(@options[:bundler_version])
+        )
+      end
+
+      @detector.detect!
+    end
+
+    # @return [UI::Prompter]
+    def prompter
+      @prompter ||= begin
+        UI::Prompter.setup!
+        UI::Prompter.new(out: @out)
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/command_builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  # Converts a gem name and option hash into a +bundle gem+ command array.
+  #
+  # @example
+  #   entry = Compatibility::Matrix.for('3.1.0')
+  #   builder = CommandBuilder.new(compatibility_entry: entry)
+  #   builder.build(gem_name: 'my_gem', options: { exe: true, test: 'rspec' })
+  #   #=> ['bundle', 'gem', 'my_gem', '--exe', '--test=rspec']
+  class CommandBuilder
+    # @param compatibility_entry [Compatibility::Matrix::Entry]
+    def initialize(compatibility_entry:)
+      @compatibility_entry = compatibility_entry
+    end
+
+    # Builds the +bundle gem+ command array.
+    #
+    # @param gem_name [String]
+    # @param options [Hash{Symbol => Object}]
+    # @return [Array<String>]
+    def build(gem_name:, options: {})
+      command = ['bundle', 'gem', gem_name]
+      Options::Catalog::ORDER.each do |key|
+        next unless options.key?(key)
+
+        append_option!(command, key, options[key])
+      end
+      command
+    end
+
+    private
+
+    # @param command [Array<String>]
+    # @param key [Symbol]
+    # @param value [Object]
+    # @return [void]
+    def append_option!(command, key, value)
+      definition = Options::Catalog.fetch(key)
+      case definition[:type]
+      when :toggle
+        command << definition[:on] if value == true
+        command << definition[:off] if value == false
+      when :flag
+        command << definition[:on] if value == true
+      when :enum
+        command << "#{definition[:flag]}=#{value}" if value.is_a?(String)
+        command << definition[:none] if value == false
+      when :string
+        command << "#{definition[:flag]}=#{value}" if value.is_a?(String) && !value.empty?
+      end
+    end
+  end
+end