gempilot 0.2.0

data/lib/gempilot/cli/commands/new.rb

@@ -0,0 +1,226 @@
+module Gempilot
+  class CLI
+    module Commands
+      ## Generates a new class, module, or command inside an existing gem.
+      class New < Command
+        using String::Inflectable
+
+        include Generator
+        include GemContext
+
+        template_dir File.join(Gempilot::ROOT, "data", "templates", "new")
+
+        usage "[options] TYPE CONSTANT"
+        description "Generate a class, module, or command in an existing gem"
+
+        examples [
+          "class MyGem::Authentication",
+          "class MyGem::Services::Authentication",
+          "module MyGem::Middleware",
+          "command deploy",
+        ]
+
+        argument :type, required: false,
+                        desc: "Type to generate (class, module, command)"
+
+        argument :path, required: false,
+                        desc: "Fully-qualified constant (e.g., MyGem::Services::Auth) or command name"
+
+        def run(type = nil, path = nil)
+          type ||= prompt_for_type
+          detect_gem_context
+          path ||= prompt_for_path
+          dispatch_add(type, path)
+        end
+
+        private
+
+        def prompt_for_type
+          puts colors.bright_black("What kind of component do you want to add?")
+          ask_multiple_choice(colors.green("Type"), %w[class module command])
+        end
+
+        def prompt_for_path
+          puts
+          puts colors.bright_black("Fully-qualified constant name (e.g., #{@gem_module}::Services::Authentication).")
+          ask(colors.green("Constant"), required: true)
+        end
+
+        def dispatch_add(type, path)
+          case type
+          when "class"   then add_class(path)
+          when "module"  then add_module(path)
+          when "command" then add_command(path)
+          else
+            puts colors.red("Unknown type '#{type}'. Use class, module, or command.")
+            exit 1
+          end
+        end
+
+        def build_namespace_lines(namespaces)
+          namespaces.each_with_index.map do |ns, i|
+            "#{"  " * i}module #{ns}"
+          end
+        end
+
+        def build_closing_lines(namespaces)
+          Array.new(namespaces.length) do |i|
+            "#{"  " * (namespaces.length - 1 - i)}end"
+          end
+        end
+
+        def build_nested_source(namespaces, type_keyword, name)
+          depth = namespaces.length
+          lines = build_namespace_lines(namespaces)
+          lines << "#{"  " * depth}#{type_keyword} #{name}"
+          lines << "#{"  " * depth}end"
+          lines.concat(build_closing_lines(namespaces))
+          "#{lines.join("\n")}\n"
+        end
+
+        def print_adding_banner(kind, label)
+          puts
+          puts colors.bright_white("Adding #{kind} ") +
+               colors.bold(colors.cyan(label)) +
+               colors.bright_white("...")
+          puts
+        end
+
+        def prepare_constant(constant)
+          namespaces, name, segments = parse_constant(constant)
+          validate_gem_root!(namespaces.first)
+          file_path = "#{File.join("lib", *segments)}.rb"
+          ensure_directory(File.dirname(file_path))
+          [namespaces, name, segments, file_path]
+        end
+
+        def ensure_directory(dir)
+          mkdir(dir) unless File.directory?(dir)
+        end
+
+        def add_class(constant)
+          namespaces, class_name, segments, file_path = prepare_constant(constant)
+          print_adding_banner("class", "#{namespaces.join("::")}::#{class_name}")
+          source = build_nested_source(namespaces, "class", class_name)
+          create_file(file_path, source)
+          add_test_file(namespaces, class_name, segments)
+        end
+
+        def add_module(constant)
+          namespaces, mod_name, _segments, file_path = prepare_constant(constant)
+          print_adding_banner("module", "#{namespaces.join("::")}::#{mod_name}")
+          source = build_nested_source(namespaces, "module", mod_name)
+          create_file(file_path, source)
+        end
+
+        def add_command(name)
+          file_name = name.underscore
+          command_name = name.camelize
+          file_path = File.join("lib", @require_path, "cli", "commands", "#{file_name}.rb")
+
+          print_adding_banner("command", command_name)
+          ensure_directory(File.dirname(file_path))
+
+          @command_name = command_name
+          @command_file_name = file_name
+          erb "command.rb.erb", file_path
+          add_command_test_file(command_name, file_name)
+        end
+
+        def command_test_path(file_name)
+          if @test_framework == :rspec
+            File.join("spec", @require_path, "cli", "commands", "#{file_name}_spec.rb")
+          else
+            File.join("test", @require_path, "cli", "commands", "#{file_name}_test.rb")
+          end
+        end
+
+        def rspec_command_content(command_name)
+          <<~RUBY
+            require "spec_helper"
+
+            RSpec.describe #{@gem_module}::CLI::Commands::#{command_name} do
+              it "is defined" do
+                expect(described_class).not_to be_nil
+              end
+            end
+          RUBY
+        end
+
+        def minitest_command_content(command_name)
+          <<~RUBY
+            require "test_helper"
+            require "#{@require_path}/cli"
+            require "stringio"
+
+            module #{@gem_module}
+              class CLI
+                class #{command_name}Test < Minitest::Test
+                  def test_placeholder
+                    stdout = StringIO.new
+                    command = Commands::#{command_name}.new(stdout: stdout)
+                    assert command
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+
+        def add_command_test_file(command_name, file_name)
+          test_path = command_test_path(file_name)
+          ensure_directory(File.dirname(test_path))
+          content = if @test_framework == :rspec
+                      rspec_command_content(command_name)
+                    else
+                      minitest_command_content(command_name)
+                    end
+          create_file(test_path, content)
+        end
+
+        def class_test_path(segments)
+          if @test_framework == :rspec
+            "#{File.join("spec", @require_path, *segments[1..])}_spec.rb"
+          else
+            "#{File.join("test", @require_path, *segments[1..])}_test.rb"
+          end
+        end
+
+        def rspec_class_content(namespaces, class_name)
+          <<~RUBY
+            require "spec_helper"
+
+            RSpec.describe #{namespaces.join("::")}::#{class_name} do
+              pending "add some examples"
+            end
+          RUBY
+        end
+
+        def minitest_class_content(namespaces, class_name)
+          <<~RUBY
+            require "test_helper"
+
+            module #{namespaces.first}
+              class #{(namespaces[1..] + [class_name]).join("::")}Test < Minitest::Test
+                def test_placeholder
+                  assert true
+                end
+              end
+            end
+          RUBY
+        end
+
+        def add_test_file(namespaces, class_name, segments)
+          test_path = class_test_path(segments)
+          ensure_directory(File.dirname(test_path))
+          content = if @test_framework == :rspec
+                      rspec_class_content(namespaces, class_name)
+                    else
+                      minitest_class_content(namespaces, class_name)
+                    end
+          create_file(test_path, content)
+        end
+      end
+    end
+  end
+end

