prick 0.2.0

data/lib/prick/command.rb

@@ -0,0 +1,85 @@
+require 'fcntl'
+
+module Command
+  class Error < RuntimeError
+    attr_reader :status
+    attr_reader :stdout
+    attr_reader :stderr
+
+    def initialize(message, status, stdout, stderr)
+      super(message)
+      @status = status
+      @stdout = stdout
+      @stderr = stderr
+    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
+  #
+  def command(cmd, stderr: false, fail: true)
+    cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
+
+    pw = IO::pipe   # pipe[0] for read, pipe[1] for write
+    pr = IO::pipe
+    pe = IO::pipe
+
+    STDOUT.flush
+
+    pid = fork {
+      pw[1].close
+      pr[0].close
+      pe[0].close
+
+      STDIN.reopen(pw[0])
+      pw[0].close
+
+      STDOUT.reopen(pr[1])
+      pr[1].close
+
+      STDERR.reopen(pe[1])
+      pe[1].close
+
+      exec(cmd)
+    }
+
+    pw[0].close
+    pr[1].close
+    pe[1].close
+
+    @status = Process.waitpid2(pid)[1].exitstatus
+
+    out = pr[0].readlines.collect { |line| line.chop }
+    err = pe[0].readlines.collect { |line| line.chop }
+
+    pw[1].close
+    pr[0].close
+    pe[0].close
+
+    if @status == 0 || fail == false
+      stderr ? [out, err] : out
+    else
+      raise Command::Error.new((out + err).join("\n") + "\n", status, out, err)
+    end
+  end
+
+  # Exit status of the last command
+  def status() @status end
+
+  # Like command but returns true if the command exited with the expected status
+  def command?(cmd, expect: 0)
+    command(cmd, fail: false)
+    @status == expect
+  end
+
+  module_function :command
+  module_function :status
+  module_function :command?
+end
+

data/lib/prick/constants.rb

