prick 0.29.2 → 0.30.0

data/lib/prick/state.rb

@@ -2,76 +2,172 @@
 require 'yaml'
 
 module Prick
+  # There is only one State object: Prick.state
+  #
+  # FIXME Not how it is done
+  # The prick.state file contains the current database, username, and
+  # environment. It is controlled by prick(1) but you can set its values by
+  # using 'prick database=asdf
+  #
   class State
-    # State file
-    def file() PRICK_PROJECT_PATH end
+    # Prick project dir. This is not a constant because prick can change
+    # directory through the -C option or the 'init' command
+    def prick_dir() @prick_dir ||= Dir.getwd end
 
-    # Schema data file
+    # Project file. Default 'prick.yml'
+    attr_reader :project_file
+
+    # Environment file. Default 'prick.environment'. Note that the file can be
+    # absent if the project doesn't use environments
+    attr_reader :environment_file
+
+    # State file. Default '.prick-state.yml'
+    attr_reader :state_file
+
+    # Schema data file. FIXME What is this?
     def schema_file() SCHEMA_VERSION_PATH end
 
+    # True if the configuration files has been loaded
+    def project_loaded? = @project_loaded
+    def state_loaded? = @state_loaded
+    def environment_loaded? = @environment_loaded
+
     # Used as an identifier and the default database and username
     attr_accessor :name
 
     # Capitalized name of project
     attr_accessor :title
 
-    # Version in prick.yml. Can be nil
+    # Project version in prick.yml. Can be nil FIXME Can it?
     attr_accessor :version
 
-    # Version in schema/prick/data.sql. Retrieved dynamically. TODO
-    attr_reader :schema_version
-
-    # Version from prick.versions.version. Retrieved dynamically. TODO FIXME: Where is conn?
-    attr_reader :database_version
-
-    # Version of prick(1)
+    # Version of prick in prick.yml. Note that this can be different than the current
+    # version of prick 
     attr_accessor :prick_version
 
-    # Name of database
+    # Database name. nil if state file is absent
     attr_accessor :database
 
-    # Name of database user
+    # Database owner name. Typically the same as the database name. nil if
+    # database is absent
     attr_accessor :username
 
-    # Run-time environment name
+    # 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
+    # corresponding Environment object
     def environment() @environment end
     def environment=(env)
-      constrain env, String
-      Environment.environment?(env) or raise "Illegal environment: '#{env}'"
+      constrain env, String, nil
+      env.nil? || Environment.environment?(env) or raise "Illegal environment: '#{env}'"
       @environment = env
     end
 
-    # Prick project dir. This is not a constant because exe/prick can change
-    # directory (FIXME it can?)
-    def prick_dir
-      @prick_dir ||= Dir.getwd
+    # Project version from PRICK.VERSIONS. Initialized by #connection
+    attr_accessor :database_version
+
+    # Prick version from PRICK.VERSIONS. Initialized by #connection
+    attr_accessor :database_prick_version
+
+    # Environment from PRICK.VERSIONS. Initialized by #connection
+    attr_accessor :database_environment
+
+    # Git branch. Lazy-evaluated
+    def branch() @branch ||= Git.branch.current end
+
+    # Git revision (commit ID). Lazy-evaluated
+    def rev(kind: :long) 
+      case kind
+        when :short; @rev_short ||= rev()[0...8]
+        when :long; @rev_long ||= Git.id
+      end
+    end
+
+    # True if the git repository is clean (not modified). Lazy-evaluated
+    def clean?() 
+      return @clean if defined?(@clean)
+      @clean = Git.clean?
+    end
+
+    def initialize(project_file, environment_file, state_file)
+      @project_file, @environment_file, @state_file = project_file, environment_file, state_file
+      @project_loaded = @state_loaded = @environment_loaded = false
+
+      if @project_file && File.exist?(@project_file)
+        load_project_file
+        load_state_file if @state_file && File.exist?(@state_file)
+      end
+
+      # FIXME The environment file should be loaded on-demand but it is hard to
+      # do when the environments are accessed through a class-interface
+      load_environment_file if @environment_file && File.exist?(@environment_file)
+    end
+
+    # 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?
+        @connection = PgConn.new(database, username)
+
+        # Set database_version/environment/prick members
+        load_database_environment
+
+        # Set environment if undefined and not overridden by :environment
+        self.environment = 
+            environment || 
+            Prick.state.environment || 
+            Environment.environment?(database_environment) && database_environment ||
+            DEFAULT_ENVIRONMENT
+      end
+      if block_given?
+        yield @connection
+      else
+        @connection
+      end
+    end
+
+    # Superuser connection. This is a connection to Postgres using the current
+    # user's credentials. It is assumed that the current user has a postgres
+    # superuser account with the same name as the user's. Memoized to connect
+    # only once
+    def self.connection(&block)
+      @@connection ||= PgConn.new("postgres")
+      if block_given?
+        yield @@connection
+      else
+        @@connection
+      end
     end
 
