schema_plus_core 0.1.0

data/lib/schema_plus/core/middleware.rb

@@ -0,0 +1,71 @@
+module SchemaPlus
+  module Core
+    module Middleware
+      module Query
+        module Exec
+          ENV = [:connection, :sql, :query_name, :binds, :result]
+        end
+      end
+
+      module Schema
+        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, :query_name, :table_name, :index_definitions]
+        end
+      end
+
+      module Migration
+        module Column
+          ENV = [:caller, :operation, :table_name, :column_name, :type, :options]
+        end
+
+        module Index
+          ENV = [:caller, :operation, :table_name, :column_names, :options]
+        end
+      end
+
+      module Sql
+        module ColumnOptions
+          ENV = [:caller, :connection, :sql, :column, :options]
+        end
+
+        module IndexComponents
+          ENV = [:connection, :table_name, :column_names, :options, :sql]
+        end
+
+        module Table
+          ENV = [:caller, :connection, :table_definition, :sql]
+        end
+      end
+
+      module Dumper
+        module Initial
+          ENV = [:dumper, :connection, :dump, :initial]
+        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
+end

data/lib/schema_plus/core/schema_dump.rb

@@ -0,0 +1,123 @@
+module SchemaPlus
+  module Core
+    class SchemaDump
+      include TSort
+
+      attr_reader :initial, :tables, :dependencies, :data
+      attr_accessor :final, :trailer
+
+      def initialize(dumper)
+        @dumper = dumper
+        @dependencies = Hash.new { |h, k| h[k] = [] }
+        @initial = []
+        @tables = {}
+        @final = []
+        @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 @initial.join("\n") if initial.any?
+        assemble_tables(stream)
+        final.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
+  end
+end

data/lib/schema_plus/core/sql_struct.rb

