prick 0.28.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '022876c913aadf3a2b42646f514f51c2db481c32db42a5903f2dbce88303d423'
-  data.tar.gz: 1772f43a5a99fe93b97e748488f3c5bfa93fddce768176744ebb27e983cbb475
+  metadata.gz: ec055b6544046998736dddf822f2ff0563c6e16deeae039f586ec96651ce5b65
+  data.tar.gz: 2687ec86827fc0c808a916462b34f7b71ab993fe0d7d5ef5444d4f5775ce91e2
 SHA512:
-  metadata.gz: d8c647cc168aee7f0aab47d39d6ce1050331a06b6aa7a04fc8173152618432c377eb7ce42784eb95d2a70134be10bddd0ff3a43298c2e20af8a3649dc8227451
-  data.tar.gz: 84068d08a68d2b1177054faa4d31218bf7bc66cf437bf255a6ff2404c0126e10288e58519e11fe7c80029c7169ff9e3a59be5327c39f8fd112bc0a846519d833
+  metadata.gz: c278a8a151aefeb23c40dc2468fd271e14b45a031f73942453157b3e8789209fa55094bde9d92276fa85c530c204795e8474bd688ccfca139b7945501f373e73
+  data.tar.gz: 4d2df4c44b4c10e13d89ee584e5c1839b963d5c7bff42f5618c20b66173f540383cf1bc3059670a5af4922c4ad594a5ceaddc617cdbf2f54a60f2c8a96ce4653

data/TODO

@@ -1,3 +1,4 @@
+o eval vs exit
 o Make it possible to define (nested) environments
 o Use standard directory layout
 

data/exe/prick

@@ -1,9 +1,5 @@
 #!/usr/bin/env ruby
 
-#$LOAD_PATH.unshift "/home/clr/prj/shellopts/lib"
-#$LOAD_PATH.unshift "/home/clr/prj/pg_graph/lib"
-#$LOAD_PATH.unshift "/home/clr/prj/fixture_fox/lib"
-
 require 'bootsnap'
 begin
   cache_dir = "/run/user/" + `id -u`.chomp
