Veerasundaravel's Ruby on Rails Weblog

October 7, 2010

Useful Rails Commands – Cheatsheet

Filed under: Ruby On Rails — Tags: , , , , , , , — Veerasundaravel @ 3:08 pm

These are the commands,  we ROR folks use often in development. Please refer and let me know if there is any missing.

rails ApplicationName – Create a new application
ruby script/generate model ModelName – Creates a model with the specified model_name
ruby script/generate controller ControllerName – Creates a controller with the specified controller_name
ruby script/generate migration MigrationName – Creates a migration with the specified migration_name
ruby script/generate scaffold ModelName ControllerName – A shortcut for creating your controller, model and view files etc.
ruby script/destroy controller ControllerName – Destroys the created controller and its related file. Same way you can destroy your model, migration files etc.
ruby script/server – start ruby server at http://localhost:3000
ruby script/plugin install PluginName – Installs the specified plugin.
ruby script/console – Opens the rails console for the current RAILS_ENV
ruby script/dbconsole – Opens the DB console for the current RAILS_ENV
ruby script/performance – For benchmarkering and profiling your application.

rake –tasks – Lists all available rake tasks
rake db:create – Create the database defined in config/database.yml for the current RAILS_ENV
rake db:drop – Drops the database for the current RAILS_ENV
rake db:migrate – Migrate the database through scripts in db/migrate folder.
rake db:reset – Drops and recreates the database from db/schema.rb for the current environment.
rake db:schema:dump – Create a db/schema.rb file that can be portably used against any DB supported by AR
rake doc:app – Build the RDOC HTML Files
rake db:sessions:create – Creates a sessions migration for use with CGI::Session::ActiveRecordStore
rake gems – List the gems that this rails application depends on
rake gems:install – Installs all required gems for this application.
rake log:clear – Truncates all *.log files in log/ to zero bytes
rake rails:freeze:gems – Lock this application to the current gems (by unpacking them into vendor/rails)
rake routes – Print out all defined routes in match order, with names.
rake test – Run all unit, functional and integration tests
rake test:functionals – Run tests for functionalsdb:test:prepare / Run the functional tests in test/functional
rake test:integration – Run tests for integrationdb:test:prepare / Run the integration tests in test/integration
rake test:units – Run tests for unitsdb:test:prepare / Run the unit tests in test/unit
rake tmp:clear – Clear session, cache, and socket files from tmp/

gem list – Lists all the installed gems.
gem install GemName – Installs the specified gem in to your machine.
gem uninstall GemName – Uninstalls the specified gem from your machine.
gem server – present a web page at http://localhost:8808/ with info about installed gems.

Alos refer:

Useful Rails3 Commands & Cheatsheet
Useful SVN and Git commands – Cheatsheet

October 4, 2010

Jekyll – Ruby gem for static site generation

Filed under: Gems — Tags: , , , , — Veerasundaravel @ 12:09 pm

Jekyll is a simple, blog aware, static site generator. It takes a template directory (representing the raw form of a website), runs it through Textile or Markdown and Liquid converters, and spits out a complete, static website suitable for serving with Apache or your favorite web server. This is also the engine behind GitHub Pages, which you can use to host your project’s page or blog right here from GitHub.

Usage

Creating a Jekyll site usually involves the following, once jekyll is installed.

  1. Set up the basic structure of the site
  2. Create some posts, or import them from your previous platform
  3. Run your site locally to see how it looks
  4. Deploy your site

Basic Structure

Jekyll at its core is a text transformation engine. The concept behind the system is this: you give it text written in your favorite markup language, be that Markdown, Textile, or just plain HTML, and it churns that through a layout or series of layout files. Throughout that process you can tweak how you want the site URLs to look, what data gets displayed on the layout and more. This is all done through strictly editing files, and the web interface is the final product.

A basic Jekyll site usually looks something like this:

.
|-- _config.yml
|-- _layouts
|   |-- default.html
|   `-- post.html
|-- _posts
|   |-- 2007-10-29-why-every-programmer-should-play-nethack.textile
|   `-- 2009-04-26-barcamp-boston-4-roundup.textile
|-- _site
`-- index.html

An overview of what each of these does:

_config.yml

Stores configuration data. A majority of these options can be specified from the command line exectuable but it’s easier to throw them in here so you don’t have to remember them.

_layouts

These are the templates which posts are inserted into. Layouts are defined on a post-by-post basis in the YAML front matter, which is described in the next section. The liquid tag {{ content }} is used to inject data onto the page.

_posts

Your dynamic content, so to speak. The format of these files is important, as named as YEAR-MONTH-DATE-title.MARKUP. The Permalinks can be adjusted very flexibly for each post, but the date and markup language are determined solely by the file name.

_site

This is where the generated site will be placed once Jekyll is done transforming it. It’s probably a good idea to add this to your .gitignore file.

index.html

Granted that this file has a YAML Front Matter section, it will be transformed by Jekyll. The same will happen for any .html, .markdown, or .textile file in your site’s root directory.

Other Files/Folders

Every other directory and file except for those listed above will be transferred over as expected. For example, you could have a css folder, a favicon.ico, etc, etc. There’s plenty of sites already using Jekyll if you’re curious as to how they’re laid out.

Any files in these directories will be parsed and transformed, according to the same rules mentioned previously for files in the root directory.

Running Jekyll

Usually this is done through the jekyll executable, which is installed with the gem. In order to get a server up and running with your Jekyll site, run:

jekyll --server

and then browse to http://0.0.0.0:4000. There’s plenty of configuration options available to you as well.

On Ubuntu, you may need to add /var/lib/gems/1.8/bin/ to your path.

Deployment

Since Jekyll simply generates a folder filled with HTML files, it can be served using practically any available web server out there.

September 22, 2010

Bundler: Best way to manage your Gems

Bundler Gem

As the name itself will specify the purpose of it. Bundler gem is used to bundle all of your required ruby gems.

The bundler allows the specification of all dependencies in a separate place from the application itself. You can specify the required version of gems and its entire set of dependencies.
So while deploying your application in a server no need to install the gem from Rubyforge or RubyGems.org etc.

Steps to follow:

1. At the root of your application, run gem install bundler

2. Create a Gemfile in the root of your application

3. Add dependencies to your Gemfile. like gem “rspec”, 1.2.3

4. At the root, run bundle install. It will install all the gems which you specified in Gemfile from the remote system. And it will create a file called Gemfile.lock. The purpose of Gemfile.lock is to get the list of gems installed and its dependencies in your app.

5. And now run bundle package. It will make a copy of your installed gems into your application path vendor/cache. It will more helpful when you are deploying your app in any other server. Cos after running bundle package, your application will look gems into vendor/cache instead of remote systems.

For more details:

http://gembundler.com/
http://gembundler.com/rails23.html
http://yehudakatz.com/2009/11/03/using-the-new-gem-bundler-today

Older Posts »

%d bloggers like this: