prick 0.27.2 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d567ea292c77fde8d238f35dad37e284917bb54bdcfa044e9916fd771686c82c
-  data.tar.gz: df8f4285e9d53fa9c907e1c43aa4a587d7b6709cda42540f1e1ba6092caf8bce
+  metadata.gz: 10bf0db9a65cd8441d8f17ea9ad055f177d49508f2445ee733722fcc0fb5c6dc
+  data.tar.gz: 693a602c5f57b6bdd97cdefa00c69a0c517cd54e4b32e2d10657fa1c8cfb8949
 SHA512:
-  metadata.gz: aaca4641608807b55e8154db7d79aff8314b88aade591e0d5fd5920b9ada1984f9ecf07a1098d40a1afd3578dc51915b40bea334bd5eb4b36b33e45bb1d45c25
-  data.tar.gz: 2e72149f29ca87b21f407491f3bb40e5bdf1bbda10908b5df25ac4f432d3776b2510e77592ad5cda45c6bb55447091cb53709788869f10bbb6a97403685bc28d
+  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
@@ -62,11 +147,11 @@ module Prick
                   when "seed"; unit.seed_nodes
                 else
                   raise Error, "Illegal key in #{unit.path}: #{key}"
-                end.concat(Array(value).map { |value| parse_entry(unit, key.to_sym, dir, value) })
+                end.concat(Array(value).map { |value| parse_entry(unit, key.to_sym, dir, value) }.compact)
               end
             }
           else
-            node = parse_entry(unit, :decl, dir, entry)
+            node = parse_entry(unit, :decl, dir, entry) or next
             if node.kind == :fox
               unit.seed_nodes << node
             else
@@ -77,58 +162,22 @@ module Prick
         unit
       end
 
-      # Expand $ENVIRONMENT variable. 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
-      # algorithm returns the unexpanded value
-      #
-      def expand_environment(dir, name)
-        env = Prick.state.environment.to_s
-        file = name
-        if !File.exist?("#{dir}/#{file}") && name =~ /^(.*?)\$ENVIRONMENT/
-          while true
-            file = expand_variables(name, ENVIRONMENT: env)
-            break if File.exist? "#{dir}/#{file}"
-            case env
-              when "production"; 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
-          end
-        end
-        return file
-      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
+      # 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*$/
+          command = $1
+          optional = !$2.nil?
+          args = expand_string($3 || '').split
+          path = expand_filename(dir, command) 
+          path || optional or raise Error, "Can't find '#{entry}' in #{dir}/ from #{unit}"
+          !path.nil? or return nil
         else
-          file = name
+          raise Error, "Not a file name: '#{entry}'"
         end
-        path = "#{dir}/#{file}"
-        [path, name, file, args]
+        [path, Array(args).flatten]
       end
 
       def parse_entry(unit, phase, dir, entry)
@@ -137,22 +186,29 @@ module Prick
           key, value = entry.first
           case key
             when "sql"
-              InlineNode.new(unit, phase, unit.path, value)
-            when "call" 
-              args = value.split(/\s+/)
-              args.size >= 3 or raise "Illegal number of arguments: #{value}"
-              file, klass, command, args = *args
-              ModuleNode.new(unit, phase, "#{dir}/#{file}", klass, command, args)
+              InlineNode.new(unit, phase, unit.path, expand_string(value))
+            when "call"
+              (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, 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(dir, value)
-              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(dir, entry)
+          (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$/
@@ -160,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.27.2"
+  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.27.2
+  version: 0.28.1
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-06 00:00:00.000000000 Z
+date: 2024-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic