prick 0.2.0 → 0.3.0

data/lib/ext/fileutils.rb

@@ -1,8 +1,19 @@
 
+
+require 'pathname'
+
 module FileUtils
   def self.touch_p(file)
     dir = File.dirname(file)
     File.exist?(dir) or FileUtils.mkdir_p(dir)
     touch(file)
   end
+
+  def self.ln_sr(from, to)
+    from = Pathname.new(from)
+    to_dir = File.dirname(to)
+    to_file = File.basename(to)
+    relpath = from.relative_path_from(File.dirname(to))
+    Dir.chdir(to_dir) { FileUtils.ln_s(relpath, File.basename(to)) }
+  end
 end

data/lib/ext/forward_method.rb

@@ -0,0 +1,18 @@
+
+class Class
+  # TODO: Check for arity
+  def forward_methods(*methods, object)
+    for method in Array(methods).flatten
+      if method.to_s.end_with?("=")
+        src = "def #{method}(args) raise if #{object}.nil?; #{object}.#{method}(args) end"
+      else
+        src = "def #{method}(*args) #{object}&.#{method}(*args) end"
+      end
+      class_eval(src)
+    end
+  end
+
+  def forward_method(*args) forward_methods(*args) end
+end
+
+

data/lib/ext/shortest_path.rb

@@ -0,0 +1,44 @@
+
+module Algorithm
+  # Return (one of) the shortest path from `from` to `to` as a list of edges.
+  # `edges` is a list of arrays with from-node and to-node as the first two
+  # elements. Returns nil if no route was found
+  #
+  # The algorithm does slightly more work than it needs to because the same node
+  # can be inserted more than once into the queue of nodes to be processed
+  #
+  def self.shortest_path(edges, from, to)
+    pool = {} # Map from 'from' to map from 'to' to edge. Eg. pool[from][to] == edge-between-them
+    edges.each { |edge| (pool[edge[0]] ||= {})[edge[1]] = edge }
+
+    visited = {}
+    prev = {}
+
+    todo = [from]
+    while true
+      return nil if todo.empty?
+
+      current = todo.shift
+      break if current == to
+
+      next if visited[current]
+      visited[current] = true
+
+      next if pool[current].nil?
+      pool[current].each { |node, edge|
+        prev[node] ||= edge
+        todo << node
+      }
+    end
+
+    to_node = to
+    route = []
+    while edge = prev[to_node]
+      to_node = edge.first
+      route.unshift edge
+      break if from == to_node
+    end
+
+    route
+  end
+end

data/lib/prick.rb

@@ -1,20 +1,28 @@
-require 'semantic' # https://github.com/jlindsey/semantic
+require "semantic" # Defined here instead of in prick/version.rb to avoid having Gem depend on it
 
-require "prick/constants.rb"
-require "prick/exceptions.rb"
+# Needs to go first because it contains class-level methods that is used by other modules
+require "ext/forward_method.rb"
 
-require "prick/archive.rb"
-require "prick/build.rb"
+require "prick/branch.rb"
+require "prick/builder.rb"
+require "prick/migration.rb"
 require "prick/command.rb"
+require "prick/constants.rb"
 require "prick/database.rb"
-require "prick/dsort.rb"
-require "prick/ensure.rb"
+require "prick/diff.rb"
+require "prick/exceptions.rb"
 require "prick/git.rb"
-require "prick/migra.rb"
+require "prick/project.rb"
 require "prick/rdbms.rb"
 require "prick/schema.rb"
+require "prick/share.rb"
+require "prick/state.rb"
 require "prick/version.rb"
-require "prick/project.rb"
+
+require "ext/fileutils.rb"
+require "ext/shortest_path.rb"
+
+require "indented_io"
 
 module Prick
 end

data/lib/prick/branch.rb

