schema_monkey 1.0.1 → 2.0.0

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

@@ -1,31 +0,0 @@
-module SchemaMonkey::CoreExtensions
-  module ActiveRecord
-    module ConnectionAdapters
-      module Mysql2Adapter
-
-        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::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)
-          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
-
-        def tables_with_schema_monkey(query_name=nil, database=nil, like=nil)
-          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
-          }.tables
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,30 +0,0 @@
-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/core_extensions/active_record/connection_adapters/schema_statements.rb

@@ -1,83 +0,0 @@
-module SchemaMonkey::CoreExtensions
-  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
-
-        IndexComponentsSql = KeyStruct[:name, :type, :columns, :options, :algorithm, :using]
-
-        def add_index_options_with_schema_monkey(table_name, column_names, options={})
-          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)
-          }
-          [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 = {})
-            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 = {})
-            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
-        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 = {})
-            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
-        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(*args)
-            options = args.extract_options!
-            table_name, column_names = args
-            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
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module SchemaMonkey::CoreExtensions
-  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::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)
-          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
-
-        def tables_with_schema_monkey(query_name=nil, table_name=nil)
-          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
-          }.tables
-        end
-
-      end
-    end
-  end
-end
-
-

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

@@ -1,42 +0,0 @@
-module SchemaMonkey::CoreExtensions
-  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 = {})
-          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 = {})
-          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 = {})
-          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
-
-        def index_with_schema_monkey(*args)
-          options = args.extract_options!
-          column_name = args.first
-          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
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module SchemaMonkey::CoreExtensions
-  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 = {})
-          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
-      end
-    end
-  end
-end

data/lib/schema_monkey/core_extensions/active_record/schema_dumper.rb

@@ -1,227 +0,0 @@
-require 'ostruct'
-require 'tsort'
-
-module SchemaMonkey::CoreExtensions
-  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, :indexes, :statements, :trailer]
-          def initialize(*args)
-            super
-            self.columns ||= []
-            self.indexes ||= []
-            self.statements ||= []
-            self.trailer ||= []
-          end
-
-          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"
-            indexes.each do |index|
-              stream.write "  add_index #{pname.inspect}, "
-              index.assemble(stream)
-              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
-
-          class Index < KeyStruct[:name, :columns, :options]
-
-            def add_option(option)
-              self.options = [options, option].reject(&:blank?).join(', ')
-            end
-
-            def assemble(stream)
-              stream.write [
-                columns.inspect,
-                "name: #{name.inspect}",
-                options
-              ].reject(&:blank?).join(", ")
-            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
-          alias_method_chain :indexes, :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(_)
-        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?
-        end
-      end
-
-      def tables_with_schema_monkey(_)
-        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, _)
-        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{
-          \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
-
-      def indexes_with_schema_monkey(table, _)
-        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|
-            m = string.strip.match %r{
-              ^
-              add_index \s*
-              [:'"](?<table>[^'"\s]+)['"]? \s* , \s*
-              (?<columns>.*) \s*
-              name: \s* [:'"](?<name>[^'"\s]+)['"]? \s*
-              (, \s* (?<options>.*))?
-              $
-            }x
-            columns = m[:columns].tr(%q{[]'":}, '').strip.split(/\s*,\s*/)
-            Dump::Table::Index.new name: m[:name], columns: columns, options: m[:options]
-          }
-        end
-      end
-    end
-  end
-end