prick 0.15.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65c56eb6650acf4a9a15acc00589075fe551548f06df7f714db56b89fc8f0f7d
-  data.tar.gz: 585b320426243c5a3a82df87a924e89e03807c47b618a44350a8c7e646112f34
+  metadata.gz: 75523a625d7139830b419f2624f96af3c029dc1ad89b0cb40dec289f4b94b522
+  data.tar.gz: 450c53de9ef6b3c8627df7471076b87c559f367d7aef30e009a846bffa98390c
 SHA512:
-  metadata.gz: 72f83cb2412de38665afac3c6b3e7bd293d17ad35c64910bec6ef6db5080922d5d6771b044b76dcc52539da60327843861f681f979f3e04739a3cb04f804f8e1
-  data.tar.gz: c5460d78662709f1c5cb8bc5badd3243230cd41ff800b3d8fb9eee3d3e49cd314f51548dab060f0435d5c1aa58c3dbdfb22c490acc96b8e4dc101659675af027
+  metadata.gz: 98b24c53c2ae54007c46cb4157963ba049327e6ea9b73c5b6b8502367e58d9d018acdb74c9896394bd90a0335359719c0e02523f1e2965de1ed31c023285eeb9
+  data.tar.gz: 25b7425c7f8547bdd0be1ee0a570b1b6115f08ff2ba3bd8c8284cced0ffc5da1ecbc0670e57bb21d2b9a45276df03d0f2f3210b83712ff50f55f811991ba11e3

data/TODO

@@ -1,4 +1,7 @@
 
+o Add a top-level 'global' directory for stuff that doesn't belong to a schema or that 
+  require superuser privileges. prick-build should then execute the content of that
+  directory first before switching to the database user
 o Check for commits to tags
 o Accumulate version history in prick.versions instead of just having the newest
 o Using rc's in migration syntax: fork-version-fork-version.rc1 ?

data/exe/prick

@@ -10,6 +10,7 @@ require 'tempfile'
 include ShellOpts
 include Prick
 
