schema_monkey 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2090c17d3f5bba79e1885f2f76a22a8c0bfcb389
-  data.tar.gz: d8fecf5bea771ace12cf1511583098408f9e2f38
+  metadata.gz: e2ba91ff751129e56965c986ca35a5ca8c7a4996
+  data.tar.gz: 48fac590947b7de42eeb8137eac0ec79639eb544
 SHA512:
-  metadata.gz: e2fdef632c27ed6619821a0b9fed86d1931a86eea897991ca0a98c88af7f7c3dfcb855243499f29af6c9d4f25397e6c3e42d2a630555eea14b820709c48cb808
-  data.tar.gz: ee53c8e8d0b1d7cb4dd824096cf208475ab16dc56cd2a9c5f2e84a844d00adcff40a60345809a30c98ed1e39bbd076c48417e642c01a1126836d1b060ebc5749
+  metadata.gz: 2f989b848d4dd7b49d970c7e65faa96ddf503a05c24463d0e8737f3f136fd0e1175181d65b649964d66ac9aae0f5977f039cb5b5d7b803e73bf448975899e92e
+  data.tar.gz: 8674917f2c77a10d16d1d52c9b54ed2bafc4386f869588d401fdbece2ae731b1e1a2787c6587e0c98c04caa11363b35d058f9fac772b1bd7de1ab240279513ff

data/README.md

@@ -35,8 +35,8 @@ SchemaMonkey works with the notion of a "client" -- which is a module containini
 
 ```ruby
 require 'schema_monkey'
-require 'other-client1'   # if needed
-require 'other-client2'   # as needed
+require 'other-client1'   # make sure clients you depend on are registered
+require 'other-client2'   # first, if/as needed.
 
 module MyClient
 
@@ -51,7 +51,7 @@ module MyClient
     # middleware stack modules, if any
     #
   end
-  
+
 end
 
 SchemaMonkey.register MyClient     # <--- That's it!  No configuration needed
@@ -86,19 +86,19 @@ require 'schema_monkey'
 module PracticalJoker
   module ActiveRecord
     module Base
-       
+
        def save(*args)
          raise "April Fools!" if Time.now.yday == 31
          super
        end
-       
+
        module ClassMethods
          def columns
            raise "Boo!" if Time.now.yday == 304
            super
          end
        end
-       
+
       end
     end
   end
@@ -107,11 +107,11 @@ end
 SchemaMonkey.register PracticalJoker
 ```
 
-SchemaMonkey inserts each submodule of `MyClient::ActiveRecord` into the corresponding module of ActiveRecord, with `ClassMethods` inserted as class methods.  
+SchemaMonkey inserts each submodule of `MyClient::ActiveRecord` into the corresponding module of ActiveRecord, with `ClassMethods` inserted as class methods.
 
 This works for arbitrary submodule paths, such as `MyClient::ActiveRecord::ConnectionAdapters::TableDefinition`.  SchemaMonkey will raise an error if the client defines a module that does not have a corresponding ActiveRecord module.
 
-Notice that insertion is done using `:prepend`, so that client modules can override existing methods and use `super`.
+Notice that insertion is done using `Module.prepend`, so that client modules can override existing methods and use `super`.
 
 ### DBMS-specific insertion
 
@@ -126,7 +126,7 @@ module MyClient
       module Sqlite3
         module TableDefinition
           #
-          # SQLite3-specific enhancements to 
+          # SQLite3-specific enhancements to
           # ActiveRecord::ConnectionAdapters::TableDefinition
           #
         end
