schema-evolution-manager 0.9.58 → 0.9.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a59b34cee82db218b0008110f365a64567ec8dcbaa9f59a0fcd30acce9586f0
-  data.tar.gz: 5a6066de334be67b4915debfc0670e27c56d40eeb008c60bbc2348da8be37603
+  metadata.gz: 60215e02faf6492f2a4e0b263008b6038f95d3ff824417fb6ce615296342ea5f
+  data.tar.gz: e9450f3c24a2f54b3f25566c1152a6454de7e7b2eb4750dd0a8021b273b014c6
 SHA512:
-  metadata.gz: 21fe48093f5386013d3eed04dec8a9ebd512a670608a6b5a663b2c68c0b9af3fedb910577a58c3e3abe8098d3e66ac76cc25019cad0ebaa47e22014aa061c10c
-  data.tar.gz: 447e2949614cb4f2c332f317596195b796ff811016d8d6259b42a351e59b8a04c324b8bbb8bae3e8248b9a521bb3ba719db4d35676ea2ad1ebbc011ce6984caf
+  metadata.gz: 6673d52ee37258fee586cd320799eeff9e6477d963a98c79f737f1fc8f44009dcbc076ed26dc8e900ef970e79516d1d115d125b6ec4d23da45d1b5903508ca8b
+  data.tar.gz: 3081446f6663a18bf00523332c0d9363e9b3322c9a900561205e1d90509698f4a6899824087a202ba9fdc5f6487fd9ab475574fbca246c7c0e156f691ceb700a

data/README.md