@@ -0,0 +1,254 @@
+require "prick/state.rb"
+
+module Prick
+  class Branch
+    # Branch name. It is usually equal to the version but migrations use a
+    # <base_version>_<version> format instead
+    attr_reader :name 
+
+    # Version of this branch. Note that version and base_version are the same
+    # for feature branches
+    attr_reader :version
+
+    # Base version
+    attr_reader :base_version
+
+    # The release directory. It contains the release's .prick-migration file
+    attr_reader :directory
+
+    # The Schema object. This is shared by many all branches
+    attr_reader :schema
+
+    # Migration object. Running the migration object on the base release will
+    # migrate it to this release
+    attr_reader :migration
+
+    # Database name
+    def database() name end
+
+    # Classifiers
+    def release?() self.is_a?(Release) && !prerelease? end
+    def prerelease?() self.is_a?(PreRelease) end
+    def feature?() self.is_a?(Feature) end
+    def migration?() self.is_a?(MigrationRelease) end
+
+    # Note that `name` can be nil. It defaults to `version.to_s`
+    def initialize(name, version, base_version, directory, migration)
+      @name = name || migration.version.to_s
+      @version = version
+      @base_version = base_version
+      @directory = directory
+      @schema = Schema.new
+      @migration = migration
+    end
+
+    def dump
+      puts "#{self.class}"
+      indent {
+        puts "name: #{name}"
+        puts "version: #{version}"
+        puts "base_version: #{base_version}"
+        puts "directory: #{directory}"
+        print "migration: "
+        migration.dump
+        puts "database: #{database}"
+      }
+    end
+
+    def self.load(name) raise NotThis end
+
+    # True if the branch exists in git
+    def exist?() self.class.exist?(name) end
+
+    def create()
+      !exist? or raise Error, "Can't create branch #{name}, exists already"
+      Git.create_branch(name)
+      Git.checkout_branch(name)
+      prepare if !prepared?
+      self
+    end
+
+    # True if the branch exists on disk
+    def present?() self.class.present?(name) end
+
+    def prepared?() @migration.exist? end
+    def prepare() @migration.create end
+
+    def include(feature_version) @migration.append_feature(feature_version) end
+
+    def build(database) schema.build(database) end
+
+    # Used to checkout migrations. MigrationReleases checks out the
+    # corresponding branch while Release and PreRelease checks out a tag
+    def checkout_release() Git.checkout_branch(version) end
+
+    def migrate(database)
+      @migration.migrate(database)
+    end
+
+    def migrate_features(database)
+      @migration.migrate_features(database)
+    end
+
+    def self.directory(name) raise NotThis end
+    def self.exist?(name) Git.branch?(name) || Git.tag?(name) end
+    def self.present?(name) File.exist?(directory(name)) end
+
+    def <=>(other)
+      if !self.is_a?(MigrationRelease) && other.is_a?(MigrationRelease)
+        compare(other.base_version, other.version)
+      else
+        compare(other.version, other.base_version)
+      end
+    end
+
+  private
+    def compare(other_version, other_base_version)
+      r = version <=> other_version
+      return r if r != 0
+      if base_version.nil?
+        other_base_version.nil? ? 0 : -1
+      elsif other_base_version.nil?
+        1
+      else
+        base_version <=> other_base_version
+      end
+    end
+  end
+
+  class AbstractRelease < Branch
+    def create(schema_version = self.version)
+      super()
+      schema.version = schema_version
+      Git.add schema.version_file
+      self
+    end
+
+    def checkout_release() Git.checkout_tag(version) end
+
+    def tag!() Git.create_tag(version) end
+  end
+
+  class Release < AbstractRelease
+    def initialize(version, base_version)
+      !version.zero? || base_version.nil? or raise Internal, "Version 0.0.0 has no base release"
+      directory = self.class.directory(version.to_s)
+      migration = ReleaseMigration.new(version, base_version)
+      super(nil, version, base_version, directory, migration)
+    end
+
+    def self.load(name)
+      migration = ReleaseMigration.load(directory(name))
+      self.new(migration.version, migration.base_version)
+    end
+
+    def self.directory(name)
+      File.join(RELEASES_DIR, name)
+    end
+  end
+
+  class PreRelease < AbstractRelease
+    attr_reader :prerelease_version
+
+    def database() version.to_s end
+
+    def initialize(prerelease_version, base_version)
+      @prerelease_version = prerelease_version
+      version = prerelease_version.truncate(:pre)
+      directory = Release.directory(version.to_s)
+      migration = ReleaseMigration.new(version, base_version)
+      super(prerelease_version.to_s, version, base_version, directory, migration)
+    end
+
+    def self.load(name, prerelease_version)
+      migration = ReleaseMigration.load(directory(name))
+      self.new(prerelease_version, migration.base_version)
+    end
+
+    def create() 
+      super(prerelease_version) 
+    end
+
+    def increment
+      PreRelease.new(prerelease_version.increment(:pre), base_version)
+    end
+
+    def self.directory(name)
+      version = Version.new(name)
+      Release.directory(version.truncate(:pre).to_s)
+    end
+  end
+
+  class MigrationRelease < Branch
+    def database() version.to_s end
+
+    def initialize(version, base_version)
+      migration = MigrationMigration.new(version, base_version)
+      super(migration.name, version, base_version, migration.dir, migration)
+    end
+
+    def self.load(name)
+      directory = self.directory(name)
+      migration_state = MigrationState.new(directory).read
+      self.new(migration_state.version, migration_state.base_version)
+    end
+
+    def self.directory(name)
+      File.join(MIGRATIONS_DIR, name)
+    end
+  end
+
+  # Feature maintains a migration in the parent release but it is ignored when
+  # including the feature
+  class Feature < Branch
+    attr_reader :feature_name
+
+    def database() base_version.to_s end
+
+    def initialize(feature_name, base_version)
+      version = Version.new(base_version, feature: feature_name)
+      migration = FeatureMigration.new(feature_name, base_version)
+      super(version.to_s, version, base_version, migration.features_dir, migration)
+      @feature_name = feature_name
+    end
+
+    def create
+      super()
+      schema.version = version
+      Git.add schema.version_file
+      self
+    end
+
+    def include(feature_version) @migration.insert_feature(feature_version) end
+
+    def rebase(base_version)
+      new_version = Version.new(new_base_version, feature: feature_name)
+      name = new_version.to_s
+
+      Git.create_branch(name)
+      Git.checkout_branch(name)
+
+      symlink = self.directory(name)
+      FileUtils.ln_sr(directory, symlink, force: true) 
+      Git.add(symlink)
+
+      migration.base_version = new_base_version
+      migration.save
+
+      schema.version = new_version
+      Git.add ect.schema.version_file
+    end
+
+    def self.load(name)
+      directory = self.directory(name)
+      migration_state = MigrationState.new(directory).read
+      self.new(migration_state.version.feature, migration_state.base_version)
+    end
+
+    def self.directory(name)
+      version = Version.new(name)
+      File.join(Release.directory(version.truncate(:feature).to_s), version.feature.to_s)
+    end
+  end
+end
+