-    # Prick executable search_path
+    # Short-hand for #connection
+    alias_method :conn, :connection
+
+    # Prick executable search_path. This includes the bin and libexec directories
     def executable_search_path
       @executable_search_path ||= "#{ENV['PATH']}:#{prick_dir}/#{BIN_DIR}:#{prick_dir}/#{LIBEXEC_DIR}"
     end
 
     # Create a bash(1) environment (Hash). It is used for in-prick expansion of
-    # variables and also injected into the enviroment of subprocesses
-    def bash_environment(scope = :global)
-      hash = {
-        "DATABASE" =>  Prick.state.database, # FIXME: Yt
-        "USERNAME" =>  Prick.state.username, # FIXME: Yt
-        "ENVIRONMENT" =>  Prick.state.environment.to_s, # FIXME: Yt
-        "PRICK_NAME" => Prick.state.name,
-        "PRICK_TITLE" => Prick.state.title,
-        "PRICK_VERSION" => Prick.state.version,
-        "PRICK_DATABASE" =>  Prick.state.database,
-        "PRICK_USERNAME" =>  Prick.state.username,
-        "PRICK_ENVIRONMENT" =>  Prick.state.environment.to_s,
-      }
-      case scope
-        when :local; # nop
-          hash.merge Environment[Prick.state.environment].bash_env
-        when :global; 
-          ENV.to_h.merge(hash).merge({
-            "PATH" => Prick.state.executable_search_path,
+    # variables and is also injected into the enviroment of subprocesses    
+    # 
+    # FIXME: Problems with BUNDLE_* variables FIXME Still a problem?
+    #
+    # TODO: Explain handling of PRICK_<STANDARD-DIRECTORY>
+    def bash_environment(all: true)
+      @bash_environment ||= begin
+        hash = {
+          "PATH" => Prick.state.executable_search_path
+        }
+
+        if all
+          hash.merge!({
+            "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),
@@ -80,52 +176,90 @@ module Prick
             "PRICK_SPOOLDIR" =>  File.join(Prick.state.prick_dir, SPOOL_DIR),
             "PRICK_TMPDIR" =>  File.join(Prick.state.prick_dir, TMP_DIR),
             "PRICK_CLONEDIR" =>  File.join(Prick.state.prick_dir, CLONE_DIR),
-            "PRICK_SPECDIR" =>  File.join(Prick.state.prick_dir, BIN_DIR)
-          }).merge(Environment[Prick.state.environment].bash_env)
+            "PRICK_SPECDIR" =>  File.join(Prick.state.prick_dir, BIN_DIR),
+          })
+        end
+
+        hash.merge!({
+          "DATABASE" =>  Prick.state.database, # FIXME: Yt
+          "USERNAME" =>  Prick.state.username, # FIXME: Yt
+          "ENVIRONMENT" =>  Prick.state.environment.to_s, # FIXME: Yt
+          "PRICK_NAME" => Prick.state.name,
+          "PRICK_TITLE" => Prick.state.title,
+          "PRICK_VERSION" => Prick.state.version,
+          "PRICK_DATABASE" =>  Prick.state.database,
+          "PRICK_USERNAME" =>  Prick.state.username,
+          "PRICK_ENVIRONMENT" =>  Prick.state.environment&.to_s, # may be the empty string
+        })
+
+        # PRICK_ENVIRONMENT_* variables
+        hash.merge! (Prick.state.environment.nil? ? {} : Environment[Prick.state.environment].bash_env)
+      end
+    end
+
+    # @scope can be :global (variables are exported), :local (variables are
+    # declared local), or nil (variables are global but not exported)
+    def bash_source(vars = nil, scope: nil)
+      case scope
+        when :global; prefix="export "
+        when :local; prefix="local "
+        when nil; prefix=""
       else
