prick 0.18.0 → 0.20.2

data/lib/prick/branch.rb

@@ -1,254 +0,0 @@
-require "prick/state.rb"
-
-module Prick
-  class Branch
-    # Branch name. It is usually equal to the version but migrations use a
-    # <base_version>_<version> format instead
-    attr_reader :name 
-
-    # Version of this branch. Note that version and base_version are the same
-    # for feature branches
-    attr_reader :version
-
-    # Base version
-    attr_reader :base_version
-
-    # The release directory. It contains the release's .prick-migration file
-    attr_reader :directory
-
-    # The Schema object. This is shared by many all branches
-    attr_reader :schema
-
-    # Migration object. Running the migration object on the base release will
-    # migrate it to this release
-    attr_reader :migration
-
-    # Database name
-    def database() name end
-
-    # Classifiers
-    def release?() self.is_a?(Release) && !prerelease? end
-    def prerelease?() self.is_a?(PreRelease) end
-    def feature?() self.is_a?(Feature) end
-    def migration?() self.is_a?(MigrationRelease) end
-
-    # Note that `name` can be nil. It defaults to `version.to_s`
-    def initialize(name, version, base_version, directory, migration)
-      @name = name || migration.version.to_s
-      @version = version
-      @base_version = base_version
-      @directory = directory
-      @schema = Schema.new
-      @migration = migration
-    end
-
-    def dump
-      puts "#{self.class}"
-      indent {
-        puts "name: #{name}"
-        puts "version: #{version}"
-        puts "base_version: #{base_version}"
-        puts "directory: #{directory}"
-        print "migration: "
-        migration.dump
-        puts "database: #{database}"
-      }
-    end
-
-    def self.load(name) raise NotThis end
-
-    # True if the branch exists in git
-    def exist?() self.class.exist?(name) end
-
-    def create()
-      !exist? or raise Error, "Can't create branch #{name}, exists already"
-      Git.create_branch(name)
-      Git.checkout_branch(name)
-      prepare if !prepared?
-      self
-    end
-
-    # True if the branch exists on disk
-    def present?() self.class.present?(name) end
-
-    def prepared?() @migration.exist? end
-    def prepare() @migration.create end
-
-    def include(feature_version) @migration.append_feature(feature_version) end
-
-    def build(database) schema.build(database) end
-
-    # Used to checkout migrations. MigrationReleases checks out the
-    # corresponding branch while Release and PreRelease checks out a tag
-    def checkout_release() Git.checkout_branch(version) end
-
-    def migrate(database)
-      @migration.migrate(database)
-    end
-
-    def migrate_features(database)
-      @migration.migrate_features(database)
-    end
-
-    def self.directory(name) raise NotThis end
-    def self.exist?(name) Git.branch?(name) || Git.tag?(name) end
-    def self.present?(name) File.exist?(directory(name)) end
-
-    def <=>(other)
-      if !self.is_a?(MigrationRelease) && other.is_a?(MigrationRelease)
-        compare(other.base_version, other.version)
-      else
-        compare(other.version, other.base_version)
-      end
-    end
-
-  private
-    def compare(other_version, other_base_version)
-      r = version <=> other_version
-      return r if r != 0
-      if base_version.nil?
-        other_base_version.nil? ? 0 : -1
-      elsif other_base_version.nil?
-        1
-      else
-        base_version <=> other_base_version
-      end
-    end
-  end
-
-  class AbstractRelease < Branch
-    def create(schema_version = self.version)
-      super()
-      schema.version = schema_version
-      Git.add schema.version_file
-      self
-    end
-
-    def checkout_release() Git.checkout_tag(version) end
-
-    def tag!() Git.create_tag(version) end
-  end
-
-  class Release < AbstractRelease
-    def initialize(version, base_version)
-      !version.zero? || base_version.nil? or raise Internal, "Version 0.0.0 has no base release"
-      directory = self.class.directory(version.to_s)
-      migration = ReleaseMigration.new(version, base_version)
-      super(nil, version, base_version, directory, migration)
-    end
-
-    def self.load(name)
-      migration = ReleaseMigration.load(directory(name))
-      self.new(migration.version, migration.base_version)
-    end
-
-    def self.directory(name)
-      File.join(RELEASES_DIR, name)
-    end
-  end
-
-  class PreRelease < AbstractRelease
-    attr_reader :prerelease_version
-
-    def database() version.to_s end
-
-    def initialize(prerelease_version, base_version)
-      @prerelease_version = prerelease_version
-      version = prerelease_version.truncate(:pre)
-      directory = Release.directory(version.to_s)
-      migration = ReleaseMigration.new(version, base_version)
-      super(prerelease_version.to_s, version, base_version, directory, migration)
-    end
-
-    def self.load(name, prerelease_version)
-      migration = ReleaseMigration.load(directory(name))
-      self.new(prerelease_version, migration.base_version)
-    end
-
-    def create() 
-      super(prerelease_version) 
-    end
-
-    def increment
-      PreRelease.new(prerelease_version.increment(:pre), base_version)
-    end
-
-    def self.directory(name)
-      version = Version.new(name)
-      Release.directory(version.truncate(:pre).to_s)
-    end
-  end
-
-  class MigrationRelease < Branch
-    def database() version.to_s end
-
-    def initialize(version, base_version)
-      migration = MigrationMigration.new(version, base_version)
-      super(migration.name, version, base_version, migration.dir, migration)
-    end
-
-    def self.load(name)
-      directory = self.directory(name)
-      migration_state = MigrationState.new(directory).read
-      self.new(migration_state.version, migration_state.base_version)
-    end
-
-    def self.directory(name)
-      File.join(MIGRATIONS_DIR, name)
-    end
-  end
-
-  # Feature maintains a migration in the parent release but it is ignored when
-  # including the feature
-  class Feature < Branch
-    attr_reader :feature_name
-
-    def database() base_version.to_s end
-
-    def initialize(feature_name, base_version)
-      version = Version.new(base_version, feature: feature_name)
-      migration = FeatureMigration.new(feature_name, base_version)
-      super(version.to_s, version, base_version, migration.features_dir, migration)
-      @feature_name = feature_name
-    end
-
-    def create
-      super()
-      schema.version = version
-      Git.add schema.version_file
-      self
-    end
-
-    def include(feature_version) @migration.insert_feature(feature_version) end
-
-    def rebase(base_version)
-      new_version = Version.new(new_base_version, feature: feature_name)
-      name = new_version.to_s
-
-      Git.create_branch(name)
-      Git.checkout_branch(name)
-
-      symlink = self.directory(name)
-      FileUtils.ln_sr(directory, symlink, force: true) 
-      Git.add(symlink)
-
-      migration.base_version = new_base_version
-      migration.save
-
-      schema.version = new_version
-      Git.add ect.schema.version_file
-    end
-
-    def self.load(name)
-      directory = self.directory(name)
-      migration_state = MigrationState.new(directory).read
-      self.new(migration_state.version.feature, migration_state.base_version)
-    end
-
-    def self.directory(name)
-      version = Version.new(name)
-      File.join(Release.directory(version.truncate(:feature).to_s), version.feature.to_s)
-    end
-  end
-end
-

