prick 0.19.0 → 0.20.1

data/lib/subcommand/prick-build.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  def self.build(database, username, schema, builddir: "schema", timer: nil, dump: nil)
+    Timer.on! if timer
+    time "Prick::Command#build" do
+      begin
+        super_conn = PgConn.new
+        conn = nil
+        builder = nil
+
+        time "Load build object" do
+          if super_conn.rdbms.exist? database
+            conn = PgConn.new(database, username)
+            super_conn.rdbms.empty!(database)
+          else
+            super_conn.rdbms.create database, owner: username
+            conn = PgConn.new(database, username)
+          end
+
+          builder = Prick::Build::Builder.new(conn, builddir)
+          builder.pool.delete_schema(builder.pool.after_schema(schema)) if schema
+        end
+        
+        case dump
+          when :nodes; builder.nodes.reject { |node| node.is_a?(Build::BuildNode) }.map &:dump
+          when :allnodes; builder.nodes.map &:dump
+          when :batches; builder.dump
+          when nil;
+        else
+          raise Prick::Error, "Illegal dump type: #{dump.inspect}"
+        end && exit
+
+        time "Execute build object" do
+          builder.execute conn
+        end
+
+      rescue Prick::Error => ex
+        $stderr.puts ex.message
+        exit 1
+
+      rescue ::Command::Error => ex
+        $stderr.puts ex.message
+        exit 1
+
+      ensure
+        super_conn&.terminate
+        conn&.terminate
+      end
+    end
+  end
+end
+

data/lib/subcommand/prick-create.rb

@@ -0,0 +1,78 @@
+
+module Prick
+  module SubCommand
+    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"
+      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"
+
+      $quiet = true if file
+
+      if file && migration_exist
+        File.open(file, "w") { |file|
+          for diff_file in DIFF_FILES
+            file.write File.read("#{migration_dir}/#{diff_file}")
+          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?)"
+
+        diff = nil
+        if force || !migration_exist
+          from_db = "#{Prick.state.name}-#{from_version}"
+          to_db = "#{Prick.state.name}-#{to_version}"
+
+          mesg "Migrating from #{from_version} to #{to_version}"
+          begin
+            origin = Git.origin
+
+            # Local repos are supported to ease testing
+            if File.directory?(origin)
+              origin = File.expand_path(origin)
+            end
+
+            diff = Dir.mktmpdir { |tmpdir|
+                Dir.chdir(tmpdir) {
+                mesg "  Building #{from_db}"
+                Git.clone(origin, from_version, branch: from_version)
+                Dir.chdir(from_version.to_s) { build(from_db, username, nil) }
+              }
+
+              mesg "  Building #{to_db}"
+              build(to_db, username, nil)
+
+              mesg "  Creating diff"
+              Diff.new(from_db, to_db)
+            }
+            !diff.same? or raise Prick::Fail, "No changes"
+          ensure
+            drop_all(from_db)
+            drop_all(to_db)
+          end
+        end
+
+        diff.write(file) if file
+      end
+
+      if file
+        File.open(file, "a") { |f| 
+          f.puts "-- UPDATE VERSION"
+          f.puts File.readlines(SCHEMA_VERSION_PATH).grep_v(/^--/)
+        }
+      else
+        FileUtils.rm_rf migration_dir if force
+        FileUtils.mkdir_p migration_dir
+        Command.command "cp -a #{SHARE_PATH}/migrate/migration/. #{migration_dir}"
+        Dir.chdir(migration_dir) { diff.write(*DIFF_FILES, mark: true) }
+      end 
+    end
+  end
+end
+

data/lib/subcommand/prick-drop.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  def self.drop_users(database)
+    PgConn.new(database) { |conn|
+      users = conn.role.list(database: database)
+      conn.role.drop(users, cascade: true)
+    }
+  end
+
+  def self.drop_database(database)
+    PgConn.new { |conn| conn.rdbms.drop database }
+  end
+
+  def self.drop_all(database)
+    PgConn.new { |conn|
+      users = conn.role.list(database: database)
+      PgConn.new(database) { |db| db.role.drop(users, cascade: true) }
+      conn.rdbms.drop database
+    }
+  end
+end
+

