ensured_schema 0.0.1 → 0.1.0

data/.gitignore

@@ -1,3 +1,5 @@
 pkg/*
 *.gem
 .bundle
+debug.log
+.rvmrc

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    ensured_schema (0.0.1)
+      activerecord (~> 2.3.5)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activerecord (2.3.10)
+      activesupport (= 2.3.10)
+    activesupport (2.3.10)
+    mocha (0.9.10)
+      rake
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 2.3.5)
+  ensured_schema!
+  mocha (~> 0.9.8)

data/Rakefile

@@ -1,2 +1,21 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+# for adapter in %w( mysql postgresql sqlite sqlite3 firebird db2 oracle sybase openbase frontbase jdbcmysql jdbcpostgresql jdbcsqlite3 jdbcderby jdbch2 jdbchsqldb )
+for adapter in %w( mysql )
+  Rake::TestTask.new("test_#{adapter}") { |t|
+    if adapter =~ /jdbc/
+      t.libs << "test" << "test/connections/jdbc_#{adapter}"
+    else
+      t.libs << "test" << "test/connections/native_#{adapter}"
+    end
+    adapter_short = adapter == 'db2' ? adapter : adapter[/^[a-z]+/]
+    t.test_files=Dir.glob( "test/cases/**/*_test{,_#{adapter_short}}.rb" ).sort
+    t.verbose = true
+  }
+
+  namespace adapter do
+    task :test => "test_#{adapter}"
+  end
+end

data/ensured_schema.gemspec

@@ -12,6 +12,10 @@ Gem::Specification.new do |s|
   s.summary     = %q{Ensures database schema always matches your schema.rb file}
   s.description = %q{Smarter migrations}
 
+  s.add_dependency('activerecord', '~> 2.3.5')
+
+  s.add_development_dependency('mocha', '~> 0.9.8')
+
   s.rubyforge_project = "ensured_schema"
 
   s.files         = `git ls-files`.split("\n")

data/lib/ensured_schema/column.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class Column
+      def limit_exists?(new_limit)
+        self.limit == new_limit
+      end
+    end
+  end
+end

data/lib/ensured_schema/ensured_table.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class EnsuredTable < Table
+
+      def column_exists?(column_name, type = nil, options = {})
+        #debugger
+        @base.column_exists?(@table_name, column_name, type, options)
+      end
+
+      %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
+        class_eval <<-EOV
+          def #{column_type}(*args)                   # def string(*args)
+            define_columns('#{column_type}', *args)    #   define_column('string', *args)
+          end                                         # end
+        EOV
+      end
+
+      def define_columns(column_type, *args)
+        options = args.extract_options!
+        column_names = args
+
+        column_names.each do |name|
+          column_def = build_column_definition(name, column_type, options)
+          def_options = column_def.members.inject({}){|h, k| h[k.to_sym] = column_def[k]; h;}
+          #debugger
+          if column_exists?(name)
+            unless column_exists?(name, column_type, def_options)
+              change(name, column_def.sql_type, options)
+              puts "#{name} has been changed!"
+            end
+          else
+            puts "creating column"
+            @base.add_column(@table_name, name, column_def.sql_type, options)
+          end
+        end
+      end
+
+      def build_column_definition(column_name, column_type, options = {})
+        column = ColumnDefinition.new(@base, column_name, column_type)
+        if options[:limit]
+          column.limit = options[:limit]
+        elsif native[column_type.to_sym].is_a?(Hash)
+          column.limit = native[column_type.to_sym][:limit]
+        end
+        column.precision = options[:precision]
+        column.scale = options[:scale]
+        column.default = options[:default]
+        column.null = options[:null]
+        column
+      end
+    end
+  end
+end

data/lib/ensured_schema/mysql_column.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlColumn
+      def limit_exists?(new_limit)
+        return super unless type.to_s == 'integer'
+        case new_limit
+        when 5..8
+          self.limit == 8
+        when nil, 4, 11
+          self.limit == 4
+        else
+          self.limit == new_limit
+        end
+      end
+    end
+  end
+end

data/lib/ensured_schema/schema.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  class Schema
+    def self.ensure(options={}, &block)
+      self.define(options, &block)
+    end
+  end
+end

