prick 0.2.0 → 0.7.0

data/lib/prick/rdbms.rb

@@ -1,11 +1,10 @@
 require 'prick/command.rb'
-require 'prick/ensure.rb'
 
 require 'csv'
 
 module Prick
   module Rdbms
-    extend Ensure
+#   extend Ensure
 
     ### EXECUTE SQL
 
@@ -15,7 +14,9 @@ module Prick
         {
           echo "set role #{user};"
           echo "set search_path to public;"
-          echo "#{sql}"
+          cat <<'EOF'
+          #{sql}
+EOF
         } | psql --csv --tuples-only --quiet -v ON_ERROR_STOP=1 -d #{db}
       )
       CSV.new(stdout.join("\n")).read
@@ -131,16 +132,6 @@ module Prick
       data_opt = (data ? "" : "--schema-only")
       Command.command "pg_dump --no-owner #{data_opt} #{db} | gzip --to-stdout >#{file}"
     end
-
-  private
-    @ensure_states = {
-      exist_user: [:create_user, :drop_user],
-      exist_database: [
-        lambda { |this, db, user| this.ensure_state(:exist_user, user) },
-        lambda { |this, db, user| this.create_database(db, owner: user) },
-        :drop_database
-      ]
-    }
   end
 end
 

data/lib/prick/schema.rb

@@ -1,100 +1,26 @@
-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
+  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"
 
-    # 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
-
-    def initialize(project)
-      @project = project
-    end
-
-    # Path to the schemas directory
-    def path() "#{project.path}/#{SCHEMA_DIR}" end
+  # Note this models the SCHEMA_DIR directory, not a database schema
+  class Schema
+    def yml_file() SchemaBuilder.yml_file(SCHEMA_DIR) end
 
-    def built?(database = project.database) 
-      database.exist? && database.version == version
-    end
+    def version() SchemaVersion.load end
+    def version=(version) SchemaVersion.new(version).write end
+    def version_file() SchemaVersion.new.path 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, SCHEMA_DIR).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,192 @@
+
+require 'yaml'
+
+module Prick
+  # General interface for prick state files. Comments are automatically removed
+  class PrickFile
+    attr_reader :path
+    def initialize(path) @path = path end
+    def exist?() File.exist?(path) end
+    def self.exist?() self.new.exist? end # Require an #initializer with no arguments
+
+    def self.load(*args) self.new(*args).read end
+
+    def self.read() raise NotThis end
+
+  protected
+    # Read file from disk or from the given branch or tag
+    def general_read(method, branch: nil, tag: nil)
+      !(branch && tag) or raise Internal, "Not both of `branch` and `tag` can be defined"
+      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_readline(**opts) do_readlines(**opts).first end
+    def do_readlines(**opts) general_read(:readlines, **opts).reject { |l| l =~ /^\s*#/ } end
+  end
+
+  # Models the .prick-version file. It contains just one line with the version
+  # of prick itself
+  class PrickVersion < PrickFile
+    def initialize() super PRICK_VERSION_FILE end
+
+    # Return the version
+    def read(branch: nil, tag: nil)
+      Version.new(do_readline(branch: branch, tag: tag).chomp.sub(/^prick-/, ""))
+    end
+
+    # Write prick version
+    def write(version)
+      File.open(path, "w") { |file| file.puts "prick-#{version}" }
+    end
+  end
+
+  # Models the schema version that is stored in the data.sql file in the prick
+  # schema directory. Note that SchemaVersion caches the version. Use #clear to
+  # reset the cache
+  class SchemaVersion < PrickFile
+    def initialize(version = nil)
+      @version = version
+      super SCHEMA_VERSION_PATH
+    end
+
+    def clear() @version = nil end
+
+    def create() raise Internal, "This should not happen" end
+
+    def read(**opts)
+      return @version if @version
+      lines = do_readlines
+      while !lines.empty?
+        line = lines.shift.chomp
+        next if line != COPY_STMT
+        data = lines.shift.chomp
+        a = data.split("\t").map { |val| parse_sql_literal(val) }
+        a.size == FIELDS.size + 1 or raise Fail, "Illegal data format in #{path}"
+        fork, major, minor, patch, pre, feature, version = *a[1..-1]
+        @version = Version.new("0.0.0", fork: fork, feature: feature)
+        @version.major = major
+        @version.minor = minor
+        @version.patch = patch
+        @version.pre = pre
+        return @version
+      end
+      raise Fail, "No COPY statement in #{path}"
+    end
+
+    def write(version = @version)
+#     puts "Writing #{path}"
+      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)
+      version
+    end
+
+  private
+    FIELDS = %w(fork major minor patch pre feature version)
+    COPY_STMT = "COPY prick.versions (id, #{FIELDS.join(', ')}) FROM stdin;"
+
+    def parse_sql_literal(s)
+      case s
+        when '\N', 'null'; nil
+        when/^\d+$/; s.to_i
+      else
+        s
+      end
+    end
+  end
+
+  # General interface for prick state files in YAML format
+  class State < PrickFile
+    # `fields` is a Hash from field name (Symbol) to field type (class) where a
+    # class can be a class known to YAML (Integer, String, etc.) or Version.
+    # The #initialize method generates an accessor methods for each field
+    def initialize(path, **fields)
+      super(path)
+      @fields = fields
+      @fields.each_key { |k| self.class.attr_accessor k }
+      @loaded = false
+    end
+
+    def create() write end
+
+    def set(**fields)
+      for field, value in fields
+        self.send(:"#{field}=", value)
+      end
+      self
+    end
+
+    def read(branch: nil, tag: nil)
+      return self if @loaded
+      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
+      @loaded = true
+      self
+    end
+
+    def write(**fields)
+      set(**fields)
+      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(version: nil, base_version: nil)
+      super(PRICK_MIGRATION_PATH, version: Version, base_version: Version)
+      set(version: version, base_version: base_version)
+    end
+  end
+
+  class HeadState < State
+    def initialize(name: nil)
+      super(PRICK_HEAD_PATH, name: String)
+      set(name: name)
+    end
+  end
+
+  class FeatureState < State
+    def initialize(feature: nil)
+      super(PRICK_FEATURE_PATH, feature: String)
+      set(feature: feature)
+    end
+  end
+
+# class FeaturesState < State
+#   def initialize(directory, features: [])
+#     super(File.join(directory, FEATURES_STATE_FILE), features: Array)
+#     set(features: features)
+#   end
+# end
+#
+
+  # Models the .prick-project file that contains the name of the project and
+  # the database user
+  class ProjectState < State
+    def initialize(name: nil, user: nil)
+      super(PROJECT_STATE_FILE, name: String, user: String)
+      set(name: name, user: user)
+    end
+  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.7.0"
 end
 
 # Project related code starts here
 module Prick
   class Version
