prick 0.18.0 → 0.20.2

data/lib/local/command.rb

@@ -0,0 +1,193 @@
+require 'fcntl'
+
+require 'forward_to'
+
+include ForwardTo
+
+module Command
+  class Error < RuntimeError
+    attr_reader :cmd
+    attr_reader :status
+    attr_reader :stdin
+    attr_reader :stdout
+    attr_reader :stderr
+
+    def initialize(cmd, status, stdin, stdout, stderr)
+      super(stderr.join("\n"))
+      @cmd = cmd
+      @status = status
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+    end
+  end
+
+  class Pipe
+    attr_reader :cmd
+    attr_reader :status
+
+    def writer() @pw[1] end
+    def reader() @pr[0] end
+    def error() @pe[0] end
+
+    forward_to :reader, :read, :gets
+    forward_to :writer, :write, :puts
+
+    # Remaining output not consumed by #get/#read or through #reader or #error
+    attr_reader :stdout
+    attr_reader :stdin
+
+    def initialize(cmd, stderr: nil, fail: true)
+      @cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
+      @stderr = stderr
+      @fail = fail
+
+      @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
+    end
+
+    def wait
+      @pw[1].close
+      @status = Process.waitpid2(@pid)[1].exitstatus
+
+      out = @pr[0].readlines.map(&:chomp)
+      err = @pe[0].readlines.map(&:chomp)
+
+      @pr[0].close
+      @pe[0].close
+
+      raise Command::Error.new(@cmd, @status, nil, out, err) if @status != 0 && @fail == true
+
+      case @stderr
+        when true; [out, err]
+        when false; out
+        when nil
+          $stderr.puts err
+          out
+      end
+    end
+  end
+
+  # Execute the shell command 'cmd' and return standard-output as an array of
+  # strings. If :stdin is a string or an array of lines if will be fed to the
+  # 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
+  #
+  # #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
+  # fetched from Command::status
+  #
+  def command(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
+    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
+
+    if stdin
+      case stdin
+        when IO; pw[1].write(stdin.read)
+        when String; pw[1].write(stdin)
+        when Array; pw[1].write(stdin.join("\n") + "\n")
+      end
+      pw[1].flush
+      pw[1].close
+    end
+
+    @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
+
+    if @status != 0
+      @exception = Command::Error.new(cmd, @status, stdin, out, err)
+      raise @exception if fail
+    else
+      @exception = nil
+    end
+
+    case stderr
+      when true; [out, err]
+      when false; out
+      when nil
+        $stderr.puts err
+        out
+    end
+  end
+
+  # Exit status of the last command
+  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
+  #
+  def command?(cmd, expect: 0, stdin: nil, stderr: false)
+    command(cmd, stdin: stdin, stderr: stderr, fail: false)
+    @status == expect
+  end
+
+  module_function :command
+  module_function :status
+  module_function :exception
+  module_function :command?
+end
+

data/lib/{prick → local}/git.rb

@@ -1,35 +1,161 @@
 
-require "prick/command.rb"
-
 module Prick
-  # Tags have a 'v' prefixed the version in the git repository but this is made
-  # transparent to the application
   module Git
-    def self.init
-      Command.command "git init"
+    # Return the origin of the repository
+    def self.origin() 
+      Command.command("git remote get-url origin").first
+    end
+
+    # Clone a repository
+    def self.clone(url, directory = nil, branch: nil)
+      branch_arg = branch ? "--branch #{branch}" : ""
+      Command.command("git clone --quiet #{branch_arg} '#{url}' #{directory}")
+    end
+
+    # Return the current commit id
+    def self.id() Command.command("git rev-parse HEAD").first end
+
+    # Return true if the repository has no modified files or unresolved
+    # conflicts. Requires the repository to have at least one commit
+    def self.clean?(file = nil)
+      re = file ? /^  #{file}(?: .*)?$/ : /^\?\?|!!/
+      !Command.command("git status --porcelain").any? { |l| l !~ re }
+    end
+
+    # Return true if the repo is synchronized with the remote
+    def self.synchronized?()
+      out = Command.command "git rev-list --count --left-right 'HEAD...@{upstream}'"
+      !(out.first =~ /^0\s+0$/).nil?
     end
 
-    # Returns true if the repository has no modified files or unresolved
-    # conflicts. Requires the repository to have at least one commit. Creating
-    # the repository using Project::initialize_directory guarantees that
-    def self.clean?()
-      Command.command("git status").find { |l| 
-        (l =~ /^Changes to be committed:/) || 
-        (l =~ /^Unmerged paths:/) ||
-        (l =~ /^Changes not staged for commit:/)
-      }.nil?
+    # Add files to the index
+    def self.add(*files)
+      files = Array(files).flatten
+      Command.command "git add #{files.join(" ")}"
+    end
+
+    # True if the file was added to the index
+    def self.added?(file = nil)
+      re = file ? /^[ACDMR]. #{file}$/ : /^[ACDMR]/
+      Command.command("git status --porcelain").any? { |l| l =~ re }
+    end
+
+    # Commit changes on the current branch"
+    def self.commit(msg)
+      out = Command.command "git commit -m '#{msg}'", fail: false
+      Command.status == 0 or raise Command.exception.exception(out.join("\n"))
     end
 
-    # Returns true if the repository is on a detached branch
-    def self.detached?
-      Command.command? "git symbolic-ref -q HEAD", expect: 1
+    # Pull changes from repository
+    def self.pull
+      Command.command "git pull"
     end
 
-    # The current tag. This is only defined if the repository is in "detached
-    # head" mode
-    def self.current_tag() 
-      self.detached? ? Command.command("git describe --tags").first.sub(/^v/, "") : nil
+    # Push change to repository
+    def self.push 
+      Command.command "git push --quiet --atomic"
     end
+
+    # Access to tag methods
+    def self.tag() Tag end
+
+    # Access to branch methods
+    def self.branch() Branch end
+
+
+    module Tag
+      # The associated commit ID of a tag
+      def self.id(tag) 
+        tag && Command.command("git rev-list -n 1 #{tag}").first 
+      end
+
+      # True if tag exists
+      def self.exist?(tag) 
+        tag && Command.command?("git describe --tags #{tag}") 
+      end
+
+      # Create tag
+      def self.create(tag, id: nil) 
+        Command.command "git tag '#{tag}' #{id}" 
+      end
+
+      # Drop a tag
+      def self.drop(tag) 
+        Command.command "git tag -d '#{tag}'" 
+      end
+
+      # Return list of all tags. Not in any particular order
+      def self.list() 
+        Command.command("git tag") 
+      end
+
+      # Return the most recent tag before the given commit (defaults to the
+      # last commit)
+      def self.current(id = nil) 
+        describe_tag(id)&.first 
+      end
+
+    private
+      # Return a [tag, number-of-commits, commit-id] tuple of the most recent
+      # tag. Return nil if no tag was found
+      def self.describe_tag(id = nil)
+        stdout, stderr = Command.command("git describe --tags #{id}", stderr: true, fail: false)
+        if Command.status != 0
+          return nil if stderr.first =~ /No names found/
+          raise Command.exception
+        end
+        if stdout.first =~ /^(.*)-(\d+)-.([0-9a-f]{7})$/
+          [$1, $2, $3]
+        else
+          [stdout.first, 0, nil]
+        end
+      end
+    end
+
+    module Branch
+      def self.exist?(branch) 
+        Command.command? "git show-ref --verify --quiet refs/heads/#{branch}"
+      end
+
+      def self.create(branch, id = nil, set_upstream: true) 
+        if set_upstream
+          current = Git.branch.current
+          Command.command %(
+            git checkout --quiet -b #{branch} #{id}
+            git push --quiet --set-upstream origin #{branch}
+            git checkout --quiet #{current}
+          )
+        else
+          Command.command "git branch #{branch} #{id}"
+        end
+      end
+
+      def self.drop(branch) 
+        Command.command "git branch -D #{branch}"
+      end
+
+      def self.list()
+        Command.command "git for-each-ref --format='%(refname:short)' refs/heads/*"
+      end
+
+      def self.current() 
+        Command.command("git branch --show-current").first
+      end
+
+      def self.checkout(branch) 
+        Command.command "git checkout --quiet #{branch}"
+      end
+    end
+  end
+end
+
+__END__
+
+    def self.changed?(file)
+      Command.command("git status --porcelain").any? { |l| l =~ /^.M #{file}$/ }
+    end
+
+
     
     # Return true if `version` has an associated tag
     def self.tag?(version)

data/lib/local/timer.rb

@@ -0,0 +1,98 @@
+
+# TODO: Move class method implementations to Timer::Timer
+module Timer
+  def self.on!() @on = true end
+  def self.off!() @on = false end
+  def self.on?() @on end
+  def self.off?() !@on end
+
+  # Output file used by #emit. Default is STDERR (this is set at load-time)
+  def self.file() @file end
+  def self.file=(file) @file = file end
+
+  # Currently only :s, or :ms. Default is :ms
+  def self.unit() @unit end
+  def self.unit=(unit) @unit = unit end
+
+  # Number of digits after the decimal point. Default 0
+  def self.scale() @scale end
+  def self.scale=(scale) @scale = scale end
+
+  def self.time(label, &block)
+    if on?
+      timer = Timer.new(label)
+      r = yield
+      timer.emit
+      r
+    else
+      yield
+    end
+  end
+
+  def time(label, &block) ::Timer.time(label, &block) end
+
+  def self.new(*args)
+    object = Timer.allocate
+    object.send(:initialize, *args)
+    object
+  end
+
+  class Timer
+    attr_reader :title
+
+    def file() ::Timer.file end
+
+    def self.on!() ::Timer.on! end
+    def self.on?() ::Time.on? end
+
+    def unit() ::Timer.unit end
+    def unit=(unit) ::Timer.unit = unit end
+
+    def scale() ::Timer.scale end
+    def scale=(scale) ::Timer.scale scale end
+
+    def initialize(title = nil)
+      @title = title
+      start
+    end
+
+    def start(title = self.title) @t0 = Time.now; @title = title end
+    def stop() @t1 ||= Time.now end
+    def time() @t1 - @t0 end
+
+    def to_s(title = self.title) "#{title}: #{Timer.format(time)}" end
+
+    def emit(title = self.title) 
+      stop
+      ::Timer.file.puts to_s(title) if ::Timer.on?
+    end
+
+    def self.factor() { s: 1, ms: 1000 }[::Timer.unit] end
+
+    def self.format(time) 
+      time ? sprintf("%.#{::Timer.scale}f#{::Timer.unit}", Timer.factor * time) : time.inspect 
+    end
+  end
+
+private
+  @on = false
+  @file = STDERR
+  @unit = :ms
+  @scale = 0
+end
+
+
+
+
+
+
+
+#def time(title, &block)
+# t0 = Time.now
+# result = yield
+# t1 = Time.now
+# dt = (1000 * (t1 - t0)).round(0)
+# puts "#{title}: #{dt}ms" if defined?(TIME) ? TIME : true
+# result
+#end
+

data/lib/prick/constants.rb

@@ -1,10 +1,14 @@
 
 module Prick
+  ### TIME
+
+  EPOCH = Time.at(0).utc
+
   ### 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"
+  SHARE_PATH = "#{File.dirname(File.dirname(__dir__))}/lib/share"
+  LIBEXEC_PATH = "#{File.dirname(File.dirname(__dir__))}/lib/libexec"
 
   # Project directories
   DIRS = [
@@ -16,22 +20,52 @@ module Prick
     CACHE_DIR = "#{VAR_DIR}/cache",
     SPOOL_DIR = "#{VAR_DIR}/spool",
     TMP_DIR = "tmp",
-    CLONE_DIR = "tmp/clone",
+    CLONE_DIR = "tmp/clones",
     SPEC_DIR = "spec"
   ]
 
-  # The project state file
-  PROJECT_STATE_FILE = ".prick-project"
-  PROJECT_STATE_PATH = PROJECT_STATE_FILE
+  # Project specification file
+  PRICK_PROJECT_FILE = "prick.yml"
+  PRICK_PROJECT_PATH = PRICK_PROJECT_FILE
+
+  # Context file
+  PRICK_CONTEXT_FILE = ".prick-context"
+  PRICK_CONTEXT_PATH = PRICK_CONTEXT_FILE
 
-  # The .prick-version file
-  PRICK_VERSION_FILE = ".prick-version"
-  PRICK_VERSION_PATH = PRICK_VERSION_FILE
+  # Fox state file (contains anchors and table sizes)
+  FOX_STATE_FILE = ".fox-state.yml"
+  FOX_STATE_PATH = FOX_STATE_FILE
 
-  # The prick.versions data file. This is where the Schema saves its version
+  # Reflections file
+  REFLECTIONS_FILE = "reflections.yml"
+  REFLECTIONS_PATH = File.join(SCHEMA_DIR, REFLECTIONS_FILE)
+
+  # Schema data file
   SCHEMA_VERSION_FILE = "data.sql"
   SCHEMA_VERSION_PATH = File.join(PRICK_DIR, SCHEMA_VERSION_FILE)
 
+  # Rspec temporary directory
+  SPEC_TMP_DIR = "spec"
+  SPEC_TMP_PATH = File.join(TMP_DIR, SPEC_TMP_DIR)
+
+
+  # Migration diff files
+  DIFF_FILE = "diff.sql"
+  DIFF_FILES = [
+    BEFORE_TABLES_DIFF_FILE = "diff.before-tables.sql",
+    TABLES_DIFF_FILE = "diff.tables.sql",
+    AFTER_TABLES_DIFF_FILE = "diff.after-tables.sql"
+  ]
+
+
+
+
+  # Not in use:
+
+  # The project state file
+  PROJECT_STATE_FILE = ".prick-project"
+  PROJECT_STATE_PATH = PROJECT_STATE_FILE
+
   # The the .prick-migration file
   PRICK_MIGRATION_FILE = ".prick-migration"
   PRICK_MIGRATION_PATH = File.join(MIGRATION_DIR, PRICK_MIGRATION_FILE)
@@ -45,16 +79,16 @@ module Prick
   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"
+# 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)
+# 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
@@ -174,53 +208,6 @@ module Prick
   /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}$/
-
-  # 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}$/
-
-  # 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>'
   #
   # The RE defines the following captures:
@@ -271,3 +258,4 @@ module Prick
   def self.tmp_databases_re(project_name) /^#{tmp_databases_sub_re(project_name)}$/ end
 end
 
+