prick 0.4.0 → 0.9.0

data/lib/prick/rdbms.rb

@@ -1,5 +1,4 @@
 require 'prick/command.rb'
-#require 'prick/ensure.rb'
 
 require 'csv'
 
@@ -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

@@ -7,24 +7,20 @@ module Prick
   BUILD_SQL_FILE = BUILD_BASE_NAME + ".sql"
   BUILD_YML_FILE = BUILD_BASE_NAME + ".yml"
 
-  # Note this models the SCHEMAS_DIR directory, not a database schema
+  # Note this models the SCHEMA_DIR directory, not a database schema
   class Schema
-    attr_reader :directory
-    def yml_file() SchemaBuilder.yml_file(directory) end
+    def yml_file() self.class.yml_file end
+    def self.yml_file() SchemaBuilder.yml_file(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 initialize(directory = SCHEMAS_DIR) 
-      @directory = directory
-    end
+    def version() SchemaVersion.load end
+    def version=(version) SchemaVersion.new(version).write end
+    def version_file() SchemaVersion.new.path end
 
     def built?(database) database.exist? && database.version == version end
 
     # `subject` can be a subpath of schema/ (ie. 'public/tables')
     def build(database, subject = nil)
-      SchemaBuilder.new(database, directory).build(subject)
+      SchemaBuilder.new(database, SCHEMA_DIR).build(subject)
     end
   end
 end

data/lib/prick/state.rb

@@ -2,25 +2,119 @@
 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_readlines(**opts) general_read(:readlines, **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). Eg. { f: Integer }
+    # `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
@@ -29,23 +123,23 @@ module Prick
       for field, value in fields
         self.send(:"#{field}=", value)
       end
+      self
     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
+      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
+    def write(**fields)
+      set(**fields)
       hash = @fields.map { |field, klass|
         value = self.send(field)
         value = value.to_s if klass == Version && !value.nil?
@@ -58,80 +152,41 @@ module Prick
   end
 
   class MigrationState < State
-    def initialize(directory, version: nil, base_version: nil)
-      super(File.join(directory, MIGRATION_STATE_FILE), version: Version, base_version: Version)
+    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 FeaturesState < State
-    def initialize(directory, features: [])
-      super(File.join(directory, FEATURES_STATE_FILE), features: Array)
-      set(features: features)
+  class HeadState < State
+    def initialize(name: nil)
+      super(PRICK_HEAD_PATH, name: String)
+      set(name: name)
     end
   end
 
-  class ProjectState < State
-    def initialize(name: nil, user: nil)
-      super(PROJECT_STATE_FILE, name: String, user: String)
-      set(name: name, user: user)
+  class FeatureState < State
+    def initialize(feature: nil)
+      super(PRICK_FEATURE_PATH, feature: String)
+      set(feature: feature)
     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
+# class FeaturesState < State
+#   def initialize(directory, features: [])
+#     super(File.join(directory, FEATURES_STATE_FILE), features: Array)
+#     set(features: features)
+#   end
+# end
+#
 
-    def write(version)
-      File.open(path, "w") { |file| file.puts "prick-#{version}" }
+  # 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
 
-  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

@@ -4,7 +4,7 @@
 
 # Required by gem
 module Prick
-  VERSION = "0.4.0"
+  VERSION = "0.9.0"
 end
 
 # Project related code starts here
@@ -21,9 +21,12 @@ module Prick
     def zero?() self == Version.zero end
 
     # Return true if `string` is a version
-    def self.version?(string) !(string =~ VERSION_RE).nil? end
+    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
 
@@ -36,8 +39,8 @@ 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
@@ -47,13 +50,16 @@ module Prick
 
     # 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
@@ -61,19 +67,19 @@ 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 or raise Version::FormatError, "Expected a version, got #{version.inspect}"
-          @custom = custom || $1
-          @semver = Semantic::Version.new($2)
-          @feature = feature || $3
+          @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
@@ -83,9 +89,17 @@ module Prick
 
     # Try converting the string `version` into a Version object. Return nil if unsuccessful
     def self.try(version)
-      version?(version) ? new(version) : nil
+      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) 
@@ -117,20 +131,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 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 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
@@ -138,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