schema_monkey 1.0.1 → 2.0.0

data/lib/schema_monkey/core_extensions/middleware.rb

@@ -1,62 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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/tool/client.rb

@@ -1,67 +0,0 @@
-module SchemaMonkey::Tool
-  class Client
-    attr_reader :monkey
-
-    def initialize(monkey, mod)
-      @monkey = monkey
-      @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)
-      # 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.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).each do |mod|
-        next if @inserted[mod]
-
-        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
-
-    private
-
-    def find_modules(container, opts={})
-      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(#{DBMS.join('|')})/i
-      end
-
-      modules = []
-      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/tool/errors.rb

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

data/lib/schema_monkey/tool/monkey.rb

@@ -1,46 +0,0 @@
-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/tool/stack.rb

@@ -1,90 +0,0 @@
-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, :implement]).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?(:implement)).last
-        hook.implement(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