migration_bundler 1.3.0

data/lib/migration_bundler/project.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'uri'
+
+module MigrationBundler
+  class Project
+    class << self
+      def load(path = Dir.pwd)
+        @project ||= proc do
+          project_path = File.join(path, '.migration_bundler.yml')
+          raise "fatal: Not a migration_bundler repository: no .migration_bundler.yml" unless File.exists?(project_path)
+          options = YAML.load(File.read(project_path))
+          new(options)
+        end.call
+      end
+
+      def set(options)
+        @project = new(options)
+      end
+
+      def clear
+        @project = nil
+      end
+    end
+
+    attr_accessor :name, :config, :database_url, :targets
+
+    def initialize(options = {})
+      options.each { |k,v| send("#{k}=", v) }
+    end
+
+    def database_url=(database_url)
+      @database_url = database_url ? URI(database_url) : nil
+    end
+
+    def database
+      database_url.scheme || 'sqlite'
+    end
+
+    def schema_path
+      "#{name}" + database_class.migration_ext
+    end
+
+    def migrations_path
+      "migrations"
+    end
+
+    def git_url
+      `git config remote.origin.url`.chomp
+    end
+
+    def git_latest_tag
+      git_tag_for_version(nil)
+    end
+    
+    def git_current_branch
+      `git symbolic-ref --short HEAD`.chomp
+    end
+
+    def git_tag_for_version(version)
+      pattern = version && "#{version}*"
+      tag = `git tag -l --sort=-v:refname #{pattern} | head -n 1`.chomp
+      tag.empty? ? nil : tag
+    end
+
+    def git_user_email
+      `git config user.email`.chomp
+    end
+
+    def git_user_name
+      `git config user.name`.chomp
+    end
+
+    def save!(path)
+      project_path = File.join(path, '.migration_bundler.yml')
+      File.open(project_path, 'w') { |f| f << YAML.dump(self.to_hash) }
+    end
+
+    def database_class
+      MigrationBundler::Util.database_named(database)
+    end
+
+    def database_target_class
+      MigrationBundler::Util.target_classes_named(database)[0]
+    end
+
+    def to_hash
+      { "name" => name, "config" => config, "database_url" => database_url.to_s, "targets" => targets }
+    end
+  end
+end

data/lib/migration_bundler/targets/base.rb

@@ -0,0 +1,85 @@
+module MigrationBundler
+  module Targets
+    class Base < Thor
+      include Thor::Actions
+      include MigrationBundler::Actions
+      add_runtime_options!
+
+      class << self
+        def source_root
+          File.join File.dirname(__FILE__), name
+        end
+
+        def name
+          "#{self}".split('::').last.gsub(/Target$/, '').downcase
+        end
+
+        def register_with_cli(cli)
+          # Allows targets a chance to configure the CLI
+          # This is an ideal place to register any options, tweak description, etc.
+        end
+      end
+
+      attr_reader :project, :database, :migrations
+
+      # Target Command
+
+      desc "init", "Initializes the target."
+      def init
+        # Default implementation does nothing
+      end
+
+      desc "new NAME", "Create a new migration"
+      def new(path)
+        # Default implementation does nothing
+      end
+
+      desc "generate", "Generates a platform specific package."
+      def generate
+        # Default implementation does nothing
+      end
+
+      desc "push", "Pushes a built package."
+      def push
+        # Default implementation does nothing
+      end
+
+      desc "push", "Validates the environment."
+      def validate
+        # Default implementation does nothing
+      end
+
+      desc "dump", "Dumps the schema"
+      def dump
+        # Default implementation does nothing
+      end
+
+      desc "load", "Loads the schema"
+      def load
+        # Default implementation does nothing
+      end
+      
+      desc "drop", "Drops all tables and records"
+      def drop
+        # Default implementation does nothing
+      end
+
+      protected
+      def project
+        @project ||= MigrationBundler::Project.load(destination_root)
+      end
+
+      def database
+        @database ||= project.database_class.new(database_url)
+      end
+
+      def database_url
+        (options[:database] && URI(options[:database])) || project.database_url
+      end
+
+      def migrations
+        @migrations ||= MigrationBundler::Migrations.new(project.migrations_path, database)
+      end
+    end
+  end
+end

data/lib/migration_bundler/targets/cassandra/cassandra_target.rb

@@ -0,0 +1,73 @@
+require 'migration_bundler/databases/cassandra_database'
+
+module MigrationBundler
+  module Targets
+    class CassandraTarget < Base
+      def init
+        migration_path = "migrations/" + MigrationBundler::Util.migration_named('create_' + options[:name]) + '.cql'
+        template('create_schema_migrations.cql.erb', migration_path)
+        git_add migration_path
+      end
+
+      def new(name)
+        migration_path = "migrations/" + MigrationBundler::Util.migration_named(name) + '.cql'
+        template('migration.cql.erb', migration_path)
+        git_add migration_path
+      end
+
+      def dump
+        database_url = (options[:database] && URI(options[:database])) || project.database_url
+        @database = MigrationBundler::Databases::CassandraDatabase.new(database_url)
+        fail Error, "Cannot dump database: the database at '#{database_url}' does not have a `schema_migrations` table." unless database.migrations_table?
+        say "Dumping schema from database '#{database_url}'"
+
+        say "Dumping keyspaces '#{keyspaces.join(', ')}'..."
+        describe_statements = keyspaces.map { |keyspace| "describe keyspace #{keyspace};" }
+        run "cqlsh -e '#{describe_statements.join(' ')}' #{database_url.host} > #{project.schema_path}"
+
+        File.open(project.schema_path, 'a') do |f|
+          f.puts "USE #{keyspace};"
+          project.config['db.dump_tables'].each do |table_name|
+            say "Dumping rows from '#{table_name}'..."
+            with_padding do
+              row_statements = database.dump_rows(table_name)
+              f.puts row_statements.join("\n")
+              say "wrote #{row_statements.size} rows.", :green
+            end
+          end
+          say
+        end
+
+        say "Dump complete. Schema written to #{project.schema_path}."
+      end
+
+      def load
+        project = MigrationBundler::Project.load
+        unless File.size?(project.schema_path)
+          raise Error, "Cannot load database: empty schema found at #{project.schema_path}. Maybe you need to `mb migrate`?"
+        end
+
+        @database = MigrationBundler::Databases::CassandraDatabase.new(database_url)
+        drop
+        run "cqlsh #{database_url.host} -f #{project.schema_path}"
+
+        say "Loaded schema at version #{database.current_version}"
+      end
+
+      def drop
+        say_status :drop, database_url, :yellow
+        database.drop(keyspaces)
+      end
+
+      private
+      def keyspace
+        database_url.path[1..-1]
+      end
+
+      def keyspaces
+        keyspaces = (project.config['cassandra.keyspaces'] || []).dup
+        keyspaces.unshift(keyspace)
+      end
+    end
+  end
+end

data/lib/migration_bundler/targets/cassandra/create_schema_migrations.cql.erb

@@ -0,0 +1,16 @@
+/* Create Monkey Butler Tables */
+
+-- Maintains list of applied migrations
+USE KEYSPACE <%= keyspace -%>;
+CREATE TABLE schema_migrations(
+    version INTEGER UNIQUE NOT NULL
+);
+
+/* Create application tables */
+
+/*
+ CREATE TABLE table_name (
+   id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+   ...
+ );
+*/

data/lib/migration_bundler/targets/cocoapods/cocoapods_target.rb

@@ -0,0 +1,43 @@
+require 'migration_bundler/targets/base'
+
+module MigrationBundler
+  module Targets
+    class CocoapodsTarget < MigrationBundler::Targets::Base
+      def init
+        unless project.config['cocoapods.repo']
+          project.config['cocoapods.repo'] = ask("What is the name of your Cocoapods specs repo? ")
+        end
+        if options['bundler']
+          append_to_file 'Gemfile', "gem 'cocoapods'\n"
+        end
+      end
+
+      def generate
+        invoke :validate
+        template('podspec.erb', podspec_name, force: true)
+      end
+
+      def validate
+        fail Error, "Invalid configuration: cocoapods.repo is not configured." unless cocoapods_repo
+      end
+
+      def push
+        invoke :validate
+        run "pod repo push #{options['quiet'] && '--silent '}--allow-warnings #{cocoapods_repo} #{podspec_name}"
+      end
+
+      private
+      def cocoapods_repo
+        project.config['cocoapods.repo']
+      end
+
+      def podspec_name
+        "#{project.name}.podspec"
+      end
+
+      def pod_version
+        unique_tag_for_version(migrations.latest_version)
+      end
+    end
+  end
+end

