schema-evolution-manager 0.9.58 → 0.9.61

data/lib/schema-evolution-manager/db.rb

@@ -2,20 +2,34 @@ module SchemaEvolutionManager
 
   class Db
 
-    attr_reader :url, :psql_executable_with_options
-
+    # psql_args: the psql executable and its global options, as an argv
+    attr_reader :url, :psql_args
+
+    # Options every psql invocation carries. --no-psqlrc keeps the applying
+    # user's ~/.psqlrc (and the system psqlrc) out of every command and
+    # migration; --no-password makes a missing credential fail rather than
+    # prompt, so an unattended apply can never hang.
+    PSQL_ISOLATION_OPTIONS = ["--no-psqlrc", "--no-password"]
+
+    # A password embedded in the url (postgres://user:pass@host/db) is moved
+    # into a private pgpass file and @url keeps only the password-free form,
+    # so the password never reaches a psql argv, a log line or an error.
+    #
+    # @param password: Optional password; takes precedence over one in the url
     def initialize(url, opts={})
-      @url = Preconditions.check_not_blank(url, "url cannot be blank")
+      Preconditions.check_not_blank(url, "url cannot be blank")
       password = opts.delete(:password)
 
-      @psql_executable_with_options = "psql"
+      @psql_args = ["psql"]
       (opts.delete(:set) || []).each do |arg|
-        @psql_executable_with_options << " --set #{arg}"
+        @psql_args += ["--set", arg]
       end
 
       Preconditions.assert_empty_opts(opts)
-      connection_data = ConnectionData.parse_url(@url)
+      connection_data = ConnectionData.parse_url(url)
+      @url = ConnectionData.strip_password(url)
 
+      password ||= connection_data.password
       if password
         ENV['PGPASSFILE'] = Db.password_to_tempfile(connection_data.pgpass(password))
       end
@@ -34,10 +48,8 @@ module SchemaEvolutionManager
     # executes a simple sql command.
     def psql_command(sql_command)
       Preconditions.assert_class(sql_command, String)
-      template = "#{@psql_executable_with_options} --no-align --tuples-only --no-psqlrc --command \"%s\" %s"
-      command = template % [sql_command, Shellwords.escape(@url)]
-      command_to_log = template % [sql_command, sanitized_url]
-      Library.system_or_error(command, command_to_log)
+      command = @psql_args + PSQL_ISOLATION_OPTIONS + ["--no-align", "--tuples-only", "--command", sql_command]
+      Library.system_or_error(command + [@url], :log => command + [sanitized_url])
     end
 
     def Db.attribute_values(path)
@@ -66,32 +78,28 @@ module SchemaEvolutionManager
       options
     end
 
-    # executes sql commands from a file in a single transaction
+    # executes sql commands from a file in a single transaction.
+    # psql reads the original file, so the line numbers and path in
+    # any psql error match the file in git.
     def psql_file(filename, path)
       Preconditions.assert_class(path, String)
       Preconditions.check_state(File.exist?(path), "File[%s] not found" % path)
 
-      options = Db.attribute_values(path).join(" ")
-
-      Library.with_temp_file(:prefix => File.basename(path)) do |tmp|
-        File.open(tmp, "w") do |out|
-          out << "\\set ON_ERROR_STOP true\n\n"
-          out << IO.read(path)
-        end
+      command = psql_file_command(path)
 
-        command = "#{@psql_executable_with_options} --file \"%s\" #{options} %s" % [tmp, Shellwords.escape(@url)]
-
-        Library.with_temp_file do |output|
-          result = `#{command} > #{output} 2>&1`.strip
-          status = $?
-          if status.to_i > 0
-            errors = File.exist?(output) ? IO.read(output) : result
-            raise ScriptError.new(self, filename, path, errors)
-          end
-        end
+      output, status = Open3.capture2e(*command)
+      if !status.success?
+        raise ScriptError.new(self, filename, path, output)
       end
     end
 
