automigration 0.2.1

data/lib/automigration/migrator.rb

@@ -0,0 +1,189 @@
+module Automigration
+  class Migrator
+    mattr_reader :system_tables
+    mattr_reader :migrations_path
+    mattr_reader :models_load_path
+    mattr_reader :models_to_ignore
+    @@system_tables = []
+    @@migrations_path = nil
+    @@models_load_path = []
+    @@models_to_ignore = []
+
+    def self.set_system_tables(tables)
+      @@system_tables = tables
+    end
+
+    def self.set_migrations_path(path)
+      @@migrations_path = path
+    end
+
+    def self.set_models_load_path(paths)
+      @@models_load_path = paths
+    end
+
+    def self.set_models_to_ignore(models)
+      @@models_to_ignore = models
+    end
+
+    def self.all_tables
+      sql = "SELECT tablename FROM pg_tables WHERE schemaname = 'public';"
+      ActiveRecord::Base.connection.execute(sql).map do |row|
+        row["tablename"]
+      end
+    end
+
+    def self.get_models
+      @@models_load_path.map do |path|
+        Dir[File.expand_path("**/*.rb", path)].map do |model_file|
+          model_name = model_file.sub(path.to_s + '/', '').sub(/.rb$/, '')
+          next if @@models_to_ignore.include?(model_name)
+          model = model_name.camelize.constantize
+          if model && model.is_a?(Class) && model.superclass == ActiveRecord::Base
+            model
+          end
+        end
+      end.flatten.compact
+    end
+
+    def initialize(options = {})
+      options.assert_valid_keys(:skip_output, :models)
+
+      @models = options[:models] || self.class.get_models
+      @options = options
+    end
+
+    def update_schema!
+      log "Models: " + @models.map(&:to_s).join(', ')
+
+      # update tables
+      tables = ['schema_migrations']
+      @models.each do |model|
+        update_model_schema(model)
+        tables << model.table_name
+
+        # update globalize2 tables
+        if model.respond_to?(:translated_attribute_names)
+          translated_model = translated_model(model)
+          update_model_schema(translated_model)
+          tables << translated_model.table_name
+        end
+      end
+
+      #remove unused tables
+      (self.class.all_tables - tables - @@system_tables).each do |table|
+        con.drop_table(table)
+        log "Remove table '#{table}'", :red
+      end
+
+      # clean migration table
+      if con.table_exists?('schema_migrations') and @@migrations_path
+        sql = "SELECT version FROM schema_migrations;"
+
+        migrations_in_db = con.execute(sql).map{|row| row['version']}
+        current_migrations = Dir[File.expand_path("*.rb", @@migrations_path)].map do |m_file| 
+          File.basename(m_file) =~ /(\d{14})/
+          $1
+        end
+
+        (migrations_in_db - current_migrations).each do |m|
+          log "Clean migration '#{m}'", :red
+          sql = "DELETE FROM schema_migrations WHERE version = '#{m}';"
+          con.execute(sql)
+        end
+      end
+    end
+
+    private
+    def translated_model(model)
+      Class.new(ActiveRecord::Base).tap do |out|
+        out.set_table_name((model.model_name.underscore + '_translation').pluralize)
+
+        out.has_fields do |f|
+          f.integer "#{model.table_name.singularize}_id"
+          f.string :locale
+          model.translated_attribute_names.each do |attr_name|
+            model.fields_keeper.db_columns_for_field(attr_name).each do |column|
+              f.send column.type, column.name
+            end
+          end
+        end
+      end
+    end
+
+    def update_model_schema(model)
+      # 0. Create table if need
+      unless con.table_exists?(model.table_name)
+        con.create_table(model.table_name) {}
+        log "Create table #{model.table_name}", :green
+        model.reset_column_information
+      end
+
+      unless model.fields_keeper.auto_migrable?
+        log "#{model.to_s} skipped", :yellow
+      else
+        log "process #{model.to_s} ..."
+        auto_columns = model.fields_keeper.db_columns
+        auto_columns_names = auto_columns.map{|c| c.name.to_s}
+        auto_columns_hash = Hash[auto_columns.map{|c| [c.name.to_s, c]}]
+
+        # 1. update columns
+        (model.column_names & auto_columns_names).each do |name|
+          model_column = Fields::Sys::DbColumn.from_activerecord_column(model.columns_hash[name])
+          auto_column = auto_columns_hash[name]
+
+          unless model_column.the_same?(auto_column)
+            begin
+              con.change_column(model.table_name, name, auto_column.type, auto_column.to_options)
+
+              log "Update column #{name} of #{model.table_name} " + 
+                "to :#{auto_column.type} type and options #{auto_column.to_options.inspect}", :yellow
+            rescue
+              con.remove_column(model.table_name, name)
+              con.add_column(model.table_name, name, auto_column.type, auto_column.to_options)
+              log "recreate column #{name} in #{model.table_name}", :yellow
+            end
+          end
+        end
+
+        # 2. add new columns
+        (auto_columns_names - model.column_names).each do |name|
+          auto_column = auto_columns_hash[name]
+          con.add_column(model.table_name, name, auto_column.type, auto_column.to_options)
+          log "Add column #{name} to #{model.table_name}", :green
+
+          model.reset_column_information
+
+          if auto_column.options[:default].present?
+            model.update_all("#{name} = '#{auto_column.options[:default]}'")
+            log "Update default value for #{model.count} models", :green
+          end
+        end
+
+        # 3. remove obsoleted columns
+        not_to_del = ['id'] + model.fields_keeper.migration_attrs
+        (model.column_names - auto_columns_names - not_to_del).each do |name|
+          con.remove_column(model.table_name, name)
+          log "Remove column #{name} from #{model.table_name}", :red
+        end
+
+        model.reset_column_information
+      end
+    end
+
+    def con
+      ActiveRecord::Base.connection
+    end
+
+    def log(msg, color = nil)
+      puts "[auto] " + colored(msg, color) unless @options[:skip_output]
+    end
+
+    def colored(msg, color)
+      if [:red, :green, :yellow].include? color
+        ANSI.send(color){msg}
+      else
+        msg
+      end
+    end
+  end
+end

data/lib/automigration/version.rb

@@ -0,0 +1,3 @@
+module Automigration
+  VERSION = "0.2.1"
+end

data/lib/automigration.rb

@@ -0,0 +1,42 @@
+require 'rails/engine'
+require 'ansi'
+require 'automigration/version'
+require 'automigration/migrator'
+require 'automigration/fields/sys/base'
+require 'automigration/fields/belongs_to'
+require 'automigration/fields/boolean'
+require 'automigration/fields/date'
+require 'automigration/fields/datetime'
+require 'automigration/fields/float'
+require 'automigration/fields/integer'
+require 'automigration/fields/password'
+require 'automigration/fields/string'
+require 'automigration/fields/text'
+require 'automigration/fields/time'
+require 'automigration/fields/sys/db_column'
+require 'automigration/fields/sys/keeper'
+require 'automigration/fields/sys/slice_creater'
+
+module Automigration
+  class Engine < ::Rails::Engine
+    config.automigration = ActiveSupport::OrderedOptions.new
+    config.automigration.system_tables = []
+    config.automigration.models_load_path = []
+    config.automigration.models_to_ignore = []
+    config.automigration.migrations_path = nil
+
+    initializer 'automigration' do |app|
+      app.config.automigration.models_load_path << Rails.root + 'app/models'
+      app.config.automigration.migrations_path = Rails.root + 'db/migrate'
+
+      ActiveSupport.on_load(:active_record) do
+        require 'automigration/base_extention'
+      end
+
+      Migrator.set_models_load_path(app.config.automigration.models_load_path)
+      Migrator.set_models_to_ignore(app.config.automigration.models_to_ignore)
+      Migrator.set_system_tables(app.config.automigration.system_tables)
+      Migrator.set_migrations_path(app.config.automigration.migrations_path)
+    end
+  end
+end