data/lib/subcommand/prick-fox.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  def self.fox(database, username, files)
+    Command.command "fox --state=#{FOX_STATE_PATH} --exec #{database} #{files.join(" ")}"
+  end
+end
+
+__END__
+
+
+    Timer.on! if timer
+    time "Prick::Command#build" do
+      begin
+        super_conn = PgConn.new
+        conn = nil
+        builder = nil
+
+        time "Load build object" do
+          if super_conn.rdbms.exist? database
+            conn = PgConn.new(database, username)
+            super_conn.rdbms.empty!(database)
+          else
+            super_conn.rdbms.create database, owner: username
+            conn = PgConn.new(database, username)
+          end
+
+          builder = Prick::Build::Builder.new(conn, builddir)
+          builder.pool.delete_schema(builder.pool.after_schema(schema)) if schema
+        end
+        
+        case dump
+          when :nodes; builder.nodes.reject { |node| node.is_a?(Build::BuildNode) }.map &:dump
+          when :allnodes; builder.nodes.map &:dump
+          when :batches; builder.dump
+          when nil;
+        else
+          raise Prick::Error, "Illegal dump type: #{dump.inspect}"
+        end && exit
+
+        time "Execute build object" do
+          builder.execute conn
+        end
+
+      rescue Prick::Error => ex
+        $stderr.puts ex.message
+        exit 1
+
+      rescue ::Command::Error => ex
+        $stderr.puts ex.message
+        exit 1
+
+      ensure
+        super_conn&.terminate
+        conn&.terminate
+      end
+    end
+  end
+end
+

data/lib/subcommand/prick-init.rb

@@ -0,0 +1,46 @@
+require 'fileutils'
+
+module Prick::SubCommand
+  def self.init(dir, name, title, database, username)
+    if dir
+      !File.exist?(dir) or raise Prick::Error, "Directory #{dir} exists"
+      FileUtils.mkdir_p(dir)
+      Dir.chdir(dir)
+    else
+      dir = "."
+    end
+    name ||= File.basename(Dir.getwd)
+    title ||= name
+    database ||= name
+    username ||= name
+
+    Command.command %(
+      git init .
+      cp -a #{SHARE_PATH}/init/. .
+      git add .
+      git commit -am "Initial import"
+    ), fail: false
+
+    Command.status == 0 or raise Prick::Fail, "Init script failed"
+
+    state = State.new
+    state.name = name
+    state.title = title
+    state.prick_version = PrickVersion.new VERSION
+    state.version = PrickVersion.new("0.0.0")
+    state.environment = :development
+    state.database = database
+    state.username = username
+    state.save
+
+    Command.command %(
+      set -e
+      git commit -am "Release 0.0.0"
+      git tag v0.0.0
+    ), fail: false
+
+    Command.status == 0 or raise Prick::Fail, "Init script failed"
+
+    [dir, state]
+  end
+end

