prick 0.19.0 → 0.20.1

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
 
+

data/lib/prick/diff.rb

@@ -1,14 +1,17 @@
 module Prick
+  # Database diff 
   class Diff
     # Diff as a list of lines
     attr_reader :diff
 
-    # Subject of the diff
+    # Diff split into before/after table changes
     attr_reader :before_table_changes
     attr_reader :table_changes
     attr_reader :after_table_changes
 
     def initialize(db1, db2)
+      constrain db1, String
+      constrain db2, String
       @db1, @db2 = db1, db2
       do_diff
       split_on_table_changes
@@ -17,40 +20,35 @@ module Prick
     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?
+    # collision with the built-in #equal? method
     def same?() diff.empty? end
 
+    # :call-seq:
+    #   write(file, mark: true)
+    #   write(file1, file2, file3, mark: false)
+    #
     # 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)
+    def write(file1, file2 = nil, file3 = nil, mark: nil)
       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"
+        mark = mark.nil? ? true : mark
+      elsif file2.nil? != file3.nil?
+        raise Prick::Fail, "Either none or both of `file2` and `file3` should be nil"
+      else
+        mark = mark.nil? ? false : mark
       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}"
+        raise Prick::Fail, "migrate command failed with status #{Command.status}: #{command}"
     end
 
     # Initialize table change variables
@@ -110,6 +108,18 @@ module Prick
         end
       }
     end
+
+    def write_segment(file, segment, mark: true)
+      lines = self.send(segment)
+      if lines.empty?
+        FileUtils.touch(file)
+      else
+        File.open(file, "w") { |f|
+          f.puts "-- " + segment.to_s.gsub("_", " ").upcase if mark
+          f.puts lines
+        }
+      end
+    end
   end
 end
 

data/lib/prick/prick_version.rb

@@ -0,0 +1,161 @@
+
+require 'semantic' # https://github.com/jlindsey/semantic
+
+# Project related code starts here
+module Prick
+  class PrickVersion
+    class FormatError < RuntimeError; end
+
+    include Comparable
+
+    PRE_LABEL = "pre"
+    PRE_RE = /^#{PRE_LABEL}\.(\d+)$/
+
+    def self.zero() PrickVersion.new("0.0.0") end
+    def zero?() self == PrickVersion.zero end
+
+    # Return true if `string` is a version
+    def self.version?(string) 
+      string.is_a?(String) or raise Internal, "String expected"
+      !(string =~ VERSION_RE).nil? 
+    end
+
+    attr_accessor :fork
+    attr_accessor :semver
+    attr_accessor :feature
+
+    def major() @semver.major end
+    def major=(major) @semver.major = major end
+
+    def minor() @semver.minor end
+    def minor=(minor) @semver.minor = minor end
+
+    def patch() @semver.patch end
+    def patch=(patch) @semver.patch = patch end
+
+    # Return true if this is a fork release
+    def fork?() !@fork.nil? end
+
+    # Return true if this is a feature release
+    def feature?() !@feature.nil? end
+
+    # Return true if this is a release branch (and not a prerelease)
+    def release?() !feature? && !pre? end
+
+    # Return true if this is a pre-release
+    def pre?() !@semver.pre.nil? end
+    def prerelease?() pre? end
+
+    # The releases is stored as a String (eg. 'pre.1') in the semantic version
+    # but #pre returns only the Integer number
+    def pre() @semver.pre =~ PRE_RE ? $1.to_i : nil end
+    def prerelease() pre end
+
+    # #pre= expects an integer or nil argument
+    def pre=(pre) @semver.pre = (pre ? "#{PRE_LABEL}.#{pre}" : nil) end
+    def prerelease=(pre) self.pre = pre end
+
+    def dup() PrickVersion.new(self) end
+    def clone() PrickVersion.new(self) end
+
+    def eql?(other) self == other end
+    def hash() @semver.hash end
+
+    def initialize(version, fork: nil, feature: nil)
+      case version
+        when String
+          version =~ VERSION_RE or raise PrickVersion::FormatError, "Expected a version, got #{version.inspect}"
+          @fork = fork || $1
+          @semver = Semantic::Version.new($3)
+          @feature = feature || $4
+        when Semantic::Version
+          @fork = fork
+          @semver = version.dup
+          @feature = feature
+        when PrickVersion
+          @fork = fork || version.fork
+          @semver = version.semver.dup
+          @feature = feature || version.feature
+      else
+        raise Internal, "Expected a String, PrickVersion, or Semantic::Version, got #{version.class}"
+      end
+    end
+
+    # Try converting the string `version` into a PrickVersion object. Return nil if unsuccessful
+    def self.try(version)
+      version.is_a?(PrickVersion) ? version : (version?(version) ? new(version) : nil)
+    end
+
+    # Parse a branch or tag name into a PrickVersion object. Return a [version, tag]
+    # tuple where tag is true if name was a tag
+    def self.parse(name)
+      name =~ VERSION_RE or raise PrickVersion::FormatError, "Expected a version, got #{name.inspect}"
+      fork, tag, semver, feature = $1, $2, $3, $4
+      version = PrickVersion.new(semver, fork: fork, feature: feature)
+      [version, tag]
+    end
+
+    # `part` can be one of :major, :minor, :patch, or :pre. If pre is undefined, it 
+    # is set to `pre_initial_value`
+    def increment(part, pre_initial_value = 1) 
+      self.dup.increment!(part, pre_initial_value)
+    end
+
+    def increment!(part, pre_initial_value = 1)
+      if part == :pre
+        self.pre = (self.pre ? self.pre + 1 : pre_initial_value)
+      else
+        @semver = semver.increment!(part)
+      end
+      self
+    end
+
+    def truncate(part)
+      case part
+        when :pre
+          v = self.dup
+          v.feature = nil
+          v.pre = nil
+          v
+        when :feature
+          v = self.dup
+          v.feature = nil
+          v
+      else
+        raise NotYet
+      end
+    end
+
+#   def path
+#     parts = [FEATURE_DIR, truncate(:pre), feature].compact
+#     File.join(*parts)
+#   end
+
+#   def link
+#     !feature? or raise Internal, "PrickVersion #{to_s} is a feature, not a release"
+#     File.join(RELEASE_DIR, to_s)
+#   end
+
+    def <=>(other)
+      r = (fork || "") <=> (other.fork || "")
+      return r if r != 0
+      r = semver <=> other.semver
+      return r if r != 0
+      r = (feature || "") <=> (other.feature || "")
+      return r
+    end
+
+    # Render as branch
+    def to_s(tag: false)
+      (fork ? "#{fork}-" : "") + (tag ? "v" : "") + semver.to_s + (feature ? "_#{feature}" : "")
+    end
+
+    # Render as a tag
+    def to_tag() to_s(tag: true) end
+
+    # Render as string
+    def inspect() to_s end
+  end
+end
+
+