create-ruby-app 1.2.0 → 1.4.0

data/lib/create_ruby_app/actions/set_ruby_implementation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module CreateRubyApp
+  module Actions
+    class NoRubyImplementationFoundError < StandardError; end
+
+    class SetRubyImplementation
+      def initialize(app)
+        @app = app
+      end
+
+      def self.call(app)
+        new(app).call
+      end
+
+      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,
+              "No version of Ruby is found or provided"
+      end
+
+      def transform_output_to_ruby_version(output)
+        output.strip.split(" ")[0..1].join("-")
+      end
+
+      def fetch_ruby_implementation(ruby_implementation)
+        stdout, _stderr, status = Open3.capture3("#{ruby_implementation} -v")
+        [stdout, status]
+      end
+
+      RUBY_IMPLEMENTATIONS = %w[
+        ruby
+        truffleruby
+        jruby
+        mruby
+        rubinius
+      ].freeze
+
+      attr_accessor :app
+    end
+  end
+end

data/lib/create_ruby_app/app.rb

@@ -7,8 +7,8 @@ module CreateRubyApp
     def initialize(
       name: "app",
       gems: [],
-      version: RUBY_VERSION,
-      logger: Logger.new(STDOUT)
+      version: nil,
+      logger: Logger.new($stdout)
     )
       @name = name
       @gems = gems
@@ -18,19 +18,22 @@ module CreateRubyApp
 
     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!", Actions::NullAction)
+      with_logger("Happy hacking!", ->(_) {})
     end
 
     def classify_name
       name.split("_").collect(&:capitalize).join
     end
 
-    attr_reader :name, :gems, :version, :logger
-
-    RUBY_VERSION = "ruby-2.7.1"
+    attr_reader :name, :gems, :logger
+    attr_accessor :version
 
     private
 

data/lib/create_ruby_app/cli.rb

@@ -1,52 +1,71 @@
 # frozen_string_literal: true
 
-require "thor"
+require "dry/cli"
 
 module CreateRubyApp
-  class CLI < Thor
-    def self.exit_on_failure?
-      true
-    end
+  module Commands
+    extend Dry::CLI::Registry
+
+    class Version < Dry::CLI::Command
+      desc "Print the current version and exit"
 
-    desc "version", "Print the current version and exit"
-    map %w[--version -v] => :version
-    def version
-      say VERSION
+      def call(*)
+        puts VERSION
+      end
     end
 
-    desc "new [NAME] [--ruby RUBY] [--gems GEMS]", "Generate new app"
-    long_desc <<~DESC
-      `create-ruby-app new NAME` will generate an app with the provided name.
-
-      Examples:
-        \x5$ create-ruby-app new my_app
-        \x5$ create-ruby-app new -g sinatra,sequel -r ruby-2.6.0 web_app
-        \x5$ create-ruby-app new --ruby jruby-2.9.6.0 my_app
-    DESC
-    method_option(
-      :ruby,
-      aliases: "-r",
-      desc: "Specify which Ruby version to use for the project",
-      default: App::RUBY_VERSION
-    )
-    method_option(
-      :gems,
-      aliases: "-g",
-      desc: "Specify which gems to add to the project",
-      default: ""
-    )
-    def new(name)
-      App.new(
-        name: replace_dashes_with_underscores(name),
-        gems: options[:gems].split(","),
-        version: options[:ruby]
-      ).run!
+    class New < Dry::CLI::Command
+      desc "Generate new Ruby application"
+
+      argument :name, required: true, desc: "Application name"
+
+      option(
+        :ruby,
+        aliases: ["-r"],
+        desc: "Specify which Ruby version to use for the project"
+      )
+      option(
+        :gems,
+        aliases: ["-g"],
+        desc: "Specify which gems to add to the project",
+        default: ""
+      )
+
+      example [
+        "my_app",
+        "-r ruby-3.4.5 my_app",
+        "-g sinatra,sequel web_app",
+        "--ruby jruby-2.9.6.0 --gems rspec,pry api_service"
+      ]
+
+      def call(name:, **options)
+        App.new(
+          name: replace_dashes_with_underscores(name),
+          gems: parse_gems(options[:gems]),
+          version: options[:ruby]
+        ).run!
+      end
+
+      private
+
+      def replace_dashes_with_underscores(name)
+        name.tr("-", "_")
+      end
+
+      def parse_gems(gems_string)
+        return [] if gems_string.nil? || gems_string.strip.empty?
+
+        gems_string.split(",").map(&:strip).reject(&:empty?)
+      end
     end
 