data/lib/subcommand/prick-make.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  def self.make(database, username, schema, timer: nil, dump: nil)
+    Timer.on! if timer
+    time "Prick::Command#build" do
+      begin
+        super_conn = PgConn.new
+        conn = nil
+        builder = nil
+        built_at = EPOCH
+        clean = false
+        create_schemas = []
+
+        time "Load build object" do
+          if super_conn.rdbms.exist? database
+            conn = PgConn.new(database, username)
+            if conn.schema.exist_table? "prick", "versions"
+              built_at = conn.value("select built_at from prick.versions")
+            end
+          else
+            super_conn.rdbms.create database, owner: username
+            conn = PgConn.new(database, username)
+            clean = true
+          end
+
+          builder = Prick::Build::Builder.new(conn, "schema", clean)
+
+          if schema
+            builder.pool.after_schema(schema).each { |schema|
+              conn.schema.drop(schema, cascade: true)
+              builder.pool.delete_schema(schema)
+            }
+          end
+
+          touched_nodes = builder.nodes.select { |node| File.mtime(node.path) > built_at }
+          touched_phases = touched_nodes.map(&:phase).uniq.compact
+          touched_kinds = touched_nodes.map(&:kind).uniq.compact
+          touched_schema = touched_nodes.first&.schema
+          missing_schema = builder.schemas.find { |schema| !conn.schema.exist?(schema) }
+          build_schema = builder.schemas.find { |schema| [touched_schema, missing_schema].include? schema }
+
+          if build_schema.nil?
+            puts "#{database} is up to date"
+            exit
+          end
+
+          if touched_phases.include?(:decl) || touched_phases.empty?
+            create_schemas = [build_schema] + builder.pool.after_schema(build_schema)
+            create_schemas.each { |schema| conn.schema.drop(schema, cascade: true) }
+            builder.pool.delete_schema(builder.pool.before_schema(build_schema), exclude: [:seed])
+          elsif touched_phases.include?(:init) || touched_phases.include?(:term)
+            builder.pool.clear(:decl, :seed)
+          elsif touched_phases.include?(:seed)
+            builder.pool.clear(:init, :decl, :term)
+          end
+
+          builder.group
+        end
+
+        case dump
+          when :nodes; builder.nodes.reject { |node| node.is_a?(Build::BuildNode) }.map &:dump
+          when :allnodes; builder.nodes.map &:dump
+          when :batches; builder.dump
+          when nil;
+        else
+          raise Prick::Error, "Illegal dump type: #{dump.inspect}"
+        end
+        exit if dump
+
+        time "Execute build object" do
+          builder.execute(conn, create_schemas: create_schemas)
+        end
+
+      rescue Prick::Build::Error => ex
+        $stderr.puts ex.message
+        exit 1
+
+      rescue Command::Error => ex
+        $stderr.puts ex.message
+        exit 1
+
+      end
+    end
+  end
+end
+
+__END__
+require 'prick_build.rb'
+
+require 'pg_conn'
+
+require 'ruby-prof'
+
+DATABASE = "mikras"
+USERNAME = "mikras"
+
+#PROFILE = true
+PROFILE = false
+TIME = true
+#TIME = false
+
+EPOCH = Time.at(0).utc
+
+schema = ARGV.first
+
+time "Program" do
+  RubyProf.start if PROFILE
+  begin
+    conn = nil
+    builder = nil
+    built_at = EPOCH
+    clean = false
+    create_schema = true
+
+    time "Load build object" do
+      PgConn.new { |super_conn|
+        if super_conn.rdbms.exist? DATABASE
+          conn = PgConn.new(DATABASE)
+          if conn.schema.exist_table? "prick", "versions"
+            built_at = conn.value("select built_at from prick.versions")
+          end
+        else
+          super_conn.rdbms.create DATABASE, owner: USERNAME
+          conn = PgConn.new(DATABASE)
+          clean = true
+        end
+      }
+
+      builder = Prick::Build::Builder.new(conn, "schema", clean)
+
+      if schema
+        builder.pool.after_schema(schema).each { |schema|
+          conn.schema.drop(schema, cascade: true)
+          builder.pool.delete_schema(schema)
+        }
+      end
+
+      touched_nodes = builder.nodes.select { |node| File.mtime(node.path) > built_at }
+      touched_phases = touched_nodes.map(&:phase).uniq.compact
+      touched_schema = touched_nodes.first&.schema
+      missing_schema = builder.schemas.find { |schema| !conn.schema.exist?(schema) }
+      build_schema = builder.schemas.find { |schema| [touched_schema, missing_schema].include? schema }
+
+#     puts "touched_nodes : #{touched_nodes.size} nodes"
+#     puts "touched_phases: #{touched_phases.inspect}"
+#     puts "touched_schema: #{touched_schema.inspect}"
+#     puts "missing_schema: #{missing_schema.inspect}"
+#     puts "build_schema  : #{build_schema.inspect}"
+
+#     builder.pool.dump
+
+      if build_schema.nil?
+        puts "#{DATABASE} is up to date"
+        exit
+      end
+
+      if touched_phases.include?(:decl) || touched_phases.empty?
+        schemas = [build_schema] + builder.pool.after_schema(build_schema)
+        schemas.each { |schema| conn.schema.drop(schema, cascade: true) }
+        builder.pool.delete_schema(builder.pool.before_schema(build_schema))
+      elsif touched_phases.include?(:init) || touched_phases.include?(:term)
+        builder.pool.clear(:decl, :seed)
+        create_schema = false
+      elsif touched_phases.include?(:seed)
+        builder.pool.clear(:init, :decl, :term)
+        create_schema = false
+      end
+
+#     builder.pool.dump
+      builder.group
+    end
+
+#   builder.dump
+#   p builder.schemas
+#   exit
+
+    time "Execute build object" do
+      builder.execute(conn, create_schema: create_schema)
+    end
+
+  rescue Prick::Build::Error => ex
+    $stderr.puts ex.message
+    exit 1
+
+  rescue Command::Error => ex
+    $stderr.puts ex.message
+    exit 1
+  end
+end
+
+if PROFILE
+  profile = RubyProf.stop
+# printer = RubyProf::GraphHtmlPrinter.new(profile)
+  printer = RubyProf::CallStackPrinter.new(profile)
+  File.open("t.html", "w") { |file|
+    printer.print(file, :min_percent => 2)
+  }
+end
+

data/lib/subcommand/prick-migrate.rb

@@ -0,0 +1,37 @@
+
+module Prick
+  module SubCommand
+#   def self.migrate(database, username, file) TODO
+    def self.migrate(database, username, file: nil)
+      PgConn.new(database, username) { |conn|
+        conn.schema.exist_relation? "prick", "versions" or 
+            raise Prick::Fail, "Can't read version from database"
+
+        from_version = PrickVersion.new(conn.value "select version from prick.versions") or
+            raise Prick::Fail, "Illegal version in table prick.versions"
+
+        if file
+          conn.transaction {
+            conn.exec File.read(file)
+          }
+        else
+          to_version = Prick.state.version
+          from_version != to_version or raise Prick::Fail, "Already up to date"
+          from_version < to_version or raise Prick::Fail, "Can't migrate backwards"
+
+          migration_dir = "#{MIGRATION_DIR}/#{from_version}" 
+          File.directory? migration_dir or 
+              raise Prick::Fail, "Can't migrate from #{from_version} to #{to_version}"
+
+          puts "Migrating from #{from_version} to #{to_version}"
+
+          builder = Prick::Build::Builder.new(conn, migration_dir)
+          conn.transaction {
+            builder.execute conn
+            conn.exec File.read(SCHEMA_VERSION_PATH)
+          }
+        end
+      }
+    end
+  end
+end