+
 SPEC = %(
   -n,name=NAME
       Name of project. Defauls to the environment variable `PRICK_PROJECT` if
@@ -51,11 +52,13 @@ SPEC = %(
   list.cache!
       List cache files
 
-  build! -d,database=DATABASE -C,no-cache [TAG]
-      Build the current database from the content in the schemas/ directory.
-      With a tag the version is built into the associated versioned database
-      and the result is saved to cache unless the -C option is given. The -d
-      option overrides the default database
+  build! -d,database=DATABASE -s,state=FILE -C,no-cache [TAG]
+      Drop all users associated with the database before building the current
+      database from the content in the schemas/ directory.  With a tag the
+      version is built into the associated versioned database and the result is
+      saved to cache unless the -C option is given. The -d option overrides the
+      default database and the -s option overrides the default state file
+      (fox.state)
 
   make! -d,database=DATABASE -C,no-cache [TAG]
       Build the current database from the content in the schemas/ directory.
@@ -77,8 +80,12 @@ SPEC = %(
       given file
 
   drop! -a,all [DATABASE]
-      Drop the given database or all versioned databases. The --all option also
-      drops the project database
+      Drop the given database or all versioned databases. Users with a username
+      on the form <database>__<username> are also dropped. The --all option
+      also drops the project database
+
+  drop.users! [DATABASE]
+      Drop users with a username on the form <database>__<username>
 
   diff! -m,mark -t,tables -T,notables
       diff [FROM-DATABASE|FROM-VERSION [TO-DATABASE|TO-VERSION]]
@@ -153,7 +160,7 @@ SPEC = %(
       in the var/spool directory
 )
 
-
+DEFAULT_STATE_FILE = "fox.state"
 
 opts, args = ShellOpts.process(SPEC, ARGV)
 
@@ -185,6 +192,7 @@ begin
 
   # Create program object
   program = Program.new(quiet: opts.quiet?, verbose: opts.verbose?)
+  $verbose = opts.verbose? ? opts.verbose : nil
 
   # Handle init command
   if opts.subcommand == :init
@@ -198,7 +206,7 @@ begin
   # Change to parent directory containing the Prick version file if not found
   # in the current directory
   program.current_directory = Dir.getwd
-  while !Dir.getwd != "/" && !File.exist?(PRICK_VERSION_FILE)
+  while Dir.getwd != "/" && !File.exist?(PRICK_VERSION_FILE)
     Dir.chdir("..")
   end
 
@@ -236,7 +244,9 @@ begin
 
     when :build
       version = args.expect(0..1)
-      program.build(opts.build!.database, version, opts.build!.no_cache?)
+      state_file = File.expand_path(opts.build!.state || DEFAULT_STATE_FILE)
+      FileUtils.rm_f(state_file)
+      program.build(opts.build!.database, version, state_file, opts.build!.no_cache?)
 
     when :make
       command = opts.make!
@@ -258,7 +268,15 @@ begin
       program.save(version, file)
 
     when :drop
-      program.drop(args.expect(0..1), opts.drop!.all?)
+      command = opts.drop!
+      case command.subcommand
+        when :users
+          database = args.extract(0..1) || program.project.database.name
+          args.expect(0)
+          program.drop_users(database)
+        else
+          program.drop(args.expect(0..1), opts.drop!.all?)
+      end
 
     when :diff
       mark = opts.diff!.mark

data/lib/prick/branch.rb

@@ -1,5 +1,8 @@
 require "prick/state.rb"
 
+# FIXME FIXME FIXME Not used!
+
+
 module Prick
   class Branch
     # Branch name. It is usually equal to the version but migrations use a
@@ -116,6 +119,14 @@ module Prick
     end
   end
 
+  # A user defined branch. User defined branches have no version and only the
+  # #build method is defined TODO: Make all methods but #build private
+  class UserBranch < Branch
+    def initialize(name)
+      super(name, nil, nil, nil, nil)
+    end
+  end
+
   class AbstractRelease < Branch
     def create(schema_version = self.version)
       super()

data/lib/prick/builder.rb

@@ -1,20 +1,23 @@
 require "prick/state.rb"
 
+require 'indented_io'
+
 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:
+  # files, FOX 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}.fox
   #   #{name}/
   #
   # The output from executable objects is expected to be SQL statements that
-  # are fed into postgres
+  # are then 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
@@ -23,8 +26,8 @@ module Prick
   # 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
+  # Build SQL scripts and executables are executed with search path set to
+  # containing schema. This doesn't include migration script or executable
   #
   class Builder
     attr_reader :database
@@ -32,6 +35,11 @@ module Prick
     attr_reader :default # either "build" or "migrate"
     attr_reader :lines
 
+    def state_file() self.class.state_file end
+    def state_file=(file) self.class.state_file = file end
+    def self.state_file() @@state_file end
+    def self.state_file=(file) @@state_file = file end
+
     def initialize(database, directory, default)
       @database = database
       @directory = directory
@@ -42,9 +50,9 @@ module Prick
     end
 
     def build(subject = default, execute: true)
+      puts "build(#{subject.inspect}, execute: #{execute.inspect})" if $verbose > 0
       @execute = execute
       @lines = []
-#     puts "Building #{subject.inspect}"
       Dir.chdir(directory) {
         if subject
           build_subject(subject)
@@ -59,14 +67,23 @@ module Prick
     def self.yml_file(directory) raise NotThis end
 
   protected
-    def do_dir(path, &block)
-      dir, file = File.split(path)
-      Dir.chdir(dir) { yield(file) }
+    def do_path(path, &block)
+      puts "do_path(#{path.inspect})" if $verbose >= 3
+      if File.directory?(path)
+        dir, file = path, nil
+      else
+        dir, file = File.split(path)
+      end
+      if $verbose >= 2
+        indent { Dir.chdir(dir) { yield(file) } }
+      else
+        Dir.chdir(dir) { yield(file) }
+      end
     end
 
     def do_sql(path, schema: nil)
-#     puts "do_sql(#{path})"
-      do_dir(path) { |file| 
+      puts "do_sql(#{path})" if $verbose >= 2
+      do_path(path) { |file|
         if @execute
           begin
             Rdbms.exec_file(database.name, file, user: database.user, schema: schema)
@@ -82,10 +99,29 @@ module Prick
       true
     end
 
-    def do_exe(path, schema: nil)
-#     puts "do_exe(#{path})"
-      do_dir(path) { |file| 
-        lines = Command.command "./#{file} #{database.name} #{database.user}" # FIXME Security
+    def do_fox(path, schema: nil)
+      puts "do_fox(#{path.inspect}, #{schema.inspect})" if $verbose >= 2
+      do_path(path) { |file|
+        lines = Command.command "fox --state=#{state_file} --write --delete=none #{database.name} #{file}"
+        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
+      }
+    end
+
+    def do_exe(path, args = [], schema: nil)
+      puts "do_exe(#{path.inspect}, #{args.inspect})" if $verbose >= 2
+      do_path(path) { |file| 
+        cmd = (["./#{file}"] + args).join(" ")
+        lines = Command.command cmd, stdin: [database.name, database.user], stderr: nil
         if @execute
           begin
             Rdbms.exec_sql(database.name, lines.join("\n"), user: database.user, schema: schema)
@@ -102,20 +138,25 @@ module Prick
     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)) }
+      puts "do_yml(#{path})" if $verbose >= 2
+      do_path(path) { |file|
+        YAML.load(File.read(file))&.each { |subject| build_subject(subject) }
+      }
       true
     end
 
-    # A subject can be both an abstract subject or a concrete file (*.yml, *.sql)
+    # A subject can be both an abstract subject or a concrete file (*.yml, *.sql, or *.fox)
     def build_subject(subject)
-      if File.file?(subject) && File.executable?(subject)
-        do_exe(subject)
+      puts "build_subject(#{subject.inspect}) in #{Dir.getwd}" if $verbose > 0
+      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.file?(subject) && subject.end_with?(".fox")
+        do_fox(subject)
       elsif File.exist?(yml_file = "#{subject}.yml")
         do_yml(yml_file)
       elsif File.exist?(sql_file = "#{subject}.sql")
@@ -128,16 +169,19 @@ module Prick
     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"]
+      puts "build_directory(#{path.inspect}) in #{Dir.getwd}" if $verbose >= 2
+      do_path(path) { |_|
+        build_subject(@default) || begin
+          if !Dir["#{default}", "#{default}.yml", "#{default}.sql"].empty?
             subjects = [default]
           else
+            candidates = Dir["*"]
             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$/, "") }
+            foxs = candidates.select { |file| file.end_with?(".fox") }.map { |f| f.sub(/\.fox$/, "") }
             dirs = candidates.select { |file| File.directory?(file) }
-            subjects = (exes + ymls + sqls + dirs).uniq.sort.reject { |f| f != "diff" }
+            subjects = (exes + ymls + sqls + foxs + dirs).uniq.sort #.reject { |f| f != "diff" } FIXME ??
           end
           subjects.inject(false) { |a, s| build_subject(s) || a }
         end
@@ -189,13 +233,13 @@ module Prick
 
   protected
     def do_sql(path)
-      schema = Dir.getwd.sub(/^.*schema\/([^\/]+)(?:\/.*)?$/, '\1')
+      schema = Dir.getwd =~ /^.*schema\/([^\/]+)(?:\/.*)?$/ ? $1 : "public"
       super(path, schema: schema)
     end
 
-    def do_exe(path)
-      schema = Dir.getwd.sub(/^.*schema\/([^\/]+)(?:\/.*)?$/, '\1')
-      super(path, schema: schema)
+    def do_exe(path, args = [])
+      schema = Dir.getwd =~ /^.*schema\/([^\/]+)(?:\/.*)?$/ ? $1 : "public"
+      super(path, args, schema: schema)
     end
   end
 end

data/lib/prick/command.rb

@@ -15,14 +15,17 @@ module Command
   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:
+  # 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, stderr: false, fail: true)
+  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
@@ -52,12 +55,18 @@ module Command
     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 }
+    err = pe[0].readlines.collect { |line| line.chop }.grep_v(/^NOTICE:/)
 
-    pw[1].close
+    pw[1].close if !stdin
     pr[0].close
     pe[0].close
 
@@ -65,7 +74,9 @@ module Command
         case stderr
           when true; [out, err]
           when false; out
-          when NilClass; $stderr.puts err
+          when NilClass; 
+            $stderr.puts err
+            out
         else
           raise Internal, "Unexpected value for :stderr - #{stderr.inspect}"
         end

data/lib/prick/database.rb

@@ -61,11 +61,11 @@ module Prick
 
     # 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() 
+    def clean()
       if exist?
         schemas = Rdbms.select_values(
-                      "postgres", 
-                      "select nspname from pg_namespace where nspowner != 10")
+                      name, 
+                      "select nspname from pg_namespace where nspowner != 10 and nspname != 'prick'")
         for schema in schemas
           Rdbms.exec_sql(name, "drop schema \"#{schema}\" cascade")
         end

data/lib/prick/head.rb

@@ -120,6 +120,12 @@ module Prick
     end
   end
 
+  class UserBranch < Branch
+    def initialize(name)
+      super(nil, nil, nil)
+    end
+  end
+
   class ReleaseBranch < Branch
     def release_branch?() true end
 

data/lib/prick/program.rb

@@ -1,4 +1,5 @@
 
+require "pg_conn"
 require "prick.rb"
 
 module Prick
@@ -64,12 +65,14 @@ module Prick
       project.cache.list.each { |l| puts l }
     end
 
-    def build(database, version, nocache)
+    def build(database, version, state_file, nocache)
       into_mesg = database && "into #{database}"
       version_mesg = version ? "v#{version}" : "current schema"
       version &&= Version.new(version)
       version.nil? || Git.tag?(version) or raise Error, "Can't find tag v#{version}"
       database = database ? Database.new(database, project.user) : project.database(version)
+      drop_users(database.name)
+      Builder.state_file = state_file
       project.build(database, version: version)
       project.save(database) if version && !nocache
       mesg "Built", version_mesg, into_mesg
@@ -113,6 +116,7 @@ module Prick
 
     def drop(database, all)
       database.nil? || !all or raise Error, "Can't use --all when database is given"
+      return if !Rdbms.exist_database?(database)
       if database
         check_owned(database)
         dbs = [database]
@@ -123,10 +127,24 @@ module Prick
       dbs += Rdbms.list_databases(Prick.tmp_databases_re(project.name)) # FIXME: Only used in dev
       dbs.each { |db|
         Rdbms.drop_database(db)
+        drop_users db
         mesg "Dropped database #{db}"
       }
     end
 
+    # Drop all users that follows the per-database-user naming convention
+    # ("<database>__<username>")
+    def drop_users(database)
+      PgConn.new("postgres") { |postgres|
+        users = postgres.role.list.grep(/^#{database.sub(/-/, "_")}__/)
+        if postgres.rdbms.exist?(database)
+          PgConn.new(database) { |conn| conn.role.drop users, cascade: true }
+        else
+          postgres.role.drop users
+        end
+      }
+    end
+
     # `select` is a tri-state variable that can be :tables, :no_tables, or :all
     # (or any other value)
     def diff(from, to, mark, select)
@@ -267,240 +285,3 @@ module Prick
   end
 end
 
-__END__
-
-
-module Prick
-  class Program
-    def project() @project ||= Project.load end
-
-    attr_accessor :quiet
-    attr_accessor :verbose
-
-    def initialize(quiet: false, verbose: false)
-      @quiet = quiet
-      @verbose = verbose
-    end
-
-    def mesg(*args) puts args.compact.grep(/\S/).join(' ') if !quiet end
-    def verb(*args) puts args.compact.grep(/\S/).join(' ') if verbose end
-    def check_clean() Git.clean? or raise Error, "Repository is dirty - please commit your changes first" end
-
-    def initialize_directory(project_name, database_user, directory)
-      !Project.initialized?(directory) or raise Error, "Directory #{directory} is already initialized"
-      Project.initialize_directory(project_name, database_user, directory)
-      if project_name != File.basename(directory)
-        mesg "Initialized project #{project_name} in #{directory}"
-      else
-        mesg "Initialized project #{project_name}"
-      end
-    end
-
-    def info
-      if project.tag?
-        puts "At v#{project.version} tag"
-      else
-        puts "On branch #{project.branch.name}"
-      end
-      puts "  Git is " + (Git.clean? ? "clean" : "dirty")
-      bv = project.branch.version
-      dv = project.database.version
-      sv = project.branch.schema.version
-      puts "  Database version: #{dv}" + (dv != bv ? " (mismatch)" : "")
-      puts "  Schema version  : #{sv}" + (sv != bv ? " (mismatch)" : "")
-    end
-
-    # TODO: Move to project to take advantage of cache
-    def build(database, version, no_cache)
-      version = version && Version.new(version)
-      into_mesg = database && "into #{database}" 
-      database = database ? Database.new(database, project.user) : project.database(version)
-      if version
-        Git.tag?(version) or raise Error, "Can't find tag v#{version}"
-        cache_file = project.cache_file(version)
-        if !no_cache && File.exist?(cache_file)
-          project.load(cache_file, database: database)
-          mesg "Loaded v#{version}", into_mesg, "from cache"
-        else
-          project.build(database: database, version: version)
-          project.save(cache_file, database: database)
-          mesg "Built v#{version}", into_mesg
-        end
-      else
-        project.build(database: database)
-        mesg "Built current schema", into_mesg
-      end
-    end
-
-    def load(database, file_or_version)
-      version = Version.try(file_or_version)
-      into_mesg = database && "into #{database}" 
-      database = database ? Database.new(database, project.user) : project.database(version)
-      if version
-        file = project.cache_file(version)
-        File.exist?(file) or raise Error, "Can't find #{file} - forgot to build?"
-        project.load(file, database: database)
-        mesg "Loaded v#{version}", into_mesg
-      else
-        file = file_or_version
-        project.load(file, database: database)
-        mesg "Loaded #{file}", into_mesg
-      end
-    end
-
-    def save(database, file)
-      file ||= "#{ENV['USER']}-#{name}-#{branch}.sql.gz"
-      subject_mesg = database ? "database #{database}" : "current database"
-      database = database ? Database.new(database, project.user) : project.database(version)
-      project.save(file, database: database)
-      mesg "Saved", subject_mesg, "to #{file}"
-    end
-
-    def make(subject)
-      project.database.exist? or raise Error, "Project database is not present"
-      project.make(project.database, subject)
-    end
-
-    def list_releases(migrations: false, cancelled: false)
-      puts (project.list_releases(all: cancelled) + (migrations ? project.list_migrations : [])).sort.map(&:name)
-    end
-
-    def list_migrations
-      puts project.list_migrations.sort.map(&:name)
-    end
-
-    def list_upgrades(from = nil, to = nil)
-      from = from ? Version.new(from) : project.database.version
-      to = to ? Version.new(to) : project.branch.version
-      branches = project.list_upgrades(from, to)
-      puts branches.map(&:name)
-    end
-
-    def prepare_schema(name)
-      project.prepare_schema(name)
-      mesg project.message
-    end
-
-    def prepare_diff(version = nil)
-      version ||= 
-          if project.prerelease? || project.migration? || project.feature?
-            project.branch.base_version
-          else
-            project.branch.version
-          end
-      project.prepare_diff(version)
-      mesg "Remember to update the associated SQL migration files"
-    end
-
-    def prepare_release
-      check_clean
-      project.version.release? or raise Error, "You need to be on a release branch to prepare a release"
-      project.prepare_release
-      mesg project.message
-    end
-
-    def check
-      version ||= 
-          if project.prerelease? || project.migration?
-            project.branch.base_version
-          else
-            project.branch.version
-          end
-      project.check_migration(version)
-    end
-
-    # `arg` can be a version numer of a relative increase (eg. 'minor')
-    def create_release(arg = nil)
-      check_clean
-      if project.release?
-        arg or raise Error, "Need a version argument"
-        version = compute_version(project.version, arg)
-        project.create_release(Version.new(version))
-        mesg project.message
-      elsif project.prerelease?
-        arg.nil? or raise Error, "Illegal number of arguments"
-        project.create_release_from_prerelease
-        mesg project.message
-      else
-        raise Error, "You need to be on a release or pre-release branch to create a new release"
-      end
-    end
-
-    def cancel_release(arg)
-      project.cancel_release(Version.new(arg))
-    end
-
-    def create_prerelease(arg)
-      check_clean
-      if project.release?
-        version = %w(major minor patch).include?(arg) ? project.version.increment(arg.to_sym) : Version.new(arg)
-        project.prepare_release(commit: false)
-        prerelease = project.create_prerelease(version)
-        mesg "Created pre-release #{prerelease.version}"
-      elsif project.prerelease?
-        arg.nil? or raise Error, "Illegal number of arguments"
-        prerelease = project.increment_prerelease
-        mesg "Created pre-release #{prerelease.prerelease_version}"
-      else
-        raise Error, "You need to be on a release branch to create a pre-release"
-      end
-    end
-
-    def prepare_migration(arg)
-      check_clean
-      version = Version.new(arg)
-      project.release? or raise "You need to be on a release or migration branch to prepare a migration"
-      project.prepare_migration(version)
-      mesg project.message
-    end
-
-    def create_feature(name)
-      check_clean
-      project.release? or raise "You ned to be on a release branch to create a feature"
-      project.create_feature(name)
-      mesg "Created feature '#{name}'"
-    end
-
-    def include_feature(name_or_version)
-      check_clean
-      project.prerelease? or raise Error, "You need to be on a pre-release branch to include a feature"
-      version = Version.try(name_or_version) || 
-          Version.new(project.branch.base_version, feature: name_or_version)
-      Git.branch?(version.to_s) or raise Error, "Can't find feature #{version}"
-      project.include_feature(version)
-      mesg "Included feature '#{name_or_version}'"
-      mesg "Please resolve eventual conflicts and then commit"
-    end
-
-    def upgrade
-      # TODO: Shutdown connections
-      project.database.version != project.version or raise Error, "Database already up to date"
-      project.backup
-      begin
-        project.upgrade
-      rescue RuntimeError
-        project.restore
-        raise Fail, "Failed upgrading database, rolled back to last version"
-      end
-    end
-
-    def backup(file = nil) project.backup(file) end
-
-    def restore(file = nil)
-      file.nil? || File.exist?(file) or raise Error, "Can't find #{file}"
-      project.restore(file)
-    end
-
-  private
-    def compute_version(version, arg)
-      if arg.nil?
-        nil
-      elsif %w(major minor patch).include?(arg)
-        version.increment(arg.to_sym)
-      else
-        Prick::Version.new(arg)
-      end
-    end
-  end
-end
-

data/lib/prick/project.rb

@@ -92,7 +92,7 @@ module Prick
       begin
         branch = Head.load(name)
       rescue Version::FormatError
-        raise Fail, "Illegal branch name: #{name}"
+        branch = Prick::UserBranch.new(name)
       end
       state = ProjectState.new.read
       Project.new(state.name, state.user, branch)
@@ -222,12 +222,12 @@ module Prick
     end
 
     def generate_schema
-      build = SchemaBuilder.new(database, SCHEMA_DIR).build(execute: false)
+      build = SchemaBuilder.new(database, state_file, SCHEMA_DIR).build(execute: false)
       puts build.lines
     end
 
     def generate_migration
-      build = MigrationBuilder.new(database, MIGRATION_DIR).build(execute: false)
+      build = MigrationBuilder.new(database, state_file, MIGRATION_DIR).build(execute: false)
       puts build.lines
     end
 

data/lib/prick/version.rb

@@ -4,7 +4,7 @@
 
 # Required by gem
 module Prick
-  VERSION = "0.15.0"
+  VERSION = "0.19.0"
 end
 
 # Project related code starts here
@@ -95,7 +95,7 @@ module Prick
     # Parse a branch or tag name into a Version object. Return a [version, tag]
     # tuple where tag is true if name was a tag
     def self.parse(name)
-      name =~ VERSION_RE or raise Version::FormatError, "Expected a version, got #{version.inspect}"
+      name =~ VERSION_RE or raise Version::FormatError, "Expected a version, got #{name.inspect}"
       fork, tag, semver, feature = $1, $2, $3, $4
       version = Version.new(semver, fork: fork, feature: feature)
       [version, tag]

data/lib/prick.rb

@@ -27,5 +27,7 @@ require "prick/version.rb"
 require "ext/fileutils.rb"
 require "ext/shortest_path.rb"
 
+$verbose = 0 if $verbose.nil?
+
 module Prick
 end

data/prick.gemspec

@@ -34,4 +34,20 @@ Gem::Specification.new do |spec|
   spec.add_dependency "shellopts", "2.0.0.pre.14"
   spec.add_dependency "semantic"
   spec.add_dependency "indented_io"
+
+  # To be able to call fox in development mode (TODO: Remove)
+  spec.add_dependency "boolean"
+  spec.add_dependency "constrain"
+  spec.add_dependency "developer_exceptions"
+  spec.add_dependency "pg"
+  spec.add_dependency "dry-inflector"
+
+  # In development mode override load paths for gems whose source are located
+  # as siblings of this project directory
+  if File.directory?("#{__dir__}/.git")
+    local_projects = Dir["../*"].select { |path| 
+      File.directory?(path) && File.exist?("#{path}/Gemfile")
+    }.map { |relpath| "#{File.absolute_path(relpath)}/lib" }
+    $LOAD_PATH.unshift *local_projects
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prick
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-19 00:00:00.000000000 Z
+date: 2021-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shellopts
@@ -52,6 +52,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: boolean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: constrain
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: developer_exceptions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A release control and management system for postgresql
 email:
 - claus.l.rasmussen@gmail.com