prick 0.30.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7302ba57c3bed137c90862b29e2a2b14938395963a3521aa10a2b096d516696f
-  data.tar.gz: f7d7e31e0f24c4346bffff6d03d104c7f8e9e9f2605bde0a6f67f48a16736499
+  metadata.gz: fed99dbfdf6e89642b4e8fdddf976efa58b1c8b75d9169fa460bd8190805cc63
+  data.tar.gz: 97fec32bbd130043b2c782f133ab5af30e9bcc5c42d4c83a26311f486786d671
 SHA512:
-  metadata.gz: 3e1fb9a5b8a9befdd1367b6653dd46dc0df0ca17ce94a15153f4d590390b1341c5930ffbc2a5608cdf906b0d22e56aaf1782c96c01ea3ffdbbbf85dc5c097f98
-  data.tar.gz: c79a6ecd5bd77169517c6b70dca2363da933fc3f73550e390297c991a2aed4c8ac0d6887855b93112fcac2d32818f3ee5e93609d1dfedae913e53f8dc6d8d187
+  metadata.gz: 35859b1f387d1bf8ccb04a37a853d509e8038102f9521a7b4b35884db5d2682e5a06bd3dda9f4aff704a105603d9df17a43d2d1bbfa66f39ba751584b73b7cb9
+  data.tar.gz: cc7dfb26f5c10b1489d82f5be5c824e7d7d118de29d9ceae6b424e26506701650da57ed800107ce8ad10ea0bda3e1d29934000170702b285ae3d7a3a8123426f

data/exe/prick