@@ -145,11 +145,11 @@ The dbms name component can be anywhere in the module path after `MyClient::Acti
 
 * However, if the client module defines a module method `self.included` then SchemaMonkey will use `include` for a module and `singleton_class.include` for a ClassMethods module -- and Ruby will of course call that method.
 
-Note that in the case of a ClassMethods module, when Ruby calls `self.prepended` or `self.included`, it will pass the singleton class.  For convience SchemaMonkey will also call `self.extended` if defined passing it the ActiveRecord module itself, just as Ruby would if `extend` were used.         
+Note that in the case of a ClassMethods module, when Ruby calls `self.prepended` or `self.included`, it will pass the singleton class.  For convience SchemaMonkey will also call `self.extended` if defined, passing it the ActiveRecord module itself, just as Ruby would if `extend` were used.
 
-## Middleware Modlues
+## Middleware Modules
 
-SchemaMonkey provides a convention-based front end to using [Modware](https://github.com/ronen/modware) middleware stacks.
+SchemaMonkey provides a convention-based front end to using [modware](https://github.com/ronen/modware) middleware stacks.
 
 SchemaMonkey uses Ruby modules to organize the stacks:  Each stack is contained in a submodule of `SchemaMonkey::Middleware`
 
@@ -173,18 +173,20 @@ This defines a stack available at `SchemaMonkey::Middleware::Index::Exists`.  Yo
 
 SchemaMonkey will raise an error if a stack had already been defined there.
 
-The defined module has a module method `start` that delegates to `Modware::Stack.start`.  Here's an example of using the above stack as a wrapper around ActiveRecord's `index_exists?` method:
+The defined stack module has a module method `start` that delegates to `Modware::Stack.start`.  Here's an example of using the above stack as a wrapper around ActiveRecord's `index_exists?` method:
 
 ```ruby
 module MyClient
   module ActiveRecord
     module ConnectionAdapters
       module SchemaStatements
+
         def index_exists?(table_name, column_name, options = {})
           SchemaMonkey::Middleware::Index::Exists.start(connection: self, table_name: table_name, column_name: column_name, options: options) { |env|
             env.result = super env.table_name, env.column_name, env.options
           }.result
         end
+
       end
     end
   end