data/lib/tasks/automigration.rake

@@ -0,0 +1,8 @@
+namespace :db do
+  desc "Auto migration"
+  task :auto => :environment do
+    Rake::Task['db:create'].invoke
+    Automigration::Migrator.new.update_schema!
+    Rake::Task['db:migrate'].invoke
+  end
+end

data/test/auto_migration_test.rb

@@ -0,0 +1,186 @@
+require 'test_helper'
+
+module Automigration
+  class AutoMigrationTest < ActiveSupport::TestCase
+    def setup
+      @migrations_path = Migrator.migrations_path
+      @system_tables = Migrator.system_tables
+      @models_to_ignore = Migrator.models_to_ignore
+    end
+
+    def teardown
+      Migrator.set_migrations_path(@migrations_path)
+      Migrator.set_system_tables(@system_tables)
+      Migrator.set_models_to_ignore(@models_to_ignore)
+
+      if connection.table_exists?('not_used_table')
+        connection.drop_table('not_used_table')
+      end
+
+      if connection.table_exists?('schema_migrations')
+        connection.drop_table('schema_migrations')
+      end
+
+      FileUtils.rm_rf(migrations_dir)
+
+      connection.drop_table('auto_migration1s') if Migrator.all_tables.index('auto_migration1s')
+      connection.drop_table('auto_migration2s')
+      Migrator.new(:skip_output => true).update_schema!
+    end
+
+    def test_create_table_if_need
+      connection.drop_table('auto_migration1s')
+      assert !Migrator.all_tables.index('auto_migration1s')
+
+      Migrator.new(:skip_output => true).update_schema!
+      assert Migrator.all_tables.index('auto_migration1s')
+    end
+
+    def test_not_create_table_if_ignored
+      connection.drop_table('auto_migration1s')
+      assert !Migrator.all_tables.index('auto_migration1s')
+
+      Migrator.set_models_to_ignore(['auto_migration1'])
+      Migrator.new(:skip_output => true).update_schema!
+      assert !Migrator.all_tables.index('auto_migration1s')
+    end
+
+    def test_remove_unused_table
+      connection.create_table('not_used_table')
+      assert Migrator.all_tables.index('not_used_table')
+
+      Migrator.new(:skip_output => true).update_schema!
+      assert !Migrator.all_tables.index('not_used_table')
+    end
+
+    def test_not_remove_unused_table_if_it_checked_as_not_migratable
+      connection.create_table('not_used_table')
+      Migrator.set_system_tables(%w(not_used_table))
+      assert Migrator.all_tables.index('not_used_table')
+
+      Migrator.new(:skip_output => true).update_schema!
+      assert Migrator.all_tables.index('not_used_table')
+    end
+
+    def test_clean_unused_migration
+      connection.create_table('schema_migrations') do |t|
+        t.string :version
+      end
+      connection.execute("INSERT INTO schema_migrations(version) VALUES('20110114120000')")
+      connection.execute("INSERT INTO schema_migrations(version) VALUES('20110114132500')")
+      connection.execute("INSERT INTO schema_migrations(version) VALUES('20110114193000')")
+
+      FileUtils.mkdir_p(migrations_dir)
+      File.open(migrations_dir + "/20110114120000_create_users.rb", "w"){|f| f.puts "# some text"}
+      File.open(migrations_dir + "/20110114193000_create_projects.rb", "w"){|f| f.puts "# some text"}
+
+      Migrator.set_migrations_path(migrations_dir)
+
+      count_sql = "SELECT count(*) AS count FROM schema_migrations"
+      assert_equal 3, connection.execute(count_sql)[0]['count'].to_i
+      Migrator.new(:skip_output => true).update_schema!
+      assert_equal 2, connection.execute(count_sql)[0]['count'].to_i
+    end
+    
+    def test_update_column_for_model_not_change_type_dramatically
+      connection.remove_column(AutoMigration1.table_name, 'string_field')
+      connection.add_column(AutoMigration1.table_name, 'string_field', :integer)
+      AutoMigration1.reset_column_information
+
+      AutoMigration1.create!(:string_field => 123)
+      assert_equal 123, AutoMigration1.first.string_field
+
+      Migrator.new(:skip_output => true).update_schema!
+
+      assert_equal '123', AutoMigration1.first.string_field
+    end
+
+    def test_update_column_for_model_change_type_dramatically
+      connection.remove_column(AutoMigration1.table_name, 'integer_field')
+      connection.add_column(AutoMigration1.table_name, 'integer_field', :string)
+      AutoMigration1.reset_column_information
+
+      AutoMigration1.create!(:integer_field => 'abc')
+      assert_equal 'abc', AutoMigration1.first.integer_field
+
+      Migrator.new(:skip_output => true).update_schema!
+
+      assert_equal nil, AutoMigration1.first.integer_field
+    end
+
+    def test_create_columns_for_model
+      assert AutoMigration1.new.attributes.keys.index("boolean_field")
+      assert AutoMigration1.new.attributes.keys.index("integer_field")
+      assert AutoMigration1.new.attributes.keys.index("float_field")
+      assert AutoMigration1.new.attributes.keys.index("string_field")
+      assert AutoMigration1.new.attributes.keys.index("text_field")
+      assert AutoMigration1.new.attributes.keys.index("datetime_field")
+      assert AutoMigration1.new.attributes.keys.index("date_field")
+      assert AutoMigration1.new.attributes.keys.index("time_field")
+      assert AutoMigration1.new.attributes.keys.index("additional_field")
+
+      assert AutoMigration1.new.attributes.keys.index("created_at")
+      assert AutoMigration1.new.attributes.keys.index("updated_at")
+    end
+
+    def test_create_columns_for_model_add_field
+      assert AutoMigration1a.new.attributes.keys.index("additional_field")
+      assert AutoMigration1a.new.attributes.keys.index("integer_field")
+
+      assert AutoMigration1a.new.attributes.keys.index("created_at")
+      assert AutoMigration1a.new.attributes.keys.index("updated_at")
+    end
+
+    def test_create_model_without_timestamps
+      assert !AutoMigration3.new.attributes.keys.index("created_at")
+      assert !AutoMigration3.new.attributes.keys.index("updated_at")
+    end
+
+    def test_destroy_columns_for_model
+      connection.add_column(AutoMigration1.table_name, 'new_column', :string)
+      AutoMigration1.reset_column_information
+
+      assert AutoMigration1.column_names.index('new_column')
+      Migrator.new(:skip_output => true).update_schema!
+      assert !AutoMigration1.column_names.index('new_column')
+    end
+
+    def test_destroy_columns_for_model
+      connection.add_column(AutoMigration1.table_name, 'new_column', :string)
+      AutoMigration1.reset_column_information
+
+      assert AutoMigration1.column_names.index('new_column')
+      Migrator.new(:skip_output => true).update_schema!
+      assert !AutoMigration1.column_names.index('new_column')
+    end
+
+    def test_destroy_columns_for_model_if_they_are_not_migrate_attr
+      connection.add_column(AutoMigration2.table_name, 'some_attr1', :string)
+      connection.add_column(AutoMigration2.table_name, 'some_attr2', :string)
+      connection.add_column(AutoMigration2.table_name, 'some_attr3', :string)
+      connection.add_column(AutoMigration2.table_name, 'some_attr4', :string)
+      AutoMigration2.reset_column_information
+
+      assert AutoMigration2.column_names.index('some_attr1')
+      assert AutoMigration2.column_names.index('some_attr2')
+      assert AutoMigration2.column_names.index('some_attr3')
+      assert AutoMigration2.column_names.index('some_attr4')
+
+      Migrator.new(:skip_output => true).update_schema!
+
+      assert AutoMigration2.column_names.index('some_attr1')
+      assert AutoMigration2.column_names.index('some_attr2')
+      assert AutoMigration2.column_names.index('some_attr3')
+      assert !AutoMigration2.column_names.index('some_attr4')
+    end
+
+    private
+    def migrations_dir
+      File.expand_path("../../../tmp/migrations", __FILE__)
+    end
+      
+    def connection
+      ActiveRecord::Base.connection
+    end
+  end
+end