-    private
+    register "version", Version, aliases: ["--version", "-v"]
+    register "new", New
+  end
 
-    def replace_dashes_with_underscores(name)
-      name.tr("-", "_")
+  class CLI
+    def self.call
+      Dry::CLI.new(Commands).call
     end
   end
 end

data/lib/create_ruby_app/templates/Gemfile.erb

@@ -7,6 +7,6 @@ group :test, :development do
 end
 <% unless locals[:gems].empty? %>
 
-<%= locals[:gems].map {|gem| "gem \"#{gem}\"" }.join("\n") %>
+<%= locals[:gems] %>
 
 <% end %>

data/lib/create_ruby_app/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CreateRubyApp
-  VERSION = "1.2.0"
+  VERSION = "1.4.0"
 end

data/lib/create_ruby_app.rb

@@ -7,7 +7,7 @@ require_relative "create_ruby_app/actions/create_directories"
 require_relative "create_ruby_app/actions/generate_files"
 require_relative "create_ruby_app/actions/install_gems"
 require_relative "create_ruby_app/actions/make_script_executable"
-require_relative "create_ruby_app/actions/null_action"
+require_relative "create_ruby_app/actions/set_ruby_implementation"
 
 module CreateRubyApp
   class CreateRubyApp

data/spec/integration/app_creation_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+require "tmpdir"
+require "fileutils"
+
+RSpec.describe "App creation" do
+  let(:temp_dir) { Dir.mktmpdir }
+  let(:original_dir) { Dir.pwd }
+
+  around do |example|
+    Dir.chdir(original_dir)
+    Dir.chdir(temp_dir) do
+      example.run
+    end
+
+    FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+  end
+
+  describe "creating an app with just a name" do
+    let(:app_name) { "test_app" }
+    let(:app) do
+      CreateRubyApp::App.new(
+        name: app_name,
+        gems: [],
+        version: nil,
+        logger: Logger.new(IO::NULL)
+      )
+    end
+
+    it "creates a complete app structure with the detected Ruby version" do
+      app.run!
+
+      # Check directory structure
+      expect(Dir.exist?(app_name)).to be(true)
+      expect(Dir.exist?("#{app_name}/bin")).to be(true)
+      expect(Dir.exist?("#{app_name}/lib")).to be(true)
+      expect(Dir.exist?("#{app_name}/spec")).to be(true)
+
+      # Check if main files exist
+      expect(File.exist?("#{app_name}/Gemfile")).to be(true)
+      expect(File.exist?("#{app_name}/.ruby-version")).to be(true)
+      expect(File.exist?("#{app_name}/lib/#{app_name}.rb")).to be(true)
+      expect(File.exist?("#{app_name}/bin/#{app_name}")).to be(true)
+      expect(File.exist?("#{app_name}/spec/spec_helper.rb")).to be(true)
+
+      # Check that a Ruby version was detected and set
+      expect(app.version).to match(
+        /^(ruby|jruby|truffleruby|mruby|rubinius)-\d+\.\d+/
+      )
+
+      # Check that the `.ruby-version` file contains the detected version
+      ruby_version_content = File.read("#{app_name}/.ruby-version")
+      expect(ruby_version_content.strip).to eq(app.version)
+
+      # Check if the main library file has the correct module and
+      # class structure
+      lib_content = File.read("#{app_name}/lib/#{app_name}.rb")
+      expect(lib_content).to include("module TestApp")
+      expect(lib_content).to include("class TestApp")
+
+      # Check if `spec_helper.rb` references the app correctly
+      spec_helper_content = File.read("#{app_name}/spec/spec_helper.rb")
+      expect(spec_helper_content).to include(
+        "require_relative \"../lib/#{app_name}\""
+      )
+
+      # Check that the executable script exists and is executable
+      expect(File.executable?("#{app_name}/bin/#{app_name}")).to be(true)
+
+      # Check that `Gemfile` has a basic structure
+      gemfile_content = File.read("#{app_name}/Gemfile")
+      expect(gemfile_content).to include('source "https://rubygems.org"')
+    end
+  end
+
+  describe "creating an app with a specified Ruby version" do
+    let(:app_name) { "custom_app" }
+    let(:specified_version) { "ruby-3.1.0" }
+    let(:app) do
+      CreateRubyApp::App.new(
+        name: app_name,
+        gems: %w[rspec pry],
+        version: specified_version,
+        logger: Logger.new(IO::NULL)
+      )
+    end
+
+    it "creates the app structure with the specified Ruby version and gems" do
+      app.run!
+
+      # Check directory structure
+      expect(Dir.exist?(app_name)).to be(true)
+      expect(Dir.exist?("#{app_name}/bin")).to be(true)
+      expect(Dir.exist?("#{app_name}/lib")).to be(true)
+      expect(Dir.exist?("#{app_name}/spec")).to be(true)
+
+      # Check that the version remains as specified
+      expect(app.version).to eq(specified_version)
+
+      # Check that the `.ruby-version` file contains the specified version
+      ruby_version_content = File.read("#{app_name}/.ruby-version")
+      expect(ruby_version_content.strip).to eq(specified_version)
+
+      # Check if `Gemfile` includes the specified gems
+      gemfile_content = File.read("#{app_name}/Gemfile")
+      expect(gemfile_content).to include('source "https://rubygems.org"')
+      expect(gemfile_content).to include('gem "pry"')
+      expect(gemfile_content).to include('gem "rspec"')
+
+      # Check if the main library file has the correct module and
+      # class structure
+      lib_content = File.read("#{app_name}/lib/#{app_name}.rb")
+      expect(lib_content).to include("module CustomApp")
+      expect(lib_content).to include("class CustomApp")
+    end
+  end
+
+  describe "creating an app with dashes in name" do
+    let(:app_name) { "my-cool-app" }
+    let(:normalized_name) { "my_cool_app" }
+    let(:app) do
+      CreateRubyApp::App.new(
+        name: normalized_name,
+        gems: [],
+        version: "ruby-3.2.0",
+        logger: Logger.new(IO::NULL)
+      )
+    end
+
+    it "normalizes the name correctly in files and classes" do
+      app.run!
+
+      # Check if the directory uses the normalized name
+      expect(Dir.exist?(normalized_name)).to be true
+
+      # Check if the main library file has the correct class name
+      lib_content = File.read("#{normalized_name}/lib/#{normalized_name}.rb")
+      expect(lib_content).to include("module MyCoolApp")
+      expect(lib_content).to include("class MyCoolApp")
+
+      # Check if `spec_helper.rb` references the correct file
+      spec_helper_content = File.read("#{normalized_name}/spec/spec_helper.rb")
+      expect(spec_helper_content).to include("require_relative \"../lib/#{normalized_name}\"")
+    end
+  end
+
+  describe "error handling" do
+    let(:app_name) { "error_test_app" }
+
+    it "raises an appropriate error when no Ruby implementation is found" do
+      app = CreateRubyApp::App.new(
+        name: app_name,
+        gems: [],
+        version: nil,
+        logger: Logger.new(IO::NULL)
+      )
+
+      # Mock all Ruby implementations to fail
+      %w[ruby truffleruby jruby mruby rubinius].each do |impl|
+        allow(Open3).to receive(:capture3).with("#{impl} -v").and_return(
+          ["", "", instance_double(Process::Status, success?: false)]
+        )
+      end
+
+      expect { app.run! }.to raise_error(
+        CreateRubyApp::Actions::NoRubyImplementationFoundError,
+        "No version of Ruby is found or provided"
+      )
+    end
+  end
+end

