padrino-gen 0.16.0.pre4 → 0.16.0

data/lib/padrino-gen/padrino-tasks/activerecord.rb

@@ -1,3 +1,4 @@
+require 'English'
 if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
   # Fixes for Yardoc YRI Building
   begin
@@ -10,8 +11,8 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
 
   namespace :ar do
     namespace :create do
-      desc "Create all the local databases defined in config/database.yml"
-      task :all => :skeleton do
+      desc 'Create all the local databases defined in config/database.yml'
+      task all: :skeleton do
         with_all_databases do |config|
           # Skip entries that don't have a database key, such as the first entry here:
           #
@@ -31,67 +32,65 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
       end
     end
 
-    desc "Creates the database defined in config/database.yml for the current Padrino.env"
-    task :create => :skeleton do
+    desc 'Creates the database defined in config/database.yml for the current Padrino.env'
+    task create: :skeleton do
       with_database(Padrino.env) do |config|
         create_database(config)
       end
     end
 
     def create_database(config)
-      begin
-        if config[:adapter] =~ /sqlite/
-          if File.exist?(config[:database])
-            $stderr.puts "#{config[:database]} already exists."
-          else
-            begin
-              # Create the SQLite database
-              FileUtils.mkdir_p File.dirname(config[:database]) unless File.exist?(File.dirname(config[:database]))
-              ActiveRecord::Base.establish_connection(config)
-              ActiveRecord::Base.connection
-            rescue StandardError => e
-              catch_error(:create, e, config)
-            end
-          end
-          return # Skip the else clause of begin/rescue
+      if config[:adapter] =~ /sqlite/
+        if File.exist?(config[:database])
+          $stderr.puts "#{config[:database]} already exists."
         else
-          ActiveRecord::Base.establish_connection(config)
-          ActiveRecord::Base.connection
-        end
-      rescue
-        case config[:adapter]
-        when 'mysql', 'mysql2', 'em_mysql2', 'jdbcmysql'
-          @charset   = ENV['CHARSET']   || 'utf8'
-          @collation = ENV['COLLATION'] || 'utf8_unicode_ci'
-          creation_options = {:charset => (config[:charset] || @charset), :collation => (config[:collation] || @collation)}
           begin
-            ActiveRecord::Base.establish_connection(config.merge(:database => nil))
-            ActiveRecord::Base.connection.create_database(config[:database], creation_options)
-            ActiveRecord::Base.establish_connection(config)
-          rescue StandardError => e
-            $stderr.puts *(e.backtrace)
-            $stderr.puts e.inspect
-            $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{config[:charset] || @charset}, collation: #{config[:collation] || @collation}"
-            $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config[:charset]
-          end
-        when 'postgresql'
-          @encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
-          begin
-            ActiveRecord::Base.establish_connection(config.merge(:database => 'postgres', :schema_search_path => 'public'))
-            ActiveRecord::Base.connection.create_database(config[:database], config.merge(:encoding => @encoding))
+            # Create the SQLite database
+            FileUtils.mkdir_p File.dirname(config[:database]) unless File.exist?(File.dirname(config[:database]))
             ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::Base.connection
           rescue StandardError => e
             catch_error(:create, e, config)
           end
         end
+        return # Skip the else clause of begin/rescue
       else
-        $stderr.puts "#{config[:database]} already exists"
+        ActiveRecord::Base.establish_connection(config)
+        ActiveRecord::Base.connection
+      end
+    rescue StandardError
+      case config[:adapter]
+      when 'mysql', 'mysql2', 'em_mysql2', 'jdbcmysql'
+        @charset   = ENV['CHARSET']   || 'utf8'
+        @collation = ENV['COLLATION'] || 'utf8_unicode_ci'
+        creation_options = { charset: config[:charset] || @charset, collation: config[:collation] || @collation }
+        begin
+          ActiveRecord::Base.establish_connection(config.merge(database: nil))
+          ActiveRecord::Base.connection.create_database(config[:database], creation_options)
+          ActiveRecord::Base.establish_connection(config)
+        rescue StandardError => e
+          $stderr.puts(*e.backtrace)
+          $stderr.puts e.inspect
+          $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{config[:charset] || @charset}, collation: #{config[:collation] || @collation}"
+          $stderr.puts '(if you set the charset manually, make sure you have a matching collation)' if config[:charset]
+        end
+      when 'postgresql'
+        @encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
+        begin
+          ActiveRecord::Base.establish_connection(config.merge(database: 'postgres', schema_search_path: 'public'))
+          ActiveRecord::Base.connection.create_database(config[:database], config.merge(encoding: @encoding))
+          ActiveRecord::Base.establish_connection(config)
+        rescue StandardError => e
+          catch_error(:create, e, config)
+        end
       end
