Ruby for Rails 最佳实践ⅩⅤ

第十五章 通过编程改进 ActiveRecord 模型

一、软模型改进与硬模型改进

1. 当在 ActiveRecord 模型类中编写一个新方法时，可以把方法区分为：被动方法（即那些仅仅获取数据并返回数据的方法）和主动方法（即那些生成新的数据结构的方法）

class Composer < ActiveRecord::Base

has_many :works

# 软改进

def editions

works.map {|work| work.editions }.flatten.uniq

end

# 硬改进

def whole_name

first_name + " " +

(if middle_name then middle_name + " " else "" end) +

last_name

end

end

2. 软模型改进与硬模型改进：本质区别

本质区别在于：软改进描述给 ActiveRecord 提供辅助；硬改进涉及产生新的数据。

二、模型的软编程改进

1. 通过软改进细化 Work 模型

（1）哪些发行商发行过该作品的版本

def publishers

editions.map {|e| e.publisher}.uniq

end

（2）该作品来自哪个国家

def country

composer.country

end

（3）哪些顾客订购过该作品

def ordered_by

editions.orders.map {|o| o.customer }.uniq

end

（4）该作品的基调是什么

def key

kee

end

2. 为顾客的业务建模

（1）该顾客有哪些未完成的订单

def open_orders

orders.find(:all, :conditions => "status = 'open'")

end

（2）该顾客当前订单中包含哪些版本

def editions_on_order

open_orders.map {|order| order.edition }.uniq

end

（3）该顾客曾经订购过哪些版本

def edition_history

orders.map {|order| order.edition }.uniq

end

（4）该顾客当前订单中包含哪些作品

def works_on_order

editions_on_order.map {|edition| edition.works }.flatten.uniq

end

（5）该顾客曾经订购过哪些作品

def work_history

edition_history.map {|edition| edition.works }.flatten.uniq

end

3. 改进 composer

（1）该作曲者的作品出现在哪些版本中

def editions

works.map {|work| work.editions }.flatten.uniq

end

（2）哪些发行商发行过包含该作曲者作品的版本

def publishers

editions.map{|edition| edition.publisher }.uniq

end

4. 对比软改进过程中的 Ruby 和 SQL

最高效、最快速的数据库记录提取方式是 SQL 代码。ActiveRecord 做的很多工作就是私底下将你的 Ruby 代码翻译为 SQL 语句，然后使用这些语句查询数据库。

为了提高执行速度，ActiveRecord 允许任何时候都可以使用 SQL。可是这样就失去了良好的 Ruby 外观，却获得了效率。

作为对比 Ruby/SQL 的例子，我们来看一下 Composer#editions 方法：

def editions

works.map {|work| work.editions }.flatten.uniq

end

该方法首先调用 works，无条件地搜集该作曲者的所有作品。调用 works 方法之后，ActiveRecord 的任务就完成了；该方法也是唯一的一个数据库查询，返回该作曲者的所有作品。剩下的都是纯 Ruby 代码：获取作品的所有版本（使用map），这些信息被存放在一个数组的数组中，然后使用 flatten 和 uniq 对该数组进行处理。最后，得到一个新数组。

下面是实现 editions 方法的另一种方式，使用 SQL 语句

def editions

