prick 0.2.0 → 0.3.0

data/lib/prick/rdbms.rb

@@ -1,11 +1,11 @@
 require 'prick/command.rb'
-require 'prick/ensure.rb'
+#require 'prick/ensure.rb'
 
 require 'csv'
 
 module Prick
   module Rdbms
-    extend Ensure
+#   extend Ensure
 
     ### EXECUTE SQL
 

data/lib/prick/schema.rb

@@ -1,100 +1,31 @@
-require "prick/constants.rb"
-require "prick/exceptions.rb"
+require "prick/state.rb"
 
 module Prick
-  # TODO: Resolve dependencies by extracting \i includes and then execute them
-  # in topological order. This means the must be no 'if' constructs in the
-  # files because otherwise dependencies are not static. The rule is that if a
-  # file \i includes another file, then the included file can always be execute
-  # before the current file
-  #
-  # Alternatively add some special tags:
-  #
-  # -- require prick (meaning include the prick schema)
-  # -- require public/user-schema (include this file)
-  #
-  class Schema
-    # Enclosing project
-    attr_reader :project
-
-    # Path to data file
-    def Schema.data_file() DATA_SQL_PATH end
-    def data_file() Schema.data_file end
-
-    # Version read from schemas/prick/data.sql
-    def version()
-      @version ||= begin
-          File.open(data_file, "r") { |file|
-            while !file.eof? && file.gets.chomp != COPY_STMT
-              ;
-            end
-            !file.eof? or raise Fail, "No COPY statement in #{data_file}"
-            l = file.gets.chomp
-            a = l.split("\t")[1..].map { |val| val == '\N' ? nil : val }
-            a.size == FIELDS.size or raise Fail, "Illegal data format in #{data_file}"
-            custom, major, minor, patch, pre = a[0], *a[1..-2].map { |val| val && val.to_i }
-            v = Version.new("0.0.0", custom: (custom == '\N' ? nil : custom))
-            v.major = major
-            v.minor = minor
-            v.patch = patch
-            v.pre = (pre == "null" ? nil : pre)
-            v
-          }
-      end
-    end
-
-    # Write version number into schemas/prick/data.sql
-    def version=(version) 
-      @version = Version.new(version)
-      File.open(data_file, "w") { |f|
-        f.puts "--"
-        f.puts "-- This file is auto-generated by prick(1). Please don't touch"
-        f.puts COPY_STMT
-        f.print \
-            "1\t",
-            FIELDS[..-2].map { |f| @version.send(f.to_sym) || '\N' }.join("\t"),
-            "\t#{@version}\n"
-        f.puts "\\."
-      }
-      Git.add(data_file)
-      @version
-    end
+  PRICK_SCHEMA = "prick"
+  SCHEMA_NAMES = %w(schema roles types tables data constraints indexes views functions comments grants)
+  BUILD_BASE_NAME = "build"
+  BUILD_SQL_FILE = BUILD_BASE_NAME + ".sql"
+  BUILD_YML_FILE = BUILD_BASE_NAME + ".yml"
 
-    def initialize(project)
-      @project = project
-    end
+  # Note this models the SCHEMAS_DIR directory, not a database schema
+  class Schema
+    attr_reader :directory
+    def yml_file() SchemaBuilder.yml_file(directory) end
 
-    # Path to the schemas directory
-    def path() "#{project.path}/#{SCHEMA_DIR}" end
+    def version() SchemaVersion.new(directory).read end
+    def version=(version) SchemaVersion.new(directory).write(version) end
+    def version_file() SchemaVersion.new(directory).path end
 
-    def built?(database = project.database) 
-      database.exist? && database.version == version
+    def initialize(directory = SCHEMAS_DIR) 
+      @directory = directory
     end
 
-    # Build a release from the files in schemas/
-    def build(database = project.database)
-      files = collect("schema.sql") + collect("data.sql")
-      Dir.chdir(path) {
-        files.each { |file| Rdbms.exec_file(database.name, file, user: project.user) }
-      }
-    end
+    def built?(database) database.exist? && database.version == version end
 
-    # Collects instances of `filename` in sub-directories of schemas/
-    def collect(filename)
-      Dir.chdir(path) {
-        if File.exist?(filename)
-          [filename]
-        else
-          Dir["*/#{filename}"]
-        end
-      }
+    # `subject` can be a subpath of schema/ (ie. 'public/tables')
+    def build(database, subject = nil)
+      SchemaBuilder.new(database, directory).build(subject)
     end
-
-  private
-    FIELDS = %w(custom major minor patch pre feature version)
-    COPY_STMT = "COPY prick.versions (id, #{FIELDS.join(', ')}) FROM stdin;"
-
-    DATA_SQL_PATH = "#{Prick::PRICK_DIR}/data.sql"
   end
 end
 

data/lib/prick/share.rb