+    else
+      $stderr.puts "#{config[:database]} already exists"
     end
 
     namespace :drop do
-      desc "Drops all the local databases defined in config/database.yml"
-      task :all => :skeleton do
+      desc 'Drops all the local databases defined in config/database.yml'
+      task all: :skeleton do
         with_all_databases do |config|
           # Skip entries that don't have a database key
           next unless config[:database]
@@ -105,77 +104,70 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
       end
     end
 
-    desc "Drops the database for the current Padrino.env"
-    task :drop => :skeleton do
+    desc 'Drops the database for the current Padrino.env'
+    task drop: :skeleton do
       with_database(Padrino.env || :development) do |config|
-        begin
-          drop_database(config)
-        rescue StandardError => e
-          catch_error(:drop, e, config)
-        end
+        drop_database(config)
+      rescue StandardError => e
+        catch_error(:drop, e, config)
       end
     end
 
     def local_database?(config, &block)
-      if %w( 127.0.0.1 localhost ).include?(config[:host]) || !config[:host]
+      if %w[127.0.0.1 localhost].include?(config[:host]) || !config[:host]
         yield
       else
         puts "This task only modifies local databases. #{config[:database]} is on a remote host."
       end
     end
 
-    desc "Migrate the database through scripts in db/migrate and update db/schema.rb by invoking ar:schema:dump. Target specific version with MIGRATION_VERSION=x. Turn off output with VERBOSE=false."
-    task :migrate => :skeleton do
-      ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+    desc 'Migrate the database through scripts in db/migrate and update db/schema.rb by invoking ar:schema:dump. Target specific version with MIGRATION_VERSION=x. Turn off output with VERBOSE=false.'
+    task migrate: :skeleton do
+      ActiveRecord::Migration.verbose = ENV['VERBOSE'] ? ENV['VERBOSE'] == 'true' : true
 
       if less_than_active_record_5_2?
-        ActiveRecord::Migrator.migrate("db/migrate/", env_migration_version)
-      elsif less_than_active_record_6_0?
-        ActiveRecord::MigrationContext.new("db/migrate/").migrate(env_migration_version)
+        ActiveRecord::Migrator.migrate('db/migrate/', env_migration_version)
       else
-        ActiveRecord::MigrationContext.new("db/migrate/", ActiveRecord::SchemaMigration).migrate(env_migration_version)
+        migration_context.migrate(env_migration_version)
       end
 
-      if less_than_active_record_7_0?
-        Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
-      else
-        Rake::Task["ar:schema:dump"].invoke if ActiveRecord.schema_format == :ruby
-      end
+      format_source = ActiveRecord.respond_to?(:schema_format) ? ActiveRecord : ActiveRecord::Base
+      Rake::Task['ar:schema:dump'].invoke if format_source.schema_format == :ruby
     end
 
     namespace :migrate do
-      desc "Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with MIGRATION_VERSION=x."
-      task :redo => :skeleton do
+      desc 'Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with MIGRATION_VERSION=x.'
+      task redo: :skeleton do
         if env_migration_version
-          Rake::Task["ar:migrate:down"].invoke
-          Rake::Task["ar:migrate:up"].invoke
+          Rake::Task['ar:migrate:down'].invoke
+          Rake::Task['ar:migrate:up'].invoke
         else
-          Rake::Task["ar:rollback"].invoke
-          Rake::Task["ar:migrate"].invoke
+          Rake::Task['ar:rollback'].invoke
+          Rake::Task['ar:migrate'].invoke
         end
       end
 
-      desc "Resets your database using your migrations for the current environment."
-      task :reset => ["ar:drop", "ar:create", "ar:migrate"]
+      desc 'Resets your database using your migrations for the current environment.'
+      task reset: ['ar:drop', 'ar:create', 'ar:migrate']
 
       desc "Runs the 'up' for a given MIGRATION_VERSION."
-      task(:up => :skeleton){ migrate_as(:up) }
+      task(up: :skeleton) { migrate_as(:up) }
 
       desc "Runs the 'down' for a given MIGRATION_VERSION."
-      task(:down => :skeleton){ migrate_as(:down) }
+      task(down: :skeleton) { migrate_as(:down) }
     end
 
