kamal-backup 0.3.0.beta21 → 0.3.1

data/lib/kamal_backup/rails_app.rb

@@ -1,10 +1,16 @@
-require "erb"
-require "uri"
-require "yaml"
+# frozen_string_literal: true
+
+require 'erb'
+require 'uri'
+require 'yaml'
+require_relative 'databases/base'
+require_relative 'yaml_access'
 
 module KamalBackup
   class RailsApp
-    DEVELOPMENT_ENV = "development"
+    include YamlAccess
+
+    DEVELOPMENT_ENV = 'development'
 
     def initialize(cwd:)
       @cwd = File.expand_path(cwd)
@@ -17,136 +23,120 @@ module KamalBackup
         defaults.merge!(deploy_defaults)
         defaults.merge!(database_defaults)
 
-        if local_storage_path
-          defaults["BACKUP_PATHS"] = local_storage_path
-        end
+        defaults['BACKUP_PATHS'] = local_storage_path if local_storage_path
 
-        defaults["KAMAL_BACKUP_STATE_DIR"] = File.join(@cwd, "tmp", "kamal-backup")
+        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)
+    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
+      if service
+        { 'APP_NAME' => service.to_s }
+      else
+        {}
       end
+    end
 
-      def database_defaults
-        config = local_database_config
-        return {} unless config
+    def database_defaults
+      config = local_database_config
+      return {} unless config
 
-        if url = fetch(config, :url)
-          adapter = adapter_from_url(url)
+      if (url = fetch(config, :url))
+        adapter = adapter_from_url(url)
 
+        {
+          'DATABASE_ADAPTER' => adapter,
+          'DATABASE_URL' => url.to_s
+        }.compact
+      else
+        case Databases.normalize_adapter(fetch(config, :adapter))
+        when 'postgres'
           {
-            "DATABASE_ADAPTER" => adapter,
-            "DATABASE_URL" => url.to_s
+            'DATABASE_ADAPTER' => 'postgres',
+            'PGHOST' => fetch(config, :host),
+            'PGPORT' => fetch(config, :port)&.to_s,
+            'PGUSER' => fetch(config, :username),
+            'PGDATABASE' => fetch(config, :database)
           }.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"
+        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" => "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
+              'DATABASE_ADAPTER' => 'sqlite',
+              'SQLITE_DATABASE_PATH' => File.expand_path(database.to_s, @cwd)
+            }
           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
+    end
 
-      def database_entry?(config)
-        fetch(config, :adapter) || fetch(config, :database) || fetch(config, :url)
-      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)
 
-      def adapter_from_url(url)
-        normalize_adapter(URI.parse(url.to_s).scheme)
-      rescue URI::InvalidURIError
-        nil
+      if database_entry?(environment)
+        environment
+      else
+        primary = fetch(environment, :primary)
+        primary if primary.is_a?(Hash)
       end
+    end
 
-      def parsed_yaml(path)
-        return {} unless File.file?(path)
+    def database_entry?(config)
+      fetch(config, :adapter) || fetch(config, :database) || fetch(config, :url)
+    end
 
-        rendered = ERB.new(File.read(path), trim_mode: "-").result
-        data = YAML.safe_load(rendered, permitted_classes: [], aliases: true)
+    def adapter_from_url(url)
+      Databases.normalize_adapter(URI.parse(url.to_s).scheme)
+    rescue URI::InvalidURIError
+      nil
+    end
 
-        if data.is_a?(Hash)
-          data
-        else
-          {}
-        end
-      rescue Psych::SyntaxError => e
-        raise ConfigurationError, "invalid YAML in #{path}: #{e.message}"
-      end
+    def parsed_yaml(path)
+      return {} unless File.file?(path)
 
-      def fetch(hash, key)
-        hash[key] || hash[key.to_s] || hash[key.to_sym]
-      end
+      rendered = ERB.new(File.read(path), trim_mode: '-').result
+      data = YAML.safe_load(rendered, permitted_classes: [], aliases: true)
 
-      def normalize_adapter(value)
-        case value.to_s.downcase
-        when "postgres", "postgresql"
-          "postgres"
-        when "mysql", "mysql2", "mariadb"
-          "mysql"
-        when "sqlite", "sqlite3"
-          "sqlite"
-        end
+      if data.is_a?(Hash)
+        data
+      else
+        {}
       end
+    rescue Psych::SyntaxError => e
+      raise ConfigurationError, "invalid YAML in #{path}: #{e.message}"
+    end
 
-      def database_config_path
-        File.join(@cwd, "config", "database.yml")
-      end
+    def database_config_path
+      File.join(@cwd, 'config', 'database.yml')
+    end
 
-      def deploy_config_path
-        File.join(@cwd, "config", "deploy.yml")
-      end
+    def deploy_config_path
+      File.join(@cwd, 'config', 'deploy.yml')
+    end
   end
 end

data/lib/kamal_backup/redactor.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module KamalBackup
   class Redactor
     SECRET_KEY_PATTERN = /(pass|password|secret|token|key|credential|authorization)/i
     SENSITIVE_KEY_PATTERN = /(?:pass|password|secret|token|key|credential|authorization)|\A(?:user|username|pguser|.*_user|.*_username)\z/i
-    REDACTED = "[REDACTED]"
+    REDACTED = '[REDACTED]'
 
     def initialize(secret_values: [], env: ENV)
       @secret_values = Array(secret_values).compact.map(&:to_s).reject { |value| value.empty? || value.length < 4 }
@@ -31,22 +33,25 @@ module KamalBackup
     end
 
     private
-      def known_secret_values
-        @known_secret_values ||= begin
-          env_secrets = @env.each_with_object([]) do |(key, value), values|
-            values << value.to_s if key.to_s.match?(SECRET_KEY_PATTERN)
-          end
 
-          (@secret_values + env_secrets).compact.uniq.reject { |value| value.empty? || value.length < 4 }
+    def known_secret_values
+      @known_secret_values ||= begin
+        env_secrets = @env.each_with_object([]) do |(key, value), values|
+          values << value.to_s if key.to_s.match?(SECRET_KEY_PATTERN)
         end
+
+        (@secret_values + env_secrets).compact.uniq.reject { |value| value.empty? || value.length < 4 }
       end
+    end
 
-      def redact_url_credentials(value)
-        value.gsub(%r{(://)([^/\s]+)@}) do
-          "#{$1}#{REDACTED}@"
-        end.gsub(/([?&](?:password|token|secret|key|access_key_id|secret_access_key)=)[^&\s]+/i) do
-          "#{$1}#{REDACTED}"
-        end
+    def redact_url_credentials(value)
+      redacted = value.gsub(%r{(://)([^/\s]+)@}) do
+        "#{::Regexp.last_match(1)}#{REDACTED}@"
       end
+
+      redacted.gsub(/([?&](?:password|token|secret|key|access_key_id|secret_access_key)=)[^&\s]+/i) do
+        "#{::Regexp.last_match(1)}#{REDACTED}"
+      end
+    end
   end
 end