@@ -0,0 +1,30 @@
+module SchemaPlus
+  module Core
+    module SqlStruct
+      IndexComponents = KeyStruct[:name, :type, :columns, :options, :algorithm, :using]
+
+      class Table < KeyStruct[:command, :name, :body, :options, :quotechar]
+        def parse!(sql)
+          m = sql.strip.match %r{
+          ^
+          (?<command>.*\bTABLE\b) \s*
+            (?<quote>['"`])(?<name>\S+)\k<quote> \s*
+            \( \s*
+            (?<body>.*) \s*
+            \) \s*
+            (?<options> \S.*)?
+            $
+          }xi
+          self.command = m[:command]
+          self.quotechar = m[:quote]
+          self.name = m[:name]
+          self.body = m[:body]
+          self.options = m[:options]
+        end
+        def assemble
+          ["#{command} #{quotechar}#{name}#{quotechar} (#{body})", options].reject(&:blank?).join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/core/version.rb

@@ -0,0 +1,5 @@
+module SchemaPlus
+  module Core
+    VERSION = "0.1.0"
+  end
+end

data/schema_dev.yml

@@ -0,0 +1,8 @@
+ruby:
+    - 2.1.5
+activerecord:
+    - 4.2
+db:
+    - mysql2
+    - sqlite3
+    - postgresql

data/schema_plus_core.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schema_plus/core/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "schema_plus_core"
+  gem.version       = SchemaPlus::Core::VERSION
+  gem.authors       = ["ronen barzel"]
+  gem.email         = ["ronen@barzel.org"]
+  gem.summary       = %q{Provides an internal extension API to ActiveRecord}
+  gem.description   = %q{Provides an internal extension API to ActiveRecord, in the form of middleware-style callback stacks}
+  gem.homepage      = "https://github.com/SchemaPlus/schema_plus_core"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "activerecord", "~> 4.2"
+  gem.add_dependency "schema_monkey", "~> 2.0"
+
+  gem.add_development_dependency "bundler", "~> 1.7"
+  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rspec", "~> 3.0.0"
+  gem.add_development_dependency "rspec-given"
+  gem.add_development_dependency "schema_dev", "~> 3.1"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "simplecov-gem-profile"
+end

data/spec/dumper_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe SchemaMonkey::Middleware::Dumper do
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  before(:each) do
+    migration.create_table "things" do |t|
+      t.integer :column
+      t.index :column
+    end
+    migration.create_table "other" do |t|
+      t.references :thing
+    end
+    migration.add_foreign_key("other", "things")
+  end
+
+  context TestDumper::Middleware::Dumper::Initial do
+    Then { expect(dump).to match /Schema[.]define.*do\s+#{middleware}/ }
+  end
+
+  context TestDumper::Middleware::Dumper::Tables do
+    Then { expect(dump).to match /create_table "other".*create_table "#{middleware}".*create_table "things"/m }
+  end
+
+  context TestDumper::Middleware::Dumper::Table do
+    Then { expect(dump).to match /t[.]integer.*option: #{middleware} \# comment: #{middleware}/ }
+    Then { expect(dump).to match /statement: #{middleware}\s+end\s+(add_index.*)?\s+trailer: #{middleware}/ }
+  end
+
+  context TestDumper::Middleware::Dumper::Indexes do
+    Then { expect(dump).to match /add_index.*#{middleware}/ }
+  end
+
+
+  private 
+
+  def middleware
+    described_class
+  end
+
+  def dump
+    begin
+      middleware.enable
+      stream = StringIO.new
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      return stream.string
+    ensure
+      middleware.disable
+    end
+  end
+
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe SchemaMonkey::Middleware do
+
+  let(:migration) { ::ActiveRecord::Migration }
+  let(:connection) { ::ActiveRecord::Base.connection }
+
+  Given {
+    migration.create_table "things"
+    class Thing < ActiveRecord::Base ; end
+  }
+
+  context SchemaMonkey::Middleware::Query do
+
+    Given { migration.add_column("things", "column1", "integer") }
+    Given(:thing) { Thing.create!  }
+
+    context TestReporter::Middleware::Query::Exec do
+      Then { expect_middleware(enable: {sql: /SELECT column1/}) { connection.select_values("SELECT column1 FROM things") } }
+      Then { expect_middleware(enable: {sql: /^UPDATE/}) { thing.update_attributes!(column1: 3) } }
+      Then { expect_middleware(enable: {sql: /^DELETE/}) { thing.delete } }
+    end
+  end
+
+  context SchemaMonkey::Middleware::Schema do
+
+    context TestReporter::Middleware::Schema::Tables do
+      Then { expect_middleware { connection.tables() } }
+    end
+
+    context TestReporter::Middleware::Schema::Indexes do
+      Then { expect_middleware { connection.indexes("things") } }
+    end
+
+  end
+
+  context SchemaMonkey::Middleware::Migration do
+
+    context TestReporter::Middleware::Migration::Column do
+      Given { migration.add_column("things", "column1", "integer") }
+      Then { expect_middleware(env: {operation: :add})  { migration.add_column("things", "column2", "integer") } }
+      # Note, sqlite3 emits both a :change and a :define
+      Then { expect_middleware(enable: {operation: :change}) { migration.change_column("things", "column1", "integer") } }
+      Then { expect_middleware(enable: {type: :reference}, env: {column_name: "ref_id"}) { migration.add_reference("things", "ref") } }
+
+      Given(:change) {
+        Class.new ::ActiveRecord::Migration do
+          def change
+            change_table("things") do |t|
+              t.integer "column2"
+            end
+          end
+        end
+      }
+      Then { expect_middleware(env: {operation: :record}) { change.migrate(:down) } }
+      Then { expect_middleware(env: {operation: :define, type: :primary_key}) { migration.create_table "other" } }
+      Then { expect_middleware(env: {operation: :define}) { table_statement(:integer, "column1") } }
+      Then { expect_middleware(enable: {type: :reference}, env: {operation: :define, column_name: "ref_id"}) { table_statement(:references, "ref") } }
+      Then { expect_middleware(enable: {type: :reference}, env: {operation: :define, column_name: "ref_id"}) { table_statement(:belongs_to, "ref") } }
+    end
+
+    context TestReporter::Middleware::Migration::Index do
+      Given { migration.add_column("things", "column1", "integer") }
+      Then { expect_middleware { table_statement(:index, "id") } }
+      Then { expect_middleware { migration.add_index("things", "column1") } }
+    end
+
+  end
+
+  context SchemaMonkey::Middleware::Sql do
+    context TestReporter::Middleware::Sql::ColumnOptions do
+      Then { expect_middleware { migration.add_column("things", "column1", "integer") } }
+    end
+
+    context TestReporter::Middleware::Sql::IndexComponents do
+      Given { migration.add_column("things", "column1", "integer") }
+      Then { expect_middleware { migration.add_index("things", "column1") } }
+    end
+
+    context TestReporter::Middleware::Sql::Table do
+      Then { expect_middleware { migration.create_table "other" } }
+    end
+  end
+
+  context SchemaMonkey::Middleware::Model do
+
+    context TestReporter::Middleware::Model::Columns do
+      Then { expect_middleware { Thing.columns } }
+    end
+
+    context TestReporter::Middleware::Model::ResetColumnInformation do
+      Then { expect_middleware { Thing.reset_column_information } }
+    end
+
+  end
+
+  context SchemaMonkey::Middleware::Dumper do
+
+    let(:dumper) { ::ActiveRecord::SchemaDumper }
+
+    context TestReporter::Middleware::Dumper::Initial do
+      Then { expect_middleware { dump }  }
+    end
+
+    context TestReporter::Middleware::Dumper::Tables do
+      Then { expect_middleware { dump }  }
+    end
+
+    context TestReporter::Middleware::Dumper::Table do
+      Then { expect_middleware(env: {table: { name: "things"} }) { dump }  }
+    end
+
+    context TestReporter::Middleware::Dumper::Indexes do
+      Then { expect_middleware(env: {table: { name: "things"} }) { dump }  }
+    end
+
+    private
+
+    def dump
+      ::ActiveRecord::SchemaDumper.dump(connection, StringIO.new)
+    end
+
+  end
+
+  def table_statement(method, *args)
+    migration.create_table("other", force: :cascade) do |t|
+      t.send method, *args
+    end
+  end
+
+  def env_match(env, matcher, bool: false)
+    matcher.each do |key, val|
+      actual = env.send key
+      case val
+      when Hash
+        val.each do |subkey, subval|
+          subactual = actual.send subkey
+          if bool
+            return false unless subactual == subval
+          else
+            expect(subactual).to eq subval
+          end
+        end
+      when Regexp
+        if bool
+          return false unless actual =~ val
+        else
+          expect(actual).to match val
+        end
+      else
+        if bool
+          return false unless actual == val
+        else
+          expect(actual).to eq val
+        end
+      end
+    end
+    true if bool
+  end
+
+  def expect_middleware(env: {}, enable: {})
+    middleware = described_class
+    begin
+      middleware.enable(-> (_env) { env_match(_env, enable, bool: true) })
+      expect { yield }.to raise_error { |error|
+        expect(error).to be_a TestReporter::Called
+        expect(error.middleware).to eq middleware
+        env_match(error.env, env)
+      }
+    ensure
+      middleware.disable
+    end
+  end
+
+end