activerecord-mysql-awesome 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acaf5232085a194cd6be165d88c391949371c823
-  data.tar.gz: 7454e2e8c349fa58074f9dfee87b40dc7e06f656
+  metadata.gz: 5c4fa2c015cdf2511abc7e277b57491d4dcbbd28
+  data.tar.gz: 37e2778cd1ed6cd57748d255753aba1741371b4f
 SHA512:
-  metadata.gz: 867ae8b90d562e056db29aa6d0f0a5f77b69d479661df53f3aa1f92760c4fb4fff72d903b79620ac5223cd08bc9ab1771dde9ac14dee549be71dfbd86bf5284d
-  data.tar.gz: 7e592e3d399b3c2421fafa289707caf3f986967e2254c25ce44fbdde87d8c0662173eddec3ebc9c792989f20ac3bea57367494e60f2e04e8831217be04fcecc5
+  metadata.gz: 55f18e15f1694fcb7365e3716d0394e2181bc11248d38a1b5de2c08b10794b597d490f047b88467afb93bf45d9a6f72726d08955b04d838dc0f23eaf8786ac1a
+  data.tar.gz: b039c7d9c91e43d1a8e8d575cc0363bd5b8daf8fcd9e30766af98b8470314ef7f59148244d071ae249630c756db0f0579ae01f94e17b3ad97143c4182410281d

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+debug.log

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1
+  - ruby-head
+env:
+  - "AR_VERSION=4.0.12"
+  - "AR_VERSION=4.1.8"
+  - "AR_VERSION=4.2.0.rc3"
+before_install:
+  - mysql -e "create database activerecord_unittest;"

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/kamipo/activerecord-mysql-awesome.png?branch=master)](https://travis-ci.org/kamipo/activerecord-mysql-awesome)
 
-Awecome patches backported for ActiveRecord MySQL adapters.
+Awesome patches backported for ActiveRecord MySQL adapters.
 
 ## Installation
 

data/Rakefile

@@ -1,2 +1,62 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
 
+require File.expand_path(File.dirname(__FILE__)) + "/test/config"
+require File.expand_path(File.dirname(__FILE__)) + "/test/support/config"
+
+desc 'Run mysql2 tests by default'
+task :default => :test
+
+desc 'Run mysql2 tests'
+task :test => :test_mysql2
+
+desc 'Build MySQL test databases'
+namespace :db do
+  task :create => ['db:mysql:build']
+  task :drop => ['db:mysql:drop']
+end
+
+%w( mysql mysql2 ).each do |adapter|
+  namespace :test do
+    Rake::TestTask.new(adapter => "#{adapter}:env") { |t|
+      t.libs << 'test'
+      t.test_files = Dir.glob( "test/cases/**/*_test.rb" ).sort
+
+      t.warning = true
+      t.verbose = true
+    }
+  end
+
+  namespace adapter do
+    task :test => "test_#{adapter}"
+
+    # Set the connection environment for the adapter
+    task(:env) { ENV['ARCONN'] = adapter }
+  end
+
+  # Make sure the adapter test evaluates the env setting task
+  task "test_#{adapter}" => ["#{adapter}:env", "test:#{adapter}"]
+end
+
+namespace :db do
+  namespace :mysql do
+    desc 'Build the MySQL test databases'
+    task :build do
+      config = ARTest.config['connections']['mysql']
+      %x( mysql --user=#{config['arunit']['username']} -e "create DATABASE #{config['arunit']['database']} DEFAULT CHARACTER SET utf8" )
+    end
+
+    desc 'Drop the MySQL test databases'
+    task :drop do
+      config = ARTest.config['connections']['mysql']
+      %x( mysqladmin --user=#{config['arunit']['username']} -f drop #{config['arunit']['database']} )
+    end
+
+    desc 'Rebuild the MySQL test databases'
+    task :rebuild => [:drop, :build]
+  end
+end
+
+task :build_mysql_databases => 'db:mysql:build'
+task :drop_mysql_databases => 'db:mysql:drop'
+task :rebuild_mysql_databases => 'db:mysql:rebuild'

data/activerecord-mysql-awesome.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = ActiveRecord::Mysql::Awesome::VERSION
   spec.authors       = ["Ryuta Kamizono"]
   spec.email         = ["kamipo@gmail.com"]
-  spec.summary       = %q{Awecome patches backported for ActiveRecord MySQL adapters}
-  spec.description   = %q{Awecome patches backported for ActiveRecord MySQL adapters}
+  spec.summary       = %q{Awesome patches backported for ActiveRecord MySQL adapters}
+  spec.description   = %q{Awesome patches backported for ActiveRecord MySQL adapters}
   spec.homepage      = "https://github.com/kamipo/activerecord-mysql-awesome"
   spec.license       = "MIT"
 
@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.0.0'
+
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_runtime_dependency "activesupport", "~> 4.0"

data/lib/activerecord-mysql-awesome/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -1,8 +1,138 @@
 require 'active_record/connection_adapters/abstract_mysql_adapter'
 
 module ActiveRecord
+  module Mysql
+    module Awesome
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil, unsigned = false)
+        case type.to_s
+        when 'integer'
+          case limit
+          when nil, 4, 11; 'int'  # compatibility with MySQL default
+          else
+            super(type, limit, precision, scale)
+          end.tap do |sql_type|
+            sql_type << ' unsigned' if unsigned
+          end
+        when 'float', 'decimal'
+          super(type, limit, precision, scale).tap do |sql_type|
+            sql_type << ' unsigned' if unsigned
+          end
+        when 'primary_key'
+          "#{type_to_sql(:integer, limit, precision, scale, unsigned)} auto_increment PRIMARY KEY"
+        when 'datetime', 'time'
+          return super(type, limit, precision, scale) unless precision
+
+          native_type = native_database_types[type.to_sym][:name]
+          case precision
+          when 0..6; "#{native_type}(#{precision})"
+          else raise(ActiveRecordError, "No #{native_type} type has precision of #{precision}. The allowed range of precision is from 0 to 6")
+          end
+        else
+          super(type, limit, precision, scale)
+        end
+      end
+
+      module Column
+        def unsigned?
+          sql_type =~ /unsigned/i
+        end
+      end
+
+      if ActiveRecord::VERSION::STRING < "4.2.0"
+        def quote(value, column = nil) #:nodoc:
+          return super unless column && column.type
+
+          case column.type
+          when :datetime, :time
+            if value.acts_like?(:time) && value.respond_to?(:usec)
+              zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+              result = value.send(zone_conversion_method).to_s(:db)
+              precision = column.precision
+              case precision
+              when 1..6
+                "'#{result}.#{sprintf("%0#{precision}d", value.usec / 10**(6 - precision))}'"
+              when 0, nil
+                "'#{result}'"
+              end
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+
+        module Column
+          def extract_limit(sql_type)
+            case sql_type
+            when /^(?:date)?time/i; nil
+            else
+              super
+            end
+          end
+
+          def extract_precision(sql_type)
+            case sql_type
+            when /^(?:date)?time/i
+              $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+            else
+              super
+            end
+          end
+        end
+      else
+        protected
+
+        def initialize_type_map(m) # :nodoc:
+          super
+          register_class_with_precision m, %r(time)i,     MysqlTime
+          register_class_with_precision m, %r(datetime)i, MysqlDateTime
+        end
+
+        def register_class_with_precision(mapping, key, klass) # :nodoc:
+          mapping.register_type(key) do |*args|
+            precision = extract_precision(args.last)
+            klass.new(precision: precision)
+          end
+        end
+
+        private
+
+        module TimeValueWithPrecision
+          def type_cast_for_database(value)
+            if value.acts_like?(:time) && value.respond_to?(:usec)
+              zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+              result = value.send(zone_conversion_method).to_s(:db)
+              case precision
+              when 1..6
+                "#{result}.#{sprintf("%0#{precision}d", value.usec / 10**(6 - precision))}"
+              when 0, nil
+                result
+              end
+            else
+              super
+            end
+          end
+        end
+
+        class MysqlTime < Type::Time # :nodoc:
+          include TimeValueWithPrecision
+        end
+
+        class MysqlDateTime < Type::DateTime # :nodoc:
+          include TimeValueWithPrecision
+        end
+      end
+    end
+  end
+
   module ConnectionAdapters
     class AbstractMysqlAdapter < AbstractAdapter
+      prepend Mysql::Awesome
+
+      class Column < ConnectionAdapters::Column # :nodoc:
+        prepend Mysql::Awesome::Column
+      end
 
       class ChangeColumnDefinition < Struct.new(:column, :name) #:nodoc:
       end
@@ -95,12 +225,6 @@ module ActiveRecord
         end
       end
 
-      class Column < ConnectionAdapters::Column # :nodoc:
-        def unsigned?
-          sql_type =~ /unsigned/i
-        end
-      end
-
       def options_for_column_spec(table_name)
         if collation = select_one("SHOW TABLE STATUS LIKE '#{table_name}'")["Collation"]
           super.merge(collation: collation)
@@ -132,28 +256,6 @@ module ActiveRecord
         raw_table_options.sub(/(ENGINE=\w+)(?: AUTO_INCREMENT=\d+)/, '\1')
       end
 
-      alias type_to_sql_without_awesome type_to_sql
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil, unsigned = false)
-        case type.to_s
-        when 'integer'
-          case limit
-          when nil, 4, 11; 'int'  # compatibility with MySQL default
-          else
-            type_to_sql_without_awesome(type, limit, precision, scale)
-          end.tap do |sql_type|
-            sql_type << ' unsigned' if unsigned
-          end
-        when 'float', 'decimal'
-          type_to_sql_without_awesome(type, limit, precision, scale).tap do |sql_type|
-            sql_type << ' unsigned' if unsigned
-          end
-        when 'primary_key'
-          "#{type_to_sql(:integer, limit, precision, scale, unsigned)} auto_increment PRIMARY KEY"
-        else
-          type_to_sql_without_awesome(type, limit, precision, scale)
-        end
-      end
-
       def add_column_sql(table_name, column_name, type, options = {})
         td = create_table_definition(table_name)
         cd = td.new_column_definition(column_name, type, options)

data/lib/activerecord/mysql/awesome/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Mysql
     module Awesome
-      VERSION = "0.0.1"
+      VERSION = "0.0.2"
     end
   end
 end

data/test/.gitignore

@@ -0,0 +1 @@
+/config.yml

data/test/cases/datetime_test.rb

@@ -0,0 +1,98 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+if mysql_56?
+  class DateTimeTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    class Foo < ActiveRecord::Base; end
+
+    def test_default_datetime_precision
+      ActiveRecord::Base.connection.create_table(:foos, force: true)
+      ActiveRecord::Base.connection.add_column :foos, :created_at, :datetime
+      ActiveRecord::Base.connection.add_column :foos, :updated_at, :datetime
+      assert_nil activerecord_column_option('foos', 'created_at', 'precision')
+    end
+
+    def test_datetime_data_type_with_precision
+      ActiveRecord::Base.connection.create_table(:foos, force: true)
+      ActiveRecord::Base.connection.add_column :foos, :created_at, :datetime, precision: 1
+      ActiveRecord::Base.connection.add_column :foos, :updated_at, :datetime, precision: 5
+      assert_equal 1, activerecord_column_option('foos', 'created_at', 'precision')
+      assert_equal 5, activerecord_column_option('foos', 'updated_at', 'precision')
+    end
+
+    def test_timestamps_helper_with_custom_precision
+      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+        t.timestamps null: true, precision: 4
+      end
+      assert_equal 4, activerecord_column_option('foos', 'created_at', 'precision')
+      assert_equal 4, activerecord_column_option('foos', 'updated_at', 'precision')
+    end
+
+    def test_passing_precision_to_datetime_does_not_set_limit
+      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+        t.timestamps null: true, precision: 4
+      end
+      assert_nil activerecord_column_option("foos", "created_at", "limit")
+      assert_nil activerecord_column_option("foos", "updated_at", "limit")
+    end
+
+    def test_invalid_datetime_precision_raises_error
+      assert_raises ActiveRecord::ActiveRecordError do
+        ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+          t.timestamps null: true, precision: 7
+        end
+      end
+    end
+
+    def test_mysql_agrees_with_activerecord_about_precision
+      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+        t.timestamps null: true, precision: 4
+      end
+      assert_equal 4, mysql_datetime_precision('foos', 'created_at')
+      assert_equal 4, mysql_datetime_precision('foos', 'updated_at')
+    end
+
+    def test_datetime_format_according_to_precision
+      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+        t.datetime :created_at, precision: 0
+        t.datetime :updated_at, precision: 4
+      end
+      date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+      Foo.create!(created_at: date, updated_at: date)
+      assert foo = Foo.find_by(created_at: date)
+      assert_equal date.to_s, foo.created_at.to_s
+      assert_equal date.to_s, foo.updated_at.to_s
+      assert_equal 000000, foo.created_at.usec
+      assert_equal 999900, foo.updated_at.usec
+    end
+
+    def test_schema_dump_includes_datetime_precision
+      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+        t.datetime :created_at, precision: 4
+        t.datetime :updated_at, precision: 6
+      end
+      schema = dump_table_schema "foos"
+      assert_match %r{t.datetime\s+"created_at",\s+precision: 4$}, schema
+      assert_match %r{t.datetime\s+"updated_at",\s+precision: 6$}, schema
+    end
+
+    private
+
+    def mysql_datetime_precision(table_name, column_name)
+      results = ActiveRecord::Base.connection.exec_query("SELECT column_name, datetime_precision FROM information_schema.columns WHERE table_name ='#{table_name}'")
+      result = results.find do |result_hash|
+        result_hash["column_name"] == column_name
+      end
+      result && result["datetime_precision"]
+    end
+
+    def activerecord_column_option(tablename, column_name, option)
+      result = ActiveRecord::Base.connection.columns(tablename).find do |column|
+        column.name == column_name
+      end
+      result && result.send(option)
+    end
+  end
+end

data/test/cases/helper.rb

@@ -0,0 +1,51 @@
+require 'bundler'
+Bundler.setup
+
+require 'activerecord-mysql-awesome'
+require 'config'
+
+require 'active_support/testing/autorun'
+require 'stringio'
+
+require 'active_record'
+require 'cases/test_case'
+require 'active_support/dependencies'
+require 'active_support/logger'
+require 'active_support/core_ext/string/strip'
+
+require 'support/config'
+require 'support/connection'
+
+# TODO: Move all these random hacks into the ARTest namespace and into the support/ dir
+
+Thread.abort_on_exception = true
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+# Enable raise errors in after_commit and after_rollback.
+ActiveRecord::Base.tap do |klass|
+  klass.raise_in_transactional_callbacks = true if klass.respond_to?(:raise_in_transactional_callbacks=)
+end
+
+# Connect to the database
+ARTest.connect
+
+def current_adapter?(*types)
+  types.any? do |type|
+    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
+  end
+end
+
+def mysql_56?
+  current_adapter?(:Mysql2Adapter) &&
+    ActiveRecord::Base.connection.send(:version).join(".") >= "5.6.0"
+end
+
+# FIXME: we have tests that depend on run order, we should fix that and
+# remove this method call.
+require 'active_support/test_case'
+ActiveSupport::TestCase.tap do |klass|
+  klass.test_order = :sorted if klass.respond_to?(:test_order=)
+end

data/test/cases/test_case.rb

@@ -0,0 +1,123 @@
+require 'active_support/test_case'
+
+module ActiveRecord
+  # = Active Record Test Case
+  #
+  # Defines some test assertions to test against SQL queries.
+  class TestCase < ActiveSupport::TestCase #:nodoc:
+    def teardown
+      SQLCounter.clear_log
+    end
+
+    def assert_date_from_db(expected, actual, message = nil)
+      assert_equal expected.to_s, actual.to_s, message
+    end
+
+    def capture(stream)
+      stream = stream.to_s
+      captured_stream = Tempfile.new(stream)
+      stream_io = eval("$#{stream}")
+      origin_stream = stream_io.dup
+      stream_io.reopen(captured_stream)
+
+      yield
+
+      stream_io.rewind
+      return captured_stream.read
+    ensure
+      captured_stream.close
+      captured_stream.unlink
+      stream_io.reopen(origin_stream)
+    end
+
+    def capture_sql
+      SQLCounter.clear_log
+      yield
+      SQLCounter.log_all.dup
+    end
+
+    def assert_sql(*patterns_to_match)
+      capture_sql { yield }
+    ensure
+      failed_patterns = []
+      patterns_to_match.each do |pattern|
+        failed_patterns << pattern unless SQLCounter.log_all.any?{ |sql| pattern === sql }
+      end
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{SQLCounter.log.join("\n")}"}"
+    end
+
+    def assert_queries(num = 1, options = {})
+      ignore_none = options.fetch(:ignore_none) { num == :any }
+      SQLCounter.clear_log
+      x = yield
+      the_log = ignore_none ? SQLCounter.log_all : SQLCounter.log
+      if num == :any
+        assert_operator the_log.size, :>=, 1, "1 or more queries expected, but none were executed."
+      else
+        mesg = "#{the_log.size} instead of #{num} queries were executed.#{the_log.size == 0 ? '' : "\nQueries:\n#{the_log.join("\n")}"}"
+        assert_equal num, the_log.size, mesg
+      end
+      x
+    end
+
+    def assert_no_queries(options = {}, &block)
+      options.reverse_merge! ignore_none: true
+      assert_queries(0, options, &block)
+    end
+
+    def assert_column(model, column_name, msg=nil)
+      assert has_column?(model, column_name), msg
+    end
+
+    def assert_no_column(model, column_name, msg=nil)
+      assert_not has_column?(model, column_name), msg
+    end
+
+    def has_column?(model, column_name)
+      model.reset_column_information
+      model.column_names.include?(column_name.to_s)
+    end
+  end
+
+  class SQLCounter
+    class << self
+      attr_accessor :ignored_sql, :log, :log_all
+      def clear_log; self.log = []; self.log_all = []; end
+    end
+
+    self.clear_log
+
+    self.ignored_sql = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL, or better yet, use a different notification for the queries
+    # instead examining the SQL content.
+    oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^\s*select .* from all_constraints/im, /^\s*select .* from all_tab_cols/im]
+    mysql_ignored      = [/^SHOW TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i, /^SHOW VARIABLES /]
+    postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select tablename\b.*from pg_tables\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
+    sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im]
+
+    [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
+      ignored_sql.concat db_ignored_sql
+    end
+
+    attr_reader :ignore
+
+    def initialize(ignore = Regexp.union(self.class.ignored_sql))
+      @ignore = ignore
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      return if 'CACHE' == values[:name]
+
+      self.class.log_all << sql
+      self.class.log << sql unless ignore =~ sql
+    end
+  end
+
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end

data/test/config.example.yml

@@ -0,0 +1,20 @@
+default_connection: 'mysql2'
+
+connections:
+  mysql:
+    arunit:
+      username: rails
+      encoding: utf8
+      collation: utf8_unicode_ci
+    arunit2:
+      username: rails
+      encoding: utf8
+
+  mysql2:
+    arunit:
+      username: rails
+      encoding: utf8
+      collation: utf8_unicode_ci
+    arunit2:
+      username: rails
+      encoding: utf8

data/test/config.rb

@@ -0,0 +1,5 @@
+TEST_ROOT       = File.expand_path(File.dirname(__FILE__))
+ASSETS_ROOT     = TEST_ROOT + "/assets"
+FIXTURES_ROOT   = TEST_ROOT + "/fixtures"
+MIGRATIONS_ROOT = TEST_ROOT + "/migrations"
+SCHEMA_ROOT     = TEST_ROOT + "/schema"

data/test/support/config.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+require 'erb'
+require 'fileutils'
+require 'pathname'
+
+module ARTest
+  class << self
+    def config
+      @config ||= read_config
+    end
+
+    private
+
+    def config_file
+      Pathname.new(ENV['ARCONFIG'] || TEST_ROOT + '/config.yml')
+    end
+
+    def read_config
+      unless config_file.exist?
+        FileUtils.cp TEST_ROOT + '/config.example.yml', config_file
+      end
+
+      erb = ERB.new(config_file.read)
+      expand_config(YAML.parse(erb.result(binding)).transform)
+    end
+
+    def expand_config(config)
+      config['connections'].each do |adapter, connection|
+        dbs = [['arunit', 'activerecord_unittest'], ['arunit2', 'activerecord_unittest2']]
+        dbs.each do |name, dbname|
+          unless connection[name].is_a?(Hash)
+            connection[name] = { 'database' => connection[name] }
+          end
+
+          connection[name]['database'] ||= dbname
+          connection[name]['adapter']  ||= adapter
+        end
+      end
+
+      config
+    end
+  end
+end

data/test/support/connection.rb

@@ -0,0 +1,18 @@
+require 'active_support/logger'
+
+module ARTest
+  def self.connection_name
+    ENV['ARCONN'] || config['default_connection']
+  end
+
+  def self.connection_config
+    config['connections'][connection_name]
+  end
+
+  def self.connect
+    puts "Using #{connection_name}"
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new("debug.log", 0, 100 * 1024 * 1024)
+    ActiveRecord::Base.configurations = connection_config
+    ActiveRecord::Base.establish_connection :arunit
+  end
+end

data/test/support/schema_dumping_helper.rb

@@ -0,0 +1,20 @@
+module SchemaDumpingHelper
+  def dump_table_schema(table, connection = ActiveRecord::Base.connection)
+    old_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+    ActiveRecord::SchemaDumper.ignore_tables = connection.tables - [table]
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  ensure
+    ActiveRecord::SchemaDumper.ignore_tables = old_ignore_tables
+  end
+
+  def dump_all_table_schema(ignore_tables)
+    old_ignore_tables, ActiveRecord::SchemaDumper.ignore_tables = ActiveRecord::SchemaDumper.ignore_tables, ignore_tables
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  ensure
+    ActiveRecord::SchemaDumper.ignore_tables = old_ignore_tables
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql-awesome
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ryuta Kamizono
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-12 00:00:00.000000000 Z
+date: 2014-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Awecome patches backported for ActiveRecord MySQL adapters
+description: Awesome patches backported for ActiveRecord MySQL adapters
 email:
 - kamipo@gmail.com
 executables: []
@@ -88,6 +88,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -101,6 +102,15 @@ files:
 - lib/activerecord/mysql/awesome/base.rb
 - lib/activerecord/mysql/awesome/railtie.rb
 - lib/activerecord/mysql/awesome/version.rb
+- test/.gitignore
+- test/cases/datetime_test.rb
+- test/cases/helper.rb
+- test/cases/test_case.rb
+- test/config.example.yml
+- test/config.rb
+- test/support/config.rb
+- test/support/connection.rb
+- test/support/schema_dumping_helper.rb
 homepage: https://github.com/kamipo/activerecord-mysql-awesome
 licenses:
 - MIT
@@ -113,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -124,5 +134,14 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Awecome patches backported for ActiveRecord MySQL adapters
-test_files: []
+summary: Awesome patches backported for ActiveRecord MySQL adapters
+test_files:
+- test/.gitignore
+- test/cases/datetime_test.rb
+- test/cases/helper.rb
+- test/cases/test_case.rb
+- test/config.example.yml
+- test/config.rb
+- test/support/config.rb
+- test/support/connection.rb
+- test/support/schema_dumping_helper.rb