prick 0.28.0 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '022876c913aadf3a2b42646f514f51c2db481c32db42a5903f2dbce88303d423'
-  data.tar.gz: 1772f43a5a99fe93b97e748488f3c5bfa93fddce768176744ebb27e983cbb475
+  metadata.gz: 10bf0db9a65cd8441d8f17ea9ad055f177d49508f2445ee733722fcc0fb5c6dc
+  data.tar.gz: 693a602c5f57b6bdd97cdefa00c69a0c517cd54e4b32e2d10657fa1c8cfb8949
 SHA512:
-  metadata.gz: d8c647cc168aee7f0aab47d39d6ce1050331a06b6aa7a04fc8173152618432c377eb7ce42784eb95d2a70134be10bddd0ff3a43298c2e20af8a3649dc8227451
-  data.tar.gz: 84068d08a68d2b1177054faa4d31218bf7bc66cf437bf255a6ff2404c0126e10288e58519e11fe7c80029c7169ff9e3a59be5327c39f8fd112bc0a846519d833
+  metadata.gz: 1ec3e792b312d572d9eb65feb3c595d94ec944b9854f12c9f16a805dfce24a45d0be6fe923c02fc1bf57c9a3ce0d6b221c28eaeaea5a1ab1a0f044e228a07b5e
+  data.tar.gz: a0cc6eb39133fbfc7eef170a173378bd685a3f43315ac633748dc1fafa02589dae100d1fe8f30ab4687a175e3d8a13d0fca793245fbb10fb2297fed5d8e4c659

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

data/lib/builder/batch.rb

@@ -32,8 +32,8 @@ module Prick
         super {
           begin
             sql = []
-            # A SQL batch allows the first node to be an executable
-            if nodes.first.is_a?(ExeNode)
+            # A SQL batch allows the first node to be an evaluated or executed node
+            if nodes.first.is_a?(CommandNode)
               time "Execute script" do
                 sql = [nodes.first.source]
               end

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,91 @@ module Prick
         end
       end
 
+      # Search for an executable in path
+      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 $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
+      #
+      # The production environment acts as a online environment but not a
+      # development environment. This means it will first search for
+      # 'production', then 'online', and then stop without searching for
+      # 'development'
+      #
+      # NOTE: This is a hardcoded feature for an internal project. It is
+      #       configurable in the next major version
+      # 
+      # TODO: Refactor: dir is not handled well when the filename includes a
+      #       $PWD variblea
+      #
+      def expand_filename(dir, filename)
+        # Expand variables
+        path = expand_variables(filename, Prick.state.bash_environment)
+
+        # Use only filename as template if expansion is an absolute path
+        if path.start_with? "/"
+          template = filename
+        else
+          template = "#{dir}/#{filename}"
+          path = "#{dir}/#{path}"
+        end
+        return path if File.exist?(path)
+
+        # Iterate through environments
+        env = Prick.state.environment.to_s
+        while true
+          return path if File.exist?(path)
+          case env
+            when "production"
+              file = expand_variables(path, ENVIRONMENT: "online") or return nil
+              return file if File.exist? file
+              break
+            when "development"; break
+            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
+          path = expand_variables(template, Prick.state.bash_environment.merge(ENVIRONMENT: env))
+        end
+
+        # Look for executable in PATH
+        if filename !~ /\// && (path = find_executable(filename))
+          return path
+        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
+
       def parse_directory(parent, dir)
         build_file = "#{dir}/build.yml".sub(/\/\//, "/")
         if File.exist? build_file
@@ -77,89 +162,24 @@ 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
+          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,19 +188,27 @@ 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$/
@@ -188,14 +216,11 @@ module Prick
               when /\.fox$/
                 FoxNode.new(unit, :seed, 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}"
+            path = 
+            raise Error, "Can't find '#{entry}' in #{dir}/ from #{unit}"
           end
         end
       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,6 +26,12 @@ 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
@@ -42,7 +50,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/state.rb

@@ -36,6 +36,35 @@ module Prick
     # Name of database user
     attr_accessor :username
 
+    # Prick project dir. This is not a constant because exe/prick can change directory
+    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
+
+    def bash_environment
+      ENV.to_h.merge({
+        DATABASE: Prick.state.database,
+        USERNAME: Prick.state.username,
+        ENVIRONMENT: Prick.state.environment.to_s,
+        PRICK_DIR: Prick.state.prick_dir,
+        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),
+        PATH: Prick.state.executable_search_path
+      })
+    end
+
     def self.load
       begin
         h = YAML.load(File.read PRICK_PROJECT_PATH)

data/lib/prick/version.rb

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

data/lib/subcommand/prick-build.rb

@@ -29,6 +29,7 @@ module Prick::SubCommand
             if force
               # Drop all schemas but re-creates the public schema
               super_conn.rdbms.empty!(database)
+              conn.schema.drop("public") # drop it again FIXME
 
             else
               # Find schemas to refresh. This includes all schemas in the

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prick
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.28.1
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-08 00:00:00.000000000 Z
+date: 2024-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic
@@ -231,7 +231,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