data/lib/subcommand/prick-release.rb

@@ -0,0 +1,23 @@
+
+module Prick
+  module SubCommand
+    def self.release(kind)
+      constrain kind, :major, :minor, :patch
+
+      Git.clean? or raise "Won't release: Repository is dirty"
+      Git.synchronized? or raise "Won't release: Repository is not synchronized with origin"
+
+      version = Prick.state.version.increment!(kind).to_s
+      Prick.state.save
+
+      Git.add(Prick.state.file)
+      Git.add(Prick.state.schema_file)
+      Git.commit "Release #{version}"
+      Git.tag.create "v#{version}"
+      Git.branch.create version
+      Git.push
+
+      puts version
+    end
+  end
+end

data/lib/subcommand/prick-setup.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  def self.setup(database, username)
+    conn = PgConn.new
+    if !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
+      conn.role.create username, superuser: true, can_login: true, create_role: true
+    end
+    if !conn.rdbms.exist? database
+      conn.rdbms.create database, owner: username
+    end
+    builder = Prick::Build::Builder.new(conn, "schema")
+    # TODO Run builder setup scrips
+  end
+end
+

data/lib/subcommand/prick-teardown.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'builder/builder.rb'
+
+module Prick::SubCommand
+  def self.teardown(database, username)
+    conn = PgConn.new # Superuser connection
+    if conn.rdbms.exist? database
+      conn.rdbms.drop database
+    end
+    if conn.role.exist? username
+      conn.role.drop username, cascade: true
+    end
+    builder = Prick::Build::Builder.new(conn, "schema")
+    # TODO Run builder teardown scrips
+  end
+end
+

data/prick.gemspec

@@ -1,10 +1,6 @@
+# frozen_string_literal: true
 
-#$LOAD_PATH.unshift("/home/clr/prj/shellopts/lib")
-
-#lib = File.expand_path("../lib", __FILE__)
-#$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-#require "prick/version"
-require_relative 'lib/prick/version'
+require_relative "lib/prick/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "prick"
@@ -15,39 +11,54 @@ Gem::Specification.new do |spec|
   spec.summary       = "A release control and management system for postgresql"
   spec.description   = "A release control and management system for postgresql"
   spec.homepage      = "http://www.nowhere.com/"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.1")
-
-# spec.metadata["homepage_uri"] = spec.homepage
-# spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
-# spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+# spec.required_ruby_version = "~> 2.7.1"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features|old)/|\.(?:git|travis|circleci)|appveyor)})
+    end
   end
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-# spec.add_dependency "pg"
-  spec.add_dependency "shellopts", "2.0.0.pre.14"
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+
+  # Add your production dependencies here
+  # spec.add_dependency GEM [, VERSION]
   spec.add_dependency "semantic"
-  spec.add_dependency "indented_io"
 
-  # To be able to call fox in development mode (TODO: Remove)
-  spec.add_dependency "boolean"
+  spec.add_dependency "indented_io"
   spec.add_dependency "constrain"
-  spec.add_dependency "developer_exceptions"
+  spec.add_dependency "forward_to"
+  spec.add_dependency "bootsnap"
+
+  # Add your development dependencies here
+  # spec.add_development_dependency GEM [, VERSION]
+  spec.add_development_dependency "ruby-prof"
+
+  # Remove when fox goes a gem
   spec.add_dependency "pg"
   spec.add_dependency "dry-inflector"
+  spec.add_dependency "boolean"
+  spec.add_dependency "developer_exceptions"
+  spec.add_dependency "shellopts", "~> 2.0.23"
 
   # In development mode override load paths for gems whose source are located
   # as siblings of this project directory
   if File.directory?("#{__dir__}/.git")
-    local_projects = Dir["../*"].select { |path| 
+    local_projects = Dir["../*"].select { |path|
       File.directory?(path) && File.exist?("#{path}/Gemfile")
     }.map { |relpath| "#{File.absolute_path(relpath)}/lib" }
     $LOAD_PATH.unshift *local_projects
   end
+
+  # Also un-comment in spec/spec_helper to use simplecov
+  # spec.add_development_dependency "simplecov"
 end