Edition.find_by_sql("SELECT edition_id from editions_works

LEFT JOIN works ON editions_works.work_id = works.id

LEFT JOIN composers ON works.composer_id = composers.id

WHERE (composers.id = #{id})")

end

Ruby 程序员在使用 Ruby 编写程序时，知道它不是特别快的语言；在碰到严重的性能瓶颈时，他们把程序的某些部分编写为 C 扩展。而在 Rails 应用开发中，SQL 也扮演着类似的角色。

三、硬模型改进

1. 美化字符串属性（Work 类）

（1）调整作品的各乐器名的格式

def nice_instruments

instrs = instruments.map {|inst| inst.name }

ordered = %w{ flute oboe violin viola cello piano orchestra }

instrs = instrs.sort_by {|i| ordered.index(i) || 0 }

case instrs.size

when 0

nil

when 1

instrs[0]

when 2

instrs.join(" and ")

else

instrs[0...-2].join(", ") + ", and " + instrs[-1]

end

end

代码中使用了 %w{…} 构造一个字符串数组，用于存放规范的乐器名顺序

ordered = %w{ flute oboe violin viola cello piano orchestra }

接着，根据 ordered 数组中各个乐器的出现顺序（乐器名在数组中的索引序号）对 instrs 排序，如果出现不存在的乐器名，则它将出现在排序结果的最后面

instrs = instrs.sort_by {|i| ordered.index(i) || 0 }

（2） 调整作品号的格式

def nice_opus

if /^\d/.match(opus)

"op. #{opus}"

else

opus

end

end

（3） 美化的作品标题

def nice_title

t,k,o,i = title, key, nice_opus, nice_instruments

"#{t} #{"in #{k}" if k}#{", #{o}" if o}#{", for #{i}" if i}"

end

（4） 美化的版本标题（Edition.rb）

def nice_title

(title || works[0].nice_title) +

" (#{publisher.name}, #{year})"

end

2. 计算作品的年代（Work 类）

（1）作品出自哪个世纪

def century

c = (year - 1).to_s[0,2].succ

c += case c

when "21" then "st"

else "th"

end

c + " century"

end

（2）作品的更富描述性的时代信息

在 Work 类中定义一个常量

PERIODS = { [1650..1750, %w{ EN DE FR IT ES NL}] => "Baroque",

[1751..1810, %w{ EN IT DE NL }] => "Classical",

[1751..1830, %w{ FR }] => "Classical",

[1837..1901, %w{ EN }] => "Victorian",

[1820..1897, %w{ DE FR }] => "Romantic" }

然后加入该方法

def period

pkey = PERIODS.keys.find do |yrange, countries|

yrange.include?(year) && countries.include?(country)

end

PERIODS[pkey] || century

end

3. 剩余的顾客业务（Customer 类）

（1） 顾客喜好排名

def rank(list)

list.uniq.sort_by do |a|

list.select {|b| a == b }.size

end.reverse

end

def composer_rankings

rank(edition_history.map {|ed| ed.composers }.flatten)

end

def instrument_rankings

rank(work_history.map {|work| work.instruments }.flatten)

end

（2）计算订购的副本的数目

def copies_of(edition)

orders.find(:all, :conditions => "edition_id = #{edition.id}").size

end

（3）未偿余额

方法一：

def balance

acc = 0

open_orders.each do |order|

acc += order.edition.price

end

"%.2f" % acc

end

方法二（递增的累计计算可以使用 inject 方法自动完成）：

def balance

"%.2f" % open_orders.inject(0) do |acc,order|

acc + order.edition.price

end

end

（4）顾客结帐

方法一：

def check_out

orders.each do |order|

order.status = "paid"

order.update

end

end

方法二：

def check_out

orders.each do |order|

order.update_attribute(:status, "paid")

end

end

四、用类方法扩展模型功能

1. 确定一组作品的所有版本（app/models/edition.rb）

def Edition.of_works(works)

works.map {|work| work.editions }.flatten.uniq

end

2. 获取库存作品的所有时代（app/models/work.rb）

def Work.all_periods

find(:all).map {|c| c.period }.flatten.uniq.sort

end

3. 确定作品的销售排名（app/models/work.rb）

def Work.sales_rankings

r = Hash.new(0)

find(:all).each do |work|

work.editions.each do |ed|

r[work.id] += ed.orders.size

end

end

r

end

散列是无序的，要使用这个散列，还需要对它进行排序：

rankings = Work.sales_rankings

r_sorted = rankings.sort_by {|key,value| value }

4. 确定作曲者的销售排名（app/models/composer.rb）

def Composer.sales_rankings

r = Hash.new(0)

Work.sales_rankings.map do |work,sales|

r[work.composer.id] += sales

end

r

end