schema_plus_core 0.1.0

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'schema_dev/tasks'
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/gemfiles/Gemfile.base

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec :path => File.expand_path('..', __FILE__)
+
+File.exist?(gemfile_local = File.expand_path('../Gemfile.local', __FILE__)) and eval File.read(gemfile_local), binding, gemfile_local

data/gemfiles/activerecord-4.2/Gemfile.base

@@ -0,0 +1,3 @@
+eval File.read File.expand_path('../../Gemfile.base', __FILE__)
+
+gem "activerecord", "~> 4.2.0"

data/gemfiles/activerecord-4.2/Gemfile.mysql2

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "mysql2"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcmysql-adapter'
+end

data/gemfiles/activerecord-4.2/Gemfile.postgresql

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "pg"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end

data/gemfiles/activerecord-4.2/Gemfile.sqlite3

@@ -0,0 +1,10 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+platform :ruby do
+  gem "sqlite3"
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter', '>=1.3.0.beta2'
+end

data/lib/schema_plus/core.rb

@@ -0,0 +1,27 @@
+require "schema_monkey"
+
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        DIR = Pathname.new(__FILE__).dirname + "core/active_record/connection_adapters"
+        autoload :PostgresqlAdapter,     DIR + "postgresql_adapter"
+        autoload :Mysql2Adapter,         DIR + "mysql2_adapter"
+        autoload :AbstractMysqlAdapter,  DIR + "abstract_mysql_adapter"
+        autoload :Sqlite3Adapter,        DIR + "sqlite3_adapter"
+      end
+    end
+end
+end
+
+require_relative "core/active_record/base"
+require_relative "core/active_record/connection_adapters/abstract_adapter"
+require_relative "core/active_record/connection_adapters/table_definition"
+require_relative "core/active_record/migration/command_recorder"
+require_relative "core/active_record/schema_dumper"
+require_relative "core/middleware"
+require_relative "core/schema_dump"
+require_relative "core/sql_struct"
+require_relative "core/version"
+
+SchemaMonkey.register(SchemaPlus::Core)

data/lib/schema_plus/core/active_record/base.rb

@@ -0,0 +1,22 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module Base
+        module ClassMethods
+
+          def columns
+            SchemaMonkey::Middleware::Model::Columns.start(model: self, columns: []) { |env|
+              env.columns += super
+            }.columns
+          end
+
+          def reset_column_information
+            SchemaMonkey::Middleware::Model::ResetColumnInformation.start(model: self) do |env|
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,43 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        module AbstractAdapter
+
+          def add_column(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|
+              super env.table_name, env.column_name, env.type, env.options
+            end
+          end
+
+          def add_reference(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|
+              super env.table_name, env.column_name.sub(/_id$/, ''), env.options
+            end
+          end
+
+          def add_index_options(table_name, column_names, options={})
+            SchemaMonkey::Middleware::Sql::IndexComponents.start(connection: self, table_name: table_name, column_names: Array.wrap(column_names), options: options.deep_dup, sql: SqlStruct::IndexComponents.new) { |env|
+              env.sql.name, env.sql.type, env.sql.columns, env.sql.options, env.sql.algorithm, env.sql.using = super env.table_name, env.column_names, env.options
+            }.sql.to_hash.values
+          end
+
+          module SchemaCreation
+
+            def add_column_options!(sql, options)
+              sql << " " + SchemaMonkey::Middleware::Sql::ColumnOptions.start(caller: self, connection: self.instance_variable_get('@conn'), sql: "", column: options[:column], options: options.except(:column)) { |env|
+                super env.sql, env.options.merge(column: env.column)
+              }.sql.lstrip
+            end
+
+            def visit_TableDefinition(o)
+              SchemaMonkey::Middleware::Sql::Table.start(caller: self, connection: self.instance_variable_get('@conn'), table_definition: o, sql: SqlStruct::Table.new) { |env|
+                env.sql.parse! super env.table_definition
+              }.sql.assemble
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -0,0 +1,17 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        module AbstractMysqlAdapter
+          module SchemaCreation
+            def visit_TableDefinition(o)
+              SchemaMonkey::Middleware::Sql::Table.start(caller: self, connection: self.instance_variable_get('@conn'), table_definition: o, sql: SqlStruct::Table.new) { |env|
+                env.sql.parse! super env.table_definition
+              }.sql.assemble
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/active_record/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,64 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        module Mysql2Adapter
+
+          def change_column(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|
+              super env.table_name, env.column_name, env.type, env.options
+            end
+          end
+
+          def add_index(table_name, column_names, options={})
+            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+              super env.table_name, env.column_names, env.options
+            end
+          end
+
+          def indexes(table_name, query_name=nil)
+            SchemaMonkey::Middleware::Schema::Indexes.start(connection: self, table_name: table_name, query_name: query_name, index_definitions: []) { |env|
+              env.index_definitions += super env.table_name, env.query_name
+            }.index_definitions
+          end
+
+          def tables(query_name=nil, database=nil, like=nil)
+            SchemaMonkey::Middleware::Schema::Tables.start(connection: self, query_name: query_name, database: database, like: like, tables: []) { |env|
+              env.tables += super env.query_name, env.database, env.like
+            }.tables
+          end
+
+          def select_rows(sql, name=nil, binds=[])
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds
+            }.result
+          end
+
+          def exec_query(sql, name='SQL', binds=[])
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds
+            }.result
+          end
+
+          alias exec_without_stmt exec_query
+
+          def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds, pk, sequence_name
+            }.result
+          end
+
+          def exec_delete(sql, name, binds)
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds
+            }.result
+          end
+
+          alias :exec_update :exec_delete
+
+        end
+      end
+    end
+  end
+end
+