-        raise ArgumentError
+        raise ArgumentError, "Illegal value for scope: #{scope.inspect}"
       end
+
+      (vars || bash_environment.keys).map { |var|
+        val = bash_environment[var]
+        "#{prefix}#{var}=\"#{Array(val).join(' ')}\"\n" 
+      }.join
     end
 
-    def bash_source
-      bash_environment(:local).map { |var,val| "export #{var}=\"#{Array(val).join(' ')}\"\n" }.join
+    # It is an error if the project file exists. 
+    def save_project
+      !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
 
-    def self.load(project_file, context_file)
-      state = State.new
-      state.send(:parse_project_file, project_file || PRICK_PROJECT_PATH)
-      state.send(:parse_context_file, context_file || PRICK_CONTEXT_PATH)
-      state
+    # FIXME: Ugly
+    def save_version
+      system("sed -i 's/^version:.*/version: #{version.to_s} #{project_file}/'")
     end
 
-    def save
-      raise NotImplementedError
-      h = {
-        "name" => name,
-        "title" => title,
-        "version" => version.to_s,
-        "prick" => prick_version.to_s
-      }
-      File.write(PRICK_PROJECT_PATH, h.to_yaml)
+    # Used by 'prick setup'
+    def save_state(database = nil, username = nil, environment = nil)
+      database ||= self.database or raise ArgumentError
+      username ||= self.username or raise ArgumentError
+      environment ||= self.environment
+      save_yaml(state_file, database: database, username: username, environment: environment)
+    end
 
-      h = {
-        "environment" => environment.to_s,
-        "database" => database,
-        "username" => username
-      }
-      File.write(PRICK_CONTEXT_PATH, h.to_yaml)
-
-      if version
-        File.write(SCHEMA_VERSION_PATH, 
-            <<~EOS
-              --
-              -- This file is auto-generated by prick(1). Please don't touch
-              --
-              delete from prick.versions;
-              insert into prick.versions (fork, major, minor, patch, pre, feature, version)
-                  values (null, #{version.major}, #{version.minor}, #{version.patch}, null, null, '#{version}');
-            EOS
-        )
+    # Save build-start information to PRICK.BUILDS. It is a nop if PRICK.BUILDS
+    # doesn't exist, this happens on first build in a completely empty database
+    def save_build_begin
+      @build_id = nil # Used by save_build_end
+      if conn.schema.exist_table?("prick", "builds")
+        @build_id = insert_record(
+            "prick.builds",
+            name: name,
+            version: version.to_s, prick: prick_version, 
+            branch: branch, rev: rev(:short), clean: clean?,
+            environment: environment)
+      end
+    end
+
+    def save_build_end(success, duration)
+      dt = Time.now - TIME
+      if @build_id
+        update_record("prick.builds", @build_id, success: success, duration: duration, prick_duration: dt)
+      else
+        insert_record(
+            "prick.builds",
+            name: name,
+            version: version.to_s, prick: prick_version, 
+            branch: branch, rev: rev(:short), clean: clean?,
+            environment: environment,
+            success: success, duration: duration, prick_duration: dt)
       end
     end
 
@@ -133,8 +267,8 @@ module Prick
       puts "State"
       indent {
         for method in [
-            :name, :title, :prick_version, :project_version, :schema_version,
-            :database_version, :database, :username]
+            :name, :title, :prick_version, :project_version, 
+            :database_version, :database_environment, :database, :username]
           puts "#{method}: #{self.send method}"
         end
         puts "environments:"
@@ -143,36 +277,104 @@ module Prick
     end
 
   private
-    def load_yaml(file, expected_keys, optional_keys)
+    # YAML helper methods
+
+    def read_yaml(file)
       begin
-        hash = YAML.load(File.read file)
+        YAML.load(File.read file)
       rescue Errno::ENOENT
-        raise Prick::Error, "Can't read #{file}"
+        Prick.error "Can't read #{file}"
       end
-      for key in expected_keys
-        !hash[key].to_s.empty? or raise Prick::Error, "Can't find '#{key}' in #{file}"
+    end
+
+    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)
+      for key in mandatory_keys
+        !hash[key].to_s.empty? or Prick.error "Can't find '#{key}' in #{file}"
       end
