db-migrate 0.0.1

data/lib/migrate/lang/javascript.rb

@@ -0,0 +1,25 @@
+module Migrate
+  module Lang
+    class Javascript < Lang
+      def initialize
+        @ext = "js"
+      end
+
+      def create_migration(dir)
+        File.open("#{dir}/up.#{@ext}", "w") do |f|
+          f.puts "// Here goes JS for migration forward\n"
+        end
+
+        File.open("#{dir}/down.#{@ext}", "w") do |f|
+          f.puts "// Here goes JS for migration backward\n"
+        end
+      end
+
+      def exec_migration(dir, is_up)
+        script = "#{dir}/#{is_up ? "up" : "down"}.#{@ext}"
+        Log.info("Executing #{script}...")
+        `node #{script}`
+      end
+    end
+  end
+end

data/lib/migrate/lang/lang.rb

@@ -0,0 +1,15 @@
+module Migrate
+  module Lang
+    class Lang
+      attr_reader :ext
+
+      def create_migration(dir)
+        raise "Implementation for creating new migration not found."
+      end
+
+      def exec_migration(dir, is_up)
+        raise "Implementation for executing migration not found."
+      end
+    end
+  end
+end

data/lib/migrate/lang/python.rb

@@ -0,0 +1,25 @@
+module Migrate
+  module Lang
+    class Python < Lang
+      def initialize
+        @ext = "py"
+      end
+
+      def create_migration(dir)
+        File.open("#{dir}/up.#{@ext}", "w") do |f|
+          f.puts "# Here goes Python code for migration forward\n"
+        end
+
+        File.open("#{dir}/down.#{@ext}", "w") do |f|
+          f.puts "# Here goes Python code for migration backward\n"
+        end
+      end
+
+      def exec_migration(dir, is_up)
+        script = "#{dir}/#{is_up ? "up" : "down"}.#{@ext}"
+        Log.info("Executing #{script}...")
+        `python #{script}`
+      end
+    end
+  end
+end

data/lib/migrate/lang/ruby.rb

@@ -0,0 +1,25 @@
+module Migrate
+  module Lang
+    class Ruby < Lang
+      def initialize
+        @ext = "rb"
+      end
+
+      def create_migration(dir)
+        File.open("#{dir}/up.#{@ext}", "w") do |f|
+          f.puts "# Here goes Ruby code for migration forward\n"
+        end
+
+        File.open("#{dir}/down.#{@ext}", "w") do |f|
+          f.puts "# Here goes Ruby code for migration backward\n"
+        end
+      end
+
+      def exec_migration(dir, is_up)
+        script = "#{dir}/#{is_up ? "up" : "down"}.#{@ext}"
+        Log.info("Executing #{script}...")
+        `ruby #{script}`
+      end
+    end
+  end
+end

data/lib/migrate/lang/sql.rb

@@ -0,0 +1,26 @@
+module Migrate
+  module Lang
+    class Sql < Lang
+      def initialize(db)
+        @db = db
+        @ext = "sql"
+      end
+
+      def create_migration(dir)
+        File.open("#{dir}/up.#{@ext}", "w") do |f|
+          f.puts "-- Here goes SQL for migration forward\n"
+        end
+
+        File.open("#{dir}/down.#{@ext}", "w") do |f|
+          f.puts "-- Here goes SQL for migration backward\n"
+        end
+      end
+
+      def exec_migration(dir, is_up)
+        script = "#{dir}/#{is_up ? "up" : "down"}.#{@ext}"
+        Log.info("Executing #{script}...")
+        @db.exec_sql(File.read(script))
+      end
+    end
+  end
+end

data/lib/migrate/logger.rb

@@ -0,0 +1,39 @@
+require "colorize"
+
+module Migrate
+  class Log
+    @@debug = true
+
+    def self.verbose(verbose)
+      @@debug = verbose
+    end
+
+    def self.info(msg)
+      return if not @@debug
+      puts ("[INFO] " + msg).green
+    end
+
+    def self.warn(msg)
+      return if not @@debug
+      puts ("[WARN] " + msg).yellow
+    end
+
+    def self.error(msg, e=nil)
+      return if not @@debug
+      puts ("[ERRPR] " + msg + (e != nil ? " #{e.message}" : "")).red
+
+      if e != nil
+        puts e.backtrace
+      end
+    end
+
+    def self.success(msg)
+      return if not @@debug
+      puts ("[SUCCESS] " + msg).blue
+    end
+
+    def self.version(msg)
+      puts (" [VERSION] #{msg} ").colorize(:color => :white, :background => :blue)
+    end
+  end
+end