+    # The psql argv psql_file runs. ON_ERROR_STOP is set on the
+    # command line, after any --set the caller passed, so it is in
+    # effect before the first line of the file is read.
+    def psql_file_command(path)
+      @psql_args + PSQL_ISOLATION_OPTIONS + ["--set", "ON_ERROR_STOP=1", "--file", path] + Db.attribute_values(path) + [@url]
+    end
+
     # True if the specific schema exists; false otherwise
     def schema_schema_evolution_manager_exists?
       sql = "select count(*) from pg_namespace where nspname='%s'" % Db.schema_name
@@ -122,47 +130,34 @@ module SchemaEvolutionManager
       end
     end
 
+    # Returns value as a SQL string literal, doubling any single quote.
+    def Db.quote_literal(value)
+      Preconditions.assert_class(value, String)
+      "'" + value.gsub("'", "''") + "'"
+    end
+
     # Returns the name of the schema_evolution_manager schema
     def Db.schema_name
       "schema_evolution_manager"
     end
 
+    # Writes the pgpass contents to a file in Library::TMPFILE_DIR,
+    # returning its path. The file is a plain file rather than a Tempfile so
+    # that no finalizer can unlink it while psql still needs it; the
+    # TMPFILE_DIR at_exit hook removes it. libpq ignores a pgpass file that
+    # is group or world readable, so it is created mode 0600.
     def Db.password_to_tempfile(contents)
-      file = Tempfile.new("sem-db")
-      file.write(contents)
-      file.rewind
-      file.path
+      path = File.join(Library::TMPFILE_DIR, "pgpass.%s" % SecureRandom.hex(8))
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0600) do |out|
+        out.write(contents)
+      end
+      path
     end
 
-    # Returns a sanitized version of the URL with the password removed
-    # to prevent passwords from being logged or displayed in error messages
+    # The url for display. @url never carries a password (see initialize),
+    # so this is @url itself; kept for callers that print the connection.
     def sanitized_url
-      # Parse the URL to extract components
-      if @url.include?("://")
-        protocol, rest = @url.split("://", 2)
-        lead, name = rest.split("/", 2)
-
-        # Check if there's a username:password@ pattern
-        if lead.include?("@")
-          # Take the last element as host_part to handle passwords with @ symbols
-          host_part = lead.split("@").last
-          # Take everything before the last @ as user_part
-          user_part = lead.split("@")[0..-2].join("@")
-
-          if user_part.include?(":")
-            # Remove password, keep only username (everything before the first colon)
-            username = user_part.split(":", 2)[0]
-            sanitized_lead = "#{username}:[REDACTED]@#{host_part}"
-          else
-            sanitized_lead = lead
-          end
-          "#{protocol}://#{sanitized_lead}/#{name}"
-        else
-          @url
-        end
-      else
-        @url
-      end
+      @url
     end
 
   end

data/lib/schema-evolution-manager/install_template.rb

@@ -12,8 +12,10 @@ module SchemaEvolutionManager
     def generate
       template = Template.new
       template.add('timestamp', Time.now.to_s)
-      template.add('lib_dir', @lib_dir)
-      template.add('bin_dir', @bin_dir)
+      # Inserted as Ruby string literals: the generated script runs under
+      # sudo, so a quote in the prefix must not end the literal
+      template.add('lib_dir', @lib_dir.inspect)
+      template.add('bin_dir', @bin_dir.inspect)
       template.parse(TEMPLATE)
     end
 
@@ -22,7 +24,7 @@ module SchemaEvolutionManager
       File.open(path, "w") do |out|
         out << generate
       end
-      Library.system_or_error("chmod +x %s" % path)
+      Library.system_or_error(["chmod", "--", "+x", path])
     end
 
     if !defined?(TEMPLATE)
@@ -35,8 +37,8 @@ module SchemaEvolutionManager
 load File.join(File.dirname(__FILE__), 'lib/schema-evolution-manager.rb')
 SchemaEvolutionManager::Library.set_verbose(true)
 
-lib_dir = '%%lib_dir%%'
-bin_dir = '%%bin_dir%%'
+lib_dir = %%lib_dir%%
+bin_dir = %%bin_dir%%
 version = SchemaEvolutionManager::Version.read
 
 version_name = "schema-evolution-manager-%s" % version.to_version_string