data/lib/gempilot/cli/commands/release.rb

@@ -0,0 +1,40 @@
+require "bundler"
+
+module Gempilot
+  class CLI
+    module Commands
+      ## Delegates to +rake release+ to build and push the gem.
+      class Release < Command
+        include GemContext
+
+        description "Release the gem (delegates to rake release)"
+
+        def run
+          detect_gem_context
+          print_release_banner
+          run_rake_release
+        end
+
+        private
+
+        def print_release_banner
+          puts colors.bright_white("Releasing ") +
+               colors.bold(colors.cyan(@gem_name)) +
+               colors.bright_white("...")
+          puts
+        end
+
+        def run_rake_release
+          success = Bundler.with_unbundled_env do
+            system("bundle", "exec", "rake", "release")
+          end
+
+          return if success
+
+          puts colors.red("Release failed. Check the output above for errors.")
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/gempilot/cli/gem_builder.rb

@@ -0,0 +1,105 @@
+module Gempilot
+  class CLI
+    ## File rendering and directory creation logic for scaffolding a new gem.
+    ##
+    ## Expects the including class to provide Generator methods (+mkdir+, +erb+,
+    ## +chmod+, +cp+, +cd+, +sh+) and the following instance variables:
+    ## +@gem_name+, +@require_path+, +@module_name+, +@hyphenated+,
+    ## +@test_framework+, +@branch+.
+    module GemBuilder
+      private
+
+      def create_directories
+        mkdir @gem_name
+        mkdir "#{@gem_name}/lib"
+        create_lib_subdirectories
+        mkdir "#{@gem_name}/bin"
+        mkdir "#{@gem_name}/exe" if options[:exe]
+        create_test_directory
+      end
+
+      def create_lib_subdirectories
+        @require_path.split("/").reduce("#{@gem_name}/lib") do |dir, part|
+          path = "#{dir}/#{part}"
+          mkdir path
+          path
+        end
+      end
+
+      def create_test_directory
+        mkdir @test_framework == :rspec ? "#{@gem_name}/spec" : "#{@gem_name}/test"
+      end
+
+      def render_core_templates
+        erb "gemspec.erb",                  "#{@gem_name}/#{@gem_name}.gemspec"
+        erb "Gemfile.erb",                  "#{@gem_name}/Gemfile"
+        erb "Rakefile.erb",                 "#{@gem_name}/Rakefile"
+        erb "README.md.erb",               "#{@gem_name}/README.md"
+        erb "LICENSE.txt.erb",             "#{@gem_name}/LICENSE.txt"
+        erb "lib/gem_name.rb.erb",         "#{@gem_name}/lib/#{@gem_name}.rb"
+        erb "lib/gem_name/version.rb.erb", "#{@gem_name}/lib/#{@require_path}/version.rb"
+        erb "lib/gem_name_extension.rb.erb", "#{@gem_name}/lib/#{@require_path}.rb" if @hyphenated
+      end
+
+      def render_test_templates
+        @test_framework == :rspec ? render_rspec_templates : render_minitest_templates
+      end
+
+      def render_rspec_templates
+        erb "spec/spec_helper.rb.erb",   "#{@gem_name}/spec/spec_helper.rb"
+        erb "spec/gem_name_spec.rb.erb", "#{@gem_name}/spec/#{@gem_name.tr("-", "_")}_spec.rb"
+        erb "spec/zeitwerk_spec.rb.erb", "#{@gem_name}/spec/zeitwerk_spec.rb"
+        erb "rspec.erb",                 "#{@gem_name}/.rspec"
+      end
+
+      def render_minitest_templates
+        erb "test/test_helper.rb.erb",   "#{@gem_name}/test/test_helper.rb"
+        erb "test/gem_name_test.rb.erb", "#{@gem_name}/test/#{@gem_name.tr("-", "_")}_test.rb"
+        erb "test/zeitwerk_test.rb.erb", "#{@gem_name}/test/zeitwerk_test.rb"
+      end
+
+      def render_dev_files
+        erb "bin/console.erb", "#{@gem_name}/bin/console"
+        erb "bin/setup.erb",   "#{@gem_name}/bin/setup"
+        chmod "+x", "#{@gem_name}/bin/console"
+        chmod "+x", "#{@gem_name}/bin/setup"
+      end
+
+      def render_config_files
+        erb "dotfiles/rubocop.yml.erb",  "#{@gem_name}/.rubocop.yml"
+        cp "dotfiles/gitignore",         "#{@gem_name}/.gitignore"
+        erb "dotfiles/ruby-version.erb", "#{@gem_name}/.ruby-version"
+        render_ci_workflow
+      end
+
+      def render_ci_workflow
+        mkdir "#{@gem_name}/.github"
+        mkdir "#{@gem_name}/.github/workflows"
+        erb "dotfiles/github/workflows/ci.yml.erb", "#{@gem_name}/.github/workflows/ci.yml"
+      end
+
+      def render_executable
+        return unless options[:exe]
+
+        erb "exe/gem_name.erb", "#{@gem_name}/exe/#{@gem_name}"
+        chmod "+x", "#{@gem_name}/exe/#{@gem_name}"
+      end
+
+      def run_bundle_install
+        cd @gem_name do
+          sh "bundle", "install"
+        end
+      end
+
+      def initialize_git_repo
+        return unless options[:git]
+
+        cd @gem_name do
+          sh "git", "init", "-q", "-b", @branch
+          sh "git", "add", "."
+          sh "git", "commit", "-q", "-m", "Initial commit."
+        end
+      end
+    end
+  end
+end

data/lib/gempilot/cli/gem_context.rb

@@ -0,0 +1,40 @@
+module Gempilot
+  class CLI
+    ## Shared context for commands that operate inside an existing gem.
+    module GemContext
+      using String::Inflectable
+
+      private
+
+      def detect_gem_context
+        gemspec = Dir.glob("*.gemspec").first
+
+        unless gemspec
+          puts colors.red("No gemspec found in current directory. Run this from your gem's root.")
+          exit 1
+        end
+
+        @gem_name = File.basename(gemspec, ".gemspec")
+        @require_path = @gem_name.tr("-", "/")
+        @gem_module = @require_path.camelize
+        @test_framework = File.directory?("spec") ? :rspec : :minitest
+      end
+
+      def parse_constant(constant)
+        parts = constant.split("::")
+        namespaces = parts[0...-1]
+        name = parts.last
+        segments = parts.map(&:underscore)
+        [namespaces, name, segments]
+      end
+
+      def validate_gem_root!(root)
+        expected = @gem_module.split("::").first
+        return if root == expected
+
+        puts colors.red("Expected constant to start with #{expected}, got #{root}")
+        exit 1
+      end
+    end
+  end
+end

data/lib/gempilot/cli/generator.rb

@@ -0,0 +1,90 @@
+require "bundler"
+require "command_kit/colors"
+require "command_kit/file_utils"
+require "fileutils"
+require "erb"
+
+module Gempilot
+  class CLI
+    ## File generation utilities for scaffolding gems and components.
+    module Generator
+      include CommandKit::Colors
+      include CommandKit::FileUtils
+
+      def self.included(command)
+        command.extend ClassMethods
+      end
+
+      ## Class-level helpers for Generator, including +template_dir+ resolution.
+      module ClassMethods
+        def template_dir(path = nil)
+          if path
+            @template_dir = File.expand_path(path)
+          else
+            @template_dir || (superclass.template_dir if superclass.respond_to?(:template_dir))
+          end
+        end
+      end
+
+      attr_reader :template_dir
+
+      def initialize(**kwargs)
+        super
+
+        return if (@template_dir = self.class.template_dir)
+
+        raise NotImplementedError, "#{self.class} did not define template_dir"
+      end
+
+      def print_action(command, dest, source: nil)
+        line = +""
+        line << "\t" << colors.bold(colors.green(command))
+        line << "\t" << colors.green(source) if source
+        line << "\t" << colors.green(dest) if dest
+
+        puts(line)
+      end
+
+      def mkdir(path)
+        print_action "mkdir", path
+        ::FileUtils.mkdir_p(path)
+      end
+
+      def touch(path)
+        print_action "touch", path
+        ::FileUtils.touch(path)
+      end
+
+      def create_file(path, content)
+        print_action "create", path
+        File.write(path, content)
+      end
+
+      def chmod(mode, path)
+        print_action "chmod", path
+        ::FileUtils.chmod(mode, path)
+      end
+
+      def cp(source, dest)
+        print_action "cp", dest, source: source
+        ::FileUtils.cp(File.join(@template_dir, source), dest)
+      end
+
+      def erb(source, dest = nil)
+        print_action("erb", dest, source: source) if dest
+
+        source_path = File.join(@template_dir, source)
+        super(source_path, dest)
+      end
+
+      def sh(command, *arguments)
+        print_action "run", [command, *arguments].join(" ")
+        success = Bundler.with_unbundled_env do
+          system(command, *arguments)
+        end
+        puts colors.yellow("Warning: '#{[command, *arguments].join(" ")}' exited with non-zero status") unless success
+        success
+      end
+    end
+  end
+end