@@ -51,7 +51,8 @@ SPEC = %(
   teardown! -- [DATABASE...] @ Remove database and owner
       Drop database, database users, and database owner if possible and not the
       current user. DATABASE defaults to the current database in which case the
-      state file is also removed
+      state file is also removed. If the --force option is present, the
+      database is dropped even if it is not a Prick database
 
   clean! -- [DATABASE] @ Empty database and remove users
       Empty the database and drop related users except the database owner and
@@ -96,33 +97,34 @@ SPEC = %(
   create.all!
       TODO
 
-  drop.schema! -- [SCHEMA...]
-      @ Drop schemas
-
-      Drops the given schemas or all schemas if called without arguments
-
-  drop.users!
+  drop.users! -- [DATABASE]
       @ Drop database users
 
       Drops all database users except the database owner
 
+  drop.owner! -- [DATABASE]
+      Drop database owner
+
+  drop.database! -- [DATABASE]
+      Drop database
+
+  drop.schema! -- [DATABASE] [SCHEMA...]
+      @ Drop schemas
+
+      Drops the given schemas or all schemas if called without arguments. The
+      'prick' schema is only deleted if named explicity
+
   drop.data!
       @ Drop data
 
       TODO
 
-  drop.owner!
-      Drop database owner
-
-  drop.database!
-      Drop database
-
   build! -f,force -t,time --dump=KIND? -- [SCHEMA]
       Build the project. If SCHEMA is defined, later schemas are excluded.
-      KIND can be 'nodes', 'allnodes' or 'batches' (the default)
+      KIND can be 'nodes', 'allnodes' or 'batches' (the default). 
 
-      Usually, schemas marked with 'no refresh' is not built, use --force to
-      rebuild all schemas
+      Schemas marked with 'no refresh' is not built unless the --force is
+      present
 
   make! -t,time --dump=KIND? -- [SCHEMA]
       @ Only rebuild changed files
@@ -131,6 +133,10 @@ SPEC = %(
       rebuild affected parts of the project. KIND can be 'nodes', 'allnodes' or
       'batches' (the default)
 
+  bash! --main
+      Emit a bash script to build the database. The script is constructed from
+      the build attributes in the environment file
+
   fox! -- FILE...
       Load fox file data. Data are reset to their initial state after build
       before the fox data are loaded. This makes it possible to experiment with
@@ -182,6 +188,8 @@ SPEC = %(
           read name title <<< $(prick dump value PRICK_NAME PRICK_TITLE)
 
   dump.node!
+      Dump build nodes
+
   dump.build!
   dump.data! @ TODO
   dump.schema! @ TODO
@@ -194,7 +202,7 @@ def require_db(database = Prick.state&.database, exist: true)
   dba = State.connection
   if exist
     dba.rdbms.exist?(database) or Prick.error "Can't find database '#{database}'"
-    if Prick.state&.conn&.name == database
+    if Prick.state&.connection&.name == database
       close_conn = false
       conn = Prick.state.conn
     else
@@ -353,29 +361,32 @@ begin
       dump = cmd.dump? ? cmd.dump("batches")&.to_sym || :batches : nil
       Prick::SubCommand.make(database, username, args.expect(0..1), timer: cmd.time?, dump: dump)
 
+    when :bash!
+      Prick::SubCommand.bash(main: cmd.main?)
+
     when :fox!
       require_db
       Prick::SubCommand.fox(database, username, args)
 
     when :drop!
-      require_db if cmd.subcommand != :owner!
-      if cmd.subcommand == :schema!
-        schemas = args.to_a
-      else
-        args.expect(0)
-      end
       case cmd.subcommand
-        when :all!
-          Prick::SubCommand.drop_all(database, username)
         when :users!
+          # Should set state.username to owner of database
+          database = state.database = args.expect(0..1) || database
+          username = state.username = State.connection.rdbms.owner(database)
+          require_db(database)
           Prick::SubCommand.drop_users(database)
         when :owner!
-          Prick::SubCommand.drop_owner(username)
+          owner = args.expect(0..1) || username
+          Prick::SubCommand.drop_owner(owner)
         when :database!
+          database = args.expect(0..1) || database
           Prick::SubCommand.drop_database(database)
         when :data!
           raise NotImplementedError
         when :schema!
+          require_db
+          schemas = args.to_a
           Prick::SubCommand.drop_schema(database, schemas)
       else
         Prick.error "Unknown subject: #{subject}"
@@ -393,7 +404,7 @@ begin
       Prick::SubCommand.migrate(database, username, file: cmd.file)
 
     when :list!
-      format = (cmd.subcommand!.long? ? :long : :short) if cmd.subcommand != :users!
+      format = (cmd.subcommand!.long? ? :long : :short) if cmd.subcommand && cmd.subcommand != :users!
       case cmd.subcommand
         when :environments!; Prick::SubCommand.list_environments(format: format)
         when :databases!; Prick::SubCommand.list_databases(format: format)
@@ -403,7 +414,7 @@ begin
         when :users!; Prick::SubCommand.list_users
         when :owners!; Prick::SubCommand.list_owners(format: format)
       else
-        Prick.error "Unknown subcommand: #{cmd.subcommand}"
+        Prick.error "Unknown subcommand '#{cmd.subcommand || args.first }'"
       end
 
     when :dump!
@@ -439,15 +450,14 @@ begin
                 Prick.error "Conflicting options - --export and --local"
               end
           puts state.bash_source(args.first ? args : nil, scope: scope)
-          exit
         when :value!
           puts args.expect(1..).map { |var| Array(state.bash_environment[var]).join(' ') }
       else
         object = args.extract(1) # Fails if object is absent
         Prick.error "Unknown dump object: #{object}"
       end
-    else
-      Prick.failure "Internal error: Unhandled command - #{opts.subcommand.inspect}"
+  else
+    Prick.failure "Internal error: Unhandled command - #{opts.subcommand.inspect}"
   end
 
 rescue Prick::Build::PostgresError => ex

data/idea.txt

@@ -0,0 +1,38 @@
+
+Build spec
+  Custom variables
+    variables VAR...
+
+  Variables
+    graph # old 'standard'
+    schema
+    rebuild
+    refresh
+    require 
+
+  Code
+    build
+    rebuild
+    refresh
+    import
+    export
+
+  Special code functions
+    super
+    build file-or-directory       # makes sure not to load a file twice
+    sql "sql statement"
+    use sql-file                  # makes sure not to load a file twice
+    load dump-files               # makes sure not to load a file twice
+
+    build_ENVIRONMENT   # eg. 'build_app_registry_backend'
+    rebuild_ENVIRONMENT
+    refresh_ENVIRONMENT
+
+  Environment variables
+    PRICK_ENVIRONMENTS # all environments included in the current environment
+
+  Helper functions
+    # Consults PRICK_ENVIRONMENTS to check if the given environment is include
+    # in the current environment
+    has_environment ENVIRONMENT
+

data/lib/prick/builder/parser.rb

@@ -50,12 +50,13 @@ module Prick
       # The hierarchy of environments is defined in the PRICK_ENVIRONMENT_FILE
       #
       def expand_filename(dir, filename)
-        environment = Prick.state.environment
+        envs = Prick.state.environments
+        env = envs[Prick.state.environment]
         bash_vars = Prick.state.bash_environment
 
         last = nil
-        for env in [environment] + Environment[environment].ancestors.reverse
-          bash_vars["ENVIRONMENT"] = env
+        for env in [env] + env.ancestors.reverse
+          bash_vars["ENVIRONMENT"] = env.name
           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))

data/lib/prick/environment.rb

@@ -1,145 +1,366 @@
+require 'set'
 require 'yaml'
 require 'dsort'
 
-# TODO: 
-#   o Check :parent vs. :inherit (or explain the difference). Also check
-#     handling of :comment 
-
+# TODO
+#   o Add a CODE type
+#   o super
 module Prick
-  # An environment as defined in the prick.environment file. The environment is
-  # constant across all instances of State so we ensure that it is loaded only
-  # once
   class Environment
-    # Environments name
+    # The enclosing Environments object. Used in #types
+    attr_reader :environments
+
+    # Environment name (String)
     attr_reader :name
 
-    # Environment comment. If not nil, this environment is considered a user-environment
-    attr_accessor :comment
+    # List of names of inherited environments
+    def inherit = assignments[:inherit]
+
+    # List of directly inherited environment objects. Assigned by the 
+    # analyzer
+    attr_accessor :parents
+
+    # Ancestors (array of Environment objects) sorted in dependency order
+    attr_accessor :ancestors
+
+    # The ancestor that defines the build attribute or nil if ambigous.
+    # Assigned by the analyzer
+    attr_accessor :super_environment
 
-    # Names of parent environments
-    def parents = @values[:parents]
+    def has_super?() = !super_environment.nil?
 
-    # Ancestors sorted in dependency order
-    def ancestors
-      @ancestors ||= effective_values[:parents].sort_by { |name| @@SORTED_INDEXES[name] }
+    # Map from variable identifier to the environment that defines the value.
+    # This assumes there are no ambigous assignments
+    def assigners
+      @assigners ||= begin
+        effective_variables.keys.map { |ident|
+          if assignments.key?(ident)
+            [ident, self]
+          else
+            [ident, ancestors.reverse.find { |env| env.assignments.key?(ident) }]
+          end
+        }.to_h
+      end
     end
 
-    # List of variables including :parents
-    def variables = @@VARIABLES
+    # Environment comment
+    def comment = assignments[:comment]
 
-    # List of user defined variables
-    def user_variables = @@VARIABLES - [:parents, :comment]
+    # Map from variable identifier (Symbol) to type. Type is one of the strings
+    # listed in Environments::TYPES
+    def types() = @environments.types
 
-    # Hash from variable to value
-    attr_accessor :values
+    # Map from variable identifier (Symbol) to value. Inherited variables are not
+    # included in #assignments
+    attr_reader :assignments
 
-    # 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
+    # Return true if the environment assigns an attribute
+    def assign?(ident) = @assignments.key?(ident)
 
-    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
+    # Map from variable identifier (Symbol) to effective value. Initially equal
+    # to #assignments but are later augmented or merged with the corresponding
+    # assignments from inherited environments
+    attr_accessor :effective_variables
 
-    def initialize(name)
+    def initialize(environments, name, assignments)
+      constrain environments, Environments
+      constrain name, String
+      constrain assignments, { Symbol => Object }
+      @environments = environments
       @name = name
-      @comment = nil
-      @values = variables.map { |key| [key, []] }.to_h
-      @effective_values = variables.map { |key| [key, []] }.to_h
-      @@ENVIRONMENTS[name] = self
+      @assignments = assignments
+      @assignments[:inherit] ||= []
+      @effective_variables = assignments.transform_values { |v| v.dup } # Deep-dup
     end
 
-    def self.load_environments(yaml) # hash maps from environment name to object
-      if hash
-        parse(yaml)
-        analyze
-      end
-    end
+    forward_to :effective_variables, :key?, :[], :[]=, :to_h, :empty?, :size, :each, :map
 
-    # does not include the name of the environment
-    def bash_env 
-      user_variables.map { |variable|
-        ["PRICK_ENVIRONMENT_#{variable.upcase}", effective_values[variable]]
+    def bash() = "build_#{name}"
+    def super_bash() = (has_super? ? "build_#{name}_super" : nil)
+    def bash_environment
+      effective_variables.map { |ident, value|
+        ["PRICK_ENVIRONMENT_#{ident.upcase}", value]
       }.to_h
     end
 
+    def inspect = "#<#{self.class} @name=#{@name}>"
+
     def dump
-      puts name
+      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 }
+        self.each { |ident,val| 
+          if ident == :build
+            puts "super: #{super_environment&.name || 'false'}"
+          end
+          assigner = assigners[ident]&.name || name
+          assigner_str = (assigner != name ? " (#{assigner})" : "")
+          if types[ident] == "TEXT"
+            puts "#{ident}#{assigner_str}:"
+            indent { puts val }
+          else
+              puts "#{ident}#{assigner_str}: #{val.inspect}"
+          end
+          if ident == :inherit
+            puts "ancestors: #{ancestors.map(&:name).inspect}"
+          end
         }
       }
     end
+  end
+
+  class Environments
+    # Map from environment name to Environment object
+    attr_reader :environments
+
+    # Environments acts like a hash from name to Environment object
+    forward_to :@environments, :[], :[]=, :key?, :keys, :values, :each, :map
+
+    # Maps from variable name (Symbol) to type (String)
+    attr_reader :types
+
+    # List of all variables (Symbol). Same as 'types.keys'
+    def variables = types.keys
+
+    # List of variable identifiers defined by prick
+    def prick_variables = @@PRICK_VARIABLES
+
+    # List of user defined variables
+    def user_variables = variables - prick_variables
+
+    def initialize(hash)
+      @types = @@TYPES.dup
+      @environments = {}
+      parse_variables(hash)
+      parse_environments(hash)
+      analyze
+    end
 
-    def self.dump
-      environments.each(&:dump)
+    def undent(s)
+      s = s[1..] if s[0] == "\n"
+      s =~ /^(\s*)\S$/m
+      indent = $1
+      s.gsub(/^#{indent}/m, "")
     end
 
-  private
-    @@VARIABLES = []
-    @@ENVIRONMENTS = {}
-    @@SORTED_ENVIRONMENTS = []
+    def bash_environment
 
-    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, :comment] + (yaml_to_array(hash.delete("variables") || []).map(&:to_sym) || [])
-
-      for environment, settings in hash
-        env = Environment.new(environment)
-        settings ||= {}
-        if settings.is_a? Hash
-          for variable, value in settings
-            if variable == "comment"
-              env.comment = value
-            else
-              variable = (variable == "inherit" ? :parents : variable.to_sym)
-              value = yaml_to_array(value)
-              variables.include?(variable) or raise ArgumentError, "Illegal variable: '#{variable}'"
-              env.values[variable] = value
+    def bash_command(environment = nil)
+      constrain environment, String, nil
+      if environment
+        env = self[environment] or raise "Unknown environment: '#{environment}'"
+        envs = [env]
+      else
+        envs = environments
+      end
+
+      puts "### SCRIPT by #{File.basename(__FILE__)}"
+
+      puts undent %(
+
+        ## STACK METHODS - ChatGPT
+
+        # global variable
+        super_stack=()
+
+        function push_super_stack() {
+          local method=$1
+          super_stack+=($method)
+        }
+        
+        function pop_super_stack() {
+          super_stack=("${super_stack[@]::${#super_stack[@]}-1}")
+        }
+        
+        function super() {
+          eval ${super_stack[-1]}
+        }
+      )
+
+      puts "## ENVIRONMENT METHODS"
+      puts
+      for name, env in environments
+        puts "function build_#{name}() {"
+        assigner = env.assigners[:build]
+        indent {
+          if assigner == env
+            if env.has_super?
+              puts "push_super_stack #{env.super_bash}"
+            end
+            puts env[:build]
+            if env.has_super?
+              puts "pop_super_stack"
             end
+          else
+            puts "build_#{assigner.name} # default super"
           end
-        else
-          raise ArgumentError, "Illegal value for '#{environment}': #{settings.inspect}"
+        }
+        puts "}"
+        puts
+        if env.has_super? && assigner == env
+          puts "build_#{name}_super() { build_#{env.super_environment.name}; }"
+          puts
         end
       end
+
+      if environment
+        puts "## DEFAULT BUILD METHOD"
+        puts
+        puts "function build() { build_#{environment}; }"
+        puts
+      end
+    end
+
+    def dump
+      puts "Types"
+      indent { types.each { |k,v| puts "#{k}: #{v}" } }
+      puts
+      puts "Environments"
+      indent { environments.values.each { |env| env.dump } }
+    end
+
+  private
+    TYPES = %w(BOOLEAN STRING LIST TEXT)
+    @@TYPES = { comment: "STRING", inherit: "LIST", build: "TEXT" }
+    @@PRICK_VARIABLES = @@TYPES.keys
+
+    def parse_variables(yaml)
+      decls = yaml.delete("variables") || ""
+      decls.split.each { |decl|
+        decl =~ /^(.*):(.*)$/ or ShellOpts.error "Illegal declaration of '#{decl}' in variable list"
+        name, type = $1.to_sym, $2
+        type = type.upcase
+        TYPES.include?(type) or ShellOpts.error "Illegal type '#{type}'"
+        @types[name] = type
+      }
     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
+    def parse_environments(yaml)
+      yaml.each { |environment, variables|
+        assignments = variables.map { |ident, value|
+          ident = ident.to_sym
+          case types[ident]
+            when "BOOLEAN"
+              [TrueClass, FalseClass].include?(value.class) or raise "Illegal value for #{ident}: #{value}"
+              ;
+            when "STRING"
+              ; # nop
+            when "LIST"
+              value = value.split
+            when "TEXT"
+              value = value.chomp
+            when nil
+              ShellOpts.error "Unknown variable '#{ident}'"
+          else
+            raise ArgumentError
+          end
+          [ident, value]
+        }.to_h
+        @environments[environment] = Environment.new(self, environment, assignments)
+      }
+    end
 
-      # Check for undeclared inherited environments
-      @@SORTED_ENVIRONMENTS.each { |environment|
-        @@ENVIRONMENTS.key?(environment) or raise ArgumentError, "Can't find '#{inherited}' environment"
+    def analyze
+      # Assign Environment#parent
+      values.each { |env|
+        env.parents = env.inherit.map { |name| 
+          self[name] or raise ArgumentError, "Can't find '#{name}' environment referred from '#{name}'"
+        }
       }
 
+      # Sort environment names in dependency order
+      deps = self.map { |name, env| [name, env.inherit] }
+      sorted_environments = DSort.dsort(deps).map { |name| self[name] }
+
       # Compute effective attribute values by processing environments in
-      # dependency order so that all parents' environments are computed before
+      # dependency order so that all inherited 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]
+      for env in sorted_environments
+        for inherited in env.parents
+          for ident, type in types
+            next if ident == :comment # Comments are not inherited
+            next if !inherited.key?(ident)
+            value = inherited[ident]
+            case type
+              when "BOOLEAN"; env[ident] = value if !env.key?(ident)
+              when "STRING"; env[ident] ||= value
+              when "LIST"; 
+                  next if ident == :inherit # Does not accumulate
+                  # FIXME !inherited.key? should prevent env[ident].nil?
+                  env[ident] = (value + (env[ident] || [])).uniq 
+              when "TEXT"; env[ident] = env[ident] || value
+            else
+              raise ArgumentError
+            end
+          end
+        end
+      end
+
+      # Assign #ancestors
+      sorted_indexes = sorted_environments.map.with_index { |env, idx| [env.name, idx] }.to_h
+      for env in sorted_environments
+        env.ancestors = 
+          (env.parents + env.parents.map(&:ancestors))
+            .flatten
+            .uniq
+            .sort_by { |env| sorted_indexes[env.name] }
+      end
+
+      # Check ambigous string, text, and boolean definitions (:initial is never
+      # ambigous and :comment is special). TODO: Find a faster algorithm
+      for env in sorted_environments
+        for ident, value in env.effective_variables
+          type = types[ident]
+
+          # Ignore mergeable types (LIST)
+          next if !%w(STRING TEXT BOOLEAN).include?(type)
+
+          # Ignore :initial and :comment
+          next if [:initial, :comment].include?(ident)
+
+          # Ignore if variable is assigned in the current environment and not the
+          # special :build attribute
+          next if env.assignments.key?(ident) && ident != :build
+
+          # Pool of ancestors. When an environment assigns a value, all ancestors
+          # of the environment are removed from the pool. If any remaining environment
+          # also assigns the variable, the definition is ambigous. 'pool' and
+          # 'queue' works together to provide a set of environments with
+          # queue-like properties
+          pool = Set.new(env.ancestors)
+
+          # Queue of ancestors. It is used to iterate the pool environments in
+          # reversed dependency order
+          queue = env.ancestors.reverse
+
+          # Look for the first environment that assigns the variable
+          while ancestor = queue.shift
+            next if !pool.include?(ancestor)
+            if ancestor.assignments.key?(ident)
+              # Remove all ancestors that are inherited by the assigning environment
+              pool -= ancestor.ancestors
+              if ident == :build
+                env.super_environment = ancestor #if ident == :build
+              end
+              break
+            end
+          end
+
+          # Check that remaining environments do not also assign the variable.
+          # The :block attribute is checked even if defined in the current
+          # environment to be able to tell if 'super' is ambigous
+          while ancestor = queue.shift
+            next if !pool.include?(ancestor)
+            if ancestor.assign?(ident)
+              if ident == :build && env.assign?(:build)
+                env.super_environment = nil
+              else
+                raise ArgumentError, "Ambigious definition of '#{ident}' in #{ancestor.name} environment"
+              end
+            end
           end
         end
-        env.effective_values.transform_values! { |v| v.uniq }
       end
     end
   end

data/lib/prick/local/command.rb

@@ -1,9 +1,5 @@
 require 'fcntl'
 
-require 'forward_to'
-
-include ForwardTo
-
 module Command
   class Error < RuntimeError
     attr_reader :cmd

data/lib/prick/local/fmt.rb

@@ -5,52 +5,95 @@ module Fmt
     widths = headers.map(&:size)
     signs = []
     types = []
+    indexes = [] # absolute position of column. Zero based
     for i in (0...headers.size)
-      widths[i] = 
-          ( 
-            [widths[i]] +
-            table.map { |row|
-              case value = row[i]
-                when TrueClass, FalseClass
-                  types[i] = 's'
-                  signs[i] = '-'
-                  5
-                when NilClass
-                  types[i] = 's'
-                  signs[i] = '-'
-                  4
-                when String
-                  types[i] = 's'
-                  signs[i] = '-'
-                  value.size
-                when Integer
-                  types[i] = 'i'
-                  signs[i] = ''
-                  Math.log10(value) + 1
-              else
-                raise ArgumentError, value
-              end
-            }
-          ).max
+      value_width = 
+          table.map { |row|
+            case value = row[i]
+              when TrueClass, FalseClass
+                types[i] = 's'
+                signs[i] = '-'
+                5
+              when NilClass
+                types[i] = 's'
+                signs[i] = '-'
+                4
+              when String
+                types[i] = 's'
+                signs[i] = '-'
+                value.split("\n").map(&:size).max || 0
+              when Integer
+                types[i] = 'i'
+                signs[i] = ''
+                Math.log10(value) + 1
+              when Array
+                types[i] = 's'
+                signs[i] = '-'
+                all_size = value.join(' ').size
+                if all_size < 60
+                  all_size
+                else
+                  value.map(&:size).max
+                end
+              when PrickVersion
+                types[i] = 's'
+                signs[i] = '-'
+                value.to_s.size
+            else
+              raise ArgumentError, "Illegal value: '#{value}' (#{value.class})"
+            end
+          }.max || 0
+      widths[i] = [widths[i], value_width].max
+      indexes[i] = (i == 0 ? 0 : indexes[i-1] + widths[i-1] + 1)
     end
 
-    widths = widths.map { _1 }
-
     for width, value in widths.zip(headers)
       printf "%-#{width}s ", value
     end
     puts
+
     widths.each.with_index { |width, index|
       char = (headers[index] =~ /^\s*$/ ? " " : "-")
       printf "%#{width}s ", char * width
     }
     puts
+
     for row in table
-      for sign, width, type, value in signs.zip(widths, types, row)
-        value = (value.nil? ? "-" : value)
-        printf "%#{sign}#{width}#{type} ", value
+#     for index, sign, width, type, value in signs.zip(indexes, signs, widths, types, row) # FIXME doesn't work?
+      for i in (0...headers.size)
+        index, sign, width, type, value = indexes[i], signs[i], widths[i], types[i], row[i]
+
+        if value && value =~ /\n/m
+          value = value.split("\n")
+          print value.first
+          for line in value[1..]
+            puts
+            print "#{' ' * index}#{line}"
+          end
+        elsif value.is_a?(Array)
+          values = value.dup
+          lines = []
+          while !values.empty?
+            rest = width
+            line = [] 
+            while !values.empty? && values.first.size <= rest
+              rest -= values.first.size
+              line << values.shift
+            end
+            lines << line.join(" ")
+          end
+          print lines.first
+          for line in lines[1..]
+            puts
+            print "#{' ' * index}#{line}"
+          end
+        else
+          value = (value.nil? ? "-" : value)
+          printf "%#{sign}#{width}#{type} ", "#{value}"
+        end
       end
       puts
     end
   end
 end
+

data/lib/prick/state.rb

@@ -52,14 +52,17 @@ module Prick
     # database is absent
     attr_accessor :username
 
-    # Environment name. If not set in the state file, the enviroment is read
-    # from the database when the first connection is established by the
-    # #connection method. Use 'Environment[environment]' to get the
+    # Map from environment name to environment object
+    attr_reader :environments
+
+    # Name of current environment. If not set in the state file, the enviroment
+    # is read from the database when the first connection is established by the
+    # #connection method. Use '#environments[environment]' to get the
     # corresponding Environment object
     def environment() @environment end
     def environment=(env)
       constrain env, String, nil
-      env.nil? || Environment.environment?(env) or raise "Illegal environment: '#{env}'"
+      env.nil? || environments.key?(env) or raise "Illegal environment: '#{env}'"
       @environment = env
     end
 
@@ -106,13 +109,13 @@ module Prick
     # Project user (owner) connection. Memoized to connect only once. 
     # TODO Rename. Also rename self.connection
     def connection(database: nil, username: nil, environment: nil, &block)
-      database ||= self.database
-      username ||= self.username
-      environment ||= self.environment
-      !database.nil? or Prick.error "Can't connect to Postgres - no database specified"
-#     exist_database_environment? or Prick.error "Database '#{database}' is not initialized"
-
       if @connection.nil?
+        database ||= self.database
+        username ||= self.username
+        environment ||= self.environment
+        !database.nil? or Prick.error "Can't connect to Postgres - no database specified"
+#       exist_database_environment? or Prick.error "Database '#{database}' is not initialized"
+
         @connection = PgConn.new(database, username)
 
         # Set database_version/environment/prick members
@@ -122,7 +125,7 @@ module Prick
         self.environment = 
             environment || 
             Prick.state.environment || 
-            Environment.environment?(database_environment) && database_environment ||
+            environments.key?(database_environment) && database_environment ||
             DEFAULT_ENVIRONMENT
       end
       if block_given?
@@ -193,13 +196,18 @@ module Prick
         })
 
         # PRICK_ENVIRONMENT_* variables
-        hash.merge! (Prick.state.environment.nil? ? {} : Environment[Prick.state.environment].bash_env)
+        if !Prick.state.environment.nil?
+          hash.merge! environments[environment].bash_environment
+        end
       end
     end
 
     # @scope can be :global (variables are exported), :local (variables are
     # declared local), or nil (variables are global but not exported)
+    #
+    # Only non-text variables are emitted
     def bash_source(vars = nil, scope: nil)
+      exclude = Array(exclude || []).flatten.map { _1.to_s }
       case scope
         when :global; prefix="export "
         when :local; prefix="local "
@@ -208,15 +216,26 @@ module Prick
         raise ArgumentError, "Illegal value for scope: #{scope.inspect}"
       end
 
-      (vars || bash_environment.keys).map { |var|
+      vars ||= bash_environment&.keys || []
+      assignments = []
+      vars.each { |var|
         val = bash_environment[var]
-        "#{prefix}#{var}=\"#{Array(val).join(' ')}\"\n" 
-      }.join
+#       next if val =~ /['"\n]/m # We don't quote
+        if val.is_a?(Array)
+          if val.first.is_a?(Array)
+            val = val.map { |v| v.join("\n") }.join("\n")
+          else
+            val = val.join(" ")
+          end
+        end
+        assignments << "#{prefix}#{var}='#{val}'\n" 
+      }
+      assignments.join
     end
 
     # It is an error if the project file exists. 
