kamal-backup 0.1.0.pre.8 → 0.1.0.pre.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ed4e21bfee7ac0e789c3a0706626062055c92701128b5999a3828f5f3190057
-  data.tar.gz: 5983618fb0fb16db51cfa82f4ff28398c00568d7a5082fd494a7063c944b111d
+  metadata.gz: 5b0a9aca508a2247ae1f44ae5cb3eab3366dcb2f47c80681c67890e0ad60a2fd
+  data.tar.gz: 16208b98365aeccabd346cd5ba150797ecff0c98e86a8592b71c8c882af67c42
 SHA512:
-  metadata.gz: 227a34dc536cd9d5ca13cb2853fcac13c03c5defbe87e406374c1ebc7b94e7cc094693903aab1e7b6addb2b2a11913bae419767cb0e242f56d86818171bacb79
-  data.tar.gz: 16788fa7108df55c2afa70f900511ce6574c931be8459774649ebcb533c415873e4424d8172e0df987804f6509f4aea7fb398676cd3741ff0c59fddf6d7e9a74
+  metadata.gz: dd46bd886c0f59413ad0762aa4a252d9e3a6ed721bc54c53e2a81ba88b80a9da40272b52c19792817ffabd2a92903db00eab0aa2bdd0d63917745955e5c7ffc2
+  data.tar.gz: '057386894dadb84c3afbd73b6949ab749873df06c8470f32e32a02036b8facf195067cd8652d13dd920110aa95e14462c275586a1de7c92e8b32823dedb1cf77'

data/README.md

@@ -40,7 +40,7 @@ group :development do
 end
 ```
 
-Install it and generate the local config stubs:
+Install it and generate the shared config stub:
 
 ```sh
 bundle install
@@ -50,7 +50,14 @@ bundle exec kamal-backup init
 That creates:
 
 - `config/kamal-backup.yml`
-- `config/kamal-backup.local.yml`
+
+For most Rails apps, that is enough. `restore local` and `drill local` can infer:
+
+- the development database target from `config/database.yml`
+- the local files target from `storage`
+- the local drill state directory from `tmp/kamal-backup`
+
+Only create `config/kamal-backup.local.yml` if you need to override those local defaults.
 
 Then add the backup accessory to `config/deploy.yml`:
 
@@ -174,11 +181,17 @@ That shared `run:<timestamp>` tag lets you match the database backup and file ba
 - `RESTIC_REPOSITORY`
 - `LOCAL_RESTORE_SOURCE_PATHS` from the accessory `BACKUP_PATHS`
 
-You still provide the local targets yourself in `config/kamal-backup.local.yml` or env:
+For a normal Rails app, the local targets come from Rails conventions:
+
+- the development database in `config/database.yml`
+- `storage` as the local files target
+- `tmp/kamal-backup` as the local drill state directory
+
+You still provide the local secrets yourself in env:
 
-- `DATABASE_URL` or `SQLITE_DATABASE_PATH`
-- `BACKUP_PATHS`
-- local secrets such as `RESTIC_PASSWORD` and DB passwords
+- `RESTIC_PASSWORD`
+- `POSTGRES_PASSWORD` or `MYSQL_PWD` when needed
+- `RESTIC_REPOSITORY` when it is not visible through `kamal config`
 
 Example:
 
