prick 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71425ed90edd4de504fc95a6d270a5659c0ff206710db81c4994b03af76931e9
-  data.tar.gz: 3c5454cc8052d994257dba637285088352196f7bb522dd16fb19e4d43cafe3b8
+  metadata.gz: fed99dbfdf6e89642b4e8fdddf976efa58b1c8b75d9169fa460bd8190805cc63
+  data.tar.gz: 97fec32bbd130043b2c782f133ab5af30e9bcc5c42d4c83a26311f486786d671
 SHA512:
-  metadata.gz: f59c9a5ac1284eeb006327370308630ec24b3dc30dfa9af10f0695f6b0501bcfe207750b78893315f2478364eee576f780a65662d6827aa77fe2b654f5b38a8a
-  data.tar.gz: 7958f8d49c73c5c1b2de604fb671367c2704ef3d373c0847ae9861378f719b2e6e9d02661c8b3c36ce91541e8adb71875f3d233f7151277c64d51439087203ad
+  metadata.gz: 35859b1f387d1bf8ccb04a37a853d509e8038102f9521a7b4b35884db5d2682e5a06bd3dda9f4aff704a105603d9df17a43d2d1bbfa66f39ba751584b73b7cb9
+  data.tar.gz: cc7dfb26f5c10b1489d82f5be5c824e7d7d118de29d9ceae6b424e26506701650da57ed800107ce8ad10ea0bda3e1d29934000170702b285ae3d7a3a8123426f

data/exe/prick

@@ -121,10 +121,10 @@ SPEC = %(
 
   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
@@ -133,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
@@ -357,6 +361,9 @@ 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)

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,150 +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
 
-    def self.dump
-      environments.each(&:dump)
+    # 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
 
-  private
-    @@VARIABLES = []
-    @@ENVIRONMENTS = {}
-    @@SORTED_ENVIRONMENTS = []
-
-    def self.yaml_to_array(value)
-      case value
-        when /\n/; [value.split("\n")]
-        when nil ; []
-        when String; value.split
-        else [value.to_s]
-      end
-#     !value.nil? && Array(value).flatten.compact.map(&:to_s).map(&:split).flatten
+    def undent(s)
+      s = s[1..] if s[0] == "\n"
+      s =~ /^(\s*)\S$/m
+      indent = $1
+      s.gsub(/^#{indent}/m, "")
     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_environment
+
+    end
+
+    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 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 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
 
-      # Check for undeclared inherited environments
-      @@SORTED_ENVIRONMENTS.each { |environment|
-        @@ENVIRONMENTS.key?(environment) or raise ArgumentError, "Can't find '#{inherited}' environment"
+    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 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
+
+    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
 
@@ -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,8 +216,11 @@ 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]
+#       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")
@@ -217,13 +228,14 @@ module Prick
             val = val.join(" ")
           end
         end
-        "#{prefix}#{var}=\"#{val}\"\n" 
-      }.join
+        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
@@ -279,7 +291,7 @@ module Prick
           puts "#{method}: #{self.send method}"
         end
         puts "environments:"
-        indent { Environment.dump }
+        indent { environments.dump }
       }
     end
 
@@ -288,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
@@ -354,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-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
@@ -16,7 +16,20 @@ module Prick::SubCommand
     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.31.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.31.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Claus Rasmussen
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-15 00:00:00.000000000 Z
+date: 2024-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic
@@ -219,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
@@ -238,7 +239,7 @@ files:
 homepage: http://www.nowhere.com/
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -254,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.7
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A release control and management system for postgresql
 test_files: []