schema_monkey 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d7581fe8672d2cf1ef4115bbfc10955a0a2e4c1
-  data.tar.gz: 5d05d31605887dfcd26fb82f546b94adc73a8d9e
+  metadata.gz: 2d6e7678f91c469b42eeac242d5095283edcaf4a
+  data.tar.gz: 11e38e5ba367ced242293615096012c752150cd3
 SHA512:
-  metadata.gz: 210fc83e5898dec122f9a20441e04a4386eaf5fd68dca7b0ff20d3c69641bee79363f945dd6bc247101468bc71a3be0df5dfcb6da89a4045383e2ab093014b6a
-  data.tar.gz: f3ca1407f7c2f19cc329eb382ccab6279e5403b1016855f323cb8007a55058b73aa584957d23e8245c0196be4f49d22ebf39456effbc207c708b498d01ade76a
+  metadata.gz: 1022cc53e764a97faca78bec36a612a5a1b69a13369ba74af3b19a93ece5cbe1dd80002bb50430360e2027b717b3082aefa6c66e2f6422d8936978884ae0ae15
+  data.tar.gz: ff13029ef2dd6a8ecf5084e8c16526ae1439ce14df10710914c21afb69abb4927bc6d5275c141e94434c0f631471d3432a820d872e1086bb6ad4fd7b0faf3f8f

data/README.md

