mysql_online_migrations 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8b8c18f26ec8b8f57c2d469d2e11e3837de24130
+  data.tar.gz: 3a65090310d0a049c85ad22da8099ea46939a913
+SHA512:
+  metadata.gz: 3bb7753d1b88a3a77cddf0f23a2a2b6cfe3717821dc625b0fb5024bd4cce25fc45aecd66a75cbb1e8b16464fb8cdd11da1e6b548e57a2c38adc7ec0dd2e77c6a
+  data.tar.gz: a631129c1c90cddd1528658c37a815749a0954882fdf8ddcf387bdf1f7c555fd63dd5ecf18ca2b60443833a9df33fdd96f98a2bfe6a08f7c3e8691b09d544f76

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.DS_Store
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    mysql_online_migrations (0.1.2)
+      activerecord (~> 3.2.15)
+      activesupport (~> 3.2.15)
+      mysql2
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.15)
+      activesupport (= 3.2.15)
+      builder (~> 3.0.0)
+    activerecord (3.2.15)
+      activemodel (= 3.2.15)
+      activesupport (= 3.2.15)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.15)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    coderay (1.0.9)
+    diff-lcs (1.2.5)
+    i18n (0.6.5)
+    logger (1.2.8)
+    method_source (0.8.2)
+    multi_json (1.8.2)
+    mysql2 (0.3.14)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    slop (3.4.6)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  logger
+  mysql_online_migrations!
+  pry
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Anthony Alberto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+mysql_online_migrations
+=======================
+
+Patch Rails migrations to support MySQL 5.6 online migrations capabilities.  
+Prior to MySQL 5.6, when adding / removing / renaming indexes and columns, MySQL would lock the writes of the whole table.  
+MySQL 5.6 adds a way to append `LOCK=NONE` to those alter table statements to allow online migrations.
+
+
+Requirements
+=======================
+Built for Rails 3.2.15, may be compatible with Rails 4.0 but you'd lose the new features introduced.  
+This gem actually just requires ActiveRecord and ActiveSupport, the full Rails gem should not be required.
+
+List of requirements :
+
+- Use mysql2 adapter
+- Use ActiveRecord "~> 3.2.15"
+- Use MySQL or Percona Server 5.6.X
+
+Scope of this gem
+=======================
+
+Patch Rails migrations to automatically add `LOCK=NONE` in the following context :
+
+- Index management : `add_index`, `remove_index`, `rename_index`
+- Add column : `add_column`, `add_timestamps`
+- Remove column : `remove_column`, `remove_timestamps`
+
+Usage
+=======================
+In a typical Rails app, just add it to your gem file :  
+`gem 'mysql_online_migrations'`
+
+And you're ready for online migrations!
+
+### Turn it off for a whole environment
+Example for environment test (your CI might not use MySQL 5.6 yet), add the following to `config/environments/test.rb`:  
+`config.active_record.mysql_online_migrations = false`
+
+### Turn it off for a specific statement
+Add `lock: true` to any of the method calls mentioned above. Example :  
+`add_index :users, :name, lock: true`
+
+The `lock: none` will be useful when hitting the caveats of `LOCK=NONE`. Please read the following section.
+
+Caveats
+=======================
+
+Here's a list of things you can't do with LOCK=NONE and therefore you should provide `lock: true`:  
+
+- Index a column of type text
+- Change the type of a column
+- Change the length of a column
+- Change the nullable value of a column
+- When adding an AUTO_INCREMENT column,
+- Other stuff found on https://blogs.oracle.com/mysqlinnodb/entry/online_alter_table_in_mysql :
+  - when the table contains FULLTEXT indexes or a hidden FTS_DOC_ID column, or
+  - when there are FOREIGN KEY constraints referring to the table, with ON…CASCADE or ON…SET NULL option.
+
+If you don't use `lock: true` when it's not supported, you'll get a MySQL exception. No risk to lock the table by accident.

data/lib/mysql_online_migrations.rb

@@ -0,0 +1,33 @@
+require 'active_record'
+require "active_record/connection_adapters/mysql2_adapter"
+
+%w(*.rb).each do |path|
+  Dir["#{File.dirname(__FILE__)}/mysql_online_migrations/#{path}"].each { |f| require(f) }
+end
+
+module MysqlOnlineMigrations
+  include Indexes
+  include Columns
+
+  def self.included(base)
+    ActiveRecord::Base.send(:class_attribute, :mysql_online_migrations, :instance_writer => false)
+    ActiveRecord::Base.send("mysql_online_migrations=", true)
+  end
+
+  def lock_statement(lock, with_comma = false)
+    return "" if lock == true
+    return "" unless perform_migrations_online?
+    puts "ONLINE MIGRATION"
+    "#{with_comma ? ', ' : ''} LOCK=NONE"
+  end
+
+  def extract_lock_from_options(options)
+    [options[:lock], options.except(:lock)]
+  end
+
+  def perform_migrations_online?
+    ActiveRecord::Base.mysql_online_migrations == true
+  end
+end
+
+ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include, MysqlOnlineMigrations)