data/lib/prick/builder.rb

@@ -1,205 +0,0 @@
-require "prick/state.rb"
-
-module Prick
-  # Builder is a procedural object for building schemas and executing
-  # migrations. Builder use resources that can be executables, SQL files, YAML
-  # files, or directories. A resource is identified by a name (eg. 'my-tables')
-  # and is used to match a build file. Build files are looked up in the
-  # following order:
-  #
-  #   #{name} executable
-  #   #{name}.* executable
-  #   #{name}.yml
-  #   #{name}.sql
-  #   #{name}/
-  #
-  # The output from executable objects is expected to be SQL statements that
-  # are fed into postgres
-  #
-  # When a resource match a directory, the directory can contain a special
-  # default resource ('build' or 'migrate') that takes over the rest of the
-  # build process for that directory.  Typically, you'll use the 'build.yml' or
-  # 'migrate.yml' to control the build order of the other resources. If a
-  # directory doesn't contain a build resource, the resources in the directory
-  # are built in alphabetic order
-  #
-  # Build (but not migration) SQL scripts and executables are executed with
-  # search path set to containing schema
-  #
-  class Builder
-    attr_reader :database
-    attr_reader :directory
-    attr_reader :default # either "build" or "migrate"
-    attr_reader :lines
-
-    def initialize(database, directory, default)
-      @database = database
-      @directory = directory
-      @default = default
-      @execute = true
-      @lines = []
-      @cwd = Dir.getwd # used in error messages
-    end
-
-    def build(subject = default, execute: true)
-      @execute = execute
-      @lines = []
-#     puts "Building #{subject.inspect}"
-      Dir.chdir(directory) {
-        if subject
-          build_subject(subject)
-        else
-          build_directory(".")
-        end
-      }
-      @lines.reject! { |l| l =~ /^\s*--/ || l =~ /^\s*$/ }
-      self
-    end
-
-    def self.yml_file(directory) raise NotThis end
-
-  protected
-    def do_dir(path, &block)
-#     puts "do_dir(#{path.inspect})"
-      dir, file = File.split(path)
-      Dir.chdir(dir) { yield(file) }
-    end
-
-    def do_sql(path, schema: nil)
-#     puts "do_sql(#{path})"
-      do_dir(path) { |file| 
-        if @execute
-          begin
-            Rdbms.exec_file(database.name, file, user: database.user, schema: schema)
-          rescue Command::Error => ex
-            $stderr.puts ex.stderr
-            $stderr.puts "in #{reldir}/#{file}"
-            exit 1
-          end  
-        else
-          @lines += IO.readlines(file).map(&:chomp)
-        end
-      }
-      true
-    end
-
-    def do_exe(path, args = [], schema: nil)
-#     puts "do_exe(#{path.inspect}, #{args.inspect})"
-      do_dir(path) { |file| 
-        cmd = (["./#{file}"] + args).join(" ")
-        lines = Command.command cmd, stdin: [database.name, database.user]
-        if @execute
-          begin
-            Rdbms.exec_sql(database.name, lines.join("\n"), user: database.user, schema: schema)
-          rescue Command::Error => ex
-            $stderr.puts ex.stderr
-            $stderr.puts "from #{reldir}/#{file}"
-            exit 1
-          end
-        else
-          @lines += lines
-        end
-      }
-      true
-    end
-
-    def do_yml(path)
-#     puts "do_yml(#{path})"
-      dir, file = File.split(path)
-      YAML.load(File.read(path))&.each { |subject| build_subject(File.join(dir, subject)) }
-      true
-    end
-
-    # A subject can be both an abstract subject or a concrete file (*.yml, *.sql)
-    def build_subject(subject)
-      cmd, *args = subject.split(/\s+/)
-      if File.file?(cmd) && File.executable?(cmd)
-        do_exe(cmd, args)
-      elsif File.file?(subject) && subject.end_with?(".yml")
-        do_yml(subject)
-      elsif File.file?(subject) && subject.end_with?(".sql")
-        do_sql(subject)
-      elsif File.exist?(yml_file = "#{subject}.yml")
-        do_yml(yml_file)
-      elsif File.exist?(sql_file = "#{subject}.sql")
-        do_sql(sql_file)
-      elsif File.directory?(subject)
-        build_directory(subject)
-      else
-        false
-      end
-    end
-
-    def build_directory(path)
-      Dir.chdir(path) {
-        build_subject(File.join(path, @default)) || begin
-          if Dir["#{path}/#{default}", "#{path}/#{default}.yml", "#{path}/#{default}.sql"]
-            subjects = [default]
-          else
-            exes = candidates.select { |file| File.file?(file) && File.executable?(file) }
-            ymls = candidates.select { |file| file.end_with?(".yml") }.map { |f| f.sub(/\.yml$/, "") }
-            sqls = candidates.select { |file| file.end_with?(".sql") }.map { |f| f.sub(/\.sql$/, "") }
-            dirs = candidates.select { |file| File.directory?(file) }
-            subjects = (exes + ymls + sqls + dirs).uniq.sort.reject { |f| f != "diff" }
-          end
-          subjects.inject(false) { |a, s| build_subject(s) || a }
-        end
-      }
-    end
-
-  private
-    # Return the relative path to the current directory from the directory of
-    # the time of the instantiation of the Builder object. Used in error
-    # messages
-    def reldir
-      Dir.getwd.sub(/^#{@cwd}\//, "")
-    end
-  end
-
-  class MigrationBuilder < Builder
-    def initialize(database, directory)
-      super(database, directory, "migrate")
-    end
-
-    def self.yml_file(directory) File.join(directory, "migrate") + ".yml" end
-  end
-
-  class SchemaBuilder < Builder
-    def initialize(database, directory)
-      super(database, directory, "build")
-    end
-
-    def build(subject = nil, execute: true)
-      if subject
-        @execute = execute
-        @lines = []
-        Dir.chdir(directory) {
-          if File.executable?(subject)
-            do_exe(subject)
-          elsif subject.end_with?(".sql")
-            do_sql(subject)
-          else
-            build_subject(subject)
-          end
-        }
-      else
-        super(execute: execute)
-      end
-      self
-    end
-
-    def self.yml_file(directory) File.join(directory, "build") + ".yml" end
-
-  protected
-    def do_sql(path)
-      schema = Dir.getwd.sub(/^.*schema\/([^\/]+)(?:\/.*)?$/, '\1')
-      super(path, schema: schema)
-    end
-
-    def do_exe(path, args = [])
-      schema = Dir.getwd.sub(/^.*schema\/([^\/]+)(?:\/.*)?$/, '\1')
-      super(path, args, schema: schema)
-    end
-  end
-end
-

data/lib/prick/cache.rb

@@ -1,34 +0,0 @@
-
-module Prick
-  class Cache
-    def initialize
-    end
-
-    def exist?(version)
-      File.exist?(file(version))
-    end
-
-    def list
-      Dir.glob(File.join(CACHE_DIR, "*.sql.gz"))
-    end
-
-    def load(database, version)
-      Rdbms.load(database, file(version))
-    end
-
-    def save(database, version = database.version)
-      Rdbms.save(database, file(version))
-    end
-
-    # Returns list of removed files
-    def clean
-      l = list
-      FileUtils.rm(l)
-      l
-    end
-
-    def file(version)
-      File.join(CACHE_DIR, "#{version}.sql.gz")
-    end
-  end
-end

data/lib/prick/command.rb

@@ -1,102 +0,0 @@
-require 'fcntl'
-
-module Command
-  class Error < RuntimeError
-    attr_reader :status
-    attr_reader :stdout
-    attr_reader :stderr
-
-    def initialize(message, status, stdout, stderr)
-      super(message)
-      @status = status
-      @stdout = stdout
-      @stderr = stderr
-    end
-  end
-
-  # Execute the shell command 'cmd' and return standard output as an array of
-  # strings.  while stderr is passed through unless stderr: is false. If stderr:
-  # is true, it returns a tuple of [stdout, stderr] instead. The shell command
-  # is executed with the `errexit` and `pipefail` bash options
-  #
-  # The :stdin option is a line or an array of lines that'll be fed to the
-  # standard input of the command. Default is nil
-  # 
-  # It raises a Command::Error exception if the command fails unless :fail is
-  # true. The exit status of the last command is stored in ::status
-  #
-  def command(cmd, stdin: nil, stderr: false, fail: true)
-    cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
-
-    pw = IO::pipe   # pipe[0] for read, pipe[1] for write
-    pr = IO::pipe
-    pe = IO::pipe
-
-    STDOUT.flush
-
-    pid = fork {
-      pw[1].close
-      pr[0].close
-      pe[0].close
-
-      STDIN.reopen(pw[0])
-      pw[0].close
-
-      STDOUT.reopen(pr[1])
-      pr[1].close
-
-      STDERR.reopen(pe[1])
-      pe[1].close
-
-      exec(cmd)
-    }
-
-    pw[0].close
-    pr[1].close
-    pe[1].close
-
-    if stdin
-      pw[1].puts(stdin)
-      pw[1].flush
-      pw[1].close
-    end
-
-    @status = Process.waitpid2(pid)[1].exitstatus
-
-    out = pr[0].readlines.collect { |line| line.chop }
-    err = pe[0].readlines.collect { |line| line.chop }.grep_v(/^NOTICE:/)
-
-    pw[1].close if !stdin
-    pr[0].close
-    pe[0].close
-
-    result = 
-        case stderr
-          when true; [out, err]
-          when false; out
-          when NilClass; $stderr.puts err
-        else
-          raise Internal, "Unexpected value for :stderr - #{stderr.inspect}"
-        end
-
-    if @status == 0 || fail == false
-      result
-    elsif fail
-      raise Command::Error.new("\n" + cmd + "\n" + (out + err).join("\n") + "\n", status, out, err)
-    end
-  end
-
-  # Exit status of the last command
-  def status() @status end
-
-  # Like command but returns true if the command exited with the expected status
-  def command?(cmd, expect: 0)
-    command(cmd, fail: false)
-    @status == expect
-  end
-
-  module_function :command
-  module_function :status
-  module_function :command?
-end
-

data/lib/prick/database.rb

@@ -1,82 +0,0 @@
-
-module Prick
-  class Database
-    attr_reader :name
-    attr_reader :user
-
-    def initialize(name, user)
-      name != "" or raise "Illegal database name" 
-      @name = name
-      @user = user
-      @version = nil
-    end
-
-    def version(cache: true)
-      if cache && @version
-        @version
-      else
-        @version = begin
-            version = 
-                if exist? && Rdbms.exist_table?(name, "prick", "versions")
-                  Rdbms.select(name, "select version from prick.versions")&.first&.first
-                else
-                  nil
-                end
-            version && Version.new(version)
-        end
-      end
-    end
-
-    def version=(version)
-      @version = version && Version.new(version)
-      Rdbms.exec_sql(name, %(
-        update prick.versions
-        set major = '#{@version.major}',
-            minor = '#{@version.minor}',
-            patch = '#{@version.patch}',
-            pre = '#{@version.pre}',
-            version = '#{@version.to_s}'
-      )) if @version
-      @version
-    end
-
-    def exist?() Rdbms.exist_database?(name) end
-    def create() Rdbms.create_database(name, owner: user) end
-    def recreate() drop if exist?; create; @version = nil end
-    def drop() Rdbms.drop_database(name, fail: false); @version = nil end
-
-    def loaded?() !version.nil? end
-
-    def load(file) 
-      !loaded? or raise Internal, "Database #{name} is already loaded"
-      Rdbms.load(name, file, user: user)
-      version # Provoke load of version
-    end
-
-    def save(file) 
-      loaded? or raise Internal, "Database #{name} is not loaded"
-      Rdbms.save(name, file)
-      @version = nil 
-    end
-
-    # Hollow-out a database without dropping it. This is useful compared to a
-    # simple drop database since it wont block on other sessions wont block
-    def clean() 
-      if exist?
-        schemas = Rdbms.select_values(
-                      "postgres", 
-                      "select nspname from pg_namespace where nspowner != 10")
-        for schema in schemas
-          Rdbms.exec_sql(name, "drop schema \"#{schema}\" cascade")
-        end
-        Rdbms.exec_sql(name, "drop schema if exists public cascade")
-        Rdbms.exec_sql(name, "create schema public authorization postgres")
-        Rdbms.exec_sql(name, "grant usage, create on schema public to public")
-      else
-        create
-      end
-    end
-
-    def to_s() name end
-  end
-end