prick 0.2.0

data/lib/ext/algorithm.rb

@@ -0,0 +1,14 @@
+
+module Algorithm
+  def follow(object, sym = nil, &block)
+    sym.nil? == block_given? or raise "Can't use both symbol and block"
+    a = []
+    while object
+      a << object
+      object = block_given? ? yield(object) : object.send(sym)
+    end
+    a
+  end
+
+  module_function :follow
+end

data/lib/ext/fileutils.rb

@@ -0,0 +1,8 @@
+
+module FileUtils
+  def self.touch_p(file)
+    dir = File.dirname(file)
+    File.exist?(dir) or FileUtils.mkdir_p(dir)
+    touch(file)
+  end
+end

data/lib/ext/pg.rb

@@ -0,0 +1,18 @@
+require 'pg'
+
+class PG::Result
+  def value() self.getvalue(0, 0) end
+
+  def each_value(&block)
+    if block_given?
+      self.each_row { |r| yield(r.first) }
+    else
+      self.each_row.map { |r| r.first }
+    end
+  end
+
+  def empty?() ntuples == 0 end
+
+  def to_a() self.values end
+end
+

data/lib/prick.rb

@@ -0,0 +1,21 @@
+require 'semantic' # https://github.com/jlindsey/semantic
+
+require "prick/constants.rb"
+require "prick/exceptions.rb"
+
+require "prick/archive.rb"
+require "prick/build.rb"
+require "prick/command.rb"
+require "prick/database.rb"
+require "prick/dsort.rb"
+require "prick/ensure.rb"
+require "prick/git.rb"
+require "prick/migra.rb"
+require "prick/rdbms.rb"
+require "prick/schema.rb"
+require "prick/version.rb"
+require "prick/project.rb"
+
+module Prick
+end
+

data/lib/prick/archive.rb

@@ -0,0 +1,124 @@
+
+module Prick
+  class DumpFile
+    attr_reader :project
+    attr_reader :name
+    attr_reader :file
+    attr_reader :path
+
+    def initialize(project, name)
+      @project = project
+      @name = name
+      @file = "#{project.name}-#{name}.#{DUMP_EXT}"
+      @path = File.join(CACHE_DIR, @file)
+    end
+
+    def exist?() File.exist?(path) end
+
+    def delete() FileUtils.rm_f(path) end
+  end
+end
+
+__END__
+
+
+
+  class Release
+    attr_reader :project
+    attr_reader :version
+    attr_reader :semver
+
+    # Associated Database object
+    attr_reader :database
+
+    # Name of release (eg. 'project-1.2.3')
+    attr_reader :name
+
+    # Release file (eb. 'project-1.2.3.dump.gz')
+    attr_reader :file
+
+    # Path to release file
+    def path() File.join(RELEASE_DIR, file) end
+
+    def initialize(project, version_or_semver, database: nil)
+      @project = project
+      @version, @semver = Semver::parse(version_or_semver)
+      @name = "#{@project.name}-#{@semver}"
+      @file = @name + RELEASE_DOT_EXT
+      @database = database || Database.new(@name, @project.user)
+    end
+
+    def self.glob(project)
+      "#{project.name}-*.#{RELEASE_EXT}"  
+    end
+
+    # $1 matches the version
+    def self.re(project)
+      /^#{project.name}-(#{VERSION_RE.source})$/ 
+    end
+
+    # True if the release file exists
+    def cached?() File.exist?(path) end
+
+    def build() project.build(version) end
+
+    def unbuild() FileUtils.rm_f(path) end
+
+    # True if the database exists and is loaded
+    def loaded?() database.loaded? end
+
+    # Create database and load release
+    def load(file = nil)
+      file ||= path
+      !loaded? or raise Error, "Release #{name} is already loaded"
+      database.create
+      database.load(file)
+    end
+
+    # Reload release
+    def reload(file = path) unload; load(file) end
+
+    # Delete a database. It is not an error if the database doesn't exists
+    def unload() database.drop if loaded?  end
+
+    # Remove the release file
+    def remove() FileUtils::rm_f(path) end
+
+    # Compare two release by semantic version
+    def <=>(other) self.semver <=> other.semver end
+
+    # Render self a the name of the release (eg. 'project-1.2.3')
+    def to_s() name end
+
+    # Returns self so that you can do 'release = lookup(version).ensure(:loaded)'
+    def ensure(state, expect: true)
+      value = self.send(:"#{state}?")
+      if value != expect
+        state_methods = STATES[state] or raise Error, "Can't change state to #{state.inspect}"
+        index = expect ? 0 : 1
+        self.send(state_method[index])
+      end
+      self
+    end
+  end
+
+  STATES = {
+    cached: [:build, :unbuild],
+    loaded: [:load, :unload]
+  }
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/prick/build.rb