data/lib/mysql_online_migrations/columns.rb

@@ -0,0 +1,48 @@
+module MysqlOnlineMigrations
+  module Columns
+    def add_column(table_name, column_name, type, options = {})
+      lock, options = extract_lock_from_options(options)
+      execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)} #{lock_statement(lock, true)}")
+    end
+
+    def add_timestamps(table_name, options = {})
+      add_column table_name, :created_at, :datetime, options
+      add_column table_name, :updated_at, :datetime, options
+    end
+
+    def change_column(table_name, column_name, type, options = {})
+      lock, options = extract_lock_from_options(options)
+      execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)} #{lock_statement(lock, true)}")
+    end
+
+    def rename_column(table_name, column_name, new_column_name, options = {})
+      lock, options = extract_lock_from_options(options)
+      execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)} #{lock_statement(lock, true)}")
+    end
+
+    def remove_column(table_name, *column_names)
+      if column_names.flatten!
+        message = 'Passing array to remove_columns is deprecated, please use ' +
+                  'multiple arguments, like: `remove_columns(:posts, :foo, :bar)`'
+        ActiveSupport::Deprecation.warn message, caller
+      end
+
+      lock, options = if column_names.last.is_a? Hash
+        options = column_names.last
+        column_names = column_names[0..-2]
+        extract_lock_from_options(options)
+      else
+        [false, {}]
+      end
+
+      columns_for_remove(table_name, *column_names).each do |column_name|
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name} #{lock_statement(lock, true)}"
+      end
+    end
+
+    def remove_timestamps(table_name, options = {})
+      remove_column table_name, :updated_at, options
+      remove_column table_name, :created_at, options
+    end
+  end
+end

data/lib/mysql_online_migrations/indexes.rb

@@ -0,0 +1,21 @@
+module MysqlOnlineMigrations
+  module Indexes
+    def add_index(table_name, column_name, options = {})
+      lock, options = extract_lock_from_options(options)
+      index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+      execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns}) #{lock_statement(lock)}"
+    end
+
+    def remove_index(table_name, options_index_name, options = {})
+      lock, options = extract_lock_from_options(options)
+      execute "DROP INDEX #{quote_column_name(index_name_for_remove(table_name, options_index_name))} ON #{quote_table_name(table_name)} #{lock_statement(lock)}"
+    end
+
+    def rename_index(table_name, old_name, new_name, options = {})
+      old_index_def = indexes(table_name).detect { |i| i.name == old_name }
+      return unless old_index_def
+      remove_index(table_name, { :name => old_name }, options)
+      add_index(table_name, old_index_def.columns, options.merge(name: new_name, unique: old_index_def.unique))
+    end
+  end
+end

data/mysql_online_migrations.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name        = 'mysql_online_migrations'
+  s.version     = '0.1.3'
+  s.summary     = "Use MySQL 5.6+ capacities to perform online migrations"
+  s.description = "MySQL 5.6 adds a way to append `LOCK=NONE` to alter table statements to allow online migrations. Let's use it."
+  s.authors     = ["Anthony Alberto"]
+  s.email       = 'alberto.anthony@gmail.com'
+  s.homepage    = 'https://github.com/anthonyalberto/mysql_online_migrations'
+
+  s.add_runtime_dependency "activerecord", "~> 3.2.15"
+  s.add_runtime_dependency "activesupport", "~> 3.2.15"
+  s.add_runtime_dependency "mysql2"
+  s.add_development_dependency "logger"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "pry"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/lib/mysql_online_migrations/columns_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe MysqlOnlineMigrations::Columns do
+  let(:comma_before_lock_none) { true }
+
+  context "#add_column" do
+    let(:queries) do
+      {
+        [:testing, :foo2, :string, {}] =>
+          "ALTER TABLE `testing` ADD `foo2` varchar(255)",
+        [:testing, :foo2, :string, { limit: 20, null: false, default: 'def' }] =>
+          "ALTER TABLE `testing` ADD `foo2` varchar(20) DEFAULT 'def' NOT NULL",
+        [:testing, :foo2, :decimal, { precision:3, scale: 2 }] =>
+          "ALTER TABLE `testing` ADD `foo2` decimal(3,2)",
+      }
+    end
+
+    let(:method_name) { :add_column }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#add_timestamps" do
+    let(:queries) do
+      {
+        [:testing2, {}] =>
+          [
+            "ALTER TABLE `testing2` ADD `created_at` datetime",
+            "ALTER TABLE `testing2` ADD `updated_at` datetime",
+          ]
+      }
+    end
+
+    let(:method_name) { :add_timestamps }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#remove_column" do
+    let(:queries) do
+      {
+        [:testing, :foo, {}] =>
+          "ALTER TABLE `testing` DROP `foo`",
+        [:testing, [:foo, :bar], {}] =>
+          [
+            "ALTER TABLE `testing` DROP `foo`",
+            "ALTER TABLE `testing` DROP `bar`"
+          ],
+        [:testing, :foo, :bar, {}] =>
+          [
+            "ALTER TABLE `testing` DROP `foo`",
+            "ALTER TABLE `testing` DROP `bar`"
+          ]
+      }
+    end
+
+    let(:method_name) { :remove_column }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#remove_timestamps" do
+    let(:queries) do
+      {
+        [:testing, {}] =>
+          [
+            "ALTER TABLE `testing` DROP `created_at`",
+            "ALTER TABLE `testing` DROP `updated_at`",
+          ]
+      }
+    end
+
+    let(:method_name) { :remove_timestamps }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#change_column" do
+    let(:queries) do
+      # Unsupported with lock=none : change column type, change limit, change null
+      {
+        [:testing, :foo, :string, { default: 'def', limit: 100 }] =>
+          "ALTER TABLE `testing` CHANGE `foo` `foo` varchar(100) DEFAULT 'def'",
+      }
+    end
+
+    let(:method_name) { :change_column }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#rename_column" do
+    let(:queries) do
+      {
+        [:testing, :foo, :foo2, {}] =>
+          "ALTER TABLE `testing` CHANGE `foo` `foo2` varchar(100) DEFAULT NULL"
+      }
+    end
+
+    let(:method_name) { :rename_column }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+end