-    def save_project
-      !File.exists?(project_file) or Prick.error "Won't overwrite '#{project_file}'"
+    def save_project(overwrite: false)
+      overwrite || !File.exists?(project_file) or Prick.error "Won't overwrite '#{project_file}'"
       hash = { name: name, title: title, version: version.to_s, prick: prick_version.to_s }
       save_yaml(project_file, hash)
     end
@@ -243,7 +262,7 @@ module Prick
             "prick.builds",
             name: name,
             version: version.to_s, prick: prick_version, 
-            branch: branch, rev: rev(:short), clean: clean?,
+            branch: branch, rev: rev(kind: :short), clean: clean?,
             environment: environment)
       end
     end
@@ -257,7 +276,7 @@ module Prick
             "prick.builds",
             name: name,
             version: version.to_s, prick: prick_version, 
-            branch: branch, rev: rev(:short), clean: clean?,
+            branch: branch, rev: rev(kind: :short), clean: clean?,
             environment: environment,
             success: success, duration: duration, prick_duration: dt)
       end
@@ -272,7 +291,7 @@ module Prick
           puts "#{method}: #{self.send method}"
         end
         puts "environments:"
-        indent { Environment.dump }
+        indent { environments.dump }
       }
     end
 
@@ -281,7 +300,7 @@ module Prick
 
     def read_yaml(file)
       begin
