Overview of the development of the Ruby on Rails framework over the past 14 months

Over time, do not have time. Everything develops very rapidly. At some point, I noticed that although I work with the latest version of Ruby on Rails, I don’t use many of the features that I implement in it, and I don’t even hear about many.
I will try to do a retrospective of what has been entered into Rails over the past 14 months. Each innovation will be accompanied by a small example, which I will copy as is from the source on which the article is based, since such explanations for each are a topic for a heap of individual articles or a link.

The narrative goes in the form of:
Version
What happened after her
The new version includes all the innovations described above.

Version 2.0.2. December 2007

Rails simply did level up compared to the 1.xx series. Who worked with it will understand me. What happened then?
There is an opportunity to specify an engine for caching:

Copy Source | Copy HTML ActionController::Base .cache_store = :memory_store ActionController::Base .cache_store = :file_store, "/path/to/cache/directory" ActionController::Base .cache_store = :drb_store, "druby://localhost:9192" ActionController::Base .cache_store = :mem_cache_store, "localhost" 

There is also an opportunity to make your own .
Simplified work with time zones .

Copy Source | Copy HTML # Set the local time zone Time .zone = "Pacific Time (US & Canada)" # All times will now reflect the local time article = Article.find(:first) article.published_at #=> Wed, 30 Jan 2008 2:21:09 PST -08:00 # Setting new times in UTC will also be reflected in local time article.published_at = Time .utc( 2008 , 1 , 1 , 0 ) article.published_at #=> Mon, 31 Dec 2007 16 : 00 : 00 PST - 08 : 00 

Name_scope appeared:

Copy Source | Copy HTML class User < ActiveRecord::Base named_scope :active, :conditions => {:active => true } named_scope :inactive, :conditions => {:active => false } named_scope :recent, lambda { { :conditions => [ 'created_at > ?' , 1 .week.ago] } } end # Standard usage User .active # same as User . find (:all, :conditions => {:active => true }) User .inactive # same as User . find (:all, :conditions => {:active => false }) User .recent # same as User . find (:all, :conditions => [ 'created_at > ?' , 1 .week.ago]) # They 're nest-able too! User.active.recent # same as: # User.with_scope(:conditions => {:active => true}) do # User.find(:all, :conditions => [' created_at > ?', 1 .week.ago]) # end

Inheritance has_one got the option: through:

Copy Source | Copy HTML class Magazine < ActiveRecord::Base has_many :subscriptions end class Subscription < ActiveRecord::Base belongs_to :magazine belongs_to : user end class User < ActiveRecord::Base has_many :subscriptions has_one :magazine, :through => : subscriptions, :conditions => [ 'subscriptions.active = ?' , true ] end 

Introduction of "dirty objects":

Copy Source | Copy HTML article = Article.find(: first ) article.changed? #=> false # Track changes to individual attributes with # attr_name_changed? accessor article.title #=> "Title" article.title = " New Title" article.title_changed? #=> true # Access previous value with attr_name_was accessor article.title_was #=> "Title" # See both previous and current value with attr_name_change accessor article.title_change #=> ["Title", " New Title"]

That allowed to generate such sql, queries that send only modified fields to the database:

Copy Source | Copy HTML article = Article.find(: first ) article.title #=> "Title" article.subject #=> "Edge Rails" # Update one of the attributes article.title = " New Title" # And only that updated attribute is persisted to the db article. save #=> " UPDATE articles SET title = 'New Title' WHERE id = 1" 

Now you can specify from which gems and which version your Rails application depends on:

Copy Source | Copy HTML Rails::Initializer.run do |config| # Require the latest version of haml config.gem "haml" # Require a specific version of chronic config.gem "chronic", :version => '0.2.3' # Require a gem from a non-standard repo config.gem "hpricot", :source => "http://code.whytheluckystiff.net" # Require a gem that needs to require a file different than the gem 's name # Ie if you normally load the gem with require ' aws/s3 ' instead of # require ' aws-s3' then you would need to specify the :lib option config.gem "aws-s3", :lib => "aws/s3" end

