sql_migrations 2.1.0.pre2 → 2.1.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a937f095c9b3ddd985e5d2a1794711b46096ac7a
-  data.tar.gz: 3c4fa8831f5dd444265ad9ca0d2d2a804b484e98
+  metadata.gz: 9522fb2b47a3d5a48d724c2b452013756df04608
+  data.tar.gz: f2c3fa4aca5e5c87d173a5d80c9294c5e5957ca1
 SHA512:
-  metadata.gz: 7a8232c7f4cfe99c3c3ebf2a5afbfa0e25b092f4102c81aca32e47a7a71112f8ef2b4a2e3ef0aa97b31b8b31828f24984813135ec0683a156b14c48d1f820810
-  data.tar.gz: 2e591e9d7c2ab71b9e745ee8596947a3e0af17b5d971914273bf5cc27ebfabe305081d08db3b9c6fcd99cfe09b0ec8cef7a952d6e9edd15a38f94f4dc6ff3119
+  metadata.gz: 3f7c4b21c50dd78dcdfe0505c97cc9fe7a9e6f09bc42c0fd5750f121cd68df1da105a0ba59ef028e105804c25aa14a4b2f3f44e48c285d95e77637ae19b73c8e
+  data.tar.gz: 5fa155c9c61d31c69d73d148b4f731001535e806453a82d833aa514878e228fe67424c5d8b502b1e2eeaa157c31181211f053c9eaba1de529d1c51b687fe31d8

data/.rubocop.yml

@@ -0,0 +1,6 @@
+Metrics/LineLength:
+  Max: 95
+Metrics/MethodLength:
+  Max: 18
+Style/SignalException:
+  Enabled: false

data/README.md