@@ -49,18 +51,18 @@ SchemaEvolutionManager::Library.ensure_dir!(bin_dir)
 Dir.chdir(lib_dir) do
   if File.exist?("schema-evolution-manager")
     if File.symlink?("schema-evolution-manager")
-      SchemaEvolutionManager::Library.system_or_error("rm schema-evolution-manager")
-      SchemaEvolutionManager::Library.system_or_error("ln -s %s %s" % [version_name, 'schema-evolution-manager'])
+      SchemaEvolutionManager::Library.system_or_error(["rm", "schema-evolution-manager"])
+      SchemaEvolutionManager::Library.system_or_error(["ln", "-s", version_name, "schema-evolution-manager"])
     else
       puts "*** WARNING: File[%s] already exists. Not creating symlink" % File.join(lib_dir, "schema-evolution-manager")
     end
   else
-    SchemaEvolutionManager::Library.system_or_error("ln -s %s %s" % [version_name, 'schema-evolution-manager'])
+    SchemaEvolutionManager::Library.system_or_error(["ln", "-s", version_name, "schema-evolution-manager"])
   end
 end
 
 ['CONVENTIONS.md', 'LICENSE', 'README.md', 'VERSION', 'install.sh'].each do |filename|
-  SchemaEvolutionManager::Library.system_or_error("cp %s %s" % [filename, version_dir])
+  SchemaEvolutionManager::Library.system_or_error(["cp", "--", filename, version_dir])
 end
 
 ['bin', 'lib', 'lib/schema-evolution-manager', 'template', 'scripts'].each do |dir|
@@ -69,9 +71,9 @@ end
   Dir.foreach(dir) do |filename|
     path = File.join(dir, filename)
     if File.file?(path)
-      SchemaEvolutionManager::Library.system_or_error("cp %s %s" % [path, this_dir])
+      SchemaEvolutionManager::Library.system_or_error(["cp", "--", path, this_dir])
       if dir == "bin" && filename != "sem-config"
-        SchemaEvolutionManager::Library.system_or_error("chmod +x %s/%s" % [this_dir, filename])
+        SchemaEvolutionManager::Library.system_or_error(["chmod", "--", "+x", File.join(this_dir, filename)])
       end
     end
   end
@@ -82,7 +84,8 @@ Dir.chdir(bin_dir) do
   Dir.foreach(aliased_bin_dir) do |filename|
     path = File.join(aliased_bin_dir, filename)
     if File.file?(path)
-      SchemaEvolutionManager::Library.system_or_error("rm -f %s && ln -s %s" % [filename, path])
+      SchemaEvolutionManager::Library.system_or_error(["rm", "-f", "--", filename])
+      SchemaEvolutionManager::Library.system_or_error(["ln", "-s", "--", path])
     end
   end
 end
@@ -91,7 +94,7 @@ end
 init_file = File.join(version_dir, "bin/sem-config")
 SchemaEvolutionManager::Preconditions.check_state(File.exist?(init_file), "Init file[%s] not found" % init_file)
 File.open(init_file, "w") do |out|
-  out << "load File.join('%s')\n" % File.join(version_dir, 'lib/schema-evolution-manager.rb')
+  out << "load %s\n" % File.join(version_dir, 'lib/schema-evolution-manager.rb').inspect
 end
 
 puts ""

data/lib/schema-evolution-manager/library.rb

@@ -2,8 +2,15 @@ module SchemaEvolutionManager
   class Library
 
     unless defined?(TMPFILE_DIR)
-      TMPFILE_DIR = "/tmp"
+      # A directory private to this process. Temp file names below are
+      # "<prefix>.<counter>", and sem-apply uses a migration's basename as the
+      # prefix, so two processes applying the same scripts would otherwise
+      # compute the same path and delete each other's copy mid-run. mktmpdir
+      # honours TMPDIR and creates the directory mode 0700 with a random name.
+      TMPFILE_DIR = Dir.mktmpdir("schema-evolution-manager-")
       TMPFILE_PREFIX = "schema-evolution-manager-#{Process.pid}.tmp"
+      tmpfile_dir_owner = Process.pid
+      at_exit { FileUtils.rm_rf(TMPFILE_DIR) if Process.pid == tmpfile_dir_owner }
     end
     @@tmpfile_count = 0
     @@verbose = false
