create-ruby-gem 0.1.0

data/lib/create_ruby_gem/compatibility/matrix.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module Compatibility
+    # Static lookup table mapping Bundler version ranges to the +bundle gem+
+    # options each range supports.
+    #
+    # This is the single source of truth for what each Bundler version
+    # can do. The wizard, validator, and builder all consult it.
+    #
+    # @example Look up the entry for a specific Bundler version
+    #   entry = Matrix.for('3.1.0')
+    #   entry.supports_option?(:linter)  #=> true
+    class Matrix
+      # A single row in the compatibility table.
+      #
+      # @!attribute [r] requirement
+      #   @return [Gem::Requirement] Bundler version range this entry covers
+      # @!attribute [r] supported_options
+      #   @return [Hash{Symbol => Array<String>, nil}] option keys to allowed
+      #     values (+nil+ means any boolean/toggle value is accepted)
+      Entry = Struct.new(:requirement, :supported_options, keyword_init: true) do
+        # @param bundler_version [Gem::Version] version to test
+        # @return [Boolean]
+        def match?(bundler_version)
+          requirement.satisfied_by?(bundler_version)
+        end
+
+        # @param option_key [Symbol, String]
+        # @return [Boolean]
+        def supports_option?(option_key)
+          supported_options.key?(option_key.to_sym)
+        end
+
+        # @param option_key [Symbol, String]
+        # @return [Array<String>, nil] allowed values, or nil for toggles/flags
+        def allowed_values(option_key)
+          supported_options.fetch(option_key.to_sym)
+        end
+      end
+
+      # @return [Array<Entry>] all known Bundler compatibility entries
+      TABLE = [
+        Entry.new(
+          requirement: Gem::Requirement.new('>= 2.4', '< 3.0'),
+          supported_options: {
+            exe: nil,
+            coc: nil,
+            ext: %w[c],
+            git: nil,
+            github_username: nil,
+            mit: nil,
+            test: %w[minitest rspec test-unit],
+            ci: %w[circle github gitlab],
+            edit: nil,
+            bundle_install: nil
+          }
+        ),
+        Entry.new(
+          requirement: Gem::Requirement.new('>= 3.0', '< 4.0'),
+          supported_options: {
+            exe: nil,
+            coc: nil,
+            changelog: nil,
+            ext: %w[c],
+            git: nil,
+            github_username: nil,
+            mit: nil,
+            test: %w[minitest rspec test-unit],
+            ci: %w[circle github gitlab],
+            linter: %w[rubocop standard],
+            edit: nil,
+            bundle_install: nil
+          }
+        ),
+        Entry.new(
+          requirement: Gem::Requirement.new('>= 4.0', '< 5.0'),
+          supported_options: {
+            exe: nil,
+            coc: nil,
+            changelog: nil,
+            ext: %w[c go rust],
+            git: nil,
+            github_username: nil,
+            mit: nil,
+            test: %w[minitest rspec test-unit],
+            ci: %w[circle github gitlab],
+            linter: %w[rubocop standard],
+            edit: nil,
+            bundle_install: nil
+          }
+        )
+      ].freeze
+
+      # Returns human-readable version range strings for all entries.
+      #
+      # @return [Array<String>]
+      def self.supported_ranges
+        TABLE.map { |entry| entry.requirement.requirements.map(&:join).join(', ') }
+      end
+
+      # Finds the compatibility entry for the given Bundler version.
+      #
+      # @param bundler_version [Gem::Version, String] the Bundler version
+      # @return [Entry]
+      # @raise [UnsupportedBundlerVersionError] if no entry matches
+      def self.for(bundler_version)
+        version = Gem::Version.new(bundler_version.to_s)
+        entry = TABLE.find { |candidate| candidate.match?(version) }
+        return entry if entry
+
+        message = "Unsupported bundler version: #{version}. "
+        message += "Supported ranges: #{supported_ranges.join(' | ')}"
+        raise UnsupportedBundlerVersionError, message
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/config/store.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+require 'yaml'
+
+module CreateRubyGem
+  module Config
+    # YAML persistence for presets and last-used options.
+    #
+    # Stores configuration at +~/.config/create-ruby-gem/config.yml+ (or
+    # +$XDG_CONFIG_HOME/create-ruby-gem/config.yml+). Writes are atomic
+    # via +Tempfile+ + rename.
+    class Store
+      # @return [Integer] current config file schema version
+      SCHEMA_VERSION = 1
+
+      # @param path [String, nil] override the default config file path
+      def initialize(path: nil)
+        @path = path || default_path
+      end
+
+      # @return [String] absolute path to the config file
+      attr_reader :path
+
+      # Returns the last-used option hash (empty hash if none saved).
+      #
+      # @return [Hash{String => Object}]
+      def last_used
+        data.fetch('last_used')
+      end
+
+      # Persists the given options as last-used.
+      #
+      # @param options [Hash{Symbol => Object}]
+      # @return [void]
+      def save_last_used(options)
+        payload = data
+        payload['last_used'] = stringify_keys(options)
+        write(payload)
+      end
+
+      # Returns a preset by name, or +nil+ if it does not exist.
+      #
+      # @param name [String]
+      # @return [Hash{String => Object}, nil]
+      def preset(name)
+        data.fetch('presets').fetch(name.to_s, nil)
+      end
+
+      # Returns all preset names sorted alphabetically.
+      #
+      # @return [Array<String>]
+      def preset_names
+        data.fetch('presets').keys.sort
+      end
+
+      # Saves a named preset.
+      #
+      # @param name [String]
+      # @param options [Hash{Symbol => Object}]
+      # @return [void]
+      def save_preset(name, options)
+        payload = data
+        payload.fetch('presets')[name.to_s] = stringify_keys(options)
+        write(payload)
+      end
+
+      # Deletes a named preset (no-op if it does not exist).
+      #
+      # @param name [String]
+      # @return [void]
+      def delete_preset(name)
+        payload = data
+        payload.fetch('presets').delete(name.to_s)
+        write(payload)
+      end
+
+      private
+
+      # @return [Hash{String => Object}]
+      def data
+        raw = load
+        {
+          'version' => raw.fetch('version', SCHEMA_VERSION),
+          'last_used' => raw.fetch('last_used', {}),
+          'presets' => raw.fetch('presets', {})
+        }
+      end
+
+      # @return [Hash]
+      # @raise [ConfigError] if YAML is malformed
+      def load
+        return {} unless File.file?(path)
+
+        YAML.safe_load_file(path, aliases: false) || {}
+      rescue Psych::SyntaxError => e
+        raise ConfigError, "Invalid config file at #{path}: #{e.message}"
+      end
+
+      # @param payload [Hash]
+      # @return [void]
+      def write(payload)
+        FileUtils.mkdir_p(File.dirname(path))
+        Tempfile.create(['create-ruby-gem', '.yml'], File.dirname(path)) do |tmp|
+          tmp.write(YAML.dump(payload))
+          tmp.flush
+          File.rename(tmp.path, path)
+        end
+      end
+
+      # @return [String]
+      def default_path
+        config_home = ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config'))
+        File.join(config_home, 'create-ruby-gem', 'config.yml')
+      end
+
+      # @param hash [Hash{Symbol => Object}]
+      # @return [Hash{String => Object}]
+      def stringify_keys(hash)
+        hash.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/detection/bundler_defaults.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module Detection
+    # Reads Bundler's own default settings (from +~/.bundle/config+ or env)
+    # to use as initial defaults in the wizard.
+    class BundlerDefaults
+      # Sentinel for "no settings argument provided".
+      UNSET = Object.new.freeze
+
+      # Fallback defaults used when Bundler settings are unavailable.
+      #
+      # @return [Hash{Symbol => Object}]
+      FALLBACKS = {
+        exe: false,
+        coc: nil,
+        changelog: nil,
+        ext: false,
+        git: true,
+        github_username: nil,
+        mit: nil,
+        test: nil,
+        ci: nil,
+        linter: nil,
+        edit: nil,
+        bundle_install: false
+      }.freeze
+
+      # Maps option keys to their Bundler settings keys.
+      #
+      # @return [Hash{Symbol => String}]
+      KEY_MAP = {
+        coc: 'gem.coc',
+        changelog: 'gem.changelog',
+        ext: 'gem.ext',
+        git: 'gem.git',
+        github_username: 'gem.github_username',
+        mit: 'gem.mit',
+        test: 'gem.test',
+        ci: 'gem.ci',
+        linter: 'gem.linter'
+      }.freeze
+
+      # @param settings [#[], nil] Bundler settings object (or nil to auto-detect)
+      def initialize(settings: UNSET)
+        @settings = settings.equal?(UNSET) ? default_settings : settings
+      end
+
+      # Returns a hash of default values derived from Bundler settings.
+      #
+      # @return [Hash{Symbol => Object}]
+      def detect
+        defaults = FALLBACKS.dup
+        return defaults unless @settings
+
+        KEY_MAP.each do |option_key, bundler_key|
+          value = normalize(@settings[bundler_key])
+          defaults[option_key] = value unless value.nil?
+        end
+        defaults
+      rescue StandardError
+        FALLBACKS.dup
+      end
+
+      private
+
+      # @return [Bundler::Settings, nil]
+      def default_settings
+        return nil unless defined?(::Bundler)
+
+        ::Bundler.settings
+      end
+
+      # @param value [String, Object, nil]
+      # @return [Boolean, String, nil]
+      def normalize(value)
+        case value
+        when 'true'
+          true
+        when 'false'
+          false
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/detection/bundler_version.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module Detection
+    # Detects the installed Bundler version by running +bundle --version+.
+    class BundlerVersion
+      # @return [Regexp] pattern to extract a version string
+      VERSION_PATTERN = /(\d+\.\d+\.\d+)/
+
+      # @param bundle_command [String] path or name of the bundle executable
+      def initialize(bundle_command: 'bundle')
+        @bundle_command = bundle_command
+      end
+
+      # Runs +bundle --version+ and parses the result.
+      #
+      # @return [Gem::Version]
+      # @raise [UnsupportedBundlerVersionError] if the version cannot be parsed
+      #   or the executable is not found
+      def detect!
+        output = IO.popen([@bundle_command, '--version'], err: %i[child out], &:read)
+        version = output[VERSION_PATTERN, 1]
+        return Gem::Version.new(version) if version
+
+        raise UnsupportedBundlerVersionError, "Cannot parse bundler version from: #{output.inspect}"
+      rescue Errno::ENOENT
+        raise UnsupportedBundlerVersionError, "Bundler executable not found: #{@bundle_command}"
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/detection/runtime.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module Detection
+    # Holds detected Ruby, RubyGems, and Bundler versions.
+    #
+    # @!attribute [r] ruby
+    #   @return [Gem::Version]
+    # @!attribute [r] rubygems
+    #   @return [Gem::Version]
+    # @!attribute [r] bundler
+    #   @return [Gem::Version]
+    RuntimeInfo = Struct.new(:ruby, :rubygems, :bundler, keyword_init: true)
+
+    # Detects the current Ruby, RubyGems, and Bundler versions.
+    class Runtime
+      # @param bundler_detector [Detection::BundlerVersion]
+      def initialize(bundler_detector: BundlerVersion.new)
+        @bundler_detector = bundler_detector
+      end
+
+      # @return [RuntimeInfo]
+      # @raise [UnsupportedBundlerVersionError] if Bundler cannot be detected
+      def detect!
+        RuntimeInfo.new(
+          ruby: Gem::Version.new(RUBY_VERSION),
+          rubygems: Gem::Version.new(Gem::VERSION),
+          bundler: @bundler_detector.detect!
+        )
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  # Base error for all create-ruby-gem failures.
+  class Error < StandardError; end
+
+  # Raised when the config file is corrupt or unreadable.
+  class ConfigError < Error; end
+
+  # Raised when CLI flags or option values are invalid.
+  class ValidationError < Error; end
+
+  # Raised when the detected Bundler version is outside all known ranges.
+  class UnsupportedBundlerVersionError < Error; end
+end