@@ -0,0 +1,64 @@
+
+module Prick
+  class Share
+    # Procedural object for templating and copying share/ files
+    class Copier
+      attr_reader :clobber, :templates
+
+      def initialize(clobber, templates)
+        @clobber = clobber
+        @templates = templates
+      end
+
+      def cp(from, to)
+        if File.directory?(from)
+          cp_dir(from, to)
+        elsif File.file?(from)
+          cp_file(from, to)
+        else
+          raise Fail, "Can't copy #{from}"
+        end
+      end
+
+      def cp_file(from, to)
+        if clobber || !File.exist?(to)
+          if templates.empty?
+            FileUtils.copy_file(from, to)
+          else
+            File.open(to, "w") { |f|
+              File.readlines(from).each { |l|
+                templates.each { |key, value| l.gsub!(/\[<#{key}>\]/, value) }
+                f.puts l
+              }
+            }
+          end
+          [to]
+        else
+          []
+        end
+      end
+
+      def cp_dir(from, to)
+        FileUtils.mkdir_p(to)
+        Dir.children(from).map { |name|
+          cp(File.join(from, name), File.join(to, name))
+        }.flatten
+      end
+    end
+
+    def self.cp(pattern, dest, clobber: true, templates: {})
+      copier = Copier.new(clobber, templates)
+      matches = Dir.glob(File.join(SHARE_PATH, pattern))
+      if File.directory?(dest)
+        matches.map { |from| copier.cp(from, File.join(dest, File.basename(from))) }.flatten
+      elsif matches.size == 1
+        copier.cp(matches.first, dest)
+      elsif matches.size == 0
+        []
+      else
+        raise Internal, "Destination is not a directory: #{destdir}"
+      end
+    end
+  end
+end
+

data/lib/prick/state.rb

@@ -0,0 +1,137 @@
+
+require 'yaml'
+
+module Prick
+  class PrickFile
+    attr_reader :path
+    def initialize(path) @path = path end
+    def exist?() File.exist?(path) end
+
+  protected
+    def general_read(method, branch: nil, tag: nil)
+      branch || tag ? Git.send(method, path, branch: branch, tag: tag) : File.open(path, "r").send(method)
+    end
+    def do_read(**opts) general_read(:read, **opts) end
+    def do_readlines(**opts) general_read(:readlines, **opts) end
+  end
+
+  class State < PrickFile
+    # `fields` is a Hash from field name (Symbol) to field type (class). Eg. { f: Integer }
+    def initialize(path, **fields)
+      super(path)
+      @fields = fields
+      @fields.each_key { |k| self.class.attr_accessor k }
+    end
+
+    def create() write end
+
+    def set(**fields)
+      for field, value in fields
+        self.send(:"#{field}=", value)
+      end
+    end
+
+    def read(branch: nil, tag: nil)
+      if branch.nil?
+        hash = YAML.load(do_read(branch: branch, tag: tag))
+        for field, klass in @fields
+          value = hash[field.to_s]
+          value = Version.new(value) if klass == Version && !value.nil?
+          self.instance_variable_set("@#{field}", value)
+        end
+      else
+        raise NotYet
+      end
+      self
+    end
+
+    def write
+      hash = @fields.map { |field, klass|
+        value = self.send(field)
+        value = value.to_s if klass == Version && !value.nil?
+        [field.to_s, value]
+      }.to_h
+      IO.write(@path, YAML.dump(hash))
+      raise if @version.is_a?(Array)
+      self
+    end
+  end
+
+  class MigrationState < State
+    def initialize(directory, version: nil, base_version: nil)
+      super(File.join(directory, MIGRATION_STATE_FILE), version: Version, base_version: Version)
+      set(version: version, base_version: base_version)
+    end
+  end
+
+  class FeaturesState < State
+    def initialize(directory, features: [])
+      super(File.join(directory, FEATURES_STATE_FILE), features: Array)
+      set(features: features)
+    end
+  end
+
+  class ProjectState < State
+    def initialize(name: nil, user: nil)
+      super(PROJECT_STATE_FILE, name: String, user: String)
+      set(name: name, user: user)
+    end
+  end
+
+  class PrickVersion < PrickFile
+    def initialize() super PRICK_VERSION_FILE end
+
+    def read(branch: nil, tag: nil)
+      Version.new(do_readlines(branch: branch, tag: tag).first.chomp.sub(/^prick-/, ""))
+    end
+
+    def write(version)
+      File.open(path, "w") { |file| file.puts "prick-#{version}" }
+    end
+  end
+
+  class SchemaVersion < PrickFile
+    def initialize(schema = SCHEMAS_DIR) super(File.join(schema, "prick", "data.sql")) end
+
+    def read(**opts)
+      lines = do_readlines
+      while !lines.empty?
+        line = lines.shift.chomp
+        next if line != COPY_STMT
+        l = lines.shift.chomp
+        a = l.split("\t")[1..].map { |val| val == '\N' ? nil : val }
+        a.size == FIELDS.size or raise Fail, "Illegal data format in #{path}"
+        custom, major, minor, patch, pre = a[0], *a[1..-2].map { |val| val && val.to_i }
+        v = Version.new("0.0.0", custom: (custom == '\N' ? nil : custom))
+        v.major = major
+        v.minor = minor
+        v.patch = patch
+        v.pre = (pre == "null" ? nil : pre)
+        return v
+      end
+      raise Fail, "No COPY statement in #{path}"
+    end
+
+    def write(version)
+      version_string = version.truncate(:pre).to_s
+      File.open(path, "w") { |f|
+        f.puts "--"
+        f.puts "-- This file is auto-generated by prick(1). Please don't touch"
+        f.puts COPY_STMT
+        f.print \
+            "1\t",
+            FIELDS[..-2].map { |f| version.send(f.to_sym) || '\N' }.join("\t"),
+            "\t#{version_string}\n"
+        f.puts "\\."
+      }
+      Git.add(path)
+    end
+
+    def create() raise Internal, "This should not happen" end
+
+  private
+    FIELDS = %w(custom major minor patch pre feature version)
+    COPY_STMT = "COPY prick.versions (id, #{FIELDS.join(', ')}) FROM stdin;"
+  end
+end
+

data/lib/prick/version.rb

@@ -1,15 +1,17 @@
 
-# Moved to lib/prick.rb to avoid having Gem depend on it
+# "require 'semantic'" is moved to lib/prick.rb to avoid having Gem depend on it
 # require 'semantic' # https://github.com/jlindsey/semantic
 
 # Required by gem
 module Prick
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end
 
 # Project related code starts here
 module Prick
   class Version
+    class FormatError < RuntimeError; end
+
     include Comparable
 
     PRE_LABEL = "pre"
@@ -18,9 +20,8 @@ module Prick
     def self.zero() Version.new("0.0.0") end
     def zero?() self == Version.zero end
 
-    # Return true if `string` is a version. If true, it sets the Regex capture
-    # groups 1-3. See also Constants::VERSION_RE
-    def self.version?(string) (string =~ VERSION_RE).nil? ? false : true end
+    # Return true if `string` is a version
+    def self.version?(string) !(string =~ VERSION_RE).nil? end
 
     attr_accessor :custom
     attr_accessor :semver
@@ -41,8 +42,8 @@ module Prick
     # Return true if this is a feature release
     def feature?() !@feature.nil? end
 
-    # Return true if this is a release branch
-    def release?() !feature? 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
@@ -63,8 +64,7 @@ module Prick
     def initialize(version, custom: nil, feature: nil)
       case version
         when String
-          version =~ VERSION_RE
-          self.class.version?(version) or raise "Expected a version, got #{version.inspect}"
+          version =~ VERSION_RE or raise Version::FormatError, "Expected a version, got #{version.inspect}"
           @custom = custom || $1
           @semver = Semantic::Version.new($2)
           @feature = feature || $3
@@ -77,20 +77,28 @@ module Prick
           @semver = version.semver.dup
           @feature = feature || version.feature
       else
-        raise "Expected a String, Version, or Semantic::Version, got #{version.class}"
+        raise Internal, "Expected a String, Version, or Semantic::Version, got #{version.class}"
       end
     end
 
+    # Try converting the string `version` into a Version object. Return nil if unsuccessful
+    def self.try(version)
+      version?(version) ? new(version) : nil
+    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
-        v = self.dup
-        v.pre = (v.pre ? v.pre+1 : pre_initial_value)
-        v
+        self.pre = (self.pre ? self.pre + 1 : pre_initial_value)
       else
-        Version.new(semver.increment!(part), custom: custom, feature: feature)
+        @semver = semver.increment!(part)
       end
+      self
     end
 
     def truncate(part)
@@ -109,6 +117,18 @@ module Prick
       end
     end
 
+    def tag() "v#{to_s}" end
+
+    def path
+      parts = [FEATURE_DIR, truncate(:pre), feature].compact
+      File.join(*parts)
+    end
+
+    def link
+      !feature? or raise Internal, "Version #{to_s} is a feature, not a release"
+      File.join(RELEASE_DIR, to_s)
+    end
+
     def <=>(other)
       r = (custom || "") <=> (other.custom || "")
       return r if r != 0

data/libexec/strip-comments

@@ -0,0 +1,33 @@
+#!/usr/bin/bash
+
+# NAME
+#   strip-comments - Remove comments from postgres files
+#
+# USAGE
+#   strip-comments [FILE]
+#
+# DESCRIPTION
+#   Remove comments and blank lines from standard intput or the given file and
+#   write the result on standard output
+#
+# REFERENCES
+#   https://stackoverflow.com/a/35708616/1745001
+#
+
+PROGRAM=$(basename $0)
+USAGE="[FILE]"
+
+function error() {
+    echo "$PROGRAM: $@"
+    echo "Usage: $PROGRAM $USAGE"
+    exit 1
+} >&2
+
+[ $# -le 1 ] || error "Illegal number of arguments"
+FILE=$1
+
+sed '/^\s*--/d' $FILE \
+|   sed 's/a/aA/g; s/__/aB/g; s/#/aC/g' \
+|   gcc -P -E -ansi - \
+|   sed 's/aC/#/g; s/aB/__/g; s/aA/a/g'
+