@@ -13,7 +20,7 @@ module SchemaEvolutionManager
       Preconditions.assert_class(dir, String)
 
       if !File.directory?(dir)
-        Library.system_or_error("mkdir -p #{dir}")
+        Library.system_or_error(["mkdir", "-p", "--", dir])
       end
       Library.assert_dir_exists(dir)
     end
@@ -31,14 +38,14 @@ module SchemaEvolutionManager
     end
 
     def Library.git_assert_tag_exists(tag)
-      command = "git tag -l"
+      command = ["git", "tag", "-l"]
       results = Library.system_or_error(command)
       if results.nil?
         raise "No git tags found"
       end
 
       if !Library.tag_exists?(tag)
-        raise "Tag[#{tag}] not found. Check #{command}"
+        raise "Tag[#{tag}] not found. Check #{Shellwords.join(command)}"
       end
     end
 
@@ -54,11 +61,17 @@ module SchemaEvolutionManager
     # no tags, otherwise returns an instance of Version. Only searches for
     # tags matching x.x.x (e.g. 1.0.2)
     def Library.latest_tag
-      `git tag -l`.strip.split.select { |tag| Version.is_valid?(tag) }.map { |tag| Version.parse(tag) }.sort.last
+      Library.git_tags.select { |tag| Version.is_valid?(tag) }.map { |tag| Version.parse(tag) }.sort.last
     end
 
+    # True only when a tag with exactly this name exists - 1.0.10 does
+    # not make 1.0.1 exist.
     def Library.tag_exists?(tag)
-      `git tag -l`.strip.include?(tag)
+      Library.git_tags.include?(tag)
+    end
+
+    def Library.git_tags
+      `git tag -l`.strip.split
     end
 
     # Ex: Library.git_create_tag("0.0.1")
@@ -66,11 +79,11 @@ module SchemaEvolutionManager
       Library.assert_valid_tag(tag)
       has_remote = Library.git_has_remote?
       if has_remote
-        Library.system_or_error("git fetch --tags origin")
+        Library.system_or_error(["git", "fetch", "--tags", "origin"])
       end
-      Library.system_or_error("git tag -a -m #{tag} #{tag}")
+      Library.system_or_error(["git", "tag", "-a", "-m", tag, tag])
       if has_remote
-        Library.system_or_error("git push --tags origin")
+        Library.system_or_error(["git", "push", "--tags", "origin"])
       end
     end
 
@@ -118,24 +131,65 @@ module SchemaEvolutionManager
       @@base_dir = Library.normalize_path(value)
     end
 
-    # Runs the specified command, raising an error if there is a problem
-    # (based on status code of the process executed). Otherwise returns
-    # all the output from the script invoked.
-    def Library.system_or_error(command, cmd_to_log=nil)
+    # Parses one property line of the form "<prefix><name> = <value>",
+    # stripping whitespace from both the name and the value. Returns
+    # [name, value] when the stripped line matches prefix (a Regexp
+    # anchored at the start of the line), otherwise nil. value is nil
+    # when the line has no equals sign. Shared by migration file
+    # attributes (-- sem.attribute.) and the .sem config file
+    # (sem.config.).
+    def Library.parse_property(line, prefix)
+      Preconditions.assert_class(line, String)
+      Preconditions.assert_class(prefix, Regexp)
+
+      stripped = line.strip
+      if stripped.match(prefix)
+        stripped.sub(prefix, '').split(/\=/, 2).map(&:strip)
+      else
+        nil
+      end
+    end
+
+    # Runs the command, raising an error if it exits non-zero, and
+    # returns its standard output, stripped. Standard error passes
+    # through to ours.
+    #
+    # The command is an argv array, executed directly and never through a
+    # shell, so a path or value holding a space, a quote or a dollar sign
+    # reaches the program as exactly one argument:
+    #
+    #   Library.system_or_error(["mv", "--", file, target])
+    #
+    # @param env: Optional hash of environment variables set for the command
+    # @param log: Optional array shown in place of the command when
+    #        logging or raising, for a command carrying a secret
+    def Library.system_or_error(command, opts={})
+      env = opts.delete(:env) || {}
+      log = opts.delete(:log) || command
+      Preconditions.assert_empty_opts(opts)
+      Preconditions.assert_class(command, Array)
+      Preconditions.check_state(!command.empty?, "command cannot be empty")
+      Preconditions.check_state(command.all? { |arg| arg.is_a?(String) }, "every argument must be a String: %s" % command.inspect)
+
+      display = Library.command_to_s(log, env)
       if Library.is_verbose?