@@ -0,0 +1,376 @@
+
+require "prick/ensure.rb"
+require "prick/dsort.rb"
+require "ext/fileutils.rb" # for ::touch_p
+
+module Prick
+  class Build
+    include Ensure
+
+    # The associated project object
+    attr_reader :project
+
+    # Version
+    attr_reader :version
+
+    # Build name. Same as `version.to_s`
+    def name() version.to_s end
+
+    # Associated database object
+    attr_reader :database
+
+    # Schema object. Only defined when the build has been checked out
+    attr_reader :schema
+
+    # Migration object. Running the migration on a base release database will
+    # mutate it into the current release
+    attr_reader :migration
+
+    # Path to a filesystem node that represents the build on disk. Used to
+    # detect if a build is present in the current release's tree. It is
+    # possible to infer the base release from the node - either by a naming
+    # convention or by reading the file. Build::deref_node_file does that
+    def node() raise AbstractMethod end
+
+    # Base release. Returns nil if version is 0.0.0. Raises an exception if
+    # branch is not represented on disk and it can't be inferred from the
+    # version (only features)
+    def base_release()
+      return nil if version.zero?
+      @base_release.present? or raise Internal, "Release #{name} is not present"
+      @base_release
+    end
+
+    # List of features in this build. This requires the build to be present on disk
+    def features() 
+      present? or raise "Build #{name} is not present"
+      version.zero? ? [] : migration.feature_versions.map { |version| project[version] }
+    end
+
+    # Return the build's history as a hash from release to list of features
+    def history()
+      h = {}
+      Algorithm.follow(self, :base_release).each { |release|
+        h[release] = []
+        indent {
+          release.features.each { |feature| h[release] << feature }
+        }
+      }
+      h
+    end
+
+    def initialize(project, base_release, version, migration, database: nil, schema: nil)
+      base_release.nil? || base_release.is_a?(Release) or 
+          raise Internal, "Expected a Release object, got #{base_release.class}"
+      version.is_a?(Version) or raise Internal, "Expected a Version object, got #{version.class}"
+      @project = project
+      @base_release = base_release
+      @version = version
+      @migration = migration
+      @schema = Schema.new(project)
+      @database = database || Database.new("#{project.name}-#{name}", project.user)
+      project[name] = self
+    end
+
+    # Return true if the build exists as a branch in git
+    def exist?() Git.branch?(name) end
+
+    # Create and checkout the branch
+    def create()
+      !present? or raise Fail, "Build #{name} is already present on disk"
+      !exist? or raise Fail, "Build #{name} is already present in git"
+      Git.create_branch(name)
+      Git.checkout_branch(name)
+    end
+
+    # FIXME: Kills the current branch under the feets of the application. Also doesn't update
+    # internal structures in Project
+    def destroy()
+      project.release != self or raise Error, "Can't destroy current branch - #{self.version}"
+      Git.delete_branch(name)
+    end
+
+    # True if the release is present in this git branch
+    def present?() File.exist?(node) end
+
+    # True if the release is the active branch
+    def active?() Git.current_branch == name end
+
+    def checkout()
+      Git.checkout(name) 
+    end
+
+    def checkback() # Doubtfull - creates strange results on Release and Prerelease branches
+      base_release.checkout 
+    end
+    
+    def built?()
+      active? && @schema.built?(@database) 
+    end
+
+    def build()
+      active? or raise Error, "Can't build: Not active"
+      @schema.build(@database) 
+    end
+
+    def rebuild() 
+      active? or raise Error, "Can't rebuild: Not active"
+      @database.recreate
+      build 
+    end
+
+    def include_feature(feature)
+      migration.include_feature(feature.migration)
+    end
+
+    def remove_feature(feature)
+      raise NotYet
+    end
+
+    # Create a copy of the project in tmp/ and checkout the branch. Used to build
+    # releases. Returns the path to the copy
+    def snapshot() end
+
+    # Sorting
+    def <=>(other) version <=> other.version end
+
+    # Use #name for String conversion
+    def to_s() name end
+
+    # Reads the name of the base release from a node (see Build#node)
+    def self.deref_node_file(node)
+      if File.basename(node) == "0.0.0"
+        nil
+      elsif File.symlink?(node) # Releases and prereleases
+        symlink = Command.command("readlink -v #{node}").first
+        value = File.basename(symlink.sub(/\/$/, ""))
+        value == "/dev/null" ? nil : value
+      elsif File.directory?(node) # Migrations
+        name = File.basename(node)
+        name =~ MIGRATION_RE or raise "Illegal migration name: #{name}"
+        $1
+      end
+    end
+
+  private
+    @states = {
+      exist: [:create, :destroy],
+      initialized: [:exist, :initialize, false], # ???
+      active: [:exist, :checkout, :checkback],
+#     built: [:active, :build, lambda { |this| this.database.recreate } ],
+    }
+  end
+
+  class AbstractRelease < Build
+    # Tag
+    def tag() [version.custom, "v#{version.semver}"].compact.join("-") end
+
+    # Cache object
+    attr_reader :archive
+
+    # Redefine Build#node
+    attr_reader :node
+
+    # The directory representing this release. It is initially empty. It is the
+    # same as the next release's migration directory and contains features that
+    # require this release
+    def release_dir() raise AbstractMethod end
+
+    def initialize(project, base_release, version, migration, **opts)
+      super
+      @node = File.join(RELEASE_DIR, name)
+      @archive = DumpFile.new(project, version.to_s)
+    end
+
+    def cached?() archive.exist? end
+    def cache() database.save(archive.path) end
+    def uncache() FileUtils.rm_f(archive.path) end
+
+    def loaded?() schema.loaded?(database) end
+    def load() database.ensure(:loaded, archive.file) end
+    def unload() database.ensure(:loaded, expect: false) end
+
+    def prepare(commit: true)
+      migration.prepare
+      Git.commit("Prepared next release") if commit
+    end
+
+    def <=>(other) version <=> other.version end
+
+    # Create the release in Git and on the disk
+    def create(create_release_link_file: true)
+      super()
+
+      # Create release link file (eg. releases/0.1.0)
+      if create_release_link_file
+        base_release_dir = (version.zero? ? "/dev/null" : "../#{migration.path}")
+        Dir.chdir(RELEASE_DIR) { 
+          FileUtils.ln_s(base_release_dir, File.basename(node))
+        }
+        Git.add(node)
+      end
+
+      # Set schema version
+      project.schema.version = version
+      Git.add(project.schema.path)
+    end
+
+    def dump
+      return self
+      $stderr.puts "#{self.class} #{version}"
+      $stderr.indent { |f|
+        f.puts "node        : #{node.inspect}"
+        f.puts "base_release: #{base_release&.version.inspect}"
+        f.puts "migration   : #{migration&.path.inspect}"
+        f.puts "release_dir : #{release_dir.inspect}"
+      }
+      self
+    end
+
+  private 
+      @ensure_states = {
+#     cached: [:built, :cache, :uncache],
+      loaded: [:cached, :load, :unload]
+    }
+  end
+
+  class Release < AbstractRelease
+    def release_dir() File.join(FEATURE_DIR, name) end
+
+    def initialize(project, base_release, version)
+      migration = base_release && ReleaseMigration.new(base_release.release_dir)
+      super(project, base_release, version, migration)
+    end
+
+    # Create the release in Git and on the disk. We assume that the migration exists
+    def create
+      super
+
+      # Create migration link file
+      if !version.zero?
+        migration_version = "#{base_release.version}_#{version}"
+        features = "../#{migration.path}"
+        Dir.chdir(MIGRATION_DIR) {
+          FileUtils.ln_s(features, migration_version)
+          Git.add(migration_version)
+        }
+      end
+
+      # Create new empty feature directory
+      ReleaseMigration.new(release_dir).create
+
+      Git.commit("Release #{version}")
+      Git.create_tag(version)
+      dump
+      migration.dump if migration
+      self
+    end
+  end
+
+  # TODO: Rename to PreRelease
+  class Prerelease < AbstractRelease
+    attr_reader :target_release
+
+    def release_dir() base_release.release_dir end
+
+    def initialize(project, base_release, version, target_version = version.truncate(:pre))
+      @target_release = Release.new(project, base_release, target_version)
+      migration = ReleaseMigration.new(target_release.migration.path)
+      super(project, base_release, version, migration)
+    end
+
+    # Create the pre-release in Git and on disk
+    def create
+      super
+      migration.prepare
+      Git.commit("Pre-release #{version}")
+      dump
+      self
+    end
+
+    # Create a migration for this release
+    def prepare_migration
+      base_release.built? or raise "Base release #{base_release} is not built"
+      puts "Prerelease#generate_migration"
+    end
+  end
+
+  class MigrationPrerelease < Prerelease
+    def initialize(project, base_release, version, target_version = version.truncate(:pre))
+      release_dir = "/migrations/..."
+    end
+  end
+
+  class MigrationRelease < AbstractRelease
+    def create
+      # does not call super because migrations belong to the release they migrate to
+      #
+      # code, code, code
+    end
+
+    def include_feature
+      raise NotYet
+    end
+  end
+
+  class Feature < Build
+    # Name of feature
+    def feature() version.feature end
+
+    # A feature's node is the feature directory
+    def node() release_dir end
+
+    def release_dir() migration.path end
+
+    def initialize(project, base_release, name)
+      base_release.is_a?(Release) || base_release.is_a?(Prerelease) or 
+          raise Internal, "Expected a Release object, got #{base_release.class}"
+      version = Version.new(base_release.version, feature: name)
+      migration = FeatureMigration.new(Migration.path(version))
+      super(project, base_release, version, migration)
+    end
+
+    def checkout() 
+      super
+#     FileUtils.ln_sf(feature, "feature")
+    end
+
+    def create
+      super
+      migration.create
+      migration.prepare
+      Git.commit("Created feature #{feature}")
+      migration.dump
+      self
+    end
+
+    # features/
+    #   0.0.0/
+    #     feature_a
+    #     feature_b/
+    #       base_release.prick
+    #       name.yml <- 0.2.0/feature_b
+    #       rebased.yml <- reads base_release here
+    #
+    #   0.2.0/
+    #     feature_a -> 0.0.0/feature_a <- not rebased
+    #     feature_b -> 0.0.0/feature_b <- rebased
+
+
+    def rebase(new_base_release)
+      # Checkout new_base_release
+      # Merge feature
+      # Establish symlinks
+      # Create as branch
+
+#     new_base > base_release or 
+#         raise Error, "Can't rebase from #{base_release.version} to #{new_base.version}"
+#     new_feature = Feature.new(project, base_release, base.version, base: base)
+#     new_feature.ensure(:active)
+#     schema.version = version
+#     FileUtils.ln_sf("../#{feature.release_dir}", new_feature.release_dir)
+#     Git.add(new_feature.release_dir)
+#     new_feature
+    end
+  end
+end