schema_plus 1.8.9 → 2.0.0.pre1

data/lib/schema_plus/active_record/schema_dumper.rb

@@ -1,171 +0,0 @@
-require 'tsort'
-
-module SchemaPlus
-  module ActiveRecord
-
-    # SchemaPlus modifies ActiveRecord's schema dumper to include foreign
-    # key constraints and views.
-    #
-    # Additionally, index and foreign key constraint definitions are dumped
-    # inline in the create_table block.  (This is done for elegance, but
-    # also because Sqlite3 does not allow foreign key constraints to be
-    # added to a table after it has been defined.)
-    #
-    # The tables and views are dumped in alphabetical order, subject to
-    # topological sort constraints that a table must be dumped before any
-    # view that references it or table that has a foreign key constaint to
-    # it.
-    #
-    module SchemaDumper
-
-      include TSort
-
-      def self.included(base) #:nodoc:
-        base.class_eval do
-          private
-          alias_method_chain :table, :schema_plus
-          alias_method_chain :tables, :schema_plus
-          alias_method_chain :indexes, :schema_plus
-          alias_method_chain :foreign_keys, :schema_plus if private_method_defined? :foreign_keys
-        end
-      end
-
-      private
-
-      def foreign_keys_with_schema_plus(*)
-        # do nothing.  this overrides AR 4.2's foreign key dumping method, which isn't needed
-        # because we're dong them inline
-      end
-
-      def break_fk_cycles #:nodoc:
-        strongly_connected_components.select{|component| component.size > 1}.each do |tables|
-          table = tables.sort.last
-          backref_fks = @inline_fks[table].select{|fk| tables.include?(fk.references_table_name)}
-          @inline_fks[table] -= backref_fks
-          @dump_dependencies[table] -= backref_fks.collect(&:references_table_name)
-          backref_fks.each do |fk|
-            @backref_fks[fk.references_table_name] << fk
-          end
-        end
-      end
-
-      def tables_with_schema_plus(stream) #:nodoc:
-        @table_dumps = {}
-        @inline_fks = Hash.new{ |h, k| h[k] = [] }
-        @backref_fks = Hash.new{ |h, k| h[k] = [] }
-        @dump_dependencies = {}
-
-        if @connection.respond_to?(:enums)
-          @connection.enums.each do |schema, name, values|
-            params = [name.inspect]
-            params << values.map(&:inspect).join(', ')
-            params << ":schema => #{schema.inspect}" if schema != 'public'
-
-            stream.puts "  create_enum #{params.join(', ')}"
-          end
-        end
-
-      if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r < "4.2".to_r
-        tables_without_schema_plus(nil)
-      else
-        tables_without_schema_plus(stream)
-      end
-
-        @connection.views.each do |view_name|
-          next if Array.wrap(::ActiveRecord::SchemaDumper.ignore_tables).any? {|pattern| view_name.match pattern}
-          definition = @connection.view_definition(view_name)
-          @table_dumps[view_name] = "  create_view #{view_name.inspect}, #{definition.inspect}, :force => true\n"
-        end
-
-        re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(#{(@table_dumps.keys).join('|')})\b}
-        @table_dumps.keys.each do |table|
-          if @connection.views.include?(table)
-            dependencies = @connection.view_definition(table).scan(re_view_referent).flatten
-          else
-            @inline_fks[table] = @connection.foreign_keys(table)
-            dependencies = @inline_fks[table].collect(&:references_table_name)
-          end
-          # select against @table_dumps keys to respect filtering based on
-          # SchemaDumper.ignore_tables (which was taken into account
-          # increate @table_dumps)
-          @dump_dependencies[table] = dependencies.sort.uniq.select {|name| @table_dumps.has_key? name}
-        end
-
-        # Normally we dump foreign key constraints inline in the table
-        # definitions, both for visual cleanliness and because sqlite3
-        # doesn't allow foreign key constraints to be added afterwards.
-        # But in case there's a cycle in the constraint references, some
-        # constraints will need to be broken out then added later.  (Adding
-        # constraints later won't work with sqlite3, but that means sqlite3
-        # won't let you create cycles in the first place.)
-        break_fk_cycles while strongly_connected_components.any?{|component| component.size > 1}
-
-        tsort().each do |table|
-          table_dump = @table_dumps[table]
-          if i = (table_dump =~ /^\s*[e]nd\s*$/)
-            table_dump.insert i, dump_indexes(table) + dump_foreign_keys(@inline_fks[table], :inline => true)
-          end
-          stream.print table_dump
-          stream.puts dump_foreign_keys(@backref_fks[table], :inline => false)+"\n" if @backref_fks[table].any?
-        end
-
-      end
-
-      def tsort_each_node(&block) #:nodoc:
-        @table_dumps.keys.sort.each(&block)
-      end
-
-      def tsort_each_child(table, &block) #:nodoc:
-        @dump_dependencies[table].each(&block)
-      end
-
-      def table_with_schema_plus(table, ignore) #:nodoc:
-        stream = StringIO.new
-        table_without_schema_plus(table, stream)
-        stream_string = stream.string
-        @connection.columns(table).each do |column|
-          if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r < "4.2".to_r
-            if !column.default_expr.nil?
-              stream_string.gsub!("\"#{column.name}\"", "\"#{column.name}\", :default => { :expr => #{column.default_expr.inspect} }")
-            end
-          else
-            if !column.default_function.nil?
-              stream_string.gsub!("\"#{column.name}\"", "\"#{column.name}\", :default => { :expr => #{column.default_function.inspect} }")
-            end
-          end
-        end
-        @table_dumps[table] = stream_string
-      end
-
-      def indexes_with_schema_plus(table, stream) #:nodoc:
-        # do nothing.  we've already taken care of indexes as part of
-        # dumping the tables
-      end
-
-      def dump_indexes(table) #:nodoc:
-        @connection.indexes(table).collect{ |index|
-          dump = "    t.index"
-          dump << " #{index.columns.inspect}," unless index.columns.blank?
-          dump << " :name => #{index.name.inspect}"
-          dump << ", :unique => true" if index.unique
-          dump << ", :kind => \"#{index.kind}\"" unless index.kind.blank?
-          unless index.columns.blank?
-            dump << ", :case_sensitive => false" unless index.case_sensitive?
-            dump << ", :conditions => #{index.conditions.inspect}" unless index.conditions.blank?
-            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
-            dump << ", :length => #{Hash[*index.columns.zip(index.lengths).flatten].inspect}" if index_lengths.present?
-            dump << ", :order => {" + index.orders.map{|column, val| "#{column.inspect} => #{val.inspect}"}.join(", ") + "}" unless index.orders.blank?
-            dump << ", :operator_class => {" + index.operator_classes.map{|column, val| "#{column.inspect} => #{val.inspect}"}.join(", ") + "}" unless index.operator_classes.blank?
-          else
-            dump << ", :expression => #{index.expression.inspect}"
-          end
-          dump << "\n"
-        }.sort.join
-      end
-
-      def dump_foreign_keys(foreign_keys, opts={}) #:nodoc:
-        foreign_keys.collect{ |foreign_key| "  " + foreign_key.to_dump(:inline => opts[:inline]) }.sort.join
-      end
-    end
-  end
-end

data/lib/schema_plus/railtie.rb

@@ -1,20 +0,0 @@
-module SchemaPlus
-  class Railtie < Rails::Railtie #:nodoc:
-
-    initializer 'schema_plus.insert', :before => "active_record.initialize_database" do
-      ActiveSupport.on_load(:active_record) do
-        SchemaPlus.insert
-      end
-    end
-
-    rake_tasks do
-      load 'rails/tasks/database.rake'
-      ['db:schema:dump', 'db:schema:load'].each do |name|
-        if task = Rake.application.tasks.find { |task| task.name == name }
-          task.enhance(["schema_plus:load"])
-        end
-      end
-    end
-
-  end
-end

data/spec/index_definition_spec.rb

@@ -1,211 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-
-describe "Index definition" do
-
-  let(:migration) { ::ActiveRecord::Migration }
-
-  before(:all) do
-    define_schema(:auto_create => false) do
-      create_table :users, :force => true do |t|
-        t.string :login
-        t.datetime :deleted_at
-      end
-
-      create_table :posts, :force => true do |t|
-        t.text :body
-        t.integer :user_id
-        t.integer :author_id
-      end
-
-      create_table :comments, :force => true do |t|
-        t.text :body
-        t.integer :post_id
-        t.foreign_key :post_id, :posts, :id
-      end
-    end
-    class User < ::ActiveRecord::Base ; end
-    class Post < ::ActiveRecord::Base ; end
-    class Comment < ::ActiveRecord::Base ; end
-  end
-
-  around(:each) do |example|
-    migration.suppress_messages do
-      example.run
-    end
-  end
-
-  after(:each) do
-    migration.remove_index :users, :name => 'users_login_index' if migration.index_name_exists? :users, 'users_login_index', true
-  end
-
-  context "when index is multicolumn" do
-    before(:each) do
-      migration.execute "CREATE INDEX users_login_index ON users (login, deleted_at)"
-      User.reset_column_information
-      @index = index_definition(%w[login deleted_at])
-    end
-
-    it "is included in User.indexes" do
-      expect(@index).not_to be_nil
-    end
-
-  end
-
-  it "should correctly report supports_partial_indexes?" do
-    query = lambda { migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL" }
-    if migration.supports_partial_indexes?
-      expect(query).not_to raise_error
-    else
-      expect(query).to raise_error
-    end
-  end
-
-  it "should not crash on equality test with nil" do
-    index = ActiveRecord::ConnectionAdapters::IndexDefinition.new(:table, :column)
-    expect{index == nil}.to_not raise_error
-    expect(index == nil).to be false
-  end
-
-
-  context "when index is ordered", :mysql => :skip do
-
-    quotes = [
-      ["unquoted", ''],
-      ["double-quoted", '"'],
-    ]
-    quotes += [
-      ["single-quoted", "'"],
-      ["back-quoted", '`']
-    ] if SchemaDev::Rspec::Helpers.sqlite3?
-
-    quotes.each do |quotename, quote|
-      it "index definition includes orders for #{quotename} columns" do
-        migration.execute "CREATE INDEX users_login_index ON users (#{quote}login#{quote} DESC, #{quote}deleted_at#{quote} ASC)"
-        User.reset_column_information
-        index = index_definition(%w[login deleted_at])
-        expect(index.orders).to eq({"login" => :desc, "deleted_at" => :asc})
-      end
-
-    end
-  end
-
-
-  context "when case insensitive is added", :postgresql => :only do
-
-    before(:each) do
-      migration.execute "CREATE INDEX users_login_index ON users(LOWER(login))"
-      User.reset_column_information
-      @index = User.indexes.detect { |i| i.expression =~ /lower\(\(login\)::text\)/i }
-    end
-
-    it "is included in User.indexes" do
-      expect(@index).not_to be_nil
-    end
-
-    it "is not case_sensitive" do
-      expect(@index).not_to be_case_sensitive
-    end
-
-    it "its column should not be case sensitive" do
-      expect(User.columns.find{|column| column.name == "login"}).not_to be_case_sensitive
-    end
-
-    it "defines expression" do
-      expect(@index.expression).to eq("lower((login)::text)")
-    end
-
-    it "doesn't define conditions" do
-      expect(@index.conditions).to be_nil
-    end
-
-  end
-
-
-  context "when index is partial" do
-    before(:each) do
-      migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL"
-      User.reset_column_information
-      @index = index_definition("login")
-    end
-
-    it "is included in User.indexes" do
-      expect(User.indexes.select { |index| index.columns == ["login"] }.size).to eq(1)
-    end
-
-    it "is case_sensitive" do
-      expect(@index).to be_case_sensitive
-    end
-
-    it "doesn't define expression" do
-      expect(@index.expression).to be_nil
-    end
-
-    it "defines conditions" do
-      expect(@index.conditions).to match %r{[(]?deleted_at IS NULL[)]?}
-    end
-
-  end if ::ActiveRecord::Migration.supports_partial_indexes?
-
-  context "when index contains expression", :postgresql => :only do
-    before(:each) do
-      migration.execute "CREATE INDEX users_login_index ON users (extract(EPOCH from deleted_at)) WHERE deleted_at IS NULL"
-      User.reset_column_information
-      @index = User.indexes.detect { |i| i.expression.present? }
-    end
-
-    it "exists" do
-      expect(@index).not_to be_nil
-    end
-
-    it "doesnt have columns defined" do
-      expect(@index.columns).to be_empty
-    end
-
-    it "is case_sensitive" do
-      expect(@index).to be_case_sensitive
-    end
-
-    it "defines expression" do
-      expect(@index.expression).to eq("date_part('epoch'::text, deleted_at)")
-    end
-
-    it "defines conditions" do
-      expect(@index.conditions).to eq("(deleted_at IS NULL)")
-    end
-
-  end
-
-  context "when index has a non-btree type", :postgresql => :only do
-    before(:each) do
-      migration.execute "CREATE INDEX users_login_index ON users USING hash(login)"
-      User.reset_column_information
-      @index = User.indexes.detect { |i| i.name == "users_login_index" }
-    end
-
-    it "exists" do
-      expect(@index).not_to be_nil
-    end
-
-    it "defines kind" do
-      expect(@index.kind).to eq("hash")
-    end
-
-    it "does not define expression" do
-      expect(@index.expression).to be_nil
-    end
-
-    it "does not define order" do
-      expect(@index.orders).to be_blank
-    end
-  end
-
-
-
-  protected
-  def index_definition(column_names)
-    User.indexes.detect { |index| index.columns == Array(column_names) }
-  end
-
-
-end

data/spec/index_spec.rb

@@ -1,249 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "index" do
-
-  let(:migration) { ::ActiveRecord::Migration }
-  let(:connection) { ::ActiveRecord::Base.connection }
-
-  describe "add_index" do
-
-    before(:each) do
-      connection.tables.each do |table| connection.drop_table table, cascade: true end
-
-      define_schema(:auto_create => false) do
-        create_table :users, :force => true do |t|
-          t.string :login
-          t.text :address
-          t.datetime :deleted_at
-        end
-
-        create_table :posts, :force => true do |t|
-          t.text :body
-          t.integer :user_id
-          t.integer :author_id
-        end
-
-        create_table :comments, :force => true do |t|
-          t.text :body
-          t.integer :post_id
-          t.foreign_key :post_id, :posts, :id
-        end
-      end
-      class User < ::ActiveRecord::Base ; end
-      class Post < ::ActiveRecord::Base ; end
-      class Comment < ::ActiveRecord::Base ; end
-    end
-
-
-    after(:each) do
-      migration.suppress_messages do
-        migration.remove_index(:users, :name => @index.name) if (@index ||= nil)
-      end
-    end
-
-    it "should create index when called without additional options" do
-      add_index(:users, :login)
-      expect(index_for(:login)).not_to be_nil
-    end
-
-    it "should create unique index" do
-      add_index(:users, :login, :unique => true)
-      expect(index_for(:login).unique).to eq(true)
-    end
-
-    it "should assign given name" do
-      add_index(:users, :login, :name => 'users_login_index')
-      expect(index_for(:login).name).to eq('users_login_index')
-    end
-
-    it "should assign order", :mysql => :skip do
-      add_index(:users, [:login, :deleted_at], :order => {:login => :desc, :deleted_at => :asc})
-      expect(index_for([:login, :deleted_at]).orders).to eq({"login" => :desc, "deleted_at" => :asc})
-    end
-
-    it "should respect algorithm: :concurrently", :postgresql => :only do
-      expect(connection).to receive(:execute).with(/CREATE INDEX CONCURRENTLY/)
-      add_index(:users, :login, :algorithm => :concurrently)
-    end if ActiveRecord::VERSION::MAJOR > 3
-
-    context "for duplicate index" do
-      it "should not complain if the index is the same" do
-        add_index(:users, :login)
-        expect(index_for(:login)).not_to be_nil
-        expect(ActiveRecord::Base.logger).to receive(:warn).with(/login.*Skipping/)
-        expect { add_index(:users, :login) }.to_not raise_error
-        expect(index_for(:login)).not_to be_nil
-      end
-      it "should complain if the index is different" do
-        add_index(:users, :login, :unique => true)
-        expect(index_for(:login)).not_to be_nil
-        expect { add_index(:users, :login) }.to raise_error
-        expect(index_for(:login)).not_to be_nil
-      end
-    end
-
-    context "extra features", :postgresql => :only do
-
-      it "should assign conditions" do
-        add_index(:users, :login, :conditions => 'deleted_at IS NULL')
-        expect(index_for(:login).conditions).to eq('(deleted_at IS NULL)')
-      end
-
-      it "should assign expression, conditions and kind" do
-        add_index(:users, :expression => "USING hash (upper(login)) WHERE deleted_at IS NULL", :name => 'users_login_index')
-        @index = User.indexes.detect { |i| i.expression.present? }
-        expect(@index.expression).to eq("upper((login)::text)")
-        expect(@index.conditions).to eq("(deleted_at IS NULL)")
-        expect(@index.kind).to       eq("hash")
-      end
-
-      it "should allow to specify expression, conditions and kind separately" do
-        add_index(:users, :kind => "hash", :expression => "upper(login)", :conditions => "deleted_at IS NULL", :name => 'users_login_index')
-        @index = User.indexes.detect { |i| i.expression.present? }
-        expect(@index.expression).to eq("upper((login)::text)")
-        expect(@index.conditions).to eq("(deleted_at IS NULL)")
-        expect(@index.kind).to       eq("hash")
-      end
-
-      it "should allow to specify kind" do
-        add_index(:users, :login, :kind => "hash")
-        expect(index_for(:login).kind).to eq('hash')
-      end
-
-      it "should assign operator_class" do
-        add_index(:users, :login, :operator_class => 'varchar_pattern_ops')
-        expect(index_for(:login).operator_classes).to eq({"login" => 'varchar_pattern_ops'})
-      end
-
-      it "should assign multiple operator_classes" do
-        add_index(:users, [:login, :address], :operator_class => {:login => 'varchar_pattern_ops', :address => 'text_pattern_ops'})
-        expect(index_for([:login, :address]).operator_classes).to eq({"login" => 'varchar_pattern_ops', "address" => 'text_pattern_ops'})
-      end
-
-      it "should allow to specify actual expression only" do
-        add_index(:users, :expression => "upper(login)", :name => 'users_login_index')
-        @index = User.indexes.detect { |i| i.name == 'users_login_index' }
-        expect(@index.expression).to eq("upper((login)::text)")
-      end
-
-      it "should raise if no column given and expression is missing" do
-        expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError, /expression/)
-      end
-
-      it "should raise if expression without name is given" do
-        expect { add_index(:users, :expression => "USING btree (login)") }.to raise_error(ArgumentError, /name/)
-      end
-
-      it "should raise if expression is given and case_sensitive is false" do
-        expect { add_index(:users, :name => 'users_login_index', :expression => "USING btree (login)", :case_sensitive => false) }.to raise_error(ArgumentError, /use LOWER/i)
-      end
-
-    end
-
-    protected
-
-    def index_for(column_names)
-      @index = User.indexes.detect { |i| i.columns == Array(column_names).collect(&:to_s) }
-    end
-
-  end
-
-  describe "remove_index" do
-
-    before(:each) do
-      connection.tables.each do |table| connection.drop_table table, cascade: true end
-      define_schema(:auto_create => false) do
-        create_table :users, :force => true do |t|
-          t.string :login
-          t.datetime :deleted_at
-        end
-      end
-      class User < ::ActiveRecord::Base ; end
-    end
-
-
-    it "removes index by column name (symbols)" do
-      add_index :users, :login
-      expect(User.indexes.length).to eq(1)
-      remove_index :users, :login
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes index by column name (symbols)" do
-      add_index :users, :login
-      expect(User.indexes.length).to eq(1)
-      remove_index 'users', 'login'
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes multi-column index by column names (symbols)" do
-      add_index :users, [:login, :deleted_at]
-      expect(User.indexes.length).to eq(1)
-      remove_index :users, [:login, :deleted_at]
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes multi-column index by column names (strings)" do
-      add_index 'users', [:login, :deleted_at]
-      expect(User.indexes.length).to eq(1)
-      remove_index 'users', ['login', 'deleted_at']
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes index using column option" do
-      add_index :users, :login
-      expect(User.indexes.length).to eq(1)
-      remove_index :users, column: :login
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes index if_exists" do
-      add_index :users, :login
-      expect(User.indexes.length).to eq(1)
-      remove_index :users, :login, :if_exists => true
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes multi-column index if exists" do
-      add_index :users, [:login, :deleted_at]
-      expect(User.indexes.length).to eq(1)
-      remove_index :users, [:login, :deleted_at], :if_exists => true
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "removes index if_exists using column option" do
-      add_index :users, :login
-      expect(User.indexes.length).to eq(1)
-      remove_index :users, column: :login, :if_exists => true
-      expect(User.indexes.length).to eq(0)
-    end
-
-    it "raises exception if doesn't exist" do
-      expect {
-        remove_index :users, :login
-      }.to raise_error
-    end
-
-    it "doesn't raise exception with :if_exists" do
-      expect {
-        remove_index :users, :login, :if_exists => true
-      }.to_not raise_error
-    end
-  end
-
-  protected
-  def add_index(*args)
-    migration.suppress_messages do
-      migration.add_index(*args)
-    end
-    User.reset_column_information
-  end
-
-  def remove_index(*args)
-    migration.suppress_messages do
-      migration.remove_index(*args)
-    end
-    User.reset_column_information
-  end
-
-end