-        puts cmd_to_log || command
+        puts display
       end
 
       begin
-        result = `#{command}`.strip
-        status = $?
-        if status.to_i > 0
-          raise "Non zero exit code[%s] running command[%s]" % [status, command]
-        end
-      rescue Exception => e
-        raise "Error running command[%s]: %s" % [command, e.to_s]
+        result, status = Open3.capture2(env, *command)
+      rescue SystemCallError => e
+        raise "Error running command[%s]: %s" % [display, e.to_s]
+      end
+      if !status.success?
+        raise "Non zero exit code[%s] running command[%s]" % [status, display]
       end
-      result
+      result.strip
+    end
+
+    # A shell-quoted rendering of an argv, for logs and error messages
+    def Library.command_to_s(command, env={})
+      (env.map { |k, v| "%s=%s" % [k, Shellwords.escape(v)] } + [Shellwords.join(command)]).join(" ")
     end
 
     def Library.normalize_path(path)
@@ -157,7 +211,7 @@ module SchemaEvolutionManager
       Preconditions.check_state(number_changes > 0)
       Preconditions.assert_empty_opts(opts)
 
-      git_log_command = "git log --pretty=format:\"%h %ad | %s%d [%an]\" --date=short -#{number_changes}"
+      git_log_command = ["git", "log", "--pretty=format:%h %ad | %s%d [%an]", "--date=short", "-#{number_changes}"]
       git_log = Library.system_or_error(git_log_command)
       out = ""
       out << "Created: %s\n" % Library.format_time
@@ -165,7 +219,7 @@ module SchemaEvolutionManager
         out << "Git Tag: %s\n" % tag
       end
       out << "\n"
-      out << "%s:\n" % git_log_command
+      out << "%s:\n" % Library.command_to_s(git_log_command)
       out << "  " << git_log.split("\n").join("\n  ") << "\n"
       out
     end

data/lib/schema-evolution-manager/migration_file.rb

@@ -42,6 +42,7 @@ module SchemaEvolutionManager
 
     unless defined?(DEFAULTS)
       DEFAULTS = [AttributeValue.new("transaction", "single")]
+      PROPERTY_PREFIX = /^\-\-\s+sem\.attribute\./
     end
 
     attr_reader :path, :attribute_values
@@ -86,11 +87,8 @@ module SchemaEvolutionManager
       File.foreach(path, mode: "rb") do |raw|
         line = raw.force_encoding("UTF-8")
         line = line.scrub unless line.valid_encoding?
-        stripped = line.strip
-        if stripped.match(/^\-\-\s+sem\.attribute\./)
-          stripped.sub!(/^\-\-\s+sem\.attribute\./, '')
-          name, value = stripped.split(/\=/, 2).map(&:strip)
-          yield name, value
+        if property = Library.parse_property(line, PROPERTY_PREFIX)
+          yield property[0], property[1]
         end
       end
     end

data/lib/schema-evolution-manager/scripts.rb

@@ -6,6 +6,18 @@ module SchemaEvolutionManager
       SCRIPTS = "scripts"
       BOOTSTRAP_SCRIPTS = "bootstrap_scripts"
       VALID_TABLE_NAMES = [BOOTSTRAP_SCRIPTS, SCRIPTS]
+      # A script basename is interpolated into SQL and passed to psql, so
+      # nothing outside this pattern may reach a query or be applied.
+      VALID_FILENAME = /\A\d{6,}-\d{6}\.sql\z/
+    end
+
+    # Raises unless filename follows the naming convention
+    # (e.g. 20120503-173242.sql). Returns the filename.
+    def Scripts.assert_valid_filename!(filename)
+      Preconditions.assert_class(filename, String)
+      Preconditions.check_state(VALID_FILENAME.match?(filename),
+                                "Invalid filename[#{filename}]. Must be like: 20120503-173242.sql")
+      filename
     end
 
     # @param db Instance of Db class