Almost at the same moment Rails-developer had to forget about hemorrhoids with migrations of the type xxx_name. Naming migrations became UTC-based:

Copy Source | Copy HTML > script/generate migration one create db/migrate/20080402122512_one.rb 

Version 2.1. June 2008

The name of the partial was determined automatically:

Copy Source | Copy HTML render :partial => 'employees' , :collection => @workers, :as => :person 

To validate validates_length_of, an option was added: tokenizer:

Copy Source | Copy HTML validates_length_of :article, :minimum => 10 , :too_short => "Your article must be at least %d words in length." , :tokenizer => lambda {|str| str.scan(/\w+/) } 

In the find method of the models option: joins, you can specify not only a string, while respecting all the SQL rules, but also simply the names of the models:

Copy Source | Copy HTML class Article < ActiveRecord::Base belongs_to :user end class User < ActiveRecord::Base has_many :articles end # Get all the users that have published articles User .find(:all, :joins => :article, :conditions => [ "articles.published = ?" , true ]) 

And the option: conditions can be described in more detail:

Copy Source | Copy HTML # Get all the users that have published articles User.find(:all, :joins => :article, :conditions => { :articles => { :published => true } }) 

Memoization appeared, which allowed us to forget about || =, but personally I somehow didn’t take it.

Copy Source | Copy HTML class Person < ActiveRecord::Base def social_security decrypt_social_security end # Memoize the result of the social_security method after # its first evaluation (must be placed after the target # method definition). # # Can pass in multiple symbols: # memoize :social_security, :credit_card memoize : social_security ... end @person = Person .new @person. social_security # decrypt_social_security is invoked @person. social_security # decrypt_social_security is NOT invoked

Something called “Nested Model Mass Assignment” appeared (how to translate it?), In general, after the example, everything becomes clear:

Copy Source | Copy HTML class User < ActiveRecord::Base validates_presence_of :login has_many : phone_numbers end class PhoneNumber < ActiveRecord::Base validates_presence_of :area_code, :number belongs_to :user end class User < ActiveRecord::Base validates_presence_of :login has_many : phone_numbers , :accessible => true end ryan = User .create( { :login => 'ryan' , : phone_numbers => [ { :area_code => '919' , :number => '123-4567' }, { :area_code => '920' , :number => '123-8901' } ] }) ryan. phone_numbers .count #=> 2 # one more way class User < ActiveRecord::Base ... def phone_numbers =(attrs_array) attrs_array.each do |attrs| phone_numbers .create(attrs) end end end

Do not forget about the presentation:

Copy Source | Copy HTML <% form_for @user do |f| %> <% = f.text_field :login %> <% fields_for :phone_numbers do |pn_f| %> <% = pn_f.text_field :area_code %> <% = pn_f.text_field :number %> <% end %> <% = submit_tag %> <% end %> 

Thus, all the logic can be concluded in the model, and the controller will look like:

Copy Source | Copy HTML class UserController < ApplicationController # Create a new user and their phone numbers with mass assignment def new @user = User.create(params[:user]) respond_to do |wants| ... end end end 

All objects have a metaclass method. wtf

Around the same time, the “Standard Internationalization Framework” is being born, which, I think, no one has lost sight of and now uses in its projects.
An etag appeared, which allows (based on subsequent changes) very well managed with caching both on the server side and the client side. For more details I send to the most wonderful screencasts and article .
named_scope evolved , mini-example:

Copy Source | Copy HTML class Article < ActiveRecord::Base # Only get the first X results named_scope :limited, lambda { |num| { :limit = > num } } end # Get the first 5 articles - instead of Article.find(:all, :limit = > 5) Article.limited(5) #= > [ < Article id: ... > , < .. > ] 