-      (unknown = (hash.keys - expected_keys - optional_keys).first) and 
-          Prick::Error "Illegal key '#{unknown}' in #{file}"
+      (unknown = (hash.keys - mandatory_keys - optional_keys).first) and 
+          Prick.error "Illegal key '#{unknown}' in #{file}"
       hash
     end
 
-    def parse_context_file(context_file)
-      hash = load_yaml(context_file, %w(environment database username), [])
-      @database = hash["database"]
-      @username = hash["username"]
-      @environment = hash["environment"]
+    def save_yaml(file, hash)
+      self.class.save_yaml(file, hash)
+    end
+
+    def self.save_yaml(file, hash)
+      IO.write(file, hash.map { |k,v| [k.to_s, v] }.to_h.to_yaml)
+    end
+
+    # Database helper methods. TODO: Make generally available
+
+    # FIXME FIXME FIXME Yt. Replace with PgConn methods
+    def select_record(table, id, columns = [])
+      sql_columns = columns.join(", ")
+      sql_id_cond = (id.nil? ? "true" : "id = #{id}")
+      connection.tuple "select #{sql_columns} from #{table} where #{sql_id_cond}"
     end
 
-    def parse_project_file(prick_file)
-      hash = load_yaml(prick_file, %w(name title), %w(version prick environments))
+    def select_record?(table, id, columns = [])
+      sql_columns = columns.join(", ")
+      sql_id_cond = (id.nil? ? "true" : "id = #{id}")
+      connection.tuple? "select #{sql_columns} from #{table} where #{sql_id_cond}"
+    end
+
+    def insert_record(table, attrs = {})
+      sql_fields = attrs.keys.join(", ")
+      sql_values = attrs.values.map { conn.quote_literal(_1) }.join(", ")
+      conn.value "insert into #{table} (#{sql_fields}) values (#{sql_values}) returning id"
+    end
+
+    def update_record(table, id, attrs = {})
+      sql_assign = attrs.map { |k,v| "#{conn.quote_identifier(k)} = #{conn.quote_literal(v)}" }.join(", ")
+      sql_id_cond = (id.nil? ? "true" : "id = #{id}")
+      conn.exec "update #{table} set #{sql_assign} where #{sql_id_cond}"
+    end
+
+    # State helper methods
+
+    def load_project_file
+      hash = load_yaml(project_file, %w(name title), %w(version prick))
       @name = hash["name"]
       @title = hash["title"]
       @version = hash["version"] && PrickVersion.new(hash["version"])
       @prick_version = hash["prick"] && PrickVersion.new(hash["prick"])