@@ -41,7 +53,7 @@ module SchemaEvolutionManager
     def each_pending(dir)
       files = {}
       Scripts.all(dir).each do |path|
-        name = File.basename(path)
+        name = Scripts.assert_valid_filename!(File.basename(path))
         files[name] = path
       end
 
@@ -63,8 +75,9 @@ module SchemaEvolutionManager
     # True if this script has already been applied to the db. False
     # otherwise.
     def has_run?(filename)
+      Scripts.assert_valid_filename!(filename)
       if @db.schema_schema_evolution_manager_exists?
-        query = "select count(*) from %s.%s where filename = '%s'" % [Db.schema_name, @table_name, filename]
+        query = "select count(*) from %s.%s where filename = %s" % [Db.schema_name, @table_name, Db.quote_literal(filename)]
         @db.psql_command(query).to_i > 0
       else
         false
@@ -73,9 +86,8 @@ module SchemaEvolutionManager
 
     # Inserts a record to indiciate that we have loaded the specified file.
     def record_as_run!(filename)
-      Preconditions.check_state(filename.match(/^\d\d\d\d\d\d+\-\d\d\d\d\d\d\.sql$/),
-                                "Invalid filename[#{filename}]. Must be like: 20120503-173242.sql")
-      command = "insert into %s.%s (filename) select '%s' where not exists (select 1 from %s.%s where filename = '%s')" % [Db.schema_name, @table_name, filename, Db.schema_name, @table_name, filename]
+      literal = Db.quote_literal(Scripts.assert_valid_filename!(filename))
+      command = "insert into %s.%s (filename) select %s where not exists (select 1 from %s.%s where filename = %s)" % [Db.schema_name, @table_name, literal, Db.schema_name, @table_name, literal]
       @db.psql_command(command)
     end
 
@@ -96,7 +108,8 @@ module SchemaEvolutionManager
       if scripts.empty? || !@db.schema_schema_evolution_manager_exists?
         []
       else
-        sql = "select filename from %s.%s where filename in (%s)" % [Db.schema_name, @table_name, "'" + scripts.join("', '") + "'"]
+        literals = scripts.map { |name| Db.quote_literal(Scripts.assert_valid_filename!(name)) }
+        sql = "select filename from %s.%s where filename in (%s)" % [Db.schema_name, @table_name, literals.join(", ")]
         @db.psql_command(sql).strip.split
       end
     end

data/lib/schema-evolution-manager/sem_info.rb

@@ -12,23 +12,49 @@ module SchemaEvolutionManager
 
       if !valid.include?(subcommand)
         if subcommand.empty?
-          puts "ERROR: Missing db subcommand. Must be one of: %s" % valid.join(", ")
+          $stderr.puts "ERROR: Missing db subcommand. Must be one of: %s" % valid.join(", ")
         else
-          puts "ERROR: Invalid db subcommand[%s]. Must be one of: %s" % [subcommand, valid.join(", ")]
+          $stderr.puts "ERROR: Invalid db subcommand[%s]. Must be one of: %s" % [subcommand, valid.join(", ")]
         end
         exit(4)
       end
 
-      db_args = SchemaEvolutionManager::Args.new(args.join(" "), :optional => ['url', 'host', 'user', 'name', 'port', 'set'])
-      db = SchemaEvolutionManager::Db.from_args(db_args)
+      db_args = SchemaEvolutionManager::Args.new(args, :optional => ['url', 'host', 'user', 'name', 'port', 'set'])
 
