prick 0.18.0 → 0.20.2

data/lib/prick/program.rb

@@ -1,506 +0,0 @@
-
-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, 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)
-      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"
-      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)
-        mesg "Dropped database #{db}"
-      }
-    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
-
-__END__
-
-
-module Prick
-  class Program
-    def project() @project ||= Project.load end
-
-    attr_accessor :quiet
-    attr_accessor :verbose
-
-    def initialize(quiet: false, verbose: false)
-      @quiet = quiet
-      @verbose = verbose
-    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
-    def check_clean() Git.clean? or raise Error, "Repository is dirty - please commit your changes first" end
-
-    def initialize_directory(project_name, database_user, directory)
-      !Project.initialized?(directory) or raise Error, "Directory #{directory} is already initialized"
-      Project.initialize_directory(project_name, database_user, directory)
-      if project_name != File.basename(directory)
-        mesg "Initialized project #{project_name} in #{directory}"
-      else
-        mesg "Initialized project #{project_name}"
-      end
-    end
-
-    def info
-      if project.tag?
-        puts "At v#{project.version} tag"
-      else
-        puts "On branch #{project.branch.name}"
-      end
-      puts "  Git is " + (Git.clean? ? "clean" : "dirty")
-      bv = project.branch.version
-      dv = project.database.version
-      sv = project.branch.schema.version
-      puts "  Database version: #{dv}" + (dv != bv ? " (mismatch)" : "")
-      puts "  Schema version  : #{sv}" + (sv != bv ? " (mismatch)" : "")
-    end
-
-    # TODO: Move to project to take advantage of cache
-    def build(database, version, no_cache)
-      version = version && Version.new(version)
-      into_mesg = database && "into #{database}" 
-      database = database ? Database.new(database, project.user) : project.database(version)
-      if version
-        Git.tag?(version) or raise Error, "Can't find tag v#{version}"
-        cache_file = project.cache_file(version)
-        if !no_cache && File.exist?(cache_file)
-          project.load(cache_file, database: database)
-          mesg "Loaded v#{version}", into_mesg, "from cache"
-        else
-          project.build(database: database, version: version)
-          project.save(cache_file, database: database)
-          mesg "Built v#{version}", into_mesg
-        end
-      else
-        project.build(database: database)
-        mesg "Built current schema", into_mesg
-      end
-    end
-
-    def load(database, file_or_version)
-      version = Version.try(file_or_version)
-      into_mesg = database && "into #{database}" 
-      database = database ? Database.new(database, project.user) : project.database(version)
-      if version
-        file = project.cache_file(version)
-        File.exist?(file) or raise Error, "Can't find #{file} - forgot to build?"
-        project.load(file, database: database)
-        mesg "Loaded v#{version}", into_mesg
-      else
-        file = file_or_version
-        project.load(file, database: database)
-        mesg "Loaded #{file}", into_mesg
-      end
-    end
-
-    def save(database, file)
-      file ||= "#{ENV['USER']}-#{name}-#{branch}.sql.gz"
-      subject_mesg = database ? "database #{database}" : "current database"
-      database = database ? Database.new(database, project.user) : project.database(version)
-      project.save(file, database: database)
-      mesg "Saved", subject_mesg, "to #{file}"
-    end
-
-    def make(subject)
-      project.database.exist? or raise Error, "Project database is not present"
-      project.make(project.database, subject)
-    end
-
-    def list_releases(migrations: false, cancelled: false)
-      puts (project.list_releases(all: cancelled) + (migrations ? project.list_migrations : [])).sort.map(&:name)
-    end
-
-    def list_migrations
-      puts project.list_migrations.sort.map(&:name)
-    end
-
-    def list_upgrades(from = nil, to = nil)
-      from = from ? Version.new(from) : project.database.version
-      to = to ? Version.new(to) : project.branch.version
-      branches = project.list_upgrades(from, to)
-      puts branches.map(&:name)
-    end
-
-    def prepare_schema(name)
-      project.prepare_schema(name)
-      mesg project.message
-    end
-
-    def prepare_diff(version = nil)
-      version ||= 
-          if project.prerelease? || project.migration? || project.feature?
-            project.branch.base_version
-          else
-            project.branch.version
-          end
-      project.prepare_diff(version)
-      mesg "Remember to update the associated SQL migration files"
-    end
-
-    def prepare_release
-      check_clean
-      project.version.release? or raise Error, "You need to be on a release branch to prepare a release"
-      project.prepare_release
-      mesg project.message
-    end
-
-    def check
-      version ||= 
-          if project.prerelease? || project.migration?
-            project.branch.base_version
-          else
-            project.branch.version
-          end
-      project.check_migration(version)
-    end
-
-    # `arg` can be a version numer of a relative increase (eg. 'minor')
-    def create_release(arg = nil)
-      check_clean
-      if project.release?
-        arg or raise Error, "Need a version argument"
-        version = compute_version(project.version, arg)
-        project.create_release(Version.new(version))
-        mesg project.message
-      elsif project.prerelease?
-        arg.nil? or raise Error, "Illegal number of arguments"
-        project.create_release_from_prerelease
-        mesg project.message
-      else
-        raise Error, "You need to be on a release or pre-release branch to create a new release"
-      end
-    end
-
-    def cancel_release(arg)
-      project.cancel_release(Version.new(arg))
-    end
-
-    def create_prerelease(arg)
-      check_clean
-      if project.release?
-        version = %w(major minor patch).include?(arg) ? project.version.increment(arg.to_sym) : Version.new(arg)
-        project.prepare_release(commit: false)
-        prerelease = project.create_prerelease(version)
-        mesg "Created pre-release #{prerelease.version}"
-      elsif project.prerelease?
-        arg.nil? or raise Error, "Illegal number of arguments"
-        prerelease = project.increment_prerelease
-        mesg "Created pre-release #{prerelease.prerelease_version}"
-      else
-        raise Error, "You need to be on a release branch to create a pre-release"
-      end
-    end
-
-    def prepare_migration(arg)
-      check_clean
-      version = Version.new(arg)
-      project.release? or raise "You need to be on a release or migration branch to prepare a migration"
-      project.prepare_migration(version)
-      mesg project.message
-    end
-
-    def create_feature(name)
-      check_clean
-      project.release? or raise "You ned to be on a release branch to create a feature"
-      project.create_feature(name)
-      mesg "Created feature '#{name}'"
-    end
-
-    def include_feature(name_or_version)
-      check_clean
-      project.prerelease? or raise Error, "You need to be on a pre-release branch to include a feature"
-      version = Version.try(name_or_version) || 
-          Version.new(project.branch.base_version, feature: name_or_version)
-      Git.branch?(version.to_s) or raise Error, "Can't find feature #{version}"
-      project.include_feature(version)
-      mesg "Included feature '#{name_or_version}'"
-      mesg "Please resolve eventual conflicts and then commit"
-    end
-
-    def upgrade
-      # TODO: Shutdown connections
-      project.database.version != project.version or raise Error, "Database already up to date"
-      project.backup
-      begin
-        project.upgrade
-      rescue RuntimeError
-        project.restore
-        raise Fail, "Failed upgrading database, rolled back to last version"
-      end
-    end
-
-    def backup(file = nil) project.backup(file) end
-
-    def restore(file = nil)
-      file.nil? || File.exist?(file) or raise Error, "Can't find #{file}"
-      project.restore(file)
-    end
-
-  private
-    def compute_version(version, arg)
-      if arg.nil?
-        nil
-      elsif %w(major minor patch).include?(arg)
-        version.increment(arg.to_sym)
-      else
-        Prick::Version.new(arg)
-      end
-    end
-  end
-end
-