create-ruby-app 1.1.0 → 1.3.0

data/LICENSE

@@ -1,21 +1,13 @@
-MIT License
-
-Copyright (c) 2019 Mathias Jean Johansen
-
-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.
+Copyright (c) 2020 Mathias Jean Johansen
+
+Permission to use, copy, modify, and distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -1,5 +1,5 @@
 # Create Ruby App
-[![Build Status](https://travis-ci.org/majjoha/create-ruby-app.svg)](https://travis-ci.org/majjoha/create-ruby-app)
+![CI](https://github.com/majjoha/create-ruby-app/workflows/CI/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/create-ruby-app.svg)](http://badge.fury.io/rb/create-ruby-app)
 
 `create-ruby-app` is an opinionated tool for scaffolding Ruby applications
@@ -14,7 +14,7 @@ instead, and if you are building a gem, please take a look at the `bundle gem`
 command.
 
 ## Requirements
-* Ruby (version 2.6.2 or newer).
+* Ruby (version 2.7.1 or newer).
 
 ## Installation
 ```
@@ -23,12 +23,12 @@ gem install create-ruby-app
 
 ## Usage
 ```
-create-ruby-app new NAME [--ruby RUBY] [--gems GEMS]
+create-ruby-app new NAME [--ruby RUBY_VERSION] [--gems GEMS]
 ```
 
 ### Example
 ```
-create-ruby-app new my-app --gems sinatra,sequel --ruby ruby-2.6.1
+create-ruby-app new my-app --gems sinatra,sequel --ruby ruby-2.7.1
 ```
 
 This will generate the following project structure with
@@ -54,4 +54,4 @@ Once the project is generated, it will run `bundle install` so you can start
 working.
 
 ## License
-See [LICENSE](https://github.com/majjoha/create-ruby-app/blob/master/LICENSE).
+See [LICENSE](https://github.com/majjoha/create-ruby-app/blob/main/LICENSE).

data/REFACTORING_PLAN.md

@@ -0,0 +1,543 @@
+# Pragmatic Refactoring Plan for create-ruby-app
+
+## Philosophy
+
+For a small project like this, we'll focus on:
+- **High-impact, low-effort changes first**
+- **Maintaining backwards compatibility**
+- **Keeping it simple - avoid over-engineering**
+- **Each step is independently valuable and testable**
+
+---
+
+## Phase 1: Quick Wins (1-2 hours)
+
+These changes are safe, require minimal testing, and provide immediate
+value.
+
+### Step 1.1: Add logger gem dependency
+**File:** `create_ruby_app.gemspec`
+
+**Change:**
+```ruby
+s.add_runtime_dependency "logger", "~> 1.6"
+```
+
+**Why:** Fixes Ruby 3.5+ compatibility. Zero risk.
+
+**Test:** Run tests, verify no warnings.
+
+---
+
+### Step 1.2: Remove empty class
+**File:** `lib/create_ruby_app.rb`
+
+**Change:** Delete lines 11-12 (the empty `CreateRubyApp::CreateRubyApp`
+class)
+
+**Why:** Dead code removal. Zero risk.
+
+**Test:** Run tests, ensure nothing breaks.
+
+---
+
+### Step 1.3: Remove outdated gemspec date
+**File:** `create_ruby_app.gemspec`
+
+**Change:** Delete line 8 (`s.date = "2019-03-11"`)
+
+**Why:** RubyGems sets this automatically. Zero risk.
+
+**Test:** Build gem, verify metadata looks correct.
+
+---
+
+### Step 1.4: Add explanatory comment to CLI
+**File:** `lib/create_ruby_app/cli.rb`
+
+**Change:**
+```ruby
+module Commands
+  # Extend (not include) required for Dry::CLI registry pattern
+  extend Dry::CLI::Registry
+  # ...
+end
+```
+
+**Why:** Better documentation. Zero risk.
+
+**Test:** None needed.
+
+---
+
+## Phase 2: Error Handling (2-3 hours)
+
+Add proper error handling without changing architecture.
+
+### Step 2.1: Create centralized error classes
+**New file:** `lib/create_ruby_app/errors.rb`
+
+```ruby
+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
+```
+
+**File:** `lib/create_ruby_app.rb` - Add:
+```ruby
+require_relative "create_ruby_app/errors"
+```
+
+**Why:** Centralized, consistent error handling.
+
+**Test:** Ensure errors are loadable.
+
+---
+
+### Step 2.2: Add error handling to InstallGems
+**File:** `lib/create_ruby_app/actions/install_gems.rb`
+
+**Change:**
+```ruby
+def call
+  Dir.chdir(app.name) do
+    success = system("bundle", "install")
+
+    unless success
+      raise GemInstallationError,
+        "Failed to install gems. Exit code: #{$?.exitstatus}"
+    end
+  end
+rescue Errno::ENOENT
+  raise GemInstallationError,
+    "Bundler not found. Run: gem install bundler"
+end
+```
+
+**Why:** Prevent silent failures.
+
+**Test:** Mock failing bundle install, verify error is raised.
+
+---
+
+### Step 2.3: Move existing error to errors.rb
+**File:** `lib/create_ruby_app/actions/set_ruby_implementation.rb`
+
+**Change:** Remove `NoRubyImplementationFoundError` class definition
+(it's now in errors.rb).
+
+**Why:** Consistency.
+
+**Test:** Run tests, ensure error still works.
+
+---
+
+## Phase 3: Code Quality Improvements (2-3 hours)
+
+Improve readability and maintainability without architectural changes.
+
+### Step 3.1: Simplify action interface
+**File:** All action files
+
+**Pattern to apply:**
+```ruby
+# BEFORE:
+class CreateDirectories
+  def initialize(app)
+    @app = app
+  end
+
+  def self.call(app)
+    new(app).call
+  end
+
+  def call
+    # ... implementation
+  end
+
+  attr_reader :app
+end
+
+# AFTER:
+class CreateDirectories
+  def self.call(app)
+    # ... implementation (access app directly)
+  end
+end
+```
+
+**Files to change:**
+- `lib/create_ruby_app/actions/create_directories.rb`
+- `lib/create_ruby_app/actions/make_script_executable.rb`
+- `lib/create_ruby_app/actions/install_gems.rb`
+
+**Why:** Less boilerplate, clearer intent.
+
+**Test:** Run all tests, ensure actions still work.
+
+**Note:** Keep `GenerateFiles` and `SetRubyImplementation` as-is for
+now (they have more complex state).
+
+---
+
+### Step 3.2: Extract gem formatting method
+**File:** `lib/create_ruby_app/actions/generate_files.rb`
+
+**Change:**
+```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
+```
+
+**Why:** Testable, readable.
+
+**Test:** Test `format_gems_for_gemfile` independently.
+
+---
+
+### Step 3.3: Make template constants private
+**File:** `lib/create_ruby_app/actions/generate_files.rb`
+
+**Change:**
+```ruby
+TRIM_MODE = "<>"
+TEMPLATES_DIR = "../templates"
+
+private_constant :TRIM_MODE, :TEMPLATES_DIR
+```
+
+**Why:** Better encapsulation.
+
+**Test:** Ensure constants still work internally.
+
+---
+
+### Step 3.4: Replace empty lambda with explicit method
+**File:** `lib/create_ruby_app/app.rb`
+
+**Change:**
+```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)
+  log_completion
+end
+
+private
+
+# ... existing methods ...
+
+def log_completion
+  logger.info("Happy hacking!")
+end
+```
+
+**Why:** Clear intent, no magic.
+
+**Test:** Run app, verify completion message still appears.
+
+---
+
+## Phase 4: Path Management (2-3 hours)
+
+Centralize path logic to reduce duplication.
+
+### Step 4.1: Add path helper methods to App
+**File:** `lib/create_ruby_app/app.rb`
+
+**Add these methods:**
+```ruby
+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_lib_dir
+  project_root.join("spec", "lib", name)
+end
+
+def file_path(relative_path)
+  project_root.join(relative_path)
+end
+```
+
+**Why:** DRY, single source of truth for paths.
+
+**Test:** Test each path method returns correct Pathname.
+
+---
+
+### Step 4.2: Update CreateDirectories to use path methods
+**File:** `lib/create_ruby_app/actions/create_directories.rb`
+
+**Change:**
+```ruby
+def self.call(app)
+  [
+    app.bin_dir,
+    app.lib_subdir,
+    app.spec_lib_dir
+  ].each(&FileUtils.method(:mkdir_p))
+end
+```
+
+**Why:** Uses centralized path logic.
+
+**Test:** Verify directories are still created correctly.
+
+---
+
+### Step 4.3: Update other actions to use path methods
+**Files:**
+- `lib/create_ruby_app/actions/make_script_executable.rb`:
+  ```ruby
+  def self.call(app)
+    FileUtils.chmod("+x", app.bin_script_path)
+  end
+  ```
+
+- `lib/create_ruby_app/actions/generate_files.rb`:
+  ```ruby
+  def create_file(path:, content:)
+    File.write(app.file_path(path), content)
+  end
+  ```
+
+- `lib/create_ruby_app/actions/install_gems.rb`:
+  ```ruby
+  def self.call(app)
+    Dir.chdir(app.project_root) do
+      # ... rest
+    end
+  end
+  ```
+
+**Why:** Consistent path handling.
+
+**Test:** Integration test - create full app, verify structure.
+
+---
+
+## Phase 5: Make SetRubyImplementation Pure (1-2 hours)
+
+Remove mutation while keeping it simple.
+
+### Step 5.1: Change SetRubyImplementation to return version
+**File:** `lib/create_ruby_app/actions/set_ruby_implementation.rb`
+
+**Change:**
+```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
+```
+
+**Why:** Pure function, no side effects.
+
+**Test:** Update tests to expect version string, not app object.
+
+---
+
+### Step 5.2: Update App#run! to handle version
+**File:** `lib/create_ruby_app/app.rb`
+
+**Change:**
+```ruby
+def run!
+  with_logger("Creating directories...", Actions::CreateDirectories)
+
+  unless @version
+    @version = with_logger(
+      "Setting Ruby implementations...",
+      Actions::SetRubyImplementation
+    )
+  end
+
+  with_logger("Generating files...", Actions::GenerateFiles)
+  with_logger("Making script executable...", Actions::MakeScriptExecutable)
+  with_logger("Installing gems...", Actions::InstallGems)
+  log_completion
+end
+
+private
+
+def with_logger(text, action)
+  logger.info(text)
+  action.call(self)
+end
+```
+
+**Why:** Explicit state management.
+
+**Test:** Ensure version is set correctly, rest of flow works.
+
+---
+
+## Phase 6: Test Coverage (3-4 hours)
+
+Bring coverage from 64.71% to 90%.
+
+### Step 6.1: Add error handling tests
+Add tests for:
+- `InstallGems` failure scenarios
+- `CreateDirectories` permission errors
+- `SetRubyImplementation` no Ruby found (already exists)
+
+### Step 6.2: Add integration tests
+Add tests for:
+- CLI.call integration
+- Full app creation with various options
+
+### Step 6.3: Extract test helpers
+**File:** `spec/support/ruby_implementation_stubber.rb`
+
+```ruby
+module RubyImplementationStubber
+  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
+end
+```
+
+**File:** `spec/spec_helper.rb` - Add:
+```ruby
+require "support/ruby_implementation_stubber"
+
+RSpec.configure do |config|
+  config.include RubyImplementationStubber
+end
+```
+
+**Why:** DRY in tests.
+
+---
+
+## What We're NOT Doing (and Why)
+
+### ❌ Action Pipeline Pattern
+**Reason:** Over-engineering for 5 actions. Current approach is fine.
+
+### ❌ Value Objects (AppName, RubyVersion)
+**Reason:** Primitive obsession isn't a problem at this scale. String
+works fine.
+
+### ❌ Context Object / Dependency Injection
+**Reason:** Actions accessing `app` directly is simple and clear for
+this size.
+
+### ❌ Result Objects / Monads
+**Reason:** Exceptions work well here. Don't need dry-monads complexity.
+
+### ❌ Separate TemplateRenderer Class
+**Reason:** `GenerateFiles` is manageable as-is. Splitting adds little
+value.
+
+### ❌ Decorator Pattern for Logging
+**Reason:** `with_logger` method is simple and works. No need to
+complicate.
+
+---
+
+## Summary
+
+**Total Time:** ~12-15 hours of focused work
+**Total Changes:** ~200-300 lines of code
+**Risk Level:** Low (each phase is independently tested)
+
+### What This Achieves:
+✅ Ruby 3.5+ compatibility
+✅ Consistent error handling
+✅ Reduced boilerplate
+✅ Better path management (DRY)
+✅ Pure functions (SetRubyImplementation)
+✅ 90% test coverage
+✅ Cleaner, more maintainable code
+
+### What This Avoids:
+❌ Over-abstraction
+❌ Unnecessary complexity
+❌ Breaking changes
+❌ Framework-level refactoring
+
+---
+
+## Execution Order
+
+1. **Phase 1** (Quick Wins) - Do first, builds confidence
+2. **Phase 2** (Error Handling) - Important safety improvement
+3. **Phase 3** (Code Quality) - Makes codebase nicer to work with
+4. **Phase 4** (Path Management) - Biggest DRY improvement
+5. **Phase 5** (Pure Functions) - Core principle improvement
+6. **Phase 6** (Test Coverage) - Lock in all changes
+
+Each phase can be done independently and committed separately. You can
+stop after any phase and still have a better codebase.

data/bin/create-ruby-app

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
 
-# frozen_string_literal: true
-
 require_relative "../lib/create_ruby_app"
 
-CreateRubyApp::CLI.start
+CreateRubyApp::CLI.call

data/lib/create_ruby_app/actions/create_directories.rb

@@ -1,18 +1,26 @@
-# frozen_string_literal: true
-
 require "fileutils"
 require "pathname"
 
 module CreateRubyApp
   module Actions
     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
   end
 end

data/lib/create_ruby_app/actions/generate_files.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "erb"
 require "pathname"
 
@@ -38,7 +36,12 @@ module CreateRubyApp
       end
 
       def gemfile
-        generate_file(file: "Gemfile.erb", locals: { gems: app.gems.sort })
+        generate_file(file: "Gemfile.erb", locals: {
+          gems: app
+            .gems
+            .sort
+            .map {|gem| "gem \"#{gem}\"" }.join("\n")
+        })
       end
 
       private
@@ -46,7 +49,7 @@ module CreateRubyApp
       attr_reader :app
 
       def generate_files
-        files.each {|path, content| create_file(path: path, content: content) }
+        files.each { |path, content| create_file(path: path, content: content) }
       end
 
       def create_file(path:, content:)

data/lib/create_ruby_app/actions/install_gems.rb

@@ -1,11 +1,19 @@
-# frozen_string_literal: true
-
 module CreateRubyApp
   module Actions
     class InstallGems
+      def initialize(app)
+        @app = app
+      end
+
       def self.call(app)
+        new(app).call
+      end
+
+      def call
         Dir.chdir(app.name) { system("bundle", "install") }
       end
+
+      attr_reader :app
     end
   end
 end