schema_monkey 0.4.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79b4b171241c85efd322e1110d21c832a3496ed8
-  data.tar.gz: ffd34501fbe45a95ed29750639c4e1dca540e6f0
+  metadata.gz: 63717b66e73fd1bf6bd109a53e4a9923e47067b2
+  data.tar.gz: 86c7b56f67c7b9c54a816e90f6e4309e1d766e20
 SHA512:
-  metadata.gz: 46d478aa24930337a10ce7fa4d672246fa6b6eb2c2ff214ed78eaa09ba6a8c84b751cdb6ba270bbc5efd0a14a4bcf7d262c0bb5ed8d045a361295d133488d9b0
-  data.tar.gz: 4cc5f36af665873d97bc8d8a1e502d8b1564cb79e60597708fd11a97745f6dfd3d3866eeb5aefa09e5a4459ecfa8c6afce2119189d4643c8a84c36393ebeeea0
+  metadata.gz: 0146db8b1769a7b59f797bae5960c003f6cf59296681d381af3356e2f1c6d7e4dbe9223e36167dff098e1a0c2846131655a87f2ad5780cae0b5a0c4c8ae355ce
+  data.tar.gz: 140723e774bd68a0356bd64d041eaa8035c535f06b3ded87bbd2d642be72899f09a7babaefbdb449c5c2e35b225bbe5313fcb225b7169f5fa67e1dd4c0d1efc6

data/README.md

@@ -11,7 +11,6 @@ SchemaMonkey is a behind-the-scenes gem to facilitate writing extensions to Acti
 
 * A convention-based protocol for `include`'ing custom modules into ActiveRecord.  You just define your modules and SchemaMonkey will automatically include them in the right places.
 