data/lib/prick/builder.rb

@@ -0,0 +1,141 @@
+require "prick/state.rb"
+
+module Prick
+  # Builder is a procedural object for building schemas and executing
+  # migrations. Builder use resources that can be executables, SQL files, YAML
+  # files, or directories. A resource is identified by a name (eg. 'my-tables')
+  # and is used to match a build file. Build files are looked up in the
+  # following order:
+  #
+  #   #{name}, #{name}.* executable
+  #   #{name}.yml
+  #   #{name}.sql
+  #   #{name}/
+  #
+  # When a resource match a directory, the directory can contain a special
+  # default resource ('build' or 'migrate') that takes over the rest of the
+  # build process for that directory.  Typically, you'll use the 'build.yml' or
+  # 'migrate.yml' to control the build order of the other resources
+  #
+  # If a directory doesn't contain a build resource, the resources in the
+  # directory are built in alphabetic order
+  #
+  class Builder
+    attr_reader :database
+    attr_reader :directory
+    attr_reader :default # either "build" or "migrate"
+
+    def initialize(database, directory, default)
+      @database = database
+      @directory = directory
+      @default = default
+    end
+
+    def build(subject = nil)
+#     puts "Building #{subject.inspect}"
+      Dir.chdir(directory) {
+        if subject
+          build_subject(subject)
+        else
+          build_directory(".")
+        end
+      }
+    end
+
+    def self.yml_file(directory) raise NotThis end
+
+  protected
+    def do_dir(path, &block)
+      dir, file = File.split(path)
+      Dir.chdir(dir) { yield(file) }
+    end
+
+    def do_sql(path)
+#     puts "do_sql(#{path})"
+      do_dir(path) { |file| Rdbms.exec_file(database.name, file, user: database.user) }
+      true
+    end
+
+    def do_exe(path)
+#     puts "do_exe(#{path})"
+      do_dir(path) { |file| Command.command "#{file} #{database.name} #{database.user}" } # FIXME Security
+      true
+    end
+
+    def do_yml(path)
+#     puts "do_yml(#{path})"
+      dir, file = File.split(path)
+      YAML.load(File.read(path))&.each { |subject| build_subject(File.join(dir, subject)) }
+      true
+    end
+
+    # A subject can be both an abstract subject or a concrete file (*.yml, *.sql)
+    def build_subject(subject)
+      if File.file?(subject) && File.executable?(subject)
+        do_exe(subject)
+      elsif subject.end_with?(".yml")
+        do_yml(subject)
+      elsif subject.end_with?(".sql")
+        do_sql(subject)
+      elsif File.exist?(yml_file = "#{subject}.yml")
+        do_yml(yml_file)
+      elsif File.exist?(sql_file = "#{subject}.sql")
+        do_sql(sql_file)
+      elsif File.directory?(subject)
+        build_directory(subject)
+      else
+        false
+      end
+    end
+
+    def build_directory(path)
+      Dir.chdir(path) {
+        build_subject(File.join(path, "build")) || begin
+          if Dir["#{path}/#{default}", "#{path}/#{default}.yml", "#{path}/#{default}.sql"]
+            subjects = [default]
+          else
+            exes = candidates.select { |file| File.file?(file) && File.executable?(file) }
+            ymls = candidates.select { |file| file.end_with?(".yml") }.map { |f| f.sub(/\.yml$/, "") }
+            sqls = candidates.select { |file| file.end_with?(".sql") }.map { |f| f.sub(/\.sql$/, "") }
+            dirs = candidates.select { |file| File.directory?(file) }
+            subjects = (exes + ymls + sqls + dirs).uniq.sort.reject { |f| f != "diff" }
+          end
+          subjects.inject(false) { |a, s| build_subject(s) || a }
+        end
+      }
+    end
+  end
+
+  class MigrationBuilder < Builder
+    def initialize(database, directory)
+      super(database, directory, "migrate")
+    end
+
+    def self.yml_file(directory) File.join(directory, "migrate") + ".yml" end
+  end
+
+  class SchemaBuilder < Builder
+    def initialize(database, directory)
+      super(database, directory, "build")
+    end
+
+    def build(subject = nil)
+      if subject
+        Dir.chdir(directory) {
+          if File.executable?(subject)
+            do_exe(subject)
+          elsif subject.end_with?(".sql")
+            do_sql(subject)
+          else
+            build_subject(subject)
+          end
+        }
+      else
+        super()
+      end
+    end
+
+    def self.yml_file(directory) File.join(directory, "build") + ".yml" end
+  end
+end
+