-    desc "Rolls the schema back to the previous version. Specify the number of steps with STEP=n"
-    task(:rollback => :skeleton){ move_as(:rollback) }
+    desc 'Rolls the schema back to the previous version. Specify the number of steps with STEP=n'
+    task(rollback: :skeleton) { move_as(:rollback) }
 
-    desc "Pushes the schema to the next version. Specify the number of steps with STEP=n"
-    task(:forward => :skeleton){ move_as(:forward) }
+    desc 'Pushes the schema to the next version. Specify the number of steps with STEP=n'
+    task(forward: :skeleton) { move_as(:forward) }
 
-    desc "Drops and recreates the database from db/schema.rb for the current environment and loads the seeds."
-    task :reset => [ 'ar:drop', 'ar:setup' ]
+    desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
+    task reset: ['ar:drop', 'ar:setup']
 
     desc "Retrieves the charset for the current environment's database"
-    task :charset => :skeleton do
+    task charset: :skeleton do
       with_database(Padrino.env || :development) do |config|
         case config[:adapter]
         when 'mysql', 'mysql2', 'em_mysql2', 'jdbcmysql'
@@ -191,7 +183,7 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
     end
 
     desc "Retrieves the collation for the current environment's database."
-    task :collation => :skeleton do
+    task collation: :skeleton do
       with_database(Padrino.env || :development) do |config|
         case config[:adapter]
         when 'mysql', 'mysql2', 'em_mysql2', 'jdbcmysql'
@@ -203,82 +195,78 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
       end
     end
 
-    desc "Retrieves the current schema version number."
-    task :version => :skeleton do
+    desc 'Retrieves the current schema version number.'
+    task version: :skeleton do
       puts "Current version: #{ActiveRecord::Migrator.current_version}"
     end
 
-    desc "Raises an error if there are pending migrations."
-    task :abort_if_pending_migrations => :skeleton do
+    desc 'Raises an error if there are pending migrations.'
+    task abort_if_pending_migrations: :skeleton do
       if defined? ActiveRecord
         pending_migrations =
           if less_than_active_record_5_2?
             ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations
-          elsif less_than_active_record_6_0?
-            ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).open.pending_migrations
           else
-            ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths, ActiveRecord::SchemaMigration).open.pending_migrations
+            migration_context.open.pending_migrations
           end
 
         if pending_migrations.any?
           puts "You have #{pending_migrations.size} pending migrations:"
           pending_migrations.each do |pending_migration|
-            puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+            puts format('  %4d %s', pending_migration.version, pending_migration.name)
           end
-          abort %{Run "rake ar:migrate" to update your database then try again.}
+          abort %(Run "rake ar:migrate" to update your database then try again.)
         end
       end
     end
 
-    desc "Create the database, load the schema, and initialize with the seed data."
-    task :setup => [ 'ar:create', 'ar:schema:load', 'seed' ]
+    desc 'Create the database, load the schema, and initialize with the seed data.'
+    task setup: ['ar:create', 'ar:schema:load', 'seed']
 
     namespace :schema do
-      desc "Create a db/schema.rb file that can be portably used against any DB supported by AR."
-      task :dump => :skeleton do
+      desc 'Create a db/schema.rb file that can be portably used against any DB supported by AR.'
+      task dump: :skeleton do
         require 'active_record/schema_dumper'
-        File.open(ENV['SCHEMA'] || Padrino.root("db", "schema.rb"), "w") do |file|
+        File.open(ENV['SCHEMA'] || Padrino.root('db', 'schema.rb'), 'w') do |file|
           ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
         end
-        Rake::Task["ar:schema:dump"].reenable
+        Rake::Task['ar:schema:dump'].reenable
       end
 
