prick 0.2.0 → 0.7.0

data/lib/prick/program.rb

@@ -0,0 +1,493 @@
+
+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
+
+    def initialize(quiet: false, verbose: false)
+      @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: 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}'"
+      subj_mesg = file ? file : "cache"
+      project.save(database, file: file)
+      mesg "Saved #{database} to #{subj_mesg}"
+    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)
+      raise NotYet
+    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) 
+      file = file || File.join(SPOOL_DIR, "#{project.name}-#{Time.now.utc.strftime("%Y%m%d-%H%M%S")}.sql.gz")
+      project.save(file: file) 
+      mesg "Backed-up database to #{file}"
+    end
+
+    def restore(file_arg = nil)
+      file = file_arg || Dir.glob(File.join(SPOOL_DIR, "#{name}-*.sql.gz")).sort.last
+      File.exist?(file) or raise Error, "Can't find #{file_arg || "any backup file"}"
+      project.load(file: file)
+      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
+
+    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
+