data/spec/lib/mysql_online_migrations/indexes_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe MysqlOnlineMigrations::Indexes do
+  let(:comma_before_lock_none) { false }
+
+  context "#add_index" do
+    let(:queries) do
+      {
+        [:testing, :foo, {}] =>
+          "CREATE INDEX `index_testing_on_foo` ON `testing` (`foo`)",
+        [:testing, :foo, { length: 10 }] =>
+          "CREATE INDEX `index_testing_on_foo` ON `testing` (`foo`(10))",
+        [:testing, [:foo, :bar, :baz], {}] =>
+          "CREATE INDEX `index_testing_on_foo_and_bar_and_baz` ON `testing` (`foo`, `bar`, `baz`)",
+        [:testing, [:foo, :bar, :baz], { unique: true }] =>
+          "CREATE UNIQUE INDEX `index_testing_on_foo_and_bar_and_baz` ON `testing` (`foo`, `bar`, `baz`)",
+        [:testing, [:foo, :bar, :baz], { unique: true, name: "best_index_of_the_world" }] =>
+          "CREATE UNIQUE INDEX `best_index_of_the_world` ON `testing` (`foo`, `bar`, `baz`)",
+      }
+    end
+
+    let(:method_name) { :add_index }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#remove_index" do
+    let(:queries) do
+      {
+        [:testing, :baz, {}] =>
+          "DROP INDEX `index_testing_on_baz` ON `testing`",
+        [:testing, [:bar, :baz], {}] =>
+          "DROP INDEX `index_testing_on_bar_and_baz` ON `testing`",
+        [:testing, { column: [:bar, :baz] }, {}] =>
+          "DROP INDEX `index_testing_on_bar_and_baz` ON `testing`",
+        [:testing, { name: "best_index_of_the_world2" }, {}] =>
+          "DROP INDEX `best_index_of_the_world2` ON `testing`"
+      }
+    end
+    let(:method_name) { :remove_index }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+
+  context "#rename_index" do
+    let(:queries) do
+      {
+        [:testing, "best_index_of_the_world2", "renamed_best_index_of_the_world2", {}] =>
+          [
+            "DROP INDEX `best_index_of_the_world2` ON `testing`",
+            "CREATE INDEX `renamed_best_index_of_the_world2` ON `testing` (`extra`)",
+          ],
+        [:testing, "best_index_of_the_world3", "renamed_best_index_of_the_world3", {}] =>
+          [
+            "DROP INDEX `best_index_of_the_world3` ON `testing`",
+            "CREATE UNIQUE INDEX `renamed_best_index_of_the_world3` ON `testing` (`baz`, `extra`)",
+          ]
+      }
+    end
+    let(:method_name) { :rename_index }
+
+    it_behaves_like "a method that adds LOCK=NONE when needed"
+    it_behaves_like "a request with LOCK=NONE that doesn't crash in MySQL"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+# require 'active_record'
+require 'rubygems'
+require 'bundler/setup'
+require 'mysql_online_migrations'
+require 'logger'
+require 'pry'
+require 'support/helpers'
+require 'support/shared_examples/mysql_online_migrations'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.include Helpers
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  #config.order = 'random'
+
+  config.before(:all) do
+    setup
+  end
+
+  config.after(:all) do
+    teardown
+  end
+
+end

data/spec/support/helpers.rb

@@ -0,0 +1,73 @@
+module Helpers
+  def execute(statement)
+  end
+
+  def unstub_execute
+    @adapter.unstub(:execute)
+  end
+
+  def stub_execute
+    original_execute = @adapter.method(:execute)
+    @adapter.stub(:execute) do |statement|
+      if statement =~ /^(alter|create|drop) /i
+        execute(statement.squeeze(' ').strip)
+      else
+        original_execute.call(statement)
+      end
+    end
+  end
+
+  def add_lock_none(str, with_comma)
+    "#{str}#{with_comma ? ' ,' : ''} LOCK=NONE"
+  end
+
+  def rebuild_table
+    @table_name = :testing
+    @adapter.drop_table @table_name rescue nil
+    @adapter.create_table @table_name do |t|
+      t.column :foo, :string, :limit => 100
+      t.column :bar, :string, :limit => 100
+      t.column :baz, :string, :limit => 100
+      t.column :extra, :string, :limit => 100
+      t.timestamps
+    end
+
+    @table_name = :testing2
+    @adapter.drop_table @table_name rescue nil
+    @adapter.create_table @table_name do |t|
+    end
+
+    @adapter.add_index :testing, :baz
+    @adapter.add_index :testing, [:bar, :baz]
+    @adapter.add_index :testing, :extra, name: "best_index_of_the_world2"
+    @adapter.add_index :testing, [:baz, :extra], name: "best_index_of_the_world3", unique: true
+  end
+
+  def setup
+    ActiveRecord::Base.establish_connection(
+      adapter: :mysql2,
+      reconnect: false,
+      database: "mysql_online_migrations",
+      username: "root",
+      host: "localhost",
+      encoding: "utf8",
+      socket: "/tmp/mysql.sock"
+    )
+
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    ActiveRecord::Base.logger.level = Logger::INFO
+
+    @adapter = ActiveRecord::Base.connection
+
+    rebuild_table
+  end
+
+  def set_ar_setting(value)
+    ActiveRecord::Base.stub(:mysql_online_migrations).and_return(value)
+  end
+
+  def teardown
+    @adapter.drop_table :testing rescue nil
+    ActiveRecord::Base.primary_key_prefix_type = nil
+  end
+end

data/spec/support/shared_examples/mysql_online_migrations.rb

@@ -0,0 +1,44 @@
+shared_examples_for "a method that adds LOCK=NONE when needed" do
+  before(:each) do
+    stub_execute
+  end
+
+  it "adds LOCK=NONE at the end of the query" do
+    queries.each do |arguments, output|
+      Array.wrap(output).each { |out| should_receive(:execute).with(add_lock_none(out, comma_before_lock_none)) }
+      @adapter.public_send(method_name, *arguments)
+    end
+  end
+
+  context "with AR global setting set to false" do
+    before(:each) { set_ar_setting(false) }
+
+    it "doesn't add lock none" do
+      queries.each do |arguments, output|
+        Array.wrap(output).each { |out| should_receive(:execute).with(out) }
+        @adapter.public_send(method_name, *arguments)
+      end
+    end
+  end
+
+  context "with lock: true option" do
+    it "doesn't add lock none" do
+      queries.each do |arguments, output|
+        Array.wrap(output).each { |out| should_receive(:execute).with(out) }
+        arguments[-1] = arguments.last.merge(lock: true)
+        @adapter.public_send(method_name, *arguments)
+      end
+    end
+  end
+end
+
+shared_examples_for "a request with LOCK=NONE that doesn't crash in MySQL" do
+  it "succeeds without exception" do
+    queries.each do |_, output|
+      Array.wrap(output).each do |out|
+        @adapter.execute(add_lock_none(out, comma_before_lock_none))
+        rebuild_table
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: mysql_online_migrations
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Anthony Alberto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MySQL 5.6 adds a way to append `LOCK=NONE` to alter table statements
+  to allow online migrations. Let's use it.
+email: alberto.anthony@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/mysql_online_migrations.rb
+- lib/mysql_online_migrations/columns.rb
+- lib/mysql_online_migrations/indexes.rb
+- mysql_online_migrations.gemspec
+- spec/lib/mysql_online_migrations/columns_spec.rb
+- spec/lib/mysql_online_migrations/indexes_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+- spec/support/shared_examples/mysql_online_migrations.rb
+homepage: https://github.com/anthonyalberto/mysql_online_migrations
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Use MySQL 5.6+ capacities to perform online migrations
+test_files:
+- spec/lib/mysql_online_migrations/columns_spec.rb
+- spec/lib/mysql_online_migrations/indexes_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+- spec/support/shared_examples/mysql_online_migrations.rb