-      desc "Load a schema.rb file into the database."
-      task :load => :skeleton do
-        file = ENV['SCHEMA'] || Padrino.root("db", "schema.rb")
-        if File.exist?(file)
-          load(file)
-        else
-          raise %{#{file} doesn't exist yet. Run "rake ar:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Padrino.root}/config/boot.rb to limit the frameworks that will be loaded}
-        end
+      desc 'Load a schema.rb file into the database.'
+      task load: :skeleton do
+        file = ENV['SCHEMA'] || Padrino.root('db', 'schema.rb')
+        File.exist?(file) ? load(file) : raise(<<~MESSAGE.gsub("\n", ' '))
+          #{file} doesn't exist yet. Run "rake ar:migrate" to create it then try again.
+          If you do not intend to use a database, you should instead alter #{Padrino.root}/config/boot.rb to limit the frameworks that will be loaded
+        MESSAGE
       end
     end
 
     namespace :structure do
-      desc "Dump the database structure to a SQL file."
-      task :dump => :skeleton do
+      desc 'Dump the database structure to a SQL file.'
+      task dump: :skeleton do
         with_database(Padrino.env) do |config|
           case config[:adapter]
-          when "mysql", "mysql2", 'em_mysql2', "oci", "oracle", 'jdbcmysql'
-            config = config.inject({}){|result, (key, value)| result[key.to_s] = value; result }
-            ActiveRecord::Tasks::DatabaseTasks.structure_dump(config, resolve_structure_sql)
-          when "postgresql"
+          when 'mysql', 'mysql2', 'em_mysql2', 'oci', 'oracle', 'jdbcmysql'
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump(config.transform_keys(&:to_s), resolve_structure_sql)
+          when 'postgresql'
             ENV['PGHOST']     = config[:host] if config[:host]
             ENV['PGPORT']     = config[:port].to_s if config[:port]
             ENV['PGPASSWORD'] = config[:password].to_s if config[:password]
+
             search_path = config[:schema_search_path]
-            if search_path
-              search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
-            end
+            search_path = search_path.split(',').map { |path| "--schema=#{path.strip}" }.join(' ') if search_path
+
             `pg_dump -U "#{config[:username]}" -s -x -O -f db/#{Padrino.env}_structure.sql #{search_path} #{config[:database]}`
-            raise "Error dumping database" if $?.exitstatus == 1
-          when "sqlite", "sqlite3"
+            raise 'Error dumping database' if $CHILD_STATUS.exitstatus == 1
+          when 'sqlite', 'sqlite3'
             dbfile = config[:database] || config[:dbfile]
             `#{config[:adapter]} #{dbfile} .schema > db/#{Padrino.env}_structure.sql`
-          when "sqlserver"
+          when 'sqlserver'
             `scptxfr /s #{config[:host]} /d #{config[:database]} /I /f db\\#{Padrino.env}_structure.sql /q /A /r`
             `scptxfr /s #{config[:host]} /d #{config[:database]} /I /F db\ /q /A /r`
-          when "firebird"
+          when 'firebird'
             set_firebird_env(config)
             db_string = firebird_db_string(config)
             sh "isql -a #{db_string} > #{Padrino.root}/db/#{Padrino.env}_structure.sql"
@@ -288,14 +276,14 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
         end
 
         if !ActiveRecord::Base.connection.respond_to?(:supports_migrations?) || ActiveRecord::Base.connection.supports_migrations?
-          File.open(resolve_structure_sql, "a"){|f| f << ActiveRecord::Base.connection.dump_schema_information }
+          File.open(resolve_structure_sql, 'a') { |f| f << ActiveRecord::Base.connection.dump_schema_information }
         end
       end
     end
 
-    desc "Generates .yml files for I18n translations."
-    task :translate => :environment do
-      models = Dir["#{Padrino.root}/{app,}/models/**/*.rb"].map { |m| File.basename(m, ".rb") }
+    desc 'Generates .yml files for I18n translations.'
+    task translate: :environment do
+      models = Dir["#{Padrino.root}/{app,}/models/**/*.rb"].map { |m| File.basename(m, '.rb') }
 
       models.each do |m|
         # get the model class
@@ -319,23 +307,27 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
             columns.each do |c|
               locale += "\n        #{c}: #{klass.human_attribute_name(c)}" 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.model_name.human}" + "\n" +
-                         "      attributes:" + "\n" +
-                         columns.map { |c| "        #{c}: #{klass.human_attribute_name(c)}" }.join("\n")
-            print "created a new for #{lang.to_s.upcase} Lang ... "; $stdout.flush
+            locale = <<~YAML
+              #{lang}:
+                models:
+                  #{m}:
+                    name: #{klass.model_name.human}
+                    attributes:
+            YAML
+
+            columns.each { |c| locale += "        #{c}: #{klass.human_attribute_name(c)}\n" }
+            locale.chomp!
           end
-          File.open(filename, "w") { |f| f.puts locale }
+
+          $stdout.flush
+          File.open(filename, 'w') { |f| f.puts locale }
         end
         puts
       end
     end
 
-    task :seed => :environment do
+    task seed: :environment do
       missing_model_features = Padrino.send(:default_dependency_paths) - Padrino.send(:dependency_paths)
       Padrino.require_dependencies(missing_model_features)
       Rake::Task['db:seed'].invoke
@@ -354,14 +346,14 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
 
       FileUtils.rm(file)
     when 'postgresql'