data/lib/migrate/migrator.rb

@@ -0,0 +1,144 @@
+module Migrate
+  class Migrator
+    def initialize(config)
+      @config = config
+      @db = config.get_db
+      @lang = config.get_lang
+
+      if @db == nil
+        throw "Database connection not found."
+        exit
+      end
+
+      if @lang == nil
+        throw "Language not found."
+      end
+    end
+
+    def init
+      @db.tx do
+        @db.create_tables
+      end
+    end
+
+    def migration_dir(migration)
+      date = DateTime.parse(migration["created_date"].to_s)
+      "#{@config.root}/v#{migration["version"]}-#{date.strftime("%Y-%m-%d")}"
+    end
+
+    def new(desc)
+      @db.tx do
+        Log.info("Creating new migration...")
+
+        migration = @db.new_migration(desc)
+        migration_dir = self.migration_dir(migration)
+        Dir.mkdir migration_dir
+        @lang.create_migration(migration_dir)
+
+        Log.success("Migration for version #{migration["version"]} created.")
+        migration_dir
+      end
+    rescue Exception => e
+      Log.error("Error while creating new migration.", e)
+      exit
+    end
+
+    # will execute single migration by running up or down script
+    def exec_migration(migration, is_up)
+      migration_dir = self.migration_dir(migration)
+      result = @lang.exec_migration(migration_dir, is_up)
+      if @lang.ext != "sql"
+        puts result
+      end
+
+      Log.info("Updating current version number...")
+      version = migration["version"]
+      is_up ? @db.log_up(version) : @db.log_down(version)
+    end
+
+    # will execute range of migrations
+    def exec_migrations(is_up=true)
+      Log.info("Executing migrations...")
+      migrations = yield @db.current_version
+
+      if migrations.count == 0
+        Log.warn("Migrations not found")
+        return
+      end
+
+      migrations.each do |migration|
+        self.exec_migration(migration, is_up)
+      end
+      Log.success("Migrations executed. Current version: #{@db.current_version}")
+    end
+
+    def up(to_version=nil)
+      @db.tx do
+        self.exec_migrations do |last_version|
+          new_version = @db.next_version
+          if to_version == nil
+            to_version = new_version
+          end
+
+          @db.migrations_range(new_version, to_version, true)
+        end
+      end
+    end
+
+    def down(to_version=nil)
+      @db.tx do
+        self.exec_migrations(false) do |current_version|
+          if current_version == 0
+            raise VersionNotFound
+          end
+
+          if to_version == nil
+            to_version = current_version
+          else
+            to_version = to_version.to_i + 1
+          end
+
+          @db.migrations_range(to_version, current_version, false)
+        end
+      end
+    end
+
+    def current_version
+      @db.tx do
+        return @db.current_version
+      end
+    end
+
+    def delete(version)
+      @db.tx do
+        Log.info("Removing migration data...")
+
+        if @db.current_version.to_i == version
+          return Log.error("Cannot remove current version.")
+        end
+
+        dir = self.migration_dir(@db.get_migration(version))
+        @db.delete version
+
+        if Dir.exist? dir
+          File.delete "#{dir}/up.sql"
+          File.delete "#{dir}/down.sql"
+          Dir.rmdir dir
+        end
+
+        Log.success("Migration data removed.")
+      end
+    end
+
+    def list(select, limit)
+      @db.tx do
+        migrations = @db.list_migrations(select, limit)
+        if not migrations.any?
+          return Log.info("Migrations not found")
+        end
+
+        @db.print(migrations, "Migrations")
+      end
+    end
+  end
+end

data/lib/migrate/storage.rb

@@ -0,0 +1,7 @@
+module Migrate
+  module Storage
+    require_relative "./storage/db"
+    require_relative "./storage/postgres"
+    require_relative "./storage/mysql"
+  end
+end

