prick 0.4.0 → 0.5.0

data/lib/prick/project.rb

@@ -2,6 +2,283 @@ require "prick/state.rb"
 
 require "tmpdir"
 
+module Prick
+  class Project
+    attr_reader :name
+    attr_reader :user # Database user
+    attr_reader :head # Current branch/tag
+    attr_reader :schema
+
+    # Return the versioned database or the project database if `version` is nil
+    def database(version = nil)
+      version ? Database.new("#{name}-#{version}", user) : @database
+    end
+
+    attr_reader :cache
+
+    def initialize(name, user, head)
+      @name = name
+      @user = user || ENV['USER']
+      @head = head
+      @schema = Schema.new
+      @database = Database.new(name, user)
+      @cache = Cache.new
+    end
+
+    forward_methods :version, :base_version, :@head
+    forward_methods :clean?, :@head
+    forward_methods :tag?, :release_tag?, :migration_tag?, :@head
+    forward_methods :branch?, :release_branch?, :prerelease_branch?, :feature_branch?, :migration_branch?, :@head
+
+    def self.exist?(directory) 
+      File.directory?(directory) && Dir.chdir(directory) { ProjectState.new.exist? } 
+    end
+
+    def self.create(name, user, directory)
+      user ||= ENV['USER']
+
+      FileUtils.mkdir(directory) if directory != "."
+
+      Dir.chdir(directory) {
+        # Initialize git instance
+        Git.init
+
+        # Create prick version file
+        PrickVersion.new.write(VERSION)
+
+        # Create project state file
+        ProjectState.new(name: name, user: user).write
+
+        # Directories
+        FileUtils.mkdir_p(DIRS)
+        DIRS.each { |dir| FileUtils.touch("#{dir}/.keep") }
+
+        # Copy default gitignore and schema files
+        Share.cp("gitignore", ".gitignore")
+        Share.cp("schema/schema", ".")
+
+        # Add .prick-migration file
+        MigrationState.new(version: Version.zero).create
+
+        # Add everything so far
+        Git.add(".")
+        Git.commit("Initial import")
+
+        # Rename branch "master"/"main" to "0.0.0_initial"
+        from_branch = Git.branch?("master") ? "master" : "main"
+        Git.rename_branch(from_branch, "0.0.0_initial")
+
+        # Create schema
+        schema = Schema.new
+        schema.version = Version.zero
+        Git.add schema.version_file
+
+        # Create release
+        Git.commit "Created release v0.0.0"
+        Git.create_tag(Version.zero)
+        Git.checkout_tag(Version.zero)
+      }
+    end
+
+    # Initialize from disk
+    #
+    # TODO Handle migrations
+    def self.load
+      if Git.detached?
+        name = "v#{Git.current_tag}"
+      else
+        name = Git.current_branch
+      end
+      begin
+        branch = Head.load(name)
+      rescue Version::FormatError
+        raise Fail, "Illegal branch name: #{name}"
+      end
+      state = ProjectState.new.read
+      Project.new(state.name, state.user, branch)
+    end
+
+#   def checkout(branch_or_tag) end
+
+    def build(database = self.database, version: nil)
+      database.clean
+      if version
+        FileUtils.mkdir_p(TMP_DIR)
+        Dir.mktmpdir("clone-", TMP_DIR) { |dir|
+          Command.command "git clone . #{dir}"
+          Dir.chdir(dir) {
+            Git.checkout_tag(version)
+            project = Project.load
+            project.head.build(database)
+          }
+        }
+      else
+        head.build(database)
+      end
+      self
+    end
+
+#   def make(database = self.database, version: nil)
+#     database.clean
+#     if cache.exist?(version)
+#       load(database, version: version)
+#     else
+#       build(database, version: version)
+#       cache.save(database, version) if version
+#     end
+#     self
+#   end
+
+    def load(database = self.database, version: nil, file: nil)
+      version.nil? ^ file.nil? or raise Internal, "Need exactly one of :file and :version to be defined"
+      database.clean
+      if version
+        cache.exist?(version) or raise Internal, "Can't find cache file for database #{database}"
+        cache.load(database, version)
+      else
+        database.load(file)
+      end
+      self
+    end
+
+    def save(database = nil, file: nil)
+      !database.nil? || file or raise Internal, "Need a database when saving to file"
+      database ||= self.database
+      if file
+        database.save(file)
+      else
+        cache.save(database)
+      end
+      self
+    end
+
+    # Create a schema diff between two database versions. to_version defaults to the
+    # current version. Returns the Diff object
+    def diff(from_version, to_version)
+      begin
+        from_db = Database.new("#{name}-base", user)
+        to_db = Database.new("#{name}-next", user)
+        from_version ||= version
+        build(from_db, version: from_version)
+        build(to_db, version: to_version)
+        Diff.new(from_db, to_db)
+      ensure
+        from_db&.drop
+        to_db&.drop
+      end
+    end
+
+    def prepare_release(fork = nil)
+      check_clean(:release_tag)
+      @head = ReleaseBranch.new(fork, version).create
+      submit "Prepared new release based on v#{version}", true
+      self
+    end
+
+    def prepare_diff(from_version = version)
+      begin
+        from_name = "#{name}-base"
+        from_db = Database.new(from_name, user)
+        build(from_db, version: from_version)
+
+        to_name = "#{name}-next"
+        to_db = Database.new(to_name, user)
+        build(to_db)
+
+        if prerelease_branch?
+          head.migrate_features(from_db)
+        end
+
+        diff = Diff.new(from_db, to_db)
+        for path, lines, tables in [
+            [BEFORE_TABLES_DIFF_PATH, diff.before_table_changes, false], 
+            [TABLES_DIFF_PATH, diff.table_changes, true], 
+            [AFTER_TABLES_DIFF_PATH, diff.after_table_changes, false]]
+          if lines.empty?
+            if File.exist?(path)
+              if tables
+                Share.cp(File.join("diff", File.basename(path)), path)
+                Git.add(path)
+              else
+                Git.rm(path)
+              end
+            end
+          else
+            Share.cp(File.join("diff", File.basename(path)), path)
+            File.open(path, "a") { |f| f.puts lines }
+            Git.add(path) if !tables
+          end
+        end
+        self
+      ensure
+        from_db&.drop
+        to_db&.drop
+      end
+    end
+
+    def create_release(new_version) 
+      check_clean(:release_branch)
+      head = ReleaseTag.new(new_version, version)
+      check_migration(head.migration)
+      (@head = head).create
+      self
+    end
+
+    def generate_schema
+      build = SchemaBuilder.new(database, SCHEMA_DIR).build(execute: false)
+      puts build.lines
+    end
+
+    def generate_migration
+      build = MigrationBuilder.new(database, MIGRATION_DIR).build(execute: false)
+      puts build.lines
+    end
+
+  private
+    def check(kind) self.send(:"#{kind}?") end
+    def check_clean(kind = nil)
+      clean? or raise Internal, "Dirty repository" 
+      kind.nil? || check(kind) or raise Internal, "Not on a #{kind} tag/branh"
+    end
+
+    def check_branch() branch? or raise Internal, "Not on a branch" end
+    def check_tag() tag? or raise Internal, "Not on a tag" end
+
+    # FIXME: Use Cache::file
+    def cache_file(version) File.join(CACHE_DIR, "#{database(version)}.sql.gz") end
+
+    def submit(msg, commit = true)
+      Git.commit msg if commit
+      @message = msg
+    end
+
+    def clean(database) # FIXME: Use Database#clean
+      if database.exist?
+        database.recreate if database.loaded?
+      else
+        database.create
+      end
+    end
+
+    def check_migration(migration)
+      begin
+        from_version = migration.base_version
+        from_db = Database.new("#{name}-base", user)
+        to_db = Database.new("#{name}-next", user)
+        build(from_db, version: from_version)
+        build(to_db)
+        migration.migrate(from_db)
+        Diff.new(from_db, to_db).same? or raise Error, "Schema/migration mismatch"
+      ensure
+        from_db&.drop
+        to_db&.drop
+      end
+    end
+  end
+end
+
+__END__
+
 module Prick
   class Project
     # Name of project. Persisted in the project state file

data/lib/prick/rdbms.rb

@@ -9,7 +9,8 @@ module Prick
 
     ### EXECUTE SQL
 
-    # Execute the SQL statement and return stdout as an array of tuples
+    # Execute the SQL statement and return stdout as an array of tuples. FIXME:
+    # SQL can't contain '"'
     def self.exec_sql(db, sql, user: ENV['USER'])
       stdout = Command.command %(
         {

data/lib/prick/schema.rb

@@ -9,22 +9,17 @@ module Prick
 
   # Note this models the SCHEMAS_DIR directory, not a database schema
   class Schema
-    attr_reader :directory
-    def yml_file() SchemaBuilder.yml_file(directory) end
+    def 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
-