prick 0.2.0

data/lib/prick/project.rb

@@ -0,0 +1,444 @@
+
+require "prick/constants.rb"
+
+require "prick/archive.rb"
+require "prick/build.rb"
+require "prick/migration.rb"
+require "prick/database.rb"
+require "prick/schema.rb"
+require "prick/git.rb"
+require "prick/migra.rb"
+
+require 'fileutils'
+
+module Prick
+  class Project
+    # Name of project. Used in database and release names. Defaults to the name
+    # of the current directory
+    attr_reader :name
+
+    # Name of Postgresql user that own the database(s). Defaults to #name
+    attr_reader :user
+
+    # Schema. Represents the schema definition under the schemas/ directory
+    attr_reader :schema
+   
+    # The current release, prerelease or feature
+    def release() @builds_by_name[Git.current_branch] end
+
+    # The project database. The project database has the same name as the project
+    # and doesn't include a version. It does not have to exist
+    attr_reader :database
+
+    # List of all builds
+    def builds() @builds_by_name.values end
+
+    # List of releases ordered from oldest to newest. Custom releases are sorted
+    # after regular releases and alphabetical between themselves
+    attr_reader :releases
+
+    # List of pre-releases
+    attr_reader :prereleases
+
+    # Hash from base-release name to feature. Note that this doesn't follow release history
+    attr_reader :features
+
+    # Ignored and orphaned objects
+    attr_reader :ignored_feature_nodes
+    attr_reader :ignored_release_nodes
+    attr_reader :orphan_feature_nodes
+    attr_reader :orphan_release_nodes
+    attr_reader :orphan_git_branches
+
+    # True if we're on a release branch
+    def release?() release && release.version.pre.nil? && !feature? end
+
+    # True if we're on a pre-release branch
+    def prerelease?() release && !release.version.pre.nil? && !feature? end
+
+    # True if we're on a feature branch
+    def feature?() release && !release.version.feature.nil? end
+
+    # Sorted list of databases associated with a release. Also include the
+    # project database if project. is true. If all: is true, also list
+    # databases that match the project but is without an associated release
+    def databases(all: false, project: true)
+      r = (project ? [database] : [])
+      if all
+        r + Rdbms.list_databases(Prick.database_re(name)).map { |name| Database.new(name, user) }
+      else
+        r + @releases.map(&:database)
+      end
+    end
+
+    # `name` is the project name and `user` is the name of the Postgresql user.
+    # `name` defaults to the name of the current directory and `user` defaults
+    # to `name`
+    def initialize(name = nil, user = nil)
+      @name = name || File.basename(Dir.getwd)
+      @name =~ PROJECT_NAME_RE or raise Error, "Illegal project name: #@name"
+      @user = user || @name
+      @user =~ USER_NAME_RE or raise Error, "Illegal postgres user name: #@user"
+#     Rdbms.ensure_state(:user_exist, @user)
+      Rdbms.create_user(@user) if !Rdbms.exist_user?(@user) # FIXME
+      @schema = Schema.new(self)
+      @database = Database.new(@name, @user)
+
+      @builds_by_name = {}
+      @builds_by_version = {}
+
+      @releases = []
+      @prereleases = []
+      @features = {}
+
+      @ignored_feature_nodes = []
+      @ignored_release_nodes = []
+
+      @orphan_feature_nodes = []
+      @orphan_release_nodes = [] # Includes prereleases
+
+      @orphan_git_branches = []
+
+      load_project
+    end
+
+    def [](name_or_version) 
+      name = version = name_or_version
+      case name_or_version
+        when String; @builds_by_name[name]
+        when Version; @builds_by_version[version]
+        when NilClass; nil
+      else
+        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+      end
+    end
+
+    def []=(name_or_version, branch)
+      case name_or_version
+        when String; 
+          name = name_or_version
+          version = Version.new(name)
+        when Version
+          version = name_or_version
+          name = version.to_s
+      else
+        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+      end
+      @builds_by_name[name] = @builds_by_version[version] = branch
+    end
+
+    def dirty?() !Git.clean? end
+
+    def build?(name_or_version) 
+      name = version = name_or_version
+      case name_or_version
+        when String; @builds_by_name.key?(name)
+        when Version; @builds_by_version.key?(version)
+        when NilClass; nil
+      else
+        raise Internal, "Expected String or Version index, got #{name_or_version.class}"
+      end
+    end
+
+    # Initialize an on-disk prick instance
+    def self.initialize_directory(directory)
+      FileUtils.mkdir_p(directory)
+      Dir.chdir(directory) {
+        DIRS.each { |dir| 
+          !File.exist?(dir) or raise Fail, "Already initialized: Directory '#{dir}' exists"
+        }
+
+        FileUtils.mkdir_p(DIRS)
+        DIRS.each { |dir| FileUtils.touch("#{dir}/.keep") }
+      }
+    end
+
+    # Create an initial release 0.0.0. ::initialize_project expects to be executed
+    # in the project directory
+    def self.initialize_project(name = File.basename(Dir.getwd), user = name || ENV['USER'])
+      FileUtils.cp("#{SHARE_PATH}/gitignore", ".gitignore")
+      FileUtils.cp("#{SHARE_PATH}/schemas/prick/schema.sql", "schemas/prick")
+      FileUtils.cp("#{SHARE_PATH}/schemas/prick/data.sql", "schemas/prick")
+      Git.init
+      Git.add(".")
+      Git.commit("Initial import")
+      project = Project.new(name, user)
+      release = Release.new(project, nil, Version.new("0.0.0"))
+      release.create
+
+      Git.delete_branch("master")
+    end
+
+    # Returns the full path to the project directory (TODO: Test)
+    def path() File.expand_path(".") end
+
+    ### COMMON METHODS
+
+    def checkout(name)
+      check_clean
+      Git.checkout_branch(name)
+    end
+
+    # Migrate the database from its current version to the current release on disk
+    def migrate
+      check_clean
+      database.exist? or raise "Project database not found"
+      history = release.history.keys.reverse.drop(1)
+      history.select! { |release| release.version >= database.version }
+      history.each { |release| release.migration.migrate(database.name) }
+      database.version = release.version
+    end
+
+    ### DEVELOPER-LEVEL METHODS
+
+    # Create and switch to feature branch
+    def feature(name)
+      check_clean
+      release? or raise Error, "Need to be on a release branch to create a feature"
+      feature = Feature.new(self, release, name).ensure(:active)
+      Git.commit "Created feature #{name}"
+    end
+
+    def rebase(version)
+      check_clean
+      feature? or raise Error, "Need to be on a feature branch to rebase"
+      release.rebase(version)
+      Git.commit "Rebased to #{version}"
+    end
+
+    ### RELEASE MANAGER LEVEL METHODS
+
+    # Create the first prerelease
+    #
+    # TODO Make it just copy files and commit them. Supports a single-user
+    # workflow. Requires a :prepared state
+    def prepare_release
+      check_clean
+      release? or raise Error, "Need to be on a release branch to prepare a new release"
+      release.prepare
+    end
+
+    def prepare_migration
+      check_clean
+      prerelease? || feature? or raise Error, "Need to be on a prerelease or feature branch to include features"
+
+      base_database = release.base_release.database
+      build(base_release.version) if !base_database.loaded?
+      build # if !database.loaded?
+
+      diff_sql = release.migration.diff_sql
+      Migra.migrate(base_database.name, database.name, diff_sql)
+    end
+
+    def create_release(version = nil)
+      check_clean
+      if release?
+        !version.nil? or raise Error, "Need version argument when on a release branch"
+        new_release = Release.new(self, release, version)
+      elsif prerelease?
+        version.nil? or raise Error, "Can't use version argument when on a pre-release branch"
+        new_release = release.target_release
+      else
+        raise Error, "Need to be on a release or pre-prelease branch to create a new release"
+      end
+      new_release.create
+      new_release
+    end
+
+    def create_prerelease(target_version)
+      check_clean
+      release? or raise Error, "Need to be on a release branch to create a pre-release"
+      prerelease = Prerelease.new(self, release, target_version.increment(:pre, 0), target_version)
+      prerelease.create
+    end
+
+    def increment_prerelease
+      check_clean
+      prerelease? or raise Error, "Need to be on a pre-release branch to make an incremental pre-release"
+      prerelease = Prerelease.new(self, release.base_release, release.version.increment(:pre))
+      prerelease.create
+    end
+
+    def create_feature(name)
+      check_clean
+      release? or raise Error, "Need to be on a release branch to create a feature"
+      feature = Feature.new(self, release, name)
+      feature.create
+    end
+
+    # Note: Does not commit
+    def include_feature(feature_version)
+      check_clean
+      prerelease? || feature? or raise Error, "Need to be on a prerelease or feature branch to include features"
+      Git.branch?(feature_version) or raise Error, "Can't find branch #{feature_version}"
+      release.include_feature(self[feature_version])
+    end
+
+    def commit_feature
+      msg = File.readlines(".git/MERGE_MSG").first.chomp
+      Git.commit msg
+#     Command.command "git commit -F .git/MERGE_MSG"
+    end
+
+    def create_migration
+    end
+
+    # Build the current database from the content of schema
+    def build(version = nil)
+      if version.nil?
+        database.recreate
+        schema.build 
+      else
+        release = self[version] or raise Error, "Can't find release #{version}"
+        release.database.recreate
+        FileUtils.mkdir_p(CACHE_DIR)
+        if !File.directory?(File.join(CLONE_DIR, ".git"))
+          FileUtils.rm_rf(CLONE_DIR)
+          Command.command "git clone . #{CLONE_DIR}"
+        end
+        Dir.chdir(CLONE_DIR) {
+          Git.checkout_tag(version.to_s)
+          project = Project.new(name, user)
+          release.database.recreate
+          project.schema.build(release.database)
+        }
+        release.cache
+      end
+    end
+
+    # Load file into current database
+    def use_database(file = nil)
+      check_clean
+      File.file?(file) or raise Error, "Can't find #{file}"
+      database.recreate
+      database.load(file)
+    end
+
+    # Load file into the given database version. If version is nil the current
+    # database is used. If file is nil, the database associated with the given
+    # version is used. Not both version and file can be nil
+    def load_database(version, file = nil)
+      check_clean
+      !version.nil? || !file.nil? or raise Fail, "Not both version and file can be nil"
+      if version
+        release = self[version]
+        file ||= release.archive.path
+        File.file?(file) or raise Error, "Can't find #{file}"
+        release.database.recreate
+        release.database.load(file)
+      else
+        database.recreate
+        database.load(file)
+      end
+    end
+
+#   def reload_release(version, *file) 
+#     lookup(version).reload(*file) 
+#   end
+#
+#   def unload(version = nil) 
+#     if version
+#       lookup(version).database.drop
+#     else
+#       databases.each(&:drop) 
+#     end
+#   end
+#
+    # Remove temporary files and databases
+    def cleanup(version = nil, project: false)
+      if version
+        release = self[version]
+        release.archive.delete
+        release.database.drop
+      else
+        FileUtils::rm_rf CLONE_DIR
+        FileUtils::rm_f Dir.glob(File.join(CACHE_DIR, Prick.dump_glob(name)))
+        databases(all: true, project: project).each(&:drop)
+      end
+    end
+
+  private
+    def check_clean()
+      !dirty? or raise "Repository is dirty. Commit your changes and try again"
+    end
+
+    # For debug
+    def dump_deps(deps)
+      deps.each { |k,v|
+        puts "  #{k} -> #{v || 'nil'}"
+      }
+    end
+
+    def load_project
+      # Maps from version to base release version
+      releases = { Version.zero => nil }
+      prereleases = {}
+      features = {}
+
+      # Collect branches from git
+      Git.list_branches.each { |branch|
+        if Version.version?(branch)
+          version = Version.new(branch)
+          if version.feature?
+            features[version] = version.truncate(:feature)
+          elsif version.pre?
+            prereleases[version] = nil
+          elsif version.release?
+            releases[version] = nil
+          else
+            raise Internal, "Unexpected state for #{version}"
+          end
+        else
+          @orphan_git_branches << branch
+        end
+      }
+
+      # Find base release for present releases and prereleases
+      Dir.each_child(RELEASE_DIR) { |node|
+        next if node.start_with?(".")
+        if Version.version?(node)
+          version = Version.new(node)
+          if releases.key?(version)
+            base_release = Build.deref_node_file(File.join(RELEASE_DIR, node))
+            releases[version] = base_release
+          elsif prereleases.key?(version)
+            base_release = Build.deref_node_file(File.join(RELEASE_DIR, node))
+            prereleases[version] = base_release
+          else
+            @orphan_release_nodes << node
+          end
+        else !prerelease_deps.key?(node)
+          @ignored_release_nodes << node
+        end
+      }
+
+      releases.sort_by { |k,v| k }.each { |release, base_release|
+        @releases << Release.new(self, self[base_release], release)
+      }
+      @releases.sort!
+
+      prereleases.each { |prerelease, base_release|
+        if base_release
+          @prereleases << Prerelease.new(self, self[base_release], prerelease)
+        else
+          @ignored_release_nodes << prerelease
+        end
+      }
+      @prereleases.sort!
+
+      if !Git.detached?
+        features.each { |feature, base_release|
+#       if File.exist?(base_release_file)
+#         recursive include of dependent releases
+
+          if base_release
+            (@features[base_release] ||= []) << Feature.new(self, self[base_release], feature.feature)
+          else
+            @ignored_release_nodes << release
+          end
+        }
+      end
+    end
+  end
+end
+

