prick 0.18.0 → 0.20.2

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
+
+

data/lib/prick/state.rb

@@ -2,191 +2,106 @@
 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
+  class State
+    # State file
+    def file() PRICK_PROJECT_PATH 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
+    # Schema data file
+    def schema_file() SCHEMA_VERSION_PATH 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
+    # Used as an identifier and the default database and username
+    attr_accessor :name
 
-    # Return the version
-    def read(branch: nil, tag: nil)
-      Version.new(do_readline(branch: branch, tag: tag).chomp.sub(/^prick-/, ""))
-    end
+    # Capitalized name of project
+    attr_accessor :title
 
-    # Write prick version
-    def write(version)
-      File.open(path, "w") { |file| file.puts "prick-#{version}" }
-    end
-  end
+    # Version in prick.yml. Can be nil
+    attr_accessor :version
 
-  # 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
+    # Version in schema/prick/data.sql. Retrieved dynamically. TODO
+    attr_reader :schema_version
 
-    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
+    # Version from prick.versions.version. Retrieved dynamically. TODO FIXME: Where is conn?
+    attr_reader :database_version
 
-    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
+    # Version of prick(1)
+    attr_accessor :prick_version
 
-  private
-    FIELDS = %w(fork major minor patch pre feature version)
-    COPY_STMT = "COPY prick.versions (id, #{FIELDS.join(', ')}) FROM stdin;"
+    # Run-time environment. Can be :production, :development, or :test
+    attr_accessor :environment 
 
-    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
+    # Name of database
+    attr_accessor :database
 
-    def create() write end
+    # Name of database user
+    attr_accessor :username
 
-    def set(**fields)
-      for field, value in fields
-        self.send(:"#{field}=", value)
+    def self.load
+      begin
+        h = YAML.load(File.read PRICK_PROJECT_PATH)
+      rescue Errno::ENOENT
+        raise Prick::Error, "Can't open project file: #{PRICK_PROJECT_PATH}"
       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)
+      state = State.new
+      state.name = h["name"]
+      state.title = h["title"]
+      state.version = h["version"] && PrickVersion.new(h["version"])
+      state.prick_version = h["prick"] && PrickVersion.new(h["prick"])
+
+      begin
+        h = YAML.load(File.read PRICK_CONTEXT_PATH)
+      rescue Errno::ENOENT
+        raise Prick::Error, "Can't open environment file: #{PRICK_CONTEXT_PATH}"
       end
-      @loaded = true
-      self
-    end
+      state.environment = h["environment"]&.to_sym
+      state.database = h["database"]
+      state.username = h["username"]
 
-    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
+      # TODO Load schema version
 
-  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)
+      state
     end
-  end
 
-  class HeadState < State
-    def initialize(name: nil)
-      super(PRICK_HEAD_PATH, name: String)
-      set(name: name)
-    end
-  end
+    def save
+      h = {
+        "name" => name,
+        "title" => title,
+        "version" => version.to_s,
+        "prick" => prick_version.to_s
+      }
+      File.write(PRICK_PROJECT_PATH, h.to_yaml)
 
-  class FeatureState < State
-    def initialize(feature: nil)
-      super(PRICK_FEATURE_PATH, feature: String)
-      set(feature: feature)
+      h = {
+        "environment" => environment.to_s,
+        "database" => database,
+        "username" => username
+      }
+      File.write(PRICK_CONTEXT_PATH, h.to_yaml)
+
+      if version
+        File.write(SCHEMA_VERSION_PATH, 
+            <<~EOS
+              --
+              -- This file is auto-generated by prick(1). Please don't touch
+              --
+              delete from prick.versions;
+              insert into prick.versions (fork, major, minor, patch, pre, feature, version)
+                  values (null, #{version.major}, #{version.minor}, #{version.patch}, null, null, '#{version}');
+            EOS
+        )
+      end
     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)
+    def dump
+      puts "State"
+      indent {
+        for method in [
+            :name, :title, :prick_version, :project_version, :schema_version,
+            :database_version, :environment, :database, :username]
+          puts "#{method}: #{self.send method}"
+        end
+      }
     end
   end
-
 end
+

data/lib/prick/version.rb

@@ -1,166 +1,5 @@
+# frozen_string_literal: true
 
-# "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.18.0"
+  VERSION = "0.20.2"
 end
-
-# Project related code starts here
-module Prick
-  class Version
-    class FormatError < RuntimeError; end
-
-    include Comparable
-
-    PRE_LABEL = "pre"
-    PRE_RE = /^#{PRE_LABEL}\.(\d+)$/
-
-    def self.zero() Version.new("0.0.0") end
-    def zero?() self == Version.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() Version.new(self) end
-    def clone() Version.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 Version::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 Version
-          @fork = fork || version.fork
-          @semver = version.semver.dup
-          @feature = feature || version.feature
-      else
-        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
-        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, "Version #{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
-
-