data/test/belongs_to_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Automigration
+  class BelongsTest < ActiveSupport::TestCase
+    include ActionDispatch::Assertions::SelectorAssertions
+
+    setup do
+      @simple = Simple.create
+      @obj = BelongsToModel.create
+    end
+
+    teardown do 
+      Simple.destroy_all
+    end
+
+    test "properties" do
+      assert_nil @obj.simple
+      assert_nil @obj.simple_id
+    end
+
+    test "mass assignment by object" do
+      @obj.update_attributes(:simple => @simple)
+      assert_equal @simple.id, @obj.simple_id 
+    end
+
+    test "mass assignment by id" do
+      @obj.update_attributes(:simple_id => @simple.id)
+      assert_equal @simple.id, @obj.simple_id 
+    end
+
+    test "use different class name" do
+      @obj.update_attributes(:some => @simple)
+      assert_equal @simple, @obj.some
+    end
+
+    test "raise if wrong name" do
+      assert_raise RuntimeError do
+        Fields::Sys::Base.from_meta(
+          :as => :belongs_to,
+          :name => "simple_id"
+        )
+      end
+    end
+
+    test "parent and children" do
+      child = BelongsToModel.find(BelongsToModel.create(:parent => @obj).id)
+      assert_equal @obj, child.parent
+      assert_equal @obj.id, child.parent_id
+    end
+  end
+end