data/lib/prick/rdbms.rb

@@ -0,0 +1,147 @@
+require 'prick/command.rb'
+require 'prick/ensure.rb'
+
+require 'csv'
+
+module Prick
+  module Rdbms
+    extend Ensure
+
+    ### EXECUTE SQL
+
+    # Execute the SQL statement and return stdout as an array of tuples
+    def self.exec_sql(db, sql, user: ENV['USER'])
+      stdout = Command.command %(
+        {
+          echo "set role #{user};"
+          echo "set search_path to public;"
+          echo "#{sql}"
+        } | psql --csv --tuples-only --quiet -v ON_ERROR_STOP=1 -d #{db}
+      )
+      CSV.new(stdout.join("\n")).read
+    end
+
+    # Execute the given file and return stdout as an array of tuples
+    def self.exec_file(db, file, user: ENV['USER'])
+      self.exec_sql(db, File.read(file), user: user)
+    end
+
+    # Execute the SQL statement and return the result as an array of record tuples
+    # Just an alias for ::exec_sql
+    def self.select(db, sql, user: ENV['USER']) exec_sql(db, sql, user: user) end
+
+    # Execute the SQL statement and return an array of values, one for each
+    # single-valued record in the result. Raises an exception if the SQL
+    # statement doesn't return records with exactly one field
+    def self.select_values(db, sql, user: ENV['USER'])
+      records = exec_sql(db, sql, user: user)
+      return [] if records.empty?
+      records.first.size == 1 or raise Prick::Fail, "Expected records with one field"
+      records.flatten
+    end
+
+    # Execute the SQL statement and return a single record as an array of values.
+    # Raises an exception if the SQL statement doesn't return exactly one
+    # record
+    def self.select_record(db, sql, user: ENV['USER'])
+      records = exec_sql(db, sql, user: user)
+      records.size == 1 or raise Prick::Fail, "Expected one row only"
+      records.first
+    end
+
+    # Execute the SQL statement and return a value. The value is the first
+    # field of the first record in the result. Raises an exception if the SQL
+    # statement doesn't return exactly one record with one field
+    def self.select_value(db, sql, user: ENV['USER'])
+      row = select_record(db, sql, user: user)
+      row.size == 1 or raise Prick::Fail, "Expected one field only"
+      row.first
+    end
+
+    ### DETECT SCHEMAS, TABLES, AND RECORDS
+
+    def self.exist_schema?(db, schema)
+      exist_record?(db, %(
+          select 1
+          from information_schema.schemata
+          where catalog_name = '#{db}'
+          and schema_name = '#{schema}'
+      ))
+    end
+
+    def self.exist_table?(db, schema, table)
+      exist_record?(db, %(
+          select 1
+          from information_schema.tables
+          where table_schema = '#{schema}'
+          and table_name = '#{table}'
+      ))
+    end
+
+    def self.exist_record?(db, sql)
+      !select(db, sql).empty?
+    end
+
+    ### MAINTAIN USERS AND DATABASES
+
+    def self.exist_user?(user)
+      exist_record?("template1", "select 1 from pg_roles where rolname = '#{user}'")
+    end
+
+    def self.create_user(user)
+      Command.command("createuser #{user}")
+    end
+
+    def self.drop_user(user, fail: true)
+      Command.command "dropuser #{user}", fail: fail
+    end
+
+    def self.exist_database?(db)
+      exist_record?("template1", "select 1 from pg_database where datname = '#{db}'")
+    end
+
+    # TODO: make `owner` an option
+    def self.create_database(db, owner: ENV['USER'], template: "template1") 
+      owner_option = (owner ? "-O #{owner}" : "")
+      Command.command "createdb -T #{template} #{owner_option} #{db}" 
+    end
+
+    def self.copy_database(from, to, owner: ENV['USER'])
+      create_database(to, owner: owner, template: from)
+    end
+
+    def self.drop_database(db, fail: true) 
+      Command.command "dropdb #{db}", fail: fail
+    end
+
+    def self.list_databases(re = /.*/)
+      select_values("template1", "select datname from pg_database").select { |db| db =~ re }
+    end
+
+    def self.load(db, file, user: ENV['USER'])
+      Command.command %(
+        {
+            echo "set role #{user};"
+            gunzip --to-stdout #{file}
+        } | psql -v ON_ERROR_STOP=1 -d #{db}
+      )
+    end
+
+    def self.save(db, file, data: true)
+      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
+
+