data_migrator 1.7 → 1.8

data/lib/data_migrator.rb

@@ -1,73 +1,101 @@
 require "benchmark"
+require 'extensions/railties/engine'
+require 'extensions/railties/engine/configuration'
 
 class DataMigrationTask < Rails::Railtie
   rake_tasks do
-    Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
+    Dir[File.join(File.dirname(__FILE__), 'tasks/*.rake')].each { |f| load f }
   end
 end
 
 module RussellEdge
   class DataMigrator
     REMOVE_FILES_REGEX = /^\./
-    
+
     class << self
+      def migrations_path
+        "#{Rails.root}/db/data_migrations/"
+      end
+
+      def migrations(path)
+        files = Dir["#{path}/**/[0-9]*_*.rb" ]
+
+        seen = Hash.new false
+
+        migrations = files.map do |file|
+          version, name = file.scan(/([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?.rb/).first
+
+          raise ActiveRecord::IllegalMigrationNameError.new(file) unless version
+          version = version.to_i
+          name = name.camelize
+
+          raise ActiveRecord::DuplicateMigrationVersionError.new(version) if seen[version]
+          raise ActiveRecord::DuplicateMigrationNameError.new(name) if seen[name]
+
+          seen[version] = seen[name] = true
+
+          {:name => File.basename(file), :filename => file, :version => version}
+        end
+
+        migrations.sort{|h| h[:version]}
+      end
+
       def next_migration_number
-    	  Time.now.utc.strftime("%Y%m%d%H%M%S")
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
       end
-    
+
       def initialize_data_migrations_table
         puts "** data_migrations table missing creating now...."
-        puts ActiveRecord::Migrator.run(:up, File.join(File.dirname(__FILE__),'../db/migrate/'), 20100819181805)
+        puts ActiveRecord::Migrator.run(:up, File.join(File.dirname(__FILE__), '../db/migrate/'), 20100819181805)
         puts "** done"
       end
-      
-      def prepare_migrations
-        target = "#{Rails.root}/db/data_migrations/"
 
-        # first copy all app data_migrations away
-        files = Dir["#{target}*.rb"]
+      def copy(destination, sources, options = {})
+        copied = []
 
-        unless files.empty?
-          FileUtils.mkdir_p "#{target}/ignore/app/"
-          FileUtils.cp files, "#{target}/ignore/app/"
-          puts "copied #{files.size} data_migrations to db/data_migrations/ignore/app"
-        end
+        FileUtils.mkdir_p(destination) unless File.exists?(destination)
 
-        dirs = Rails::Application::Railties.engines.map{|p| p.config.root.to_s}
-        files = Dir["{#{dirs.join(',')}}/db/data_migrations/*.rb"]
+        destination_migrations = migrations(destination)
+        last = destination_migrations.last
+        sources.each do |scope, path|
+          source_migrations = migrations(path)
 
-        unless files.empty?
-          FileUtils.mkdir_p target
-          FileUtils.cp files, target
-          puts "copied #{files.size} migrations to db/data_migrations"
-        end
-      end
+          source_migrations.each do |migration|
 
-      def cleanup_migrations
-        target = "#{Rails.root}/db/data_migrations/"
+            source = File.read(migration[:filename])
+            source = "# This migration comes from #{scope} (originally #{migration[:version]})\n#{source}"
 
-    	  files = Dir["#{target}*.rb"]
-        unless files.empty?
-          FileUtils.rm files
-          puts "removed #{files.size} data_migrations from db/data_migrations"
-        end
-        files = Dir["#{target}/ignore/app/*.rb"]
-        unless files.empty?
-          FileUtils.cp files, target
-          puts "copied #{files.size} data_migrations back to db/data_migrations"
+            if duplicate = destination_migrations.detect { |m| m[:name] == migration[:name] }
+              if options[:on_skip] && duplicate.scope != scope.to_s
+                options[:on_skip].call(scope, migration)
+              end
+              next
+            end
+
+            migration[:version] = next_migration_number().to_i
+            new_path = File.join(destination, "#{File.basename(migration[:filename], '.*')}.#{scope}.rb")
+            old_path, migration[:filename] = migration[:filename], new_path
+
+            File.open(migration[:filename], "w") { |f| f.write source }
+            copied << migration
+            options[:on_copy].call(scope, migration, old_path) if options[:on_copy]
+            destination_migrations << migration
+          end
         end
-        FileUtils.rm_rf "#{target}/ignore/app"
+
+        copied
       end
+
     end
-    
+
     def initialize(migrations_path=nil)
       @default_migrations_path = migrations_path || "#{Rails.root}/db/data_migrations"
     end
-      
+
     def migrate(passed_location=nil, passed_version=nil)
       setup
-   
-      location = passed_location.nil? ? @default_migrations_path  : passed_location
+
+      location = passed_location.nil? ? @default_migrations_path : passed_location
       @@current_version = get_current_version
 
       if passed_version.nil? || @@current_version.nil?
@@ -78,12 +106,12 @@ module RussellEdge
         handle_higher_passed_version(passed_version)
       end
     end
-  
+
     def pending_migrations
       versions = []
       files = get_all_files
       files.each do |file|
-        filename, version, klass_name = seperate_file_parts(file)
+        filename, version, klass_name = separate_file_parts(file)
         versions << filename unless version_has_been_migrated?(version)
       end
 
@@ -99,64 +127,64 @@ module RussellEdge
 
       current_version
     end
-  
+
     def run_up(passed_version)
       setup
-    
+
       raise "VERSION is required" unless passed_version
-    
+
       files = get_all_files
       found = false
-    
+
       files.each do |file|
-        filename, version, klass_name = seperate_file_parts(file)
+        filename, version, klass_name = separate_file_parts(file)
         if passed_version == version
           found = true
           (version_has_been_migrated?(version)) ? (puts "** Version #{passed_version} has already been migrated") : handle_action(file, klass_name, version, :up)
         end
       end
-    
+
       puts "** Version #{passed_version} not found" unless found
-    
+
     end
-  
+
     def run_down(passed_version)
       setup
-    
+
       raise "VERSION is required" unless passed_version
-    
+
       files = get_all_files
-      found = false 
+      found = false
 
       files.each do |file|
-        filename, version, klass_name = seperate_file_parts(file)
+        filename, version, klass_name = separate_file_parts(file)
         if passed_version == version
           found = true
           (version_has_been_migrated?(version)) ? handle_action(file, klass_name, version, :down) : (puts "** Version #{passed_version} has not been migrated")
         end
       end
-    
+
       puts "** Version #{passed_version} not found" unless found
-    
+
     end
-	
+
     private
-  
+
     def setup
       RussellEdge::DataMigrator.initialize_data_migrations_table unless data_migrations_table_exists?
-      
-      unless File.directory?  @default_migrations_path
-        FileUtils.mkdir_p( @default_migrations_path)
+
+      unless File.directory? @default_migrations_path
+        FileUtils.mkdir_p(@default_migrations_path)
         #create ignore folder
-        FileUtils.mkdir_p(File.join(@default_migrations_path,'ignore/'))
+        FileUtils.mkdir_p(File.join(@default_migrations_path, 'ignore/'))
       end
     end
-  
+
     def handle_higher_passed_version(passed_version)
       files = get_all_files
 
       files.each do |file|
-        filename, version, klass_name = seperate_file_parts(file)
+        filename, version, klass_name = separate_file_parts(file)
         if version <= passed_version
           unless version_has_been_migrated?(version)
             handle_action(file, klass_name, version, :up)
@@ -170,9 +198,9 @@ module RussellEdge
       files = get_all_files
 
       files.each do |file|
-        filename, version, klass_name = seperate_file_parts(file)
+        filename, version, klass_name = separate_file_parts(file)
         if passed_version.nil? or version <= passed_version
-          if !version_has_been_migrated?(version) 
+          if !version_has_been_migrated?(version)
             handle_action(file, klass_name, version, :up)
           end
         end
@@ -183,7 +211,7 @@ module RussellEdge
       files = get_all_files
 
       files.each do |file|
-        filename, version, klass_name = seperate_file_parts(file)
+        filename, version, klass_name = separate_file_parts(file)
         if version > passed_version
           handle_action(file, klass_name, version, :down) if version_has_been_migrated?(version)
         end
@@ -201,16 +229,15 @@ module RussellEdge
             klass.send(action.to_s)
           end
         end
-      rescue Exception=>ex
-        RussellEdge::DataMigrator.cleanup_migrations
+      rescue Exception => ex
         raise ex
       end
       time_str = "(%.4fs)" % time.real
       puts "================Finished #{klass.to_s} in #{time_str}=="
-      
+
       (action == :up) ? insert_migration_version(version) : remove_migration_version(version)
     end
-  
+
     def insert_migration_version(version)
       ActiveRecord::Base.connection.execute("insert into data_migrations (version) values ('#{version}')")
     end
@@ -225,42 +252,43 @@ module RussellEdge
       db_result = ActiveRecord::Base.connection.select_all("select count(*) as num_rows from data_migrations where version = '#{version}'")
 
       num_rows = db_result[0]['num_rows'] unless db_result == -1
-    
+
       result = false if (num_rows.nil? || num_rows.to_i == 0)
       result
     end
 
     def data_migrations_table_exists?
-      table_names =  ActiveRecord::Base.connection.tables
+      table_names = ActiveRecord::Base.connection.tables
       table_names.include?('data_migrations')
     end
 
-    def seperate_file_parts(file)
+    def separate_file_parts(file)
       paths = file.split('/')
       filename = paths[paths.length - 1]
       version = filename.split('_')[0]
       klass_name = filename.gsub(/#{version}/, "").gsub(/.rb/, "")[1..filename.length]
+      klass_name = klass_name.split('.')[0] if klass_name.split('.').length > 1 #check for scope of engine name
 
       return filename, version.to_i, klass_name
     end
 
     def get_all_files
       files = []
-    
+
       if File.directory? @default_migrations_path
-    
-        files_or_directories = Dir.entries(@default_migrations_path).map{|directory| directory}
 
-        files_or_directories.delete_if{|name| name =~ REMOVE_FILES_REGEX} #remove any file leading with . or ..
-        files_or_directories.delete_if{|name| name == 'ignore'} #ignore the ignore folder
+        files_or_directories = Dir.entries(@default_migrations_path).map { |directory| directory }
+
+        files_or_directories.delete_if { |name| name =~ REMOVE_FILES_REGEX } #remove any file leading with . or ..
+        files_or_directories.delete_if { |name| name == 'ignore' } #ignore the ignore folder
+
 
-      
         files_or_directories.each do |file_or_directory|
           file_or_directory = @default_migrations_path + "/" + file_or_directory
           files = get_files_in_directory(file_or_directory, files)
         end
 
-        files.sort! {|x,y| File.basename(x) <=> File.basename(y)}
+        files.sort! { |x, y| File.basename(x) <=> File.basename(y) }
       end
 
       files
@@ -268,10 +296,10 @@ module RussellEdge
 
     def get_files_in_directory(file_or_directory, files)
       unless file_or_directory =~ /\w\.rb/
-        files_or_directories = Dir.entries(file_or_directory).map{|directory| directory}
+        files_or_directories = Dir.entries(file_or_directory).map { |directory| directory }
 
-        files_or_directories.delete_if{|name| name =~ REMOVE_FILES_REGEX} #remove any file leading with . or ..
-        files_or_directories.delete_if{|name| name == 'ignore'} #ignore the ignore folder
+        files_or_directories.delete_if { |name| name =~ REMOVE_FILES_REGEX } #remove any file leading with . or ..
+        files_or_directories.delete_if { |name| name == 'ignore' } #ignore the ignore folder
 
         files_or_directories.each do |_file_or_directory|
           _file_or_directory = file_or_directory + "/" + _file_or_directory

data/lib/extensions/railties/engine.rb

@@ -0,0 +1,23 @@
+Rails::Engine.class_eval do
+  rake_tasks do
+    next if self.is_a?(Rails::Application)
+    next unless has_data_migrations?
+
+    namespace railtie_name do
+      namespace :install do
+        desc "Copy data_migrations from #{railtie_name} to application"
+        task :data_migrations do
+          ENV["FROM"] = railtie_name
+          Rake::Task["railties:install:data_migrations"].invoke
+        end
+      end
+    end
+  end
+
+  protected
+
+  def has_data_migrations?
+    paths["db/data_migrations"].existent.any?
+  end
+
+end

data/lib/extensions/railties/engine/configuration.rb

@@ -0,0 +1,30 @@
+Rails::Engine::Configuration.class_eval do
+  def paths
+    @paths ||= begin
+      paths = Rails::Paths::Root.new(@root)
+      paths.add "app",                 :eager_load => true, :glob => "*"
+      paths.add "app/assets",          :glob => "*"
+      paths.add "app/controllers",     :eager_load => true
+      paths.add "app/helpers",         :eager_load => true
+      paths.add "app/models",          :eager_load => true
+      paths.add "app/mailers",         :eager_load => true
+      paths.add "app/views"
+      paths.add "lib",                 :load_path => true
+      paths.add "lib/assets",          :glob => "*"
+      paths.add "lib/tasks",           :glob => "**/*.rake"
+      paths.add "config"
+      paths.add "config/environments", :glob => "#{Rails.env}.rb"
+      paths.add "config/initializers", :glob => "**/*.rb"
+      paths.add "config/locales",      :glob => "*.{rb,yml}"
+      paths.add "config/routes",       :with => "config/routes.rb"
+      paths.add "db"
+      paths.add "db/migrate"
+      paths.add "db/data_migrations"
+      paths.add "db/seeds",            :with => "db/seeds.rb"
+      paths.add "vendor",              :load_path => true
+      paths.add "vendor/assets",       :glob => "*"
+      paths.add "vendor/plugins"
+      paths
+    end
+  end
+end

data/lib/tasks/data_migrator.rake

@@ -2,20 +2,16 @@ namespace :db do
   desc 'migrates data into database'
   task :migrate_data => :environment do
     passed_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-    RussellEdge::DataMigrator.prepare_migrations
+
     RussellEdge::DataMigrator.new.migrate(nil, passed_version)
-	  RussellEdge::DataMigrator.cleanup_migrations
-      
   end#end migrate_data task
     
   namespace :migrate_data do
 	task :list_pending => :environment do
-      RussellEdge::DataMigrator.prepare_migrations
       pending_migrations = RussellEdge::DataMigrator.new.pending_migrations
       puts "================Pending Data Migrations=========="
       puts pending_migrations
       puts "================================================="
-      RussellEdge::DataMigrator.cleanup_migrations
     end#end list_pending task
 
     task :version => :environment do
@@ -26,23 +22,44 @@ namespace :db do
     task :up => :environment do
       passed_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless passed_version
-       
-      RussellEdge::DataMigrator.prepare_migrations
+
       RussellEdge::DataMigrator.new.run_up(passed_version)
-      RussellEdge::DataMigrator.cleanup_migrations
-        
     end#end up task
       
     task :down => :environment do
       passed_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless passed_version
-		  
-      RussellEdge::DataMigrator.prepare_migrations
+
       RussellEdge::DataMigrator.new.run_down(passed_version)
-      RussellEdge::DataMigrator.cleanup_migrations
-        
     end#end down task
   end#end namespace
 end
 
+namespace :railties do
+  namespace :install do
+    # desc "Copies missing data_migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
+    task :data_migrations => :environment do
+      to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map {|n| n.strip }
+      railties = ActiveSupport::OrderedHash.new
+      Rails.application.railties.all do |railtie|
+        next unless to_load == :all || to_load.include?(railtie.railtie_name)
+
+        if railtie.respond_to?(:paths) && (path = railtie.paths['db/data_migrations'].first)
+          railties[railtie.railtie_name] = path
+        end
+      end
+
+      on_skip = Proc.new do |name, migration|
+        puts "NOTE: Data Migration #{migration[:name]} from #{name} has been skipped. Migration with the same name already exists."
+      end
+
+      on_copy = Proc.new do |name, migration, old_path|
+        puts "Copied data_migration #{migration[:name]} from #{name}"
+      end
+
+      RussellEdge::DataMigrator.copy(RussellEdge::DataMigrator.migrations_path, railties, :on_skip => on_skip, :on_copy => on_copy)
+    end
+  end
+end
+
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: data_migrator
 version: !ruby/object:Gem::Version
-  version: '1.7'
+  version: '1.8'
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,19 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-26 00:00:00.000000000Z
+date: 2012-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &2157691620 !ruby/object:Gem::Requirement
+  name: rails
+  requirement: &70230211897860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.3.5
+        version: '2.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2157691620
+  version_requirements: *70230211897860
 description: Allows you to create data migrations that can be run up and down to insert
   data into the database.
 email: russellfholmes@gmail.com
@@ -31,6 +31,8 @@ extra_rdoc_files: []
 files:
 - db/migrate/20100819181805_create_data_migrations_table.rb
 - lib/data_migrator.rb
+- lib/extensions/railties/engine/configuration.rb
+- lib/extensions/railties/engine.rb
 - lib/generators/data_migration/data_migration_generator.rb
 - lib/generators/data_migration/templates/migration_template.rb
 - lib/generators/data_migration/USAGE
@@ -59,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Creates Data Migrations for data similar to schema migrations.