schema_monkey 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72a64abeef5d3b9c5b59cfb54214e5158246b7c9
+  data.tar.gz: 9e8d840289ac07f0efeb97d3aef091ab1fbb5cde
+SHA512:
+  metadata.gz: 0d52996ac73f76b495b88b6a4122eac06e4cf2b1088ee18d2654f97f492468ecc7fa8fb855cebe654ba4fee2a9ddf831dfa40e2242ccdb0b0fd8899c981abef5
+  data.tar.gz: 6994d391d237b4e322ec4808d11b1e734ae144df725f5b297f250a722efb8f3e9de2479843eaed54592432ed06b913e195d19d041838873352f59f37e7526c8e

data/.gitignore

@@ -0,0 +1,8 @@
+/coverage
+/tmp
+/pkg
+
+*.lock
+*.log
+*.sqlite3
+!gemfiles/**/*.sqlite3

data/.travis.yml

@@ -0,0 +1,19 @@
+# This file was auto-generated by the schema_dev tool, based on the data in
+#                 ./schema_dev.yml
+# Please do not edit this file; any changes will be overwritten next time
+# schema_dev gets run.
+---
+sudo: false
+rvm:
+- 1.9.3
+- 2.1.5
+gemfile:
+- gemfiles/rails-4.2/Gemfile.mysql2
+- gemfiles/rails-4.2/Gemfile.postgresql
+- gemfiles/rails-4.2/Gemfile.sqlite3
+env: POSTGRESQL_DB_USER=postgres MYSQL_DB_USER=travis
+addons:
+  postgresql: '9.3'
+before_script: bundle exec rake create_databases
+after_script: bundle exec rake drop_databases
+script: bundle exec rake travis

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 ronen barzel 
+
+MIT License
+
+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 @@
+[![Gem Version](https://badge.fury.io/rb/schema_monkey.svg)](http://badge.fury.io/rb/schema_monkey)
+[![Build Status](https://secure.travis-ci.org/SchemaPlus/schema_monkey.svg)](http://travis-ci.org/SchemaPlus/schema_monkey)
+[![Coverage Status](https://img.shields.io/coveralls/SchemaPlus/schema_monkey.svg)](https://coveralls.io/r/SchemaPlus/schema_monkey)
+[![Dependency Status](https://gemnasium.com/lomba/schema_monkey.svg)](https://gemnasium.com/SchemaPlus/schema_monkey)
+
+# schema_monkey
+
+TODO: Write a gem description
+
+schema_monkey is part of the [SchemaPlus](https://github.com/SchemaPlus/) family of Ruby on Rails extension gems.
+
+## Installation
+
+In your application's Gemfile
+
+```ruby
+gem "schema_monkey"
+```
+## Compatibility
+
+schema_monkey is tested on
+
+[//]: # SCHEMA_DEV: MATRIX - begin
+[//]: # These lines are auto-generated by schema_dev based on schema_dev.yml
+* ruby **1.9.3** with rails **4.2**, using **mysql2**, **sqlite3** or **postgresql**
+* ruby **2.1.5** with rails **4.2**, using **mysql2**, **sqlite3** or **postgresql**
+
+[//]: # SCHEMA_DEV: MATRIX - end
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+## History
+
+*   See [CHANGELOG](CHANGELOG.md) for per-version release notes.
+
+## Development & Testing
+
+Are you interested in contributing to schema_monkey?  Thanks!  Please follow
+the standard protocol: fork, feature branch, develop, push, and issue pull request.
+
+Some things to know about to help you develop and test:
+
+* **schema_dev**:  schema_monkey uses [schema_dev](https://github.com/SchemaPlus/schema_dev) to
+  facilitate running rspec tests on the matrix of ruby, rails, and database
+  versions that the gem supports, both locally and on
+  [travis-ci](http://travis-ci.org/SchemaPlus/schema_monkey)
+
+  To to run rspec locally on the full matrix, do:
+
+        $ schema_dev bundle install
+        $ schema_dev rspec
+
+  You can also run on just one configuration at a time;  For info, see `schema_dev --help` or the
+  [schema_dev](https://github.com/SchemaPlus/schema_dev) README.
+
+  The matrix of configurations is specified in `schema_dev.yml` in
+  the project root.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'schema_dev/tasks'
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/gemfiles/Gemfile.base

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec :path => File.expand_path('..', __FILE__)
+
+platform :ruby do
+    gem "byebug" if RUBY_VERSION > "2"
+end

data/gemfiles/rails-4.2/Gemfile.base

@@ -0,0 +1,3 @@
+eval File.read File.expand_path('../../Gemfile.base', __FILE__)
+
+gem "rails", "~> 4.2.0"

data/gemfiles/rails-4.2/Gemfile.mysql2

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "mysql2"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+end

data/gemfiles/rails-4.2/Gemfile.postgresql

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "pg"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/gemfiles/rails-4.2/Gemfile.sqlite3

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "sqlite3"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter', '>=1.3.0.beta2'
+end

data/lib/schema_monkey/active_record/base.rb

@@ -0,0 +1,31 @@
+module SchemaMonkey
+  module ActiveRecord
+
+    module Base
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          class << base
+            alias_method_chain :columns, :schema_monkey
+            alias_method_chain :reset_column_information, :schema_monkey
+          end
+        end
+
+        def columns_with_schema_monkey
+          Middleware::Model::Columns.start model: self, columns: [] do |env|
+            env.columns += columns_without_schema_monkey
+          end
+        end
+
+        def reset_column_information_with_schema_monkey
+          Middleware::Model::ResetColumnInformation.start model: self do |env|
+            reset_column_information_without_schema_monkey
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,39 @@
+module SchemaMonkey
+  module ActiveRecord
+    module ConnectionAdapters
+      module AbstractAdapter
+        def self.included(base) #:nodoc:
+          base.alias_method_chain :initialize, :schema_monkey
+        end
+
+        def initialize_with_schema_monkey(*args) #:nodoc:
+          initialize_without_schema_monkey(*args)
+
+          dbm = case adapter_name
+                when /^MySQL/i                 then :Mysql
+                when 'PostgreSQL', 'PostGIS'   then :Postgresql
+                when 'SQLite'                  then :Sqlite3
+                end
+
+          SchemaMonkey.include_adapters(self.class, dbm)
+          SchemaMonkey.insert_middleware(dbm)
+        end
+
+        module SchemaCreation
+          def self.included(base)
+            base.class_eval do
+              alias_method_chain :add_column_options!, :schema_monkey
+              public :options_include_default?
+            end
+          end
+
+          def add_column_options_with_schema_monkey!(sql, options)
+            Middleware::Migration::ColumnOptionsSql.start caller: self, connection: self.instance_variable_get('@conn'), sql: sql, options: options do |env|
+              add_column_options_without_schema_monkey! env.sql, env.options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,31 @@
+module SchemaMonkey
+  module ActiveRecord
+    module ConnectionAdapters
+      module MysqlAdapter
+
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :indexes, :schema_monkey
+            alias_method_chain :tables, :schema_monkey
+          end
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Column
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Reference
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Index
+        end
+
+        def indexes_with_schema_monkey(table_name, query_name=nil)
+          Middleware::Query::Indexes.start connection: self, table_name: table_name, query_name: query_name do |env|
+            env.index_definitions += indexes_without_schema_monkey env.table_name, env.query_name
+          end
+        end
+
+        def tables_with_schema_monkey(query_name=nil, database=nil, like=nil)
+          Middleware::Query::Tables.start connection: self, query_name: query_name, database: database, like: like do |env|
+            env.tables += tables_without_schema_monkey env.query_name, env.database, env.like
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/schema_monkey/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,30 @@
+module SchemaMonkey
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :exec_cache, :schema_monkey
+            alias_method_chain :indexes, :schema_monkey
+          end
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Reference
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Column
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Index
+        end
+
+        def exec_cache_with_schema_monkey(sql, name, binds)
+          Middleware::Query::ExecCache.start connection: self, sql: sql, name: name, binds: binds do |env|
+            exec_cache_without_schema_monkey(env.sql, env.name, env.binds)
+          end
+        end
+
+        def indexes_with_schema_monkey(table_name, query_name=nil)
+          Middleware::Query::Indexes.start connection: self, table_name: table_name, query_name: query_name do |env|
+            env.index_definitions += indexes_without_schema_monkey env.table_name, env.query_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/active_record/connection_adapters/schema_statements.rb

@@ -0,0 +1,86 @@
+module SchemaMonkey
+  module ActiveRecord
+    module ConnectionAdapters
+      module SchemaStatements
+
+        #
+        # The hooks at the top level of this module are for the base class, which are not overriden by
+        # any specific adapters in AR.
+        #
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :add_index_options, :schema_monkey
+          end
+        end
+
+        def add_index_options_with_schema_monkey(table_name, column_names, options={})
+          cache = []
+          Middleware::Migration::IndexComponentsSql.start connection: self, table_name: table_name, column_names: Array.wrap(column_names), options: options.deep_dup do |env|
+            cache << env
+            env.sql.name, env.sql.type, env.sql.columns, env.sql.options, env.sql.algorithm, env.sql.using = add_index_options_without_schema_monkey(env.table_name, env.column_names, env.options)
+          end
+          env = cache[0]
+          [env.sql.name, env.sql.type, env.sql.columns, env.sql.options, env.sql.algorithm, env.sql.using]
+        end
+
+        #
+        # The hooks below here are grouped into modules.  Different
+        # connection adapters define this methods in different places, so
+        # each will include the hooks into the appropriate class
+        #
+
+        module Column
+          def self.included(base)
+            base.class_eval do
+              alias_method_chain :add_column, :schema_monkey
+              alias_method_chain :change_column, :schema_monkey
+            end
+          end
+
+          def add_column_with_schema_monkey(table_name, name, type, options = {})
+            Middleware::Migration::Column.start caller: self, operation: :add, table_name: table_name, column_name: name, type: type, options: options.deep_dup do |env|
+              add_column_without_schema_monkey env.table_name, env.column_name, env.type, env.options
+            end
+          end
+
+          def change_column_with_schema_monkey(table_name, name, type, options = {})
+            Middleware::Migration::Column.start caller: self, operation: :change, table_name: table_name, column_name: name, type: type, options: options.deep_dup do |env|
+              change_column_without_schema_monkey env.table_name, env.column_name, env.type, env.options
+            end
+          end
+        end
+
+        module Reference
+          def self.included(base)
+            base.class_eval do
+              alias_method_chain :add_reference, :schema_monkey
+            end
+          end
+          def add_reference_with_schema_monkey(table_name, name, options = {})
+            Middleware::Migration::Column.start caller: self, operation: :add, table_name: table_name, column_name: "#{name}_id", type: :reference, options: options.deep_dup do |env|
+              add_reference_without_schema_monkey env.table_name, env.column_name.sub(/_id$/, ''), env.options
+            end
+          end
+        end
+
+        module Index
+          def self.included(base)
+            base.class_eval do
+              alias_method_chain :add_index, :schema_monkey
+            end
+          end
+          def add_index_with_schema_monkey(table_name, column_names, options={})
+            if column_names.is_a? Hash and options.empty?
+                options = column_names
+                column_names = nil
+            end
+            Middleware::Migration::Index.start caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup do |env|
+              add_index_without_schema_monkey env.table_name, env.column_names, env.options
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_monkey/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,33 @@
+module SchemaMonkey
+  module ActiveRecord
+    module ConnectionAdapters
+      module Sqlite3Adapter
+
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :indexes, :schema_monkey
+            alias_method_chain :tables, :schema_monkey
+          end
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Column
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Reference
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::ActiveRecord::ConnectionAdapters::SchemaStatements::Index
+        end
+
+        def indexes_with_schema_monkey(table_name, query_name=nil)
+          Middleware::Query::Indexes.start connection: self, table_name: table_name, query_name: query_name do |env|
+            env.index_definitions += indexes_without_schema_monkey env.table_name, env.query_name
+          end
+        end
+
+        def tables_with_schema_monkey(query_name=nil, table_name=nil)
+          Middleware::Query::Tables.start connection: self, query_name: query_name, table_name: table_name do |env|
+            env.tables += tables_without_schema_monkey env.query_name, env.table_name
+          end
+        end
+
+      end
+    end
+  end
+end
+
+

data/lib/schema_monkey/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,40 @@
+module SchemaMonkey
+  module ActiveRecord
+    module ConnectionAdapters
+      module TableDefinition
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :column, :schema_monkey
+            alias_method_chain :references, :schema_monkey
+            alias_method_chain :belongs_to, :schema_monkey
+            alias_method_chain :index, :schema_monkey
+          end
+        end
+
+        def column_with_schema_monkey(name, type, options = {})
+          Middleware::Migration::Column.start caller: self, operation: :define, table_name: self.name, column_name: name, type: type, options: options.deep_dup do |env|
+            column_without_schema_monkey env.column_name, env.type, env.options
+          end
+        end
+
+        def references_with_schema_monkey(name, options = {})
+          Middleware::Migration::Column.start caller: self, operation: :define, table_name: self.name, column_name: "#{name}_id", type: :reference, options: options.deep_dup do |env|
+            references_without_schema_monkey env.column_name.sub(/_id$/, ''), env.options
+          end
+        end
+
+        def belongs_to_with_schema_monkey(name, options = {})
+          Middleware::Migration::Column.start caller: self, operation: :define, table_name: self.name, column_name: "#{name}_id", type: :reference, options: options.deep_dup do |env|
+            belongs_to_without_schema_monkey env.column_name.sub(/_id$/, ''), env.options
+          end
+        end
+
+        def index_with_schema_monkey(column_name, options = {})
+          Middleware::Migration::Index.start caller: self, operation: :define, table_name: self.name, column_names: column_name, options: options.deep_dup do |env|
+            index_without_schema_monkey env.column_names, env.options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/active_record/migration/command_recorder.rb

@@ -0,0 +1,19 @@
+module SchemaMonkey
+  module ActiveRecord
+    module Migration
+      module CommandRecorder
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :add_column, :schema_monkey
+          end
+        end
+
+        def add_column_with_schema_monkey(table_name, column_name, type, options = {})
+          Middleware::Migration::Column.start caller: self, operation: :record, table_name: table_name, column_name: column_name, type: type, options: options.deep_dup do |env|
+            add_column_without_schema_monkey env.table_name, env.column_name, env.type, env.options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/active_record/schema_dumper.rb

@@ -0,0 +1,179 @@
+require 'ostruct'
+require 'tsort'
+
+module SchemaMonkey
+  module ActiveRecord
+    module SchemaDumper
+
+      class Dump
+        include TSort
+
+        attr_reader :extensions, :tables, :dependencies, :data
+        attr_accessor :foreign_keys, :trailer
+
+        def initialize(dumper)
+          @dumper = dumper
+          @dependencies = Hash.new { |h, k| h[k] = [] }
+          @extensions = []
+          @tables = {}
+          @foreign_keys = []
+          @data = OpenStruct.new # a place for middleware to leave data
+        end
+
+        def depends(tablename, dependents)
+          @tables[tablename] ||= false # placeholder for dependencies applied before defining the table
+          @dependencies[tablename] += Array.wrap(dependents)
+        end
+
+        def assemble(stream)
+          stream.puts @extensions.join("\n") if extensions.any?
+          assemble_tables(stream)
+          foreign_keys.each do |statement|
+            stream.puts "  #{statement}"
+          end
+          stream.puts @trailer
+        end
+
+        def assemble_tables(stream)
+          tsort().each do |table|
+            @tables[table].assemble(stream) if @tables[table]
+          end
+        end
+
+        def tsort_each_node(&block)
+          @tables.keys.sort.each(&block)
+        end
+
+        def tsort_each_child(tablename, &block)
+          @dependencies[tablename].sort.uniq.reject{|t| @dumper.ignored? t}.each(&block)
+        end
+
+        class Table < KeyStruct[:name, :pname, :options, :columns, statements: [], trailer: []]
+
+          def assemble(stream)
+            stream.write "  create_table #{pname.inspect}"
+            stream.write ", #{options}" unless options.blank?
+            stream.puts " do |t|"
+            typelen = @columns.map{|col| col.type.length}.max
+            namelen = @columns.map{|col| col.name.length}.max
+            @columns.each do |column|
+              stream.write "    "
+              column.assemble(stream, typelen, namelen)
+              stream.puts ""
+            end
+            statements.each do |statement|
+              stream.puts "    #{statement}"
+            end
+            stream.puts "  end"
+            trailer.each do |statement|
+              stream.puts "  #{statement}"
+            end
+            stream.puts ""
+          end
+
+          class Column < KeyStruct[:name, :type, :options, :comments]
+
+            def add_option(option)
+              self.options = [options, option].reject(&:blank?).join(', ')
+            end
+
+            def add_comment(comment)
+              self.comments = [comments, comment].reject(&:blank?).join('; ')
+            end
+
+            def assemble(stream, typelen, namelen)
+              stream.write "t.%-#{typelen}s " % type
+              if options.blank? && comments.blank?
+                stream.write name.inspect
+              else
+                pr = name.inspect
+                pr += "," unless options.blank?
+                stream.write "%-#{namelen+3}s " % pr
+              end
+              stream.write "#{options}" unless options.blank?
+              stream.write " " unless options.blank? or comments.blank?
+              stream.write "# #{comments}" unless comments.blank?
+            end
+          end
+        end
+      end
+
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :dump, :schema_monkey
+          alias_method_chain :extensions, :schema_monkey
+          alias_method_chain :tables, :schema_monkey
+          alias_method_chain :table, :schema_monkey
+          alias_method_chain :foreign_keys, :schema_monkey
+          alias_method_chain :trailer, :schema_monkey
+          public :ignored?
+        end
+      end
+
+      def dump_with_schema_monkey(stream)
+        @dump = Dump.new(self)
+        dump_without_schema_monkey(stream)
+        @dump.assemble(stream)
+      end
+
+      def foreign_keys_with_schema_monkey(table, _)
+        stream = StringIO.new
+        foreign_keys_without_schema_monkey(table, stream)
+        @dump.foreign_keys += stream.string.split("\n").map(&:strip)
+      end
+
+      def trailer_with_schema_monkey(_)
+        stream = StringIO.new
+        trailer_without_schema_monkey(stream)
+        @dump.trailer = stream.string
+      end
+
+      def extensions_with_schema_monkey(_)
+        Middleware::Dumper::Extensions.start dumper: self, connection: @connection, extensions: @dump.extensions do |env|
+          stream = StringIO.new
+          extensions_without_schema_monkey(stream)
+          @dump.extensions << stream.string unless stream.string.blank?
+        end
+      end
+
+      def tables_with_schema_monkey(_)
+        Middleware::Dumper::Tables.start dumper: self, connection: @connection, dump: @dump do |env|
+          tables_without_schema_monkey(nil)
+        end
+      end
+
+      def table_with_schema_monkey(table, _)
+        Middleware::Dumper::Table.start dumper: self, connection: @connection, dump: @dump, table: @dump.tables[table] = Dump::Table.new(name: table) do |env|
+          stream = StringIO.new
+          table_without_schema_monkey(env.table.name, stream)
+          m = stream.string.match %r{
+          \A \s*
+            create_table \s*
+            [:'"](?<name>[^'"\s]+)['"]? \s*
+            ,? \s*
+            (?<options>.*) \s+
+            do \s* \|t\| \s* $
+          (?<columns>.*)
+          ^\s*end\s*$
+          (?<trailer>.*)
+          \Z
+          }xm
+          env.table.pname = m[:name]
+          env.table.options = m[:options].strip
+          env.table.trailer = m[:trailer].split("\n").map(&:strip).reject{|s| s.blank?}
+          env.table.columns = m[:columns].strip.split("\n").map { |col|
+            m = col.strip.match %r{
+            ^
+            t\.(?<type>\S+) \s*
+              [:'"](?<name>[^"\s]+)[,"]? \s*
+              ,? \s*
+              (?<options>.*)
+            $
+            }x
+            Dump::Table::Column.new(name: m[:name], type: m[:type], options: m[:options])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/middleware.rb

@@ -0,0 +1,113 @@
+module SchemaMonkey
+  module Middleware
+
+    class Base
+      def initialize(app)
+        @app = app
+      end
+      def continue(env)
+        @app.call env
+      end
+    end
+
+    module Stack
+      def stack
+        @stack ||= ::Middleware::Builder.new do
+          use Root
+        end
+      end
+
+      def append(middleware)
+        stack.insert_before(Root, middleware)
+      end
+
+      def prepend(middleware)
+        stack.insert(0, middleware)
+      end
+
+      def start(*args, &block)
+        env = self.const_get(:Env).new(*args)
+        env.instance_variable_set('@root', block)
+        stack.call(env)
+      end
+
+      class Root < Base
+        def call(env)
+          env.instance_variable_get('@root').call(env)
+        end
+      end
+    end
+
+    module Query
+      module ExecCache
+        extend Stack
+        Env = KeyStruct[:connection, :sql, :name, :binds]
+      end
+
+      module Tables
+        extend Stack
+        # :database and :like are only for mysql
+        # :table_name is only for sqlite3
+        Env = KeyStruct[:connection, :query_name, :table_name, :database, :like, tables: []]
+      end
+
+      module Indexes
+        extend Stack
+        Env = KeyStruct[:connection, :table_name, :query_name, index_definitions: []]
+      end
+    end
+
+    module Migration
+
+      module Column
+        extend Stack
+        Env = KeyStruct[:caller, :operation, :table_name, :column_name, :type, :options]
+      end
+
+      module ColumnOptionsSql
+        extend Stack
+        Env = KeyStruct[:caller, :connection, :sql, :options]
+      end
+
+      module Index
+        extend Stack
+        Env = KeyStruct[:caller, :operation, :table_name, :column_names, :options]
+      end
+
+      module IndexComponentsSql
+        extend Stack
+        Sql = KeyStruct[:name, :type, :columns, :options, :algorithm, :using]
+        Env = KeyStruct[:connection, :table_name, :column_names, :options, sql: Sql.new]
+      end
+
+    end
+
+    module Dumper
+      module Extensions
+        extend Stack
+        Env = KeyStruct[:dumper, :connection, :extensions]
+      end
+      module Tables
+        extend Stack
+        Env = KeyStruct[:dumper, :connection, :dump]
+      end
+      module Table
+        extend Stack
+        Env = KeyStruct[:dumper, :connection, :dump, :table]
+      end
+    end
+
+    module Model
+      module Columns
+        extend Stack
+        Env = KeyStruct[:model, :columns]
+      end
+      module ResetColumnInformation
+        extend Stack
+        Env = KeyStruct[:model]
+      end
+    end
+
+
+  end
+end

data/lib/schema_monkey/module_support.rb

@@ -0,0 +1,48 @@
+module SchemaMonkey
+  module ModuleSupport
+
+    def include_once(base, mod)
+      base.send(:include, mod) unless base.include? mod
+    end
+
+    def include_if_defined(base, parent, subname)
+      if submodule = get_const(parent, subname)
+        include_once(base, submodule)
+      end
+    end
+
+    def patch(base, parent = SchemaMonkey)
+      patch = get_const(parent, base)
+      raise "#{parent} does not contain a definition of #{base}" unless patch
+      include_once(base, patch)
+    end
+
+    # ruby 2.* supports mod.const_get("Component::Path") but ruby 1.9.3
+    # doesn't.  And neither has a version that can return nil rather than
+    # raising a NameError
+    def get_const(mod, name)
+      name.to_s.split('::').map(&:to_sym).each do |component|
+        begin
+          mod = mod.const_get(component, false)
+        rescue NameError
+          return nil
+        end
+      end
+      mod
+    end
+
+    def get_modules(parent, opts={})
+      opts = opts.keyword_args(:prefix, :match, :reject, :recursive, :respond_to, :and_self)
+      parent = get_const(parent, opts.prefix) if opts.prefix
+      return [] unless parent && parent.is_a?(Module)
+      modules = []
+      modules << parent if opts.and_self
+      modules += parent.constants.reject{|c| parent.autoload? c}.map{|c| parent.const_get(c)}.select(&it.is_a?(Module))
+      modules.reject! &it.to_s =~ opts.reject if opts.reject
+      modules.select! &it.to_s =~ opts.match if opts.match
+      modules.select! &it.respond_to?(opts.respond_to) if opts.respond_to
+      modules += modules.flat_map { |mod| get_modules(mod, opts.except(:prefix, :and_self)) } if opts.recursive
+      modules
+    end
+  end
+end

data/lib/schema_monkey/railtie.rb

@@ -0,0 +1,20 @@
+module SchemaMonkey
+  class Railtie < Rails::Railtie #:nodoc:
+
+    initializer 'schema_monkey.insert', :before => "active_record.initialize_database" do
+      ActiveSupport.on_load(:active_record) do
+        SchemaMonkey.insert
+      end
+    end
+
+    rake_tasks do
+      load 'rails/tasks/database.rake'
+      ['db:schema:dump', 'db:schema:load'].each do |name|
+        if task = Rake.application.tasks.find { |task| task.name == name }
+          task.enhance(["schema_monkey:load"])
+        end
+      end
+    end
+
+  end
+end

data/lib/schema_monkey/version.rb

@@ -0,0 +1,3 @@
+module SchemaMonkey
+  VERSION = "0.1.0"
+end

data/lib/schema_monkey.rb

@@ -0,0 +1,81 @@
+require 'hash_keyword_args'
+require 'key_struct'
+require 'middleware'
+
+require_relative "schema_monkey/middleware"
+require_relative "schema_monkey/module_support"
+require_relative "schema_monkey/active_record/base"
+require_relative "schema_monkey/active_record/connection_adapters/abstract_adapter"
+require_relative "schema_monkey/active_record/connection_adapters/table_definition"
+require_relative 'schema_monkey/active_record/connection_adapters/schema_statements'
+require_relative 'schema_monkey/active_record/migration/command_recorder'
+require_relative 'schema_monkey/active_record/schema_dumper'
+require_relative 'schema_monkey/railtie' if defined?(Rails::Railtie)
+
+module SchemaMonkey
+
+  extend SchemaMonkey::ModuleSupport
+
+  DBMS = [:Postgresql, :Mysql, :Sqlite3]
+
+  module ActiveRecord
+    module ConnectionAdapters
+      autoload :PostgresqlAdapter, 'schema_monkey/active_record/connection_adapters/postgresql_adapter'
+      autoload :MysqlAdapter, 'schema_monkey/active_record/connection_adapters/mysql_adapter'
+      autoload :Sqlite3Adapter, 'schema_monkey/active_record/connection_adapters/sqlite3_adapter'
+    end
+  end
+
+  def self.insert
+    insert_modules
+    include_adapters(::ActiveRecord::ConnectionAdapters::AbstractAdapter, :Abstract)
+    insert_middleware
+  end
+
+  def self.register(mod)
+    registered_modules << mod
+  end
+
+  def self.registered_modules
+    @registered_modules ||= [self]
+  end
+
+  def self.include_adapters(base, dbm)
+    registered_modules.each do |mod|
+      include_if_defined(base, mod, "ActiveRecord::ConnectionAdapters::#{dbm}Adapter")
+    end
+  end
+
+  def self.insert_modules
+    registered_modules.each do |mod|
+      get_modules(mod, prefix: 'ActiveRecord', match: /\bActiveRecord\b/, recursive: true).each do |candidate|
+        next if candidate.is_a?(Class)
+        if (base = get_const(::ActiveRecord, candidate.to_s.sub(/^#{mod}::ActiveRecord::/, '')))
+          patch base, mod
+        end
+      end
+      mod.insert if mod.respond_to?(:insert) and mod != self
+    end
+  end
+
+  def self.insert_middleware(dbm=nil)
+    @inserted ||= {}
+
+    if dbm
+      match = /\b#{dbm}\b/
+      reject = nil
+    else
+      match = nil
+      reject = /\b(#{DBMS.join('|')})\b/
+    end
+
+    registered_modules.each do |mod|
+      get_modules(mod, prefix: 'Middleware', and_self: true, match: match, reject: reject, recursive: true, respond_to: :insert).each do |middleware|
+        next if @inserted[middleware]
+        middleware.insert
+        @inserted[middleware] = true
+      end
+    end
+  end
+
+end

data/schema_dev.yml

@@ -0,0 +1,9 @@
+ruby:
+    - 1.9.3
+    - 2.1.5
+rails:
+    - 4.2
+db:
+    - mysql2
+    - sqlite3
+    - postgresql

data/schema_monkey.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schema_monkey/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "schema_monkey"
+  spec.version       = SchemaMonkey::VERSION
+  spec.authors       = ["ronen barzel"]
+  spec.email         = ["ronen@barzel.org"]
+  spec.summary       = %q{Provides an internal API and module inclusion protocol to facilitate adding features to ActiveRecord}
+  spec.description   = %q{Provides an internal API and module inclusion protocol to facilitate adding features to ActiveRecord}
+  spec.homepage      = "https://github.com/SchemaPlus/schema_monkey"
+  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.add_dependency "activerecord", "~> 4.2"
+  spec.add_dependency "hash_keyword_args"
+  spec.add_dependency "its-it"
+  spec.add_dependency "key_struct"
+  spec.add_dependency "middleware", "~> 0.1"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "schema_dev", "~> 1.4"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-gem-profile"
+end

data/spec/sanity_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+
+# A basic sanity check to have as a spec when first starting.  Feel free to delete this
+# once you've got real content.
+
+describe "Sanity Check" do
+
+  it "database is connected" do
+    expect(ActiveRecord::Base).to be_connected
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'simplecov'
+require 'simplecov-gem-profile'
+SimpleCov.start "gem"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rspec'
+require 'active_record'
+require 'schema_monkey'
+require 'schema_dev/rspec'
+
+SchemaDev::Rspec.setup
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.warnings = true
+end
+
+SimpleCov.command_name "[ruby #{RUBY_VERSION} - ActiveRecord #{::ActiveRecord::VERSION::STRING} - #{ActiveRecord::Base.connection.adapter_name}]"
+

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: schema_monkey
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ronen barzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: hash_keyword_args
+  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: its-it
+  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: key_struct
+  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: middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: schema_dev
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: simplecov-gem-profile
+  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: Provides an internal API and module inclusion protocol to facilitate
+  adding features to ActiveRecord
+email:
+- ronen@barzel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemfiles/Gemfile.base
+- gemfiles/rails-4.2/Gemfile.base
+- gemfiles/rails-4.2/Gemfile.mysql2
+- gemfiles/rails-4.2/Gemfile.postgresql
+- gemfiles/rails-4.2/Gemfile.sqlite3
+- lib/schema_monkey.rb
+- lib/schema_monkey/active_record/base.rb
+- lib/schema_monkey/active_record/connection_adapters/abstract_adapter.rb
+- lib/schema_monkey/active_record/connection_adapters/mysql_adapter.rb
+- lib/schema_monkey/active_record/connection_adapters/postgresql_adapter.rb
+- lib/schema_monkey/active_record/connection_adapters/schema_statements.rb
+- lib/schema_monkey/active_record/connection_adapters/sqlite3_adapter.rb
+- lib/schema_monkey/active_record/connection_adapters/table_definition.rb
+- lib/schema_monkey/active_record/migration/command_recorder.rb
+- lib/schema_monkey/active_record/schema_dumper.rb
+- lib/schema_monkey/middleware.rb
+- lib/schema_monkey/module_support.rb
+- lib/schema_monkey/railtie.rb
+- lib/schema_monkey/version.rb
+- schema_dev.yml
+- schema_monkey.gemspec
+- spec/sanity_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/SchemaPlus/schema_monkey
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Provides an internal API and module inclusion protocol to facilitate adding
+  features to ActiveRecord
+test_files:
+- spec/sanity_spec.rb
+- spec/spec_helper.rb