schema-evolution-manager 0.9.24

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

@@ -0,0 +1,44 @@
+module SchemaEvolutionManager
+
+  # Simple library to ask user for input, with easy mocakability for
+  # testing
+  class Ask
+
+    TRUE_STRINGS = ['y', 'yes'] unless defined?(TRUE_STRINGS)
+
+    # Asks the user a question. Expects a string back.
+    def Ask.for_string(message, opts={})
+      default = opts.delete(:default)
+      Preconditions.assert_empty_opts(opts)
+
+      final_message = message.dup
+      if default
+        final_message << " [%s] " % default
+      end
+
+      value = nil
+      while value.to_s == ""
+        print final_message
+        value = get_input.strip
+        if value.to_s == "" && default
+          value = default.to_s.strip
+        end
+      end
+      value
+    end
+
+    # Asks the user a question. Returns a boolean. Boolean is defined as
+    # matching the strings 'y' or 'yes', case insensitive
+    def Ask.for_boolean(message)
+      value = Ask.for_string("%s (y/n) " % message)
+      TRUE_STRINGS.include?(value.downcase)
+    end
+
+    # here to help with tests
+    def Ask.get_input
+      STDIN.gets
+    end
+
+  end
+
+end

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

@@ -0,0 +1,50 @@
+module SchemaEvolutionManager
+
+  class BaselineUtil
+
+    def initialize(db, opts={})
+      @dry_run = opts.delete(:dry_run)
+      if @dry_run.nil?
+        @dry_run = true
+      end
+
+      @db = Preconditions.assert_class(db, Db)
+      @scripts = Scripts.new(@db, Scripts::SCRIPTS)
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    # Applies scripts in order, returning number of scripts applied
+    def apply!(dir)
+      Preconditions.check_state(File.directory?(dir),
+                                "Dir[%s] does not exist" % dir)
+
+      count = 0
+      @scripts.each_pending(dir) do |filename, path|
+        count += 1
+        if @dry_run
+          puts "[DRY RUN] Baselining #{filename}"
+          apply_dry_run(filename, path)
+        else
+          puts "Baselining #{filename}"
+          apply_real(filename, path)
+        end
+      end
+      count
+    end
+
+    private
+    def apply_dry_run(filename, path)
+      puts path
+      puts ""
+    end
+
+    def apply_real(filename, path)
+      @scripts.record_as_run!(filename)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,104 @@
+module SchemaEvolutionManager
+
+  class Db
+
+    attr_reader :url
+
+    def initialize(url)
+      @url = Preconditions.check_not_blank(url, "url cannot be blank")
+    end
+
+    # Installs schema_evolution_manager. Automatically upgrades schema_evolution_manager.
+    def bootstrap!
+      scripts = Scripts.new(self, Scripts::BOOTSTRAP_SCRIPTS)
+      dir = File.join(Library.base_dir, "scripts")
+      scripts.each_pending(dir) do |filename, path|
+        psql_file(path)
+        scripts.record_as_run!(filename)
+      end
+    end
+
+    # executes a simple sql command.
+    def psql_command(sql_command)
+      Preconditions.assert_class(sql_command, String)
+      command = "psql --no-align --tuples-only --command \"%s\" %s" % [sql_command, @url]
+      Library.system_or_error(command)
+    end
+
+    def Db.attribute_values(path)
+      Preconditions.assert_class(path, String)
+
+      options = []
+
+      ['quiet', 'no-align', 'tuples-only'].each do |v|
+        options << "--#{v}"
+      end
+
+      SchemaEvolutionManager::MigrationFile.new(path).attribute_values.map do |value|
+        if value.attribute.name == "transaction"
+          if value.value == "single"
+            options << "--single-transaction"
+          elsif value.value == "none"
+            # No-op
+          else
+            raise "File[%s] - attribute[%s] unsupported value[%s]" % [path, value.attribute.name, value.value]
+          end
+        else
+          raise "File[%s] - unsupported attribute named[%s]" % [path, value.attribute.name]
+        end
+      end
+
+      options
+    end
+
+    # executes sql commands from a file in a single transaction
+    def psql_file(path)
+      Preconditions.assert_class(path, String)
+      Preconditions.check_state(File.exists?(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 \"%s\" #{options} %s" % [tmp, @url]
+        Library.system_or_error(command)
+      end
+    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
+      psql_command(sql).to_i > 0
+    end
+
+    # Parses command line arguments returning an instance of
+    # Db. Exists if invalid config.
+    def Db.parse_command_line_config(arg_string)
+      Preconditions.assert_class(arg_string, String)
+      args = Args.new(arg_string, :optional => ['url', 'host', 'user', 'name', 'port'])
+      Db.from_args(args)
+    end
+
+    def Db.from_args(args)
+      Preconditions.assert_class(args, Args)
+      if args.url
+        Db.new(args.url)
+      else
+        base = "%s:%s/%s" % [args.host || "localhost", args.port || 5432, args.name]
+        url = args.user ? "%s@%s" % [args.user, base] : base
+        Db.new("postgres://" + url)
+      end
+    end
+
+    # Returns the name of the schema_evolution_manager schema
+    def Db.schema_name
+      "schema_evolution_manager"
+    end
+
+  end
+
+end

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

@@ -0,0 +1,118 @@
+module SchemaEvolutionManager
+
+  class InstallTemplate
+
+    def initialize(opts={})
+      @lib_dir = Preconditions.check_not_blank(opts.delete(:lib_dir), "lib_dir is required")
+      @bin_dir = Preconditions.check_not_blank(opts.delete(:bin_dir), "bin_dir is required")
+      Preconditions.assert_empty_opts(opts)
+    end
+
+    # Generates the actual contents of the install file
+    def generate
+      template = Template.new
+      template.add('timestamp', Time.now.to_s)
+      template.add('lib_dir', @lib_dir)
+      template.add('bin_dir', @bin_dir)
+      template.parse(TEMPLATE)
+    end
+
+    def write_to_file(path)
+      puts "Writing %s" % path
+      File.open(path, "w") do |out|
+        out << generate
+      end
+      Library.system_or_error("chmod +x %s" % path)
+    end
+
+    if !defined?(TEMPLATE)
+      TEMPLATE = <<-"EOS"
+#!/usr/bin/env ruby
+#
+# Generated on %%timestamp%%
+#
+
+load File.join(File.dirname(__FILE__), 'lib/schema-evolution-manager.rb')
+SchemaEvolutionManager::Library.set_verbose(true)
+
+lib_dir = '%%lib_dir%%'
+bin_dir = '%%bin_dir%%'
+version = SchemaEvolutionManager::Version.read
+
+version_name = "schema-evolution-manager-%s" % version.to_version_string
+version_dir = File.join(lib_dir, version_name)
+version_bin_dir = File.join(version_dir, 'bin')
+
+SchemaEvolutionManager::Library.ensure_dir!(version_dir)
+SchemaEvolutionManager::Library.ensure_dir!(bin_dir)
+
+Dir.chdir(lib_dir) do
+  if File.exists?("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'])
+    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'])
+  end
+end
+
+['CONVENTIONS.md', 'LICENSE', 'README.md', 'VERSION'].each do |filename|
+  SchemaEvolutionManager::Library.system_or_error("cp %s %s" % [filename, version_dir])
+end
+
+['bin', 'lib', 'lib/schema-evolution-manager', 'template', 'scripts'].each do |dir|
+  this_dir = File.join(version_dir, dir)
+  SchemaEvolutionManager::Library.ensure_dir!(this_dir)
+  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])
+      if dir == "bin" && filename != "sem-config"
+        SchemaEvolutionManager::Library.system_or_error("chmod +x %s/%s" % [this_dir, filename])
+      end
+    end
+  end
+end
+
+aliased_bin_dir = File.join(lib_dir, "schema-evolution-manager", "bin")
+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])
+    end
+  end
+end
+
+# Overrwrite bin/sem-config with proper location of lib dir
+init_file = File.join(version_dir, "bin/sem-config")
+SchemaEvolutionManager::Preconditions.check_state(File.exists?(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')
+end
+
+puts ""
+puts "schema-evolution-manager %s installed in %s" % [version.to_version_string, version_dir]
+puts "  - lib dir: %s" % lib_dir
+puts "  - bin dir: %s" % bin_dir
+puts ""
+
+found = `which sem-add`.strip
+if found == ""
+  puts "Recommend adding the bin directory to your path"
+  puts "  export PATH=%s:$PATH" % bin_dir
+  puts ""
+end
+
+puts "installation complete"
+puts ""
+
+EOS
+    end
+
+  end
+
+end

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

@@ -0,0 +1,176 @@
+module SchemaEvolutionManager
+  class Library
+
+    unless defined?(TMPFILE_DIR)
+      TMPFILE_DIR = "/tmp"
+      TMPFILE_PREFIX = "schema-evolution-manager-#{Process.pid}.tmp"
+    end
+    @@tmpfile_count = 0
+    @@verbose = false
+
+    # Creates the dir if it does not already exist
+    def Library.ensure_dir!(dir)
+      Preconditions.assert_class(dir, String)
+
+      if !File.directory?(dir)
+        Library.system_or_error("mkdir -p #{dir}")
+      end
+      Library.assert_dir_exists(dir)
+    end
+
+    def Library.assert_dir_exists(dir)
+      Preconditions.assert_class(dir, String)
+
+      if !File.directory?(dir)
+        raise "Dir[#{dir}] does not exist"
+      end
+    end
+
+    def Library.format_time(timestamp=Time.now)
+      timestamp.strftime('%Y-%m-%d %H:%M:%S %Z')
+    end
+
+    def Library.git_assert_tag_exists(tag)
+      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}"
+      end
+    end
+
+    def Library.assert_valid_tag(tag)
+      Preconditions.check_state(Version.is_valid?(tag), "Invalid tag[%s]. Format must be x.x.x (e.g. 1.1.2)" % tag)
+    end
+
+    def Library.git_has_remote?
+      system("git config --get remote.origin.url")
+    end
+
+    # Fetches the latest tag from the git repo. Returns nil if there are
+    # 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.new(tag) }.sort.last
+    end
+
+    def Library.tag_exists?(tag)
+      `git tag -l`.strip.include?(tag)
+    end
+
+    # Ex: Library.git_create_tag("0.0.1")
+    def Library.git_create_tag(tag)
+      Library.assert_valid_tag(tag)
+      has_remote = Library.git_has_remote?
+      if has_remote
+        Library.system_or_error("git fetch --tags origin")
+      end
+      Library.system_or_error("git tag -a -m #{tag} #{tag}")
+      if has_remote
+        Library.system_or_error("git push --tags origin")
+      end
+    end
+
+    # Generates a temp file name, yield the full path to the
+    # file. Cleans up automatically on exit.
+    def Library.with_temp_file(opts={})
+      prefix = opts.delete(:prefix)
+      Preconditions.assert_empty_opts(opts)
+
+      if prefix.to_s == ""
+        prefix = TMPFILE_PREFIX
+      end
+      path = File.join(TMPFILE_DIR, "%s.%s" % [prefix, @@tmpfile_count])
+      @@tmpfile_count += 1
+      yield path
+    ensure
+      Library.delete_file_if_exists(path)
+    end
+
+    def Library.delete_file_if_exists(path)
+      if File.exists?(path)
+        FileUtils.rm_r(path)
+      end
+    end
+
+    # Writes the string to a temp file, yielding the path. Cleans up on
+    # exit.
+    def Library.write_to_temp_file(string)
+      Library.with_temp_file do |path|
+        File.open(path, "w") do |out|
+          out << string
+        end
+        yield path
+      end
+    end
+
+    # Returns the relative path to the base directory (root of this git
+    # repo)
+    def Library.base_dir
+      @@base_dir
+    end
+
+    def Library.set_base_dir(value)
+      Preconditions.check_state(File.directory?(value), "Dir[%s] not found" % value)
+      @@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)
+      if Library.is_verbose?
+        puts command
+      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]
+      end
+      result
+    end
+
+    def Library.normalize_path(path)
+      Pathname.new(path).cleanpath.to_s
+    end
+
+    def Library.is_verbose?
+      @@verbose
+    end
+
+    def Library.set_verbose(value)
+      @@verbose = value ? true : false
+    end
+
+    # Returns a formatted string of git commits made since the specified tag.
+    def Library.git_changes(opts={})
+      tag = opts.delete(:tag)
+      number_changes = opts.delete(:number_changes) || 10
+      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 = Library.system_or_error(git_log_command)
+      out = ""
+      out << "Created: %s\n" % Library.format_time
+      if tag
+        out << "Git Tag: %s\n" % tag
+      end
+      out << "\n"
+      out << "%s:\n" % git_log_command
+      out << "  " << git_log.split("\n").join("\n  ") << "\n"
+      out
+    end
+
+    @@base_dir = Library.normalize_path(File.join(File.dirname(__FILE__), ".."))
+  end
+
+end