-      if subcommand == "version"
-        version = SchemaEvolutionManager::Versions.new(db).latest
-        puts version unless version.nil?
-      elsif subcommand == "scripts"
-        SchemaEvolutionManager::Scripts.new(db, SchemaEvolutionManager::Scripts::SCRIPTS).applied.each do |filename|
-          puts filename
+      if db_args.url.to_s.strip.empty? && db_args.name.to_s.strip.empty?
+        $stderr.puts "ERROR: Missing database connection. Provide --url <postgres url> or --host/--name."
+        exit(3)
+      end
+
+      # A common mistake is passing a bare database name to --url. Catch it with
+      # an actionable hint instead of letting parse_url raise a raw backtrace.
+      if db_args.url && !db_args.url.include?("://")
+        $stderr.puts "ERROR: --url must be a full connection string (e.g. postgres://localhost:5432/%s). To connect by database name, use --name %s." % [db_args.url, db_args.url]
+        exit(3)
+      end
+
+      begin
+        db = SchemaEvolutionManager::Db.from_args(db_args)
+        if subcommand == "version"
+          version = SchemaEvolutionManager::Versions.new(db).latest
+          if version.nil?
+            $stderr.puts "No deployed version recorded"
+          else
+            puts version
+          end
+        elsif subcommand == "scripts"
+          applied = SchemaEvolutionManager::Scripts.new(db, SchemaEvolutionManager::Scripts::SCRIPTS).applied
+          if applied.empty?
+            $stderr.puts "No scripts recorded"
+          else
+            applied.each { |filename| puts filename }
+          end
         end
+      rescue => e
+        # Surface a single clean line (e.g. bad url, unreachable host, missing
+        # database) rather than a Ruby stack trace.
+        $stderr.puts "ERROR: %s" % e.message.to_s.split("\n").first
+        exit(3)
       end
     end
 

data/lib/schema-evolution-manager/sem_version.rb

@@ -3,7 +3,7 @@ module SchemaEvolutionManager
 
 module SemVersion
 
-VERSION ||= '0.9.43'
+VERSION ||= '0.9.61'
 
 end
 

data/lib/schema-evolution-manager/template.rb

@@ -29,7 +29,9 @@ module SchemaEvolutionManager
       Preconditions.check_not_blank(contents)
       string = contents.dup
       @subs.each do |sub|
-        string = string.gsub(/%%#{sub.pattern}%%/, sub.value)
+        # Block form: the value is inserted literally, so a backslash in
+        # it is never read as a backreference
+        string = string.gsub(/%%#{sub.pattern}%%/) { sub.value }
       end
       string
     end

data/lib/schema-evolution-manager.rb

@@ -1,7 +1,9 @@
 require 'fileutils'
 require 'pathname'
-require 'tempfile'
+require 'tmpdir'
+require 'securerandom'
 require 'shellwords'
+require 'open3'
 
 dir = File.dirname(__FILE__)
 lib_dir = File.join(dir, "schema-evolution-manager")
@@ -28,3 +30,4 @@ load File.join(lib_dir, 'install_template.rb')
 load File.join(lib_dir, 'script_error.rb')
 load File.join(lib_dir, 'sem_info.rb')
 load File.join(lib_dir, 'migration_file.rb')
+load File.join(lib_dir, 'config.rb')

data/template/dev.rb

@@ -6,7 +6,7 @@
 #
 
 Dir.chdir(File.dirname($0)) {
-  command = "sem-apply --url %%url%%"
-  puts command
-  exec(command)
+  command = ["sem-apply", "--url", %%url_literal%%]
+  puts command.join(" ")
+  exec(*command)
 }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schema-evolution-manager
 version: !ruby/object:Gem::Version
-  version: 0.9.58
+  version: 0.9.61
 platform: ruby
 authors:
 - Michael Bryzek
 bindir: bin
 cert_chain: []
-date: 2026-07-17 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies: []
 description: '["Michael Bryzek"]'
 email: mbryzek@alum.mit.edu
@@ -35,6 +35,7 @@ files:
 - lib/schema-evolution-manager/args.rb
 - lib/schema-evolution-manager/ask.rb
 - lib/schema-evolution-manager/baseline_util.rb
+- lib/schema-evolution-manager/config.rb
 - lib/schema-evolution-manager/connection_data.rb
 - lib/schema-evolution-manager/db.rb
 - lib/schema-evolution-manager/install_template.rb
@@ -72,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Schema evolution manager is a simple schema migration tool for postgresql
   databases.