create-ruby-app 1.1.0 → 1.3.0

data/CODE_REVIEW.md

@@ -0,0 +1,1659 @@
+# Code Review & Improvement Plan for create-ruby-app
+
+## Overview
+
+The codebase is well-structured with a clean action-based architecture.
+Test coverage is at 64.71% (target: 90%). The code follows Ruby idioms
+reasonably well but has opportunities for improvement in immutability,
+side effects, DRY principles, and SOLID adherence.
+
+---
+
+## Critical Issues
+
+### 1. Mutation of App State
+
+**Location:** `lib/create_ruby_app/actions/set_ruby_implementation.rb:23`
+
+**Problem:** `SetRubyImplementation` mutates the `app` object by calling
+`app.version=`, violating immutability principles and creating hidden
+side effects.
+
+**Impact:** Makes reasoning about state difficult, complicates testing,
+breaks functional programming principles.
+
+**Before:**
+```ruby
+def call
+  return app if app.version
+
+  RUBY_IMPLEMENTATIONS.find do |ruby_implementation|
+    stdout, status = fetch_ruby_implementation(ruby_implementation)
+
+    if status.success? && !stdout.empty?
+      app.version = transform_output_to_ruby_version(stdout)
+      return app
+    end
+  end
+
+  raise NoRubyImplementationFoundError
+end
+```
+
+**After:**
+```ruby
+def call
+  return app.version if app.version
+
+  RUBY_IMPLEMENTATIONS.each do |ruby_implementation|
+    stdout, status = fetch_ruby_implementation(ruby_implementation)
+
+    if status.success? && !stdout.empty?
+      return transform_output_to_ruby_version(stdout)
+    end
+  end
+
+  raise NoRubyImplementationFoundError
+end
+
+# In App#run!:
+def run!
+  @version = Actions::SetRubyImplementation.call(self) unless @version
+  # ... rest of actions
+end
+```
+
+**Benefit:** Pure function, testable, no side effects, clear data flow.
+
+---
+
+### 2. Test Coverage Gap (64.71% vs 90% target)
+
+**Problem:** Missing test coverage for:
+- `CLI.call` integration path
+- `App#with_logger` private method behavior
+- Error handling paths in actions
+- Template rendering edge cases
+
+**Impact:** Insufficient confidence in refactoring, potential bugs in
+uncovered code paths.
+
+**Example Missing Test:**
+```ruby
+# spec/lib/create_ruby_app/actions/install_gems_spec.rb
+RSpec.describe CreateRubyApp::Actions::InstallGems do
+  describe ".call" do
+    context "when bundle install fails" do
+      it "raises a GemInstallationError" do
+        app = instance_double(CreateRubyApp::App, name: "test_app")
+
+        allow(Dir).to receive(:chdir).and_yield
+        allow_any_instance_of(Object).to receive(:system)
+          .and_return(false)
+
+        expect { described_class.call(app) }
+          .to raise_error(
+            CreateRubyApp::Actions::GemInstallationError
+          )
+      end
+    end
+  end
+end
+```
+
+**Benefit:** Safer refactoring, fewer production bugs, meets project
+standards.
+
+---
+
+## Design & Architecture Issues
+
+### 3. Inconsistent Action Interface Pattern
+
+**Location:** All action files in
+`lib/create_ruby_app/actions/*.rb:11-13`
+
+**Problem:** Actions have both class method `.call(app)` and instance
+method `#call`, creating unnecessary indirection. The class method
+instantiates then immediately calls instance method.
+
+**Impact:** Boilerplate in every action, unclear whether to use class
+or instance, harder to test.
+
+**Before:**
+```ruby
+class CreateDirectories
+  def initialize(app)
+    @app = app
+  end
+
+  def self.call(app)
+    new(app).call
+  end
+
+  def call
+    [
+      Pathname.new("#{app.name}/bin"),
+      Pathname.new("#{app.name}/lib/#{app.name}"),
+      Pathname.new("#{app.name}/spec/lib/#{app.name}")
+    ].each(&FileUtils.method(:mkdir_p))
+  end
+
+  attr_reader :app
+end
+```
+
+**After:**
+```ruby
+class CreateDirectories
+  def self.call(app)
+    [
+      Pathname.new("#{app.name}/bin"),
+      Pathname.new("#{app.name}/lib/#{app.name}"),
+      Pathname.new("#{app.name}/spec/lib/#{app.name}")
+    ].each(&FileUtils.method(:mkdir_p))
+  end
+end
+```
+
+**Benefit:** Less boilerplate, clearer API, easier to understand and
+test.
+
+---
+
+### 4. God Method: App#run! Violates Single Responsibility Principle
+
+**Location:** `lib/create_ruby_app/app.rb:17-27`
+
+**Problem:** `run!` method is hardcoded with specific actions and
+logging messages. Adding/removing/reordering actions requires modifying
+this method. Mixing orchestration with logging concerns.
+
+**Impact:** Violates Open/Closed Principle, difficult to extend, tight
+coupling, hard to test individual flow variations.
+
+**Before:**
+```ruby
+def run!
+  with_logger("Creating directories...", Actions::CreateDirectories)
+  with_logger(
+    "Setting Ruby implementations...",
+    Actions::SetRubyImplementation
+  )
+  with_logger("Generating files...", Actions::GenerateFiles)
+  with_logger("Making script executable...", Actions::MakeScriptExecutable)
+  with_logger("Installing gems...", Actions::InstallGems)
+  with_logger("Happy hacking!", ->(_) {})
+end
+```
+
+**After:**
+```ruby
+def run!
+  pipeline.each do |step|
+    logger.info(step[:message])
+    step[:action].call(self)
+  end
+end
+
+def pipeline
+  @pipeline ||= [
+    {
+      message: "Creating directories...",
+      action: Actions::CreateDirectories
+    },
+    {
+      message: "Setting Ruby implementations...",
+      action: Actions::SetRubyImplementation
+    },
+    {
+      message: "Generating files...",
+      action: Actions::GenerateFiles
+    },
+    {
+      message: "Making script executable...",
+      action: Actions::MakeScriptExecutable
+    },
+    {
+      message: "Installing gems...",
+      action: Actions::InstallGems
+    }
+  ]
+end
+
+def log_completion
+  logger.info("Happy hacking!")
+end
+```
+
+**Benefit:** Extensible, testable, follows SOLID, allows dependency
+injection of action pipeline.
+
+---
+
+### 5. Logging Responsibility Misplaced
+
+**Location:** `lib/create_ruby_app/app.rb:38-41`
+
+**Problem:** `App#with_logger` couples logging to action execution.
+Actions don't know they're being logged, but App controls this as a
+cross-cutting concern in a non-standard way.
+
+**Impact:** Violates Single Responsibility, makes it hard to change
+logging strategy, reduces flexibility.
+
+**Before:**
+```ruby
+def with_logger(text, action)
+  logger.info(text)
+  action.call(self)
+end
+```
+
+**After (Option 1 - Decorator Pattern):**
+```ruby
+class LoggedAction
+  def initialize(action, message, logger)
+    @action = action
+    @message = message
+    @logger = logger
+  end
+
+  def call(app)
+    @logger.info(@message)
+    @action.call(app)
+  end
+end
+
+# Usage in App#run!:
+def run!
+  actions.each { |action| action.call(self) }
+  logger.info("Happy hacking!")
+end
+
+def actions
+  [
+    LoggedAction.new(
+      Actions::CreateDirectories,
+      "Creating directories...",
+      logger
+    ),
+    # ... etc
+  ]
+end
+```
+
+**After (Option 2 - Pipeline Executor):**
+```ruby
+class ActionPipeline
+  def initialize(steps, logger)
+    @steps = steps
+    @logger = logger
+  end
+
+  def execute(app)
+    @steps.each do |step|
+      @logger.info(step[:message])
+      step[:action].call(app)
+    end
+  end
+end
+
+# Usage:
+def run!
+  ActionPipeline.new(pipeline, logger).execute(self)
+end
+```
+
+**Benefit:** Separation of concerns, flexible logging strategies,
+cleaner App class.
+
+---
+
+### 6. Tight Coupling: Actions Know Too Much About App Structure
+
+**Location:** All action classes
+
+**Problem:** Actions directly access `app.name`, `app.gems`,
+`app.version`. Changes to App internal structure ripple through all
+actions.
+
+**Impact:** High coupling, difficult to refactor App, violates Law of
+Demeter.
+
+**Before:**
+```ruby
+class CreateDirectories
+  def self.call(app)
+    [
+      Pathname.new("#{app.name}/bin"),
+      Pathname.new("#{app.name}/lib/#{app.name}"),
+      Pathname.new("#{app.name}/spec/lib/#{app.name}")
+    ].each(&FileUtils.method(:mkdir_p))
+  end
+end
+```
+
+**After (Option 1 - Pass Only Required Data):**
+```ruby
+class CreateDirectories
+  def self.call(project_name:)
+    [
+      Pathname.new("#{project_name}/bin"),
+      Pathname.new("#{project_name}/lib/#{project_name}"),
+      Pathname.new("#{project_name}/spec/lib/#{project_name}")
+    ].each(&FileUtils.method(:mkdir_p))
+  end
+end
+
+# In App#run!:
+Actions::CreateDirectories.call(project_name: name)
+```
+
+**After (Option 2 - Context Object):**
+```ruby
+class AppContext
+  attr_reader :project_name, :ruby_version, :gems, :paths
+
+  def initialize(name:, version:, gems:)
+    @project_name = name
+    @ruby_version = version
+    @gems = gems
+    @paths = PathBuilder.new(name)
+  end
+end
+
+class CreateDirectories
+  def self.call(context)
+    context.paths.directories.each(&FileUtils.method(:mkdir_p))
+  end
+end
+```
+
+**Benefit:** Loose coupling, easier to refactor, clearer dependencies,
+better testability.
+
+---
+
+## Code Quality Issues
+
+### 7. Magic Empty Lambda as Final Action
+
+**Location:** `lib/create_ruby_app/app.rb:26`
+
+**Problem:** `with_logger("Happy hacking!", ->(_) {})` uses empty
+lambda to show completion message. Unclear intent, breaks action
+pattern consistency.
+
+**Impact:** Confusing, fragile, violates Principle of Least Surprise.
+
+**Before:**
+```ruby
+def run!
+  with_logger("Creating directories...", Actions::CreateDirectories)
+  # ... other actions
+  with_logger("Happy hacking!", ->(_) {})
+end
+```
+
+**After (Option 1):**
+```ruby
+def run!
+  with_logger("Creating directories...", Actions::CreateDirectories)
+  # ... other actions
+  log_completion
+end
+
+private
+
+def log_completion
+  logger.info("Happy hacking!")
+end
+```
+
+**After (Option 2):**
+```ruby
+class CompletionAction
+  def self.call(_app)
+    # No-op action for consistency
+  end
+end
+
+def run!
+  with_logger("Creating directories...", Actions::CreateDirectories)
+  # ... other actions
+  with_logger("Happy hacking!", CompletionAction)
+end
+```
+
+**Benefit:** Clear intent, consistent pattern, self-documenting code.
+
+---
+
+### 8. Hardcoded Constants Should Be Configurable
+
+**Location:**
+`lib/create_ruby_app/actions/set_ruby_implementation.rb:41-47`
+
+**Problem:** `RUBY_IMPLEMENTATIONS` array is hardcoded. No way to
+extend or modify Ruby implementation search order without modifying
+source.
+
+**Impact:** Not extensible for new Ruby implementations or custom
+search orders.
+
+**Before:**
+```ruby
+RUBY_IMPLEMENTATIONS = %w[
+  ruby
+  truffleruby
+  jruby
+  mruby
+  rubinius
+].freeze
+```
+
+**After:**
+```ruby
+class SetRubyImplementation
+  DEFAULT_IMPLEMENTATIONS = %w[
+    ruby
+    truffleruby
+    jruby
+    mruby
+    rubinius
+  ].freeze
+
+  def self.call(app, implementations: DEFAULT_IMPLEMENTATIONS)
+    return app.version if app.version
+
+    implementations.each do |ruby_implementation|
+      stdout, status = fetch_ruby_implementation(ruby_implementation)
+
+      if status.success? && !stdout.empty?
+        return transform_output_to_ruby_version(stdout)
+      end
+    end
+
+    raise NoRubyImplementationFoundError
+  end
+end
+
+# In App initialization:
+def initialize(
+  name: "app",
+  gems: [],
+  version: nil,
+  logger: Logger.new($stdout),
+  ruby_implementations: nil
+)
+  @name = name
+  @gems = gems
+  @version = version
+  @logger = logger
+  @ruby_implementations = ruby_implementations
+end
+```
+
+**Benefit:** Flexible, extensible, follows Open/Closed Principle.
+
+---
+
+### 9. Non-functional String Manipulation in GenerateFiles#gemfile
+
+**Location:** `lib/create_ruby_app/actions/generate_files.rb:38-44`
+
+**Problem:** Inline block with sorting, mapping, and joining makes code
+harder to read. The logic for formatting gems is mixed with template
+data preparation.
+
+**Impact:** Reduced readability, difficult to test gem formatting
+independently, violates Single Responsibility.
+
+**Before:**
+```ruby
+def gemfile
+  generate_file(file: "Gemfile.erb", locals: {
+    gems: app
+      .gems
+      .sort
+      .map {|gem| "gem \"#{gem}\"" }.join("\n")
+  })
+end
+```
+
+**After:**
+```ruby
+def gemfile
+  generate_file(
+    file: "Gemfile.erb",
+    locals: { gems: format_gems_for_gemfile(app.gems) }
+  )
+end
+
+private
+
+def format_gems_for_gemfile(gems)
+  gems
+    .sort
+    .map { |gem| "gem \"#{gem}\"" }
+    .join("\n")
+end
+```
+
+**Benefit:** Readable, testable, follows Single Responsibility
+Principle.
+
+---
+
+### 10. Path Construction Scattered Across Actions
+
+**Location:** Multiple files:
+- `lib/create_ruby_app/actions/create_directories.rb:17-19`
+- `lib/create_ruby_app/actions/make_script_executable.rb:15`
+- `lib/create_ruby_app/actions/generate_files.rb:56`
+- `lib/create_ruby_app/actions/install_gems.rb:13`
+
+**Problem:** String interpolation like `"#{app.name}/bin/#{app.name}"`
+appears in multiple actions.
+
+**Impact:** DRY violation, inconsistent path handling, error-prone,
+hard to change directory structure.
+
+**Before:**
+```ruby
+# In CreateDirectories:
+Pathname.new("#{app.name}/bin")
+Pathname.new("#{app.name}/lib/#{app.name}")
+
+# In MakeScriptExecutable:
+FileUtils.chmod("+x", "#{app.name}/bin/#{app.name}")
+
+# In GenerateFiles:
+File.write("#{app.name}/#{path}", content)
+
+# In InstallGems:
+Dir.chdir(app.name) { system("bundle", "install") }
+```
+
+**After:**
+```ruby
+# In App class:
+def project_root
+  @project_root ||= Pathname.new(name)
+end
+
+def bin_dir
+  project_root.join("bin")
+end
+
+def bin_script_path
+  bin_dir.join(name)
+end
+
+def lib_dir
+  project_root.join("lib")
+end
+
+def lib_subdir
+  lib_dir.join(name)
+end
+
+def spec_dir
+  project_root.join("spec")
+end
+
+def spec_lib_dir
+  spec_dir.join("lib", name)
+end
+
+def file_path(relative_path)
+  project_root.join(relative_path)
+end
+
+# Usage in actions:
+class CreateDirectories
+  def self.call(app)
+    [
+      app.bin_dir,
+      app.lib_subdir,
+      app.spec_lib_dir
+    ].each(&FileUtils.method(:mkdir_p))
+  end
+end
+
+class MakeScriptExecutable
+  def self.call(app)
+    FileUtils.chmod("+x", app.bin_script_path)
+  end
+end
+
+class GenerateFiles
+  def create_file(path:, content:)
+    File.write(app.file_path(path), content)
+  end
+end
+
+class InstallGems
+  def self.call(app)
+    Dir.chdir(app.project_root) { system("bundle", "install") }
+  end
+end
+```
+
+**Benefit:** DRY, consistent paths, single source of truth, easier to
+test and modify.
+
+---
+
+### 11. Mixed Concerns in GenerateFiles
+
+**Location:** `lib/create_ruby_app/actions/generate_files.rb`
+
+**Problem:** Class handles both file generation logic AND template
+rendering AND path construction. Methods like `script_file`, `lib_file`
+are public but only used internally.
+
+**Impact:** Violates Single Responsibility, unclear API, difficult to
+test components independently.
+
+**Before:**
+```ruby
+class GenerateFiles
+  def call
+    generate_files
+  end
+
+  def script_file
+    generate_file(file: "script_file.erb", locals: {})
+  end
+
+  def lib_file
+    generate_file(file: "lib_file.erb", locals: { app: app.classify_name })
+  end
+
+  # ... more public methods that should be private
+
+  private
+
+  def generate_file(file:, locals: [])
+    ERB
+      .new(read_file(file), trim_mode: TRIM_MODE)
+      .result_with_hash(locals: locals)
+  end
+
+  def read_file(file)
+    Pathname.new(__FILE__)
+      .dirname
+      .join("#{TEMPLATES_DIR}/#{file}")
+      .read
+  end
+
+  def files
+    {
+      "bin/#{app.name}" => script_file,
+      "lib/#{app.name}.rb" => lib_file,
+      # ...
+    }
+  end
+end
+```
+
+**After:**
+```ruby
+# Separate template renderer:
+class TemplateRenderer
+  TRIM_MODE = "<>"
+  TEMPLATES_DIR = File.expand_path("../templates", __dir__)
+
+  def self.render(template_name, locals = {})
+    template_path = File.join(TEMPLATES_DIR, "#{template_name}.erb")
+    template_content = File.read(template_path)
+
+    ERB
+      .new(template_content, trim_mode: TRIM_MODE)
+      .result_with_hash(locals: locals)
+  end
+
+  private_constant :TRIM_MODE, :TEMPLATES_DIR
+end
+
+# Simplified GenerateFiles:
+class GenerateFiles
+  def self.call(app)
+    files(app).each do |path, content|
+      File.write(app.file_path(path), content)
+    end
+  end
+
+  def self.files(app)
+    {
+      "bin/#{app.name}" => script_file,
+      "lib/#{app.name}.rb" => lib_file(app),
+      "spec/spec_helper.rb" => spec_helper_file(app),
+      ".ruby-version" => ruby_version_file(app),
+      "Gemfile" => gemfile(app)
+    }
+  end
+
+  private_class_method def self.script_file
+    TemplateRenderer.render("script_file")
+  end
+
+  private_class_method def self.lib_file(app)
+    TemplateRenderer.render("lib_file", app: app.classify_name)
+  end
+
+  private_class_method def self.spec_helper_file(app)
+    TemplateRenderer.render("spec_helper", app: app.name)
+  end
+
+  private_class_method def self.ruby_version_file(app)
+    TemplateRenderer.render("ruby-version", version: app.version)
+  end
+
+  private_class_method def self.gemfile(app)
+    TemplateRenderer.render(
+      "Gemfile",
+      gems: format_gems(app.gems)
+    )
+  end
+
+  private_class_method def self.format_gems(gems)
+    gems.sort.map { |gem| "gem \"#{gem}\"" }.join("\n")
+  end
+end
+```
+
+**Benefit:** Single Responsibility, clearer separation, easier to test,
+better encapsulation.
+
+---
+
+### 12. Error Handling Inconsistency
+
+**Location:** Various action files
+
+**Problem:** Only `SetRubyImplementation` has custom error class. Other
+actions fail silently or raise system errors (FileUtils, System calls).
+
+**Impact:** Inconsistent error handling, difficult to rescue specific
+failures, poor user experience.
+
+**Before:**
+```ruby
+# Only one custom error:
+class NoRubyImplementationFoundError < StandardError; end
+
+# Other actions have no error handling:
+class InstallGems
+  def self.call(app)
+    Dir.chdir(app.name) { system("bundle", "install") }
+  end
+end
+```
+
+**After:**
+```ruby
+# lib/create_ruby_app/errors.rb
+module CreateRubyApp
+  class Error < StandardError; end
+
+  class NoRubyImplementationFoundError < Error; end
+  class DirectoryCreationError < Error; end
+  class FileGenerationError < Error; end
+  class GemInstallationError < Error; end
+  class ScriptExecutableError < Error; end
+end
+
+# Usage in actions:
+class InstallGems
+  def self.call(app)
+    Dir.chdir(app.project_root) do
+      success = system("bundle", "install")
+
+      unless success
+        raise GemInstallationError,
+          "Failed to install gems for #{app.name}. " \
+          "Please check your Gemfile and try again."
+      end
+    end
+  rescue Errno::ENOENT => e
+    raise GemInstallationError,
+      "Bundle command not found: #{e.message}"
+  end
+end
+
+class CreateDirectories
+  def self.call(app)
+    [
+      app.bin_dir,
+      app.lib_subdir,
+      app.spec_lib_dir
+    ].each do |dir|
+      FileUtils.mkdir_p(dir)
+    end
+  rescue Errno::EACCES => e
+    raise DirectoryCreationError,
+      "Permission denied creating directories: #{e.message}"
+  rescue StandardError => e
+    raise DirectoryCreationError,
+      "Failed to create directories: #{e.message}"
+  end
+end
+```
+
+**Benefit:** Consistent error handling, better user experience, easier
+to debug, more robust.
+
+---
+
+### 13. System Call Without Error Handling
+
+**Location:** `lib/create_ruby_app/actions/install_gems.rb:13`
+
+**Problem:** `system("bundle", "install")` doesn't check return value.
+If bundler fails, execution continues silently.
+
+**Impact:** Creates incomplete/broken projects, silent failures, poor
+user experience.
+
+**Before:**
+```ruby
+class InstallGems
+  def self.call(app)
+    Dir.chdir(app.name) { system("bundle", "install") }
+  end
+end
+```
+
+**After:**
+```ruby
+class InstallGems
+  def self.call(app)
+    Dir.chdir(app.project_root) do
+      success = system("bundle", "install")
+
+      unless success
+        raise GemInstallationError,
+          "Bundle install failed with exit code #{$?.exitstatus}. " \
+          "Please check your Gemfile and ensure bundler is installed."
+      end
+    end
+  rescue Errno::ENOENT
+    raise GemInstallationError,
+      "Bundler is not installed. Please run: gem install bundler"
+  end
+end
+```
+
+**Benefit:** Catches failures early, better user experience, more
+robust.
+
+---
+
+### 14. Template Constants Are Implementation Details
+
+**Location:** `lib/create_ruby_app/actions/generate_files.rb:82-83`
+
+**Problem:** `TRIM_MODE` and `TEMPLATES_DIR` are public constants but
+are implementation details.
+
+**Impact:** Pollutes constant namespace, can be accidentally overridden,
+unclear why they're public.
+
+**Before:**
+```ruby
+class GenerateFiles
+  # ... methods ...
+
+  TRIM_MODE = "<>"
+  TEMPLATES_DIR = "../templates"
+end
+```
+
+**After:**
+```ruby
+class GenerateFiles
+  TRIM_MODE = "<>"
+  TEMPLATES_DIR = "../templates"
+
+  private_constant :TRIM_MODE, :TEMPLATES_DIR
+
+  # ... methods ...
+end
+```
+
+**Benefit:** Better encapsulation, clearer API, prevents accidental
+modification.
+
+---
+
+### 15. Unused Empty Class
+
+**Location:** `lib/create_ruby_app.rb:11-12`
+
+**Problem:** `CreateRubyApp::CreateRubyApp` class is empty and unused.
+
+**Impact:** Dead code, confusing namespace, unclear purpose.
+
+**Before:**
+```ruby
+module CreateRubyApp
+  class CreateRubyApp
+  end
+end
+```
+
+**After:**
+```ruby
+# Remove the empty class entirely
+```
+
+**Benefit:** Cleaner codebase, less confusion, follows YAGNI principle.
+
+---
+
+## Minor Improvements
+
+### 16. classify_name Could Use ActiveSupport-style Method
+
+**Location:** `lib/create_ruby_app/app.rb:29-31`
+
+**Problem:** Manual string manipulation. Ruby/Rails has established
+patterns for this.
+
+**Impact:** Minor: reinventing the wheel, less idiomatic.
+
+**Before:**
+```ruby
+def classify_name
+  name.split("_").collect(&:capitalize).join
+end
+```
+
+**After:**
+```ruby
+def classify_name
+  name.split("_").map(&:capitalize).join
+end
+
+# Or extract to a separate concern:
+module StringClassifier
+  def self.classify(string)
+    string.split("_").map(&:capitalize).join
+  end
+end
+
+def classify_name
+  StringClassifier.classify(name)
+end
+```
+
+**Benefit:** More idiomatic, potentially more robust edge case handling.
+
+---
+
+### 17. Gemspec Has Outdated Date
+
+**Location:** `create_ruby_app.gemspec:8`
+
+**Problem:** `s.date = "2019-03-11"` is hardcoded and outdated.
+
+**Impact:** Misleading metadata, appears unmaintained.
+
+**Before:**
+```ruby
+Gem::Specification.new do |s|
+  s.name    = "create-ruby-app"
+  s.version = CreateRubyApp::VERSION
+  s.date    = "2019-03-11"
+  # ...
+end
+```
+
+**After:**
+```ruby
+Gem::Specification.new do |s|
+  s.name    = "create-ruby-app"
+  s.version = CreateRubyApp::VERSION
+  # Let RubyGems set the date automatically
+  # ...
+end
+```
+
+**Benefit:** Accurate metadata, appears maintained.
+
+---
+
+### 18. Dry::CLI::Registry Could Use Module Inclusion
+
+**Location:** `lib/create_ruby_app/cli.rb:4-5`
+
+**Problem:** `Commands` module extends `Dry::CLI::Registry`, but it's
+not immediately clear this is necessary vs include.
+
+**Impact:** Minor: potential confusion for maintainers unfamiliar with
+dry-cli.
+
+**Before:**
+```ruby
+module Commands
+  extend Dry::CLI::Registry
+
+  class Version < Dry::CLI::Command
+    # ...
+  end
+end
+```
+
+**After:**
+```ruby
+module Commands
+  # Extend (not include) is required for Dry::CLI registry pattern
+  extend Dry::CLI::Registry
+
+  class Version < Dry::CLI::Command
+    # ...
+  end
+end
+```
+
+**Benefit:** Clearer intent, easier maintenance.
+
+---
+
+### 19. parse_gems Method Could Be More Functional
+
+**Location:** `lib/create_ruby_app/cli.rb:53-57`
+
+**Problem:** Multiple transformations chained, but early return with
+ternary operator breaks functional flow.
+
+**Impact:** Minor: slightly less readable, mixed paradigms.
+
+**Before:**
+```ruby
+def parse_gems(gems_string)
+  return [] if gems_string.nil? || gems_string.strip.empty?
+
+  gems_string.split(",").map(&:strip).reject(&:empty?)
+end
+```
+
+**After:**
+```ruby
+def parse_gems(gems_string)
+  gems_string
+    .to_s
+    .split(",")
+    .map(&:strip)
+    .reject(&:empty?)
+end
+
+# Or more Ruby-idiomatic with safe navigation:
+def parse_gems(gems_string)
+  return [] unless gems_string
+
+  gems_string
+    .split(",")
+    .map(&:strip)
+    .reject(&:empty?)
+end
+```
+
+**Benefit:** More functional, concise, Ruby-idiomatic.
+
+---
+
+### 20. Logger Deprecation Warning
+
+**Location:** `lib/create_ruby_app/app.rb:1`
+
+**Problem:** Test output shows: "logger was loaded from the standard
+library, but will no longer be part of the default gems starting from
+Ruby 3.5.0."
+
+**Impact:** Future compatibility issue, will break in Ruby 3.5+.
+
+**Before:**
+```ruby
+# In create_ruby_app.gemspec:
+s.add_development_dependency "rake", "~> 13.3.0"
+s.add_development_dependency "rspec", "~> 3.13.1"
+s.add_development_dependency "simplecov", "~> 0.22.0"
+```
+
+**After:**
+```ruby
+# In create_ruby_app.gemspec:
+s.add_runtime_dependency "logger", "~> 1.6"
+
+s.add_development_dependency "rake", "~> 13.3.0"
+s.add_development_dependency "rspec", "~> 3.13.1"
+s.add_development_dependency "simplecov", "~> 0.22.0"
+```
+
+**Benefit:** Future-proof, no warnings, follows Ruby 3.5+ requirements.
+
+---
+
+## Refactoring Opportunities
+
+### 21. Extract Action Pipeline Pattern
+
+**Current:** Actions hardcoded in `App#run!`
+
+**Before:**
+```ruby
+def run!
+  with_logger("Creating directories...", Actions::CreateDirectories)
+  with_logger(
+    "Setting Ruby implementations...",
+    Actions::SetRubyImplementation
+  )
+  with_logger("Generating files...", Actions::GenerateFiles)
+  with_logger("Making script executable...", Actions::MakeScriptExecutable)
+  with_logger("Installing gems...", Actions::InstallGems)
+  with_logger("Happy hacking!", ->(_) {})
+end
+```
+
+**After:**
+```ruby
+# lib/create_ruby_app/action_pipeline.rb
+module CreateRubyApp
+  class ActionPipeline
+    Step = Struct.new(:message, :action, keyword_init: true)
+
+    def initialize(steps, logger)
+      @steps = steps
+      @logger = logger
+    end
+
+    def execute(context)
+      @steps.each do |step|
+        @logger.info(step.message)
+        step.action.call(context)
+      end
+    end
+  end
+end
+
+# In App class:
+def run!
+  ActionPipeline.new(pipeline_steps, logger).execute(self)
+  logger.info("Happy hacking!")
+end
+
+def pipeline_steps
+  [
+    ActionPipeline::Step.new(
+      message: "Creating directories...",
+      action: Actions::CreateDirectories
+    ),
+    ActionPipeline::Step.new(
+      message: "Setting Ruby implementations...",
+      action: Actions::SetRubyImplementation
+    ),
+    ActionPipeline::Step.new(
+      message: "Generating files...",
+      action: Actions::GenerateFiles
+    ),
+    ActionPipeline::Step.new(
+      message: "Making script executable...",
+      action: Actions::MakeScriptExecutable
+    ),
+    ActionPipeline::Step.new(
+      message: "Installing gems...",
+      action: Actions::InstallGems
+    )
+  ]
+end
+```
+
+**Benefit:** Testable pipeline, configurable actions, follows Strategy
+pattern, Open/Closed Principle.
+
+---
+
+### 22. Introduce Value Objects
+
+**Current:** Primitive strings for `name`, `version`
+
+**Before:**
+```ruby
+def initialize(name: "app", gems: [], version: nil, logger: Logger.new($stdout))
+  @name = name
+  @gems = gems
+  @version = version
+  @logger = logger
+end
+```
+
+**After:**
+```ruby
+# lib/create_ruby_app/value_objects/app_name.rb
+module CreateRubyApp
+  class AppName
+    attr_reader :value
+
+    def initialize(value)
+      @value = normalize(value)
+      validate!
+    end
+
+    def to_s
+      value
+    end
+
+    def classify
+      value.split("_").map(&:capitalize).join
+    end
+
+    private
+
+    def normalize(name)
+      name.to_s.tr("-", "_")
+    end
+
+    def validate!
+      if value.empty?
+        raise ArgumentError, "App name cannot be empty"
+      end
+
+      unless value.match?(/\A[a-z_][a-z0-9_]*\z/)
+        raise ArgumentError,
+          "App name must be valid Ruby identifier: #{value}"
+      end
+    end
+  end
+end
+
+# lib/create_ruby_app/value_objects/ruby_version.rb
+module CreateRubyApp
+  class RubyVersion
+    attr_reader :implementation, :version
+
+    def initialize(version_string)
+      @implementation, @version = parse(version_string)
+      validate!
+    end
+
+    def to_s
+      "#{implementation}-#{version}"
+    end
+
+    private
+
+    def parse(version_string)
+      parts = version_string.to_s.split("-", 2)
+      [parts[0], parts[1]]
+    end
+
+    def validate!
+      if implementation.nil? || version.nil?
+        raise ArgumentError, "Invalid Ruby version format"
+      end
+    end
+  end
+end
+
+# Usage in App:
+def initialize(
+  name: "app",
+  gems: [],
+  version: nil,
+  logger: Logger.new($stdout)
+)
+  @name = AppName.new(name)
+  @gems = gems
+  @version = version ? RubyVersion.new(version) : nil
+  @logger = logger
+end
+```
+
+**Benefit:** Type safety, validation in one place, clearer domain model,
+follows Value Object pattern.
+
+---
+
+### 23. Extract Path Management
+
+**Current:** Path strings constructed everywhere
+
+**Before:**
+```ruby
+# Scattered throughout actions:
+Pathname.new("#{app.name}/bin")
+"#{app.name}/lib/#{app.name}"
+FileUtils.chmod("+x", "#{app.name}/bin/#{app.name}")
+```
+
+**After:**
+```ruby
+# lib/create_ruby_app/project_structure.rb
+module CreateRubyApp
+  class ProjectStructure
+    attr_reader :project_name
+
+    def initialize(project_name)
+      @project_name = project_name
+    end
+
+    def root
+      @root ||= Pathname.new(project_name)
+    end
+
+    def bin_dir
+      root.join("bin")
+    end
+
+    def bin_script
+      bin_dir.join(project_name)
+    end
+
+    def lib_dir
+      root.join("lib")
+    end
+
+    def lib_subdir
+      lib_dir.join(project_name)
+    end
+
+    def lib_main_file
+      lib_dir.join("#{project_name}.rb")
+    end
+
+    def spec_dir
+      root.join("spec")
+    end
+
+    def spec_lib_dir
+      spec_dir.join("lib", project_name)
+    end
+
+    def spec_helper
+      spec_dir.join("spec_helper.rb")
+    end
+
+    def ruby_version_file
+      root.join(".ruby-version")
+    end
+
+    def gemfile
+      root.join("Gemfile")
+    end
+
+    def directories
+      [bin_dir, lib_subdir, spec_lib_dir]
+    end
+  end
+end
+
+# Usage in App:
+def paths
+  @paths ||= ProjectStructure.new(name)
+end
+
+# Usage in actions:
+class CreateDirectories
+  def self.call(app)
+    app.paths.directories.each(&FileUtils.method(:mkdir_p))
+  end
+end
+```
+
+**Benefit:** DRY, testable, single source of truth, easier to modify
+structure.
+
+---
+
+### 24. Consider Result Objects Instead of Exceptions
+
+**Current:** Exceptions for control flow in `SetRubyImplementation`
+
+**Before:**
+```ruby
+def call
+  return app.version if app.version
+
+  RUBY_IMPLEMENTATIONS.each do |ruby_implementation|
+    stdout, status = fetch_ruby_implementation(ruby_implementation)
+
+    if status.success? && !stdout.empty?
+      return transform_output_to_ruby_version(stdout)
+    end
+  end
+
+  raise NoRubyImplementationFoundError,
+        "No version of Ruby is found or provided"
+end
+```
+
+**After (using dry-monads):**
+```ruby
+require "dry/monads"
+
+class SetRubyImplementation
+  include Dry::Monads[:result]
+
+  def self.call(app)
+    return Success(app.version) if app.version
+
+    result = DEFAULT_IMPLEMENTATIONS.lazy.map do |impl|
+      detect_ruby_implementation(impl)
+    end.find(&:success?)
+
+    result || Failure(
+      :no_ruby_found,
+      "No version of Ruby is found or provided"
+    )
+  end
+
+  def self.detect_ruby_implementation(implementation)
+    stdout, status = fetch_ruby_implementation(implementation)
+
+    if status.success? && !stdout.empty?
+      Success(transform_output_to_ruby_version(stdout))
+    else
+      Failure(:not_found, implementation)
+    end
+  end
+
+  # ... rest of methods
+end
+
+# In App#run!:
+result = Actions::SetRubyImplementation.call(self)
+
+result.fmap { |version| @version = version }
+      .or { |error| raise NoRubyImplementationFoundError, error }
+```
+
+**Benefit:** More functional, explicit error handling, better
+performance, clearer control flow.
+
+---
+
+## Testing Improvements Needed
+
+### 25. Missing Tests
+
+**Examples of missing test coverage:**
+
+```ruby
+# spec/lib/create_ruby_app/app_spec.rb - Add:
+RSpec.describe CreateRubyApp::App do
+  describe "#with_logger" do
+    it "logs message before executing action" do
+      logger = instance_double(Logger)
+      app = described_class.new(
+        name: "test",
+        version: "ruby-3.4.0",
+        logger: logger
+      )
+      action = ->(_) {}
+
+      expect(logger).to receive(:info).with("Test message").ordered
+      expect(action).to receive(:call).with(app).ordered
+
+      app.send(:with_logger, "Test message", action)
+    end
+  end
+end
+
+# spec/lib/create_ruby_app/actions/create_directories_spec.rb - Add:
+RSpec.describe CreateRubyApp::Actions::CreateDirectories do
+  describe ".call" do
+    context "when directory creation fails due to permissions" do
+      it "raises DirectoryCreationError" do
+        app = instance_double(
+          CreateRubyApp::App,
+          name: "test_app"
+        )
+
+        allow(FileUtils).to receive(:mkdir_p)
+          .and_raise(Errno::EACCES, "Permission denied")
+
+        expect { described_class.call(app) }
+          .to raise_error(
+            CreateRubyApp::DirectoryCreationError,
+            /Permission denied/
+          )
+      end
+    end
+  end
+end
+```
+
+### 26. Test Improvements
+
+**Reduce duplication in set_ruby_implementation_spec.rb:**
+
+**Before:**
+```ruby
+context "when no version if provided, but an `mruby` implementation is found" do
+  let(:app) do
+    instance_double(CreateRubyApp::App, name: "mruby_app", version: nil)
+  end
+
+  it "returns the local version" do
+    %w[ruby truffleruby jruby rubinius].each do |ruby_implementation|
+      allow(Open3).to receive(:capture3).with(
+        "#{ruby_implementation} -v"
+      ).and_return(
+        ["", "", instance_double(Process::Status, success?: false)]
+      )
+    end
+
+    allow(Open3).to receive(:capture3).with("mruby -v").and_return(
+      ["mruby 3.3.0", "", instance_double(Process::Status, success?: true)]
+    )
+
+    # ... more repetitive setup
+  end
+end
+```
+
+**After:**
+```ruby
+RSpec.describe CreateRubyApp::Actions::SetRubyImplementation do
+  describe ".call" do
+    let(:app) { instance_double(CreateRubyApp::App, version: nil) }
+
+    def stub_ruby_implementations(except:, found_version:)
+      implementations = %w[ruby truffleruby jruby mruby rubinius]
+
+      implementations.each do |impl|
+        if impl == except
+          allow(Open3).to receive(:capture3).with("#{impl} -v")
+            .and_return([
+              found_version,
+              "",
+              instance_double(Process::Status, success?: true)
+            ])
+        else
+          allow(Open3).to receive(:capture3).with("#{impl} -v")
+            .and_return([
+              "",
+              "",
+              instance_double(Process::Status, success?: false)
+            ])
+        end
+      end
+    end
+
+    context "when mruby implementation is found" do
+      it "returns the mruby version" do
+        stub_ruby_implementations(
+          except: "mruby",
+          found_version: "mruby 3.3.0"
+        )
+
+        expect(described_class.call(app)).to eq("mruby-3.3.0")
+      end
+    end
+
+    context "when jruby implementation is found" do
+      it "returns the jruby version" do
+        stub_ruby_implementations(
+          except: "jruby",
+          found_version: "jruby 9.4.14.0"
+        )
+
+        expect(described_class.call(app)).to eq("jruby-9.4.14.0")
+      end
+    end
+  end
+end
+```
+
+---
+
+## Priority Ranking (High Impact, Low Effort First)
+
+1. **Add logger gem to gemspec** (High impact, 1 line, immediate
+   benefit)
+2. **Fix system call error handling in InstallGems** (High impact, 3
+   lines, prevents silent failures)
+3. **Remove empty CreateRubyApp::CreateRubyApp class** (Low effort, 2
+   lines, clean code)
+4. **Extract gem formatting logic in GenerateFiles** (Medium effort,
+   improves readability significantly)
+5. **Make SetRubyImplementation pure** (High impact, medium effort,
+   core FP principle)
+6. **Extract path management methods to App** (Medium effort, high DRY
+   improvement)
+7. **Standardize action interface** (Medium effort, reduces boilerplate
+   significantly)
+8. **Add missing error handling and custom exceptions** (High impact,
+   prevents silent failures)
+9. **Extract action pipeline pattern** (Higher effort, major
+   architectural improvement)
+10. **Increase test coverage to 90%** (Higher effort, but critical for
+    confidence)
+
+---
+
+## Summary
+
+The codebase is solid but has room for improvement in:
+
+- **Immutability:** Reduce mutations, make functions pure
+- **SOLID:** Better separation of concerns, dependency inversion,
+  Open/Closed
+- **DRY:** Extract repeated path logic and patterns
+- **Error Handling:** Consistent, comprehensive error handling
+- **Testability:** Improve coverage and reduce coupling for easier
+  testing
+- **Functional Programming:** More pure functions, less side effects
+
+**Total Issues Identified:** 26
+**Estimated Effort to Address All:** Medium (2-3 days of focused work)
+**Risk Level of Changes:** Low to Medium (good test coverage enables
+safe refactoring)
+
+The improvements are incremental and can be tackled independently,
+making this a manageable refactoring effort with significant quality
+gains.