Rails 3.0.9 veröffentlicht

Rails 3.0.9 wurde heute veröffentlicht. Es behebt ein paar Bugs und enthält zudem noch das letzte Sicherheitsfix.

Das Update kann wie gewohnt über gem eingespielt werden:

[bash]
gem install rails
[/bash]

Ansonsten gibt es noch die Möglichkeit über bundler die eigene Railsversion auf den aktuellsten Stand zu bringen.

Gemfile anpassen…

[ruby]
gem ‚rails‘, ‚3.0.9‘
[/ruby]

… und bundler aufrufen

[bash]
bundle install
[/bash]

Screencast: Daten-Bäume mit Ancestry verwenden

Ancestry ist ein gem über welches man auf einfache Weise Baumstrukturen in Rails (2+3) /Ruby-Applikationen einsetzen kann. Neben allen zu erwartenenden Funktionen wie zum Beispiel für Eltern, Kinder und Nachbar-Elementen, unterstützt Ancestry auch STI (Single Table Inheritance). Auch Funktionen zum Sortieren, Integretäts-Test und Rückwärtskombatibilität sind verfügbar.
Ryan zeigt in dieser Woche wie es in eingesetzt werden kann.

 

Download:

Download(15.7 MB, 9:39)
Alternativer Download für iPod & Apple TV(15.1 MB, 9:39)

 

Resourcen:

 

Quellcode:

[bash]
bundle
rails g migration add_ancestry_to_messages ancestry:string
rake db:migrate
[/bash]

[ruby]
# Gemfile
gem ‚ancestry‘

# migration.rb
class AddAncestryToMessages < ActiveRecord::Migration
def self.up
add_column :messages, :ancestry, :string
add_index :messages, :ancestry
end

def self.down
remove_index :messages, :ancestry
remove_column :messages, :ancestry
end
end

# messages_controller.rb
def new
@message = Message.new(:parent_id => params[:parent_id])
end

# messages_helper.rb
def nested_messages(messages)
messages.map do |message, sub_messages|
render(message) + content_tag(:div, nested_messages(sub_messages), :class => "nested_messages")
end.join.html_safe
end
[/ruby]

[html]
<!– messages/index.html.erb –>
<%= nested_messages @messages.arrange(:order => :created_at) %>

<!– messages/show.html.erb –>
<%= nested_messages @message.subtree.arrange(:order => :created_at) %>

<!– messages/_form.html.erb –>
<%= f.hidden_field :parent_id %>

<!– messages/_message.html.erb –>
<%= link_to message.content, message %>

<%= link_to "Reply", new_message_path(:parent_id => message) %> |
[/html]

[css]
/* application.css */

.nested_messages {
margin-left: 30px;
}

.nested_messages .nested_messages .nested_messages .nested_messages {
margin-left: 0;
}
[/css]

Screencast: JavaScript mit Jasmine testen

Jasmine ist ein BDD-Testframework um JavaScript zu testen. Es ist für die Tests nicht auf DOM angewiesen und hat auch keine Abhängigkeiten zu anderen Frameworks. Ryan zeigt wie es in Kombination mit Rails eingesetzt werden kann.

 

Download:

Download(24.8 MB, 15:20)
Alternativer Download für iPod & Apple TV(25.3 MB, 15:20)

 

Resourcen:

 

Quellcode:

[bash]
bundle
rails g jasmine:install
rake jasmine
rake jasmine:ci
curl http://cloud.github.com/downloads/velesin/jasmine-jquery/jasmine-jquery-1.2.0.js > spec/javascripts/helpers/jasmine_jquery-1.2.0.js
[/bash]

[ruby]
# Gemfile
gem ‚jasmine‘, :group => [:development, :test]
[/ruby]

[javascript]
/* credit_card_spec.js */

describe("CreditCard", function() {
it("cleans number by removing spaces and dashes", function() {
expect(CreditCard.cleanNumber("123 4-5")).toEqual("12345");
});

it("validates based on mod 10", function() {
expect(CreditCard.validNumber("4111 1111-11111111")).toBeTruthy();
expect(CreditCard.validNumber("4111111111111121")).toBeFalsy();
});

it("validates when text field loses focus", function() {
loadFixtures("order_form.html");
$("#card_number").validateCreditCardNumber();
$("#card_number").val("123");
$("#card_number").blur();
expect($("#card_number_error")).toHaveText("Invalid credit card number.");
$("#card_number").val("4111 1111-11111111");
$("#card_number").blur();
expect($("#card_number_error")).toHaveText("");
});
});

/* credit_card.js */
var CreditCard = {
cleanNumber: function(number) {
return number.replace(/[- ]/g, "");
},

validNumber: function(number) {
var total = 0;
number = this.cleanNumber(number);
for (var i=number.length-1; i >= 0; i–) {
var n = parseInt(number[i]);
if ((i+number.length) % 2 == 0) {
n = n*2 > 9 ? n*2 – 9 : n*2;
}
total += n;
};
return total % 10 == 0;
}
};

(function($){
$.fn.validateCreditCardNumber = function() {
return this.each(function() {
$(this).blur(function() {
if (!CreditCard.validNumber(this.value)) {
$("#" + this.id + "_error").text("Invalid credit card number.");
} else {
$("#" + this.id + "_error").text("");
}
});
});
};
})(jQuery);

/* applicaiton.js */
$(function() {
$("#order_credit_card_number").validateCreditCardNumber();
});
[/javascript]

[html]
<!– orders/_form.html.erb –>
<%= f.text_field :credit_card_number %>
<span id="order_credit_card_number_error"></span>
[/html]

Request Specs und Capybara

Request specs in RSpec sind einge großartige Möglichkeit den kompletten Applikation-Stack zu testen. Ryan zeigt diese Woche wie dies und capybara in Verbindung mit Selenium eingesetzt werden kann.

 

Download:

Download(20.3 MB, 13:16)
Alternativer Download für iPod & Apple TV(20.6 MB, 13:16)

 

Resourcen:

 

Quellcode:

[bash]
bundle
rails g rspec:install
rails g integration_test task
rake spec:requests
[/bash]

[ruby]
# Gemfile
group :development, :test do
gem ‚rspec-rails‘
gem ‚capybara‘, :git => ‚git://github.com/jnicklas/capybara.git‘
gem ‚launchy‘
gem ‚database_cleaner‘
end

# spec/requests/tasks_spec
describe "Tasks" do
describe "GET /tasks" do
it "displays tasks" do
Task.create!(:name => "paint fence")
visit tasks_path
page.should have_content("paint fence")
end

it "supports js", :js => true do
visit tasks_path
click_link "test js"
page.should have_content("js works")
end
end

describe "POST /tasks" do
it "creates task" do
visit tasks_path
fill_in "New Task", :with => "mow lawn"
click_button "Add"
page.should have_content("Successfully added task.")
page.should have_content("mow lawn")
end
end
end

# spec_helper.rb
require ‚capybara/rspec‘

RSpec.configure do |config|
# …
config.use_transactional_fixtures = false

config.before(:suite) do
DatabaseCleaner.strategy = :truncation
end

config.before(:each) do
DatabaseCleaner.start
end

config.after(:each) do
DatabaseCleaner.clean
end
end
[/ruby]

[html]
<!– tasks/index.html.erb –>
<%= link_to_function "test js", ‚$(this).html("js works")‘ %>
[/html]

Rails 3.0.5 veröffentlicht

Gestern Abend wurde Rails 3.0.5 veröffentlicht. Diese Version beinhaltet ein paar kleinere Bugfixes und es wurden weitere Deprecations (Warnung über veraltete Methoden/Funktionen) hinzugefügt.

Bugs Fixes:

  1. gzip gibt nun die Datei binär zurück
  2. Active Record limit Werte
  3. Relation#where erzeugt nun immer ein „AND“-Statement
  4. Observer callbacks werden jetzt nur ein mal aufgerufen

Deprecations:

  1. Relation#& Alias für Relation#merge.
  2. Interpolierte Beziehung

Eine komplette Liste mit allen Ändernungen ist hier verfügbar: https://github.com/rails/rails/compare/v3.0.4…v3.0.5

ALTER TABLE mit Rails 3 und MySQL

Da nicht immer von Anfang an die Datenbank- bzw. Tabellenstruktur eindeutig ist und geänderte Anforderungen das Datenbankschema beeinflussen, müssen Anpassungen vorgenommen werden. Dies ist in der Regel einfach in den Migration-Scripten konfigurierbar. Mit dem vorgestellten Commit wird es in Zukunft in einer optimierteren Version als Bulk ablaufen.

Der erwähnte Commit ist im GitHub einsehbar (https://github.com/rails/rails/commit/30176f28a41681c7607eed39d03501327869d40c).

 

Das Problem, das bisher bei Änderungen an Tabellen bestand, war die Art wie MySQL diese ausführt. Wenn man von folgendem Beispiel ausgeht:
Es sollen zwei Spalten hinzugefügt werden und der Datentyp einer weiteren soll geändert werden.

[ruby]
change_table(:users) do |t|
t.string :im_handle
t.belongs_to :company
t.change :birthdate, :datetime
end
[/ruby]

 

Diese Migration führte bisher zu drei separat ausgeführten Befehlen:

 

[bash]
ALTER TABLE `users` ADD `im_handle` varchar(255)
ALTER TABLE `users` ADD `company_id` int(11)
ALTER TABLE `users` CHANGE `updated_at` `updated_at` datetime DEFAULT NULL
[/bash]

 

Diese Aktion ist bei kleinen Datenbanken „relativ“ unproblematisch, aber führt zu Problemen bei größeren.Denn wenn man einen Blick in die MySQL Dokumentation wirft, wird man feststellen, dass MySQL einiges im Hintergrund ausführt, um die Änderung durchzuführen. Die grobe Reihenfolge sieht ungefähr so aus:

 
  1. Die Tabelle wird gesperrt (lock). Kein UPDATE und INSERT mehr zugelassen
  2. Eine temporäre Kopie der Tabelle samt Inhalt wird angelegt
  3. Die gewünschten Änderungen werden auf die Kopie angewendet
  4. Die originale Tabelle wird durch die geänderte Kopie ersetzt
 

Wenn nun das oben gezeigte Beispiel ausgeführt wird, würden diese Schritte drei mal ausgeführt werden. Das ist nicht unbedingt performant und nicht immer gewünscht.

In den kommenden Rails-Versionen kann dieser Vorgang als Bulk durchgeführt werden. Dadurch werden alle Änderungen als einziger Befehl durchgeführt:

[ruby]
change_table(:users, :bulk => true) do |t|
t.string :im_handle
t.belongs_to :company
t.change :birthdate, :datetime
end
[/ruby]

Durch den zusätzlichen Parameter „bulk => true“ werden die einzelnen Statements zu einer zusammengefasst:

[bash]
ALTER TABLE `users` ADD COLUMN `im_handle` varchar(255), ADD COLUMN `company_id` int(11), CHANGE `updated_at` `updated_at` datetime DEFAULT NULL
[/bash]

Dadurch werden Datenbankänderungen in Zukunft nicht nur schneller sondern auch atomarer.

Screencast: Metriken

In dieser Woche gibt es von Ryan einen Screencast rund um das Thema Metriken. Es werden mitunter folgende Gems und Tools gezeigt: Metric Fu, Metrical, SimpleCov, Rails Best Practices.

 

Download:

Download(30.1 MB, 7:51)
Alternativer Download für iPod & Apple TV(27.3 MB, 7:51)

 

Resourcen:

 

Quellcode:

[bash]
gem install metrical
metrical
bundle
rake spec
open coverage/index.html
gem install rails_best_practices
rails_best_practices -f html –with-textmate
open rails_best_practices_output.html
[/bash]

[ruby]
# Gemfile
gem "simplecov", :require => false, :group => :test

# .metrics
MetricFu::Configuration.run do |config|
config.metrics -= [:rcov]
end
[/ruby]

Ruby on Rails 3 Tutorial Livelessons Bundle: Learn Rails by Example

Ruby on Rails 3 Tutorial LiveLessons is your complete video guided tour of modern Rails web development! Top Rails expert and author Michael Hartl walks you through the entire process: installing and setting up Rails, designing Rails applications with MVC and REST, building dynamic pages, coding effectively in Ruby, implementing registration and authentication, adding social features, even testing and deployment.

Just watch and learn: You’ll find expert insight, modern best practices, and step-by-step instructions for solving real-world problems!

  • LiveLessons are video courses that are organized into short, self-contained lessons–you’ll learn key skills in as little as [shortest lesson time to come] minutes
  • Track your progress as you follow clearly defined learning objectives
  • Follow along as your instructor shows exactly how to get great results in your real-world environment

Ruby on Rails 3 Tutorial: Learn Rails by Example

Using Rails 3, developers can build web applications of exceptional elegance and power. Although its remarkable capabilities have made Ruby on Rails one of the world’s most popular web development frameworks, it can be challenging to learn and use. Ruby on Rails™ 3 Tutorial is the solution. Leading Rails developer Michael Hartl teaches Rails 3 by guiding you through the development of your own complete sample application using the latest techniques in Rails web development.

Drawing on his experience building RailsSpace, Insoshi, and other sophisticated Rails applications, Hartl illuminates all facets of design and implementation—including powerful new techniques that simplify and accelerate development.

You’ll find integrated tutorials not only for Rails, but also for the essential Ruby, HTML, CSS, JavaScript, and SQL skills you’ll need when developing web applications. Hartl explains how each new technique solves a real-world problem, and he demonstrates this with bite-sized code that’s simple enough to understand, yet novel enough to be useful. Whatever your previous web development experience, this book will guide you to true Rails mastery.

 

This book will help you

  • Install and set up your Rails development environment
  • Go beyond generated code to truly understand how to build Rails applications from scratch
  • Learn Test Driven Development (TDD) with RSpec
  • Effectively use the Model-View-Controller (MVC) pattern
  • Structure applications using the REST architecture
  • Build static pages and transform them into dynamic ones
  • Master the Ruby programming skills all Rails developers need
  • Define high-quality site layouts and data models
  • Implement registration and authentication systems, including validation and secure passwords
  • Update, display, and delete users
  • Add social features and microblogging, including an introduction to Ajax
  • Record version changes with Git and share code at GitHub
  • Simplify application deployment with Heroku
 
 

RailsTutorial.org: Michael Hartl’s awesome new Rails TutorialThe Ruby on Rails3 Tutorial: Learn Rails by Example by Michael Hartl has become a must read for developers learning how to build Rails apps.

—Peter Cooper, editor of Ruby Inside

Very detailed and hands-on Rails Tutorial!

Great job! I’m learning Rails, and found your tutorial to be one of the most detailed and hands-on guides. Besides many details of Rails, it also taught me about Git, Heroku, RSpec, Webrat, and most important (at least to me), it emphasized the Test-Driven Development (TDD) methodology. I learned a lot from your tutorial. Keep up the good job! Thanks so much for sharing it.

—Albert Liu, senior manager, Achievo Corporation.

Ruby on Rails Tutorial is the best!

Just wanted to say that your Ruby on Rails tutorial is the best! I’ve been trying for a while to wrap my head around Rails. Going through your tutorial, I’m finally feeling comfortable in the Rails environment. Your pedagogical style of gradually introducing more complex topics while at the same time giving the reader the instant gratification and a sense of accomplishment with working examples really works for me. I also like the tips and suggestions that give me a sense of learning from a real Rails insider. Your e-mail response to a problem I ran into is an example of your generous sharing of your experience.

—Ron Bingham, CEO, SounDBuytz

I love the writing style of the Rails Tutorial

I love the writing style of the Rails Tutorial, and there is so much content that is different from other Rails books out there, making it that much more valuable…Thanks for your work!

—Allen Ding

Ruby on Rails 3: Das Entwickler-Handbuch

Das Buch von Hussein und Tanja „Ruby on Rails 3: Das Entwickler-Handbuch“ erscheint im April in einer neuen und aktualisieren Version.

Einiges hat sich getan: Rails 3 integriert das Ruby-Framework »Merb« und erweitert damit enorm sein Potenzial. Die neue Version bietet so eine viel größere Flexibilität bei der Wahl des Datenbank-, Test- und Template-Frameworks. Die zahlreichen und komplexen Möglichkeiten des Frameworks werden ausführlich behandelt. Dabei bleibt das Buch stets verständlich und praxisbezogen, da Rails anhand mehrerer »Realworld«-Beispiele anschaulich erläutert wird. Alle Beispielapplikationen sind dabei systematisch aufgebaut: von einer einfachen bis zu einer komplexen Anwendung inklusive TestDrivenDevelopment. Tipps und Tricks, eine umfassende Befehlsreferenz und eine Einführung in die Sprache Ruby lassen dann keine Wünsche mehr offen.