@@ -3,38 +3,46 @@
 [![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
+# SchemaMonkey
 
-TODO: Write a gem description
+SchemaMonkey is a behind-the-scenes gem to facilitate writing other gems that extend ActiveRecord.  It provides:
+
+* A "middleware"-style interface to key ActiveRecord internal functions.  For example, there's a middleware hook to let you insert a handler for migration column definition options, and there are several hooks to insert handlers for the various parts of a schema dump.
+
+* 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.
+
+* It takes care of setting up the Railtie appropriately to invoke the gems.
+
+The middleware interface has two benefits: it provides a clean API so that the client gems don't need to monkey-patch ActiveRecord (SchemaMonkey does all the monkey-patching for you), and it lets the client gems operate in parallel without concern about conflicting monkey-patches.
 
-schema_monkey is part of the [SchemaPlus](https://github.com/SchemaPlus/) family of Ruby on Rails extension gems.
 
 ## Installation
 
-In your application's Gemfile
+In your gem's `gemspec`, specify a dependency:
 
 ```ruby
-gem "schema_monkey"
+spec.add_dependency "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.
+
 ## Compatibility
 
-schema_monkey is tested on
+SchemaMonkey is tested on:
 
-[//]: # SCHEMA_DEV: MATRIX - begin
-[//]: # These lines are auto-generated by schema_dev based on schema_dev.yml
+<!-- 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
+<!-- SCHEMA_DEV: MATRIX - end -->
 
 ## Usage
 
-TODO: Write usage instructions here
 
+**Sorry -- no real documentation yet.  Will get to that as soon as I can.**
 
-## History
 
-*   See [CHANGELOG](CHANGELOG.md) for per-version release notes.
 
 ## Development & Testing
 
@@ -43,7 +51,9 @@ 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**:  schema_monkey uses [schema_dev](https://github.com/SchemaPlus/schema_dev) to
+* **Ugh -- no specs yet.  SchemaMonkey is currently tested indirectly by testing the client gems that use it.  That's another thing to get to as soon as I can.**
+
+* **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
   versions that the gem supports, both locally and on
   [travis-ci](http://travis-ci.org/SchemaPlus/schema_monkey)
@@ -57,4 +67,4 @@ Some things to know about to help you develop and test:
   [schema_dev](https://github.com/SchemaPlus/schema_dev) README.
 
   The matrix of configurations is specified in `schema_dev.yml` in
-  the project root.
+  the project root.

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

@@ -11,12 +11,11 @@ module SchemaMonkey
 
           dbm = case adapter_name
                 when /^MySQL/i                 then :Mysql
-                when 'PostgreSQL', 'PostGIS'   then :Postgresql
-                when 'SQLite'                  then :Sqlite3
+                when 'PostgreSQL', 'PostGIS'   then :PostgreSQL
+                when 'SQLite'                  then :SQLite3
                 end
 
-          SchemaMonkey.include_adapters(self.class, dbm)
-          SchemaMonkey.insert_middleware(dbm)
+          SchemaMonkey.insert(dbm: dbm)
         end
 
         module SchemaCreation

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

@@ -1,7 +1,7 @@
 module SchemaMonkey
   module ActiveRecord
     module ConnectionAdapters
-      module MysqlAdapter
+      module Mysql2Adapter
 
         def self.included(base)
           base.class_eval do

data/lib/schema_monkey/client.rb

@@ -0,0 +1,61 @@
+module SchemaMonkey
+  class Client
+    def initialize(mod)
+      @root = mod
+      @inserted = {}
+    end
+
+    def insert(opts={})
+      opts = opts.keyword_args(:dbm)
+      include_modules(dbm: opts.dbm)
+      insert_middleware(dbm: opts.dbm)
+      @root.insert() if @root.respond_to?(:insert) and @root != ::SchemaMonkey
+    end
+
+    def include_modules(opts={})
+      opts = opts.keyword_args(:dbm)
+      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}"
+        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|
+        next if @inserted[mod]
+        next unless mod.respond_to? :insert
+        # Kernel.warn "inserting #{mod}"
+        mod.insert
+        @inserted[mod] = true
+      end
+    end
+
+    private
+
+    def find_modules(container, opts={})
+      opts = opts.keyword_args(dbm: nil, and_self: nil)
+      return [] unless (container = Module.get_const(@root, container))
+
+      if opts.dbm
+        accept = /\b#{opts.dbm}/i
+        reject = nil
+      else
+        accept = nil
+        reject = /\b#{SchemaMonkey::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
+      modules
+    end
+
+  end
+end

data/lib/schema_monkey/module.rb

@@ -0,0 +1,33 @@
+module SchemaMonkey
+  module Module
+    extend self
+
+    def include_once(base, mod)
+      base.send(:include, mod) unless base.include? mod
+    end
+
+    # 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)
+      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 descendants(mod, opts={})
+      opts = opts.keyword_args(can_load: nil)
+      consts, auto = mod.constants.group_by{|c| !!mod.autoload?(c)}.values_at(false, true)
+      consts ||= []
+      consts += auto.select &it.to_s =~ opts.can_load if opts.can_load and auto
+      children = consts.map{|c| mod.const_get(c) }.select &it.is_a?(::Module)
+      children + children.flat_map {|c| descendants(c, can_load: opts.can_load) }
+    end
+
+  end
+end

data/lib/schema_monkey/version.rb

@@ -1,3 +1,3 @@
 module SchemaMonkey
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/lib/schema_monkey.rb

@@ -2,9 +2,11 @@ require 'hash_keyword_args'
 require 'its-it'
 require 'key_struct'
 require 'middleware'
+require 'active_support/core_ext/string'
 
+require_relative "schema_monkey/client"
 require_relative "schema_monkey/middleware"
-require_relative "schema_monkey/module_support"
+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"
@@ -14,69 +16,29 @@ require_relative 'schema_monkey/active_record/schema_dumper'
 require_relative 'schema_monkey/railtie' if defined?(Rails::Railtie)
 
 module SchemaMonkey
+  extend Module
 
-  extend SchemaMonkey::ModuleSupport
-
-  DBMS = [:Postgresql, :Mysql, :Sqlite3]
+  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 :Mysql2Adapter, 'schema_monkey/active_record/connection_adapters/mysql2_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
+    clients << Client.new(mod)
   end
 
-  def self.registered_modules
-    @registered_modules ||= [self]
+  def self.clients
+    @clients ||= [Client.new(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
+  def self.insert(opts={})
+    opts = opts.keyword_args(:dbm)
+    clients.each &it.insert(dbm: opts.dbm)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema_monkey
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - ronen barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-26 00:00:00.000000000 Z
+date: 2015-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -186,15 +186,16 @@ files:
 - 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/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_support.rb
+- lib/schema_monkey/module.rb
 - lib/schema_monkey/railtie.rb
 - lib/schema_monkey/version.rb
 - schema_dev.yml

data/lib/schema_monkey/module_support.rb

@@ -1,48 +0,0 @@
-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 += modules.flat_map { |mod| get_modules(mod, reject: opts.reject, recursive: true) } if opts.recursive
-      modules.select! &it.to_s =~ opts.match if opts.match
-      modules.select! &it.respond_to?(opts.respond_to) if opts.respond_to
-      modules
-    end
-  end
-end