data/test/db_column_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+module Automigration
+  class DbColumnTest < ActiveSupport::TestCase
+    def test_the_same
+      a = Fields::Sys::DbColumn.new('field', 'integer',
+        :default => 3,
+        :null => true,
+        :limit => 3,
+        :scale => 1,
+        :precision => 2)
+
+      b = Fields::Sys::DbColumn.new('field', 'integer',
+        :default => 3,
+        :null => true,
+        :limit => 3,
+        :scale => 1,
+        :precision => 2)
+
+      assert a.the_same?(b)
+    end
+  end
+end

data/test/fields/accessible_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+module Automigration
+  module Fields
+    class AccessbileTest < ActiveSupport::TestCase
+      test "mass assignment deny" do
+        obj = AccessibleModel.create(:first => 123, :second => 345)
+        assert_equal 123, obj.first
+        assert_equal 0, obj.second
+      end
+    end
+  end
+end

data/test/fields_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Automigration
+  class FieldsTest < ActiveSupport::TestCase
+    def test_kind_of_field
+      assert_equal :boolean, Fields::Boolean.kind
+    end
+
+    def test_automigrable_model
+      assert Simple.fields_keeper.auto_migrable?
+      assert !NotAutomigrable.fields_keeper.auto_migrable?
+    end
+
+    def test_migrations_attrs
+      assert_equal [], AutoMigration1.fields_keeper.migration_attrs
+
+      assert_equal ['some_attr1', 'some_attr2' , 'some_attr3'], 
+        AutoMigration2.fields_keeper.migration_attrs
+    end
+
+    def test_boolean_column_false_by_default
+      assert_equal false, AutoMigration1.new.boolean_field
+    end
+
+    def test_from_meta
+      assert_equal Fields::Boolean, Fields::Sys::Base.from_meta(:as => :boolean, :name => 'some').class
+    end
+
+    def test_attributes_accessible
+      obj = AutoMigration1.create(:integer_field => 123)
+      assert_equal 123, obj.integer_field
+    end
+  end
+end