@@ -271,12 +284,12 @@ DATABASE_ADAPTER=sqlite
 SQLITE_DATABASE_PATH=/data/db/production.sqlite3
 ```
 
-Local config files:
+Optional local config files:
 
 - `config/kamal-backup.yml`
 - `config/kamal-backup.local.yml`
 
-Keep secrets such as `RESTIC_PASSWORD`, cloud credentials, and local DB passwords in environment variables, not in YAML files.
+`config/kamal-backup.local.yml` is only for nonstandard local targets. Keep secrets such as `RESTIC_PASSWORD`, cloud credentials, and local DB passwords in environment variables, not in YAML files.
 
 ## Docs
 

data/exe/kamal-backup

@@ -1,10 +1,15 @@
 #!/usr/bin/env ruby
 
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+root = File.expand_path("..", __dir__)
+gemfile = File.join(root, "Gemfile")
+libdir = File.join(root, "lib")
 
-require "bundler/setup"
+$LOAD_PATH.unshift(libdir) if File.directory?(libdir) && !$LOAD_PATH.include?(libdir)
 
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+if File.exist?(gemfile)
+  ENV["BUNDLE_GEMFILE"] ||= gemfile
+  require "bundler/setup"
+end
 
 require "kamal_backup"
 

data/lib/kamal_backup/cli.rb

@@ -97,10 +97,6 @@ module KamalBackup
         File.join(init_config_root, "kamal-backup.yml")
       end
 
-      def local_config_path
-        File.join(init_config_root, "kamal-backup.local.yml")
-      end
-
       def write_init_file(path, contents)
         if File.exist?(path)
           say "Exists: #{path}", :yellow
@@ -119,19 +115,6 @@ module KamalBackup
         YAML
       end
 
-      def local_config_template
-        <<~YAML
-          # Local machine targets for restore local and drill local.
-          # With -d/-c, APP_NAME, DATABASE_ADAPTER, RESTIC_REPOSITORY, and
-          # LOCAL_RESTORE_SOURCE_PATHS can come from your Kamal accessory config.
-          # Keep secrets such as RESTIC_PASSWORD and cloud credentials in env.
-          database_url: postgres://localhost/your_app_development
-          backup_paths:
-            - storage
-          state_dir: tmp/kamal-backup
-        YAML
-      end
-
       def deploy_snippet
         <<~YAML
           accessories:
@@ -339,12 +322,14 @@ module KamalBackup
     desc "init", "Create kamal-backup config stubs for local restore and drill commands"
     def init
       write_init_file(shared_config_path, shared_config_template)
-      write_init_file(local_config_path, local_config_template)
 
       puts
       puts "Add this accessory block to your Kamal deploy config:"
       puts
       puts deploy_snippet
+      puts
+      puts "For most Rails apps, restore local and drill local can infer the development database, storage path, and tmp state directory."
+      puts "Create config/kamal-backup.local.yml only if you need to override those local defaults."
     end
 
     desc "schedule", "Run the foreground scheduler loop"

data/lib/kamal_backup/config.rb

@@ -1,6 +1,7 @@
 require "uri"
 require "yaml"
 require_relative "errors"
+require_relative "rails_app"
 
 module KamalBackup
   class Config
@@ -46,7 +47,7 @@ module KamalBackup
 
     def initialize(env: ENV, cwd: Dir.pwd, defaults: {})
       raw_env = env.to_h
-      @env = defaults.to_h.merge(load_config_files(raw_env, cwd: cwd)).merge(raw_env)
+      @env = project_defaults(cwd: cwd).merge(defaults.to_h).merge(load_config_files(raw_env, cwd: cwd)).merge(raw_env)
     end
 
     def app_name
@@ -283,6 +284,10 @@ module KamalBackup
     end
 
     private
+      def project_defaults(cwd:)
+        RailsApp.new(cwd: cwd).defaults
+      end
+
       def load_config_files(raw_env, cwd:)
         config_paths(raw_env, cwd: cwd).each_with_object({}) do |path, merged|
           next unless File.file?(path)

data/lib/kamal_backup/rails_app.rb

@@ -0,0 +1,152 @@
+require "erb"
+require "uri"
+require "yaml"
+
+module KamalBackup
+  class RailsApp
+    DEVELOPMENT_ENV = "development"
+
+    def initialize(cwd:)
+      @cwd = File.expand_path(cwd)
+    end
+
+    def defaults
+      return {} unless rails_app?
+
+      {}.tap do |defaults|
+        defaults.merge!(deploy_defaults)
+        defaults.merge!(database_defaults)
+
+        if local_storage_path
+          defaults["BACKUP_PATHS"] = local_storage_path
+        end
+
+        defaults["KAMAL_BACKUP_STATE_DIR"] = File.join(@cwd, "tmp", "kamal-backup")
+      end
+    end
+
+    private
+      def rails_app?
+        File.file?(database_config_path)
+      end
+
+      def deploy_defaults
+        service = fetch(parsed_yaml(deploy_config_path), :service)
+
+        if service
+          { "APP_NAME" => service.to_s }
+        else
+          {}
+        end
+      end
+
+      def database_defaults
+        config = local_database_config
+        return {} unless config
+
+        if url = fetch(config, :url)
+          adapter = adapter_from_url(url)
+
+          {
+            "DATABASE_ADAPTER" => adapter,
+            "DATABASE_URL" => url.to_s
+          }.compact
+        else
+          case normalize_adapter(fetch(config, :adapter))
+          when "postgres"
+            {
+              "DATABASE_ADAPTER" => "postgres",
+              "PGHOST" => fetch(config, :host),
+              "PGPORT" => fetch(config, :port)&.to_s,
+              "PGUSER" => fetch(config, :username),
+              "PGDATABASE" => fetch(config, :database)
+            }.compact
+          when "mysql"
+            {
+              "DATABASE_ADAPTER" => "mysql",
+              "MYSQL_HOST" => fetch(config, :host),
+              "MYSQL_PORT" => fetch(config, :port)&.to_s,
+              "MYSQL_USER" => fetch(config, :username),
+              "MYSQL_DATABASE" => fetch(config, :database)
+            }.compact
+          when "sqlite"
+            database = fetch(config, :database)
+            if database
+              {
+                "DATABASE_ADAPTER" => "sqlite",
+                "SQLITE_DATABASE_PATH" => File.expand_path(database.to_s, @cwd)
+              }
+            else
+              {}
+            end
+          else
+            {}
+          end
+        end
+      end
+
+      def local_storage_path
+        File.join(@cwd, "storage")
+      end
+
+      def local_database_config
+        environment = fetch(parsed_yaml(database_config_path), DEVELOPMENT_ENV)
+        return nil unless environment.is_a?(Hash)
+
+        if database_entry?(environment)
+          environment
+        else
+          primary = fetch(environment, :primary)
+          primary if primary.is_a?(Hash)
+        end
+      end
+
+      def database_entry?(config)
+        fetch(config, :adapter) || fetch(config, :database) || fetch(config, :url)
+      end
+
+      def adapter_from_url(url)
+        normalize_adapter(URI.parse(url.to_s).scheme)
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def parsed_yaml(path)
+        return {} unless File.file?(path)
+
+        rendered = ERB.new(File.read(path), trim_mode: "-").result
+        data = YAML.safe_load(rendered, permitted_classes: [], aliases: true)
+
+        if data.is_a?(Hash)
+          data
+        else
+          {}
+        end
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "invalid YAML in #{path}: #{e.message}"
+      end
+
+      def fetch(hash, key)
+        hash[key] || hash[key.to_s] || hash[key.to_sym]
+      end
+
+      def normalize_adapter(value)
+        case value.to_s.downcase
+        when "postgres", "postgresql"
+          "postgres"
+        when "mysql", "mysql2", "mariadb"
+          "mysql"
+        when "sqlite", "sqlite3"
+          "sqlite"
+        end
+      end
+
+      def database_config_path
+        File.join(@cwd, "config", "database.yml")
+      end
+
+      def deploy_config_path
+        File.join(@cwd, "config", "deploy.yml")
+      end
+  end
+end

data/lib/kamal_backup/version.rb

@@ -1,3 +1,3 @@
 module KamalBackup
-  VERSION = "0.1.0.pre.8"
+  VERSION = "0.1.0.pre.10"
 end

data/lib/kamal_backup.rb

@@ -4,6 +4,7 @@ require_relative "kamal_backup/errors"
 require_relative "kamal_backup/command"
 require_relative "kamal_backup/redactor"
 require_relative "kamal_backup/config"
+require_relative "kamal_backup/rails_app"
 require_relative "kamal_backup/kamal_bridge"
 require_relative "kamal_backup/restic"
 require_relative "kamal_backup/evidence"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kamal-backup
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.8
+  version: 0.1.0.pre.10
 platform: ruby
 authors:
 - crmne
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -61,6 +61,7 @@ files:
 - lib/kamal_backup/errors.rb
 - lib/kamal_backup/evidence.rb
 - lib/kamal_backup/kamal_bridge.rb
+- lib/kamal_backup/rails_app.rb
 - lib/kamal_backup/redactor.rb
 - lib/kamal_backup/restic.rb
 - lib/kamal_backup/scheduler.rb