yamine 0.13.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f7c7127a262069469056cf55f94b5785de8e1890bc0814d84453159e1a01096
-  data.tar.gz: 0001bfbad73772c3caa7e615384a0c70dfa82732987174f55cbfbffac703dd15
+  metadata.gz: 43ea000326072db8f0173360b3ef58a6cce132e20f372b65f0e777bafbb97e9d
+  data.tar.gz: 3e878d2cae8afffd1dca255a006a5863e12dbd4471a4b6214656dda5bc97d37f
 SHA512:
-  metadata.gz: 702d9b80482ac8f541f16ab5946b8916b0c23750774e398eabe85cd940a5d39306bdc188e010065e17ecf91081feb79b94d021a24c71186978ba8d1e4ede7dba
-  data.tar.gz: f0f12d6cc5b32bcc46804ef3009a72ab4fac500f792b6d6ea39f05324857031b4cb0f06fe131ef291a61f2faf1d1fd87eb85520d6698b63a6a5b6dde394e637d
+  metadata.gz: 272dae53dfac6b0521c09c00ae096cdc10620dcabf8064a286a0fe25813a61738b3fefc4bb34cf8fdfdd8dd1467a0064ec4e8ceb6ec7b262a8ed638b66101bda
+  data.tar.gz: e16540d1830850c50a54451ec5f0bfb0ad87fd770b111a0b4276aad9a6916dadeeed4c106b61392e5fc5794e6276f003f718a5e53135885f36cc142944d1a12f

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.13.1] — 2026-09-12
+
+### Fixed
+
+- **`worktree clean` no longer reports "could not drop — remove manually"
+  for a database that never existed.** `dropdb` fails on a missing
+  database, and the old code collapsed that into a generic failure. Now
+  `Database.drop` returns an honest three-state outcome — `:dropped`,
+  `:missing` (nothing to drop, not an error), `:failed` (server
+  unreachable or drop refused) — by splitting "server reachable" from
+  "database present". Clean prints each outcome (`dropped N`,
+  `N did not exist — nothing to drop`) plus a summary line, exits 1 only
+  when something really failed, and **keeps the claim of a failed drop**
+  so the next clean can retry it (the old code deleted all claims
+  regardless, losing track of databases it failed to drop).
+- `db drop` and `db create` resolve the DATABASE_URL template the way
+  boot does (ENV, then config env.clear) instead of ENV-only, so they
+  work from a shell without the variable exported.
+
 ## [0.13.0] — 2026-09-11
 
 ### Changed

data/lib/yamine/cli/boot.rb

@@ -546,13 +546,7 @@ module Yamine
       end
 
       def database_template_from_config(resolved)
-        top = resolved.env.is_a?(Hash) ? resolved.env["clear"] : nil
-        from_top = top.is_a?(Hash) ? top["DATABASE_URL"] : nil
-        return from_top if from_top && !from_top.to_s.strip.empty?
-
-        env = resolved.processes.values.map { |e| e["env"] || {} }
-        clear = env.map { |e| e["clear"] || {} }.reduce({}, :merge)
-        clear["DATABASE_URL"]
+        Database.template_for(resolved)
       end
 
       # Schema-load on first boot uses the app's own command when declared

data/lib/yamine/cli/system.rb

@@ -893,9 +893,9 @@ module Yamine
         resolved = Resolver.resolve(Dir.pwd)
         name = Database.name_for(Dir.pwd, env: boot_env_name,
           state_dir: ctx.store.dir)
-        template = ENV["DATABASE_URL"]
+        template = drop_template
         unless template && !template.strip.empty?
-          $stderr.puts "Error: set DATABASE_URL (template with host/user; database segment is replaced)."
+          $stderr.puts "Error: no DATABASE_URL template found (ENV or env.clear in config/local.yml)."
           exit 1
         end
         if Database.ensure_exists(name, template)
@@ -917,38 +917,41 @@ module Yamine
           $stderr.puts "Error: worktree #{info["dir"]} still exists. Use --force to drop #{name} anyway."
           exit 1
         end
