stable-cli-rails 0.7.11 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe9114ae5eae07811ec911b967cef33620ebf62c7df4f30c202f3743f7d6bea5
-  data.tar.gz: 91920b483e2c26e58d1ef7ca7c786ea5cf91a4849ac16ec276fee4cdbf72d878
+  metadata.gz: ab8c647151029030baf0e96737f45f20cc6b067b952b032b98eac46e5e14e158
+  data.tar.gz: 5db558cabc869e1f6d6684d26b1d7b08178679194d09ebdbbd42aa67d828aee7
 SHA512:
-  metadata.gz: dbdc4b736300bd5a395f67b9138e3aa7410a0184d4f5ea2be6f5e3445934fcf57588b526e5b957ee0c551247ab3013febd29eaffd96cc7bde43f982df91e3b53
-  data.tar.gz: 19e8dd338cd34dd6621159785171c970468d43b0f423048c4c3fc10bd4ab4851cedd59091a03e1748acf990fa1853a7b1da33bbadba552bae186a71a69799f3e
+  metadata.gz: fe68968ac73be6725262a224ceda502eaee576c2aa3a8822a2742577e9f5d6fc05f1c3092c6f7f1c0f011218aaa851949863e3473e8ea95de9e6fd91b94f31dc
+  data.tar.gz: e333ac1da62ceb50a7a77ec83d1c145900f90b8888249c4307102bc1dfb0e3661e0bf97c1efe5a33be27b1aa409e639278ca91643989c3c2c0954d763c665533

data/lib/stable/bootstrap.rb

@@ -3,6 +3,7 @@
 require 'fileutils'
 
 module Stable
+  # Bootstrap utilities for setting up Stable environment
   module Bootstrap
     def self.run!
       FileUtils.mkdir_p(Paths.root)

data/lib/stable/cli.rb

@@ -9,12 +9,12 @@ require_relative 'scanner'
 require_relative 'registry'
 
 module Stable
+  # Main CLI class for the Stable command-line interface
   class CLI < Thor
     def initialize(*)
       super
       Stable::Bootstrap.run!
       Services::SetupRunner.ensure_dependencies!
-      dedupe_registry!
     end
 
     def self.exit_on_failure?
@@ -29,6 +29,7 @@ module Stable
     method_option :db, type: :string, desc: 'Database name to create and integrate'
     method_option :postgres, type: :boolean, default: false, desc: 'Use Postgres for the database'
     method_option :mysql, type: :boolean, default: false, desc: 'Use MySQL for the database'
+    method_option :full, type: :boolean, default: false, desc: 'Setup full Rails app common generators'
     def new(name, ruby: RUBY_VERSION, rails: nil, port: nil)
       safe_name = Validators::AppName.call!(name)
       Commands::New.new(safe_name, options).call
@@ -157,9 +158,5 @@ module Stable
     def port_in_use?(port)
       system("lsof -i tcp:#{port} > /dev/null 2>&1")
     end
-
-    def dedupe_registry!
-      Services::AppRegistry.dedupe
-    end
   end
 end

data/lib/stable/commands/doctor.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # Doctor command - checks system health and dependencies
     class Doctor
       def call
         puts 'Running Stable health checks...'

data/lib/stable/commands/list.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # List command - displays all registered applications
     class List
       def call
         apps = Services::AppRegistry.all
@@ -34,12 +35,12 @@ module Stable
           end
 
         format(
-          '%-18s %-26s %-8s %-10s %-10s',
-          app[:name],
-          app[:domain],
-          app[:port],
-          app[:ruby],
-          status
+          '%<name>-18s %<domain>-26s %<port>-8s %<ruby>-10s %<status>-10s',
+          name: app[:name],
+          domain: app[:domain],
+          port: app[:port],
+          ruby: app[:ruby],
+          status: status
         )
       end
     end

data/lib/stable/commands/new.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # New command - creates a new Rails application
     class New
       def initialize(name, options)
         @name = name

data/lib/stable/commands/remove.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # Remove command - removes a Rails application
     class Remove
       def initialize(name)
         @name = name

data/lib/stable/commands/restart.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # Restart command - restarts a Rails application
     class Restart
       def initialize(name)
         @name = name

data/lib/stable/commands/setup.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # Setup command - initializes Stable environment
     class Setup
       def call
         Services::SetupRunner.new.call

data/lib/stable/commands/start.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # Start command - starts a Rails application
     class Start
       def initialize(name)
         @name = name

