prick 0.2.0 → 0.7.0

data/lib/prick/cache.rb

@@ -0,0 +1,34 @@
+
+module Prick
+  class Cache
+    def initialize
+    end
+
+    def exist?(version)
+      File.exist?(file(version))
+    end
+
+    def list
+      Dir.glob(File.join(CACHE_DIR, "*.sql.gz"))
+    end
+
+    def load(database, version)
+      Rdbms.load(database, file(version))
+    end
+
+    def save(database, version = database.version)
+      Rdbms.save(database, file(version))
+    end
+
+    # Returns list of removed files
+    def clean
+      l = list
+      FileUtils.rm(l)
+      l
+    end
+
+    def file(version)
+      File.join(CACHE_DIR, "#{version}.sql.gz")
+    end
+  end
+end

data/lib/prick/command.rb

@@ -14,14 +14,13 @@ module Command
     end
   end
 
-  # Execute the shell command 'cmd' and return the output as an array of
-  # strings
-  #
-  # If :stderr is true, it returns return a tuple of [stdout, stderr] instead
-  #
-  # The shell command is executed with the `errexit` and `pipefail` bash
-  # options.  It raises a Command::Error exception if the command fails unless
-  # :fail is true. The exit status of the last command is stored in ::status
+  # Execute the shell command 'cmd' and return standard output as an array of
+  # strings while stderr is passed through unless stderr: is false. If stderr:
+  # is true, it returns a tuple of [stdout, stderr] instead. The shell command
+  # is executed with the `errexit` and `pipefail` bash options
+  # 
+  # It raises a Command::Error exception if the command fails unless :fail is
+  # true. The exit status of the last command is stored in ::status
   #
   def command(cmd, stderr: false, fail: true)
     cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
@@ -62,10 +61,19 @@ module Command
     pr[0].close
     pe[0].close
 
+    result = 
+        case stderr
+          when true; [out, err]
+          when false; out
+          when NilClass; $stderr.puts err
+        else
+          raise Internal, "Unexpected value for :stderr - #{stderr.inspect}"
+        end
+
     if @status == 0 || fail == false
-      stderr ? [out, err] : out
-    else
-      raise Command::Error.new((out + err).join("\n") + "\n", status, out, err)
+      result
+    elsif fail
+      raise Command::Error.new("\n" + cmd + "\n" + (out + err).join("\n") + "\n", status, out, err)
     end
   end
 

data/lib/prick/constants.rb

@@ -1,62 +1,96 @@
 
 module Prick
+  ### DIRECTORIES AND FILE NAMES
+
   # Shared files (part of the installation)
   SHARE_PATH = "#{File.dirname(File.dirname(__dir__))}/share"
+  LIBEXEC_PATH = "#{File.dirname(File.dirname(__dir__))}/libexec"
 
   # Project directories
   DIRS = [
-    RELEASE_DIR = "releases",
-    MIGRATION_DIR = "migrations",
-    FEATURE_DIR = "features",
-    SCHEMA_DIR = "schemas",
+    MIGRATION_DIR = "migration",
+    SCHEMA_DIR = "schema",
     PRICK_DIR = "#{SCHEMA_DIR}/prick",
     PUBLIC_DIR = "#{SCHEMA_DIR}/public",
     VAR_DIR = "var",
     CACHE_DIR = "#{VAR_DIR}/cache",
+    SPOOL_DIR = "#{VAR_DIR}/spool",
     TMP_DIR = "tmp",
     CLONE_DIR = "tmp/clone",
     SPEC_DIR = "spec"
   ]
 