data/lib/schema_plus/core/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,46 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        module PostgresqlAdapter
+
+          def change_column(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|
+              super env.table_name, env.column_name, env.type, env.options
+            end
+          end
+
+          def add_index(table_name, column_names, options={})
+            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+              super env.table_name, env.column_names, env.options
+            end
+          end
+
+          def exec_cache(sql, name, binds)
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds
+            }.result
+          end
+
+          def exec_no_cache(sql, name, binds)
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds
+            }.result
+          end
+
+          def indexes(table_name, query_name=nil)
+            SchemaMonkey::Middleware::Schema::Indexes.start(connection: self, table_name: table_name, query_name: query_name, index_definitions: []) { |env|
+              env.index_definitions += super env.table_name, env.query_name
+            }.index_definitions
+          end
+
+          def tables(query_name=nil)
+            SchemaMonkey::Middleware::Schema::Tables.start(connection: self, query_name: query_name, tables: []) { |env|
+              env.tables += super env.query_name
+            }.tables
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,43 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        module Sqlite3Adapter
+
+          def change_column(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|
+              super env.table_name, env.column_name, env.type, env.options
+            end
+          end
+
+          def add_index(table_name, column_names, options={})
+            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+              super env.table_name, env.column_names, env.options
+            end
+          end
+
+          def exec_query(sql, name=nil, binds=[])
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
+              env.result = super env.sql, env.query_name, env.binds
+            }.result
+          end
+
+          def indexes(table_name, query_name=nil)
+            SchemaMonkey::Middleware::Schema::Indexes.start(connection: self, table_name: table_name, query_name: query_name, index_definitions: []) { |env|
+              env.index_definitions += super env.table_name, env.query_name
+            }.index_definitions
+          end
+
+          def tables(query_name=nil, table_name=nil)
+            SchemaMonkey::Middleware::Schema::Tables.start(connection: self, query_name: query_name, table_name: table_name, tables: []) { |env|
+              env.tables += super env.query_name, env.table_name
+            }.tables
+          end
+
+        end
+      end
+    end
+  end
+end
+
+

data/lib/schema_plus/core/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,36 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module ConnectionAdapters
+        module TableDefinition
+
+          def column(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|
+              super env.column_name, env.type, env.options
+            end
+          end
+
+          def references(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|
+              super env.column_name.sub(/_id$/, ''), env.options
+            end
+          end
+
+          def belongs_to(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|
+              super env.column_name.sub(/_id$/, ''), env.options
+            end
+          end
+
+          def index(*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|
+              super env.column_names, env.options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/active_record/migration/command_recorder.rb

@@ -0,0 +1,16 @@
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module Migration
+        module CommandRecorder
+
+          def add_column(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|
+              super env.table_name, env.column_name, env.type, env.options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/active_record/schema_dumper.rb

@@ -0,0 +1,102 @@
+require 'ostruct'
+require 'tsort'
+
+module SchemaPlus
+  module Core
+    module ActiveRecord
+      module SchemaDumper
+
+        def self.prepended(base)
+          base.class_eval do
+            public :ignored?
+          end
+        end
+
+        def dump(stream)
+          @dump = SchemaDump.new(self)
+          super stream
+          @dump.assemble(stream)
+        end
+
+        def foreign_keys(table, _)
+          stream = StringIO.new
+          super table, stream
+          @dump.final += stream.string.split("\n").map(&:strip)
+        end
+
+        def trailer(_)
+          stream = StringIO.new
+          super stream
+          @dump.trailer = stream.string
+        end
+
+        def extensions(_)
+          SchemaMonkey::Middleware::Dumper::Initial.start(dumper: self, connection: @connection, dump: @dump, initial: @dump.initial) do |env|
+            stream = StringIO.new
+            super stream
+            env.dump.initial << stream.string unless stream.string.blank?
+          end
+        end
+
+        def tables(_)
+          SchemaMonkey::Middleware::Dumper::Tables.start(dumper: self, connection: @connection, dump: @dump) do |env|
+            super nil
+          end
+        end
+
+        def table(table, _)
+          SchemaMonkey::Middleware::Dumper::Table.start(dumper: self, connection: @connection, dump: @dump, table: @dump.tables[table] = SchemaDump::Table.new(name: table)) do |env|
+            stream = StringIO.new
+            super 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
+              SchemaDump::Table::Column.new(name: m[:name], type: m[:type], options: m[:options])
+            }
+          end
+        end
+
+        def indexes(table, _)
+          SchemaMonkey::Middleware::Dumper::Indexes.start(dumper: self, connection: @connection, dump: @dump, table: @dump.tables[table]) do |env|
+            stream = StringIO.new
+            super 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*/)
+              SchemaDump::Table::Index.new name: m[:name], columns: columns, options: m[:options]
+            }
+          end
+        end
+      end
+    end
+  end
+end