-        YAML.load(File.read file)
+        YAML.load File.read(file).sub(/^__END__\n.*/m, "")
       rescue Errno::ENOENT
         Prick.error "Can't read #{file}"
       end
@@ -290,7 +309,7 @@ module Prick
     def load_yaml(file, mandatory_keys, optional_keys =  [])
       mandatory_keys = mandatory_keys.map(&:to_s)
       optional_keys = optional_keys.map(&:to_s)
-      hash = read_yaml(file)
+      hash = read_yaml(file) or Prick.error "Not a valid YAML file - #{file}"
       for key in mandatory_keys
         !hash[key].to_s.empty? or Prick.error "Can't find '#{key}' in #{file}"
       end
@@ -347,7 +366,7 @@ module Prick
 
     def load_environment_file
       hash = environment_file ? read_yaml(environment_file) : {}
-      Environment.load_environments(hash)
+      @environments = Environments.new(hash)
       @environment_loaded = true
     end
 

data/lib/prick/subcommand/prick-bash.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+class IO
+  def self.capture(&block) # ChatGPT
+    block_given? or raise ArgumentError
+    stdout = $stdout
+    begin
+      $stdout = StringIO.new
+      yield
+      $stdout.string
+    ensure
+      $stdout = stdout
+    end
+  end
+end
+
+module Prick::SubCommand
+  def self.bash(main: false)
+#   IO.capture {
+      env = Prick.state.environment # Shorthands
+      envs = Prick.state.environments
+
+      puts "#!/usr/bin/bash"
+      puts
+      puts "# This file is auto-generated by prick. Please don't touch"
+      puts
+      puts ". bash.include"
+      puts
+
+      # Emit environment. PRICK_ENVIRONMENT_BUILD is excluded because its value
+      # is bash source that is hard to escape and there is no use for this
+      # variable anyway
+      puts "### ENVIRONMENT by state.rb"
+      puts
+      puts Prick.state.bash_source(scope: :global)
+      puts
+
+      # Emit script
+      if env
+        envs.bash_command env
+      else
+        envs.bash_command
+      end
+
+      if main
+        puts "### MAIN by prick-load.rb"
+        puts
+        puts "build"
+      end
+#   }
+  end
+end
+