data/spec/lib/create_ruby_app/actions/create_directories_spec.rb

@@ -4,7 +4,7 @@ require_relative "../../../spec_helper"
 
 RSpec.describe CreateRubyApp::Actions::CreateDirectories do
   describe ".call" do
-    let(:app) { instance_double("app", name: "foo_bar") }
+    let(:app) { instance_double(CreateRubyApp::App, name: "foo_bar") }
     let(:action) { described_class }
 
     it "creates the directories" do

data/spec/lib/create_ruby_app/actions/generate_files_spec.rb

@@ -5,7 +5,7 @@ require_relative "../../../spec_helper"
 RSpec.describe CreateRubyApp::Actions::GenerateFiles do
   describe "#generate_gemfile" do
     context "when no additional gems are added" do
-      let(:app) { instance_double("app", gems: []) }
+      let(:app) { instance_double(CreateRubyApp::App, gems: []) }
       let(:action) { described_class.new(app) }
       let(:gemfile) do
         <<~GEMFILE
@@ -25,7 +25,9 @@ RSpec.describe CreateRubyApp::Actions::GenerateFiles do
     end
 
     context "when additional gems are added" do
-      let(:app) { instance_double("app", gems: %w[sinatra sqlite]) }
+      let(:app) do
+        instance_double(CreateRubyApp::App, gems: %w[sinatra sqlite])
+      end
       let(:action) { described_class.new(app) }
       let(:gemfile) do
         <<~GEMFILE
@@ -51,7 +53,10 @@ RSpec.describe CreateRubyApp::Actions::GenerateFiles do
   describe "#generate_ruby_version_file" do
     context "when no version is specified" do
       let(:app) do
-        instance_double("app", version: CreateRubyApp::App::RUBY_VERSION)
+        instance_double(
+          CreateRubyApp::App,
+          version: "ruby-2.7.1"
+        )
       end
       let(:action) { described_class.new(app) }
 
@@ -59,7 +64,7 @@ RSpec.describe CreateRubyApp::Actions::GenerateFiles do
     end
 
     context "when a version is specified" do
-      let(:app) { instance_double("app", version: "ruby-2.5.0") }
+      let(:app) { instance_double(CreateRubyApp::App, version: "ruby-2.5.0") }
       let(:action) { described_class.new(app) }
 
       it { expect(action.ruby_version_file).to eq("ruby-2.5.0") }
@@ -68,7 +73,7 @@ RSpec.describe CreateRubyApp::Actions::GenerateFiles do
 
   describe "#generate_lib_file" do
     context "when generating a lib file" do
-      let(:app) { instance_double("app") }
+      let(:app) { instance_double(CreateRubyApp::App) }
       let(:action) { described_class.new(app) }
       let(:lib_file) do
         <<~LIB_FILE
@@ -91,7 +96,7 @@ RSpec.describe CreateRubyApp::Actions::GenerateFiles do
 
   describe "#generate_spec_helper_file" do
     context "when generating a spec helper file" do
-      let(:app) { instance_double("app", name: "this_is_an_app") }
+      let(:app) { instance_double(CreateRubyApp::App, name: "this_is_an_app") }
       let(:action) { described_class.new(app) }
       let(:spec_helper) do
         <<~SPEC_HELPER
@@ -118,7 +123,7 @@ RSpec.describe CreateRubyApp::Actions::GenerateFiles do
 
   describe "#generate_script_file" do
     context "when generating an executable script file" do
-      let(:app) { instance_double("app") }
+      let(:app) { instance_double(CreateRubyApp::App) }
       let(:action) { described_class.new(app) }
       let(:script_file) do
         <<~SCRIPT_FILE

data/spec/lib/create_ruby_app/actions/install_gems_spec.rb

@@ -4,7 +4,7 @@ require_relative "../../../spec_helper"
 
 RSpec.describe CreateRubyApp::Actions::InstallGems do
   describe ".call" do
-    let(:app) { instance_double("app", name: "foo_bar") }
+    let(:app) { instance_double(CreateRubyApp::App, name: "foo_bar") }
     let(:action) { described_class }
 
     it "installs the gems" do

data/spec/lib/create_ruby_app/actions/make_script_executable_spec.rb

@@ -4,7 +4,7 @@ require_relative "../../../spec_helper"
 
 RSpec.describe CreateRubyApp::Actions::MakeScriptExecutable do
   describe ".call" do
-    let(:app) { instance_double("app", name: "foo_bar") }
+    let(:app) { instance_double(CreateRubyApp::App, name: "foo_bar") }
     let(:action) { described_class }
 
     it "creates the directories" do