Courtesy of InVisible, here is an exhaustive Ruby on Rails 1.1 Cheat Sheet. I’ve added a copy of it here so I know where to find it: Rails 1.1 Cheat Sheet. There is also a PDF version available.
It covers everything from the basics, generators, scaffolds, models, controllers, views (including AJAX), and configuration.
Check it out!
$ rails app_name
Options:
vendor/rails directory$ gem_server
Open a web browser with the address localhost:8088
is the make of ruby – the R uby m AKE. Rails defines a number of tasks to help you:
rake db:fixtures:load # Load fixtures into the current environment’s database.
# Load specific fixtures using FIXTURES=x,y
rake db:migrate # Migrate the database through scripts in db/migrate. Target
# specific version with VERSION=x
rake db:schema:dump # Create a db/schema.rb file that can be portably used against
# any DB supported by AR
rake db:schema:load # Load a schema.rb file into the database
rake db:sessions:clear # Clear the sessions table
rake db:sessions:create # Creates a sessions table for use with
# CGI::Session::ActiveRecordStore
rake db:structure:dump # Dump the database structure to a SQL file
rake db:test:clone # Recreate the test database from the current environment’s
# database schema
rake db:test:clone_structure # Recreate the test databases from the development structure
rake db:test:prepare # Prepare the test database and load the schema
rake db:test:purge # Empty the test database
rake doc:app # Build the app HTML Files
rake doc:clobber_app # Remove rdoc products
rake doc:clobber_plugins # Remove plugin documentation
rake doc:clobber_rails # Remove rdoc products
rake doc:plugins # Generate documation for all installed plugins
rake doc:rails # Build the rails HTML Files
rake doc:reapp # Force a rebuild of the RDOC files
rake doc:rerails # Force a rebuild of the RDOC files
rake log:clear # Truncates all *.log files in log/ to zero bytes
rake rails:freeze:edge # Lock this application to latest Edge Rails. Lock a specific
# revision with REVISION=X
rake rails:freeze:gems # Lock this application to the current gems (by unpacking them
# into vendor/rails)
rake rails:unfreeze # Unlock this application from freeze of gems or edge and return
# to a fluid use of system gems
rake rails:update # Update both scripts and public/javascripts from Rails
rake rails:update:javascripts # Update your javascripts from your current rails install
rake rails:update:scripts # Add new scripts to the application script/ directory
rake stats # Report code statistics (KLOCs, etc) from the application
rake test # Test all units and functionals
rake test:functionals # Run tests for functionalsdb:test:prepare
rake test:integration # Run tests for integrationdb:test:prepare
rake test:plugins # Run tests for pluginsenvironment
rake test:recent # Run tests for recentdb:test:prepare
rake test:uncommitted # Run tests for uncommitteddb:test:prepare
rake test:units # Run tests for unitsdb:test:prepare
rake tmp:cache:clear # Clears all files and directories in tmp/cache
rake tmp:clear # Clear session, cache, and socket files from tmp/
rake tmp:create # Creates tmp directories for sessions, cache, and sockets
rake tmp:sessions:clear # Clears all files in tmp/sessions
rake tmp:sockets:clear # Clears all ruby_sess.* files in tmp/sessions
script/about # Information about environenment
script/breakpointer # starts the breakpoint server
script/console # interactive Rails Console
script/destroy # deletes files created by generators
script/generate # -> generators
script/plugin # -> Plugins
script/runner # executes a task in the rails context
script/server # launches the development server
# http://localhost:3000
script/performance/profiler # profile an expenive method
script/performance/benchmarker # benchmark different methods
script/process/reaper
script/process/spawner
ruby script/generate model ModellName
ruby script/generate controller ListController show edit
ruby script/generate scaffold ModelName ControllerName
ruby script/generate migration AddNewTable
ruby script/generate plugin PluginName
ruby script/generate mailer Notification lost_password signup
ruby script/generate web_service ServiceName api_one api_two
ruby script/generate integration_test TestName
ruby script/generate session_migration
Options
-p, –pretend Run but do not make any changes.
-f, –force Overwrite files that already exist.
-s, –skip Skip files that already exist.
-q, –quiet Suppress normal output.
-t, –backtrace Debugging: show backtrace on errors.
-h, –help Show this help message.
-c, –svn Modify files with subversion. (Note: svn must be in path)
script/plugin discover # discover plugin repositories
script/plugin list # list all available plugins
script/plugin install where # install the „where“ plugin
script/plugin install -x where # install where plugin as SVN external
script/plugin install http://invisible.ch/projects/plugins/where
script/plugin update # update installed plugins
script/plugin source # add a source repository
script/plugin unsource # removes a source repository
script/plugin sources # lists source repositories
A searchable directory of plugins can be found at AgileDevelopment.
There are four ways of associating models. has_one, has_many, belongs_to and has_and_belongs_to_many
def Order < ActiveRecord::Base
has_many :line_items
belongs_to :customer # there's a column "customer_id" in the db table
end
def LineItem < ActiveRecord::Base
belongs_to :order # there's a column "order_id" in the db table
end
def Customer < ActiveRecord::Base
has_many :orders
has_one :address
end
def Address < ActiveRecord::Base
belongs_to :customer
end
belongs_to :some_model,
:class_name => ‘MyClass’, # specifies other class name
:foreign_key => ‘my_real_id’, # and primary key
:conditions => ‘column = 0’ # only finds when this condition met
has_one :some_model,
# as belongs_to and additionally:
:dependent => :destroy # deletes associated object
:order => ‘name ASC’ # SQL fragment for sorting
has_many :some_model
# as has_one and additionally:
:dependent => :destroy # deletes all dependent data
# calling each objects destroy
:dependent => :delete_all # deletes all dependent data
# without calling the destroy methods
:dependent => :nullify # set association to null, not
# destroying objects
:group => ‘name’ # adds GROUP BY fragment
:finder_sql => ‘select ….’ # instead of the Rails finders
:counter_sql => ‘select …’ # instead of the Rails counters
def Category < ActiveRecord::Base
has_and_belongs_to_many :products
end
def Product < ActiveRecord::Base
has_and_belongs_to_many :categories
end
Table categories_products with category_id and product_id (without id column)
class Author < ActiveRecord::Base
has_many :authorships
has_many :books, :through => :authorships
end
class Authorship < ActiveRecord::Base
belongs_to :author
belongs_to :book
end
class Book < ActiveRecord::Base
has_one :authorship
end
@author = Author.find :first
@author.authorships.collect { |a| a.book } # selects all books that the author's
# authorships belong to.
@author.books # selects all books by using the Authorship
# join model
Also works through has_many associations:
class Firm < ActiveRecord::Base
has_many :clients
has_many :invoices, :through => :clients
has_many :paid_invoices, :through => :clients, :source => :invoice
end
class Client < ActiveRecord::Base
belongs_to :firm
has_many :invoices
end
class Invoice < ActiveRecord::Base
belongs_to :client
end
@firm = Firm.find :first
@firm.clients.collect { |c| c.invoices }.flatten # select all invoices for all clients
# of the firm
@firm.invoices # selects all invoices by going through
# the Client join model.
validates_presence_of :firstname, :lastname # must be filled out
validates_length_of :password,
:minimum => 8 # more than 8 characters
:maximum => 16 # shorter than 16 characters
:in => 8..16 # between 8 and 16 characters
:too_short => ‘way too short’
:too_long => ‘way to long’
validates_acceptance_of :eula # Must accept a condition
:accept => ‘Y’ # default: 1 (ideal for a checkbox)
validates_confirmation_of :password
# the fields password and password_confirmation must match
validates_uniqueness_of :user_name # user_name has to be unique
:scope => ‘account_id’ # Condition:
# account_id = user.account_id
validates_format_of :email # field must match a regular expression
:with => /^([^@\s]+)@((?:[-a-z0-9]+.)+[a-z]{2,})$/i
validates_numericality_of :value # value is numeric
:only_integer => true
:allow_nil => true
validates_inclusion_in :gender, # value is in enumeration
:in => %w( m, f )
validates_exclusion_of :age # value is not in Enumeration
:in => 13..19 # don’t want any teenagers
validates_associated :relation
# validates that the associated object is valid
Options for all validations above:
:message => ‘my own errormessage’ # eigene Fehlermeldung
:on => :create # or :update (validates only then)
:if => … # call method oder Proc
Person.average :age
Person.minimum :age
Person.maximum :age
Person.sum :salary, :group => :last_name
find(42) # object with ID 42
find([37, 42]) # Array with the objects with id 37, 42
find :all
find :first,
:conditions => [ “name = ?”, “Hans” ] # finds the first record with
# the matching condition
more parameters for find:
:order => ‘name DESC’ # sql fragment for sorting
:offset => 20 # starts with entry 20
:limit => 10 # only return 10 objects
:group => ‘name’ # sql fragment GROUP BY
:joins => ‘LEFT JOIN …’ # additional LEFT JOIN (rarely used)
:include => [:account, :friends] # LEFT OUTER JOIN with these model
:include => { :groups => { :members=> { :favorites } } }
:select => [:name, :adress] # instead of SELECT * FROM
:readonly => true # objects are write protected
Developer.with_scope(:find => { :conditions => “salary > 10000”, :limit => 10 }) do
Developer.find(:all) # => SELECT * FROM developers WHERE (salary > 10000) LIMIT 10
# inner rule is used. (all previous parameters are ignored)
Developer.with_exclusive_scope(:find => { :conditions => “name = ‘Jamis’” }) do
Developer.find(:all) # => SELECT * FROM developers WHERE (name = ‘Jamis’)
end
# parameters are merged
Developer.with_scope(:find => { :conditions => “name = ‘Jamis’” }) do
Developer.find(:all) # => SELECT * FROM developers WHERE
# (( salary > 10000 ) AND ( name = ‘Jamis’ )) LIMIT 10
end
end
for more details and examples, see:
During the life cycle of an active record object, you can hook into 9 events:
Examples:
class Subscription < ActiveRecord::Base
before_create :record_signup
private
def record_signup
self.signed_up_on = Date.today
end
end
class Firm < ActiveRecord::Base
# Destroys the associated clients and people when the firm is destroyed
before_destroy { |record| Person.destroy_all "firm_id = #{record.id}" }
before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
end
The Observer classes let’s you extract the functionality of the callbacks:
class CommentObserver < ActiveRecord::Observer
def after_save(comment)
Notifications.deliver_comment("admin@do.com", "New comment was posted", comment)
end
end
Store observers in app/model/model_observer.rb
Enable observer by putting this in config/environment.rb
config.active_record.observers = :comment_observer, :signup_observer
ruby sript/generate migration AddTables
Creates a file db/migrations/001_add_tables. The methods “up” and “down” change the db schema
def self.up # brings db schema to the next version
create_table :table, :force => true do |t|
t.column :name, :string
t.column :age, :integer, { :default => 42 }
t.column :description, :text
# :string, :text, :integer, :float, :datetime, :timestamp, :time, :date,
# :binary, :boolean
end
add_column :table, :column, :type
rename_column :table, :old_name, :new_name
change_column :table, :column, :new_type
execute “SQL Statement”
add_index :table, :column, :unique => true, :name => ‘some_name’
add_index :table, [ :column1, :column2 ]
end
def self.down # rollbacks changes
rename_column :table, :new_name, :old_name
remove_column :table, :column
drop_table :table
remove_index :table, :column
end
To execute the migration:
rake db:migrate
rake db:migrate VERSION=14
rake db:migrate RAILS_ENV=production
rake test:units
The following assertions are available:
assert_kind_of Class, @var # same class
assert @var # not nil
assert_equal 1, @p.id # equality
@product.destroy
assert_raise(ActiveRecord::RecordNotFound) { Product.find( @product.id ) }
Each public method in a controller is callable by the (standard) URL scheme /controller/action
class WorldController < ApplicationController
def hello
render :text => ‘Hello world’
end
Parameters are stored in the params hash:
/world/hello/1?foo=bar
id = params[:id] # 1
foo = params[:foo] # bar
Instance variables defined in the the controllers methods are available to the corresponding view templates:
def show
@person = Person.find( params[:id])
end
Distinguish the type of response accepted:
def index
@posts = Post.find :all
respond_to do |type|
type.html # using defaults, which will render weblog/index.rhtml
type.xml { render :action => “index.rxml” }
type.js { render :action => “index.rjs” }
end
end
Usually the view template with the same name as the controller method is used to render the results
Action
render :action => ‘some_action’ # the default. Does not need to be specified
# in a controller method called “some_action”
render :action => ‘another_action’, :layout => false
render :action => ‘some_action’, :layout => ‘another_layout’
Partials
Partials are stored in files called “_subformname” ( _error, _subform, _listitem)
render :partial => ‘subform’
render :partial => ‘error’, :status => 500
render :partial => ‘subform’, :locals => { :variable => @other_variable }
render :partial => ‘listitem’, :collection => @list
render :partial => ‘listitem’, :collection => @list, :spacer_template => ‘list_divider’
Template
Like rendering an action, but finds the template based on the template root (app/views)
render :template => ‘weblog/show’ # renders app/views/weblog/show
File
render :file => ‘/path/to/some/file.rhtml’
render :file => ‘/path/to/some/filenotfound.rhtml’, status => 404, :layout => true
Text
render :text => “Hello World”
render :text => “This is an error”, :status => 500
render :text => “Let’s use a layout”, :layout => true
render :text => ‘Specific layout’, :layout => ‘special’
Inline Template
Uses ERb to render the “miniature” template
render :inline => ”<%= 'hello , ' * 3 + 'again' %>”
render :inline => ”<%= 'hello ' + name %>”, :locals => { :name => “david” }
Nothing
render :nothing
render :nothing, :status => 403 # forbidden
RJS
def refresh
render :update do |page|
page.replace_html ‘user_list’, :partial => ‘user’, :collection => @users
page.visual_effect :highlight, ‘user_list’
end
end
Change the content-type:
render :action => “atom.rxml”, :content_type => “application/atom+xml”
In config/routes.rb
map.connect ”, :controller => ‘posts’, :action => ‘list’ # default
map.connect ‘:action/:controller/:id’
map.connect ‘tasks/:year/:month’, :controller => ‘tasks’,
:action => ‘by_date’,
:month => nil, :year => nil,
:requirements => {:year => /\d{4}/,
:month => /\d{1,2}/ }
Filters can change a request before or after the controller. They can for example be used for authentication, encryption or compression.
before_filter :login_required, :except => [ :login ]
before_filter :autenticate, :only => [ :edit, :delete ]
after_filter :compress
It’s also possible to use a Proc for a really small filter action:
before_filter { |controller| false if controller.params[“stop_action”] }
Change the order of your filters by using prepend_before_filter and prepend_after_filter (like prepend_before_filter :some_filter which will put the some_filter at the beginning of the filter chain)
If you define a filter in a super class, you can skip it in the subclass:
skip_before_filter :some_filter
skip_after_filter :some_filter
To save data across multiple requests, you can use either the session or the flash hashes. A flash stores a value (normally text) until the next request, while a session stores data during the complete session.
session[:user] = @user
flash[:message] = “Data was saved successfully”
<%= link_to "login", :action => ‘login’ unless session[:user] %>
<% if flash[:message] %>
<div><%= h flash[:message] %></div>
<% end %>
It’s possible to turn off session management:
session :off # turn session managment off
session :off, :only => :action # only for this :action
session :off, :except => :action # except for this action
session :only => :foo, # only for :foo when doing HTTPS
:session_secure => true
session :off, :only => :foo, # off for foo, if uses as Web Service
:if => Proc.new { |req| req.parameters[:ws] }
Setting
cookies[:user_name] = “david” # => Will set a simple session cookie
cookies[:login] = { :value => “XJ-122”, :expires => Time.now + 3600}
# => Will set a cookie that expires in 1 hour
Reading
cookies[:user_name] # => “david”
cookies.size # => 2
Deleting
cookies.delete :user_name
All the option symbols for setting cookies are:
All view templates are stored in app/views/controllername. The extension determines what kind of template format is used:
All instance variables of the controller are available to the view. In addition, the following special objects can be accessed:
HTMl mixed with Ruby using tags. All of Ruby is available for programming
<% %> # executes the Ruby code
<%= %> # executes the Ruby code and displays the result
<ul>
<% @products.each do |p| %>
<li><%= h @p.name %></li>
<% end %>
</ul>
The output of anything in <%= %> tags is directly copied to the HTML output stream. To secure against HTML injection, use the h() function to html_escape the output
Creates XML files
xml.instruct! # <?xml version="1.0" encoding="UTF-8"?>
xml.comment! “a comment” # <!-- a comment -->
xml.feed “xmlns” => “http://www.w3.org/2005/Atom” do
xml.title “My Atom Feed”
xml.subtitle h(@feed.subtitle), “type” => ‘html’
xml.link url_for( :only_path => false,
:controller => ‘feed’,
:action => ‘atom’ )
xml.updated @updated.iso8601
xml.author do
xml.name “Jens-Christian Fischer”
xml.email “jcfischer@gmail.com”
end
@entries.each do |entry|
xml.entry do
xml.title entry.title
xml.link “href” => url_for ( :only_path => false,
:controller => ‘entries’,
:action => ‘show’,
:id => entry )
xml.id entry.urn
xml.updated entry.updated.iso8601
xml.summary h(entry.summary)
end
end
end
for more details see: http://rubyforge.org/projects/builder/
In addition to HTML and XML templates, Rails also understands JavaScript Templates. They allow you to easily create complex alterations of the displayed page. You can manipulate a page element with the following methods:
select Select a DOM element for further processing
page.select(‘pattern’) # selects an item on the page through a CSS pattern
# select(‘p’), select(‘p.welcome b’)
page.select(‘div.header em’).first.hide
page.select(‘#items li’).eacj do |value|
value.hide
end
insert_html Inserts content into the DOM at a specific position
page.insert_html :position, id, content
position can be one of the following:
:top:bottom:before:afterExamples:
page.insert_html :bottom, ‘list’, ’<li>last item</li>’
page.insert_html :before, ‘tasks’, :partial => ‘task’
replace_html Replaces the innerHTML of the specified DOM element
page.replace_html ‘title’, “This is the new title”
page.replace_html ‘person-45’, :partial => ‘person’, :object => @person
replace Replaces the “outer HTML”, (i.e. the entire element) of the specified DOM element
page.replace ‘task’, :partial => ‘task’, :object => @task
remove Removes the specified DOM element
page.remove ‘edit-button’
hide Hides the specified DOM element
page.hide ‘some-element’
show Shows the specified DOM element
page.show ‘some-element’
toggle Toggle the visibility of a DOM element
page.toggle ‘some-element’
alert Display an alert box
page.alert ‘Hello world’
redirect_to Redirects the browser to a given location
page.redirect_to :controller => ‘blog’, :action => ‘show’, :id => @post
call Calls another JavaScript function
page.call foo, 1, 2
assign Assigns a value to a JS variable
page.assign “foo”, 42
<< Writes raw JavaScript to the page
page << "alert('hello world);"
delay Delays the code in the block by a number of seconds
page.delay(10) do
page.visual_effect :fade, 'notice'
end
visual_effect Calls a Scriptaculous effect
page.visual_effect :highlight, 'notice', :duration => 2
sortable Create a sortable element
page.sortable ‘my_list’, :url => { :action => ‘order’ }
dragable Create a dragable element
page.dragable ‘my_image’, :revert => true
drop_receiving Create an element for receiving drops
page.drop_recieving ‘my_cart’, :url => { :controller => ‘cart’, :action => ‘add’ }
Small functions, usually used for displaying data, can be extracted to helpers. Each view has it’s own helper class (in app/helpers). Common functionality is stored in app/helpers/application_helper.rb
link_to “Name”, :controller => ‘post’, :action => ‘show’, :id => @post.id
link_to “Delete”, { :controller => “admin”,
:action => “delete”,
:id => @post },
{ :class => ‘css-class’,
:id => ‘css-id’,
:confirm => “Are you sure?” }
image_tag “spinner.png”, :class => “image”, :alt => “Spinner”
mail_to “info@invisible.ch”, “send mail”,
:subject => “Support request by #{@user.name}”,
:cc => @user.email,
:body => ‘….’,
:encoding => “javascript”
stylesheet_link_tag “scaffold”, “admin”, :media => “all”
<%= form_tag { :action => :save }, { :method => :post } %>
creates a form tag with the specified action, makes it a post request.
Use :multipart => true to define a Mime-Multipart form (for file uploads)
<%= text_field :modelname, :attribute_name, options %>
creates a text input field of the form:
<input type="text" name="modelname[attribute_name]" id="attributename" />
Example:
text_field “post”, “title”, “size” => 20
<input type="text" id="post_title" name="post[title]"
size="20" value="#{@post.title}" />
<%= hidden_field ... %>
creates a hidden field
<%= password_field ... %>
creates a password field (all input shown as stars)
<%= file_field ... %>
creates a file field
<%= text_area ... %>
creates a text area. Example:
text_area “post”, “body”, “cols” => 20, “rows” => 40
<textarea cols="20" rows="40" id="post_body" name="post[body]">
#{@post.body}
</textarea>
<%= radio_button :modelname, :attribute, :tag_value, options %>
creates a radio button.
Example:
radio_button “post”, “category”, “rails”
radio_button “post”, “category”, “java”
<input type="radio" id="post_category" name="post[category]" value="rails"
checked="checked" />
<input type="radio" id="post_category" name="post[category]" value="java" />
<%= check_box :modelname, :attribute, options, on_value, off_value %>
Example:
check_box “post”, “validated” # post.validated? returns 1 or 0
<input type="checkbox" id="post_validate" name="post[validated]"
value="1" checked="checked" />
<input name="post[validated]" type="hidden" value="0" />
check_box “puppy”, “gooddog”, {}, “yes”, “no”
<input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
<input name="puppy[gooddog]" type="hidden" value="no" />
Create a select tag. Pass an array of choices
<%= select :variable, :attribute, choices, options, html_options %>
select “post”,
“person_id”,
Person.find_all.collect {|p| [ p.name, p.id ] },
{ :include_blank => true }
<select name="post[person_id]">
<option></option>
<option value="1" selected="selected">David</option>
<option value="2">Sam</option>
<option value="3">Tobias</option>
</select>
<%= collection_select :variable, :attribute, choices, :id, :value %>
<%= date_select :variable, :attribute, options %>
<%= datetime_select :variable, :attribute, options %>
Examples:
date_select “post”, “written_on”
date_select “user”, “birthday”, :start_year => 1910
date_select “user”, “cc_date”, :start_year => 2005,
:use_month_numbers => true,
:discard_day => true,
:order => [:year, :month]
datetime_select “post”, “written_on”
<%= end_form_tag %>
A layout defines the surroundings of an HTML page. It’s the place to define common look & feel. Layouts live in app/views/layouts
<html>
<head>
<title>Form: <%= controller.action_name %></title>
<%= stylesheet_link_tag 'scaffold' %>
</head>
<body>
<%= yield %> # the content will show up here
</body>
</html>
—-
class MyController < ApplicationController
layout "standard", :except => [ :rss, :atom ]
…
end
—-
class MyOtherController < ApplicationController
layout :compute_layout
# this method computes the name of the layout to use
def compute_layout
return "admin" if session[:role] == "admin"
"standard"
end
...
end
Layouts have access to the instance variables of the controller so you can pass values “up”
Partials are building blocks for creating views. They allow re-use of commonly used display blocks. They are stored in files:
render :partial => ‘product’
loads the partial in _form.rthml and passed the instance variable @product to it. The partial can access it using @product
render :partial => ‘product’, :locals => { :product => @bought }
loads the same partial but assigns a different instance variable to it.
render :partial => ‘product’, :collection => @product_list
renders the partial for each element in @product_list and assigns @product to each element. An iteration counter will automatically be made available to the template with a name of the form partial_name_counter (in the above example: product_counter).
To reuse both controller logic and views, use them as “components”
render_component :controller => ‘posts’, :action => ‘last_posts’
That calls last_posts in the PostsController. Use
render :layout => false, …
or
layout “xxx”, :except => ‘last_posts’
to render this action without a layout
rake test:functional
get :action # a get request of the specificed action
get :action, :id => 1,
{ session_hash }, # optional session variables
{ flash_hash } # optional messages in the flash
post :action, :foo => { :value1 => ‘abc’, :value2 => ‘123’ },
{ :user_id => 17 },
{ :message => ‘success’ }
get, post, put, delete, head
assert_response :success
# possible parameters are:
# :success
# :redirect
# :missing
# :error
assert_redirected_to :action => :other_action
assert_redirected_to :controller => ‘foo’, :action => ‘bar’
assert_redirected_to http://www.invisible.ch
assert_template “post/index”
assert_nil assigns(:some_variable)
assert_not_nil assigns(:some_variable)
assert_equal 17, assigns(:posts).size
assert_tag :tag => ‘body’
assert_tag :content => ‘Rails Seminar’
assert_tag :tag => ‘div’, :attributes => { :class => ‘index_list’ }
assert_tag :tag => ‘head’, :parent => { :tag => ‘body’ }
assert_tag :tag => ‘html’, :child => { :tag => ‘head’ }
assert_tag :tag => ‘body’, :descendant => { :tag => ‘div’ }
assert_tag :tag => ‘ul’,
:children => { :count => 1..3,
:only => { :tag => ‘li’ } }
Be sure to include the javascript libraries in the layout
<%= javascript_include_tag :defaults %>
<%= link_to_remote "link", :update => ‘some_div’,
:url => { :action => ‘show’, :id => post.id } %>
<%= link_to_remote "link", :url => { :action => ‘create’,
:update => { :success => ‘good_div’,
:failure => ‘error_div’ },
:loading => ‘Element.show(‘spinner’),
:complete => ‘Element.hide(‘spinner’) } %>
:loading Called when the remote document is being loaded with data
by the browser.
:loaded Called when the browser has finished loading the remote document.
:interactive Called when the user can interact with the remote document,
even though it has not finished loading.
:success Called when the XMLHttpRequest is completed, and the HTTP
status code is in the 2XX range.
:failure Called when the XMLHttpRequest is completed, and the HTTP
status code is not in the 2XX range.
:complete Called when the XMLHttpRequest is complete (fires after
success/failure if they are present).
You can also specifiy reactions to return codes directly:
link_to_remote word,
:url => { :action => “action” },
404 => “alert(‘Not found…? Wrong URL…?’)”,
:failure => “alert(‘HTTP Error ’ + request.status + ‘!’)”
Create a form that will submit via an XMLHttpRequest instead of a POST request. The parameters are passed exactly the same way (so the controller can use the params method to access the parameters). Fallback for non JavaScript enabled browsers can be specified by using the :action methods in the :html option.
form_remote_tag :html => { :action => url_for(:controller => ‘controller’,
:action => ‘action’),
:method => :post }
In View:
<%= text_field_with_auto_complete :model, :attribute %>
In Controller:
auto_complete_for :model, :attribute
<label for="search">Search term:</label>
<%= text_field_tag :search %>
<%= observe_field(:search,
:frequency => 0.5,
:update => :results,
:url => { :action => :search }) %>
<div id="results"></div>
Optionally specify:
:on => :blur # trigger for event (default :changed or :clicked)
:with => … # a JavaScript expression to specify what value is sent
# defaults to “value”
:with => ‘bla’ # “‘bla’ = value”
:with => ‘a=b’ # “a=b”
Same semantics as observe_field
<%= periodically_call_remote(:update => ‘process-list’,
:url => { :action => :ps },
:frequency => 2 ) %>
A lot of things can be configured in the config/environment.rb file. This list is not exhaustive:
config.action_controller.session_store = :active_record_store
# one of :active_record_store, :drb_store,
# :mem_cache_store, or :memory_store or your own class
ActionController::Base.session_options[:session_key] = ‘my_app’
# use an application specific session_key
ActionController::Base.session_options[:session_id] = ‘12345’
# use this session_id. Will be created if not specified
ActionController::Base.session_options[:session_expires] = 3.minute.from_now
# how long before a session expires?
ActionController::Base.session_options[:new_session] = true
# force the creation of a new session
ActionController::Base.session_options[:session_secure] = true
# only use sessions over HTTPS
ActionController::Base.session_options[:session_domain] = ‘invisible.ch’
# Specify which domain this session is valid for (default: hostname of server)
ActionController::Base.session_options[:session_path] = ‘/my_app’
# the path for which this session applies. Defaults to the
# directory of the CGI script
ActionController::Base.fragment_cache_store = :file_store, “/path/to/cache/directory”
Part of the course materials for the Ruby On Rails Workshop by InVisible GmbH.
InVisible GmbH
Langgrütstrasse 172
8047 Zürich
+41 44 401 09 30
http://www.invisible.ch
mailto:info@invisible.ch
Dieser Inhalt ist unter einer Creative Commons-Lizenz lizenziert.
update: This version of the reference is from May 06. You may find an updated version on InVisible
nanoRAILS was down for the past 12h because of a setup change on my host on DreamHost.
Suddenly, the link /usr/local/lib/ruby was changed to point to an incorrect location, so instead of having the ruby libraries under /usr/local/lib/ruby/1.8, they would effectively be under /usr/local/lib/ruby/ruby/1.8 :(
Suffice it to say that things don’t work too well after that.
Running dispatch.fgci by hand revealed that “require pathname” fails. Hmmm, that’s not supposed to happen! That when I realized the above mentioned link had been changed just a few hours before.
After tinkering some more, and trying a few options, I managed to put a kludge together till the link is put back in the right place.
In the public directory, I created a myruby script:
#!/bin/bash
export RUBYLIB=/usr/local/lib/ruby/ruby/1.8/:/usr/local/lib/ruby/ruby/1.8/i386-linux/
/usr/bin/ruby $*
Make sure that script is executable (chmod +x myruby)
then in dispatch.fcgi, I replaced the first line with:
#!/usr/bin/env [PATH TO YOUR RAILS APP]/public/myruby
Of course, this will likely break once the link is restored to its correct value.
You’ve got to love using a shared host!
Update: ruby setup is back to normal now. At least I learned something in the process.
Everyone that was inconvenienced by this outage, please accept my apologies.
Javascript is great when it works. When it doesn’t work, it can get you from happy to miserable in less time than it takes you to say XmlHttpRequest.
Today I just found (via Ajaxian) an interesting tool that I’m adding to my arsenal when it comes to figuring out what’s happening in javascript. Definitely an invaluable debugging tool. It is called JavaScript Shell. When you embed the script, you get a command line window where you can make javascript calls directly from inside your web page.
You can call any method, inspect objects (using props), see where DOM objects are (using blink), and the killer feature, in my view, is the autocompletion using the tab key! It also features a command history, which is very convenient to try variations of the same call.
And if that wasn’t enough, you can also use the script as a bookmarklet. There is a Firefox version, and an Internet Explorer version available from Curiosity is bliss (ported to IE by Julien Couvreur).
You should try the script for yourself.
This is a great tool to debug, or even try a few things quickly and this will be a good complement to the rails console. It sure beats having to reload the page!
Here’s the question I was faced with today.
If you install a software that is licenced under the GPL license on a server, and let people interact with the software, do you have to make the source available? And furthermore, if you did modify that software, are you obligated to release that software along with the source.
A good example of that would be Joomla!. It is not uncommon to want to customize it, fix bugs very specific to your use of the software, etc…
Based on my understanding on the GPL, my inital thinking that you had to make your modifications available. But I had enough doubts that I wanted to find out more. After a few hours of research, it turns out I was wrong.
Essentially, the section 0 of the GPL clearly states that it only covers distribution, copying, and modifications (that you allow others to copy or that you distribute).
In fact, the GPL FAQ specifically addresses that issues under
The GPL permits anyone to make a modified version and use it without ever distributing it to others. What this company is doing is a special case of that. Therefore, the company does not have to release the modified sources.
It is essential for people to have the freedom to make modifications and use them privately, without ever publishing those modifications. However, putting the program on a server machine for the public to talk to is hardly “private” use, so it would be legitimate to require release of the source code in that special case. We are thinking about doing something like this in GPL version 3, but we don’t have precise wording in mind yet.
In the mean time, you might want to use the Affero GPL for programs designed for network server use.
Interestingly enough, this is appears to be a question that comes up often enough to be included in the FAQ and it mentions that they were considering addressing that issue in version 3. Based on my reading of the current draft of GPL 3, this has not happened yet, and unlikely to happen at this juncture.
That FAQ entry also points to an alternative license that would require you to release the code if you host the GPL software on a server: The Affero GPL or AGPL. Section 2.d has additional requirements on top of GPL:
2…d) If the Program as you received it is intended to interact with users through a computer network and if, in the version you received, any user interacting with the Program was given the opportunity to request transmission to that user of the Program’s complete source code, you must not remove that facility from your modified version of the Program or work based on the Program, and must offer an equivalent opportunity for all users interacting with your Program through a computer network to request immediate transmission by HTTP of the complete source code of your modified version or other derivative work.
The fact that someone felt they had to modify the text of the GPL to make it more epxlicit should in itself be proof enough that GPL does not cover it, and that therefore does not require you to release sources.
The AGPL is not a license that has a very wide adoption, but you can find quite a few projects using it beyond affero.org.
I’ve also found a discussion between Richard Stallman himself and Steve- Parker that yields the same answer:
Scenario 2) I modify GPL code – eg a CGI library – to suit my own needs for
use on a publicly-available web server. This code is being run, by the
general public, on my web server. Should I, in this case, make the code
available? Under the GPL, must I?
And Richard Stallman’s answer:
The GPL does not require it. But is not very good for the community
when people do this, so I am looking at a way that GPL 3 could
require publication in this case.
You will also find the discussion on the Open Source Law Blog relevant. What makes it more interesting is that Paul Arne is a lawyer that specializes in Open Source Software licensing.
So in conclusion, you can be fairly confident that the answer to my original question is “Yes, you can host a modified GPL software, and not be required to release your modifications”. Of course, by doing so, you lose the benefits of GPL, but that’s a debate for another day.
In the first part, I explained how you could
Display ads from TextLinkAds in a rails application.
This created the basis for today’s addition: caching.
You know that the ads won’t change that often, and saving your bandwith and CPU cycle (and TextLinkAds too) is not too much to ask.
One way to achieve that is to use the fragment cache provided by Ruby on Rails. It does not however provide expiration dates. To add expiration, you can use 2 related elements, one for storing the expiration, one to store the actual data.
Firt you need to generate the names of the 2 keys:
def fragment_key(name)
return “TLA/TIME/#{name}”, “TLA/DATA/#{name}”
end
and here, the logic to check whether the cache is present, and has not expired.
def content
url = “http://www.text-link-ads.com/xml.php?inventory_key=”+@sb_config[‘key’]+”&referer=”+CGI::escape(@request.env[‘REQUEST_URI’])
agent = “&user_agent=”+CGI::escape(@request.env[‘HTTP_USER_AGENT’])
url_time, url_data = fragment_key(url)
#is it time to update the cache?
time = read_fragment(url_time)
if (time == nil) || (time.to_time < Time.now)
@links = request(url+agent) rescue nil
#if we can get the latest, then update the cache
if @links != nil
expire_fragment(url_time)
expire_fragment(url_data)
write_fragment(url_time, Time.now+6.hour)
write_fragment(url_data, @links)
else
#otherwise try again in 1 hour
write_fragment(url_time, Time.now+1.hour)
@links = read_fragment(url_data)
end
else
#use the cache
@links = read_fragment(url_data)
end
end
In case the request to TextLinkAds fails (@links is nil), for whatever reason, you keep the cache for one extra hour till you make an other attempt.
And to make the code complete, here are the needed files to include and other needed helper functions:
require 'net/http'
require 'cgi'
def request(url)
XmlSimple.xml_in(http_get(url))
end
# Does an HTTP GET on a given URL and returns the response body
def http_get(url)
Net::HTTP.get_response(URI.parse(url)).body.to_s
end
So this takes care of caching the calls to TextLinkAds. You may not be done, though. Depending on the app you use, and its caching strategy, you may have another problem to solve. Your app may be caching your pages and actions, which may cause your links from TextLinkAds never to be updated. One solution is to use an approach similar to the one used by typo as described by Scott Laird and use caches_action_with_params from *scottstuff*.
This can wrap any method in your controller, and provide you the ability to control the longevity of your application’s cache simply by setting the lifetime value in the response:
response.lifetime = 6.hour
So for an application like typo, the code would be:
def content
response.lifetime = 6.hour
url = "http://www.text-link-ads.com/xml.php?inventory_key="+@sb_config['key']+"&referer="+CGI::escape(@request.env['REQUEST_URI'])
agent = "&user_agent="+CGI::escape(@request.env['HTTP_USER_AGENT'])
url_time, url_data = fragment_key(url)
#is it time to update the cache?
time = read_fragment(url_time)
if (time == nil) || (time.to_time < Time.now)
@links = request(url+agent) rescue nil
#if we can get the latest, then update the cache
if @links != nil
expire_fragment(url_time)
expire_fragment(url_data)
write_fragment(url_time, Time.now+6.hour)
write_fragment(url_data, @links)
else
#otherwise try again in 1 hour
write_fragment(url_time, Time.now+1.hour)
@links = read_fragment(url_data)
end
else
#use the cache
@links = read_fragment(url_data)
end
end
As time permits, I’ll be posting my sidebar plugin for typo to provide a nice UI to set your TextLinkAds account and referral id.
After hours spent in breakpointer struggling to make sense of the output, I figured there had to be a better way to look at a stack trace than what the default output provides:
irb(ArticlesController):007:0> caller
=> [“./vendor/rails/railties/lib/breakpoint.rb:512:in `breakpoint’”, “./vendor/rails/railties/lib/breakpoint.rb:512:in `breakpoint’”, “./vendor/rails/actionpack/lib/action_controller/caching.rb:510:in `cache_sweeper’”, “./app/controllers/articles_controller.rb:7”, …]
Well, after some research, I found at least 4! And they work for any data structure, not just for stack traces, but I’m a pretty happy camper just with cleaner stack traces!
Solution #1
Building on Using the standard output in breakpointer, you can use each to get a more decent output.
caller.each { |x| client.puts x }
which returns:
./vendor/rails/railties/lib/breakpoint.rb:512:in `breakpoint’
./vendor/rails/railties/lib/breakpoint.rb:512:in `breakpoint’
./vendor/rails/actionpack/lib/action_controller/caching.rb:510:in `cache_sweeper’
…
Solution #2
Use PrettyPrint
client.require ‘pp’
client.pp caller
Solution #3
Use YAML
client.require ‘yaml’
client.y caller
Solution #4
Use to_yaml
client.puts caller.to_yaml
These methods can also be used to display any complex data.
Try it on the request object for example.
To avoid having to type the require each time, add to .irbrc:
require ‘yaml’
require ‘pp’
When you use script/breakpointer, once you have stopped in irb, if you try using print, puts or some other way to display something, your ouput goes to your main rails output, not to irb, which is not quite convenient.
First, it took me a while to realize where the output was in fact going. I guessed I was not too quick on that one.
Second, even knowing where to look, I did not find this solution very satisfying.
It turns out there is a solution. the client variable can help you use the right output
client.print “hello\n”
will output:
hello
=> nil
Works the same for puts.
Once my application with TextLinkAds was approved, I looked for a sample code to make it work in typo, or more generally in Ruby on Rails. TextLinkAds did not provide any, and a quick search in google did not return anything.
So I took their php example and came up with these snippets.
In your controller:
require ‘net/http’
require ‘cgi’
def content
url = “http://www.text-link-ads.com/xml.php?inventory_key=”+TEXTLINKADS KEY+”&referer=”+CGI::escape(@request.env[‘REQUEST_URI’])+”&user_agent=”+CGI::escape(@request.env[‘HTTP_USER_AGENT’])
@links = request(url) rescue nil
end
def request(url)
XmlSimple.xml_in(http_get(url))
end
def http_get(url)
Net::HTTP.get_response(URI.parse(url)).body.to_s
end
And in your view (rhtml), you just need to add:
<% if @links != nil %>
<% if (@links != nil)&&(@links["Link"] != nil) %>
<% for link in @links["Link"] -%>
<li><%= link['BeforeText'][0] -%> <
a href="<%= link['URL'][0] -%>”><%= link['Text'][0] -%></a> <%= link['AfterText'][0] -%> </li>
<% end -%>
<% end -%>
<% else %>
Advertise here!
<% end -%>
To make the above look right with markdown, I had to cut the < a > element in between. When pasting this, remove the carriage return. If someone has a better idea on how to prevent the < a > element from being interpreted as a link even in a code block, please let me know!
Based on the example, it is fine to cache the result, so I’ll be adding that later tonight. As soon as I get caching up and running, I’ll also post the typo sidebar plugin
5/4/06 update: I tweaked the code to account for the no links at all case. TextLinkAds starts with a test link that they later remove, and my code broke. I replaced:
<% if @links != nil %>
by
<% if (@links != nil)&&(@links["Link"] != nil) %>