data/lib/stable/commands/stop.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Commands
+    # Stop command - stops a Rails application
     class Stop
       def initialize(name)
         @name = name

data/lib/stable/db_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Stable
+  # Database management utilities for Rails applications
   class DBManager
     attr_reader :name, :adapter
 
@@ -101,16 +102,30 @@ module Stable
       )) or abort('Failed to repair MySQL root authentication')
     end
 
-    # Detect MySQL socket on macOS / Linux
+    # Detect MySQL socket on macOS / Linux / Windows
     def mysql_socket
-      paths = [
-        '/opt/homebrew/var/mysql/mysql.sock', # Homebrew macOS
-        '/tmp/mysql.sock',                    # Default
-        '/var/run/mysqld/mysqld.sock' # Linux default
-      ]
+      platform = RUBY_PLATFORM
+
+      paths = case platform
+              when /darwin/ # macOS
+                [
+                  '/opt/homebrew/var/mysql/mysql.sock', # Homebrew macOS
+                  '/tmp/mysql.sock'                     # Fallback
+                ]
+              when /linux/
+                [
+                  '/var/run/mysqld/mysqld.sock', # Linux default
+                  '/tmp/mysql.sock' # Fallback
+                ]
+              when /mingw|mswin|win32/ # Windows
+                # Windows typically uses TCP connections, not sockets
+                return nil
+              else
+                ['/tmp/mysql.sock'] # Generic fallback
+              end
 
       paths.each { |p| return p if File.exist?(p) }
-      abort 'MySQL socket not found. Is MySQL running?'
+      abort 'MySQL socket not found. Is MySQL running? (On Windows, ensure MySQL is configured for TCP connections)'
     end
 
     # Default Rails DB user

data/lib/stable/paths.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 module Stable
+  # Path utilities for Stable configuration and data directories
   module Paths
     def self.root
-      File.expand_path('~/StableCaddy')
+      ENV['STABLE_TEST_ROOT'] || File.expand_path('~/StableCaddy')
     end
 
     def self.caddy_dir
@@ -21,5 +22,13 @@ module Stable
     def self.apps_file
       File.join(root, 'apps.yml')
     end
+
+    def self.projects_dir
+      File.join(root, 'projects')
+    end
+
+    def self.app_config_file(app_name)
+      File.join(projects_dir, app_name, "#{app_name}.yml")
+    end
   end
 end

data/lib/stable/registry.rb

@@ -4,17 +4,39 @@ require 'yaml'
 require 'fileutils'
 
 module Stable
+  # Application registry for managing Rails app configurations
   class Registry
-    def self.file_path
-      Stable::Paths.apps_file
-    end
+    def self.apps
+      apps = []
+
+      # Read legacy apps.yml file for backward compatibility
+      legacy_file = Stable::Paths.apps_file
+      if File.exist?(legacy_file)
+        legacy_apps = load_legacy_apps(legacy_file)
+        apps.concat(legacy_apps)
+      end
+
+      # Read individual app config files from projects directory
+      projects_dir = Stable::Paths.projects_dir
+      if Dir.exist?(projects_dir)
+        Dir.glob(File.join(projects_dir, '*/')).each do |app_dir|
+          app_name = File.basename(app_dir)
+          config_file = Stable::Paths.app_config_file(app_name)
+
+          next unless File.exist?(config_file)
 
-    def self.save(apps)
-      FileUtils.mkdir_p(Stable.root)
-      File.write(file_path, apps.to_yaml)
+          # Skip if we already have this app from legacy file
+          next if apps.any? { |app| app[:name] == app_name }
+
+          app_config = load_app_config(app_name)
+          apps << app_config if app_config
+        end
+      end
+
+      apps
     end
 
-    def self.apps
+    def self.load_legacy_apps(file_path)
       return [] unless File.exist?(file_path)
 
       data = YAML.load_file(file_path) || []
@@ -27,5 +49,33 @@ module Stable
         end
       end
     end
+
+    def self.save_app_config(app_name, config)
+      config_file = Stable::Paths.app_config_file(app_name)
+      FileUtils.mkdir_p(File.dirname(config_file))
+      File.write(config_file, config.to_yaml)
+    end
+
+    def self.load_app_config(app_name)
+      config_file = Stable::Paths.app_config_file(app_name)
+      return nil unless File.exist?(config_file)
+
+      parse_config_file(config_file)
+    end
+
+    def self.remove_app_config(app_name)
+      config_file = Stable::Paths.app_config_file(app_name)
+      FileUtils.rm_f(config_file)
+    end
+
+    def self.parse_config_file(config_file)
+      data = YAML.load_file(config_file)
+      return nil unless data.is_a?(Hash)
+
+      data.each_with_object({}) do |(k, v), memo|
+        key = k.is_a?(String) ? k.to_sym : k
+        memo[key] = v
+      end
+    end
   end
 end