@@ -0,0 +1,199 @@
+
+module Prick
+  # Shared files (part of the installation)
+  SHARE_PATH = "#{File.dirname(File.dirname(__dir__))}/share"
+
+  # Project directories
+  DIRS = [
+    RELEASE_DIR = "releases",
+    MIGRATION_DIR = "migrations",
+    FEATURE_DIR = "features",
+    SCHEMA_DIR = "schemas",
+    PRICK_DIR = "#{SCHEMA_DIR}/prick",
+    PUBLIC_DIR = "#{SCHEMA_DIR}/public",
+    VAR_DIR = "var",
+    CACHE_DIR = "#{VAR_DIR}/cache",
+    TMP_DIR = "tmp",
+    CLONE_DIR = "tmp/clone",
+    SPEC_DIR = "spec"
+  ]
+
+  # Dump files
+  DUMP_EXT = "dump.gz"
+  DUMP_GLOB = "*-[0-9]*.#{DUMP_EXT}"
+  def self.dump_glob(project_name) "#{project_name}-*.#{DUMP_EXT}" end
+
+
+  # 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
+
+  # Matches a custom name
+  CUSTOM_NAME_SUB_RE = NAME_SUB_RE
+  CUSTOM_NAME_RE = NAME_RE
+
+  # Matches a feature name
+  FEATURE_NAME_SUB_RE = NAME_SUB_RE
+  FEATURE_NAME_RE = NAME_RE
+
+  # Matches a postgres user name
+  USER_NAME_SUB_RE = NAME_SUB_RE
+  USER_NAME_RE = NAME_RE
+
+  # Matches a major.minor.patch version
+  #
+  # The *_SEMVER REs are derived from the canonical RE 
+  #
+  # /
+  #   (0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)
+  #   (?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?
+  #   (?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?
+  # /x
+  #
+  # https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string.
+  #
+  MMP_SEMVER_SUB_RE = /(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)/
+  MMP_SEMVER_RE = /^#{MMP_SEMVER_SUB_RE}$/
+
+  # Matches the prelease part of a semantic version
+  #
+  PRE_SEMVER_SUB_RE = /pre\.\d+/
+  PRE_SEMVER_RE = /^#{PRE_SEMVER_SUB_RE}$/
+
+  # Matches a semantic version
+  #
+  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>'
+  #
+  # The RE defines the following captures:
+  #   $1 - custom name, can be nil
+  #   $2 - semantic version
+  #   $3 - feature name, can be nil
+  #
+  VERSION_SUB_RE = /
+      (?:(#{CUSTOM_NAME_SUB_RE})-)?
+      (#{SEMVER_SUB_RE})
+      (?:_(#{FEATURE_NAME_SUB_RE}))?
+  /x
+  VERSION_RE = /^#{VERSION_SUB_RE}$/
+
+  # Matches an abstract release (either a release or a prerelease)
+  #
+  # The RE defines the following captures:
+  #   $1 - custom name, can be nil
+  #   $2 - semantic version
+  #
+  ABSTRACT_RELEASE_SUB_RE = /
+      (?:(#{CUSTOM_NAME_SUB_RE})-)?
+      (#{SEMVER_SUB_RE})
+  /x
+  ABSTRACT_RELEASE_RE = /^#{ABSTRACT_RELEASE_SUB_RE}$/
+
+  # Matches a (proper) release
+  #
+  # The RE defines the following captures:
+  #   $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}$/
+
+  # Matches a prerelease branch
+  #
+  # The RE defines the following captures:
+  #   $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}$/
+
+  # Matches a feature branch
+  #
+  # The RE defines the following captures:
+  #   $1 - custom name, can be nil
+  #   $2 - semantic version
+  #   $3 - feature name
+  #
+  FEATURE_SUB_RE = /#{ABSTRACT_RELEASE_SUB_RE}_(#{FEATURE_NAME_SUB_RE})/
+  FEATURE_RE = /^#{FEATURE_SUB_RE}$/
+
+  # Project release RE. The general syntax is '<project>-<custom>-<version>'
+  #
+  # The RE defines the following captures:
+  #   $1 - project
+  #   $2 - version
+  #   $3 - custom name, can be nil
+  #   $4 - semantic version
+  #
+  PROJECT_SUB_RE = /(#{PROJECT_NAME_SUB_RE})-(#{ABSTRACT_RELEASE_SUB_RE})/
+  PROJECT_RE = /^#{PROJECT_SUB_RE}$/
+  def self.project_sub_re(project_name)
+    /(#{Regexp.escape(project_name)})(-#{VERSION_SUB_RE})/
+  end
+  def self.release_re(project_name) /^#{project_sub_re(project_name)}$/ end
+
+  # Matches versioned databases. Note that databases never include the feature name.
+  # Features use the project database instead of a feature-specific database
+  #
+  # The RE defines the following captures
+  #   $1 - project
+  #   $2 - version
+  #   $3 - custom name, can be nil
+  #   $4 - semantic version
+  #
+  DATABASE_SUB_RE = PROJECT_SUB_RE
+  DATABASE_RE = /^#{DATABASE_SUB_RE}$/
+  def self.database_sub_re(project_name) project_sub_re(project_name) end
+  def self.database_re(project_name) /^#{database_sub_re(project_name)}$/ end
+
+  # Matches project database and versioned databases
+  #
+  # The RE defines the following captures
+  #   $1 - project
+  #   $2 - version, can be nil
+  #   $3 - custom name, can be nil
+  #   $4 - semantic version, can be nil
+  #
+  ALL_DATABASES_SUB_RE = /(#{PROJECT_NAME_SUB_RE})(?:-(#{ABSTRACT_RELEASE_SUB_RE}))?/
+  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
+end
+

data/lib/prick/database.rb

@@ -0,0 +1,58 @@
+
+require "prick/ensure.rb"
+
+module Prick
+  class Database
+    attr_reader :name
+    attr_reader :user
+
+    def initialize(name, user)
+      @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)
+      end
+    end
+
+    def version=(version)
+      @version = version && Version.new(version)
+      Rdbms.exec_sql(name, %(
+        update prick.versions
+        set major = '#{@version.major}',
+            minor = '#{@version.minor}',
+            patch = '#{@version.patch}',
+            pre = '#{@version.pre}',
+            version = '#{@version.to_s}'
+      )) if @version
+      @version
+    end
+
+    def exist?() Rdbms.exist_database?(name) end
+    def create() Rdbms.create_database(name, owner: user) end
+    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 save(file) Rdbms.save(name, file); @version = nil end
+
+    include Ensure
+
+  private
+    @states = {
+      exist: [:create, :drop],
+      loaded: [:exist, :load, :recreate]
+    }
+  end
+end

data/lib/prick/dsort.rb

@@ -0,0 +1,151 @@
+require 'tsort'
+
+module DSort
+  # Thrown if a cyclic dependency is detected
+  #
+  # DSort::Cyclic is inherited from TSort::Cyclic so that recue handling code
+  # written for TSort will still work. It provides a #cycles member that lists
+  # the cycles
+  class Cyclic < TSort::Cyclic
+    # List of detected cycles sorted from shortest to longest cycle
+    attr_reader :cycles
+
+    def initialize(dsort_object)
+      @cycles = 
+          dsort_object.each_strongly_connected_component \
+            .select { |e| e.size > 1 } \
+            .sort { |l,r| r <=> l }
+      gram = cycles.size > 1 ? "ies" : "y"
+      super("Cyclic depedendenc#{gram} detected")
+    end
+  end
+
+  # dsort sorts its input in "dependency" order: The input can be thought of
+  # depends-on relations between objects and the output as sorted in the order
+  # needed to safisfy those dependencies so that no object comes before an
+  # object it depends on
+  #
+  # dsort can take an array or a hash argument, or be supplied with a block
+  #
+  # The Array argument should consist of pairs (two-element Arrays) with the
+  # first element being the depending object and the second an object or an
+  # array of objects it depends on: For example [:a, :b] means that :a depends
+  # on :b, and [:b, [:c, :d]] that :b depends on both :c and :d
+  #
+  # The Hash argument should be a hash from depending object to an object or
+  # array of objects it depends on. If h is a Hash then dsort(h) is equivalent
+  # to dsort(h.to_a)
+  #
+  # Note that if the elements are arrays themselves, then you should use the
+  # array form to list the dependencies even if there is only one dependency.
+  # Ie. use [:a, [:b]] or {:a => [:b] } instead of [:a, :b] or {:a => :b}
+  #
+  # If dsort is given a block, the block is given an element as argument and
+  # should return an (possibly empty) array of the objects the argument depends
+  # on. The argument to dsort should be an element or an array of elements to
+  # be given to the block. Note that if the elements are arrays themselves,
+  # then the arguments to dsort should use the array form even if there is only
+  # one element. Ie.  Use dsort([:a]) instead of dsort(:a)
+  #
+  # dsort raise a DSort::Cyclic exception if a cycle detected 
+  #
+  # Example: If we have that dsort depends on ruby and rspec, ruby depends
+  # on C to compile, and rspec depends on ruby, then in what order should we
+  # build them ? Using dsort we could do
+  #
+  #   p dsort [[:dsort, [:ruby, :rspec]]], [:ruby, :C], [:rspec, :ruby]]
+  #       => [:C, :ruby, :rspec, :dsort]
+  #
+  # Using a hash
+  #
+  #   h = {
+  #     :dsort => [:ruby, :rspec],
+  #     :ruby => [:C],
+  #     :rspec => [:ruby]
+  #   }
+  #   p dsort(h) # Same as dsort(h.to_a)
+  #       => [:C, :ruby, :rspec, :dsort]
+  #
+  # or using a block
+  #
+  #   p dsort(:dsort) { |e| h[e] }
+  #       => [:C, :ruby, :rspec, :dsort]
+  #
+  def dsort(a, &block) 
+    sort_object = DSortPrivate::DSortObject.new(a, &block)
+    begin
+      sort_object.tsort 
+    rescue TSort::Cyclic
+      raise Cyclic.new(sort_object)
+    end
+  end
+
+  # tsort sort its input in topological order: The input can be thought of as
+  # comes-before relations between objects and the output will be in
+  # first-to-last order. This definition corresponds to the mathemacial
+  # defitionnn of topological sort. See
+  # http://en.wikipedia.org/wiki/Topological_sorting
+  #
+  # Arguments are the same as for dsort. tsort is equivalent to
+  # dsort(...).reverse
+  #
+  # tsort raise a DSort::Cyclic exception if a cycle is detected (DSort::Cyclic
+  # is an alias for TSort::Cyclic)
+  #
+  def tsort(a, &block) dsort(a, &block).reverse end
+
+  module_function :dsort, :tsort
+
+  module DSortPrivate
+    class DSortObject
+      include TSort
+
+      # Hash from element to array of dependencies
+      attr_reader :deps
+
+      # Create @deps hash from object to list of dependencies
+      def initialize(a, &block)
+        @deps = {}
+        if block_given?
+          a = [a] if !a.is_a?(Array)
+          a.each { |elem| find_dependencies(elem, &block) }
+        else
+          a.each { |obj, deps| 
+            (@deps[obj] ||= []).concat(deps.is_a?(Array) ? deps : [deps])
+          }
+        end
+
+        # Make sure all dependent objects are also represented as depending
+        # objects: If we're given [:a, :b] we want the @deps hash to include
+        # both :a and :b as keys
+        @deps.values.each { |deps|
+          (deps.is_a?(Array) ? deps : [deps]).each { |d|
+            @deps[d] = [] if !@deps.key?(d)
+          }
+        }
+      end
+
+      # TSort virtual methods
+      def tsort_each_node(&block) @deps.each_key(&block) end
+      def tsort_each_child(node, &block) @deps[node].each(&block) end
+
+    private
+      def find_dependencies(a, &block)
+        block.call(a).each { |d|
+          (@deps[a] ||= []) << d
+          find_dependencies(d, &block)
+        }
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+