tennpipes-init 3.6.6

data/lib/tennpipes-init/tennpipes-tasks/database.rb

@@ -0,0 +1,12 @@
+has_seeds = File.file?('db/seeds.rb')
+if TennpipesTasks.load?(:database, has_seeds)
+  namespace :db do
+    desc 'Load the seed data from db/seeds.rb'
+    task :seed => :environment do
+      seed_file = Tennpipes.root('db', 'seeds.rb')
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  task :seed => 'db:seed'
+end

data/lib/tennpipes-init/tennpipes-tasks/datamapper.rb

@@ -0,0 +1,94 @@
+if TennpipesTasks.load?(:datamapper, defined?(DataMapper))
+  namespace :dm do
+    namespace :auto do
+      desc "Perform auto migration (reset your db data)"
+      task :migrate => :environment do
+        ::DataMapper.repository.auto_migrate!
+        puts "<= dm:auto:migrate executed"
+      end
+
+      desc "Perform non destructive auto migration"
+      task :upgrade => :environment do
+        ::DataMapper.repository.auto_upgrade!
+        puts "<= dm:auto:upgrade executed"
+      end
+    end
+
+    namespace :migrate do
+      task :load => :environment do
+        require 'dm-migrations/migration_runner'
+        FileList["db/migrate/*.rb"].each do |migration|
+          load migration
+        end
+      end
+
+      desc "Migrate up using migrations"
+      task :up, [:version] => :load do |t, args|
+        version = args[:version] || env_migration_version
+        migrate_up!(version)
+        puts "<= dm:migrate:up #{version} executed"
+      end
+
+      desc "Migrate down using migrations"
+      task :down, [:version] => :load do |t, args|
+        version = args[:version] || env_migration_version
+        migrate_down!(version)
+        puts "<= dm:migrate:down #{version} executed"
+      end
+    end
+
+    desc "Migrate the database to the latest version"
+    task :migrate do
+      migrate_task = if Dir['db/migrate/*.rb'].empty?
+                       'dm:auto:upgrade'
+                     else
+                       'dm:migrate:up'
+                     end
+
+      Rake::Task[migrate_task].invoke
+    end
+
+    desc "Create the database"
+    task :create => :environment do
+      config = DataMapper.repository.adapter.options.symbolize_keys
+      adapter = config[:adapter]
+      user, password, host = config[:user], config[:password], config[:host]
+
+      database       = config[:database]  || config[:path]
+      database.sub!(/^\//,'') unless adapter.start_with?('sqlite')
+
+      charset        = config[:charset]   || ENV['CHARSET']   || 'utf8'
+      collation      = config[:collation] || ENV['COLLATION'] || 'utf8_unicode_ci'
+
+      puts "=> Creating database '#{database}'"
+      Tennpipes::Generators::SqlHelpers.create_db(adapter, user, password, host, database, charset, collation)
+      puts "<= dm:create executed"
+    end
+
+    desc "Drop the database (postgres and mysql only)"
+    task :drop => :environment do
+      config = DataMapper.repository.adapter.options.symbolize_keys
+      adapter = config[:adapter]
+      user, password, host = config[:user], config[:password], config[:host]
+
+      database       = config[:database] || config[:path]
+      database.sub!(/^\//,'') unless adapter.start_with?('sqlite')
+
+      puts "=> Dropping database '#{database}'"
+      Tennpipes::Generators::SqlHelpers.drop_db(adapter, user, password, host, database)
+      puts "<= dm:drop executed"
+    end
+
+    desc "Drop the database, migrate from scratch and initialize with the seed data"
+    task :reset => [:drop, :setup]
+
+    desc "Create the database migrate and initialize with the seed data"
+    task :setup => [:create, :migrate, :seed]
+  end
+
+  task 'db:migrate' => 'dm:migrate'
+  task 'db:create'  => 'dm:create'
+  task 'db:drop'    => 'dm:drop'
+  task 'db:reset'   => 'dm:reset'
+  task 'db:setup'   => 'dm:setup'
+end

data/lib/tennpipes-init/tennpipes-tasks/minirecord.rb

@@ -0,0 +1,19 @@
+if TennpipesTasks.load?(:minirecord, defined?(MiniRecord))
+  namespace :mr do
+    desc 'Auto migration of database'
+    task :migrate => :environment do
+      Dir["models/*.rb"].each do |file_path|
+        basename = File.basename(file_path, File.extname(file_path))
+        clazz = basename.camelize.constantize
+        clazz.auto_upgrade! if clazz.ancestors.include?(ActiveRecord::Base)
+      end
+      puts "<= mr:migrate executed"
+    end
+  end
+
+  task 'db:migrate' => 'mr:migrate'
+  # task 'db:create'  => 'mr:create'
+  # task 'db:drop'    => 'mr:drop'
+  # task 'db:reset'   => 'mr:reset'
+  # task 'db:setup'   => 'mr:setup'
+end

data/lib/tennpipes-init/tennpipes-tasks/mongoid.rb

@@ -0,0 +1,215 @@
+if TennpipesTasks.load?(:mongoid, defined?(Mongoid))
+  require 'mongoid'
+
+  namespace :mi do
+
+    if Mongoid::VERSION =~ /^[012]\./
+      # Mongoid 2 API
+      def mongoid_collections
+        Mongoid.master.collections
+      end
+
+      def mongoid_collection(name)
+        Mongoid.master.collection(name)
+      end
+
+      def mongoid_new_collection(collection, name)
+        collection.db.collection(name)
+      end
+
+      def enum_mongoid_documents(collection)
+        collection.find({}, :timeout => false, :sort => "_id") do |cursor|
+          cursor.each do |doc|
+            yield doc
+          end
+        end
+      end
+
+      def rename_mongoid_collection(collection, new_name)
+        collection.rename(new_name)
+      end
+    else
+      # Mongoid 3+ API
+      def mongoid_collections
+        Mongoid.default_session.collections
+      end
+
+      def mongoid_collection(name)
+        Mongoid.default_session[name]
+      end
+
+      def mongoid_new_collection(collection, name)
+        Mongoid.default_session[name]
+      end
+
+      def enum_mongoid_documents(collection)
+        collection.find.sort(:_id => 1).each do |doc|
+          yield doc
+        end
+      end
+
+      def rename_mongoid_collection(collection, new_name)
+        db_name = collection.database.name
+        collection.database.session.with(:database => :admin) do |admin|
+          admin.command(
+            :renameCollection => "#{db_name}.#{collection.name}",
+            :to               => "#{db_name}.#{new_name}",
+            :dropTarget       => true)
+        end
+      end
+    end
+
+    desc 'Drops all the collections for the database for the current Tennpipes.env'
+    task :drop => :environment do
+      mongoid_collections.select {|c| c.name !~ /system/ }.each(&:drop)
+    end
+
+    # Helper to retrieve a list of models.
+    def get_mongoid_models
+      documents = []
+      Dir['{app,.}/models/**/*.rb'].sort.each do |file|
+        model_path = file[0..-4].split('/')[2..-1]
+
+        begin
+          klass = model_path.map(&:classify).join('::').constantize
+          if klass.ancestors.include?(Mongoid::Document) && !klass.embedded
+            documents << klass
+          end
+        rescue => e
+          # Just for non-mongoid objects that don't have the embedded
+          # attribute at the class level.
+        end
+      end
+
+      documents
+    end
+
+    desc 'Create the indexes defined on your mongoid models'
+    task :create_indexes => :environment do
+      get_mongoid_models.each(&:create_indexes)
+    end
+
+    def convert_ids(obj)
+      if obj.is_a?(String) && obj =~ /^[a-f0-9]{24}$/
+        defined?(Moped) ? Moped::BSON::ObjectId.from_string(obj) : BSON::ObjectId(obj)
+      elsif obj.is_a?(Array)
+        obj.map do |v|
+          convert_ids(v)
+        end
+      elsif obj.is_a?(Hash)
+        obj.each do |k, v|
+          obj[k] = convert_ids(v)
+        end
+      else
+        obj
+      end
+    end
+
+    def collection_names
+      @collection_names ||= get_mongoid_models.map{ |d| d.collection.name }.uniq
+    end
+
+    desc "Convert string objectids in mongo database to ObjectID type"
+    task :objectid_convert => :environment do
+      collection_names.each do |collection_name|
+        puts "Converting #{collection_name} to use ObjectIDs"
+
+        # Get old collection.
+        collection = mongoid_collection(collection_name)
+
+        # Get new collection (a clean one).
+        mongoid_collection("#{collection_name}_new").drop
+        new_collection = mongoid_new_collection(collection, "#{collection_name}_new")
+
+        # Convert collection documents.
+        enum_mongoid_documents(collection) do |doc|
+          new_doc = convert_ids(doc)
+          new_collection.insert(new_doc, :safe => true)
+        end
+
+        puts "Done! Converted collection is in #{new_collection.name}\n\n"
+      end
+
+      # No errors. great! now rename _new to collection_name.
+      collection_names.each do |collection_name|
+        collection = mongoid_collection(collection_name)
+        new_collection = mongoid_new_collection(collection, "#{collection_name}_new")
+
+        # Swap collection to _old.
+        puts "Moving #{collection.name} to #{collection_name}_old"
+        mongoid_new_collection(collection, "#{collection_name}_old").drop
+
+        begin
+          rename_mongoid_collection(collection, "#{collection_name}_old")
+        rescue StandardError => e
+          puts "Unable to rename database #{collection_name} to #{collection_name}_old"
+          puts "reason: #{e.message}\n\n"
+        end
+
+        # Swap _new to collection.
+        puts "Moving #{new_collection.name} to #{collection_name}\n\n"
+
+        begin
+          rename_mongoid_collection(new_collection, collection_name)
+        rescue StandardError => e
+          puts "Unable to rename database #{new_collection.name} to #{collection_name}"
+          puts "reason: #{e.message}\n\n"
+        end
+      end
+
+      puts "DONE! Run `tennpipes rake mi:cleanup_old_collections` to remove old collections"
+    end
+
+    desc "Clean up old collections backed up by objectid_convert"
+    task :cleanup_old_collections => :environment do
+      collection_names.each do |collection_name|
+        collection = mongoid_collection(collection_name)
+        mongoid_new_collection(collection, "#{collection.name}_old").drop
+      end
+    end
+
+    desc "Generates .yml files for I18n translations"
+    task :translate => :environment do
+      models = Dir["#{Tennpipes.root}/{app,}/models/**/*.rb"].map { |m| File.basename(m, ".rb") }
+
+      models.each do |m|
+        # Get the model class.
+        klass = m.camelize.constantize
+
+        # Avoid non Mongoid models.
+        next unless klass.ancestors.include?(Mongoid::Document)
+
+        # Init the processing.
+        print "Processing #{m.humanize}: "
+        FileUtils.mkdir_p("#{Tennpipes.root}/app/locale/models/#{m}")
+        langs = Array(I18n.locale)
+
+        # Create models for it and en locales.
+        langs.each do |lang|
+          filename   = "#{Tennpipes.root}/app/locale/models/#{m}/#{lang}.yml"
+          columns    = klass.fields.values.map(&:name).reject { |name| name =~ /id/i }
+          # If the lang file already exist we need to check it.
+          if File.exist?(filename)
+            locale = File.open(filename).read
+            columns.each do |c|
+              locale += "\n        #{c}: #{c.humanize}" unless locale.include?("#{c}:")
+            end
+            print "Lang #{lang.to_s.upcase} already exist ... "; $stdout.flush
+          else
+            locale     = "#{lang}:" + "\n" +
+            "  models:" + "\n" +
+            "    #{m}:" + "\n" +
+            "      name: #{klass.name}" + "\n" +
+            "      attributes:" + "\n" +
+            columns.map { |c| "        #{c}: #{c.humanize}" }.join("\n")
+            print "created a new for #{lang.to_s.upcase} Lang ... "; $stdout.flush
+          end
+          File.open(filename, "w") { |f| f.puts locale }
+        end
+        puts
+      end
+    end
+  end
+
+  task 'db:drop' => 'mi:drop'
+end

data/lib/tennpipes-init/tennpipes-tasks/mongomapper.rb

@@ -0,0 +1,55 @@
+if defined?(MongoMapper)
+  begin
+    require 'i18n'
+  rescue LoadError
+    # Only do this for I18n check later.
+  end
+
+  namespace :mm do
+    desc 'Drops all the collections for the database for the current Tennpipes.env'
+    task :drop => :environment do
+      MongoMapper.database.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+    end
+
+    desc "Generates .yml files for I18n translations"
+    task :translate => :environment do
+      models = Dir["#{Tennpipes.root}/{app,}/models/**/*.rb"].map { |m| File.basename(m, ".rb") }
+
+      models.each do |m|
+        # Get the model class.
+        klass = m.camelize.constantize
+
+        # Init the processing
+        print "Processing #{m.humanize}: "
+        FileUtils.mkdir_p("#{Tennpipes.root}/app/locale/models/#{m}")
+        langs = Array(I18n.locale)
+
+        # Create models for it and en locales.
+        langs.each do |lang|
+          filename   = "#{Tennpipes.root}/app/locale/models/#{m}/#{lang}.yml"
+          columns    = klass.keys.values.map(&:name).reject { |name| name =~ /id/i }
+          # If the lang file already exist we need to check it
+          if File.exist?(filename)
+            locale = File.open(filename).read
+            columns.each do |c|
+              locale += "\n        #{c}: #{c.humanize}" unless locale.include?("#{c}:")
+            end
+            print "Lang #{lang.to_s.upcase} already exist ... "; $stdout.flush
+          else
+            locale     = "#{lang}:" + "\n" +
+                         "  models:" + "\n" +
+                         "    #{m}:" + "\n" +
+                         "      name: #{klass.human_name}" + "\n" +
+                         "      attributes:" + "\n" +
+                         columns.map { |c| "        #{c}: #{c.humanize}" }.join("\n")
+            print "created a new for #{lang.to_s.upcase} Lang ... "; $stdout.flush
+          end
+          File.open(filename, "w") { |f| f.puts locale }
+        end
+        puts
+      end
+    end
+  end
+
+  task 'db:drop' => 'mm:drop'
+end

data/lib/tennpipes-init/tennpipes-tasks/sequel.rb

@@ -0,0 +1,85 @@
+if TennpipesTasks.load?(:sequel, defined?(Sequel))
+  namespace :sq do
+    namespace :migrate do
+      desc "Perform automigration (reset your db data)"
+      task :auto => :skeleton do
+        ::Sequel.extension :migration
+        ::Sequel::Migrator.run Sequel::Model.db, "db/migrate", :target => 0
+        ::Sequel::Migrator.run Sequel::Model.db, "db/migrate"
+        puts "<= sq:migrate:auto executed"
+      end
+
+      desc "Perform migration up/down to MIGRATION_VERSION"
+      task :to, [:version] => :skeleton do |t, args|
+        version = (args[:version] || env_migration_version).to_s.strip
+        ::Sequel.extension :migration
+        fail "No MIGRATION_VERSION was provided" if version.empty?
+        ::Sequel::Migrator.apply(Sequel::Model.db, "db/migrate", version.to_i)
+        puts "<= sq:migrate:to[#{version}] executed"
+      end
+
+      desc "Perform migration up to latest migration available"
+      task :up => :skeleton do
+        ::Sequel.extension :migration
+        ::Sequel::Migrator.run Sequel::Model.db, "db/migrate"
+        puts "<= sq:migrate:up executed"
+      end
+
+      desc "Perform migration down (erase all data)"
+      task :down => :skeleton do
+        ::Sequel.extension :migration
+        ::Sequel::Migrator.run Sequel::Model.db, "db/migrate", :target => 0
+        puts "<= sq:migrate:down executed"
+      end
+    end
+
+    desc "Perform migration up to latest migration available"
+    task :migrate => 'sq:migrate:up'
+
+    desc "Create the database"
+    task :create => :skeleton do
+      config = Sequel::Model.db.opts
+      user, password, host = config[:user], config[:password], config[:host]
+      database = config[:database]
+      charset = config[:charset] || ENV['CHARSET']   || 'utf8'
+      collation = config[:collation] || ENV['COLLATION'] || 'utf8_unicode_ci'
+
+      puts "=> Creating database '#{database}'"
+      if config[:adapter] == 'sqlite3'
+        ::Sequel.sqlite(database)
+      else
+        require 'tennpipes-init/tennpipes-tasks/sql-helpers'
+        Tennpipes::Generators::SqlHelpers.create_db(config[:adapter], user, password, host, database, charset, collation)
+      end
+      puts "<= sq:create executed"
+    end
+
+    desc "Drop the database (postgres and mysql only)"
+    task :drop => :skeleton do
+      config = ::Sequel::Model.db.opts
+      user, password, host, database = config[:user], config[:password], config[:host], config[:database]
+
+      ::Sequel::Model.db.disconnect
+
+      puts "=> Dropping database '#{database}'"
+      if config[:adapter] == 'sqlite3'
+        File.delete(database) if File.exist?(database)
+      else
+        Tennpipes::Generators::SqlHelpers.drop_db(config[:adapter], user, password, host, database)
+      end
+      puts "<= sq:drop executed"
+    end
+
+    desc 'Drop the database, migrate from scratch and initialize with the seed data'
+    task :reset => ['drop', 'create', 'migrate', 'seed']
+
+    task :seed => :environment do
+      missing_model_features = Tennpipes.send(:default_dependency_paths) - Tennpipes.send(:dependency_paths)
+      Tennpipes.require_dependencies(missing_model_features)
+      Rake::Task['db:seed'].invoke
+    end
+  end
+
+  task 'db:migrate' => 'sq:migrate'
+  task 'db:reset' => 'sq:reset'
+end