data/lib/stable/scanner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Stable
+  # Scanner utility for application discovery and management
   class Scanner
     def self.run
       Registry.save([])

data/lib/stable/services/app_creator.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Service for creating new Rails applications
     class AppCreator
       def initialize(name, options)
         @name = name
@@ -11,59 +12,58 @@ module Stable
       def call
         ruby = @options[:ruby] || RUBY_VERSION
         port = @options[:port] || next_free_port
-        app_path = File.expand_path(@name)
+        app_path = File.join(Stable::Paths.projects_dir, @name)
         domain = "#{@name}.test"
 
-        # --- Register app in registry ---
-        Services::AppRegistry.add(name: @name, path: app_path, domain: domain, port: port, ruby: ruby, started_at: nil,
-                                  pid: nil)
+        # --- Check if app already exists ---
+        config_file = Stable::Paths.app_config_file(@name)
+        abort "App '#{@name}' already exists" if File.exist?(config_file)
 
-        abort "Folder already exists: #{app_path}" if File.exist?(app_path)
+        # --- Register app in registry ---
+        Services::AppRegistry.add(
+          name: @name, path: app_path, domain: domain, port: port,
+          ruby: ruby, started_at: nil, pid: nil
+        )
 
-        # --- Ensure Ruby + gemset ---
+        # --- Ensure Ruby version & RVM ---
         Ruby.ensure_version(ruby)
         Ruby.ensure_rvm!
-        System::Shell.run("bash -lc 'source #{Ruby.rvm_script} && rvm #{ruby}@#{@name} --create do true'")
+
+        # --- Create gemset ---
+        System::Shell.run("bash -lc 'source #{Ruby.rvm_script} && rvm #{ruby} do rvm gemset create #{@name} || true'")
 
         rvm_cmd = Ruby.rvm_prefix(ruby, @name)
 
-        # --- Install Rails into gemset if missing ---
-        rails_version = @options[:rails]
-        rails_check_cmd = if rails_version
-                            "#{rvm_cmd} gem list -i rails -v #{rails_version}"
-                          else
-                            "#{rvm_cmd} gem list -i rails"
-                          end
+        # --- Install Bundler ---
+        System::Shell.run("bash -lc '#{rvm_cmd} gem install bundler --no-document'")
 
+        # --- Install Rails if missing ---
+        rails_version = @options[:rails]
+        rails_check_cmd = rails_version ? "#{rvm_cmd} gem list -i rails -v #{rails_version}" : "#{rvm_cmd} gem list -i rails"
         unless system("bash -lc '#{rails_check_cmd}'")
-          puts "Installing Rails #{rails_version || 'latest'} in gemset..."
+          puts "Installing Rails #{rails_version || 'latest'}..."
           install_cmd = rails_version ? "#{rvm_cmd} gem install rails -v #{rails_version}" : "#{rvm_cmd} gem install rails"
-          system("bash -lc '#{install_cmd}'") or abort('Failed to install Rails')
+          system("bash -lc '#{install_cmd}'") or abort("Failed to install Rails #{rails_version || ''}")
         end
 
         # --- Create Rails app ---
         puts "Creating Rails app #{@name} (Ruby #{ruby})..."
-        System::Shell.run("bash -lc '#{rvm_cmd} rails new #{app_path}'")
+        rails_cmd = "#{rvm_cmd} rails new #{app_path} " \
+                    '--skip-importmap --skip-hotwire --skip-javascript --skip-solid'
+        System::Shell.run("bash -lc '#{rails_cmd}'")
 
-        # --- Write ruby version/gemset and bundle install inside gemset ---
+        # --- Write ruby version/gemset ---
         Dir.chdir(app_path) do
           File.write('.ruby-version', "#{ruby}\n")
           File.write('.ruby-gemset', "#{@name}\n")
-
-          puts 'Running bundle install...'
-          System::Shell.run("bash -lc '#{rvm_cmd} bundle install --jobs=4 --retry=3'")
         end
 
         # --- Database integration ---
         if @options[:db]