+  # The project state file
+  PROJECT_STATE_FILE = ".prick-project"
+  PROJECT_STATE_PATH = PROJECT_STATE_FILE
+
+  # The .prick-version file
+  PRICK_VERSION_FILE = ".prick-version"
+  PRICK_VERSION_PATH = PRICK_VERSION_FILE
+
+  # The prick.versions data file. This is where the Schema saves its version
+  SCHEMA_VERSION_FILE = "data.sql"
+  SCHEMA_VERSION_PATH = File.join(PRICK_DIR, SCHEMA_VERSION_FILE)
+
+  # The the .prick-migration file
+  PRICK_MIGRATION_FILE = ".prick-migration"
+  PRICK_MIGRATION_PATH = File.join(MIGRATION_DIR, PRICK_MIGRATION_FILE)
+
+  # The the .prick-feature file
+  PRICK_FEATURE_FILE = ".prick-feature"
+  PRICK_FEATURE_PATH = File.join(MIGRATION_DIR, PRICK_FEATURE_FILE)
+
+  # The strip-comments executable
+  STRIP_COMMENTS_NAME = "strip-comments"
+  STRIP_COMMENTS_PATH = File.join(LIBEXEC_PATH, "strip-comments")
+
+  # Diff files
+  DIFF_FILE = "diff.sql"
+  BEFORE_TABLES_DIFF_NAME = "diff.before-tables.sql"
+  TABLES_DIFF_NAME = "diff.tables.sql"
+  AFTER_TABLES_DIFF_NAME = "diff.after-tables.sql"
+
+  BEFORE_TABLES_DIFF_PATH = File.join(MIGRATION_DIR, BEFORE_TABLES_DIFF_NAME)
+  TABLES_DIFF_PATH = File.join(MIGRATION_DIR, TABLES_DIFF_NAME)
+  AFTER_TABLES_DIFF_PATH = File.join(MIGRATION_DIR, AFTER_TABLES_DIFF_NAME)
+
+  TABLES_DIFF_SHARE_PATH = File.join(SHARE_PATH, "diff", TABLES_DIFF_NAME)
+
+
   # Dump files
   DUMP_EXT = "dump.gz"
   DUMP_GLOB = "*-[0-9]*.#{DUMP_EXT}"
   def self.dump_glob(project_name) "#{project_name}-*.#{DUMP_EXT}" end
 
+  ### REGULAR EXPRESSIONS
+
+  # Matches a system name. System names are used for objects that are external to prick
+  # (like usernames)
+  NAME_SUB_RE = /[a-z][a-z0-9_-]*/
+  NAME_RE = /^#{NAME_SUB_RE}$/
 
   # Matches an identifier. Identifiers consist of lower case letters, digits
   # and underscores but not dashes because they're used as separators
   IDENT_SUB_RE = /[a-z][a-z0-9_]*/
   IDENT_RE = /^#{IDENT_SUB_RE}$/
 
-  # Matches an uppercase identifier
-# UPCASE_IDENT_SUB_RE = /[A-Z][A-Z0-9_]*/
-# UPCASE_IDENT_RE = /#{UPCASE_IDENT_SUB_RE}/
-
-  # A (system) name. Names are used for projects and usernames that are
-  # external to prick and can include both dashes and underscores but dashes
-  # have to be followed by a character and not a digit so 'ident-1234' is not
-  # allowed but 'ident_1234' and 'ident1234' are
-  NAME_SUB_RE = /#{IDENT_SUB_RE}/
-  NAME_RE = /^#{NAME_SUB_RE}$/
-
   # Matches a project name
-  PROJECT_NAME_SUB_RE = NAME_SUB_RE
-  PROJECT_NAME_RE = NAME_RE
+  PROJECT_NAME_SUB_RE = IDENT_SUB_RE
+  PROJECT_NAME_RE = IDENT_RE
 
   # Matches a custom name
-  CUSTOM_NAME_SUB_RE = NAME_SUB_RE
-  CUSTOM_NAME_RE = NAME_RE
+  CUSTOM_NAME_SUB_RE = IDENT_SUB_RE
+  CUSTOM_NAME_RE = IDENT_RE
 
   # Matches a feature name
-  FEATURE_NAME_SUB_RE = NAME_SUB_RE
-  FEATURE_NAME_RE = NAME_RE
+  FEATURE_NAME_SUB_RE = /(?!initial)#{IDENT_SUB_RE}/
+  FEATURE_NAME_RE = /^#{FEATURE_NAME_SUB_RE}$/
 
   # Matches a postgres user name
   USER_NAME_SUB_RE = NAME_SUB_RE
   USER_NAME_RE = NAME_RE
 