data/lib/ensured_schema/schema_statements.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SchemaStatements
+      # Checks to see if an index exists on a table for a given index definition
+      #
+      # === Examples
+      #  # Check an index exists
+      #  index_exists?(:suppliers, :company_id)
+      #
+      #  # Check an index on multiple columns exists
+      #  index_exists?(:suppliers, [:company_id, :company_type])
+      #
+      #  # Check a unique index exists
+      #  index_exists?(:suppliers, :company_id, :unique => true)
+      #
+      #  # Check an index with a custom name exists
+      #  index_exists?(:suppliers, :company_id, :name => "idx_company_id"
+      def new_index_exists?(table_name, column_name, options = {}) # Don't overwrite existing index_exists?
+        column_names = Array.wrap(column_name)
+        index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names)
+        if options[:unique]
+          indexes(table_name).any?{ |i| i.unique && i.name == index_name }
+        else
+          indexes(table_name).any?{ |i| i.name == index_name }
+        end
+      end
+
+      # Checks to see if a column exists in a given table.
+      #
+      # === Examples
+      #  # Check a column exists
+      #  column_exists?(:suppliers, :name)
+      #
+      #  # Check a column exists of a particular type
+      #  column_exists?(:suppliers, :name, :string)
+      #
+      #  # Check a column exists with a specific definition
+      #  column_exists?(:suppliers, :name, :string, :limit => 100)
+      def column_exists?(table_name, column_name, type = nil, options = {})
+        #debugger
+        columns(table_name).any?{ |c| c.name == column_name.to_s &&
+                                      (!type                 || c.type.to_s == type.to_s) &&
+                                      (!options[:limit]      || c.limit_exists?(options[:limit])) &&
+                                      (!options[:precision]  || c.precision == options[:precision]) &&
+                                      (!options[:scale]      || c.scale == options[:scale]) }
+      end
+
+      def table(table_name, options = {}, &block)
+        if table_exists?(table_name)
+          puts "table already exists"
+          ensure_table(table_name, &block) # what to do about changing table options
+        else
+          puts "creating table"
+          create_table(table_name, options, &block)
+        end
+      end
+
+      def ensure_table(table_name)
+        yield EnsuredTable.new(table_name, self)
+      end
+
+      def ensure_index(table_name, column_name, options = {})
+        unless new_index_exists?(table_name, column_name, options)
+          add_index(table_name, column_name, options)
+        end
+      end
+    end
+  end
+end

data/lib/ensured_schema/version.rb

@@ -1,3 +1,3 @@
 module EnsuredSchema
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/ensured_schema.rb

@@ -1,155 +1,5 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class AbstractAdapter
-      def table_exists?(table_name)
-        tables.map(&:downcase).include?(table_name.to_s.downcase)
-      end
-    end
-
-    module SchemaStatements
-      # Checks to see if a column exists in a given table.
-      #
-      # === Examples
-      #  # Check a column exists
-      #  column_exists?(:suppliers, :name)
-      #
-      #  # Check a column exists of a particular type
-      #  column_exists?(:suppliers, :name, :string)
-      #
-      #  # Check a column exists with a specific definition
-      #  column_exists?(:suppliers, :name, :string, :limit => 100)
-      def column_exists?(table_name, column_name, type = nil, options = {})
-        #debugger
-        columns(table_name).any?{ |c| c.name == column_name.to_s &&
-                                      (!type                 || c.type.to_s == type.to_s) &&
-                                      (!options[:limit]      || c.limit_exists?(options[:limit])) &&
-                                      (!options[:precision]  || c.precision == options[:precision]) &&
-                                      (!options[:scale]      || c.scale == options[:scale]) }
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    class Column
-      def limit_exists?(new_limit)
-        self.limit == new_limit
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    class MysqlColumn
-      def limit_exists?(new_limit)
-        return super unless type.to_s == 'integer'
-        case new_limit
-        when 5..8
-          self.limit == 8
-        when nil, 4, 11
-          self.limit == 4
-        else
-          self.limit == new_limit
-        end
-      end
-    end
-  end
-end
-
-
-module ActiveRecord
-  module ConnectionAdapters
-    class EnsuredTable < Table
-
-      def column_exists?(column_name, type = nil, options = {})
-        #debugger
-        @base.column_exists?(@table_name, column_name, type, options)
-      end
-
-      %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
-        class_eval <<-EOV
-          def #{column_type}(*args)                   # def string(*args)
-            define_columns('#{column_type}', *args)    #   define_column('string', *args)
-          end                                         # end
-        EOV
-      end
-
-      def define_columns(column_type, *args)
-        options = args.extract_options!
-        column_names = args
-
-        column_names.each do |name|
-          column_def = build_column_definition(name, column_type, options)
-          def_options = column_def.members.inject({}){|h, k| h[k.to_sym] = column_def[k]; h;}
-          #debugger
-          if column_exists?(name)
-            unless column_exists?(name, column_type, def_options)
-              debugger
-              change(name, column_def.sql_type, options)
-              puts "#{name} has been changed!"
-            end
-          else
-            puts "creating column"
-            @base.add_column(@table_name, name, column_def.sql_type, options)
-          end
-        end
-      end
-
-      def build_column_definition(column_name, column_type, options = {})
-        column = ColumnDefinition.new(@base, column_name, column_type)
-        if options[:limit]
-          column.limit = options[:limit]
-        elsif native[column_type.to_sym].is_a?(Hash)
-          column.limit = native[column_type.to_sym][:limit]
-        end
-        column.precision = options[:precision]
-        column.scale = options[:scale]
-        column.default = options[:default]
-        column.null = options[:null]
-        column
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  class Schema
-    def self.ensure(options={}, &block)
-      self.define(options, &block)
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters # :nodoc:
-    module SchemaStatements
-      def table(table_name, options = {}, &block)
-        if table_exists?(table_name)
-          puts "table already exists"
-          ensure_table(table_name, &block) # what to do about changing table options
-        else
-          puts "creating table"
-          create_table(table_name, options, &block)
-        end
-      end
-
-      def ensure_table(table_name)
-        yield EnsuredTable.new(table_name, self)
-      end
-
-      def ensure_index(table_name, column_name, options = {})
-        begin
-          add_index(table_name, column_name, options)
-        rescue => e
-          if e.message =~ /Duplicate key/
-            puts "index already exists"
-          else
-            raise e
-          end
-        end
-      end
-    end
-  end
-end
+require 'ensured_schema/column'
+require 'ensured_schema/mysql_column'
+require 'ensured_schema/schema_statements'
+require 'ensured_schema/ensured_table'
+require 'ensured_schema/schema'

data/test/cases/ensured_schema_test.rb

@@ -0,0 +1,206 @@
+require "cases/helper"
+
+require 'models/person'
+
+if ActiveRecord::Base.connection.supports_migrations?
+  class ActiveRecord::Migration
+    class <<self
+      attr_accessor :message_count
+      def puts(text="")
+        self.message_count ||= 0
+        self.message_count += 1
+      end
+    end
+  end
+
+  class EnsuredSchemaTest < ActiveRecord::TestCase
+    def setup
+      @conn = ActiveRecord::Base.connection
+      @conn.drop_table("testings") if @conn.table_exists?("testings")
+      @conn.drop_table("testings") if @conn.table_exists?("testings")
+    end
+
+    def testings_definition
+      assert_nothing_raised do
+        ActiveRecord::Schema.ensure(:version => '1') do
+          table(:testings, :id => false, :force => true) do |t|
+            t.string :test,  :limit => 30, :default => "", :null => false
+          end
+        end
+
+        ActiveRecord::Schema.ensure(:version => '1') do
+          table(:testings, :id => false, :force => true) do |t|
+            t.string :test,  :limit => 30, :default => "", :null => false
+          end
+        end
+      end
+      assert @conn.table_exists?("testings")
+    end
+
+    def test_column_definition_does_not_raise
+      assert_nothing_raised do
+        ActiveRecord::Schema.ensure(:version => '1') do
+          table(:testings, :id => false, :force => true) do |t|
+            t.string :test,  :limit => 30, :default => "", :null => false
+          end
+          table(:testings, :id => false, :force => true) do |t|
+            t.expects(:change).never
+            t.string :test,  :limit => 30, :default => "", :null => false
+          end
+        end
+      end
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_column_exists
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string
+      end
+
+      assert Person.connection.column_exists?(:testings, :foo)
+      assert !Person.connection.column_exists?(:testings, :bar)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_column_exists_with_type
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string
+        t.column :bar, :decimal, :precision => 8, :scale => 2
+      end
+
+      assert Person.connection.column_exists?(:testings, :foo, :string)
+      assert !Person.connection.column_exists?(:testings, :foo, :integer)
+      assert Person.connection.column_exists?(:testings, :bar, :decimal)
+      assert !Person.connection.column_exists?(:testings, :bar, :integer)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_column_exists_with_definition
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+        t.column :bar, :decimal, :precision => 8, :scale => 2
+      end
+
+      assert Person.connection.column_exists?(:testings, :foo, :string, :limit => 100)
+      assert !Person.connection.column_exists?(:testings, :foo, :string, :limit => 50)
+      assert Person.connection.column_exists?(:testings, :bar, :decimal, :precision => 8, :scale => 2)
+      assert !Person.connection.column_exists?(:testings, :bar, :decimal, :precision => 10, :scale => 2)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_new_index_exists?
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+        t.column :bar, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, :foo
+
+      assert Person.connection.new_index_exists?(:testings, :foo)
+      assert !Person.connection.new_index_exists?(:testings, :bar)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_new_index_exists?_on_multiple_columns
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+        t.column :bar, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, [:foo, :bar]
+
+      assert Person.connection.new_index_exists?(:testings, [:foo, :bar])
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_unique_new_index_exists?
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, :foo, :unique => true
+
+      assert Person.connection.new_index_exists?(:testings, :foo, :unique => true)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    # From original column_exists? patch in Rails 3: https://rails.lighthouseapp.com/projects/8994/tickets/4219
+    def test_named_new_index_exists?
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, :foo, :name => "custom_index_name"
+
+      assert Person.connection.new_index_exists?(:testings, :foo, :name => "custom_index_name")
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_column_exists_with_integer_limit
+      @conn.create_table :testings do |t|
+        t.column :one,    :integer, :limit => 1
+        t.column :two,    :integer, :limit => 2
+        t.column :three,  :integer, :limit => 3
+        t.column :four,   :integer, :limit => 4
+        t.column :five,   :integer, :limit => 5
+        t.column :six,    :integer, :limit => 6
+        t.column :seven,  :integer, :limit => 7
+        t.column :eight,  :integer, :limit => 8
+        t.column :eleven, :integer, :limit => 11
+      end
+
+      assert @conn.column_exists?(:testings, :one,    :integer, :limit => 1)
+      assert @conn.column_exists?(:testings, :two,    :integer, :limit => 2)
+      assert @conn.column_exists?(:testings, :three,  :integer, :limit => 3)
+      assert @conn.column_exists?(:testings, :four,   :integer, :limit => 4)
+      assert @conn.column_exists?(:testings, :five,   :integer, :limit => 5)
+      assert @conn.column_exists?(:testings, :six,    :integer, :limit => 6)
+      assert @conn.column_exists?(:testings, :seven,  :integer, :limit => 7)
+      assert @conn.column_exists?(:testings, :eight,  :integer, :limit => 8)
+      assert @conn.column_exists?(:testings, :eleven, :integer, :limit => 11)
+    end
+
+    def test_column_gets_changed
+      ActiveRecord::Schema.ensure(:version => '1') do
+        table(:testings, :id => false, :force => true) do |t|
+          t.string :test,  :limit => 30, :default => "", :null => false
+        end
+        table(:testings, :id => false, :force => true) do |t|
+          t.string :test,  :limit => 20, :default => "", :null => false
+        end
+      end
+
+      assert !@conn.column_exists?(:testings, :test, :string, :limit => 30)
+      assert @conn.column_exists?(:testings, :test, :string, :limit => 20, :default => "", :null => false)
+      assert @conn.column_exists?(:testings, :test)
+    end
+
+    def test_ensure_index
+      assert_nothing_raised do
+        ActiveRecord::Schema.ensure(:version => '1') do
+          table(:testings, :id => false, :force => true) do |t|
+            t.string :test,  :limit => 30, :default => "", :null => false
+          end
+          ensure_index :testings, [:test], :name => "test_index", :unique => true
+          ensure_index :testings, [:test], :name => "test_index", :unique => true
+        end
+      end
+      assert @conn.new_index_exists?(:testings, :test, :name => "test_index")
+    end
+
+    protected
+    def with_change_table
+      Person.connection.change_table :delete_me do |t|
+        yield t
+      end
+    end
+  end
+end

data/test/cases/helper.rb

@@ -0,0 +1,70 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
+
+require 'config'
+
+require 'rubygems'
+require 'test/unit'
+require 'stringio'
+
+require 'active_record'
+require 'active_record/test_case'
+require 'active_record/fixtures'
+require 'connection'
+
+require 'cases/repair_helper'
+
+require 'ensured_schema'
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+# Quote "type" if it's a reserved word for the current connection.
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
+
+def current_adapter?(*types)
+  types.any? do |type|
+    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
+  end
+end
+
+ActiveRecord::Base.connection.class.class_eval do
+  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+
+  def execute_with_query_record(sql, name = nil, &block)
+    $queries_executed ||= []
+    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+    execute_without_query_record(sql, name, &block)
+  end
+
+  alias_method_chain :execute, :query_record
+end
+
+# Make with_scope public for tests
+class << ActiveRecord::Base
+  public :with_scope, :with_exclusive_scope
+end
+
+unless ENV['FIXTURE_DEBUG']
+  module ActiveRecord::TestFixtures::ClassMethods
+    def try_to_load_dependency_with_silence(*args)
+      ActiveRecord::Base.logger.silence { try_to_load_dependency_without_silence(*args)}
+    end
+
+    alias_method_chain :try_to_load_dependency, :silence
+  end
+end
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  include ActiveRecord::Testing::RepairHelper
+
+  self.fixture_path = FIXTURES_ROOT
+  self.use_instantiated_fixtures  = false
+  self.use_transactional_fixtures = true
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+  end
+end