-      Environment.load_environments(hash["environments"] || {})
+      @project_loaded = true
+    end
+
+    def load_environment_file
+      hash = environment_file ? read_yaml(environment_file) : {}
+      Environment.load_environments(hash)
+      @environment_loaded = true
+    end
+
+    def load_state_file
+      hash = load_yaml(state_file, %w(database username), %w(environment))
+      @database = hash["database"]
+      @username = hash["username"]
+      @environment = hash["environment"]
+      @state_loaded = true
+    end
+
+    # Database helper methods
+
+    # Return true if the database environment exists
+    def exist_database_environment?
+      connection.schema.exist_relation?("prick", "versions")
+    end
+
+    # Loads database environment. It is an error if the prick schema is absent
+    def load_database_environment
+      version, environment, prick_version = connection.tuple %(
+        select version, environment, prick from prick.versions
+      )
+      @database_version = PrickVersion.new(version)
+      @database_environment = environment
+      @database_prick_version = PrickVersion.new(prick_version)
     end
   end
 end
 
-

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

@@ -5,36 +5,40 @@ require_relative '../builder/builder.rb'
 module Prick::SubCommand
   def self.build(
       database, username, schema, 
-      builddir: "schema", force: false, timer: nil, dump: nil)
+      builddir: "schema", force: false, 
+      timer: nil, dump: nil)
 
     Timer.on! if timer
-    time "Prick::Command#build" do
-      begin
-        super_conn = PgConn.new # Used to create new databases (doesn't make a
-                                # difference right now as the mikras user is
-                                # still a superuser)
 
+    Timer.time "Prick::Command#build" do
+      begin
+        super_conn = State.connection # Used to create new databases (doesn't make a
+                                      # difference right now as the database user is
+                                      # a superuser anyway
         conn = nil
         builder = nil
-        time "Load build object" do
-          if super_conn.rdbms.exist? database
+
+        constrain super_conn.rdbms.exist?, true
+
+        Timer.time "Load build object" do
+          if super_conn.rdbms.exist? database # FIXME Why create database? Setup should have done this
             exist = true
           else
             super_conn.rdbms.create database, owner: username
             exist = false
           end
-          conn = PgConn.new(database, username)
+          conn = Prick.state.connection
 
           builder = Prick::Build::Builder.new(conn, builddir)
 
-          if exist
+          if exist # Empty (part of) the database
             if force
-              # Drop all schemas but re-creates the public schema
-              super_conn.rdbms.empty!(database, public: false)
-
+              # Drop all schemas except the prick schema and re-creates the
+              # public schema
+              build.pool.delete_schema("prick") if super_conn.schema.exist?("prick")
+              super_conn.rdbms.empty!(database, public: false, exclude: ["prick"])
             else
-              # Find schemas to refresh. This includes all schemas in the
-              # database
+              # Find all schemas
               refresh_schemas = conn.schema.list
 
               # Find existing keep-schemas (but exclude target schema)
@@ -45,15 +49,17 @@ module Prick::SubCommand
               # Remove keep-schemas from list of schemas
               refresh_schemas -= keep_schemas
 
-              # Eliminate keep schemas from build pool
+              # Also remove keep-schemas from the build pool. Why don't we use
+              # the pool tracker's list of keep schemas?
               builder.pool.delete_schema(keep_schemas)
 
               # Drop refresh schemes
-              refresh_schemas.each { |schema| conn.schema.drop(schema, cascade: true) }
+              refresh_schemas.each { |s| conn.schema.drop(s, cascade: true) }
             end
           end
 
-          # Delete schemas after target scheme if present
+          # Delete schemas that comes after the target in the build sequence if
+          # 'prick build' was given a schema
           builder.pool.delete_schema(builder.pool.after_schema(schema)) if schema
         end
         
@@ -63,10 +69,10 @@ module Prick::SubCommand
           when :batches; builder.dump
           when nil;
         else
-          raise Prick::Error, "Illegal dump type: #{dump.inspect}"
+          Prick.error "Illegal dump type: #{dump.inspect}"
         end && exit
 
-        time "Execute build object" do
+        Timer.time "Execute build object" do
           builder.execute conn
         end
 

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

@@ -3,13 +3,13 @@
 require_relative '../builder/builder.rb'
 
 module Prick::SubCommand
-  # Drop users and empty database. This has the same as effect as
-  # teardown+setup but without recreating the user and the database that
-  # annoyingly terminates all user sessions
+  # Drop users and hollow-out database. This has the same as effect as
+  # teardown+setup but without recreating the database owner and the database
+  # which would otherwise terminate all user sessions
   def self.clean(database)
     drop_users(database)
-    PgConn.new("postgres") { |conn|
-      conn.rdbms.empty!(database) if conn.rdbms.exist?(database)
+    State.connection { |conn|
+      conn.rdbms.empty!(database, exclude: ["prick"]) if conn.rdbms.exist?(database)
     }
   end
 end

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

@@ -1,16 +1,51 @@
-
 module Prick
   module SubCommand
+    PRICK_BUILD_FILES = %w(tables.sql views.sql) # HARDCODED
+
+    def self.create_database(database, username, environment)
+      super_conn = State.connection
+
+      # Create user if absent
+      if !super_conn.role.exist? username
+        # FIXME Should not be created as superuser but we can't do that before we
+        # have a super: option in build so that superuser-requiring function
+        # definitions can be built
+        super_conn.role.create username, superuser: true, can_login: true, create_role: true
+      end
+
+      # Create database
+      super_conn.rdbms.create database, owner: username
+
+      # Setup Prick schema. Note that this is hardcoded, the prick build file
+      # is ignored
+      conn = PgConn.new(database, username) # Can't use Prick.state.connection on a new database
+      conn.schema.create("prick")
+      PRICK_BUILD_FILES.each { |file| conn.exec(IO.read("#{SCHEMA_PRICK_DIR}/#{file}")) }
+
+      # Add initial build record
+      state = Prick.state # shorthand
+      conn.insert "prick.builds",
+          name: state.title,
+          version: state.version,
+          prick: state.prick_version,
+          branch: state.branch,
+          rev: state.rev(kind: :short),
+          clean: state.clean?,
+          environment: environment || Prick::DEFAULT_ENVIRONMENT,
+          built_at: nil,
+          success: nil
+    end
+      
     def self.create_migration(username, from_version, force: false, file: nil)
       constrain from_version, PrickVersion
       Git.clean? or raise "Won't migrate: Repository is dirty"
       Git.synchronized? or raise "Won't migrate: Repository is not synchronized"
 
-      from_version != PrickVersion.zero or raise Prick::Error, "Can't migrate from release 0.0.0"
+      from_version != PrickVersion.zero or Prick.error "Can't migrate from release 0.0.0"
       to_version = Prick.state.version
       migration_dir = "#{MIGRATION_DIR}/#{from_version}"
       migration_exist = File.directory? migration_dir
-      force || file || !migration_exist or raise Prick::Fail, "Migration #{from_version} exists"
+      force || file || !migration_exist or Prick.failure "Migration #{from_version} exists"
 
       $quiet = true if file
 
@@ -21,8 +56,8 @@ module Prick
           end
         }
       else
-        from_version != to_version or raise Prick::Fail, "Can't migrate to same release"
-        from_version < to_version or raise Prick::Fail, "Can't migrate backwards (why not?)"
+        from_version != to_version or Prick.failure "Can't migrate to same release"
+        from_version < to_version or Prick.failure "Can't migrate backwards (why not?)"
 
         diff = nil
         if force || !migration_exist
@@ -51,7 +86,7 @@ module Prick
               mesg "  Creating diff"
               Diff.new(from_db, to_db)
             }
-            !diff.same? or raise Prick::Fail, "No changes"
+            !diff.same? or Prick.failure "No changes"
           ensure
             drop_all(from_db)
             drop_all(to_db)