data/lib/prick/subcommand/prick-build.rb

@@ -18,7 +18,7 @@ module Prick::SubCommand
         conn = nil
         builder = nil
 
-        constrain super_conn.rdbms.exist?, true
+        constrain super_conn.rdbms.exist?(database), true # FIXME Same problem as below
 
         Timer.time "Load build object" do
           if super_conn.rdbms.exist? database # FIXME Why create database? Setup should have done this

data/lib/prick/subcommand/prick-create.rb

@@ -88,7 +88,7 @@ module Prick
             }
             !diff.same? or Prick.failure "No changes"
           ensure
-            drop_all(from_db)
+            drop_all(from_db) # FIXME This will fail, maybe use teardown instead?
             drop_all(to_db)
           end
         end

data/lib/prick/subcommand/prick-drop.rb

@@ -29,6 +29,8 @@ module Prick::SubCommand
       end
     else
       # We don't terminate sessions because we assume one-database-users
+      # FIXME: users is undefined
+      raise NotImpementedError
       conn.role.drop(users, cascade: true) # Fails if the users owns objects in other databases
     end
   end
@@ -44,30 +46,12 @@ module Prick::SubCommand
     constrain database, String
     constrain schemas, [String]
     if schemas.empty?
-      State.connection { |conn| conn.rdbms.empty!(database) }
+      State.connection { |conn| conn.rdbms.empty!(database, exclude: "prick") }
     else
       Prick.state.connection { |conn|
         schemas.each { |schema| conn.schema.drop(schema, cascade: true) }
       }
     end
   end
-
-  # Drop database and its users including the owner if possible and not the
-  # current user
-  def self.drop_all(database, username = nil)
-    constrain database, String
-    State.connection { |conn|
-      if username.nil? && conn.rdbms.exist?(database)
-        owner = State.connection.rdbms.owner(database)
-      else
-        owner = username || database
-      end
-      if conn.rdbms.exist? database
-        drop_users(database) 
-        drop_database(database)
-      end
-      drop_owner(owner) if owner != ENV['USER']
-    }
-  end
 end
 

data/lib/prick/subcommand/prick-list.rb

@@ -1,6 +1,6 @@
 module Prick::SubCommand
   def self.list_environments(format: :long)
-    environments = Environment.environments.select { |env| env.comment }
+    environments = Prick.state.environments.values.select { |env| env.comment }
     if format == :short
       puts environments.map(&:name)
     else
@@ -12,11 +12,24 @@ module Prick::SubCommand
 
   def self.list_variables(format: :long, all: false)
     if format == :short
-      puts Prick.state.bash_environment.keys
+      puts Prick.state.bash_environment(all: all).keys
     else
       headers = %w(variable value)
       vars = Prick.state.bash_environment(all: all).reject { |k,v| k == "PATH" }
-      rows = vars.map { |k,v| [k, Array(v).flatten.join(" ")] }
+      rows = vars.map
+#     rows = vars.map { |k,v| 
+#       if v.is_a?(Array)
+#         if v.first&.is_a?(Array)
+#           v = v.first
+#         else
+#           v = v.join(" ")
+#         end
+#       else
+#         v = v.to_s
+#       end
+#
+#       [k, v] 
+#     }
       Fmt.puts_table(headers, rows)
     end
   end