data/lib/create_ruby_gem/options/catalog.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module Options
+    # Registry of every +bundle gem+ option create-ruby-gem knows about.
+    #
+    # Each entry in {DEFINITIONS} describes the option's type and CLI flags.
+    # {ORDER} controls the sequence in which the wizard presents options.
+    #
+    # @see Options::Validator
+    # @see Wizard::Session
+    module Catalog
+      # Option definitions keyed by symbolic name.
+      #
+      # Each value is a Hash with +:type+ and the relevant flag keys
+      # (+:on+/+:off+ for toggles, +:flag+ for enums/strings, etc.).
+      #
+      # @return [Hash{Symbol => Hash}]
+      DEFINITIONS = {
+        exe: { type: :toggle, on: '--exe', off: '--no-exe' },
+        coc: { type: :toggle, on: '--coc', off: '--no-coc' },
+        changelog: { type: :toggle, on: '--changelog', off: '--no-changelog' },
+        ext: { type: :enum, flag: '--ext', none: '--no-ext', values: %w[c go rust] },
+        git: { type: :flag, on: '--git' },
+        github_username: { type: :string, flag: '--github-username' },
+        mit: { type: :toggle, on: '--mit', off: '--no-mit' },
+        test: { type: :enum, flag: '--test', none: '--no-test', values: %w[minitest rspec test-unit] },
+        ci: { type: :enum, flag: '--ci', none: '--no-ci', values: %w[circle github gitlab] },
+        linter: { type: :enum, flag: '--linter', none: '--no-linter', values: %w[rubocop standard] },
+        edit: { type: :string, flag: '--edit' },
+        bundle_install: { type: :toggle, on: '--bundle', off: '--no-bundle' }
+      }.freeze
+
+      # Wizard step order — matches the sequence users see.
+      #
+      # @return [Array<Symbol>]
+      ORDER = DEFINITIONS.keys.freeze
+
+      # Fetches the definition for a given option key.
+      #
+      # @param key [Symbol, String]
+      # @return [Hash] the option definition
+      # @raise [KeyError] if the key is unknown
+      def self.fetch(key)
+        DEFINITIONS.fetch(key.to_sym)
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/options/validator.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module Options
+    # Validates user-selected options against the compatibility entry
+    # for the detected Bundler version.
+    #
+    # Checks that: the gem name is valid, every option key is known,
+    # every option is supported by this Bundler version, and every
+    # value is valid for the option's type and allowed values.
+    class Validator
+      # @return [Regexp] pattern for valid gem names
+      GEM_NAME_PATTERN = /\A[a-zA-Z][a-zA-Z0-9_-]*\z/
+
+      # @param compatibility_entry [Compatibility::Matrix::Entry]
+      def initialize(compatibility_entry)
+        @compatibility_entry = compatibility_entry
+      end
+
+      # Validates the gem name and all options.
+      #
+      # @param gem_name [String]
+      # @param options [Hash{Symbol => Object}]
+      # @return [true]
+      # @raise [ValidationError] if any validation fails
+      def validate!(gem_name:, options:) # rubocop:disable Naming/PredicateMethod
+        validate_gem_name!(gem_name)
+
+        options.each do |key, value|
+          validate_option_key!(key)
+          validate_supported_option!(key)
+          validate_value!(key, value)
+          validate_supported_value!(key, value)
+        end
+
+        true
+      end
+
+      private
+
+      # @param gem_name [String]
+      # @raise [ValidationError]
+      # @return [void]
+      def validate_gem_name!(gem_name)
+        return if gem_name.is_a?(String) && gem_name.match?(GEM_NAME_PATTERN)
+
+        raise ValidationError, "Invalid gem name: #{gem_name.inspect}"
+      end
+
+      # @param key [Symbol]
+      # @raise [ValidationError]
+      # @return [void]
+      def validate_option_key!(key)
+        return if Catalog::DEFINITIONS.key?(key.to_sym)
+
+        raise ValidationError, "Unknown option: #{key}"
+      end
+
+      # @param key [Symbol]
+      # @raise [ValidationError]
+      # @return [void]
+      def validate_supported_option!(key)
+        return if @compatibility_entry.supports_option?(key)
+
+        raise ValidationError, "Option #{key} is not supported by this bundler version"
+      end
+
+      # @param key [Symbol]
+      # @param value [Object]
+      # @raise [ValidationError]
+      # @return [void]
+      def validate_value!(key, value)
+        definition = Catalog.fetch(key)
+        case definition[:type]
+        when :toggle
+          return if value.nil? || value == true || value == false
+        when :flag
+          return if value.nil? || value == true
+        when :enum
+          return if value.nil? || value == false || definition[:values].include?(value)
+        when :string
+          return if value.nil? || value.is_a?(String)
+        end
+
+        raise ValidationError, "Invalid value for #{key}: #{value.inspect}"
+      end
+
+      # @param key [Symbol]
+      # @param value [Object]
+      # @raise [ValidationError]
+      # @return [void]
+      def validate_supported_value!(key, value)
+        return if value.nil? || value == true || value == false
+
+        supported_values = @compatibility_entry.allowed_values(key)
+        return if supported_values.nil? || supported_values.include?(value)
+
+        raise ValidationError, "Value #{value.inspect} for #{key} is not supported by this bundler version"
+      end
+    end
+  end
+end