-        if drop_database(ctx, name)
+        template = drop_template
+        unless template && !template.strip.empty?
+          $stderr.puts "Error: no DATABASE_URL template found (ENV or env.clear in config/local.yml) — cannot reach the server to drop #{name}."
+          exit 1
+        end
+        case Database.drop(name, template)
+        when :dropped
           map.delete(name)
           Database.save_map(ctx.store.dir, map)
           puts "Dropped #{name}."
-        else
-          $stderr.puts "Error: could not drop #{name}."
+        when :missing
+          map.delete(name)
+          Database.save_map(ctx.store.dir, map)
+          puts "#{name} did not exist — nothing to drop (claim removed)."
+        when :failed
+          $stderr.puts "Error: could not drop #{name} — is the database server running? The claim is kept."
           exit 1
         end
       end
 
-      def drop_database(_ctx, name)
-        template = ENV["DATABASE_URL"]
-        return false unless template && !template.strip.empty?
+      # Template for reaching the database server outside of boot:
+      # ENV first, then the app's config (env.clear). Runs from the
+      # main checkout, so the config's own template is the usual source.
+      def drop_template
+        env = ENV["DATABASE_URL"]
+        return env if env && !env.strip.empty?
 
-        case Database.adapter_for(template)
-        when :postgres
-          uri = URI.parse(template)
-          _out, status = Open3.capture2("dropdb", name, env: Database.pg_env(uri))
-          status.success?
-        when :mysql
-          uri = URI.parse(template)
-          args = ["-h", uri.host || "127.0.0.1", "-u",
-                  URI.decode_www_form_component(uri.user || "root")]
-          _out, status = Open3.capture2("mysqladmin", *args, "drop", name, "-f")
-          status.success?
-        else
-          false
-        end
-      rescue SystemCallError
-        false
+        config = Config.load(Dir.pwd)
+        return nil unless config
+
+        Database.template_for(TemplateSource.new(config.env_config, config.processes))
       end
 
+      TemplateSource = Struct.new(:env, :processes)
+
       def boot_env_name
         ENV.fetch("RAILS_ENV", "development")
       end
@@ -974,16 +977,31 @@ module Yamine
             puts "No orphaned worktree databases."
             return
           end
+          template = drop_template
+          unless template && !template.strip.empty?
+            $stderr.puts "Error: no DATABASE_URL template found (ENV or env.clear in config/local.yml) — cannot drop the orphaned databases."
+            exit 1
+          end
+          dropped, missing, failed = [], [], []
           orphaned.each do |name, _info|
-            if drop_database(ctx, name)
-              puts "Dropped orphaned #{name}."
-            else
-              $stderr.puts "Could not drop #{name} — remove manually."
+            case Database.drop(name, template)
+            when :dropped then dropped << name
+            when :missing then missing << name
+            when :failed then failed << name
             end
           end
+          dropped.each { |n| puts "  dropped #{n}" }
+          missing.each { |n| puts "  #{n} did not exist — nothing to drop" }
+          failed.each { |n| warn "  could not drop #{n} — is the server running? Claim kept for a retry." }
+          # Forget only the claims we actually handled; a failed drop
+          # stays recorded so the next clean can retry it.
           map = Database.load_map(ctx.store.dir)
-          orphaned.each_key { |name| map.delete(name) }
+          (dropped + missing).each { |n| map.delete(n) }
           Database.save_map(ctx.store.dir, map)
+          summary = "Cleaned #{orphaned.length} orphaned claim(s): #{dropped.length} dropped, #{missing.length} already gone"
+          summary += ", #{failed.length} failed" if failed.any?
+          puts "#{summary}."
+          exit 1 if failed.any?
         else
           raise Error, "Usage: yamine worktree [list|clean]"
         end

data/lib/yamine/database.rb

@@ -100,6 +100,28 @@ module Yamine
       nil
     end
 