data/test/models/accessible_model.rb

@@ -0,0 +1,6 @@
+class AccessibleModel < ActiveRecord::Base
+  has_fields do |f|
+    f.integer :first, :default => 0
+    f.integer :second, :default => 0, :accessible => false
+  end
+end

data/test/models/auto_migration1.rb

@@ -0,0 +1,14 @@
+class AutoMigration1 < ActiveRecord::Base
+  has_fields do |f|
+    f.integer :integer_field
+    f.float :float_field
+    f.boolean :boolean_field
+    f.string :string_field
+    f.text :text_field
+    f.datetime :datetime_field
+    f.date :date_field
+    f.time :time_field
+  end
+
+  add_field :integer, :additional_field
+end

data/test/models/auto_migration1a.rb

@@ -0,0 +1,7 @@
+class AutoMigration1a < ActiveRecord::Base
+  add_field :integer, :additional_field
+
+  has_fields do |f|
+    f.integer :integer_field
+  end
+end

data/test/models/auto_migration2.rb

@@ -0,0 +1,8 @@
+class AutoMigration2 < ActiveRecord::Base
+  migration_attr :some_attr1, :some_attr2
+  migration_attr :some_attr3
+
+  has_fields do |f|
+    f.integer :integer_field
+  end
+end

data/test/models/auto_migration3.rb

@@ -0,0 +1,5 @@
+class AutoMigration3 < ActiveRecord::Base
+  has_fields :timestamps => false do |f|
+    f.integer :integer_field
+  end
+end

data/test/models/belongs_to_model.rb

@@ -0,0 +1,9 @@
+class BelongsToModel < ActiveRecord::Base
+  has_fields do |f|
+    f.string :name
+
+    f.belongs_to :simple
+    f.belongs_to :some, :class_name => 'Simple'
+    f.belongs_to :parent, :class_name => 'BelongsToModel'
+  end
+end

data/test/models/boolean_model.rb

@@ -0,0 +1,5 @@
+class BooleanModel < ActiveRecord::Base
+  has_fields do |f|
+    f.boolean :value
+  end
+end

data/test/models/form_field.rb

@@ -0,0 +1,6 @@
+class FormField < ActiveRecord::Base
+  has_fields do |f|
+    f.string :string
+    f.integer :integer
+  end
+end

data/test/models/form_field2.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+class FormField2 < ActiveRecord::Base
+  has_fields do |f|
+    f.string :string, :ru => 'Атрибут', :en => 'Attribute'
+  end
+end

data/test/models/local_name.rb

@@ -0,0 +1,5 @@
+class LocalName < ActiveRecord::Base
+  has_fields do |f|
+    f.integer :value
+  end
+end

data/test/models/local_name2.rb

@@ -0,0 +1,5 @@
+class LocalName2 < ActiveRecord::Base
+  has_fields do |f|
+    f.integer :value
+  end
+end

data/test/models/not_automigrable.rb

@@ -0,0 +1,2 @@
+class NotAutomigrable < ActiveRecord::Base
+end

data/test/models/searchable.rb

@@ -0,0 +1,6 @@
+class Searchable < ActiveRecord::Base
+  has_fields do |t|
+    t.string :title
+    t.text :body
+  end
+end

data/test/models/simple.rb

@@ -0,0 +1,5 @@
+class Simple < ActiveRecord::Base
+  has_fields do |f|
+    f.boolean :boolean
+  end
+end

data/test/models/user1.rb

@@ -0,0 +1,7 @@
+class User1 < ActiveRecord::Base
+  validates :login, :presence => true
+
+  has_fields do |f|
+    f.string :login
+  end
+end