data/lib/migration_bundler/targets/cocoapods/podspec.erb

@@ -0,0 +1,12 @@
+Pod::Spec.new do |s|
+  s.name         = "<%= project.name %>"
+  s.version      = "<%= pod_version %>"
+  s.summary      =  "Packages the database schema and migrations for <%= project.name -%>"
+  s.homepage     = "<%= project.config['homepage'] || "http://github.com/layerhq" %>"
+  s.author       =  { "<%= project.git_user_name -%>" => "<%= project.git_user_email -%>" }
+  s.source       =  { :git => "<%= project.git_url -%>", :tag => "<%= pod_version -%>" }
+  s.license      =  'Commercial'
+  s.requires_arc = true
+
+  s.resource_bundles = { '<%= project.name -%>' => ['migrations/*', '<%= project.schema_path -%>'] }
+end

data/lib/migration_bundler/targets/maven/maven_target.rb

@@ -0,0 +1,62 @@
+require 'migration_bundler/targets/base'
+
+module MigrationBundler
+  module Targets
+    class MavenTarget < MigrationBundler::Targets::Base
+      def init
+        unless project.config['maven.url']
+          project.config['maven.url'] = ask("What is the URL of your Java Maven repo? ")
+        end
+        unless project.config['maven.username']
+          project.config['maven.username'] = ask("What is the username for your Java Maven repo? ")
+        end
+        unless project.config['maven.password']
+          project.config['maven.password'] = ask("What is the password for your Java Maven repo? ")
+        end
+      end
+
+      def generate
+        invoke :validate
+        remove_file "project"
+        empty_directory "project"
+        empty_directory "project/src"
+        empty_directory "project/src/main"
+        empty_directory "project/src/main/resources"
+        empty_directory "project/src/main/resources/schema"
+
+        copy_file "project/build.gradle", "project/build.gradle"
+        FileUtils.cp_r project.schema_path, "project/src/main/resources/schema/schema.sql"
+        FileUtils.cp_r project.migrations_path, "project/src/main/resources"
+
+        version = unique_tag_for_version(migrations.latest_version)
+        run "cd project && gradle#{options['quiet'] && ' -q '} -Pversion=#{version} clean jar"
+      end
+
+      def validate
+        fail Error, "Invalid configuration: maven.repo is not configured." unless maven_url
+        fail Error, "Invalid configuration: maven.username is not configured." unless maven_username
+        fail Error, "Invalid configuration: maven.password is not configured." unless maven_password
+      end
+
+      def push
+        invoke :validate
+        version = project.git_latest_tag
+        run "cd project && gradle#{options['quiet'] && ' -q'} -Pversion=#{version} -Purl=#{maven_url} -Pusername=#{maven_username} -Ppassword=#{maven_password} publish"
+      end
+
+      private
+
+      def maven_url
+        project.config['maven.url']
+      end
+
+      def maven_username
+        project.config['maven.username']
+      end
+
+      def maven_password
+        project.config['maven.password']
+      end
+    end
+  end
+end

data/lib/migration_bundler/targets/maven/project/.gitignore

@@ -0,0 +1,6 @@
+.gradle
+/local.properties
+/.idea/workspace.xml
+.DS_Store
+/build
+/classes

data/lib/migration_bundler/targets/maven/project/MonkeyButler.iml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$" external.system.id="GRADLE" external.system.module.group="" external.system.module.version="0.1.1" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/build/classes/main" />
+    <output-test url="file://$MODULE_DIR$/build/classes/test" />
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/resources" type="java-test-resource" />
+      <excludeFolder url="file://$MODULE_DIR$/.gradle" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+

data/lib/migration_bundler/targets/maven/project/build.gradle

@@ -0,0 +1,54 @@
+apply plugin: 'java'
+apply plugin: 'maven'
+apply plugin: 'maven-publish'
+
+/**
+ * Specify:
+ *   -Pversion=[VERSION]
+ *   -Purl=[MAVEN URL TO PUBLISH TO] e.g. "http://nexus.dev.layer.com:8081/nexus/content/repositories/releases" or "${System.env.HOME}/.m2/repository"
+ *   -Pusername=[USERNAME FOR MAVEN PUBLISH]
+ *   -Ppassword=[PASSWORD FOR MAVEN PUBLISH]
+ */
+
+ext {
+    mavenUrl = rootProject.hasProperty("url") ? rootProject.property("url") : "${System.env.HOME}/.m2/repository"
+    mavenUsername = rootProject.hasProperty("username") ? rootProject.property("username") : null;
+    mavenPassword = rootProject.hasProperty("password") ? rootProject.property("password") : null;
+}
+
+compileJava {
+    sourceCompatibility = 1.6
+    targetCompatibility = 1.6
+}
+
+repositories {
+    mavenCentral()
+}
+
+/*************************************************
+ * Uploading
+ ************************************************/
+task Jar(type: Jar) {
+    jar.archiveName = "MigrationBundler-" + version + ".jar"
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            groupId "com.layer"
+            artifactId "MigrationBundler"
+            from components.java
+        }
+    }
+    repositories {
+        maven {
+            credentials {
+                username = mavenUsername;
+                password = mavenPassword;
+            }
+            url = mavenUrl;
+        }
+    }
+}
+
+

data/lib/migration_bundler/targets/sqlite/create_migration_bundler_tables.sql.erb

@@ -0,0 +1,15 @@
+/* Create Monkey Butler Tables */
+
+-- Maintains list of applied migrations
+CREATE TABLE schema_migrations(
+    version INTEGER UNIQUE NOT NULL
+);
+
+/* Create application tables */
+
+/*
+ CREATE TABLE table_name (
+   id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+   ...
+ );
+*/

data/lib/migration_bundler/targets/sqlite/migration.sql.erb

@@ -0,0 +1,11 @@
+-- Create or alter tables
+
+/*
+CREATE TABLE table_name (
+  id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT
+);
+
+ALTER TABLE table_name (
+  ...
+)
+*/

data/lib/migration_bundler/targets/sqlite/sqlite_target.rb

@@ -0,0 +1,92 @@
+require 'migration_bundler/databases/sqlite_database'
+
+module MigrationBundler
+  module Targets
+    class SqliteTarget < Base
+      # TODO: Need a way to do this for self elegantly...
+      def self.register_with_cli(cli)
+        cli.method_option :database, type: :string, aliases: '-d', desc: "Set target DATABASE", for: :dump
+        cli.method_option :database, type: :string, aliases: '-d', desc: "Set target DATABASE", for: :load
+      end
+
+      def init
+        migration_name = MigrationBundler::Util.migration_named('create_' + options['name'])
+        template('create_migration_bundler_tables.sql.erb', "migrations/#{migration_name}.sql")
+        git_add "migrations/#{migration_name}.sql"
+        create_file(database_path)
+        append_to_file '.gitignore', database_path
+      end
+
+      no_commands do
+        # NOTE: Used instead of database.url to avoid creation of the database in pretend mode
+        def database_path
+          database_url.path || database_url.opaque
+        end
+      end
+
+      def new(name)
+        migration_ext = project.database_class.migration_ext
+        migration_name = MigrationBundler::Util.migration_named(name) + migration_ext
+        template('migration.sql.erb', "migrations/#{migration_name}")
+        git_add "migrations/#{migration_name}"
+      end
+
+      def dump
+        database_url = (options[:database] && URI(options[:database])) || project.database_url
+        database_path = database_url.path || database_url.opaque
+        fail Error, "Cannot dump database: no file at path '#{database_path}'." unless File.exists?(database_path)
+
+        @database = MigrationBundler::Databases::SqliteDatabase.new(database_url)
+        fail Error, "Cannot dump database: the database at path '#{database_path}' does not have a `schema_migrations` table." unless database.migrations_table?
+        say "Dumping schema from database '#{database_path}'"
+
+        File.truncate(project.schema_path, 0)
+
+        types = { table: 'tables', index: 'indexes', trigger: 'triggers', view: 'views'}
+        types.each do |type, name|
+          say "Dumping #{name}..."
+          with_padding do
+            database.dump_to_schema(type, project.schema_path) do |name|
+              say "wrote #{type}: #{name}", :green
+            end
+          end
+          say
+        end
+
+        File.open(project.schema_path, 'a') do |f|
+          project.config['db.dump_tables'].each do |table_name|
+            say "Dumping rows from '#{table_name}'..."
+            with_padding do
+              row_statements = database.dump_rows(table_name)
+              f.puts row_statements.join("\n")
+              say "wrote #{row_statements.size} rows.", :green
+            end
+          end
+          say
+        end
+
+        say "Dump complete. Schema written to #{project.schema_path}."
+      end
+
+      def load
+        project = MigrationBundler::Project.load
+        unless File.size?(project.schema_path)
+          raise Error, "Cannot load database: empty schema found at #{project.schema_path}. Maybe you need to `mb migrate`?"
+        end
+
+        drop
+        command = "sqlite3 #{database.path} < #{project.schema_path}"
+        say_status :executing, command
+        stdout_str, stderr_str, status = Open3.capture3(command)
+        fail Error, "Failed loading schema: #{stderr_str}" unless stderr_str.empty?
+
+        say "Loaded schema at version #{database.current_version}"
+      end
+
+      def drop
+        say_status :truncate, database.path, :yellow
+        database.drop
+      end
+    end
+  end
+end

data/lib/migration_bundler/templates/Gemfile.erb

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+ruby '2.0.0'
+
+gem 'migration_bundler'

data/lib/migration_bundler/templates/gitignore.erb

@@ -0,0 +1 @@
+.DS_Store

data/lib/migration_bundler/util.rb

@@ -0,0 +1,71 @@
+module MigrationBundler
+  class Util
+    class << self
+      def migration_timestamp
+        Time.now.strftime('%Y%m%d%H%M%S%3N').to_i
+      end
+
+      def migration_named(name, timestamp = migration_timestamp)
+        migration_name = [timestamp, Thor::Util.snake_case(name)].join('_')
+      end
+
+      def strip_leading_whitespace(string)
+        string.gsub(/^\s+/, '')
+      end
+
+      def migration_version_from_path(path)
+        path.match(/(\d{17})_/)[1].to_i
+      end
+
+      def migration_versions_from_paths(paths)
+        paths.map { |path| migration_version_from_path(path) }
+      end
+
+      def migrations_by_version(paths)
+        paths.inject({}) do |hash, path|
+          version = migration_version_from_path(path)
+          hash[version] = path
+          hash
+        end
+      end
+
+      def camelize(term, uppercase_first_letter = true)
+        string = term.to_s
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+        string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+        string.gsub!('/', '::')
+        string
+      end
+
+      def database_named(name)
+        raise ArgumentError, "Database name cannot be nil." if name.nil?
+        require "migration_bundler/databases/#{name}_database"
+        klass_name = "MigrationBundler::Databases::#{Util.camelize(name)}Database"
+        Object.const_get(klass_name)
+      end
+
+      def target_classes_named(*names)
+        raise ArgumentError, "Database name cannot be nil." if names.nil?
+        names.flatten.map do |name|
+          require "migration_bundler/targets/#{name}/#{name}_target"
+          klass_name = "MigrationBundler::Targets::#{Util.camelize(name)}Target"
+          Object.const_get(klass_name).tap do |klass|
+            yield klass if block_given?
+          end
+        end
+      end
+
+      def unique_tag_for_version(version)
+        revision = nil
+        tag = nil
+        begin
+          tag = [version, revision].compact.join('.')
+          existing_tag = `git tag -l #{tag}`
+          break if existing_tag == ""
+          revision = revision.to_i + 1
+        end while true
+        tag
+      end
+    end
+  end
+end

data/lib/migration_bundler/version.rb

@@ -0,0 +1,3 @@
+module MigrationBundler
+  VERSION = "1.3.0"
+end

data/lib/migration_bundler.rb

@@ -0,0 +1 @@
+require 'migration_bundler/cli'