+    class FormatError < RuntimeError; end
+
     include Comparable
 
     PRE_LABEL = "pre"
@@ -18,11 +20,13 @@ 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.is_a?(String) or raise Internal, "String expected"
+      !(string =~ VERSION_RE).nil? 
+    end
 
-    attr_accessor :custom
+    attr_accessor :fork
     attr_accessor :semver
     attr_accessor :feature
 
@@ -35,24 +39,27 @@ module Prick
     def patch() @semver.patch end
     def patch=(patch) @semver.patch = patch end
 
-    # Return true if this is a custom release
-    def custom?() !@custom.nil? 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
-    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
+    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() Version.new(self) end
     def clone() Version.new(self) end
@@ -60,37 +67,52 @@ module Prick
     def eql?(other) self == other end
     def hash() @semver.hash end
 
-    def initialize(version, custom: nil, feature: nil)
+    def initialize(version, fork: nil, feature: nil)
       case version
         when String
-          version =~ VERSION_RE
-          self.class.version?(version) or raise "Expected a version, got #{version.inspect}"
-          @custom = custom || $1
-          @semver = Semantic::Version.new($2)
-          @feature = feature || $3
+          version =~ VERSION_RE or raise Version::FormatError, "Expected a version, got #{version.inspect}"
+          @fork = fork || $1
+          @semver = Semantic::Version.new($3)
+          @feature = feature || $4
         when Semantic::Version
-          @custom = custom
+          @fork = fork
           @semver = version.dup
           @feature = feature
         when Version
-          @custom = custom || version.custom
+          @fork = fork || version.fork
           @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.is_a?(Version) ? version : (version?(version) ? new(version) : nil)
+    end
+
+    # Parse a branch or tag name into a Version object. Return a [version, tag]
+    # tuple where tag is true if name was a tag
+    def self.parse(name)
+      name =~ VERSION_RE or raise Version::FormatError, "Expected a version, got #{version.inspect}"
+      fork, tag, semver, feature = $1, $2, $3, $4
+      version = Version.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
-        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,8 +131,18 @@ module Prick
       end
     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 || "")
+      r = (fork || "") <=> (other.fork || "")
       return r if r != 0
       r = semver <=> other.semver
       return r if r != 0
@@ -118,16 +150,17 @@ module Prick
       return r
     end
 
-    # Render as String
-    def to_s
-      (custom ? "#{custom}-" : "") + semver.to_s + (feature ? "_#{feature}" : "")
+    # 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
-
-# ZERO = Version.new("0.0.0")
 end