-  # Matches a major.minor.patch version
+  # Matches a major.minor.patch ('MMP') version
   #
   # The *_SEMVER REs are derived from the canonical RE 
   #
@@ -81,15 +115,48 @@ module Prick
   SEMVER_SUB_RE = /#{MMP_SEMVER_SUB_RE}(?:-#{PRE_SEMVER_SUB_RE})?/
   SEMVER_RE = /^#{SEMVER_SUB_RE}$/
 
-  # Version RE. The general syntax for a version is '<custom>-<version>_<feature>'
+  # Tag RE.  The general syntax for a tag is '<custom>-v<version>_<feature>'
   #
   # The RE defines the following captures:
   #   $1 - custom name, can be nil
   #   $2 - semantic version
   #   $3 - feature name, can be nil
   #
+  TAG_SUB_RE = /
+      (?:(#{CUSTOM_NAME_SUB_RE})-)?
+      v
+      (#{SEMVER_SUB_RE})
+      (?:_(#{FEATURE_NAME_SUB_RE}))?
+  /x
+  TAG_RE = /^#{TAG_SUB_RE}$/
+
+  # TODO: Handle initial branches (0.0.0-initial)
+
+  # Branch RE. The general syntax for a branch is '<custom>-<version>_<feature>'
+  #
+  # The RE defines the following captures:
+  #   $1 - custom name, can be nil
+  #   $2 - semantic version
+  #   $3 - feature name, can be nil
+  #
+  BRANCH_SUB_RE = /
+      (?:(#{CUSTOM_NAME_SUB_RE})-)?
+      (#{SEMVER_SUB_RE})
+      (?:_(#{FEATURE_NAME_SUB_RE}))?
+  /x
+  BRANCH_RE = /^#{BRANCH_SUB_RE}$/
+
+  # Tag or branch RE. The general syntax for a branch is '<custom>-v?<version>_<feature>'
+  #
+  # The RE defines the following captures:
+  #   $1 - custom name, can be nil
+  #   $2 - tag, nil or 'v'
+  #   $3 - semantic version
+  #   $4 - feature name, can be nil
+  #
   VERSION_SUB_RE = /
       (?:(#{CUSTOM_NAME_SUB_RE})-)?
+      (v)?
       (#{SEMVER_SUB_RE})
       (?:_(#{FEATURE_NAME_SUB_RE}))?
   /x
@@ -113,24 +180,11 @@ module Prick
   #   $1 - custom name, can be nil
   #   $2 - semantic version
   #
-  RELEASE_SUB_RE = /
-      (?:(#{CUSTOM_NAME_SUB_RE})-)?
-      (#{MMP_SEMVER_SUB_RE})
-  /x
-  RELEASE_RE = /^#{RELEASE_SUB_RE}$/
-
-  # Migration RE. The syntax is <version>_<version>
-  #
-  # The RE defines the following captures
-  #   $1 - from version
-  #   $2 - from custom name, can be nil
-  #   $3 - from semantic version
-  #   $4 - to version
-  #   $5 - to custom name, can be nil
-  #   $6 - to semantic version
-  #
-  MIGRATION_SUB_RE = /(#{RELEASE_SUB_RE})_(#{RELEASE_SUB_RE})/
-  MIGRATION_RE = /^#{MIGRATION_SUB_RE}$/
+# RELEASE_SUB_RE = /
+#     (?:(#{CUSTOM_NAME_SUB_RE})-)?
+#     (#{MMP_SEMVER_SUB_RE})
+# /x
+# RELEASE_RE = /^#{RELEASE_SUB_RE}$/
 
   # Matches a prerelease branch
   #
@@ -138,11 +192,11 @@ module Prick
   #   $1 - custom name, can be nil
   #   $2 - semantic version
   #
-  PRERELEASE_SUB_RE = /
-      (?:(#{CUSTOM_NAME_SUB_RE})-)?
-      (#{MMP_SEMVER_SUB_RE}-#{PRE_SEMVER_SUB_RE})
-  /x
-  PRERELEASE_RE = /^#{PRERELEASE_SUB_RE}$/
+# PRERELEASE_SUB_RE = /
+#     (?:(#{CUSTOM_NAME_SUB_RE})-)?
+#     (#{MMP_SEMVER_SUB_RE}-#{PRE_SEMVER_SUB_RE})
+# /x
+# PRERELEASE_RE = /^#{PRERELEASE_SUB_RE}$/
 
   # Matches a feature branch
   #
@@ -151,8 +205,21 @@ module Prick
   #   $2 - semantic version
   #   $3 - feature name
   #
-  FEATURE_SUB_RE = /#{ABSTRACT_RELEASE_SUB_RE}_(#{FEATURE_NAME_SUB_RE})/
-  FEATURE_RE = /^#{FEATURE_SUB_RE}$/
+# FEATURE_SUB_RE = /#{ABSTRACT_RELEASE_SUB_RE}_(#{FEATURE_NAME_SUB_RE})/
+# FEATURE_RE = /^#{FEATURE_SUB_RE}$/
+
+  # Migration RE. The syntax is <version>_<version>
+  #
+  # The RE defines the following captures
+  #   $1 - from version
+  #   $2 - from custom name, can be nil
+  #   $3 - from semantic version
+  #   $4 - to version
+  #   $5 - to custom name, can be nil
+  #   $6 - to semantic version
+  #
+# MIGRATION_SUB_RE = /(#{RELEASE_SUB_RE})_(#{RELEASE_SUB_RE})/
+# MIGRATION_RE = /^#{MIGRATION_SUB_RE}$/
 
   # Project release RE. The general syntax is '<project>-<custom>-<version>'
   #
@@ -195,5 +262,12 @@ module Prick
   ALL_DATABASES_RE = /^#{ALL_DATABASES_SUB_RE}$/
   def self.all_databases_sub_re(project_name) /(#{project_name})(?:-(#{ABSTRACT_RELEASE_SUB_RE}))?/ end
   def self.all_databases_re(project_name) /^#{all_databases_sub_re(project_name)}$/ end
+
+  # Matches temporary databases. Mostly useful when debugging because temporary databases
+  # should be deleted on exit
+  TMP_DATABASES_SUB_RE = /#{PROJECT_NAME_SUB_RE}-(?:base|next)/
+  TMP_DATABASES_RE = /^#{TMP_DATABASES_SUB_RE}$/
+  def self.tmp_databases_sub_re(project_name) /#{project_name}-(?:base|next)/ end
+  def self.tmp_databases_re(project_name) /^#{tmp_databases_sub_re(project_name)}$/ end
 end
 

data/lib/prick/database.rb

@@ -1,26 +1,29 @@
 
-require "prick/ensure.rb"
-
 module Prick
   class Database
     attr_reader :name
     attr_reader :user
 
     def initialize(name, user)
+      name != "" or raise "Illegal database name" 
       @name = name
       @user = user
       @version = nil
     end
 
-    def version
-      @version ||= begin
-          version = 
-              if exist? && Rdbms.exist_table?(name, "prick", "versions")
-                Rdbms.select(name, "select version from prick.versions")&.first&.first
-              else
-                nil
-              end
-          version && Version.new(version)
+    def version(cache: true)
+      if cache && @version
+        @version
+      else
+        @version = begin
+            version = 
+                if exist? && Rdbms.exist_table?(name, "prick", "versions")
+                  Rdbms.select(name, "select version from prick.versions")&.first&.first
+                else
+                  nil
+                end
+            version && Version.new(version)
+        end
       end
     end
 
@@ -42,17 +45,22 @@ module Prick
     def recreate() drop if exist?; create; @version = nil end
     def drop() Rdbms.drop_database(name, fail: false); @version = nil end
 
-    def loaded?() exist? && !version.nil? end
-    def load(file) Rdbms.load(name, file, user: user); @version = nil end
+    def loaded?() !version.nil? end
+
+    def load(file) 
+      !loaded? or raise Internal, "Database #{name} is already loaded"
+      Rdbms.load(name, file, user: user)
+      version # Provoke load of version
+    end
 
-    def save(file) Rdbms.save(name, file); @version = nil end
+    def save(file) 
+      loaded? or raise Internal, "Database #{name} is not loaded"
+      Rdbms.save(name, file)
+      @version = nil 
+    end
 
-    include Ensure
+    def clean() recreate end # TODO: Find solution that doesn't involve dropping the database
 
-  private
-    @states = {
-      exist: [:create, :drop],
-      loaded: [:exist, :load, :recreate]
-    }
+    def to_s() name end
   end
 end

data/lib/prick/diff.rb

@@ -0,0 +1,125 @@
+module Prick
+  class Diff
+    # Diff as a list of lines
+    attr_reader :diff
+
+    # Subject of the diff
+    attr_reader :before_table_changes
+    attr_reader :table_changes
+    attr_reader :after_table_changes
+
+    def initialize(db1, db2)
+      @db1, @db2 = db1, db2
+      do_diff
+      split_on_table_changes
+    end
+
+    def self.same?(db1, db2) Diff.new(db1, db2).same? end
+
+    # Return true if the two databases are equal. Named #same? to avoid name
+    # collision with the built in #equal?
+    def same?() diff.empty? end
+
+    # Write the diff between the databases to the given file(s). Return true if
+    # the databases are equal
+    def write_segments(file1, file2 = nil, file3 = nil, mark: true)
+      if file2.nil? && file3.nil?
+        file2 = file3 = file1
+      elsif file2.nil? ^ !file3.nil?
+        raise Internal, "Either none or both of `file2` and `file3` should be nil"
+      end
+      write_segment(file1, :before_table_changes, mark: mark)
+      write_segment(file2, :table_changes, mark: mark)
+      write_segment(file3, :after_table_changes, mark: mark)
+    end
+
+    def write_segment(file, segment, mark: true)
+      lines = self.send(segment)
+      if lines.empty?
+        FileUtils.rm_f(file) if file != "/dev/stdout"
+      else
+        File.open(file, "w") { |f|
+          f.puts "--" + segment.to_s.gsub("_", " ").upcase if mark
+          f.puts lines
+        }
+      end
+    end
+
+  private
+    def do_diff(file = nil)
+      command = "migra --unsafe --with-privileges postgres:///#{@db1} postgres:///#{@db2}"
+      @diff = Command.command(command, fail: false)
+      [0,2].include?(Command.status) or
+        raise Internal, "migrate command failed with status #{Command.status}: #{command}"
+    end
+
+    # Initialize table change variables
+    def split_on_table_changes
+      @before_table_changes = []
+      @table_changes = []
+      @after_table_changes = []
+
+      before = true
+      tables = false
+      after = false
+
+      in_table = false
+
+      diff.each { |l|
+        if before
+          if l =~ /^alter table/
+            @table_changes << l
+            before = false
+            tables = true
+          elsif l =~ /^create table/
+            @table_changes << l
+            before = false
+            tables = true
+            in_table = true
+          elsif l =~ /^drop table/
+            @table_changes << l
+            before = false
+            tables = true
+          else
+            @before_table_changes << l
+          end
+        elsif tables
+          if in_table
+            if l =~ /^\)/
+              @table_changes << l
+              in_table = false
+            else
+              @table_changes << l
+            end
+          elsif l =~ /^alter table/
+            @table_changes << l
+          elsif l =~ /^create table/
+            @table_changes << l
+            in_table = true
+          elsif l =~ /^drop table/
+            @table_changes << l
+          elsif l =~ /^\s*$/
+            @table_changes << l
+          else
+            @after_table_changes << l
+            tables = false
+            after = true
+          end
+        else
+          @after_table_changes << l
+        end
+      }
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+