Features

Rake Tasks

A generated Padrino project has a Rakefile that loads Padrino's tasks, so you can run them with padrino rake or bundle exec rake:

# for a list of tasks
$ padrino rake -T

If you need custom tasks you can add those to:

your_project_/**lib/tasks**
your_project_/**tasks**
your_project_/**test**
your_project_/**spec**

Padrino loads every *.rake file in lib/tasks and tasks (including their subdirectories) and in test and spec.

Padrino by default has some useful tasks.

Basic

Like other frameworks we have an :environment task that loads our environment and apps. Example:

# This is a custom task
# tasks/version.rake
task version: :environment do
  puts Padrino.version
end

Routes

We have support for retrieving a list of named routes within your application for easy access.

$ padrino rake routes

which will return all the named routes for your project:

Application: SampleBlogUpdated::Admin
    URL                           REQUEST  PATH
    (:sessions, :new)               GET    /admin/sessions/new
    (:sessions, :create)           POST    /admin/sessions/create
    (:sessions, :destroy)         DELETE   /admin/sessions/destroy
    (:base, :index)                 GET    /admin/
    (:accounts, :index)             GET    /admin/accounts
    (:accounts, :new)               GET    /admin/accounts/new
    (:accounts, :create)           POST    /admin/accounts/create
    (:accounts, :edit)              GET    /admin/accounts/edit/:id
    (:accounts, :update)            PUT    /admin/accounts/update/:id
    (:accounts, :destroy)         DELETE   /admin/accounts/destroy/:id
    (:accounts, :destroy_many)    DELETE   /admin/accounts/destroy_many
    (:posts, :index)                GET    /admin/posts
    (:posts, :new)                  GET    /admin/posts/new
    (:posts, :create)              POST    /admin/posts/create
    (:posts, :edit)                 GET    /admin/posts/edit/:id
    (:posts, :update)               PUT    /admin/posts/update/:id
    (:posts, :destroy)            DELETE   /admin/posts/destroy/:id
    (:posts, :destroy_many)       DELETE   /admin/posts/destroy_many

Application: SampleBlogUpdated::App
    URL                 REQUEST  PATH
    (:about)              GET    /about_us
    (:posts, :index)      GET    /posts(.:format)?
    (:posts, :show)       GET    /posts/show/:id

Testing

When testing with Padrino you have a built-in padrino rake test or for rspec padrino rake spec.

$ padrino rake test # => for bacon, shoulda
$ padrino rake spec # => for rspec

you can customize test/test.rake or spec/spec.rake

I18n

You can auto generate a yml file for localizing your models using this command (mi:translate with Mongoid):

$ padrino rake ar:translate

See Localization for detailed instructions.

ORM

Padrino has rake tasks for ActiveRecord, Sequel, and Mongoid with some bonuses.

NOTE: we have a namespace for each orm, because of this, Padrino can mount several applications and each of them can use different orms without conflict, so that you can have multiple applications living together and one of them can use ActiveRecord, while another uses Sequel or Mongoid instead. In this way we prevent collisions.

ActiveRecord Tasks

rake ar:abort_if_pending_migrations # Raises an error if there are pending migrations
rake ar:charset                     # Retrieves the charset for the current environment's database
rake ar:collation                   # Retrieves the collation for the current environment's database
rake ar:create                      # Creates the database defined in config/database.yml for the current Padrino.env
rake ar:create:all                  # Create all the local databases defined in config/database.yml
rake ar:drop                        # Drops the database for the current Padrino.env
rake ar:drop:all                    # Drops all the local databases defined in config/database.yml
rake ar:dump                        # Dump the database data to a SQL file (FILE=path, default tmp/<env>_dump.sql)
rake ar:forward                     # Pushes the schema to the next version
rake ar:migrate                     # Migrate the database through scripts in db/migrate and update db/schema.rb by invoking ar:schema:dump
rake ar:migrate:down                # Runs the 'down' for a given MIGRATION_VERSION
rake ar:migrate:redo                # Rollbacks the database one migration and re migrate up
rake ar:migrate:reset               # Resets your database using your migrations for the current environment
rake ar:migrate:up                  # Runs the 'up' for a given MIGRATION_VERSION
rake ar:reset                       # Drops and recreates the database from db/schema.rb for the current environment and loads the seeds
rake ar:rollback                    # Rolls the schema back to the previous version
rake ar:schema:dump                 # Create a db/schema.rb file that can be portably used against any DB supported by AR
rake ar:schema:load                 # Load a schema.rb file into the database
rake ar:setup                       # Create the database, load the schema, and initialize with the seed data
rake ar:structure:dump              # Dump the database structure to a SQL file
rake ar:translate                   # Generates .yml files for I18n translations
rake ar:version                     # Retrieves the current schema version number

Sequel Tasks

rake sq:create              # Create the database
rake sq:drop                # Drop the database
rake sq:dump                # Dump the database data to a SQL file (FILE=path, default tmp/<env>_dump.sql)
rake sq:migrate             # Perform migration up to latest migration available
rake sq:migrate:auto        # Perform automigration (reset your db data)
rake sq:migrate:down        # Perform migration down (erase all data)
rake sq:migrate:to[version] # Perform migration up/down to MIGRATION_VERSION
rake sq:migrate:up          # Perform migration up to latest migration available
rake sq:reset               # Drop the database, migrate from scratch and initialize with the seed data

sq:create and sq:drop work with Postgres, MySQL and SQLite. For Postgres and MySQL they connect to the database server with your app's connection settings and run CREATE DATABASE or DROP DATABASE, so they don't need createdb, dropdb or the mysql client installed, and they work when the server runs in a container. sq:create does nothing when the database already exists.

To create a database that doesn't exist yet, your app must boot without connecting to it. Projects generated with -d sequel pass test: false to Sequel.connect in config/database.rb for this. In an older project, add it yourself:

Sequel.connect('postgres://localhost/blog_development', loggers: [logger], test: false)

Mongoid Tasks

rake mi:cleanup_old_collections # Clean up old collections backed up by objectid_convert
rake mi:create_indexes          # Create the indexes defined on your mongoid models
rake mi:drop                    # Drops all the collections for the database for the current Padrino.env
rake mi:objectid_convert        # Convert string objectids in mongo database to ObjectID type
rake mi:translate               # Generates .yml files for I18n translations

Dumping Data

db:dump (ar:dump with ActiveRecord, sq:dump with Sequel) writes the schema and data of the current Padrino.env database to tmp/<env>_dump.sql, using the database's own tool: pg_dump for Postgres, mysqldump for MySQL and sqlite3 for SQLite. That tool must be on your PATH. When the database server runs in a container, run the tool inside the container instead.

$ padrino rake db:dump                      # => tmp/development_dump.sql
$ padrino rake db:dump -e production        # => tmp/production_dump.sql
$ padrino rake db:dump FILE=backups/blog.sql

Generated projects ignore tmp/ in .gitignore, so a dump is not committed by accident. The password reaches the tool through PGPASSWORD or MYSQL_PWD, not the command line. A dump that fails leaves no partial file and keeps an earlier dump at the same path. When an ActiveRecord environment has several databases, each one goes to tmp/<env>_<name>_dump.sql, and FILE= is refused. Mongoid projects have no dump task yet.

Seed

Like in Rails we can populate our db using db/seeds.rb here's an example (from our padrino-admin):

email     = shell.ask 'Which email do you want use for logging into admin?'
password  = shell.ask 'Tell me the password to use:'

shell.say ''

account = Account.create(email: email, password: password,
                         password_confirmation: password, role: 'admin')

if account.valid?
  shell.say 'Perfect! Your account was created.'
  shell.say ''
  shell.say 'Now you can start your server with padrino start and then login into /admin with:'
  shell.say "   email: #{email}"
  shell.say "   password: #{password}"
  shell.say ''
  shell.say "That's all!"
else
  shell.say 'Sorry but some thing went wrong!'
  shell.say ''
  account.errors.full_messages.each { |m| shell.say "   - #{m}" }
end