data/lib/gempilot/cli.rb

@@ -0,0 +1,19 @@
+require "command_kit/commands"
+require "command_kit/commands/auto_load"
+require "command_kit/options/version"
+require_relative "../gempilot"
+
+module Gempilot
+  ## Top-level command router for the gempilot CLI.
+  class CLI
+    include CommandKit::Commands
+    include CommandKit::Commands::AutoLoad.new(
+      dir: "#{__dir__}/cli/commands",
+      namespace: "#{self}::Commands",
+    )
+    include CommandKit::Options::Version
+
+    command_name "gempilot"
+    version Gempilot::VERSION
+  end
+end

data/lib/gempilot/github_release.rb

@@ -0,0 +1,30 @@
+module Gempilot
+  ## Manages GitHub releases for a version tag.
+  class GithubRelease
+    include StrictShell
+
+    attr_reader :tag
+
+    def initialize(tag)
+      @tag = tag
+    end
+
+    def create
+      sh "git", "push"
+      sh "git", "push", "--tags"
+      sh "gh", "release", "create",
+         "--generate-notes", "--fail-on-no-commits",
+         tag
+    end
+
+    def destroy
+      sh "gh", "release", "delete",
+         "--yes", "--cleanup-tag",
+         tag
+    end
+
+    def list
+      sh "gh", "release", "list"
+    end
+  end
+end

data/lib/gempilot/project/version.rb

@@ -0,0 +1,39 @@
+module Gempilot
+  class Project
+    Version = Data.define(:path, :value) do
+      def tag
+        "v#{value}"
+      end
+
+      def bump(segment = :patch)
+        case segment.to_sym
+        when :major, :minor, :patch then bump_semver(segment)
+        when :dev                   then bump_dev
+        else raise ArgumentError, "Unknown segment #{segment.inspect}. Use :major, :minor, :patch, or :dev"
+        end
+      end
+
+      private
+
+      def bump_semver(segment)
+        major, minor, patch = value.split(".").first(3).map(&:to_i)
+        new_value = case segment.to_sym
+                    when :major then "#{major + 1}.0.0"
+                    when :minor then "#{major}.#{minor + 1}.0"
+                    when :patch then "#{major}.#{minor}.#{patch + 1}"
+                    end
+        with(value: new_value)
+      end
+
+      def bump_dev
+        if value.match?(/\.dev\d+\z/)
+          with(value: value.sub(/\d+\z/) { it.to_i + 1 })
+        else
+          with(value: "#{value}.dev1")
+        end
+      end
+
+      alias_method :next_version, :bump
+    end.freeze
+  end
+end