-      ActiveRecord::Base.establish_connection(config.merge(:database => 'postgres', :schema_search_path => 'public'))
+      ActiveRecord::Base.establish_connection(config.merge(database: 'postgres', schema_search_path: 'public'))
       ActiveRecord::Base.connection.drop_database config[:database]
     end
   end
 
   def set_firebird_env(config)
-    ENV["ISC_USER"]     = config[:username].to_s if config[:username]
-    ENV["ISC_PASSWORD"] = config[:password].to_s if config[:password]
+    ENV['ISC_USER']     = config[:username].to_s if config[:username]
+    ENV['ISC_PASSWORD'] = config[:password].to_s if config[:password]
   end
 
   def firebird_db_string(config)
@@ -369,7 +361,7 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
   end
 
   def catch_error(type, error, config)
-    $stderr.puts *(error.backtrace)
+    $stderr.puts(*error.backtrace)
     $stderr.puts error.inspect
     case type
     when :create
@@ -381,14 +373,12 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
 
   def migrate_as(type)
     version = env_migration_version
-    fail "MIGRATION_VERSION is required" unless version
+    raise 'MIGRATION_VERSION is required' unless version
 
     if less_than_active_record_5_2?
-      ActiveRecord::Migrator.run(type, "db/migrate/", version)
-    elsif less_than_active_record_6_0?
-      ActiveRecord::MigrationContext.new('db/migrate/').run(type, version)
+      ActiveRecord::Migrator.run(type, 'db/migrate/', version)
     else
-      ActiveRecord::MigrationContext.new('db/migrate/', ActiveRecord::SchemaMigration).run(type, version)
+      migration_context.run(type, version)
     end
 
     dump_schema
@@ -399,17 +389,15 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
 
     if less_than_active_record_5_2?
       ActiveRecord::Migrator.send(type, 'db/migrate/', step)
-    elsif less_than_active_record_6_0?
-      ActiveRecord::MigrationContext.new('db/migrate/').send(type, step)
     else
-      ActiveRecord::MigrationContext.new('db/migrate/', ActiveRecord::SchemaMigration).send(type, step)
+      migration_context.send(type, step)
     end
 
     dump_schema
   end
 
   def dump_schema
-    Rake::Task["ar:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    Rake::Task['ar:schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   def resolve_structure_sql
@@ -417,19 +405,25 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
   end
 
   def less_than_active_record_5_2?
-    ActiveRecord.version < Gem::Version.create("5.2.0")
+    ActiveRecord.version < Gem::Version.create('5.2.0')
   end
 
   def less_than_active_record_6_0?
-    ActiveRecord.version < Gem::Version.create("6.0.0")
+    ActiveRecord.version < Gem::Version.create('6.0.0')
   end
 
   def less_than_active_record_6_1?
-    ActiveRecord.version < Gem::Version.create("6.1.0")
+    ActiveRecord.version < Gem::Version.create('6.1.0')
   end
 
-  def less_than_active_record_7_0?
-    ActiveRecord.version < Gem::Version.create("7.0.0")
+  def migration_context
+    if less_than_active_record_6_0?
+      ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths)
+    else
+      connection = ActiveRecord::Base.connection
+      connection = connection.pool unless connection.respond_to?(:migration_context)
+      connection.migration_context
+    end
   end
 
   def with_database(env_name)
@@ -446,14 +440,12 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
     end
   end
 
-  def with_all_databases
+  def with_all_databases(&block)
     if less_than_active_record_6_0?
-      ActiveRecord::Base.configurations.each_value do |config|
-        yield config
-      end
+      ActiveRecord::Base.configurations.each_value(&block)
     else
       ActiveRecord::Base.configurations.configs_for.each do |db_config|
-        yield configuration_hash(db_config)
+        block.call(configuration_hash(db_config))
       end
     end
   end
@@ -465,8 +457,8 @@ if PadrinoTasks.load?(:activerecord, defined?(ActiveRecord))
   end
 
   task 'db:migrate' => 'ar:migrate'
-  task 'db:create'  => 'ar:create'
-  task 'db:drop'    => 'ar:drop'
-  task 'db:reset'   => 'ar:reset'
-  task 'db:setup'   => 'ar:setup'
+  task 'db:create' => 'ar:create'
+  task 'db:drop' => 'ar:drop'
+  task 'db:reset' => 'ar:reset'
+  task 'db:setup' => 'ar:setup'
 end

data/lib/padrino-gen/padrino-tasks/database.rb

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