data/lib/migrate/storage/db.rb

@@ -0,0 +1,150 @@
+require 'terminal-table'
+
+module Migrate
+  module Storage
+    class DB
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def type
+        @config.storage
+      end
+
+      def new_migration(description="")
+        self.exec_sql <<-eos
+          INSERT INTO #{@config.version_info} (description, created_date) 
+          VALUES('#{description}', now())
+        eos
+
+        res = self.exec_sql <<-eos
+          SELECT * FROM #{@config.version_info} ORDER BY version DESC LIMIT 1
+        eos
+        res[0]
+      end
+
+      def list_migrations(selects, limit)
+        self.exec_sql <<-eos 
+          SELECT #{(selects == nil ? "*" : selects)} FROM #{@config.version_info}
+          ORDER BY last_up, version
+          #{limit != nil ? "LIMIT #{limit}" : ""}
+        eos
+      end
+
+      def migrations_range(from, to, is_up)
+        self.exec_sql <<-eos
+          SELECT * FROM #{@config.version_info}
+            WHERE version >= #{from} AND version <= #{to}
+          ORDER BY version #{!is_up ? "DESC" : ""}
+          eos
+      end
+
+      def extract_version(results)
+        if results && results.count > 0
+          results[0]["version"]
+        else
+          raise VersionNotFound
+        end
+      end
+
+      def lowest_version
+        self.extract_version self.exec_sql <<-eos
+          SELECT version FROM #{@config.version_info}
+            ORDER BY version
+          LIMIT 1
+        eos
+      end
+
+      def next_version
+        self.extract_version self.exec_sql <<-eos
+          SELECT version FROM #{@config.version_info} 
+            WHERE version > (SELECT version FROM #{@config.version_number} LIMIT 1)
+          ORDER BY version
+          LIMIT 1
+        eos
+      end
+
+      def current_version
+        self.extract_version self.exec_sql <<-eos
+          SELECT * FROM #{config.version_number}
+          LIMIT 1
+        eos
+      end
+
+      def prev_version
+        self.extract_version self.exec_sql <<-eos
+          SELECT version FROM #{@config.version_info} 
+            WHERE version < (SELECT version FROM #{@config.version_number} LIMIT 1) 
+          ORDER BY version DESC
+          LIMIT 1
+        eos
+      end
+
+      def log_up(version)
+        self.exec_sql "UPDATE #{@config.version_info} SET last_up=now() WHERE version=#{version}"
+        self.exec_sql "UPDATE #{@config.version_number} SET version=#{version}"
+      end
+
+      def log_down(version)
+        self.exec_sql "UPDATE #{@config.version_info} SET last_down=now() WHERE version=#{version}"
+        
+        lowest_version = self.lowest_version
+        version_to_save = lowest_version.to_i < version.to_i ? self.prev_version().to_i : 0
+        self.exec_sql "UPDATE #{@config.version_number} SET version=#{version_to_save}"
+      end
+
+      def get_migration(version)
+        res = self.exec_sql "SELECT * FROM #{@config.version_info} WHERE version=#{version}"
+        if res && res.count > 0
+          res[0]
+        else
+          raise VersionNotFound
+        end
+      end
+
+      def delete(version)
+        self.exec_sql "DELETE FROM #{@config.version_info} WHERE version=#{version}"
+      end
+
+      def print(results, title="")
+        rows = []
+        headings = results[0].keys
+
+        results.each do |result|
+          row = []
+          result.each do |column, value|
+            if column == "description"
+              if value.length > 70
+                value = value.scan(/.{1,70}/).join("\n")
+              end
+            end
+
+            row << value
+          end
+          rows << row
+        end
+
+        table = Terminal::Table.new :headings => headings, :rows => rows
+        table.title = title
+        puts table
+      end
+
+      # Will create database model used by tool
+      def create_tables
+        raise "Implementation for creating tables not found"
+      end
+
+      # Executes SQL
+      def exec_sql(sql)
+        raise "Implementation for executing SQL script not found"
+      end
+
+      # Creates new transaction. Should accept block.
+      def tx
+        raise "Implementation for starting new transaction not found"
+      end
+    end
+  end
+end