data/lib/prick/subcommand/prick-release.rb

@@ -8,7 +8,7 @@ module Prick
       Git.synchronized? or raise "Won't release: Repository is not synchronized with origin"
 
       version = Prick.state.version.increment!(kind).to_s
-      Prick.state.save_project
+      Prick.state.save_project(overwrite: true)
 
       Git.add(Prick.state.project_file)
       Git.add(Prick.state.schema_file)

data/lib/prick/version.rb

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

data/lib/prick.rb

@@ -2,9 +2,15 @@ require 'prick/version.rb'
 
 require 'pg_conn'
 
-require 'fixture_fox'
 require 'indented_io'
+
 require 'constrain'
+include Constrain
+
+require 'forward_to'
+include ForwardTo
+
+require 'fixture_fox'
 
 module Prick
   class Error < RuntimeError; end
@@ -33,17 +39,18 @@ module Prick
 end
 
 require_relative 'prick/subcommand/subcommand.rb'
+require_relative 'prick/subcommand/prick-bash.rb'
 require_relative 'prick/subcommand/prick-build.rb'
 require_relative 'prick/subcommand/prick-clean.rb'
 require_relative 'prick/subcommand/prick-create.rb'
 require_relative 'prick/subcommand/prick-drop.rb'
-require_relative 'prick/subcommand/prick-set.rb'
-require_relative 'prick/subcommand/prick-list.rb'
 require_relative 'prick/subcommand/prick-fox.rb'
 require_relative 'prick/subcommand/prick-init.rb'
+require_relative 'prick/subcommand/prick-list.rb'
 require_relative 'prick/subcommand/prick-make.rb'
 require_relative 'prick/subcommand/prick-migrate.rb'
 require_relative 'prick/subcommand/prick-release.rb'
+require_relative 'prick/subcommand/prick-set.rb'
 require_relative 'prick/subcommand/prick-setup.rb'
 require_relative 'prick/subcommand/prick-teardown.rb'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prick
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-23 00:00:00.000000000 Z
+date: 2024-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic
@@ -182,6 +182,7 @@ files:
 - bin/setup
 - doc/build-yml.txt
 - exe/prick
+- idea.txt
 - lib/prick.rb
 - lib/prick/builder/batch.rb
 - lib/prick/builder/builder.rb
@@ -218,6 +219,7 @@ files:
 - lib/prick/share/migrate/migration/diff.before-tables.sql
 - lib/prick/share/migrate/migration/diff.tables.sql
 - lib/prick/state.rb
+- lib/prick/subcommand/prick-bash.rb
 - lib/prick/subcommand/prick-build.rb
 - lib/prick/subcommand/prick-clean.rb
 - lib/prick/subcommand/prick-create.rb
@@ -252,7 +254,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.18
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A release control and management system for postgresql