@@ -38,10 +34,19 @@ SPEC = %(
       Change to directory DIR before doing anything else
 
   -d,database=DATABASE
-      Override database name from prick.yml
+      Override database name. Default is read from .prick.context
 
   -U,username=USERNAME
-      Override username from from prick.yml
+      Override username. Default is read from .prick.context
+
+  -e,environment=ENVIRONMENT
+      Override environment. Default is read from from .prick.context
+
+  -p,project=PRICK-FILE
+      Override default environment file ('prick.yml')
+
+  -c,context=CONTEXT-FILE
+      Override default context file ('.prick.context')
 
   version!
       Print project version
@@ -62,6 +67,9 @@ SPEC = %(
   teardown!
       Drop the database and the database user. TODO: Also run teardown scripts
 
+  clean!
+      Empties the database and drops related users except the database user
+
   create.data!
   create.schema!
   create.database!
@@ -79,8 +87,9 @@ SPEC = %(
   drop! -- [KIND]
       @ Drop objects
 
-      Kind can be 'users', 'data', 'schema', 'database' (the default), or 'all'. It is
-      not an error if the object doesn't exist. TODO Only 'users' is currently defined
+      Kind can be 'users', 'data', 'schema', 'user', 'database' (the default),
+      or 'all'. It is not an error if the object doesn't exist. TODO 'data' and
+      'schema' is not implemented
 
   build! -f,force -t,time --dump=KIND? -- [SCHEMA]
       Build the project. If SCHEMA is defined, later schemas are excluded.
@@ -98,7 +107,10 @@ SPEC = %(
 
   fox! -- FILE...
       Load fox file data. Data are reset to their initial state after build
-      before the fox data are loaded
+      before the fox data are loaded. This makes it possible to experiment with
+      different data sets
+
+      # TODO: A --clean option that resets data
 
   release! -- KIND
       Create a release of the given kind. KIND can be 'major', 'minor', or
@@ -112,6 +124,7 @@ SPEC = %(
   dump.data!
   dump.schema!
   dump.database!
+  dump.environment!
       TODO
 
   dump.migration! --force -- VERSION
@@ -154,13 +167,18 @@ begin
   # Check state
   File.exist?(PRICK_PROJECT_FILE) or raise Prick::Error, "Not in a prick project directory"
 
+  # Handle -p and -c
+  project_file = opts.project || PRICK_PROJECT_PATH
+  context_file = opts.context || PRICK_CONTEXT_PATH
+
   # Load state
-  Prick.state = State.load
+  state = Prick.state = State.load(project_file, context_file)
+
+  # Set database, username and environment
+  database = state.database = opts.database || state.database
+  username = state.username = opts.username || state.username
+  environment = state.environment = opts.environment || state.environment
 
-  # Handle -d and -U options
-  database = opts.database || Prick.state.database
-  username = opts.username || Prick.state.username
-    
   # Expect a sub-command
   cmd = opts.subcommand! or raise Prick::Error, "Subcomand expected"
 
@@ -180,6 +198,9 @@ begin
     when :teardown!
       Prick::SubCommand.teardown(database, username)
 
+    when :clean!
+      Prick::SubCommand.clean(database)
+
     when :create!
       create_command = opts.create!
       case create_command.subcommand
@@ -190,14 +211,15 @@ begin
               username, version, 
               force: create_command.subcommand!.force?, 
               file: create_command.subcommand!.file)
-        else
-          raise NotImplementedError
+      else
+        raise NotImplementedError
       end
 
     when :build!
       dump = cmd.dump? ? cmd.dump("batches")&.to_sym || :batches : nil
+#     exclude = cmd.exclude? ? cmd.exclude.split(",") : []
       Prick::SubCommand.build(
-        database, username, args.expect(0..1), force: cmd.force?, timer: cmd.time?, dump: dump)
+          database, username, args.expect(0..1), force: cmd.force?, timer: cmd.time?, dump: dump)
 
     when :make!
       dump = cmd.dump? ? cmd.dump("batches")&.to_sym || :batches : nil
@@ -212,6 +234,8 @@ begin
           Prick::SubCommand.drop_all(database)
         when :users
           Prick::SubCommand.drop_users(database)
+        when :user
+          Prick::SubCommand.drop_user(username)
         when :database
           Prick::SubCommand.drop_database(database)
         when :data, :schema
@@ -233,20 +257,44 @@ begin
     when :dump!
       subject = cmd.subcommand!
       case cmd.subcommand
-        when :migration
+        when :migration!
           arg = args.expect(1)
           version = PrickVersion.try(arg) or raise "Illegal version number: #{arg}"
           Prick::SubCommand.create_migration(username, version, force: subject.force?, file: "/dev/stdout")
-        when :data, :schema, :database
+        when :type!
+          conn = PgConn.new(database, username)
+          builder = Prick::Build::Builder.new(conn, Prick::SCHEMA_DIR)
+          meta = PgMeta.new(conn, exclude_schemas: builder.pg_graph_ignore_schemas)
+          graph = PgGraph::Type.new(meta, builder.reflections_file)
+          graph.dump
+        when :data!, :schema!, :database!
           raise NotImplementedError
+        when :environment!
+          puts state.bash_source
       else
-        raise Prick::Error, "Unknown subject: #{subject.inspect}"
+        raise Prick::Error, "Unknown dump object: #{cmd.subcommand!.__name__}"
       end
 
+
     else
       raise Prick::Fail, "Internal error: Unhandled command - #{opts.subcommand.inspect}"
   end
 
+rescue Prick::Build::PostgresError => ex
+  $stderr.puts "Error: #{ex.message}"
+  if STDERR.tty?
+    file, lineno, charno = ex.err
+    if file && lineno
+      lines = IO.readlines(file).map(&:chomp)
+      i = lineno - 1
+      from = [i - 10, 0].max
+      to = [i + 10, lines.size].min
+      $stderr.puts
+      $stderr.puts lines[from...i], lines[i].bold, lines[i+1...to]
+    end
+  end
+  exit 1
+
 rescue RuntimeError, IOError, ShellOpts::Failure, Prick::Fail, Prick::Build::PostgresError => ex 
   ShellOpts.failure(ex.message)
 

data/lib/builder/batch.rb

@@ -14,10 +14,10 @@ module Prick
         @nodes = [] 
       end
 
-      def execute(&block)
+      def execute(**opts, &block)
         name = self.class.to_s.sub(/.*::/, "").split(/(?=[A-Z])/).map(&:downcase).join(" ")
         time "Execute #{name} (nodes: #{nodes.size})" do
-          yield
+          yield(**opts)
         end
       end
 
@@ -28,23 +28,38 @@ module Prick
     end
 
     class SqlBatch < BuildBatch
-      def execute
+      def execute(step: true) # This is marginally faster!
         super {
           begin
             sql = []
-            # A SQL batch allows the first node to be an executable
-            if nodes.first.is_a?(ExeNode)
-              time "Execute script" do
-                sql = [nodes.first.source]
+            file = nil
+            node = nil
+
+            # A SQL batch allows the first node to be an evaluated or executed node
+            if nodes.first.is_a?(CommandNode)
+              node = nodes.shift
+              sql = [node.source]
+            end
+
+            if step
+              conn.execute sql, silent: true if !sql.empty?
+              for node in nodes
+                conn.execute node.source, silent: true
               end
+            else
+              node = nil
+              conn.execute sql + nodes[sql.size..-1].map(&:source), silent: true
             end
-            conn.execute sql + nodes[sql.size..-1].map(&:source)
 
-          rescue PG::SyntaxError, PG::Error => ex 
-            error, line, pos = parse_pg_message(ex.message)
-            if line
+          rescue PG::Error => ex
+            error, line, char = conn.err
+            file = nil
+            if step
+              ;
+            elsif line
+              # Locate error node and make line number relative
               if line < nodes.first.lines
-                node = nodes.first;
+                node = nodes.first
               else
                 line -= nodes.first.lines
                 node = nodes[1..-1].find { |node|
@@ -58,26 +73,20 @@ module Prick
                   end
                 }
               end
+#             file = node.path
+            end
 
-              if node.is_a?(SqlNode)
-                message = ["prick: #{error} in #{node.path}", line, pos].compact.join(":")
-              else
-                message = "prick: #{error} from #{node.path}"
-              end
+            if node.is_a?(SqlNode)
+              message = ["#{error} in #{node.path}", line, char].compact.join(":")
+            elsif node
+              message = "#{error} from #{node.path}"
             else
-              raise
+              message = conn.errmsg + " in SQL batch"
             end
-            raise PostgresError.new(message)
+            raise PostgresError.new(message, file, line, char)
           end
         }
       end
-
-    private
-      # Returns [error, line, pos] tuple
-      def parse_pg_message(message)
-        message =~ /ERROR:\s*(.*?)\n(LINE (\d+): ).*?\n(\s*\^)/m or return nil
-        [$1, $3.to_i, $4.size - $2.size]
-      end
     end
 
     class ModuleBatch < BuildBatch
@@ -139,7 +148,7 @@ module Prick
             # FIXME: Why only in FoxBatch - should be set higher up in the system
             conn.execute "update prick.versions set built_at = now() at time zone 'UTC'"
           rescue PG::SyntaxError, PG::Error => ex 
-            raise PostgresError, "prick: #{ex.message}"
+            raise PostgresError.new(ex.message)
           end
         }
         t_type.emit

data/lib/builder/builder.rb

@@ -10,7 +10,18 @@ include Constrain
 module Prick
   module Build
     class Error < StandardError; end
-    class PostgresError < Error; end
+    class PostgresError < Error
+      attr_reader :file
+      attr_reader :lineno
+      attr_reader :charno
+
+      def initialize(message, file = nil, lineno = nil, charno = nil)
+        super(message)
+        @file, @lineno, @charno = file, lineno, charno
+      end
+
+      def err = [@file, @lineno, @charno]
+    end
 
     class Builder
       # PgConn object

data/lib/builder/node.rb

@@ -41,7 +41,7 @@ module Prick
         @source_lines = nil
       end
 
-      def to_s() [path, args].compact.join(" ") end
+      def to_s() @to_s ||= [path, args].compact.join(" ") end
       def inspect() to_s end
       def dump() puts "#{inspect} (#{schema})" end
 
@@ -121,41 +121,45 @@ module Prick
       def self.objects() @@objects end
     end
 
-    class ExeNode < Node
-      # Using a pipe instead of just executing the command shaves off some
-      # deciseconds spent starting up bash. It expects the process to read
-      # database/username from standard input
-      attr_reader :pipe
+    class CommandNode < Node
+      alias_method :command, :to_s
+
+      def filename = File.basename(path)
+      def relpath = path.sub(/^#{Dir.getwd}\//, "")
 
       def initialize(parent, phase, path, args = nil)
+        constrain args, [String]
         super(parent, phase, :exe, path, args)
-        @pipe = Command::Pipe.new(to_s, stderr: nil)
       end
 
       def inspect() "#{path} #{(args || []).join(" ")}" end
 
     protected
-      def read_source
+      def execute_command
         begin
-          pipe.puts [conn.name, conn.user]
-          sql = pipe.wait
+          Command.command(Prick.state.bash_environment, command)
         rescue Command::Error => ex
-          message = "prick: Error executing '#{to_s}'\n" + ex.stderr.map { |l| "   #{l}" }.join("\n")
+          message = "Error executing '#{command}'\n" + ex.stderr.map { |l| "   #{l}" }.join("\n")
           raise Prick::Error.new(message)
-          
-        rescue Errno::EPIPE
-          raise Prick::Error, "Pipe fail in #{path} called from #{parent.path}\n" + 
-                              "Tip: Read username/database from standard input"
-        end
-        if pipe.status != 0
-          $stderr.puts pipe.error
-          raise Prick::Error, "Failed executing #{path} called from #{parent.path}"
         end
+      end
+    end
+
+    class EvalNode < CommandNode
+      def read_source
+        sql = execute_command
         @source_lines = 1 + 1 + sql.count("\n")
         ["set search_path to #{schema}, pg_temp;\n", sql]
       end
     end
 
+    class ExecNode < CommandNode
+      def read_source
+        execute_command
+        []
+      end
+    end
+
     # A build.yml file node
     class BuildNode < Node
       def nodes() @nodes ||= init_nodes + decl_nodes + seed_nodes + term_nodes end

data/lib/builder/parser.rb

@@ -34,6 +34,48 @@ module Prick
         end
       end
 
+      # Search for an executable in path. Return nil if not found
+      def find_executable(filename) # ChatGPT
+        Prick.state.executable_search_path.split(File::PATH_SEPARATOR).each do |directory|
+          path = File.join(directory, filename)
+          return path if File.executable?(path)
+        end
+        nil
+      end
+
+      # Expand environments variables file name. Iterates through inherited
+      # environments if the file name contain the $ENVIRONMENT variable. Return
+      # nil if not found
+      #
+      # The hierarchy of environments is defined in the PRICK_ENVIRONMENT_FILE
+      #
+      def expand_filename(dir, filename)
+        environment = Prick.state.environment
+        bash_vars = Prick.state.bash_environment
+
+        last = nil
+        for env in [environment] + Environment[environment].ancestors.reverse
+          bash_vars["ENVIRONMENT"] = env
+          file = expand_variables(filename, bash_vars)
+          last ||= (file != last and file) or return nil # return if no ENVIRONMENT substitution
+          path = (file.start_with?("/") ? file : File.join(dir, file))
+
+          # Check for file (may be executable)
+          return path if File.exist?(path)
+
+          # Check for executable in search path
+          path = find_executable(file) and return path if file !~ /\//
+        end
+
+        # Return nil if not found
+        return nil
+      end
+
+      # Expand $ENVIRONMENT variable
+      def expand_string(string)
+        expand_variables(string, Prick.state.bash_environment)
+      end
+
       def parse_directory(parent, dir)
         build_file = "#{dir}/build.yml".sub(/\/\//, "/")
         if File.exist? build_file
@@ -77,89 +119,25 @@ module Prick
         unit
       end
 
-      # Expand $ENVIRONMENT variable in file names. The function implements a
-      # hierarchy of environments:
-      #
-      #   production
-      #     (online)
-      #   development
-      #     online
-      #     offline
-      #       backend
-      #       frontend
-      #       test
-      #
-      # If an environment doesn't exist in #dir, then the higher level
-      # environments are tried in turn. Eg. if the current environment is
-      # 'test', the algorithm expands '$ENVIRONMENT' to 'test', 'offline', and
-      # 'development' until an existing file is found. If no file is found the
-      # the unexpanded value is returned
-      #
-      # NOTE: This is a hardcoded feature for an internal project. It is
-      #       configurable in the next major version
-      #
-      def expand_filename(dir, filename)
-        if File.exist?("#{dir}/#{filename}")
-          return filename
-        elsif filename =~ /\$ENVIRONMENT|\$\{ENVIRONMENT\}/
-          env = Prick.state.environment.to_s
-          while true
-            file = expand_variables(filename, ENVIRONMENT: env, PWD: Dir.getwd)
-            return file if File.exist? "#{dir}/#{file}"
-            case env
-              when "production"
-                file = expand_variables(filename, ENVIRONMENT: "online", PWD: Dir.getwd) or return nil
-                return file if File.exist? "#{dir}/#{file}"
-                return nil
-              when "development"; return nil
-              when "online"; env = "development"
-              when "offline"; env = "development"
-              when "backend"; env = "offline"
-              when "frontend"; env = "offline"
-              when "test"; env = "offline"
-            else
-              raise Error, "Illegal env: '#{env}'"
-            end
-          end
-        else
-          return nil
-        end
-      end
-
-      # Expand $ENVIRONMENT variable
-      def expand_string(string)
-        expand_variables(string, ENVIRONMENT: Prick.state.environment.to_s, PWD: Dir.getwd)
-      end
-
+      # Returns path, filename, and an array of arguments. It is an error if
+      # the file can't be found unless #optional is true. In that case a nil
+      # value is returned
       def parse_file_entry(unit, dir, entry)
         entry = entry.sub(/\/$/, "")
         if entry =~ /^(\S+?)(\?)?(?:\s+(.+))?\s*$/
-          filename = $1
+          command = $1
           optional = !$2.nil?
-          args = expand_string($3 || '').split
-          file = expand_filename(dir, filename) 
-          file || optional or raise Error, "Can't find #{filename} in #{dir} from #{unit}"
-          !file.nil? or return nil
+          rest = $3
+          args = expand_string(rest || '').split
+          path = expand_filename(dir, command)
+          path || optional or raise Error, "Can't find '#{entry}' in #{dir}/ from #{unit}"
+          !path.nil? or return nil
         else
           raise Error, "Not a file name: '#{entry}'"
         end
-        path = "#{dir}/#{file}"
-        [path, entry, file, args].flatten
+        [path, Array(args).flatten]
       end
 
-#     def parse_file_entry(dir, entry)
-#       name = expand_environment(dir, entry)
-#       name.sub!(/\/$/, "")
-#       if name =~ /^(\S+)\s+(.+)$/ # has arguments -> exe
-#         file = $1
-#         args = $2.split
-#       else
-#         file = name
-#       end
-#       path = "#{dir}/#{file}"
-#       [path, name, file, args]
-#     end
-
       def parse_entry(unit, phase, dir, entry)
         if entry.is_a?(Hash)
           entry.size == 1 or raise Error, "sql and module are single-line values"
@@ -168,34 +146,40 @@ module Prick
             when "sql"
               InlineNode.new(unit, phase, unit.path, expand_string(value))
             when "call"
-              (path, name, file, klass, command, args = parse_file_entry(unit, dir, value)) or return nil
+              (path, args = parse_file_entry(unit, dir, value)) or return nil
+              args.size >= 2 or raise Error, "Illegal number of arguments"
+              klass = args.shift
+              command = args.shift
               klass && command or raise "Illegal number of arguments: #{value}"
-              ModuleNode.new(unit, phase, "#{dir}/#{file}", klass, command, args)
+              ModuleNode.new(unit, phase, path, klass, command, args)
+            when "eval"
+              (path, args = parse_file_entry(unit, dir, value)) or return nil
+              EvalNode.new(unit, phase, path, args)
             when "exec"
-              (path, name, file, args = parse_file_entry(unit, dir, value)) or return nil
-              ExeNode.new(unit, phase, path, args)
+              (path, args = parse_file_entry(unit, dir, value)) or return nil
+              ExecNode.new(unit, phase, path, args)
           else
             raise Error, "Illegal key: #{key}"
           end
         else
-          (path, name, file, args = parse_file_entry(unit, dir, entry)) or return nil
+          (path, args = parse_file_entry(unit, dir, entry)) or return nil
           if File.directory? path
             parse_directory(unit, path)
+          elsif File.executable? path
+            ExecNode.new(unit, phase, path, args)
           elsif File.file? path
             case path
               when /\.sql$/
                 SqlNode.new(unit, phase, path)
               when /\.fox$/
                 FoxNode.new(unit, :seed, path)
+              when /build-.*\.yml$/
+                parse_build_file(unit, dir, path)
             else
-              if File.executable? path
-                ExeNode.new(unit, phase, path, args)
-              else
-                raise Error, "Unrecognized file type #{File.basename(path)} in #{dir}"
-              end
+              raise Error, "Expected executable, fox, or sql file: #{File.basename(path)} in #{dir}"
             end
           else
-            raise Error, "Can't find #{name} in #{dir} from #{unit}"
+            raise Error, "Can't find '#{entry}' in #{dir}/ from #{unit}"
           end
         end
       end

data/lib/ext/expand_variables.rb

@@ -6,7 +6,7 @@
 # backslash. All occurrences of a variable in the string are replaced
 #
 # The str argument is the template string and the variables argument is a hash
-# from variable name (Symbol) to variable value
+# from variable name (String) to variable value
 #
 # Note that the characters '\x00' and '\x01' are used internally and may not be
 # present in the template string
@@ -17,11 +17,24 @@ def expand_variables(str, variables) # ChatGPT
   
   # Expand variables
   str.gsub!(/\$(\w+)\b|\$\{(\w+)\}/) do |match| # Strange that '\b' is necessary
-    key = ($1 || $2).to_sym
-    variables[key] || match
+    key = $1 || $2
+#   variables[key] || match
+    variables[key] || ""
   end
 
   # Restore escaped characters
   str.gsub("\x00", '\\').gsub("\x01", '$')
 end
 
+# Return true if any of the variables will be expanded
+def expand_variables?(str, variables)
+  # Replace escaped bashslashes and dollar signs
+  str = str.gsub('\\\\', "\x00").gsub('\\$', "\x01")
+  
+  # Look for expansion
+  str.gsub!(/\$(\w+)\b|\$\{(\w+)\}/) do |match| # Strange that '\b' is necessary
+    return true if variables.include?($1 || $2)
+  end
+
+  return false
+end

data/lib/local/ansi.rb

@@ -0,0 +1,6 @@
+
+class String
+  ANSI_BOLD_START = "\e[1m"
+  ANSI_BOLD_STOP = "\e[22m"
+  def bold = "#{ANSI_BOLD_START}#{self.to_s}#{ANSI_BOLD_STOP}"
+end

data/lib/local/command.rb

@@ -97,16 +97,15 @@ module Command
   # command on standard-input, if it is a IO object that IO object is piped to
   # the command
   #
-  # By default #command pass through standard-error but if :stderr is true,
-  # #command will return a tuple of standard-output, standard-error lines. If
-  # :stderr is false, standard-error is ignored and is the same as adding
-  # "2>/dev/null" to the command
+  # By default #command pass through stderr but if :stderr is true, #command
+  # will instead return a tuple of stdout/stderr lines. If :stderr is false,
+  # stderr is ignored and is the same as adding "2>/dev/null" to the command
   #
-  # #command raises a Command::Error exception if the command return with an
-  # exit code != 0 unless :fail is false. In that case the the exit code can be
+  # #command raises a Command::Error exception if the command returns with an exit
+  # code != 0 unless :fail is false. In that case the the exit code can be
   # fetched from Command::status
   #
-  def command(cmd, stdin: nil, stderr: nil, fail: true)
+  def command(env = {}, cmd, stdin: nil, stderr: nil, fail: true)
     cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
 
     pw = IO::pipe # pipe[0] for read, pipe[1] for write
@@ -129,7 +128,8 @@ module Command
       STDERR.reopen(pe[1])
       pe[1].close
 
-      exec(cmd)
+      env
+      exec(env.map { |k,v| [k.to_s, v.to_s] }.to_h, cmd)
     }
 
     pw[0].close
@@ -143,15 +143,14 @@ module Command
         when Array; pw[1].write(stdin.join("\n") + "\n")
       end
       pw[1].flush
-      pw[1].close
     end
+    pw[1].close # Closing standard input so the command doesn't hang on read
 
     @status = Process.waitpid2(pid)[1].exitstatus
 
     out = pr[0].readlines.map(&:chomp)
     err = pe[0].readlines.map(&:chomp)
 
-    pw[1].close if !stdin
     pr[0].close
     pe[0].close
 
@@ -171,13 +170,6 @@ module Command
     end
   end
 
-  # Exit status of the last command. FIXME: This is not usable because the
-  # methods raise an exception if the command exited with anything but 0
-  def status() @status end
-
-  # Stored exception when #command is called with :fail true
-  def exception() @exception end
-
   # Like command but returns true if the command exited with the expected
   # status. Note that it suppresses standard-error by default
   #
@@ -186,6 +178,12 @@ module Command
     @status == expect
   end
 
+  # Exit status of the last command
+  def status() @status end
+
+  # Exception of the last command if it failed, otherwise nil TODO What is this used for?
+  def exception() @exception end
+
   module_function :command
   module_function :status
   module_function :exception

data/lib/prick/constants.rb

@@ -14,8 +14,10 @@ module Prick
   DIRS = [
     MIGRATION_DIR = "migration",
     SCHEMA_DIR = "schema",
-    PRICK_DIR = "#{SCHEMA_DIR}/prick",
+    SCHEMA_PRICK_DIR = "#{SCHEMA_DIR}/prick",
     PUBLIC_DIR = "#{SCHEMA_DIR}/public",
+    BIN_DIR = "bin",
+    LIBEXEC_DIR = "libexec",
     VAR_DIR = "var",
     CACHE_DIR = "#{VAR_DIR}/cache",
     SPOOL_DIR = "#{VAR_DIR}/spool",
@@ -24,10 +26,20 @@ module Prick
     SPEC_DIR = "spec"
   ]
 
+  # Prick project root directory
+  PRICK_DIR = Dir.getwd
+
+  # Search path for executables
+  PRICK_PATH = "#{ENV['PATH']}:#{PRICK_DIR}/#{BIN_DIR}:#{PRICK_DIR}/#{LIBEXEC_DIR}"
+
   # Project specification file
   PRICK_PROJECT_FILE = "prick.yml"
   PRICK_PROJECT_PATH = PRICK_PROJECT_FILE
 
+# # Environment specification file
+# PRICK_ENVIRONMENT_FILE = "prick.environment.yml"
+# PRICK_ENVIRONMENTS_PATH = PRICK_ENVIRONMENT_FILE
+
   # Context file
   PRICK_CONTEXT_FILE = ".prick-context"
   PRICK_CONTEXT_PATH = PRICK_CONTEXT_FILE
@@ -42,7 +54,7 @@ module Prick
 
   # Schema data file
   SCHEMA_VERSION_FILE = "data.sql"
-  SCHEMA_VERSION_PATH = File.join(PRICK_DIR, SCHEMA_VERSION_FILE)
+  SCHEMA_VERSION_PATH = File.join(SCHEMA_PRICK_DIR, SCHEMA_VERSION_FILE)
 
   # Rspec temporary directory
   SPEC_TMP_DIR = "spec"

data/lib/prick/environment.rb

@@ -0,0 +1,134 @@
+require 'yaml'
+require 'dsort'
+
+module Prick
+  class Environment
+    # Environments name
+    attr_reader :name
+
+    # Names of parent environments
+    def parents = @values[:parents]
+
+    # Ancestors sorted in dependency order
+    def ancestors
+      @ancestors ||= effective_values[:parents].sort_by { |name| @@SORTED_INDEXES[name] }
+    end
+
+    # List of variables including :parents
+    def variables = @@VARIABLES
+
+    # List of user defined variables
+    def user_variables = @@VARIABLES - [:parent]
+
+    # Hash from variable to value
+    attr_accessor :values
+
+    # Hash from variable name to effective value. The effective value is the
+    # sum of this environment's value and its parents' values
+    attr_accessor :effective_values
+
+    def self.[](name) @@ENVIRONMENTS[name] end
+    def self.environment?(name) @@ENVIRONMENTS.key?(name) end
+    def self.environments() @@SORTED_ENVIRONMENTS.map { |key| @@ENVIRONMENTS[key] } end
+    def self.variables() @@VARIABLES end
+
+    def initialize(name)
+      @name = name
+      @values = variables.map { |key| [key, []] }.to_h
+      @effective_values = variables.map { |key| [key, []] }.to_h
+      @@ENVIRONMENTS[name] = self
+    end
+
+    def self.load_environments(hash) # hash can be nil
+      if hash
+        parse(hash)
+        analyze
+      end
+    end
+
+    # does not include the name of the environment
+    def bash_env 
+      user_variables.map { |variable|
+        ["PRICK_ENVIRONMENT_#{variable.upcase}", effective_values[variable]]
+      }.to_h
+    end
+
+    def dump
+      puts name
+      indent {
+        values.each { |var, val|
+          next if val.empty?
+          puts "#{var}:"
+          indent { puts val }
+        }
+        effective_values.each { |var, val|
+          next if val.empty?
+          puts "effective_#{var}:"
+          indent { puts val }
+        }
+      }
+    end
+
+    def self.dump
+      environments.each(&:dump)
+    end
+
+  private
+    @@VARIABLES = []
+    @@ENVIRONMENTS = {}
+    @@SORTED_ENVIRONMENTS = []
+
+    def self.yaml_to_array(value)
+      !value.nil? && Array(value).flatten.compact.map(&:to_s).map(&:split).flatten
+    end
+
+    def self.parse(hash)
+      hash = hash.dup
+      @@VARIABLES = [:parents] + (yaml_to_array(hash.delete("variables")).map(&:to_sym) || [])
+
+      for environment, settings in hash
+        env = Environment.new(environment)
+        if settings.is_a? Hash
+          for variable, value in settings
+            variable = (variable == "inherit" ? :parents : variable.to_sym)
+            value = yaml_to_array(value)
+            if variables.include?(variable)
+              env.values[variable] = value 
+            else 
+              raise ArgumentError, "Illegal variable: '#{variable}'"
+            end
+          end
+        else
+          raise ArgumentError, "Illegal value for '#{environment}': #{settings.inspect}"
+        end
+      end
+    end
+
+    def self.analyze
+      # Sort environments in dependency order
+      deps = @@ENVIRONMENTS.map { |name, env| [name, env.parents] }
+      @@SORTED_ENVIRONMENTS = DSort.dsort(deps)
+      @@SORTED_INDEXES = @@SORTED_ENVIRONMENTS.map.with_index { |env, idx| [env, idx] }.to_h
+
+      # Check for undeclared inherited environments
+      @@SORTED_ENVIRONMENTS.each { |environment|
+        @@ENVIRONMENTS.key?(environment) or raise ArgumentError, "Can't find '#{inherited}' environment"
+      }
+
+      # Compute effective attribute values by processing environments in
+      # dependency order so that all parents' environments are computed before
+      # the current environment
+      for name in @@SORTED_ENVIRONMENTS
+        env = Environment[name]
+        env.effective_values = env.values.transform_values { |v| v.dup } # Deep-dup
+        for parent in env.parents.dup
+          for var in variables
+            env.effective_values[var].unshift *Environment[parent].effective_values[var]
+          end
+        end
+        env.effective_values.transform_values! { |v| v.uniq }
+      end
+    end
+  end
+end
+

data/lib/prick/state.rb

@@ -27,42 +27,79 @@ module Prick
     # Version of prick(1)
     attr_accessor :prick_version
 
-    # Run-time environment. Can be :production, :development, or :test
-    attr_accessor :environment 
-
     # Name of database
     attr_accessor :database
 
     # Name of database user
     attr_accessor :username
 
-    def self.load
-      begin
-        h = YAML.load(File.read PRICK_PROJECT_PATH)
-      rescue Errno::ENOENT
-        raise Prick::Error, "Can't open project file: #{PRICK_PROJECT_PATH}"
-      end
-      state = State.new
-      state.name = h["name"]
-      state.title = h["title"]
-      state.version = h["version"] && PrickVersion.new(h["version"])
-      state.prick_version = h["prick"] && PrickVersion.new(h["prick"])
+    # Run-time environment name
+    def environment() @environment end
+    def environment=(env)
+      constrain env, String
+      Environment.environment?(env) or raise "Illegal environment: '#{env}'"
+      @environment = env
+    end
 
-      begin
-        h = YAML.load(File.read PRICK_CONTEXT_PATH)
-      rescue Errno::ENOENT
-        raise Prick::Error, "Can't open environment file: #{PRICK_CONTEXT_PATH}"
+    # Prick project dir. This is not a constant because exe/prick can change
+    # directory (FIXME it can?)
+    def prick_dir
+      @prick_dir ||= Dir.getwd
+    end
+
+    # Prick executable search_path
+    def executable_search_path
+      @executable_search_path ||= "#{ENV['PATH']}:#{prick_dir}/#{BIN_DIR}:#{prick_dir}/#{LIBEXEC_DIR}"
+    end
+
+    # Create a bash(1) environment (Hash). It is used for in-prick expansion of
+    # variables and also injected into the enviroment of subprocesses
+    def bash_environment(scope = :global)
+      hash = {
+        "DATABASE" =>  Prick.state.database, # FIXME: Yt
+        "USERNAME" =>  Prick.state.username, # FIXME: Yt
+        "ENVIRONMENT" =>  Prick.state.environment.to_s, # FIXME: Yt
+        "PRICK_NAME" => Prick.state.name,
+        "PRICK_TITLE" => Prick.state.title,
+        "PRICK_VERSION" => Prick.state.version,
+        "PRICK_DATABASE" =>  Prick.state.database,
+        "PRICK_USERNAME" =>  Prick.state.username,
+        "PRICK_ENVIRONMENT" =>  Prick.state.environment.to_s,
+      }
+      case scope
+        when :local; # nop
+          hash.merge Environment[Prick.state.environment].bash_env
+        when :global; 
+          ENV.to_h.merge(hash).merge({
+            "PATH" => Prick.state.executable_search_path,
+            "PRICK_SCHEMADIR" =>  File.join(Prick.state.prick_dir, SCHEMA_DIR),
+            "PRICK_BINDIR" =>  File.join(Prick.state.prick_dir, BIN_DIR),
+            "PRICK_LIBEXECDIR" =>  File.join(Prick.state.prick_dir, LIBEXEC_DIR),
+            "PRICK_VARDIR" =>  File.join(Prick.state.prick_dir, VAR_DIR),
+            "PRICK_CACHEDIR" =>  File.join(Prick.state.prick_dir, CACHE_DIR),
+            "PRICK_SPOOLDIR" =>  File.join(Prick.state.prick_dir, SPOOL_DIR),
+            "PRICK_TMPDIR" =>  File.join(Prick.state.prick_dir, TMP_DIR),
+            "PRICK_CLONEDIR" =>  File.join(Prick.state.prick_dir, CLONE_DIR),
+            "PRICK_SPECDIR" =>  File.join(Prick.state.prick_dir, BIN_DIR)
+          }).merge(Environment[Prick.state.environment].bash_env)
+      else
+        raise ArgumentError
       end
-      state.environment = h["environment"]&.to_sym
-      state.database = h["database"]
-      state.username = h["username"]
+    end
 
-      # TODO Load schema version
+    def bash_source
+      bash_environment(:local).map { |var,val| "export #{var}=\"#{Array(val).join(' ')}\"\n" }.join
+    end
 
+    def self.load(project_file, context_file)
+      state = State.new
+      state.send(:parse_project_file, project_file || PRICK_PROJECT_PATH)
+      state.send(:parse_context_file, context_file || PRICK_CONTEXT_PATH)
       state
     end
 
     def save
+      raise NotImplementedError
       h = {
         "name" => name,
         "title" => title,
@@ -97,11 +134,45 @@ module Prick
       indent {
         for method in [
             :name, :title, :prick_version, :project_version, :schema_version,
-            :database_version, :environment, :database, :username]
+            :database_version, :database, :username]
           puts "#{method}: #{self.send method}"
         end
+        puts "environments:"
+        indent { Environment.dump }
       }
     end
+
+  private
+    def load_yaml(file, expected_keys, optional_keys)
+      begin
+        hash = YAML.load(File.read file)
+      rescue Errno::ENOENT
+        raise Prick::Error, "Can't read #{file}"
+      end
+      for key in expected_keys
+        !hash[key].to_s.empty? or raise Prick::Error, "Can't find '#{key}' in #{file}"
+      end
+      (unknown = (hash.keys - expected_keys - optional_keys).first) and 
+          Prick::Error "Illegal key '#{unknown}' in #{file}"
+      hash
+    end
+
+    def parse_context_file(context_file)
+      hash = load_yaml(context_file, %w(environment database username), [])
+      @database = hash["database"]
+      @username = hash["username"]
+      @environment = hash["environment"]
+    end
+
+    def parse_project_file(prick_file)
+      hash = load_yaml(prick_file, %w(name title), %w(version prick environments))
+      @name = hash["name"]
+      @title = hash["title"]
+      @version = hash["version"] && PrickVersion.new(hash["version"])
+      @prick_version = hash["prick"] && PrickVersion.new(hash["prick"])
+      Environment.load_environments(hash["environments"] || {})
+    end
   end
 end
 
+

data/lib/prick/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prick
-  VERSION = "0.28.0"
+  VERSION = "0.29.0"
 end

data/lib/prick.rb

@@ -17,7 +17,9 @@ require 'ext/expand_variables.rb'
 require 'local/command.rb'
 require 'local/git.rb'
 require 'local/timer.rb'
+require 'local/ansi.rb'
 
+require 'prick/environment.rb'
 require 'prick/state.rb'
 require 'prick/prick_version.rb'
 require 'prick/diff.rb'
@@ -33,6 +35,7 @@ end
 require 'subcommand/prick-init.rb'
 require 'subcommand/prick-setup.rb'
 require 'subcommand/prick-teardown.rb'
+require 'subcommand/prick-clean.rb'
 require 'subcommand/prick-create.rb'
 require 'subcommand/prick-build.rb'
 require 'subcommand/prick-make.rb'

data/lib/subcommand/prick-build.rb

@@ -3,7 +3,10 @@
 require 'builder/builder.rb'
 
 module Prick::SubCommand
-  def self.build(database, username, schema, builddir: "schema", force: false, timer: nil, dump: nil)
+  def self.build(
+      database, username, schema, 
+      builddir: "schema", force: false, timer: nil, dump: nil)
+
     Timer.on! if timer
     time "Prick::Command#build" do
       begin
@@ -15,20 +18,19 @@ module Prick::SubCommand
         builder = nil
         time "Load build object" do
           if super_conn.rdbms.exist? database
-            conn = PgConn.new(database, username)
             exist = true
           else
             super_conn.rdbms.create database, owner: username
-            conn = PgConn.new(database, username)
             exist = false
           end
+          conn = PgConn.new(database, username)
 
           builder = Prick::Build::Builder.new(conn, builddir)
 
           if exist
             if force
               # Drop all schemas but re-creates the public schema
-              super_conn.rdbms.empty!(database)
+              super_conn.rdbms.empty!(database, public: false)
 
             else
               # Find schemas to refresh. This includes all schemas in the
@@ -68,9 +70,9 @@ module Prick::SubCommand
           builder.execute conn
         end
 
-      rescue Prick::Error => ex
-        $stderr.puts ex.message
-        exit 1
+#     rescue Prick::Error => ex
+#       $stderr.puts ex.message
+#       exit 1
 
       rescue ::Command::Error => ex
         $stderr.puts ex.message

data/lib/subcommand/prick-clean.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  # Drop users and empty database. This has the same as effect as
+  # teardown+setup but without recreating the user and the database that
+  # annoyingly terminates all user sessions
+  def self.clean(database)
+    drop_users(database)
+    PgConn.new("postgres") { |conn|
+      conn.rdbms.empty!(database) if conn.rdbms.exist?(database)
+    }
+  end
+end
+
+

data/lib/subcommand/prick-drop.rb

@@ -3,8 +3,15 @@
 require 'builder/builder.rb'
 
 module Prick::SubCommand
-  def self.drop_users(database)
+  def self.drop_user(username) # No database so does not cascade
     PgConn.new("postgres") { |conn|
+      conn.role.drop([username])
+    }
+  end
+
+  # Drop all users associated with the given database except the owner
+  def self.drop_users(database)
+    PgConn.new(database) { |conn|
       users = conn.role.list(database: database)
       conn.role.drop(users, cascade: true)
     }
@@ -15,11 +22,9 @@ module Prick::SubCommand
   end
 
   def self.drop_all(database)
-    PgConn.new("postgres") { |conn|
-      users = conn.role.list(database: database)
-      PgConn.new(database) { |db| db.role.drop(users, cascade: true) }
-      conn.rdbms.drop database
-    }
+    drop_users(database)
+    drop_database(database)
+    drop_user(username)
   end
 end
 

data/prick.environments.yml

@@ -0,0 +1,14 @@
+online: 
+offline: 
+production: online
+development: offline
+frontend: development
+app_registry_frontend: frontend
+app_portal_frontend: frontend
+backend: development
+app_registry_backend: backend
+app_portal_backend: backend
+fdw_import: online
+sagsys_import: offline
+app_portal_import: offline
+test: offline

data/prick.gemspec

@@ -38,6 +38,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "postspec"
   spec.add_dependency "pg_graph"
   spec.add_dependency "shellopts"
+  spec.add_dependency "dsort"
 
   spec.add_development_dependency "ruby-prof"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prick
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.29.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-08 00:00:00.000000000 Z
+date: 2024-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dsort
+  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: ruby-prof
   requirement: !ruby/object:Gem::Requirement
@@ -174,12 +188,14 @@ files:
 - lib/builder/node_pool.rb
 - lib/builder/parser.rb
 - lib/ext/expand_variables.rb
+- lib/local/ansi.rb
 - lib/local/command.rb
 - lib/local/git.rb
 - lib/local/timer.rb
 - lib/prick.rb
 - lib/prick/constants.rb
 - lib/prick/diff.rb
+- lib/prick/environment.rb
 - lib/prick/prick_version.rb
 - lib/prick/state.rb
 - lib/prick/version.rb
@@ -203,6 +219,7 @@ files:
 - lib/share/migrate/migration/diff.before-tables.sql
 - lib/share/migrate/migration/diff.tables.sql
 - lib/subcommand/prick-build.rb
+- lib/subcommand/prick-clean.rb
 - lib/subcommand/prick-create.rb
 - lib/subcommand/prick-drop.rb
 - lib/subcommand/prick-fox.rb
@@ -212,6 +229,7 @@ files:
 - lib/subcommand/prick-release.rb
 - lib/subcommand/prick-setup.rb
 - lib/subcommand/prick-teardown.rb
+- prick.environments.yml
 - prick.gemspec
 homepage: http://www.nowhere.com/
 licenses: []
@@ -231,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.18
 signing_key:
 specification_version: 4
 summary: A release control and management system for postgresql