Shallow Routes appeared . Note that in later versions this option no longer affects nested routes.
Meanwhile, thanks to Google Summer of Code, Joshua Peak made Rails thread safe. Since this was done Ruby on Rails has acquired a pool of connections to the database.

Version 2.2.2 October, 2008

There were two routes, IMHO, the options are very good: except and: only. Explanatory example:

Copy Source | Copy HTML # Only generate the :index route of articles map.resources :articles, :only = > :index # Generate all but the destroy route of articles map.resources :articles, :except = > :destroy # Only generate the non-modifying routes of articles map.resources :articles, :only = > [:index, :show] 

A supplement to named_scope has been published - default_scope:

Copy Source | Copy HTML class Article < ActiveRecord::Base default_scope :order = > 'created_at DESC' named_scope :published, :conditions = > { :published = > true } end Article.find(:all) #= > "SELECT * FROM `articles` ORDER BY created_at DESC" Article.published #= > "SELECT * FROM `articles` WHERE published = true ORDER BY created_at DESC"

It was decided to rename application.rb to application_controller.rb, which will take effect starting with Rails 2.3.
Partial evolved even more :

Copy Source | Copy HTML render :partial = > 'articles/article', :locals = > { :article = > @article } # Render the 'article' partial with an article local variable render 'articles/article', :article = > @article # Or even better (same as above) render @article # And for collections, same as: # render :partial = > 'articles/article', :collection = > @articles render @articles 

Appeared Object.try:

Copy Source | Copy HTML # No exceptions when receiver is nil nil.try(:destroy) #= > nil # Useful when chaining potential nil items User.admins.first.try(:address).try(:reset) 

Routes with .format at the end were removed. Hooray! Personally, I very rarely needed them. An example of how to use .format now:

Copy Source | Copy HTML formatted_article_path(article, :xml) = > article_path(article, :format = > :xml) formatted_new_article_path(:json) = > new_article_path(:format = > :json) 

In December 2008, the ability to generate your application based on a template was added. More details.
A little later, Rails Metal appears, which allows you to give a response to the client, bypassing the MVC model. Screencast in the subject .
named_scope becomes dynamic:

Copy Source | Copy HTML Article.find_by_published_and_user_id(true, 1) #= > "SELECT * FROM articles WHERE published = 1 AND user_id = 1" Article.scoped_by_published_and_user_id(true, 1).find(:all, :limit = > 5) #= > "SELECT * FROM articles WHERE published = 1 AND user_id = 1 LIMIT 5" Article.scoped_by_published(true).scoped_by_user_id(1) #= > "SELECT * FROM articles WHERE published = 1 AND user_id = 1 

After the new year, HTTP Digest Authentication appears.
In the continuation of the Nested Model Mass Assignment appears Nested Object Forms . Great innovation.

Version 2.3.0RC1. February, 2009

The latest innovation in RoR is Batched Find. Just an example:

Copy Source | Copy HTML Article.each { |a| ... } # = > iterate over all articles, in chunks of 1000 (the default) Article.each(:conditions = > { :published = > true }, :batch_size = > 100 ) { |a| ... } # iterate over published articles in chunks of 100 Article.find_in_batches { |articles| articles.each { |a| ... } } # = > articles is array of size 1000 Article.find_in_batches(:batch_size = > 100 ) { |articles| articles.each { |a| ... } } # iterate over all articles in chunks of 100 class Article < ActiveRecord::Base named_scope :published, :conditions = > { :published = > true } end Article.published.find_in_batches(:batch_size = > 100 ) { |articles| ... } # iterate over published articles in chunks of 100

Version 2.3.0. ?, 2009

We are not waiting for you.
')
I draw the attention of developers. Use the version of RoR, which you have in the project to the maximum, do not reinvent the wheel :) Good luck and have a nice day. Comments and corrections are welcome.

Source: https://habr.com/ru/post/53367/

All Articles