@@ -1,11 +1,11 @@
-# sql-migrations
+# sql_migrations
 
 [![Gem Version](https://badge.fury.io/rb/sql_migrations.svg)](http://badge.fury.io/rb/sql_migrations)
-[![Build Status](https://travis-ci.org/grzesiek/sql-migrations.svg?branch=master)](https://travis-ci.org/grzesiek/sql-migrations)
+[![Build Status](https://travis-ci.org/grzesiek/sql_migrations.svg?branch=master)](https://travis-ci.org/grzesiek/sql_migrations)
 
 Simple standalone migrations you can use with plain SQL.
 
-This gives you possibility to execute migrations, seed datebase (on production and in test environment with fixtures) in non-Ruby pojects.
+This gives you possibility to execute migrations, seed datebase (on production and in test environment with fixtures) in non-Ruby projects.
 `sql-migrations` can work with multiple different databases, and support many db adapters.
 
 ## Why ?
@@ -47,50 +47,64 @@ For example, if you work on old Zend 1 project, and you want to take benefit fro
 4.  Create database config file in `db/config/databases.yml`
 
     ```yaml
-    default:
-      development:
-        adapter: mysql2
-        encoding: utf8
-        database: test_db_dev
-        username: test_user
-        password: test_pass
-        host: 192.168.1.1
-      test:
-        adapter: mysql2
-        encoding: utf8
-        database: <%= ENV['DB_NAME'] %>
-        username: <%= ENV['DB_USER'] %>
-        password: <%= ENV['DB_PASS'] %>
-        host: <%=     ENV['DB_HOST'] %>
-      production:
-        adapter: mysql2
-        encoding: utf8
-        database: test_db_prod
-        username: test_user
-        password: test_pass
-        host: 192.168.1.100
-        
-    second_db:
-      development:
-        adapter: mysql2
-        encoding: utf8
-        database: second_db_dev
-        username: test_user
-        password: test_pass
-        host: 127.0.0.1
-      test:
-        adapter: mysql2
-        encoding: utf8
-        database: second_db_test
-        username: test_user
-        password: test_pass
-        host: 127.0.0.1
+    production:
+      databases:
+        default:
+          adapter: mysql2
+          encoding: utf8
+          database: default_db_prod
+          username: prod_user
+          password: prod_pass
+          host: 192.168.1.1
+      options:
+        separator: ;
+
+    development:
+      databases:
+        default:
+          adapter: mysql2
+          encoding: utf8
+          database: default_db_dev
+          username: dev_user
+          password: dev_pass
+          host: 127.0.0.1
+        second_db:
+          adapter: mysql2
+          encoding: utf8
+          database: second_db_dev
+          username: test_user
+          password: test_pass
+          host: 127.0.0.1
+      options:
+        separator: ;
+
+    test:
+      databases:
+        default:
+          adapter: mysql2
+          encoding: utf8
+          database: <%= ENV['DB_DEFAULT_NAME'] %>
+          username: <%= ENV['DB_DEFAULT_USER'] %>
+          password: <%= ENV['DB_DEFAULT_PASS'] %>
+          host:     <%= ENV['DB_DEFAULT_HOST'] %>
+        second_db:
+          adapter: mysql2
+          encoding: utf8
+          database: <%= ENV['DB_SECOND_NAME'] %>
+          username: <%= ENV['DB_SECOND_USER'] %>
+          password: <%= ENV['DB_SECOND_PASS'] %>
+          host:     <%= ENV['DB_SECOND_HOST'] %>
+      options:
+        separator: ;
     ```
 
-    Note that you need to define `default` database configuration.
-
     As shown above, it is possible to use ERB-like syntax to use environment variables in config.
 
+    `default` database configuration is optional, nonetheless if supplied it will not be necessary to create additional subdirectory to store migrations (look below).
+
+    If you have multi-statement migrations you should provide `separator` configuration variable in `options` block. `options` key is optional in YAML.
+
+
 4.  Migrations/seed/fixtures can be executed using rake tasks. So you will need to create `Rakefile`:
 
     ```ruby
@@ -101,12 +115,39 @@ For example, if you work on old Zend 1 project, and you want to take benefit fro
     SqlMigrations.load_tasks
     ```
 
+    You can also create Rake tasks by yourself:
+
+    ```ruby
+    require 'sql_migrations'
+    SqlMigrations::Config.load!('databases.yml')
+
+    namespace :db do
+      desc 'Migrate database'
+      task :migrate do
+        puts '[i] Running migrations ...'
+        SqlMigrations.migrate
+      end
+
+      desc 'Seed database'
+      task :seed do
+        puts '[i] Seeding databases ...'
+        SqlMigrations.seed
+      end
+
+      desc 'Prepare databases -- migrate and seed'
+      task :prepare do
+        Rake::Task['db:migrate'].invoke
+        Rake::Task['db:seed'].invoke
+      end
+    end
+    ```
+
 5.  It's ready !
   
 
 ## Usage
 
-1.  Valid migration/seed/fixture file names match agains regexp `/(\d{8})_(\d{6})_(.*)?\.sql/`. So valid filenames would be:
+1.  Valid migration/seed/fixture file names match against regexp `/(\d{8})_(\d{6})_(.*)?\.sql/`. So valid filenames would be:
 
 
         20150303_180100_test_migration.sql
@@ -115,7 +156,7 @@ For example, if you work on old Zend 1 project, and you want to take benefit fro
 
     You can put plain SQL into that files.
 
-2.  It is possible to create migration files, seed files and fixtures inside followig directory structure:
+2.  It is possible to create migration files, seed files and fixtures inside following directory structure:
 
         db/
           migrations/
@@ -142,7 +183,7 @@ For example, if you work on old Zend 1 project, and you want to take benefit fro
 
         db/
           migrations/
-            20150303_180100_test_migration.sql
+            20150303_180100_test_migration_for_default_database.sql
             second_db/
               20150303_180101_test_migration_for_second_db.sql
 
@@ -172,7 +213,7 @@ For example, if you work on old Zend 1 project, and you want to take benefit fro
         # this will list all migrations/seed files/fixtures that where found
         rake sqlmigration:files:list    
 
-6.  Enviroment variables
+6.  Environment variables
 
     If you want to run migration on different database (for example test) specify ENV:
 
@@ -192,4 +233,4 @@ For example, if you work on old Zend 1 project, and you want to take benefit fro
 
 ## License
 
-This is free sofware licensed under MIT license, see LICENSE file
+This is free software licensed under MIT license, see LICENSE file

data/Rakefile

@@ -1,6 +1,13 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new('spec')
-task :default => :spec
+RuboCop::RakeTask.new
 
+task :test do
+  Rake::Task['spec'].invoke
+  Rake::Task['rubocop'].invoke
+end
+
+task default: :test

data/lib/sql_migrations/config.rb

@@ -1,36 +1,55 @@
 module SqlMigrations
+  # Configuration class
+  #
   class Config
     class << self
-      attr_reader :options
+      attr_reader :env
 
-      def load!(config_file)
-        @options = YAML.load(ERB.new(File.new(config_file).read).result)
+      def load!(config_file, env = nil)
+        @env = (env || ENV['ENV'] || ENV['RAKE_ENV'] || :development).to_sym
+        config = get_config_for_env_from_file(config_file)
+        @databases = config[:databases]
+        @options   = config[:options]
+        { databases: @databases, options: @options }
       end
-    end
 
-    def initialize
-      @env = (ENV['ENV'] ||= "development").to_sym
-      @options = self.class.options
-      @databases = get_databases_from_config
-    end
+      def databases
+        get_config_required(:@databases)
+      end
+
+      def options
+        get_config_optional(:@options)
+      end
+
+      private
 
-    def databases
-      @databases.map do |db|
-        db_options = @options[db.to_s][@env.to_s]
-        unless db_options
-          raise "Configuration for #{db} in environment #{@env} not found !"
+      def get_config_required(config_variable)
+        config_value = instance_variable_get(config_variable)
+        if config_value.nil? || config_value.empty?
+          raise "No configuration for `#{config_variable.to_s[1..-1]}` !"
         end
-        db_options.merge!(name: db)
+        config_value
+      end
+
+      def get_config_optional(config_variable)
+        config_value = instance_variable_get(config_variable)
+        (config_value.nil? || config_value.empty?) ? {} : config_value
       end
-    end
 
-    private
-    def get_databases_from_config
-      databases = @options.map { |k, v| k.to_sym }
-      unless databases.include?(:default)
-        raise "Default database configuration not found !"
+      def get_config_for_env_from_file(file)
+        yaml_hash = YAML.load(ERB.new(File.new(file).read).result)
+        config = symbolize_keys(yaml_hash)[@env]
+        raise LoadError, "No configuration for `#{@env}` environment found !" unless config
+        config
+      end
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(key, value), new_hash|
+          new_key = key.is_a?(String) ? key.to_sym : key
+          new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+          new_hash[new_key] = new_value
+        end
       end
-      databases
     end
   end
 end

data/lib/sql_migrations/database.rb

@@ -1,66 +1,84 @@
 module SqlMigrations
+  # Class that represents database gem will connect to
+  #
   class Database
-
     SCHEMA_TABLE = :sqlmigrations_schema
-    attr_reader :db, :name
+    attr_reader :name, :driver
 
-    def initialize(options)
-      @name = options[:name] || :default
+    def initialize(name, options)
+      @name    = name
+      @adapter = options[:adapter]
       begin
-        @db = self.class.connect(options)
+        @driver = self.class.connect(options)
       rescue
-        puts "[-] Could not connect to database using #{options['adapter']} adapter"
+        puts "[-] Could not connect to `#{@name}` database using #{@adapter} adapter"
         raise
       else
-        puts "[+] Connected to database using #{options['adapter']} adapter"
+        puts "[+] Connected to `#{@name}` database using #{@adapter} adapter"
       end
       install_table
     end
 
     def execute_migrations
-      puts "[i] Executing migrations"
-      Migration.find(@name).each { |migration| migration.execute(self) }
+      migrations = Migration.find(@name)
+      if !migrations.empty?
+        puts "[i] Executing migrations for `#{@name}` database"
+        migrations.each { |migration| migration.execute(self) }
+      else
+        puts "[i] No new migrations for `#{@name}` database"
+      end
     end
 
     def seed_database
-      puts "[i] Seeding database"
-      Seed.find(@name).each { |seed| seed.execute(self) }
+      seeds = Seed.find(@name)
+      if !seeds.empty?
+        puts "[i] Seeding `#{@name}` database"
+        seeds.each { |seed| seed.execute(self) }
+      else
+        puts "[i] No new seeds for `#{@name}` database"
+      end
     end
 
     def seed_with_fixtures
-      puts "[i] Seeding test database with fixtures"
-      Fixture.find(@name).each { |fixture| fixture.execute(self) }
+      fixtures = Fixture.find(@name)
+      if !fixtures.empty?
+        puts "[i] Seeding `#{@name}` database with fixtures"
+        fixtures.each { |fixture| fixture.execute(self) }
+      else
+        puts "[i] No new fixturess for `#{@name}` database"
+      end
     end
 
     def schema_dataset
-      @db[SCHEMA_TABLE]
+      @driver[SCHEMA_TABLE]
     end
 
     private
 
     def self.connect(options)
-      Sequel.connect(adapter:  options['adapter'],
-                     host:     options['host'],
-                     database: options['database'],
-                     user:     options['username'],
-                     password: options['password'],
+      Sequel.connect(adapter:  options[:adapter],
+                     encoding: options[:encoding],
+                     host:     options[:host],
+                     database: options[:database],
+                     user:     options[:username],
+                     password: options[:password],
                      test:     true)
     end
 
     def install_table
       # Check if we have migrations_schema table present
-      unless @db.table_exists?(SCHEMA_TABLE)
-        puts "[!] Installing `#{SCHEMA_TABLE}`"
-        @db.create_table(SCHEMA_TABLE) do
-          primary_key :id
-          Bignum   :time
-          DateTime :executed
-          String   :name
-          String   :type
-          index [ :time, :type ]
-        end
+      return if @driver.table_exists?(SCHEMA_TABLE)
+      puts "[!] Installing `#{SCHEMA_TABLE}`"
+      @driver.create_table(SCHEMA_TABLE) do
+        # rubocop:disable Style/SingleSpaceBeforeFirstArg
+        primary_key :id
+        Bignum      :time
+        DateTime    :executed
+        String      :name
+        String      :type
+        index      [:time, :type]
+        # rubocop:enable Style/SingleSpaceBeforeFirstArg
       end
     end
-
   end
 end

data/lib/sql_migrations/find_scripts.rb

@@ -0,0 +1,64 @@
+module SqlMigrations
+  # Class for finding sql scripts
+  #
+  class FindScripts
+    class << self
+      def find(db_name, type)
+        files = []
+        Find.find(Dir.pwd) do |path|
+          file_parameters = match_file(db_name, type, path)
+          next unless file_parameters
+          file_parameters.merge!(path: path)
+          files << file_parameters
+        end
+        files
+      end
+
+      def match_file(db_dir, type, path)
+        # parent_dir/base_dir/filename_that_matches_regexp.sql
+        _filename, base_dir, parent_dir  = path.split(File::SEPARATOR).last(3).reverse
+
+        # Only files that match agains regexp will do
+        file_parameters = file_match_regexp(File.basename(path))
+        return nil unless file_parameters
+
+        # Only files that lay in specific directory structure will do
+        file_database = file_match_directories(parent_dir, base_dir, db_dir, type)
+        return nil unless file_database
+
+        { date: file_parameters[1], time: file_parameters[2],
+          name: file_parameters[3], db_name: file_database }
+      end
+
+      def file_match_regexp(file_name)
+        file_name.match(/(\d{8})_(\d{6})_(.*)?\.sql/)
+      end
+
+      def file_match_directories(parent_dir, base_dir, db_dir, type)
+        # example: migrations/migration_file.sql
+        file_in_type_base_dir   = (base_dir == type.to_s)
+        # example: migrations/some_database/migration_file.sql
+        file_in_type_parent_dir = (parent_dir == type.to_s)
+        # example migrations/some_database/migration_file.sql
+        file_in_db_dir          = (base_dir == db_dir.to_s)
+
+        file_in_valid_db_dir    = (file_in_type_parent_dir && file_in_db_dir)
+
+        # If we are matching script assigned to :default database
+        #   scripts can be placed in base_dir or in parent dir indicating type
+        #   and in :default base_dir
+        if db_dir == :default
+          matches =  file_in_type_base_dir || file_in_valid_db_dir
+          file_database = :default
+        else
+          # Otherwise only files for specific type dir (migration/fixture/seed)
+          #   and specific database dir apply
+          matches = file_in_valid_db_dir
+          file_database = base_dir.to_sym
+        end
+
+        matches ? file_database : nil
+      end
+    end
+  end
+end

data/lib/sql_migrations/fixture.rb

@@ -1,13 +1,13 @@
 module SqlMigrations
+  # Fixture class
+  #
   class Fixture < SqlScript
-
     def self.find(db_name)
       super(db_name, :fixture)
     end
 
     def to_s
-      "Fixture #{@name}, datetime: #{@date + @time}"
+      "Fixture #{@name} for `#{@db_name}` database, datetime: #{@date + @time}"
     end
-
   end
 end

data/lib/sql_migrations/migration.rb

@@ -1,13 +1,13 @@
 module SqlMigrations
+  # Migration class
+  #
   class Migration < SqlScript
-
     def self.find(db_name)
       super(db_name, :migrations)
     end
 
     def to_s
-      "Migration #{@name} for db: #{@db_name}, datetime: #{@date + @time}"
+      "Migration #{@name} for `#{@db_name}` database, datetime: #{@date + @time}"
     end
-
   end
 end

data/lib/sql_migrations/seed.rb

@@ -1,13 +1,13 @@
 module SqlMigrations
+  # Seed class
+  #
   class Seed < SqlScript
-
     def self.find(db_name)
       super(db_name, :seed)
     end
 
     def to_s
-      "Seed data #{@name}, datetime: #{@date + @time}"
+      "Seed data #{@name} for `#{@db_name}` database, datetime: #{@date + @time}"
     end
-
   end
 end

data/lib/sql_migrations/sql_script.rb

@@ -1,26 +1,27 @@
 module SqlMigrations
+  # SqlScript class
+  #
   class SqlScript
-
     attr_reader :date, :time, :name
 
-    def initialize(path, opts)
-      @date     = opts[:date]
-      @time     = opts[:time]
-      @name     = opts[:name]
-      @path     = opts[:path]
-      @db_name  = opts[:db_name]
-      @content  = File.read(path)
-      @type     = self.class.name.downcase.split('::').last
-      @datetime = (@date + @time).to_i
+    def initialize(content, opts)
+      @content   = content
+      @date      = opts[:date]
+      @time      = opts[:time]
+      @name      = opts[:name]
+      @db_name   = opts[:db_name]
+      @type      = self.class.name.downcase.split('::').last
+      @datetime  = (@date + @time).to_i
     end
 
     def execute(db)
       @database = db
-      return false unless is_new?
+      return false unless new?
+      driver = @database.driver
       begin
-        @database.db.transaction do
+        driver.transaction do
           @benchmark = Benchmark.measure do
-            @database.db.run @content
+            statements.each { |query| driver.run(query) }
           end
         end
       rescue
@@ -31,45 +32,31 @@ module SqlMigrations
       end
     end
 
-    def self.find(db_name, type)
-      scripts = []
-      Find.find(Dir.pwd) do |path|
-        if !db_name.is_a? Array then db_name = [ db_name ] end
-        file_date, file_time, file_name, file_db = self.file_options(db_name, type, path)
-        next unless file_name
-        scripts << self.new(path, date: file_date, time: file_time, name: file_name, db_name: file_db)
+    def statements
+      separator = Config.options[:separator]
+      if separator
+        statements = @content.split(separator)
+        statements.collect!(&:strip)
+        statements.reject(&:empty?)
+      else
+        [@content]
       end
-      scripts.sort_by { |file| (file.date + file.time).to_i }
     end
 
-    private
-    def self.file_options(db_names, type, path)
-
-      up_dir, dir, filename = path.split(File::SEPARATOR)[-3, 3]
-
-      # Only files that match agains this regexp
-      file_opts = File.basename(path).match(/(\d{8})_(\d{6})_(.*)?\.sql/)
-      return nil unless file_opts
-
-      file_in_type_dir   = (dir    == type.to_s)
-      file_in_type_updir = (up_dir == type.to_s)
-      file_in_db_dir     = db_names.include?(dir.to_sym)
-                          
-      # There is exception when we are looking for files for more than one database
-      # or we are checking default database only
-      if db_names == [ :default ] || db_names.count > 1
-        return nil unless (file_in_type_dir || (file_in_db_dir && file_in_type_updir))
-      else
-        # Only files for specific type (migration/fixture/seed)
-        # Only files for specific database
-        return nil unless (file_in_db_dir && file_in_type_updir)
+    def self.find(db_name, type)
+      files = FindScripts.find(db_name, type)
+      scripts = files.map do |parameters|
+        path = parameters.delete(:path)
+        content = File.read(path)
+        new(content, parameters)
       end
 
-      file_database = db_names.include?(dir.to_sym) ? dir : :default
-      return file_opts[1], file_opts[2], file_opts[3], file_database
+      scripts.sort_by { |file| (file.date + file.time).to_i }
     end
 
-    def is_new?
+    private
+
+    def new?
       schema = @database.schema_dataset
       last = schema.order(Sequel.asc(:time)).where(type: @type).last
       is_new = schema.where(time: @datetime, type: @type).count == 0
@@ -83,10 +70,10 @@ module SqlMigrations
 
     def on_success
       puts "[+] Successfully executed #{@type}, name: #{@name}"
+      puts "    #{@type.capitalize} file: #{@date}_#{@time}_#{@name}.sql"
       puts "    Benchmark: #{@benchmark}"
       schema = @database.schema_dataset
       schema.insert(time: @datetime, name: @name, type: @type, executed: DateTime.now)
     end
-
   end
 end

data/lib/sql_migrations/tasks/list.rake

@@ -1,6 +1,6 @@
 namespace :sqlmigrations do
   namespace :files do
-    desc "List found migration and seed files"
+    desc 'List found migration and seed files'
     task :list do
       SqlMigrations.list_files
     end

data/lib/sql_migrations/tasks/migrate.rake

@@ -1,6 +1,6 @@
 namespace :sqlmigrations do
   namespace :db do
-    desc "Run migrations"
+    desc 'Run migrations'
     task :migrate do
       SqlMigrations.migrate
     end

data/lib/sql_migrations/tasks/seed.rake

@@ -1,6 +1,6 @@
 namespace :sqlmigrations do
   namespace :db do
-    desc "Seed database"
+    desc 'Seed database'
     task :seed do
       SqlMigrations.seed
     end

data/lib/sql_migrations/tasks/seed_test.rake

@@ -1,7 +1,7 @@
 namespace :sqlmigrations do
   namespace :db do
     namespace :test do
-      desc "Seed test database with fixtures"
+      desc 'Seed test database with fixtures'
       task :seed do
         SqlMigrations.seed_test
       end

data/lib/sql_migrations/version.rb

@@ -1,3 +1,5 @@
+# SqlMigrations
+#
 module SqlMigrations
-  VERSION = "2.1.0.pre2"
+  VERSION = '2.1.0.pre3'
 end

data/lib/sql_migrations.rb

@@ -8,36 +8,37 @@ require 'erb'
 require 'sql_migrations/version'
 require 'sql_migrations/database'
 require 'sql_migrations/config'
+require 'sql_migrations/find_scripts'
 require 'sql_migrations/sql_script'
 require 'sql_migrations/migration'
 require 'sql_migrations/seed'
 require 'sql_migrations/fixture'
 
+# SqlMigrations
+#
 module SqlMigrations
   class << self
-
     def load_tasks
-      load "sql_migrations/tasks/migrate.rake"
-      load "sql_migrations/tasks/seed.rake"
-      load "sql_migrations/tasks/seed_test.rake"
-      load "sql_migrations/tasks/list.rake"
+      load 'sql_migrations/tasks/migrate.rake'
+      load 'sql_migrations/tasks/seed.rake'
+      load 'sql_migrations/tasks/seed_test.rake'
+      load 'sql_migrations/tasks/list.rake'
     end
 
     def migrate
-      databases { |db| db.execute_migrations }
+      databases(&:execute_migrations)
     end
 
     def seed
-      databases { |db| db.seed_database      }
+      databases(&:seed_database)
     end
 
     def seed_test
-      databases { |db| db.seed_with_fixtures }
+      databases(&:seed_with_fixtures)
     end
 
     def list_files
-      Config.new.databases.each do |db_config|
-        name = db_config[:name]
+      Config.databases.each do |name, _config|
         Migration.find(name).each { |migration| puts migration }
         Seed.find(name).each      { |seed|      puts seed      }
         Fixture.find(name).each   { |fixture|   puts fixture   }
@@ -45,9 +46,10 @@ module SqlMigrations
     end
 
     private
+
     def databases
-      Config.new.databases.each do |db_config|
-        db = Database.new(db_config)
+      Config.databases.each do |name, config|
+        db = Database.new(name, config)
         yield db
       end
     end

data/spec/features/config_spec.rb

@@ -1,16 +1,40 @@
+describe 'no loadable configuration file' do
+  it 'should raise error when config is not loaded' do
+    expect { SqlMigrations.list_files }.to raise_error RuntimeError
+  end
+end
+
 describe 'loadable configuration file' do
   before do
     File.open('databases.yml', 'w') do |f|
-      f.puts 'default:'
-      f.puts '  test:'
-      f.puts '    adapter: sqlite3'
-      f.puts '    database: <%= ENV["DB_NAME"] %>'
+      f.puts 'development:'
+      f.puts '  databases:'
+      f.puts '    default:'
+      f.puts '      adapter: sqlite3'
+      f.puts '      database: <%= ENV["DB_NAME"] %>'
+      f.puts '  options:'
+      f.puts '    separator: ;'
     end
+    ENV['DB_NAME'] = 'test_database'
+    SqlMigrations::Config.load! 'databases.yml'
   end
 
   it 'should use environment variables in config' do
-    ENV['DB_NAME'] = 'test_database'
-    SqlMigrations::Config.load! 'databases.yml'
-    expect(SqlMigrations::Config.options['default']['test']['database']).to eq 'test_database'
+    databases = SqlMigrations::Config.databases
+    expect(databases[:default][:database]).to eq 'test_database'
+  end
+
+  it 'should parse database correctly' do
+    databases = SqlMigrations::Config.databases[:default]
+    expect(databases).to eq(adapter: 'sqlite3', database: 'test_database')
+  end
+
+  it 'should parse options correctly' do
+    options = SqlMigrations::Config.options
+    expect(options[:separator]).to eq ';'
+  end
+
+  after do
+    ENV.delete('DB_NAME')
   end
 end

data/spec/features/migration_multistatement_spec.rb

@@ -0,0 +1,28 @@
+describe 'multistatement migration' do
+  before do
+    Dir.mkdir('/migrations')
+    File.open('/migrations/20150514_154010_test_multistatement_migration.sql', 'w') do |f|
+      f.puts 'CREATE TABLE multi_test_table1(col_int1 INTEGER, col_str1 STRING);'
+      f.puts 'CREATE TABLE multi_test_table2(col_int2 INTEGER, col_str2 STRING);'
+    end
+    allow(SqlMigrations::Config).to receive(:databases) { { default: { development: {} } } }
+    allow(SqlMigrations::Config).to receive(:options) { { separator: ';' } }
+    @migration = SqlMigrations::Migration.find(:default).first
+  end
+
+  it 'should have multiple statements' do
+    expect(@migration.statements.count).to eq 2
+  end
+
+  it 'should be properly executed' do
+    $stdout = StringIO.new
+    database = SqlMigrations::Database.new(:default, adapter: :sqlite)
+    @migration.execute(database)
+    expect(@sqlite_db.table_exists?(:multi_test_table1)).to be true
+    expect(@sqlite_db[:multi_test_table1].columns).to include(:col_int1)
+    expect(@sqlite_db[:multi_test_table1].columns).to include(:col_str1)
+    expect(@sqlite_db.table_exists?(:multi_test_table2)).to be true
+    expect(@sqlite_db[:multi_test_table2].columns).to include(:col_int2)
+    expect(@sqlite_db[:multi_test_table2].columns).to include(:col_str2)
+  end
+end

data/spec/features/migration_order_spec.rb

@@ -1,26 +1,25 @@
 describe 'migrations valid order support engine' do
   before do
-    allow(SqlMigrations::Config).to receive(:options) { { "default" => { "development" => {}}} }
+    allow(SqlMigrations::Config).to receive(:databases) { { default: { development: {} } } }
     $stdout = StringIO.new
     Dir.mkdir('/migrations')
     File.open('/migrations/20150305_154010_test_migration.sql', 'w') do |f|
-      f.puts "CREATE TABLE test_table(col_int INTEGER, col_str STRING)"
+      f.puts 'CREATE TABLE test_table(col_int INTEGER, col_str STRING)'
     end
 
-    @database  = SqlMigrations::Database.new(name: :default, 'adapter' => :sqlite)
-    migration = SqlMigrations::Migration.find([ :default ]).first
+    @database  = SqlMigrations::Database.new(:default, adapter: :sqlite)
+    migration = SqlMigrations::Migration.find(:default).first
     migration.execute(@database)
 
     File.open('/migrations/20150305_154011_test2_migration.sql', 'w') do |f|
-      f.puts "CREATE TABLE test_table2(col_int2 INTEGER, col_str2 STRING)"
+      f.puts 'CREATE TABLE test_table2(col_int2 INTEGER, col_str2 STRING)'
     end
     File.open('/migrations/20150305_154012_test3_migration.sql', 'w') do |f|
-      f.puts "CREATE TABLE test_table3(col_int3 INTEGER, col_str3 STRING)"
+      f.puts 'CREATE TABLE test_table3(col_int3 INTEGER, col_str3 STRING)'
     end
-    @migrations = SqlMigrations::Migration.find([ :default ])
+    @migrations = SqlMigrations::Migration.find(:default)
   end
 
-
   it 'should find all migrations' do
     expect(@migrations.count).to be 3
   end
@@ -35,7 +34,6 @@ describe 'migrations valid order support engine' do
   end
 
   it 'should create all tables' do
-    database = SqlMigrations::Database.new(name: :default, 'adapter' => :sqlite)
     @migrations.each { |migration| migration.execute(@database) }
     expect(@sqlite_db.table_exists?(:test_table)).to be true
     expect(@sqlite_db[:test_table].columns).to include(:col_int)

data/spec/features/migration_spec.rb

@@ -2,10 +2,10 @@ describe 'migration' do
   before do
     Dir.mkdir('/migrations')
     File.open('/migrations/20150305_154010_test_migration.sql', 'w') do |f|
-      f.puts "CREATE TABLE test_table(col_int INTEGER, col_str STRING)"
+      f.puts 'CREATE TABLE test_table(col_int INTEGER, col_str STRING)'
     end
-    allow(SqlMigrations::Config).to receive(:options) { { "default" => { "development" => {}}} }
-    @migration = SqlMigrations::Migration.find([ :default ]).first
+    allow(SqlMigrations::Config).to receive(:databases) { { default: { development: {} } } }
+    @migration = SqlMigrations::Migration.find(:default).first
   end
 
   it 'should be found and initialized' do
@@ -26,7 +26,7 @@ describe 'migration' do
 
   it 'should be properly executed' do
     $stdout = StringIO.new
-    database = SqlMigrations::Database.new(name: :default, 'adapter' => :sqlite)
+    database = SqlMigrations::Database.new(:default, adapter: :sqlite)
     @migration.execute(database)
     expect(@sqlite_db.table_exists?(:test_table)).to be true
     expect(@sqlite_db[:test_table].columns).to include(:col_int)

data/spec/features/schema_table_spec.rb

@@ -1,28 +1,30 @@
 describe 'schema table in database' do
   before do
-    allow(SqlMigrations::Config).to receive(:options) { { "default" => { "development" => {}}} }
+    allow(SqlMigrations::Config).to receive(:databases) { { default: {} } }
   end
 
   it 'should be created if it does not exist' do
     expect do
-      @database = SqlMigrations::Database.new(name: :default, 'adapter' => :sqlite)
-    end.to output("[+] Connected to database using sqlite adapter\n" +
+      @database = SqlMigrations::Database.new(:default, adapter: :sqlite)
+    end.to output("[+] Connected to `default` database using sqlite adapter\n" \
                   "[!] Installing `sqlmigrations_schema`\n").to_stdout
-    expect(@database.db.table_exists?(:sqlmigrations_schema)).to be true
+    expect(@database.driver.table_exists?(:sqlmigrations_schema)).to be true
   end
 
   it 'should not be create if it exists' do
     @sqlite_db.create_table(:sqlmigrations_schema) do
+      # rubocop:disable Style/SingleSpaceBeforeFirstArg
       primary_key :id
-      Bignum   :time
-      DateTime :executed
-      String   :name
-      String   :type
-      index [ :time, :type ]
+      Bignum      :time
+      DateTime    :executed
+      String      :name
+      String      :type
+      index      [:time, :type]
+      # rubocop:enable Style/SingleSpaceBeforeFirstArg
     end
     expect do
-      @database = SqlMigrations::Database.new(name: :default, 'adapter' => :sqlite)
-    end.to output("[+] Connected to database using sqlite adapter\n").to_stdout
-    expect(@database.db.table_exists?(:sqlmigrations_schema)).to be true
+      @database = SqlMigrations::Database.new(:default, adapter: :sqlite)
+    end.to output("[+] Connected to `default` database using sqlite adapter\n").to_stdout
+    expect(@database.driver.table_exists?(:sqlmigrations_schema)).to be true
   end
 end

data/spec/features/sql_scripts_spec.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Metrics/LineLength
 describe 'sql scripts' do
   before do
     Dir.mkdir('/migrations')
@@ -5,27 +6,41 @@ describe 'sql scripts' do
     Dir.mkdir('/fixtures')
 
     File.open('/migrations/20150305_154010_first_test_migration.sql', 'w') do |f|
-      f.puts "CREATE TABLE first_test_table(col_int1 INTEGER, col_str1 STRING)"
+      f.puts 'CREATE TABLE first_test_table(col_int1 INTEGER, col_str1 STRING)'
     end
     File.open('/migrations/20150305_154011_second_test_migration.sql', 'w') do |f|
-      f.puts "CREATE TABLE second_test_table(col_int2 INTEGER, col_str2 STRING)"
+      f.puts 'CREATE TABLE second_test_table(col_int2 INTEGER, col_str2 STRING)'
     end
     File.open('/seed/20150305_154010_test_seed.sql', 'w') do |f|
-      f.puts "INSERT INTO first_test_table(col_int1, col_str1) VALUES(123, 'test_string1')"
-      f.puts "INSERT INTO second_test_table(col_int2, col_str2) VALUES(456, 'test_string2')"
+      f.puts 'INSERT INTO first_test_table(col_int1, col_str1) VALUES(123, "test_string1")'
+      f.puts 'INSERT INTO second_test_table(col_int2, col_str2) VALUES(456, "test_string2")'
     end
     File.open('/fixtures/20150305_154010_test_test_seed', 'w') do |f|
-      f.puts "INSERT INTO first_test2_table(col_int1, col_str1) VALUES(2123, '2test_string1')"
-      f.puts "INSERT INTO second_test2_table(col_int2, col_str2) VALUES(2456, '2test_string2')"
+      f.puts 'INSERT INTO first_test2_table(col_int1, col_str1) VALUES(2123, "2test_string1")'
+      f.puts 'INSERT INTO second_test2_table(col_int2, col_str2) VALUES(2456, "2test_string2")'
     end
-    allow(SqlMigrations::Config).to receive(:options) { { "default" => { "development" => {}}} }
+
+    Dir.mkdir('/migrations/test2_db')
+    File.open('/migrations/test2_db/20150511_144000_second_db_test_migration.sql', 'w') do |f|
+      f.puts 'CREATE TABLE second_db_test_table(col_int1 INTEGER, col_str1 STRING)'
+    end
+
+    Dir.mkdir('/migrations/default')
+    File.open('/migrations/default//20150511_144100_default_db_test2_migration.sql', 'w') do |f|
+      f.puts 'CREATE TABLE default_db_test2_table(col_int1 INTEGER, col_str1 STRING)'
+    end
+
+    allow(SqlMigrations::Config).to receive(:databases) { { default: {}, test2_db: {} } }
   end
 
   it 'should be found' do
     expect { SqlMigrations.list_files }.to \
-      output("Migration first_test_migration for db: default, datetime: 20150305154010\n" +
-             "Migration second_test_migration for db: default, datetime: 20150305154011\n" +
-             "Seed data test_seed, datetime: 20150305154010\n").to_stdout
+      output("Migration first_test_migration for `default` database, datetime: 20150305154010\n" \
+             "Migration second_test_migration for `default` database, datetime: 20150305154011\n" \
+             "Migration default_db_test2_migration for `default` database, datetime: 20150511144100\n" \
+             "Seed data test_seed for `default` database, datetime: 20150305154010\n" \
+             "Migration second_db_test_migration for `test2_db` database, datetime: 20150511144000\n"
+            ).to_stdout
   end
-
 end
+# rubocop:enable Metrics/LineLength

data/spec/spec_helper.rb

@@ -3,10 +3,16 @@ require 'memfs'
 Bundler.require
 
 RSpec.configure do |config|
+  config.profile_examples = 2
+  config.order = :random
+  Kernel.srand config.seed
+
   config.before do
     @sqlite_db = Sequel.sqlite
     allow(SqlMigrations::Database).to receive(:connect) { @sqlite_db }
     MemFs.activate!
+    # Reset configuration for every test suite
+    SqlMigrations::Config.instance_eval('@databases = nil; @options = nil')
   end
 
   config.after do

data/sql_migrations.gemspec

@@ -4,23 +4,26 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'sql_migrations/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "sql_migrations"
+  spec.name          = 'sql_migrations'
   spec.version       = SqlMigrations::VERSION
-  spec.authors       = ["Grzegorz Bizon"]
-  spec.email         = ["grzegorz.bizon@ntsn.pl"]
-  spec.summary       = %q{Simple standalone migrations you can use with plain SQL}
-  spec.homepage      = "http://github.com/grzesiek/sql-migrations"
-  spec.license       = "MIT"
+  spec.authors       = ['Grzegorz Bizon']
+  spec.email         = ['grzegorz.bizon@ntsn.pl']
+  spec.summary       = 'Simple standalone migrations you can use with plain SQL'
+  spec.homepage      = 'http://github.com/grzesiek/sql_migrations'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
+  # rubocop:disable Style/SingleSpaceBeforeFirstArg
   spec.add_development_dependency 'rspec',   '~> 3.2.0'
   spec.add_development_dependency 'sqlite3', '~> 1.3.10'
   spec.add_development_dependency 'memfs',   '~> 0.4.3'
+  spec.add_development_dependency 'rubocop', '~> 0.31.0'
   spec.add_dependency             'bundler', '~> 1.7'
   spec.add_dependency             'rake',    '~> 10.0'
   spec.add_dependency             'sequel',  '~> 4.19.0'
+  # rubocop:enable Style/SingleSpaceBeforeFirstArg
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sql_migrations
 version: !ruby/object:Gem::Version
-  version: 2.1.0.pre2
+  version: 2.1.0.pre3
 platform: ruby
 authors:
 - Grzegorz Bizon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-11 00:00:00.000000000 Z
+date: 2015-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.3
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.31.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -103,6 +117,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE
@@ -111,6 +126,7 @@ files:
 - lib/sql_migrations.rb
 - lib/sql_migrations/config.rb
 - lib/sql_migrations/database.rb
+- lib/sql_migrations/find_scripts.rb
 - lib/sql_migrations/fixture.rb
 - lib/sql_migrations/migration.rb
 - lib/sql_migrations/seed.rb
@@ -121,13 +137,14 @@ files:
 - lib/sql_migrations/tasks/seed_test.rake
 - lib/sql_migrations/version.rb
 - spec/features/config_spec.rb
+- spec/features/migration_multistatement_spec.rb
 - spec/features/migration_order_spec.rb
 - spec/features/migration_spec.rb
 - spec/features/schema_table_spec.rb
 - spec/features/sql_scripts_spec.rb
 - spec/spec_helper.rb
 - sql_migrations.gemspec
-homepage: http://github.com/grzesiek/sql-migrations
+homepage: http://github.com/grzesiek/sql_migrations
 licenses:
 - MIT
 metadata: {}
@@ -153,6 +170,7 @@ specification_version: 4
 summary: Simple standalone migrations you can use with plain SQL
 test_files:
 - spec/features/config_spec.rb
+- spec/features/migration_multistatement_spec.rb
 - spec/features/migration_order_spec.rb
 - spec/features/migration_spec.rb
 - spec/features/schema_table_spec.rb