prick 0.19.0 → 0.20.1

data/lib/prick/program.rb

@@ -1,287 +0,0 @@
-
-require "pg_conn"
-require "prick.rb"
-
-module Prick
-  # Implements the command line commands
-  class Program
-    # Lazy-constructed because Project can only be initialized when the
-    # directory structure is present
-    def project() @project ||= Project.load end
-
-    attr_accessor :quiet
-    attr_accessor :verbose
-    attr_accessor :current_directory # Path to the directory where prick was called from
-
-    def initialize(current_directory = Dir.getwd, quiet: false, verbose: false)
-      @current_directory = current_directory
-      @quiet = quiet
-      @verbose = verbose
-    end
-
-    # Check if the git repository is clean. Raise an error if not
-    def check_clean() 
-      Git.clean? or raise Error, "Repository is dirty - please commit your changes first" 
-    end
-
-    # Create project directory structure
-    def init(name, user, directory)
-      !Project.exist?(directory) or raise Error, "Directory #{directory} is already initialized"
-      Project.create(name, user, directory)
-      if name != directory
-        mesg "Initialized project #{name} in #{directory}"
-      else
-        mesg "Initialized project #{name}"
-      end
-    end
-
-    def info
-      if project.tag?
-        puts "At v#{project.version} tag"
-      else
-        puts "On branch #{project.head.name}, #{project.version}"
-      end
-      puts "  Git is " + (Git.clean? ? "clean" : "dirty")
-      bv = project.head.version
-      dv = project.database.version
-      sv = project.head.schema.version
-      puts "  Database version: #{dv}" + (dv != bv ? " (mismatch)" : "")
-      puts "  Schema version  : #{sv}" + (sv != bv ? " (mismatch)" : "")
-    end
-
-    def list_releases(migrations: false, cancelled: false)
-      raise NotYet
-    end
-
-    def list_migrations
-      raise NotYet
-    end
-
-    def list_upgrades(from = nil, to = nil)
-      raise NotYet
-    end
-
-    def list_cache
-      project.cache.list.each { |l| puts l }
-    end
-
-    def build(database, version, state_file, nocache)
-      into_mesg = database && "into #{database}"
-      version_mesg = version ? "v#{version}" : "current schema"
-      version &&= Version.new(version)
-      version.nil? || Git.tag?(version) or raise Error, "Can't find tag v#{version}"
-      database = database ? Database.new(database, project.user) : project.database(version)
-      drop_users(database.name)
-      Builder.state_file = state_file
-      project.build(database, version: version)
-      project.save(database) if version && !nocache
-      mesg "Built", version_mesg, into_mesg
-    end
-
-    def make(database, version, nocache)
-      version &&= Version.new(version)
-      version.nil? || Git.tag?(version) or raise Error, "Can't find tag v#{version}"
-      if !nocache && version && project.cache.exist?(version)
-        load(database, version)
-      else
-        build(database, version, nocache)
-      end
-    end
-
-    def make_clean(all)
-      project.cache.clean.each { |file| mesg "Removed cache file #{File.basename(file)}" }
-      drop(nil, all)
-    end
-
-    def load(database, file_or_version)
-      check_owned(database) if database
-      into_mesg = database && "into #{database}"
-      if version = Version.try(file_or_version)
-        database = database ? Database.new(database, project.user) : project.database(version)
-        project.load(database, version: version)
-        mesg "Loaded v#{version}", into_mesg, "from cache"
-      else 
-        file = file_or_version
-        project.load(database, file: norm_path(file))
-        mesg "Loaded #{File.basename(file)}", into_mesg
-      end
-    end
-
-    def save(version, file)
-      database = project.database(version)
-      database.exist? or raise "Can't find database '#{database}'"
-      project.save(database, file: norm_path(file))
-      mesg "Saved #{database} to #{file || 'cache'}"
-    end
-
-    def drop(database, all)
-      database.nil? || !all or raise Error, "Can't use --all when database is given"
-      return if !Rdbms.exist_database?(database)
-      if database
-        check_owned(database)
-        dbs = [database]
-      else
-        dbs = Rdbms.list_databases(Prick.database_re(project.name))
-        dbs << project.name if all && project.database.exist?
-      end
-      dbs += Rdbms.list_databases(Prick.tmp_databases_re(project.name)) # FIXME: Only used in dev
-      dbs.each { |db|
-        Rdbms.drop_database(db)
-        drop_users db
-        mesg "Dropped database #{db}"
-      }
-    end
-
-    # Drop all users that follows the per-database-user naming convention
-    # ("<database>__<username>")
-    def drop_users(database)
-      PgConn.new("postgres") { |postgres|
-        users = postgres.role.list.grep(/^#{database.sub(/-/, "_")}__/)
-        if postgres.rdbms.exist?(database)
-          PgConn.new(database) { |conn| conn.role.drop users, cascade: true }
-        else
-          postgres.role.drop users
-        end
-      }
-    end
-
-    # `select` is a tri-state variable that can be :tables, :no_tables, or :all
-    # (or any other value)
-    def diff(from, to, mark, select)
-      diff = project.diff(from && Version.new(from), to && Version.new(to))
-      if !diff.same?
-        if select != :tables && !diff.before_table_changes.empty?
-          puts "-- BEFORE TABLE CHANGES" if mark
-          puts diff.before_table_changes
-        end
-        if select != :no_tables && !diff.table_changes.empty?
-          puts "-- TABLE CHANGES" if mark
-          puts diff.table_changes
-        end
-        if select != :tables && !diff.after_table_changes.empty?
-          puts "-- AFTER TABLE CHANGES" if mark
-          puts diff.after_table_changes
-        end
-      end
-    end
-
-    def migrate
-      raise NotYet
-    end
-
-    def prepare_release(fork)
-      project.prepare_release(fork)
-    end
-
-    def prepare_feature(name)
-      raise NotYet
-    end
-
-    def prepare_migration(from = nil)
-      raise NotYet
-    end
-
-    def prepare_schema(name)
-      project.prepare_schema(name)
-    end
-
-    def prepare_diff(version = nil)
-      # Helpful check to ensure the user has built the current version
-#     Diff.same?(to_db, database) or 
-#         raise Error, "Schema and project database are not synchronized"
-
-      project.prepare_diff(version || project.version)
-      if FileUtils.compare_file(TABLES_DIFF_PATH, TABLES_DIFF_SHARE_PATH)
-        mesg "Created diff. No table changes found, no manual migration updates needed"
-      else
-        mesg "Created diff. Please inspect #{TABLES_DIFF_PATH} and incorporate the"
-        mesg "changes in #{MIGRATION_DIR}/migrate.sql"
-      end
-    end
-
-    def include(name)
-      raise NotYet
-    end
-
-    def check
-      version ||= 
-          if project.prerelease? || project.migration?
-            project.branch.base_version
-          else
-            project.branch.version
-          end
-      project.check_migration(version)
-    end
-
-    def create_release(version = nil)
-      if project.prerelease_branch?
-        raise NotYet
-      elsif project.release_branch?
-        project.create_release(Version.new(version))
-      else
-        raise Error, "You need to be on a release or pre-release branch to create a new release"
-      end
-      mesg "Created release v#{project.head.version}"
-    end
-
-    def create_prerelease(version = nil)
-      raise NotYet
-    end
-
-    def create_feature(name)
-      raise NotYet
-    end 
-
-    def cancel(version)
-      raise NotYet
-    end
-
-    def generate_schema
-      project.generate_schema
-    end
-
-    def generate_migration
-      project.generate_migration
-    end
-
-    def upgrade
-      raise NotYet
-    end
-
-    # TODO: Create a Backup class and a Project#backup_store object
-    def backup(file = nil) 
-      path = norm_path(file) || 
-          File.join(SPOOL_DIR, "#{project.name}-#{Time.now.utc.strftime("%Y%m%d-%H%M%S")}.sql.gz")
-      project.save(file: path) 
-      mesg "Backed-up database to #{file}"
-    end
-
-    def restore(file = nil)
-      path =  norm_path(file) || Dir.glob(File.join(SPOOL_DIR, "#{name}-*.sql.gz")).sort.last
-      File.exist?(path) or raise Error, "Can't find #{file || "any backup file"}"
-      project.load(file: path)
-      mesg "Restored database from #{file}"
-    end
-
-  protected
-    def check_owned(database)
-      database =~ ALL_DATABASES_RE or raise Error, "Not a prick database: #{database}"
-      project_name = $1
-      project_name == project.name or raise Error, "Database not owned by this prick project: #{database}"
-    end
-
-    # Expand relative path with respect to the directory where prick was called
-    # from. Return nil if file is nil
-    def norm_path(file)
-      if file && !file.start_with?("/")
-        File.join(current_directory, file)
-      else
-        file
-      end
-    end
-
-    def mesg(*args) puts args.compact.grep(/\S/).join(' ') if !quiet end
-    def verb(*args) puts args.compact.grep(/\S/).join(' ') if verbose end
-  end
-end
-