-          adapter = if @options[:mysql]
-                      :mysql
-                    else
-                      :postgresql
-                    end
-
+          adapter = @options[:mysql] ? :mysql : :postgresql
           gem_name = adapter == :postgresql ? 'pg' : 'mysql2'
           gemfile_path = File.join(app_path, 'Gemfile')
+
           unless File.read(gemfile_path).include?(gem_name)
             File.open(gemfile_path, 'a') do |f|
               f.puts "\n# Added by Stable CLI"
@@ -72,17 +72,86 @@ module Stable
             puts "✅ Added '#{gem_name}' gem to Gemfile"
           end
 
-          # ensure gem is installed inside gemset
-          System::Shell.run("bash -lc 'cd #{app_path} && #{rvm_cmd} bundle install --jobs=4 --retry=3'")
+          # Use correct Ruby/gemset for bundle install
+          System::Shell.run(rvm_run('bundle install --jobs=4 --retry=3', chdir: app_path))
 
-          # run adapter setup which will write database.yml and prepare
           db_adapter = adapter == :mysql ? Database::MySQL : Database::Postgres
-          db_adapter.new(app_name: @name, app_path: app_path).setup
+          db_adapter.new(app_name: @name, app_path: app_path, ruby: ruby).setup
+        end
+
+        # --- Run bundle & DB prepare ---
+        System::Shell.run(rvm_run('bundle install --jobs=4 --retry=3', chdir: app_path))
+        System::Shell.run(rvm_run('bundle exec rails db:prepare', chdir: app_path))
+
+        rails_check = "cd #{app_path} && #{rvm_cmd} bundle exec rails runner \"puts Rails.version\""
+        rails_version = `bash -lc '#{rails_check}'`.strip.to_f
+
+        begin
+          rails_ver = Gem::Version.new(rails_version)
+        rescue ArgumentError
+          rails_ver = Gem::Version.new('0.0.0')
+        end
+
+        # only if Rails >= 7
+        if rails_ver >= Gem::Version.new('7.0.0')
+          # Gems to re-add
+          optional_gems = {
+            'importmap-rails' => nil,
+            'turbo-rails' => nil,
+            'stimulus-rails' => nil,
+            'solid_cache' => nil,
+            'solid_queue' => nil,
+            'solid_cable' => nil
+          }
+
+          gemfile = File.join(app_path, 'Gemfile')
+
+          # Add gems if not already present
+          optional_gems.each do |gem_name, version|
+            next if File.read(gemfile).match?(/^gem ['"]#{gem_name}['"]/)
+
+            File.open(gemfile, 'a') do |f|
+              f.puts version ? "gem '#{gem_name}', '#{version}'" : "gem '#{gem_name}'"
+            end
+          end
+
+          # Install all new gems
+          System::Shell.run(rvm_run('bundle install', chdir: app_path))
+
+          # Run generators for installed gems
+          generators = [
+            'importmap:install',
+            'turbo:install stimulus:install',
+            'solid_cache:install solid_queue:install solid_cable:install'
+          ]
+
+          generators.each do |cmd|
+            System::Shell.run(rvm_run("bundle exec rails #{cmd}", chdir: app_path))
+          end
         end
 
-        # --- Refresh bundle and prepare DB (idempotent) ---
-        System::Shell.run("bash -lc 'cd #{app_path} && #{rvm_cmd} bundle check || #{rvm_cmd} bundle install'")
-        System::Shell.run("bash -lc 'cd #{app_path} && #{rvm_cmd} bundle exec rails db:prepare'")
+        # --- Add allowed host for Rails < 7.2 ---
+        if @options[:rails] && @options[:rails].to_f < 7.2
+          env_file = File.join(app_path, 'config/environments/development.rb')
+
+          if File.exist?(env_file)
+            content = File.read(env_file)
+
+            # Append host config inside the Rails.application.configure block
+            updated_content = content.gsub(/Rails\.application\.configure do(.*?)end/mm) do |_match|
+              inner = Regexp.last_match(1)
+              # Prevent duplicate entries
+              unless inner.include?(domain)
+                inner += "  # allow local .test host for this app\n  config.hosts << '#{domain}'\n"
+              end
+              "Rails.application.configure do#{inner}end"
+            end
+
+            File.write(env_file, updated_content)
+          else
+            warn "Development environment file not found: #{env_file}"
+          end
+        end
 
         # --- Hosts, certs, caddy ---
         Services::HostsManager.add(domain)
@@ -90,50 +159,31 @@ module Stable
         Services::CaddyManager.ensure_running!
         Services::CaddyManager.reload
 
-        # --- Start the app ---
+        # --- Start Rails server ---
         puts "Starting Rails server for #{@name} on port #{port}..."
         log_file = File.join(app_path, 'log', 'stable.log')
         FileUtils.mkdir_p(File.dirname(log_file))
 
         abort "Port #{port} is already in use. Choose another port." if port_in_use?(port)
 
-        pid = spawn('bash', '-lc', "cd \"#{app_path}\" && #{rvm_cmd} bundle exec rails s -p #{port} -b 127.0.0.1",
-                    out: log_file, err: log_file)
+        pid = spawn(
+          'bash', '-lc',
+          "cd \"#{app_path}\" && #{rvm_cmd} bundle exec rails s -p #{port} -b 127.0.0.1",
+          out: log_file, err: log_file
+        )
         Process.detach(pid)
-
         AppRegistry.update(@name, started_at: Time.now.to_i, pid: pid)
 
         sleep 1.5
         wait_for_port(port)
-        prefix = @options[:skip_ssl] ? 'http' : 'https'
-        display_domain = if @options[:skip_ssl]
-                           "#{domain}:#{port}"
-                         else
-                           domain
-                         end
 
+        prefix = @options[:skip_ssl] ? 'http' : 'https'
+        display_domain = @options[:skip_ssl] ? "#{domain}:#{port}" : domain
         puts "✔ #{@name} running at #{prefix}://#{display_domain}"
       end
 
       private
 
-      def create_rails_app
-        System::Shell.run("rails new #{@name}")
-      end
-
-      def setup_database
-        return unless @options[:mysql] || @options[:postgres]
-
-        adapter =
-          if @options[:mysql]
-            Database::MySQL
-          else
-            Database::Postgres
-          end
-
-        adapter.new(@name).setup
-      end
-
       def next_free_port
         used_ports = Services::AppRegistry.all.map { |a| a[:port] }
         port = 3000
@@ -158,6 +208,13 @@ module Stable
           sleep 0.5
         end
       end
+
+      def rvm_run(cmd, chdir: nil, ruby: nil)
+        ruby ||= @options[:ruby] || RUBY_VERSION
+        gemset = @name
+        cd = chdir ? "cd #{chdir} && " : ''
+        "bash -lc '#{cd}source #{Dir.home}/.rvm/scripts/rvm && rvm #{ruby}@#{gemset} do #{cmd}'"
+      end
     end
   end
 end

data/lib/stable/services/app_registry.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Application registry management service
     class AppRegistry
       class << self
         def all
@@ -42,32 +43,19 @@ module Stable
         end
 
         def add(app)
-          apps = Stable::Registry.apps
-          apps.reject! { |a| a[:name] == app[:name] }
-          apps << app
-          Stable::Registry.save(apps)
-        end
-
-        # Remove duplicate app entries (by name) and persist the canonical list
-        def dedupe
-          apps = Stable::Registry.apps
-          apps.uniq! { |a| a[:name] }
-          Stable::Registry.save(apps)
-          apps
+          Stable::Registry.save_app_config(app[:name], app)
         end
 
         def remove(name)
-          apps = Stable::Registry.apps.reject { |a| a[:name] == name }
-          Stable::Registry.save(apps)
+          Stable::Registry.remove_app_config(name)
         end
 
         def update(name, attrs)
-          apps = Stable::Registry.apps
-          idx = apps.index { |a| a[:name] == name }
-          return unless idx
+          app = find(name)
+          return unless app
 
-          apps[idx] = apps[idx].merge(attrs)
-          Stable::Registry.save(apps)
+          updated_app = app.merge(attrs)
+          Stable::Registry.save_app_config(name, updated_app)
         end
 
         def mark_stopped(name)

data/lib/stable/services/app_remover.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Service for removing Rails applications
     class AppRemover
       def initialize(name)
         @name = name

data/lib/stable/services/app_restarter.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Service for restarting Rails applications
     class AppRestarter
       def initialize(name)
         @name = name

data/lib/stable/services/app_starter.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Service for starting Rails applications
     class AppStarter
       def initialize(name)
         @name = name

data/lib/stable/services/app_stopper.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Service for stopping Rails applications
     class AppStopper
       def initialize(name)
         @app = AppRegistry.fetch(name)

data/lib/stable/services/caddy_manager.rb

@@ -2,6 +2,7 @@
 
 module Stable
   module Services
+    # Service for managing Caddy web server configuration
     class CaddyManager
       class << self
         def caddyfile