-* (If you're using Rails) It takes care of setting up a Railtie appropriately to invoke the extensions.
 
 The middleware interface has two benefits: it provides a clean API so that the gem or aplication code doesn't need to monkey-patch ActiveRecord (SchemaMonkey does all the monkey-patching for you), and it lets multiple client gems operate in parallel without concern about conflicting monkey-patches.
 
@@ -30,6 +29,14 @@ gem "schema_monkey", "~> <MAJOR>.<MINOR>", ">= <MAJOR>.<MINOR>.<PATCH>"
 
 SchemaMonkey follows semantic versioning; it's a good idea to explicitly use the `~>` and `>=` dependencies to make sure your gem's clients don't accidentally pull in a version of SchemaMonkey that your gem isn't compatible with.
 
+To use with a rails app, also include
+
+```ruby
+gem "schema_monkey_rails"
+```
+
+which creates a Railtie to insert SchemaMonkey appropriately into the rails stack.
+
 ## Compatibility
 
 SchemaMonkey is tested on:
@@ -44,7 +51,7 @@ SchemaMonkey is tested on:
 ## Usage
 
 
-**Sorry -- no real documentation yet.  Too much is still in flux.**
+**Sorry -- no real documentation yet. See examples in [schema_plus_indexes](https://github/SchemaPlus/schema_plus_indexes) and [schema_plus_pg_indexes](https://github/SchemaPlus/schema_plus_pg_indexes)**
 
 
 
@@ -55,7 +62,13 @@ the standard protocol: fork, feature branch, develop, push, and issue pull reque
 
 Some things to know about to help you develop and test:
 
-* **Ugh -- not many specs yet.  SchemaMonkey is currently tested indirectly by testing the client gems that use it.  Working on it...**
+* SchemaMonkey is a wrapper around two subparts:
+
+  * `SchemaMonkey::Tool` provides the convention-based mechanism for registering clients that extend ActiveRecord using `include`'s and middleware.
+  
+  * `SchemaMonkey::CoreExtensions` defines the ActiveRecord extension API. It is itself just the first client registered with `SchemaMonkey::Tool`.  **Ugh. Currently no specs for `SchemaMonkey::CoreExtensions`;  testing indirectly by testing the client gems that use it.  Working on it...**
+
+  One day might actually split these into separate gems to decouple their development and testing.  And actually the middleware mechanism of `SchemaMonkey::Tool` could be a split out separate gem.
 
 * **schema_dev**:  SchemaMonkey uses [schema_dev](https://github.com/SchemaPlus/schema_dev) to
   facilitate running rspec tests on the matrix of ruby, rails, and database

data/lib/schema_monkey.rb

@@ -1,45 +1,40 @@
-require 'hash_keyword_args'
-require 'its-it'
-require 'key_struct'
-require 'middleware'
-require 'active_record'
-require 'active_support/core_ext/string'
-
-require_relative "schema_monkey/client"
-require_relative "schema_monkey/middleware"
-require_relative "schema_monkey/module"
-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/rake'
+require_relative "schema_monkey/core_extensions"
+require_relative "schema_monkey/tool"
 
+# 
+# Middleware contents will be created dynamically
+#
 module SchemaMonkey
-  extend Module
-
-  DBMS = [:PostgreSQL, :Mysql, :SQLite3]
-
-  module ActiveRecord
-    module ConnectionAdapters
-      autoload :PostgresqlAdapter, 'schema_monkey/active_record/connection_adapters/postgresql_adapter'
-      autoload :Mysql2Adapter, 'schema_monkey/active_record/connection_adapters/mysql2_adapter'
-      autoload :Sqlite3Adapter, 'schema_monkey/active_record/connection_adapters/sqlite3_adapter'
-    end
+  module Middleware
   end
+end
 
+#
+# Wrap public API of SchemaMonkey::Tool
+#
+module SchemaMonkey
   def self.register(mod)
-    clients << Client.new(mod)
+    Tool::register(mod)
   end
 
-  def self.clients
-    @clients ||= [Client.new(self)]
+  def self.insert(opts={})
+    Tool::insert(opts)
   end
 
-  def self.insert(opts={})
-    opts = opts.keyword_args(:dbm)
-    clients.each &it.insert(dbm: opts.dbm)
+  def self.include_once(*args)
+    Tool::Module.include_once(*args)
+  end
+
+  module Rake
+    def self.insert(*args)
+      Tool::Rake::insert(*args)
+    end
   end
 
+  MiddlewareError = Tool::MiddlewareError
 end
+
+#
+# Register CoreExtensions
+#
+SchemaMonkey::Tool.register(SchemaMonkey::CoreExtensions)

data/lib/schema_monkey/core_extensions.rb

@@ -0,0 +1,23 @@
+require 'active_record'
+require 'key_struct'
+
+module SchemaMonkey
+  module CoreExtensions
+    module ActiveRecord
+      module ConnectionAdapters
+        DIR = Pathname.new(__FILE__).dirname + 'core_extensions/active_record/connection_adapters'
+        autoload :PostgresqlAdapter,    DIR + 'postgresql_adapter'
+        autoload :Mysql2Adapter,        DIR + 'mysql2_adapter'
+        autoload :Sqlite3Adapter,       DIR + 'sqlite3_adapter'
+      end
+    end
+  end
+end
+
+require_relative "core_extensions/active_record/base"
+require_relative "core_extensions/active_record/connection_adapters/abstract_adapter"
+require_relative "core_extensions/active_record/connection_adapters/table_definition"
+require_relative 'core_extensions/active_record/connection_adapters/schema_statements'
+require_relative 'core_extensions/active_record/migration/command_recorder'
+require_relative 'core_extensions/active_record/schema_dumper'
+require_relative "core_extensions/middleware"

data/lib/schema_monkey/{active_record → core_extensions/active_record}/base.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
 
     module Base
@@ -15,13 +15,13 @@ module SchemaMonkey
         end
 
         def columns_with_schema_monkey
-          Middleware::Model::Columns.start model: self, columns: [] do |env|
+          SchemaMonkey::Middleware::Model::Columns.start(model: self, columns: []) { |env|
             env.columns += columns_without_schema_monkey
-          end
+          }.columns
         end
 
         def reset_column_information_with_schema_monkey
-          Middleware::Model::ResetColumnInformation.start model: self do |env|
+          SchemaMonkey::Middleware::Model::ResetColumnInformation.start(model: self) do |env|
             reset_column_information_without_schema_monkey
           end
         end

data/lib/schema_monkey/{active_record → core_extensions/active_record}/connection_adapters/abstract_adapter.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module ConnectionAdapters
       module AbstractAdapter
@@ -27,9 +27,9 @@ module SchemaMonkey
           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|
+            SchemaMonkey::Middleware::Migration::ColumnOptionsSql.start(caller: self, connection: self.instance_variable_get('@conn'), sql: sql, options: options) { |env|
               add_column_options_without_schema_monkey! env.sql, env.options
-            end
+            }.sql
           end
         end
       end

data/lib/schema_monkey/{active_record → core_extensions/active_record}/connection_adapters/mysql2_adapter.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module ConnectionAdapters
       module Mysql2Adapter
@@ -8,21 +8,21 @@ module SchemaMonkey
             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
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, SchemaMonkey::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Column
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, SchemaMonkey::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Reference
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter, SchemaMonkey::CoreExtensions::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, index_definitions: [] do |env|
+          SchemaMonkey::Middleware::Query::Indexes.start(connection: self, table_name: table_name, query_name: query_name, index_definitions: []) { |env|
             env.index_definitions += indexes_without_schema_monkey env.table_name, env.query_name
-          end
+          }.index_definitions
         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, tables: [] do |env|
+          SchemaMonkey::Middleware::Query::Tables.start(connection: self, query_name: query_name, database: database, like: like, tables: []) { |env|
             env.tables += tables_without_schema_monkey env.query_name, env.database, env.like
-          end
+          }.tables
         end
       end
     end

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

@@ -0,0 +1,30 @@
+module SchemaMonkey::CoreExtensions
+  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::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Reference
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements, SchemaMonkey::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Column
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements, SchemaMonkey::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Index
+        end
+
+        def exec_cache_with_schema_monkey(sql, name, binds)
+          SchemaMonkey::Middleware::Query::ExecCache.start(connection: self, sql: sql, name: name, binds: binds) { |env|
+            env.result = exec_cache_without_schema_monkey(env.sql, env.name, env.binds)
+          }.result
+        end
+
+        def indexes_with_schema_monkey(table_name, query_name=nil)
+          SchemaMonkey::Middleware::Query::Indexes.start(connection: self, table_name: table_name, query_name: query_name, index_definitions: []) { |env|
+            env.index_definitions += indexes_without_schema_monkey env.table_name, env.query_name
+          }.index_definitions
+        end
+      end
+    end
+  end
+end

data/lib/schema_monkey/{active_record → core_extensions/active_record}/connection_adapters/schema_statements.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module ConnectionAdapters
       module SchemaStatements
@@ -13,13 +13,12 @@ module SchemaMonkey
           end
         end
 
+        IndexComponentsSql = KeyStruct[:name, :type, :columns, :options, :algorithm, :using]
+
         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 = SchemaMonkey::Middleware::Migration::IndexComponentsSql.start(connection: self, table_name: table_name, column_names: Array.wrap(column_names), options: options.deep_dup, sql: IndexComponentsSql.new) { |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
 
@@ -38,13 +37,13 @@ module SchemaMonkey
           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|
+            SchemaMonkey::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|
+            SchemaMonkey::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
@@ -57,7 +56,7 @@ module SchemaMonkey
             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|
+            SchemaMonkey::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
@@ -72,7 +71,7 @@ module SchemaMonkey
           def add_index_with_schema_monkey(*args)
             options = args.extract_options!
             table_name, column_names = args
-            Middleware::Migration::Index.start caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup do |env|
+            SchemaMonkey::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

data/lib/schema_monkey/{active_record → core_extensions/active_record}/connection_adapters/sqlite3_adapter.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module ConnectionAdapters
       module Sqlite3Adapter
@@ -8,21 +8,21 @@ module SchemaMonkey
             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
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Column
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::CoreExtensions::ActiveRecord::ConnectionAdapters::SchemaStatements::Reference
+          SchemaMonkey.include_once ::ActiveRecord::ConnectionAdapters::SchemaStatements, SchemaMonkey::CoreExtensions::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, index_definitions: [] do |env|
+          SchemaMonkey::Middleware::Query::Indexes.start(connection: self, table_name: table_name, query_name: query_name, index_definitions: []) { |env|
             env.index_definitions += indexes_without_schema_monkey env.table_name, env.query_name
-          end
+          }.index_definitions
         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, tables: [] do |env|
+          SchemaMonkey::Middleware::Query::Tables.start(connection: self, query_name: query_name, table_name: table_name, tables: []) { |env|
             env.tables += tables_without_schema_monkey env.query_name, env.table_name
-          end
+          }.tables
         end
 
       end

data/lib/schema_monkey/{active_record → core_extensions/active_record}/connection_adapters/table_definition.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module ConnectionAdapters
       module TableDefinition
@@ -12,19 +12,19 @@ module SchemaMonkey
         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|
+          SchemaMonkey::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|
+          SchemaMonkey::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|
+          SchemaMonkey::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
@@ -32,7 +32,7 @@ module SchemaMonkey
         def index_with_schema_monkey(*args)
           options = args.extract_options!
           column_name = args.first
-          Middleware::Migration::Index.start caller: self, operation: :define, table_name: self.name, column_names: column_name, options: options.deep_dup do |env|
+          SchemaMonkey::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

data/lib/schema_monkey/{active_record → core_extensions/active_record}/migration/command_recorder.rb

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module Migration
       module CommandRecorder
@@ -9,7 +9,7 @@ module SchemaMonkey
         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|
+          SchemaMonkey::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

data/lib/schema_monkey/{active_record → core_extensions/active_record}/schema_dumper.rb

@@ -1,7 +1,7 @@
 require 'ostruct'
 require 'tsort'
 
-module SchemaMonkey
+module SchemaMonkey::CoreExtensions
   module ActiveRecord
     module SchemaDumper
 
@@ -157,7 +157,7 @@ module SchemaMonkey
       end
 
       def extensions_with_schema_monkey(_)
-        Middleware::Dumper::Extensions.start dumper: self, connection: @connection, dump: @dump, extensions: @dump.extensions do |env|
+        SchemaMonkey::Middleware::Dumper::Extensions.start(dumper: self, connection: @connection, dump: @dump, extensions: @dump.extensions) do |env|
           stream = StringIO.new
           extensions_without_schema_monkey(stream)
           env.dump.extensions << stream.string unless stream.string.blank?
@@ -165,13 +165,13 @@ module SchemaMonkey
       end
 
       def tables_with_schema_monkey(_)
-        Middleware::Dumper::Tables.start dumper: self, connection: @connection, dump: @dump do |env|
+        SchemaMonkey::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|
+        SchemaMonkey::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{
@@ -204,7 +204,7 @@ module SchemaMonkey
       end
 
       def indexes_with_schema_monkey(table, _)
-        Middleware::Dumper::Indexes.start dumper: self, connection: @connection, dump: @dump, table: @dump.tables[table] do |env|
+        SchemaMonkey::Middleware::Dumper::Indexes.start(dumper: self, connection: @connection, dump: @dump, table: @dump.tables[table]) do |env|
           stream = StringIO.new
           indexes_without_schema_monkey(env.table.name, stream)
           env.table.indexes += stream.string.split("\n").map { |string|

data/lib/schema_monkey/core_extensions/middleware.rb

@@ -0,0 +1,62 @@
+module SchemaMonkey::CoreExtensions
+  module Middleware
+    module Query
+      module ExecCache
+        ENV = [:connection, :sql, :name, :binds, :result]
+      end
+
+      module Tables
+        # :database and :like are only for mysql
+        # :table_name is only for sqlite3
+        ENV = [:connection, :query_name, :table_name, :database, :like, :tables]
+      end
+
+      module Indexes
+        ENV = [:connection, :table_name, :query_name, :index_definitions]
+      end
+    end
+
+    module Migration
+      module Column
+        ENV = [:caller, :operation, :table_name, :column_name, :type, :options]
+      end
+
+      module ColumnOptionsSql
+        ENV = [:caller, :connection, :sql, :options]
+      end
+
+      module Index
+        ENV = [:caller, :operation, :table_name, :column_names, :options]
+      end
+
+      module IndexComponentsSql
+        ENV = [:connection, :table_name, :column_names, :options, :sql]
+      end
+    end
+
+    module Dumper
+      module Extensions
+        ENV = [:dumper, :connection, :dump, :extensions]
+      end
+      module Tables
+        ENV = [:dumper, :connection, :dump]
+      end
+      module Table
+        ENV = [:dumper, :connection, :dump, :table]
+      end
+      module Indexes
+        ENV = [:dumper, :connection, :dump, :table]
+      end
+    end
+
+    module Model
+      module Columns
+        ENV = [:model, :columns]
+      end
+      module ResetColumnInformation
+        ENV = [:model]
+      end
+    end
+
+  end
+end

data/lib/schema_monkey/tool.rb

@@ -0,0 +1,43 @@
+require 'hash_keyword_args'
+require 'its-it'
+require 'key_struct'
+require 'active_support/core_ext/string'
+
+require_relative "tool/client"
+require_relative "tool/errors"
+require_relative "tool/module"
+require_relative "tool/monkey"
+require_relative "tool/stack"
+require_relative 'tool/rake'
+
+module SchemaMonkey
+  module Tool
+
+    DBMS = [:PostgreSQL, :Mysql, :SQLite3]
+
+    def self.register(mod)
+      monkey.register(mod)
+    end
+
+    def self.insert(opts={})
+      monkey.insert(opts)
+    end
+
+    private
+
+    def self.monkey
+      @monkey ||= Monkey.new
+    end
+
+    def self.reset_for_rspec
+      @monkey = nil
+      self.reset_middleware
+    end
+
+    def self.reset_middleware
+      SchemaMonkey.send :remove_const, :Middleware
+      SchemaMonkey.send :const_set, :Middleware, ::Module.new
+    end
+
+  end
+end

data/lib/schema_monkey/{client.rb → tool/client.rb}

@@ -1,6 +1,9 @@
-module SchemaMonkey
+module SchemaMonkey::Tool
   class Client
-    def initialize(mod)
+    attr_reader :monkey
+
+    def initialize(monkey, mod)
+      @monkey = monkey
       @root = mod
       @inserted = {}
     end
@@ -14,23 +17,27 @@ module SchemaMonkey
 
     def include_modules(opts={})
       opts = opts.keyword_args(:dbm)
+      # Kernel.warn "--- include modules for #{@root}, dbm=#{opts.dbm.inspect}"
       find_modules(:ActiveRecord, dbm: opts.dbm).each do |mod|
         next if mod.is_a? Class
         component = mod.to_s.sub(/^#{@root}::ActiveRecord::/, '')
         component = component.gsub(/#{opts.dbm}/i, opts.dbm.to_s) if opts.dbm # canonicalize case
-        next unless base = Module.get_const(::ActiveRecord, component)
-        # Kernel.warn "including #{mod}"
+        next unless base = Module.const_lookup(::ActiveRecord, component)
+        # Kernel.warn "including #{mod} (dbm=#{opts.dbm})"
         Module.include_once base, mod
       end
     end
 
     def insert_middleware(opts={})
       opts = opts.keyword_args(:dbm)
-      find_modules(:Middleware, dbm: opts.dbm, and_self: true).each do |mod|
+      find_modules(:Middleware, dbm: opts.dbm).each do |mod|
         next if @inserted[mod]
-        next unless mod.respond_to? :insert
-        # Kernel.warn "inserting #{mod}"
-        mod.insert
+
+        stack_path = mod.to_s.sub(/^#{@root}::Middleware::/, '')
+        stack_path = stack_path.split('::').reject(&it =~/\b#{opts.dbm}\b/i).join('::') if opts.dbm
+
+        monkey.insert_middleware_hook(mod, stack_path: stack_path) unless stack_path.empty?
+
         @inserted[mod] = true
       end
     end
@@ -38,19 +45,18 @@ module SchemaMonkey
     private
 
     def find_modules(container, opts={})
-      opts = opts.keyword_args(dbm: nil, and_self: nil)
-      return [] unless (container = Module.get_const(@root, container))
+      opts = opts.keyword_args(dbm: nil)
+      return [] unless (container = Module.const_lookup @root, container)
 
       if opts.dbm
         accept = /\b#{opts.dbm}/i
         reject = nil
       else
         accept = nil
-        reject = /\b#{SchemaMonkey::DBMS.join('|')}/i
+        reject = /\b(#{DBMS.join('|')})/i
       end
 
       modules = []
-      modules << container if opts.and_self
       modules += Module.descendants(container, can_load: accept)
       modules.select!(&it.to_s =~ accept) if accept
       modules.reject!(&it.to_s =~ reject) if reject

data/lib/schema_monkey/tool/errors.rb

@@ -0,0 +1,4 @@
+module SchemaMonkey::Tool
+  class MiddlewareError < Exception
+  end
+end

data/lib/schema_monkey/{module.rb → tool/module.rb}

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::Tool
   module Module
     extend self
 
@@ -9,7 +9,7 @@ module SchemaMonkey
     # ruby 2.* supports mod.const_get("Component::Path") but ruby 1.9.3
     # doesn't.  And neither has an option to return nil rather than raising
     # a NameError
-    def get_const(mod, name)
+    def const_lookup(mod, name)
       name.to_s.split('::').map(&:to_sym).each do |component|
         begin
           mod = mod.const_get(component, false)
@@ -29,5 +29,12 @@ module SchemaMonkey
       children + children.flat_map {|c| descendants(c, can_load: opts.can_load) }
     end
 
+    def mkpath(mod, path)
+      path.split('::').each do |component|
+        mod = const_lookup(mod, component) || mod.const_set(component, ::Module.new)
+      end
+      mod
+    end
+
   end
 end

data/lib/schema_monkey/tool/monkey.rb

@@ -0,0 +1,46 @@
+module SchemaMonkey::Tool
+
+  # The main manager for the monkey patches.  Singleton instance 
+  # created by SchemaMonkey.monkey
+
+  class Monkey
+
+    attr_reader :clients, :stacks
+
+    def initialize
+      @clients = []
+    end
+
+    def register(mod)
+      clients << Client.new(self, mod)
+    end
+
+    def insert(opts={})
+      opts = opts.keyword_args(:dbm)
+      clients.each &it.insert(dbm: opts.dbm)
+    end
+
+    def insert_middleware_hook(mod, opts={})
+      opts = opts.keyword_args(stack_path: :required)
+
+      return unless Stack.is_hook?(mod)
+
+      stack = Module.const_lookup SchemaMonkey::Middleware, opts.stack_path
+      env = Module.const_lookup mod, "ENV"
+
+      case
+      when stack && env
+        raise MiddlewareError, "#{mod}::ENV: stack #{stack} is already defined"
+      when !stack && !env
+        raise MiddlewareError, "#{mod}: No stack #{SchemaMonkey::Middleware}::#{opts.stack_path}"
+      when !stack && env
+        stack = Module.mkpath SchemaMonkey::Middleware, opts.stack_path
+        stack.send :extend, Stack::StartMethod
+        stack.send :stack=, Stack.new(module: stack, env: env)
+      end
+
+      stack.stack.append(mod)
+    end
+
+  end
+end

data/lib/schema_monkey/{rake.rb → tool/rake.rb}

@@ -1,4 +1,4 @@
-module SchemaMonkey
+module SchemaMonkey::Tool
   module Rake
     TASKS_PATH = Pathname.new(__FILE__).dirname + "tasks"
 

data/lib/schema_monkey/tool/stack.rb

@@ -0,0 +1,90 @@
+module SchemaMonkey::Tool
+  class Stack
+    def initialize(opts={})
+      opts = opts.keyword_args(module: :required, env: :required)
+      @module = opts.module
+      @env_class = @module.const_set "Env", KeyStruct[*opts.env]
+      @hooks = []
+    end
+
+    def self.is_hook?(mod)
+      return true if (mod.instance_methods & [:before, :around, :after, :implementation]).any?
+      return true if Module.const_lookup mod, "ENV"
+      false
+    end
+
+    def append(mod)
+      hook = Hook.new(self, mod)
+      @hooks.last._next = hook if @hooks.any?
+      @hooks << hook
+    end
+
+    def start(env_opts, &implementation)
+      env = @env_class.new(env_opts)
+      @implementation = implementation
+
+      @hooks.each do |hook|
+        hook.before env if hook.respond_to? :before
+      end
+
+      @hooks.first._call(env)
+
+      @hooks.each do |hook|
+        hook.after env if hook.respond_to? :after
+      end
+
+      env
+    end
+
+    def call_implementation(env)
+      if hook = @hooks.select(&it.respond_to?(:implementation)).last
+        hook.implementation(env)
+      elsif @implementation
+        @implementation.call env
+      else
+        raise MiddlewareError, "No implementation for middleware stack #{@module}"
+      end
+    end
+
+    class Hook
+      attr_accessor :_next
+
+      def initialize(stack, mod)
+        @stack = stack
+        singleton_class.send :include, mod
+      end
+
+      def _call(env)
+        if respond_to? :around
+          around(env) { |env|
+            _continue env
+          }
+        else
+          _continue env
+        end
+      end
+
+      def _continue(env)
+        if self._next
+          self._next._call(env)
+        else
+          @stack.call_implementation(env)
+        end
+      end
+    end
+
+    module StartMethod
+      attr_reader :stack
+
+      def start(env, &block)
+        stack.start(env, &block)
+      end
+
+      private
+
+      def stack=(stack)
+        @stack = stack
+      end
+    end
+  end
+end

data/lib/schema_monkey/version.rb

@@ -1,3 +1,3 @@
 module SchemaMonkey
-  VERSION = "0.4.1"
+  VERSION = "1.0.0"
 end

data/schema_monkey.gemspec

@@ -22,7 +22,6 @@ Gem::Specification.new do |spec|
   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"

data/spec/middleware_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe SchemaMonkey::Middleware do
+
+  When(:insertion) { SchemaMonkey.insert }
+
+  context "with stack registered" do
+
+    Given { SchemaMonkey.register make_definition }
+
+    Then { expect(defined?(SchemaMonkey::Middleware::Group::Stack)).to be_truthy }
+
+    context "when start with no implementation" do
+
+      When(:env) { SchemaMonkey::Middleware::Group::Stack.start result: [] }
+
+      Then { expect(env).to have_failed(SchemaMonkey::MiddlewareError, /implementation/) }
+    end
+
+    context "when start with inline implementation" do
+
+      When(:env) { SchemaMonkey::Middleware::Group::Stack.start result: [] { |env| env.result << :inline } }
+
+      Then { expect(env.result).to eq [:inline] }
+
+      context "if register client1" do
+
+        Given { SchemaMonkey.register make_client(1) }
+
+        Then { expect(env.result).to eq [:before1, :around_pre1, :implementation1, :around_post1, :after1 ] }
+
+        context "if register client2" do
+
+          Given { SchemaMonkey.register make_client(2) }
+
+          Then { expect(env.result).to eq [:before1, :before2, :around_pre1, :around_pre2, :implementation2, :around_post2, :around_post1, :after1, :after2 ] }
+        end
+      end
+    end
+
+    context "if register again" do
+      Given { SchemaMonkey.register make_definition }
+      Then { expect(insertion).to have_failed(SchemaMonkey::MiddlewareError, /already defined/i) }
+    end
+  end
+
+  context "without stack registered" do
+    context "if register client1" do
+      Given { SchemaMonkey.register make_client(1) }
+
+      Then { expect(insertion).to have_failed(SchemaMonkey::MiddlewareError, /no stack/i) }
+    end
+  end
+
+
+  def make_definition
+    Module.new.tap(&it.module_eval(<<-END))
+      module Middleware
+        module Group
+          module Stack
+            ENV = [:result]
+          end
+        end
+      end
+    END
+  end
+
+  def make_client(n)
+    Module.new.tap(&it.module_eval(<<-END))
+      module Middleware
+        module Group
+          module Stack
+            def before(env)
+              env.result << :"before#{n}"
+            end
+
+            def after(env)
+              env.result << :"after#{n}"
+            end
+
+            def around(env)
+              env.result << :"around_pre#{n}"
+              yield env
+              env.result << :"around_post#{n}"
+            end
+
+            def implementation(env)
+              env.result << :"implementation#{n}"
+            end
+          end
+        end
+      end
+    END
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'simplecov'
 require 'simplecov-gem-profile'
-SimpleCov.start "gem"
+SimpleCov.start "gem" do
+  add_filter "/tasks/"
+end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -17,6 +19,9 @@ Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
   config.warnings = true
+  config.after(:each) do
+    SchemaMonkey::Tool.reset_for_rspec
+  end
 end
 
 SimpleCov.command_name "[ruby #{RUBY_VERSION} - ActiveRecord #{::ActiveRecord::VERSION::STRING} - #{ActiveRecord::Base.connection.adapter_name}]"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema_monkey
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 1.0.0
 platform: ruby
 authors:
 - ronen barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-01 00:00:00.000000000 Z
+date: 2015-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,20 +66,6 @@ dependencies:
     - - ">="
       - !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
@@ -198,24 +184,30 @@ files:
 - gemfiles/activerecord-4.2/Gemfile.postgresql
 - gemfiles/activerecord-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/mysql2_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/client.rb
-- lib/schema_monkey/middleware.rb
-- lib/schema_monkey/module.rb
-- lib/schema_monkey/rake.rb
-- lib/schema_monkey/tasks/insert.rake
+- lib/schema_monkey/core_extensions.rb
+- lib/schema_monkey/core_extensions/active_record/base.rb
+- lib/schema_monkey/core_extensions/active_record/connection_adapters/abstract_adapter.rb
+- lib/schema_monkey/core_extensions/active_record/connection_adapters/mysql2_adapter.rb
+- lib/schema_monkey/core_extensions/active_record/connection_adapters/postgresql_adapter.rb
+- lib/schema_monkey/core_extensions/active_record/connection_adapters/schema_statements.rb
+- lib/schema_monkey/core_extensions/active_record/connection_adapters/sqlite3_adapter.rb
+- lib/schema_monkey/core_extensions/active_record/connection_adapters/table_definition.rb
+- lib/schema_monkey/core_extensions/active_record/migration/command_recorder.rb
+- lib/schema_monkey/core_extensions/active_record/schema_dumper.rb
+- lib/schema_monkey/core_extensions/middleware.rb
+- lib/schema_monkey/tool.rb
+- lib/schema_monkey/tool/client.rb
+- lib/schema_monkey/tool/errors.rb
+- lib/schema_monkey/tool/module.rb
+- lib/schema_monkey/tool/monkey.rb
+- lib/schema_monkey/tool/rake.rb
+- lib/schema_monkey/tool/stack.rb
+- lib/schema_monkey/tool/tasks/insert.rake
 - lib/schema_monkey/version.rb
 - schema_dev.yml
 - schema_monkey.gemspec
 - spec/connection_spec.rb
+- spec/middleware_spec.rb
 - spec/rake_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/SchemaPlus/schema_monkey
@@ -245,5 +237,6 @@ summary: Provides an internal API and module inclusion protocol to facilitate ad
   features to ActiveRecord
 test_files:
 - spec/connection_spec.rb
+- spec/middleware_spec.rb
 - spec/rake_spec.rb
 - spec/spec_helper.rb

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

@@ -1,30 +0,0 @@
-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, index_definitions: [] 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/middleware.rb

@@ -1,117 +0,0 @@
-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, :dump, :extensions]
-      end
-      module Tables
-        extend Stack
-        Env = KeyStruct[:dumper, :connection, :dump]
-      end
-      module Table
-        extend Stack
-        Env = KeyStruct[:dumper, :connection, :dump, :table]
-      end
-      module Indexes
-        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