+    # The DATABASE_URL template per-worktree names derive from: ENV
+    # first, then the config's top-level env.clear, then per-process
+    # env.clear (configs written before top-level env existed). Shared
+    # by boot, `db create/drop`, and `worktree clean` so they all agree.
+    # Takes anything responding to .env (resolver Result / Config) —
+    # pass env_config for a bare Config.
+    def template_for(resolved)
+      source = if resolved.respond_to?(:env)
+        resolved.env
+      else
+        resolved.env_config
+      end
+      top = source.is_a?(Hash) ? source["clear"] : nil
+      from_top = top.is_a?(Hash) ? top["DATABASE_URL"] : nil
+      return from_top if from_top && !from_top.to_s.strip.empty?
+
+      processes = resolved.respond_to?(:processes) ? resolved.processes : {}
+      env = processes.values.map { |e| e["env"] || {} }
+      clear = env.map { |e| e["clear"] || {} }.reduce({}, :merge)
+      clear["DATABASE_URL"]
+    end
+
     # Databases whose worktree dirs no longer exist (for `worktree clean`).
     def orphaned(state_dir)
       load_map(state_dir).select { |_, v| !File.directory?(v["dir"]) }
@@ -146,6 +168,73 @@ module Yamine
       end
     end
 
+    # Drop a database with an honest outcome. Returns :dropped,
+    # :missing (the database did not exist — nothing to do, NOT an
+    # error), or :failed (server unreachable, drop refused). The
+    # distinction matters: `worktree clean` used to print "could not
+    # drop — remove manually" for a database that never existed,
+    # sending the user hunting for locks and permissions that were
+    # never the problem.
+    def drop(name, database_url)
+      case adapter_for(database_url)
+      when :postgres then pg_drop(name, database_url)
+      when :mysql then mysql_drop(name, database_url)
+      else :failed
+      end
+    end
+
+    def pg_drop(name, database_url)
+      reachable, exists = pg_state(name, database_url)
+      return :missing if reachable && !exists
+      return :failed unless reachable
+
+      uri = URI.parse(database_url)
+      _out, status = Open3.capture2("dropdb", name, env: pg_env(uri))
+      return :dropped if status.success?
+
+      reachable, exists = pg_state(name, database_url)
+      reachable && exists ? :failed : :dropped
+    rescue SystemCallError
+      :failed
+    end
+
+    def mysql_drop(name, database_url)
+      reachable, exists = mysql_state(name, database_url)
+      return :missing if reachable && !exists
+      return :failed unless reachable
+
+      uri = URI.parse(database_url)
+      _out, status = Open3.capture2("mysqladmin", *mysql_args(uri), "drop", name, "-f")
+      return :dropped if status.success?
+
+      reachable, exists = mysql_state(name, database_url)
+      reachable && exists ? :failed : :dropped
+    rescue SystemCallError
+      :failed
+    end
+
+    # [server_reachable, database_exists] — the split that lets drop
+    # tell "nothing to drop" apart from "could not reach the server".
+    def pg_state(name, database_url)
+      uri = URI.parse(database_url)
+      out, status = Open3.capture2(pg_env(uri), "psql", "-lqt")
+      return [false, false] unless status.success?
+
+      [true, out.split("\n").any? { |l| l.split("|").first.to_s.strip == name }]
+    rescue SystemCallError
+      [false, false]
+    end
+
+    def mysql_state(name, database_url)
+      uri = URI.parse(database_url)
+      out, status = Open3.capture2("mysql", *mysql_args(uri), "-e", "SHOW DATABASES;")
+      return [false, false] unless status.success?
+
+      [true, out.split("\n").include?(name)]
+    rescue SystemCallError
+      [false, false]
+    end
+
     # Create the database if missing. Uses createdb/mysqladmin when
     # available; returns true/false, never raises (boot reports, not dies).
     def ensure_exists(name, database_url)

data/lib/yamine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yamine
-  VERSION = "0.13.0"
+  VERSION = "0.13.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yamine
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.13.1
 platform: ruby
 authors:
 - Kaka Ruto