@@ -220,11 +222,11 @@ end
 SchemaMonkey.register(UColumnImpliesUnique)
 ```
 
-SchemaMonkey uses the module `MyLaterClient::Middleware::Index::Exists` as [Modware](https://github.com/ronen/modware) middleware for the corresponding stack.  The middleware module can define middleware methods `before`, `arround`, `after`, or `implementation` as per [Modware](https://github.com/ronen/modware)
+SchemaMonkey uses the module `MyLaterClient::Middleware::Index::Exists` as [modware](https://github.com/ronen/modware) middleware for the corresponding stack.  The middleware module can define middleware methods `before`, `arround`, `after`, or `implementation` as per [modware](https://github.com/ronen/modware)
 
 Note that the distinguishing feature between defining and using a stack is whether `Env` is defined.
 
-    
+
 
 
 ## Compatibility
@@ -246,8 +248,10 @@ the standard protocol: fork, feature branch, develop, push, and issue pull reque
 
 Some things to know about to help you develop and test:
 
+<!-- SCHEMA_DEV: TEMPLATE USES SCHEMA_DEV - begin -->
+<!-- These lines are auto-inserted from a schema_dev template -->
 * **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
+  facilitate running rspec tests on the matrix of ruby, activerecord, and database
   versions that the gem supports, both locally and on
   [travis-ci](http://travis-ci.org/SchemaPlus/schema_monkey)
 
@@ -256,8 +260,10 @@ Some things to know about to help you develop and test:
         $ 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.
+  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.
+
+
+<!-- SCHEMA_DEV: TEMPLATE USES SCHEMA_DEV - end -->

data/gemfiles/Gemfile.base

@@ -1,8 +1,4 @@
 source 'https://rubygems.org'
 gemspec :path => File.expand_path('..', __FILE__)
 
-platform :ruby do
-    gem "byebug" if RUBY_VERSION > "2"
-end
-
 File.exist?(gemfile_local = File.expand_path('../Gemfile.local', __FILE__)) and eval File.read(gemfile_local), binding, gemfile_local

data/lib/schema_monkey.rb

@@ -11,7 +11,7 @@ require_relative "schema_monkey/monkey"
 require_relative "schema_monkey/stack"
 require_relative 'schema_monkey/rake'
 
-# 
+#
 # Middleware contents will be created dynamically
 #
 module SchemaMonkey
@@ -20,7 +20,7 @@ module SchemaMonkey
 end
 
 #
-# 
+#
 #
 module SchemaMonkey
 

data/lib/schema_monkey/client.rb

@@ -16,7 +16,6 @@ module SchemaMonkey
     def insert_active_record(dbm: nil)
       # Kernel.warn "--- inserting active_record for #{@root}, dbm=#{dbm.inspect}"
       find_modules(:ActiveRecord, dbm: dbm).each do |mod|
-        next if mod.is_a? Class
         relative_path = canonicalize_path(mod, :ActiveRecord, dbm)
         ActiveRecord.insert(relative_path, mod)
       end
@@ -35,7 +34,7 @@ module SchemaMonkey
       path = mod.to_s.sub(/^#{@root}::#{base}::/, '')
       if dbm
         path = path.split('::')
-        if (i = path.find_index(&it =~ /\b#{dbm}\b/i)) # delete first occurence 
+        if (i = path.find_index(&it =~ /\b#{dbm}\b/i)) # delete first occurence
           path.delete_at i
         end
         path = path.join('::').gsub(/#{dbm}/i, dbm.to_s) # canonicalize case for things like PostgreSQLAdapter

data/lib/schema_monkey/monkey.rb

@@ -1,6 +1,6 @@
 module SchemaMonkey
 
-  # The main manager for the monkey patches.  Singleton instance 
+  # The main manager for the monkey patches.  Singleton instance
   # created by SchemaMonkey.monkey
 
   class Monkey
@@ -11,7 +11,7 @@ module SchemaMonkey
       @clients = []
       @inserted = nil
       @inserted_dbm = nil
-      Module.insert ::ActiveRecord::ConnectionAdapters::AbstractAdapter, SchemaMonkey::ActiveRecord::ConnectionAdapters::AbstractAdapter 
+      Module.insert ::ActiveRecord::ConnectionAdapters::AbstractAdapter, SchemaMonkey::ActiveRecord::ConnectionAdapters::AbstractAdapter
     end
 
     def register(mod)

data/lib/schema_monkey/stack.rb

@@ -3,8 +3,8 @@ module SchemaMonkey
     def self.insert(path, mod)
       env = Module.const_lookup(mod, "Env") || Module.const_lookup(mod, "ENV")
       return unless env or Modware.is_middleware?(mod)
-      stack = env ? create(path, env) : get(path)
-      stack.stack.add(mod)
+      stack_holder = env ? create(path, env) : get(path)
+      stack_holder.stack.add(mod)
     rescue MiddlewareError => err
       raise MiddlewareError, "#{mod}: #{err.message}"
     end
@@ -12,22 +12,22 @@ module SchemaMonkey
     private
 
     def self.create(path, env)
-      if stack = get(path, err: false)
-        raise MiddlewareError, "stack #{stack} is already defined"
+      if mod = get(path, err: false)
+        raise MiddlewareError, "stack #{mod} is already defined"
       end
-      Module.mkpath(SchemaMonkey::Middleware, path).tap { |stack|
-        stack.send :extend, Stack::StartMethod
-        stack.send :stack=, Modware::Stack.new(env: env)
+      Module.mkpath(SchemaMonkey::Middleware, path).tap { |mod|
+        mod.send :extend, Stack::StackHolder
+        mod.send :stack=, Modware::Stack.new(env: env)
       }
     end
 
     def self.get(path, err: true)
-      stack = Module.const_lookup SchemaMonkey::Middleware, path
-      return stack if stack
+      mod = Module.const_lookup SchemaMonkey::Middleware, path
+      return mod if mod and mod.is_a? Stack::StackHolder
       raise MiddlewareError, "No stack #{SchemaMonkey::Middleware}::#{path}" if err
     end
 
-    module StartMethod
+    module StackHolder
       attr_reader :stack
 
       def start(env, &block)

data/lib/schema_monkey/version.rb

@@ -1,3 +1,3 @@
 module SchemaMonkey
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/schema_monkey.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   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.summary       = %q{Provides a module insertion protocol to facilitate adding features to ActiveRecord}
+  spec.description   = %q{Provides a module insertion protocol to facilitate adding features to ActiveRecord}
   spec.homepage      = "https://github.com/SchemaPlus/schema_monkey"
   spec.license       = "MIT"
 

data/spec/active_record_spec.rb

@@ -4,7 +4,7 @@ $client_count = 0
 
 describe SchemaMonkey::ActiveRecord do
 
-  before(:each) {
+  When(:result) {
     SchemaMonkey.register(client)
     SchemaMonkey.insert
     ActiveRecord::Base.establish_connection :schema_dev
@@ -16,23 +16,23 @@ describe SchemaMonkey::ActiveRecord do
 
     [:prepend, :include].each do |mode|
 
-      context "#{mode} general module"+suffix do
-        let(:client) { make_client('ConnectionAdapters::SchemaStatements', mode: mode, class_methods: class_methods) }
-        it { expect_inserted(ActiveRecord::ConnectionAdapters::SchemaStatements, client.module, mode, class_methods) }
+      context "with #{mode} general module"+suffix do
+        Given(:client) { make_client('ConnectionAdapters::SchemaStatements', mode: mode, class_methods: class_methods) }
+        Then { expect_inserted(ActiveRecord::ConnectionAdapters::SchemaStatements, client.module, mode, class_methods) }
       end
 
       SchemaMonkey::DBMS.each do |dbm|
 
-        context "#{mode} #{dbm} module"+suffix do
-          let(:client) { make_client("ConnectionAdapters::#{dbm}::SchemaStatements", mode: mode, class_methods: class_methods) }
+        context "with #{mode} #{dbm} module"+suffix do
+          Given(:client) { make_client("ConnectionAdapters::#{dbm}::SchemaStatements", mode: mode, class_methods: class_methods) }
 
           SchemaMonkey::DBMS.each do |loaded_dbm|
 
-            context "when #{loaded_dbm}", loaded_dbm.to_s.downcase.to_sym => :only do
+            context "if using #{loaded_dbm}", loaded_dbm.to_s.downcase.to_sym => :only do
               if dbm == loaded_dbm
-                it { expect_inserted(ActiveRecord::ConnectionAdapters::SchemaStatements, client.module, mode, class_methods) }
+                Then { expect_inserted(ActiveRecord::ConnectionAdapters::SchemaStatements, client.module, mode, class_methods) }
               else
-                it { expect_not_inserted(ActiveRecord::ConnectionAdapters::SchemaStatements, client.module, class_methods) }
+                Then { expect_not_inserted(ActiveRecord::ConnectionAdapters::SchemaStatements, client.module, class_methods) }
               end
             end
           end
@@ -42,6 +42,11 @@ describe SchemaMonkey::ActiveRecord do
     end
   end
 
+  context "with invalid module" do
+    Given(:client) { make_client('ConnectionAdapters::NoSuchModule') }
+    Then { expect(result).to have_failed(SchemaMonkey::InsertionError) }
+  end
+
   private
 
   def expect_inserted(base, mod, mode, class_methods)
@@ -59,7 +64,7 @@ describe SchemaMonkey::ActiveRecord do
     expect(base.ancestors).not_to include mod
   end
 
-  def make_client(path, mode:, class_methods: nil)
+  def make_client(path, mode: nil, class_methods: nil)
     name = "TestActiveRecord#{$client_count}"
     $client_count += 1
     Object.send :remove_const, name if Object.const_defined? name

data/spec/middleware_spec.rb

@@ -45,6 +45,14 @@ describe SchemaMonkey::Middleware do
     end
   end
 
+  context "with module but no stack registered" do
+    context "if register client1" do
+      Given { SchemaMonkey::Module.mkpath SchemaMonkey::Middleware, "Group::Stack" }
+      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))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema_monkey
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - ronen barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-10 00:00:00.000000000 Z
+date: 2015-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -150,8 +150,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Provides an internal API and module inclusion protocol to facilitate
-  adding features to ActiveRecord
+description: Provides a module insertion protocol to facilitate adding features to
+  ActiveRecord
 email:
 - ronen@barzel.org
 executables: []
@@ -209,8 +209,7 @@ 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
+summary: Provides a module insertion protocol to facilitate adding features to ActiveRecord
 test_files:
 - spec/active_record_spec.rb
 - spec/connection_spec.rb