data/lib/create_ruby_gem/runner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'cli/kit'
+require 'shellwords'
+
+module CreateRubyGem
+  # Executes the assembled +bundle gem+ command via the shell.
+  #
+  # Supports +--dry-run+ mode, which prints the command instead of running it.
+  #
+  # @example
+  #   Runner.new.run!(['bundle', 'gem', 'my_gem', '--exe'])
+  class Runner
+    # @param out [IO] output stream for dry-run printing
+    # @param system_runner [#call, nil] callable that executes a shell command
+    def initialize(out: $stdout, system_runner: nil)
+      @out = out
+      @system_runner = system_runner || ->(*command) { ::CLI::Kit::System.system(*command) }
+    end
+
+    # Executes the command or prints it in dry-run mode.
+    #
+    # @param command [Array<String>] the command to execute
+    # @param dry_run [Boolean] when true, prints instead of executing
+    # @return [true] on success
+    # @raise [Error] if the command exits with a non-zero status
+    def run!(command, dry_run: false)
+      if dry_run
+        @out.puts(command.join(' '))
+        return true
+      end
+
+      status = @system_runner.call(*command)
+      return true if status.respond_to?(:success?) && status.success?
+
+      raise Error, "Command failed: #{command.shelljoin}"
+    end
+  end
+end

data/lib/create_ruby_gem/ui/back_navigation_patch.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CreateRubyGem
+  module UI
+    # Raised when the user presses Ctrl+B during a prompt.
+    #
+    # @api private
+    class BackKeyPressed < StandardError; end
+
+    # Monkey-patches +CLI::UI::Prompt+ to intercept Ctrl+B for back-navigation.
+    #
+    # @api private
+    module BackNavigationPatch
+      # ASCII code for Ctrl+B.
+      CTRL_B = "\u0002"
+
+      # Patch module prepended onto +CLI::UI::Prompt.singleton_class+.
+      module PromptReadCharPatch
+        # @raise [BackKeyPressed] when the user presses Ctrl+B
+        # @return [String] the character read
+        def read_char
+          char = super
+
+          raise BackKeyPressed if char == BackNavigationPatch::CTRL_B
+
+          char
+        end
+      end
+
+      # Prepends the Ctrl+B patch onto +CLI::UI::Prompt+ (idempotent).
+      #
+      # @return [void]
+      def self.apply!
+        singleton = ::CLI::UI::Prompt.singleton_class
+        return if singleton.ancestors.include?(PromptReadCharPatch)
+
+        singleton.prepend(PromptReadCharPatch)
+      end
+    end
+  end
+end