@@ -1,5 +1,3 @@
-[![Build Status](https://travis-ci.org/mbryzek/schema-evolution-manager.svg?branch=main)](https://travis-ci.org/mbryzek/schema-evolution-manager)
-
 # Schema Evolution Manager (sem)
 
 ## Intended Audience
@@ -43,6 +41,24 @@ dozens of independent postgresql databases.
 See INSTALLATION and GETTING STARTED for details.
 
 
+## Why sem
+
+sem is deliberately small. A schema change is a plain SQL file, named
+by the timestamp it was added, committed to git next to every other
+change to that database. There is no migration DSL, no down
+migrations, and no runtime dependency beyond ruby, git and psql.
+
+Applying changes is psql running each file in order inside a
+transaction, and recording the filename in one table. Because psql
+does the work, anything that runs in psql runs in sem: plpgsql,
+extensions, data fixes, large backfills.
+
+If you want a tool that generates SQL from a model, or that rolls
+schema changes back for you, sem is the wrong choice. If you want the
+SQL you wrote to be the SQL that runs, and a plain record of what ran
+where, it is a good fit.
+
+
 ## Project Goals
 
   - Absolutely minimal set of dependencies. We found that anything
@@ -133,7 +149,7 @@ There are three ways to install schema evolution manager:
 
         git clone git@github.com:mbryzek/schema-evolution-manager.git
         cd schema-evolution-manager
-        git checkout 0.9.58
+        git checkout 0.9.61
         ruby ./configure.rb
         sudo ./install.rb
 
@@ -157,6 +173,23 @@ version.
     git init /tmp/sample
     sem-init --dir /tmp/sample --url postgresql://postgres@localhost/sample
 
+### Configuring the scripts directory (.sem)
+
+By default sem keeps scripts in ./scripts. To keep them elsewhere, commit
+a file named .sem at the root of the repository:
+
+    sem.config.scripts_dir = schema/scripts
+
+Every command walks up from the current directory to the first .sem and
+resolves paths relative to the directory that holds it. Blank lines and
+lines starting with # are ignored. sem-init writes the file for you when
+given --scripts_dir:
+
+    sem-init --dir /tmp/sample --url postgresql://postgres@localhost/sample --scripts_dir schema/scripts
+
+sem-dist always packs the scripts under the name scripts/ and never packs
+.sem, so a tarball applies on a server with no .sem.
+
 ### Writing your first sql script
 
     cd /tmp/sample
@@ -236,6 +269,18 @@ There are two recommended ways in which to pass user passwords to psql:
 
         sem-apply --url postgresql://postgres@localhost/sample --password
 
+### Running inside the postgres Docker image
+
+The official postgres image runs the scripts in
+docker-entrypoint-initdb.d before the server listens on TCP. During
+that phase postgres accepts connections only on its unix socket, so a
+URL naming localhost is refused. Leave the host out of the URL and
+libpq connects over the socket:
+
+    sem-apply --url postgresql://$POSTGRES_USER@/$POSTGRES_DB
+
+No password is needed on the socket during initialization.
+
 ### Apply the changes
 
     sem-apply --url postgresql://postgres@localhost/sample

data/bin/sem-add

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-# == Adds a database upgrade script to this repository.
+# == Adds a database upgrade script to this repository. The script is
+#    written to the scripts directory named by .sem (default ./scripts)
 #
 # == Usage
 #  sem-add <path>
@@ -19,7 +20,7 @@ end
 SchemaEvolutionManager::Preconditions.check_state(File.exist?(file), "File[#{file}] could not be found")
 SchemaEvolutionManager::Preconditions.check_state(file.match(/\.sql/i), "File[#{file}] must end with .sql")
 
-scripts_dir = File.join(`pwd`.strip, "scripts")
+scripts_dir = SchemaEvolutionManager::Config.load.scripts_dir
 SchemaEvolutionManager::Library.ensure_dir!(scripts_dir)
 
 contents = IO.read(file)
@@ -33,7 +34,7 @@ while File.exist?(target)
 end
 
 puts "Adding #{target}"
-SchemaEvolutionManager::Library.system_or_error("mv #{file} #{target}")
-SchemaEvolutionManager::Library.system_or_error("git add #{target}")
+SchemaEvolutionManager::Library.system_or_error(["mv", "--", file, target])
+SchemaEvolutionManager::Library.system_or_error(["git", "add", "--", target])
 
 puts "File staged in git. You need to commit and push"

data/bin/sem-apply

@@ -23,6 +23,7 @@ password = if args.password
              nil
            end
 
+config = SchemaEvolutionManager::Config.load
 db = SchemaEvolutionManager::Db.from_args(args, :password => password)
 util = SchemaEvolutionManager::ApplyUtil.new(db, :dry_run => args.dry_run || false)
 
@@ -30,12 +31,12 @@ begin
   db.bootstrap!
 
   puts "Upgrading schema for #{db.sanitized_url}"
-  count = util.apply!("./scripts")
+  count = util.apply!(config.scripts_dir)
   if count == 0
     puts "  All scripts have been previously applied"
   end
 
-  version_file = "./VERSION"
+  version_file = File.join(config.base_dir, "VERSION")
   if !util.dry_run? && File.exist?(version_file)
     version = IO.read(version_file).strip
     if !version.empty?

data/bin/sem-baseline

@@ -17,6 +17,7 @@ load File.join(File.dirname(__FILE__), 'sem-config')
 
 args = SchemaEvolutionManager::Args.from_stdin(:optional => %w(url host port name user dry_run))
 
+config = SchemaEvolutionManager::Config.load
 db = SchemaEvolutionManager::Db.from_args(args)
 db.bootstrap!
 
@@ -24,10 +25,10 @@ dry_run = args.dry_run.nil? ? false : args.dry_run
 
 util = SchemaEvolutionManager::BaselineUtil.new(db, :dry_run => dry_run)
 
-puts "Baselining schema for #{db.url}"
+puts "Baselining schema for #{db.sanitized_url}"
 
 begin
-  count = util.apply!("./scripts")
+  count = util.apply!(config.scripts_dir)
   if count == 0
     puts "  All scripts have been previously applied"
   end

data/bin/sem-dist

@@ -30,13 +30,13 @@ args = SchemaEvolutionManager::Args.from_stdin(:optional => ['artifact_name', 't
 
 # On MAC OS X, use gnutar if available, otherwise use tar with --no-xattrs
 tar_cmd = `which gnutar 2> /dev/null`.strip
-tar_opts = ""
+tar_opts = []
 if tar_cmd == ""
   tar_cmd = "tar"
   # Use --no-xattrs to prevent extended attributes from being archived (works in create mode)
   # Also use --no-mac-metadata to prevent AppleDouble files
-  if system("tar --no-xattrs -cf /dev/null /dev/null 2>/dev/null")
-    tar_opts = "--no-xattrs --no-mac-metadata"
+  if system("tar", "--no-xattrs", "-cf", "/dev/null", "/dev/null", :err => File::NULL)
+    tar_opts = ["--no-xattrs", "--no-mac-metadata"]
   end
 end
 
@@ -58,7 +58,8 @@ SchemaEvolutionManager::Library.git_assert_tag_exists(tag)
 SchemaEvolutionManager::Versions.validate_version!(tag)
 
 changes = SchemaEvolutionManager::Library.git_changes(:tag => tag)
-repo_path = SchemaEvolutionManager::Library.normalize_path(`pwd`.strip)
+config = SchemaEvolutionManager::Config.load
+repo_path = config.base_dir
 
 if args.artifact_name
   artifact_name = args.artifact_name
@@ -76,16 +77,19 @@ SchemaEvolutionManager::Library.with_temp_file do |tmp|
   tmpdir = File.join(tmp, filename)
   SchemaEvolutionManager::Library.ensure_dir!(tmpdir)
 
-  SchemaEvolutionManager::Library.system_or_error("cp -R %s %s" % [File.join(repo_path, "scripts"), File.join(tmpdir, "scripts")])
+  # The tarball always holds the scripts under the fixed name scripts/
+  # and never .sem, so a server applies it without any config.
+  SchemaEvolutionManager::Library.system_or_error(["cp", "-R", "--", config.scripts_dir, File.join(tmpdir, "scripts")])
   File.open(File.join(tmpdir, "CHANGES"), "w") { |out| out << changes }
   File.open(File.join(tmpdir, "VERSION"), "w") { |out| out << tag }
 
-  # Clear extended attributes to avoid tar warnings on Linux
-  SchemaEvolutionManager::Library.system_or_error("xattr -cr #{tmpdir} 2>/dev/null || true")
+  # Clear extended attributes to avoid tar warnings on Linux. Best
+  # effort: xattr is absent on most Linux hosts.
+  system("xattr", "-cr", "--", tmpdir, [:out, :err] => File::NULL)
 
   Dir.chdir(tmp) do
     # COPYFILE_DISABLE prevents AppleDouble ._ files from being created
-    SchemaEvolutionManager::Library.system_or_error("COPYFILE_DISABLE=1 #{tar_cmd} #{tar_opts} -cf #{filename}.tar #{filename}")
+    SchemaEvolutionManager::Library.system_or_error([tar_cmd] + tar_opts + ["-cf", "#{filename}.tar", "--", filename], :env => { "COPYFILE_DISABLE" => "1" })
     FileUtils.cp("#{filename}.tar", tarball)
   end
 end
@@ -96,8 +100,7 @@ if File.exist?(gzip_file)
   FileUtils.rm(gzip_file)
 end
 
-command = "gzip #{tarball}"
-SchemaEvolutionManager::Library.system_or_error(command)
+SchemaEvolutionManager::Library.system_or_error(["gzip", "--", tarball])
 
 puts ""
 puts "Created distribution file at #{gzip_file}"

data/bin/sem-init

@@ -9,16 +9,19 @@
 #
 #   dir: The directory containing a git repository that will contain the schema evolution files
 #   url: The connection string for the psql database
+#   scripts_dir: Optional path to the scripts directory, relative to dir. When given,
+#                it is recorded in dir/.sem so every sem command finds it. Defaults to scripts
 #
 # == Example
 #  git init /tmp/example_repo
 #  bin/sem-init --dir /tmp/example_repo --url postgresql://username@localhost/sample
+#  bin/sem-init --dir /tmp/example_repo --url postgresql://username@localhost/sample --scripts_dir schema/scripts
 #
 
 load File.join(File.dirname(__FILE__), 'sem-config')
 SchemaEvolutionManager::Library.set_verbose(true)
 
-args = SchemaEvolutionManager::Args.from_stdin(:required => %w(dir), :optional => %w(url host port name user))
+args = SchemaEvolutionManager::Args.from_stdin(:required => %w(dir), :optional => %w(url host port name user scripts_dir))
 SchemaEvolutionManager::Preconditions.check_state(File.directory?(args.dir), "Dir[%s] does not exist" % args.dir)
 
 if args.url.nil? && args.name.nil?
@@ -43,8 +46,11 @@ template_dir = File.join(SchemaEvolutionManager::Library.base_dir, "template")
 SchemaEvolutionManager::Preconditions.check_state(File.directory?(template_dir),
                                                   "Could not find schema-evolution-manager/template subdir. Expected it at[%s]" % [template_dir])
 
+# The wrapper scripts are committed to the repository, so they carry the url
+# with any password removed; a password is supplied through a pgpass file.
+# dev.rb takes the url as a ruby string literal.
 subs = {
-  "url" => db.url,
+  "url_literal" => SchemaEvolutionManager::ConnectionData.strip_password(db.url).inspect,
   "add_script_path" => File.join(SchemaEvolutionManager::Library.base_dir, "bin/sem-add")
 }
 
@@ -57,40 +63,56 @@ Dir.chdir(args.dir) do
     if !File.exist?(wrapper)
       puts "Creating wrapper script #{wrapper}"
       copy_file(path, wrapper, subs)
-      SchemaEvolutionManager::Library.system_or_error("chmod +x #{wrapper}")
-      SchemaEvolutionManager::Library.system_or_error("git add #{wrapper}")
+      SchemaEvolutionManager::Library.system_or_error(["chmod", "--", "+x", wrapper])
+      SchemaEvolutionManager::Library.system_or_error(["git", "add", "--", wrapper])
       wrappers << wrapper
     end
   end
   if !wrappers.empty?
-    SchemaEvolutionManager::Library.system_or_error("git commit -m 'Add schema-evolution-manager wrapper scripts' #{wrappers.join(" ")}")
+    SchemaEvolutionManager::Library.system_or_error(["git", "commit", "-m", "Add schema-evolution-manager wrapper scripts", "--"] + wrappers)
   end
 
   readme = "README.md"
   if !File.exist?(readme)
     puts "Creating #{readme}"
     copy_file("schema-evolution-manager/template/README.md", "README.md", subs)
-    SchemaEvolutionManager::Library.system_or_error("git add #{readme}")
-    SchemaEvolutionManager::Library.system_or_error("git commit -m 'Adding README.md' README.md")
+    SchemaEvolutionManager::Library.system_or_error(["git", "add", "--", readme])
+    SchemaEvolutionManager::Library.system_or_error(["git", "commit", "-m", "Adding README.md", "--", readme])
   end
 
-  if !File.exist?("scripts")
-    SchemaEvolutionManager::Library.system_or_error("mkdir scripts")
-    SchemaEvolutionManager::Library.system_or_error("touch scripts/.exists")
-    SchemaEvolutionManager::Library.system_or_error("git add scripts/.exists")
-    SchemaEvolutionManager::Library.system_or_error("git commit -m 'Adding scripts directory' scripts/.exists")
+  if args.scripts_dir
+    config_file = SchemaEvolutionManager::Config::FILENAME
+    if File.exist?(config_file)
+      existing = SchemaEvolutionManager::Config.parse(File.expand_path(config_file))
+      SchemaEvolutionManager::Preconditions.check_state(existing.scripts_dir == File.expand_path(args.scripts_dir),
+                                                        "%s already sets scripts_dir[%s] - not overwriting with[%s]" % [config_file, existing.scripts_dir, args.scripts_dir])
+    else
+      puts "Creating #{config_file}"
+      File.open(config_file, "w") { |out| out << "sem.config.scripts_dir = #{args.scripts_dir}\n" }
+      SchemaEvolutionManager::Library.system_or_error(["git", "add", "--", config_file])
+      SchemaEvolutionManager::Library.system_or_error(["git", "commit", "-m", "Adding #{config_file}", "--", config_file])
+    end
+  end
+
+  scripts_dir = args.scripts_dir || "scripts"
+  if !File.exist?(scripts_dir)
+    exists_marker = File.join(scripts_dir, ".exists")
+    SchemaEvolutionManager::Library.ensure_dir!(scripts_dir)
+    SchemaEvolutionManager::Library.system_or_error(["touch", exists_marker])
+    SchemaEvolutionManager::Library.system_or_error(["git", "add", "--", exists_marker])
+    SchemaEvolutionManager::Library.system_or_error(["git", "commit", "-m", "Adding scripts directory", "--", exists_marker])
   end
 
   # Create the first git tag if necessary
-  tags = SchemaEvolutionManager::Library.system_or_error("git tag -l")
+  tags = SchemaEvolutionManager::Library.system_or_error(["git", "tag", "-l"])
   if tags.nil? || tags == ""
     puts "Creating initial git tag (0.0.1)"
     SchemaEvolutionManager::Library.git_create_tag("0.0.1")
   end
 
   if SchemaEvolutionManager::Library.git_has_remote?
-    branch = SchemaEvolutionManager::Library.system_or_error("git symbolic-ref --short HEAD")
-    SchemaEvolutionManager::Library.system_or_error("git push origin #{branch}")
+    branch = SchemaEvolutionManager::Library.system_or_error(["git", "symbolic-ref", "--short", "HEAD"])
+    SchemaEvolutionManager::Library.system_or_error(["git", "push", "origin", branch])
   end
 
 end

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

@@ -16,6 +16,7 @@ module SchemaEvolutionManager
         :name => "Specifies the name of the database to which to connect",
         :url => "The connection string for the psql database",
         :dir => "Path to a directory",
+        :scripts_dir => "Path to the scripts directory, relative to --dir. Recorded in .sem",
         :tag => "A git tag (e.g. 0.0.1)",
         :prefix => "Configure installer to use this prefix",
         :set => "Passthrough for postgresql --set argument. Returns an array of the options set"
@@ -26,17 +27,21 @@ module SchemaEvolutionManager
         :dry_run => "Include flag to echo commands that will run without actually executing them",
         :non_interactive => "Avoid all prompts and use defaults for any option that requires user input",
         :help => "Display help",
+        :version => "Display the version of schema-evolution-manager",
         :verbose => "Enable verbose logging of all system calls",
       }
     end
 
-    attr_reader :artifact_name, :host, :port, :name, :prefix, :url, :user, :dir, :dry_run, :non_interactive, :tag, :password, :set
+    attr_reader :artifact_name, :host, :port, :name, :prefix, :url, :user, :dir, :dry_run, :non_interactive, :tag, :password, :set, :scripts_dir
 
-    # args: Actual string arguments
+    # args: The arguments, either an argv array (each element one
+    #       argument, so a value may contain whitespace) or a string
+    #       split on whitespace
     # :required => list of parameters that are required
     # :optional => list of parameters that are optional
     def initialize(args, opts={})
-      Preconditions.assert_class_or_nil(args, String)
+      Preconditions.check_state(args.nil? || args.is_a?(String) || args.is_a?(Array),
+                                "args must be a String or an Array")
       required = (opts.delete(:required) || []).map { |flag| format_flag(flag) }
       optional = (opts.delete(:optional) || []).map { |flag| format_flag(flag) }
       Preconditions.assert_class(required, Array)
@@ -51,6 +56,9 @@ module SchemaEvolutionManager
       if !optional.include?(:verbose)
         optional << :verbose
       end
+      if !optional.include?(:version)
+        optional << :version
+      end
 
       found_arguments = parse_string_arguments(args)
       missing = required.select { |field| blank?(found_arguments[field]) }
@@ -63,6 +71,7 @@ module SchemaEvolutionManager
       @url = found_arguments.delete(:url)
       @user = found_arguments.delete(:user)
       @dir = found_arguments.delete(:dir)
+      @scripts_dir = found_arguments.delete(:scripts_dir)
       @tag = found_arguments.delete(:tag)
       @set = found_arguments.delete(:set) || []
 
@@ -71,6 +80,7 @@ module SchemaEvolutionManager
       @password = found_arguments.delete(:password)
       @help = found_arguments.delete(:help)
       @verbose = found_arguments.delete(:verbose)
+      @version = found_arguments.delete(:version)
 
       Preconditions.check_state(found_arguments.empty?,
                                 "Did not handle all flags: %s" % found_arguments.keys.join(" "))
@@ -79,6 +89,11 @@ module SchemaEvolutionManager
         RdocUsage.printAndExit(0)
       end
 
+      if @version
+        puts SemVersion::VERSION
+        exit(0)
+      end
+
       if @verbose
         Library.set_verbose(true)
       end
@@ -90,8 +105,7 @@ module SchemaEvolutionManager
 
     # Hack to minimize bleeding from STDIN. Returns an instance of Args class
     def Args.from_stdin(opts)
-      values = ARGV.join(" ")
-      Args.new(values, opts)
+      Args.new(ARGV.dup, opts)
     end
 
     private
@@ -133,10 +147,9 @@ module SchemaEvolutionManager
 
 
     def parse_string_arguments(args)
-      Preconditions.assert_class_or_nil(args, String)
       found = {}
       index = 0
-      values = args.to_s.strip.split(/\s+/)
+      values = args.is_a?(Array) ? args : args.to_s.strip.split(/\s+/)
       while index < values.length do
         flag = format_flag(values[index])
         index += 1

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

@@ -54,7 +54,7 @@ module SchemaEvolutionManager
           input = STDIN.gets
           puts ""
         ensure
-          `stty #{settings}`
+          system("stty", settings)
         end
         input
       end

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

@@ -0,0 +1,90 @@
+module SchemaEvolutionManager
+
+  # Repository level configuration, read from a file named .sem. Every
+  # command walks up from the current directory to the first .sem; the
+  # directory holding it is the base directory. Lines follow the
+  # migration file attribute grammar:
+  #
+  #   sem.config.scripts_dir = schema/scripts
+  #
+  # Blank lines and lines starting with # are ignored. Paths are
+  # relative to the base directory. With no .sem anywhere, the base
+  # directory is the start directory and scripts_dir is ./scripts.
+  class Config
+
+    unless defined?(FILENAME)
+      FILENAME = ".sem"
+      PROPERTY_PREFIX = /^sem\.config\./
+      DEFAULT_SCRIPTS_DIR = "scripts"
+      NAMES = ["scripts_dir"]
+    end
+
+    attr_reader :path, :base_dir, :scripts_dir
+
+    # path: the .sem file this config was read from, or nil
+    # base_dir: absolute path against which relative paths resolve
+    # scripts_dir: scripts directory, relative to base_dir or absolute
+    def initialize(path, base_dir, scripts_dir)
+      @path = path
+      @base_dir = Library.normalize_path(File.expand_path(base_dir))
+      @scripts_dir = Library.normalize_path(File.expand_path(scripts_dir, @base_dir))
+    end
+
+    def Config.load(start_dir=Dir.pwd)
+      Preconditions.assert_class(start_dir, String)
+      start = File.expand_path(start_dir)
+      Preconditions.check_state(File.directory?(start), "Dir[%s] does not exist" % start)
+
+      if path = Config.find(start)
+        Config.parse(path)
+      else
+        Config.new(nil, start, DEFAULT_SCRIPTS_DIR)
+      end
+    end
+
+    # Returns the path to the first .sem file found walking up from
+    # dir to the filesystem root, or nil if there is none.
+    def Config.find(dir)
+      current = File.expand_path(dir)
+      loop do
+        candidate = File.join(current, FILENAME)
+        if File.file?(candidate)
+          return candidate
+        end
+        parent = File.dirname(current)
+        if parent == current
+          return nil
+        end
+        current = parent
+      end
+    end
+
+    def Config.parse(path)
+      Preconditions.check_state(File.file?(path), "File[%s] does not exist" % path)
+
+      values = {}
+      File.foreach(path).each_with_index do |line, index|
+        stripped = line.strip
+        if stripped.empty? || stripped.start_with?("#")
+          next
+        end
+
+        location = "File[%s] line %s" % [path, index + 1]
+        name, value = Library.parse_property(stripped, PROPERTY_PREFIX)
+        Preconditions.check_state(!name.nil? && !value.nil?,
+                                  "%s: Invalid line[%s]. Expected sem.config.<name> = <value>" % [location, stripped])
+        Preconditions.check_state(NAMES.include?(name),
+                                  "%s: Config with name[%s] not found. Must be one of: %s" % [location, name, NAMES.join(" ")])
+        Preconditions.check_state(!value.empty?,
+                                  "%s: Config[%s] - value cannot be blank" % [location, name])
+        Preconditions.check_state(!values.has_key?(name),
+                                  "%s: Config[%s] is specified more than once" % [location, name])
+        values[name] = value
+      end
+
+      Config.new(path, File.dirname(path), values["scripts_dir"] || DEFAULT_SCRIPTS_DIR)
+    end
+
+  end
+
+end

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

@@ -3,8 +3,8 @@ module SchemaEvolutionManager
   class ConnectionData
 
     DEFAULT_PORT = 5432 unless defined?(DEFAULT_PORT)
-    
-    attr_reader :host, :name, :port, :user
+
+    attr_reader :host, :name, :port, :user, :password
 
     def initialize(host, name, opts={})
       @host = host
@@ -19,50 +19,103 @@ module SchemaEvolutionManager
       Preconditions.check_argument(@port > 0, "Port must be > 0")
 
       @user = opts.delete(:user)
+      @password = opts.delete(:password)
       Preconditions.assert_empty_opts(opts)
     end
 
     # Returns a valid pgpass line entry representing this connection.
+    # The name parsed from a url can carry query parameters
+    # (?sslmode=require), which libpq does not match on, so they are dropped.
     #
     # @param password: Optional password to include in the connection string
     def pgpass(password=nil)
-      [@host, @port, @name, @user, password.to_s].join(":")
+      database = @name.to_s.split("?", 2).first
+      [@host, @port, database, @user, password].map { |v| ConnectionData.pgpass_escape(v) }.join(":")
+    end
+
+    # libpq reads ':' as the pgpass field separator and '\' as its escape,
+    # so both must be backslash-escaped within a field.
+    def ConnectionData.pgpass_escape(value)
+      value.to_s.gsub(/[\\:]/) { |c| "\\#{c}" }
+    end
+
+    # Returns the url with any password removed from it. The username is
+    # kept so that libpq still selects the matching pgpass entry.
+    #
+    # @param url e.g. postgres://user:pass@db.com:5553/test_db
+    def ConnectionData.strip_password(url)
+      ConnectionData.rebuild_lead(url) { |user, _password| user }
+    end
+
+    # Returns the url with any password replaced by [REDACTED], for display.
+    def ConnectionData.redact(url)
+      ConnectionData.rebuild_lead(url) { |user, password| password.nil? ? user : "#{user}:[REDACTED]" }
     end
 
     # Parses a connection string into a ConnectionData instance. You
-    # will get an error if the URL could not be parsed.
+    # will get an error if the URL could not be parsed. A password in the
+    # url is percent-decoded, as libpq does, and never appears in an error.
     #
     # @param url e.g. postgres://user1@db.com:5553/test_db
     def ConnectionData.parse_url(url)
+      display = ConnectionData.redact(url)
       protocol, rest = url.split("//", 2)
       if rest.nil?
-        raise "Invalid url[%s]. Expected to start with postgres://" % url
+        raise "Invalid url[%s]. Expected to start with postgres://" % display
       end
-      
+
       lead, name = rest.split("/", 2)
       if name.nil?
-        raise "Invalid url[%s]. Missing database name" % url
+        raise "Invalid url[%s]. Missing database name" % display
       end
 
-      parts = lead.split("@", 2)
-      if parts.size == 2
-        user = parts[0]
-        db_host = parts[1]
-      else
-        user = nil
-        db_host = lead
-      end
+      userinfo, db_host = ConnectionData.split_lead(lead)
+      user, password = ConnectionData.split_userinfo(userinfo)
 
       host, port = db_host.split(":", 2)
       if port
         if port.to_i.to_s != port
-          raise "Invalid url[%s]. Expected database port[%s] to be an integer" % [url, port]
+          raise "Invalid url[%s]. Expected database port[%s] to be an integer" % [display, port]
         end
       end
 
-      ConnectionData.new(host, name, :user => user, :port => port)
+      ConnectionData.new(host, name, :user => user && ConnectionData.percent_decode(user),
+                         :password => password && ConnectionData.percent_decode(password), :port => port)
     end
-    
+
+    # Splits "userinfo@host:port" on the LAST '@', since an unencoded
+    # password may itself contain one. Returns [userinfo or nil, host:port]
+    def ConnectionData.split_lead(lead)
+      index = lead.rindex("@")
+      index.nil? ? [nil, lead] : [lead[0...index], lead[(index + 1)..-1]]
+    end
+
+    # Splits "user:password" on the FIRST ':'. Returns [user, password or nil]
+    def ConnectionData.split_userinfo(userinfo)
+      return [nil, nil] if userinfo.nil?
+      user, password = userinfo.split(":", 2)
+      [user, password]
+    end
+
+    def ConnectionData.percent_decode(value)
+      value.gsub(/%([0-9A-Fa-f]{2})/) { $1.hex.chr }
+    end
+
+    # Yields [user, password] from the url's userinfo and returns the url
+    # with the userinfo replaced by the block's result. A url with no
+    # userinfo is returned unchanged.
+    def ConnectionData.rebuild_lead(url)
+      protocol, rest = url.split("//", 2)
+      return url if rest.nil?
+      lead, name = rest.split("/", 2)
+      userinfo, db_host = ConnectionData.split_lead(lead)
+      return url if userinfo.nil?
+      user, password = ConnectionData.split_userinfo(userinfo)
+      new_userinfo = yield(user, password)
+      new_lead = new_userinfo.to_s.empty? ? db_host : "#{new_userinfo}@#{db_host}"
+      name.nil? ? "#{protocol}//#{new_lead}" : "#{protocol}//#{new_lead}/#{name}"
+    end
+
   end
 
 end