require 'roxy'
class Person
  include Roxy::Moxie
  attr_accessor :first, :last, :parents
  proxy :parents do
    def divorced?
      proxy_target.size > 1 and proxy_target.collect { |parent| parent.last }.uniq.size > 1
    end
  end
end

现在你就可以直接在person.parents上直接调用divorced?方法了，


-> person.parents.divorced? => true|false


当然如果只是简单的修改find条件，那么named_scope无疑是个更好的选择，更多信息及安装方法请看这里。

这本书目前只完成了第一章，不过出版社已经迫不及待的发售了Shortcut版本（有点类似电影宣传片，但是价格不菲），这本书的作者Stefan Kaes就是Letrails上访问量最高的文章之一《Rails应用优化指南》的作者。书中的内容主要来自作者参与Rails Core开发以及他自己的几个Rails咨询项目中的经验。

至于Shortcut，只有48页，主要讲了一些Ruby编程的最佳实践，有些内容《Rails应用优化指南》也有讲到，对于编写高质量的Ruby代码还是有帮助的，但12刀的价格，尽管RMB持续升值，性价比仍然过低（且大部分内容根据目录标题应该都可以谷歌到），还是期待整书面世。

e1 = [1, 2, 3, 4].each
e2 = [10, 11, 4].each
loop {
  p e1.next + e2.next
}
#prints 11, 13 and 7

还是蛮不错的，不用担心听不懂，因为Matz的英语实在是。。。

如果你是Ruby Metaprogramming的新手，那么下面的代码或许会帮你找到一点感觉：


class Object
  # The hidden singleton lurks behind everyone
  def metaclass; class << self; self; end; end
  def meta_eval &blk; metaclass.instance_eval &blk; end
  # Adds methods to a metaclass
  def meta_def name, &blk
    meta_eval { define_method name, &blk }
  end
  # Defines an instance method within a class
  def class_def name, &blk
    class_eval { define_method name, &blk }
  end
end

摸不着头脑？没关系，先将这个文件保存起来，会用得到的，下面我们正式开始：

在讲解Metaclass之前，让我们先来看看什么是class和object？（注意，小写开头的class和object指代广义的类和对象，而大写开头的Class和Object则指代Ruby中的Class和Object class）


>> class MailTruck
>>   attr_accessor :driver, :route
>>   def initialize( driver, route )
>>     @driver, @route = driver, route
>>   end
>> end
>> m = MailTruck.new( "Harold", ['12 Corrigan Way', '23 Antler Ave'] )
=> #<MailTruck:0x81cfb94 @route=["12 Corrigan Way", "23 Antler Ave"],
        @driver="Harold">
>> m.class
=> MailTruck


我们可以将object看作是变量或者说实例变量的载体，一个MailTruck object一旦初始化完成，就将拥有两个变量：@driver以及 @route。它们可以存储任何其它对象：


>> m.instance_variable_set( "@speed", 45 )
=> 45
>> m.driver
=> "Harold"


让我们来看看这是如何实现的，当Ruby执行到attr_accessor :driver这句话时，它就为MailTruck class定义了一对读写方法：driver以及driver=，也就是说实例变量保存在object中，而实例变量的访问方法（accessor method）保存在class中。

这是一个需要牢记的重要概念：方法存储在class中，而非object。

但class也是object，这个想必你们都知道，因为在Ruby中，一切皆对象，也就是说，在object上运行的方法，也可以在class上运行：


>> m.object_id
=> 68058570
>> MailTruck.object_id
=> 68069450


但是我们前面又讲过，变量保存在object中，而方法保存在class中，既然class也是object，那class的方法必然保存在另一个class中，这样岂不是无限循环了？

但事实不是这样的，这一切都终止在Object class，实际上，Ruby中的class并不是一个真正的object，我们可以从Ruby源代码中看到如下定义：


struct RObject {
  struct RBasic basic;
  struct st_table *iv_tbl;
};
struct RClass {
  struct RBasic basic;
  struct st_table *iv_tbl;
  struct st_table *m_tbl;
  VALUE super;
};


我们可以看到，class有一个m_tbl存储所有的方法，还有一个super字段存储parent class，但是object没有，不过对于Ruby程序员来说，class又符合作为一个object所必须的条件：可以存储变量，并且可以回溯到Object class，因此，我们可以将它当作object对待：


>> m = MailTruck.new
=> #<MailTruck:0x815c45c>
>> m.class
=> MailTruck
>> MailTruck.class
=> Class
>> MailTruck.superclass
=> Object
>> Class.superclass.superclass
=> Object
>> Class.class
=> Class
>> Object.class
=> Class
>> Object.superclass
=> nil


上面class之间复杂的关系是否让你抓狂，下面这个图或许可以让问题简单点：

从这张图我们可以看出：

• Class继承自Object
• Object的class是Class
• Class的class是它自己
• MailTrunk以及其它所有自定义class都是Class的object
• MailTrunk以及其它所有自定义class都继承自Object

简单的说，就是，在继承层次上，所有class都继承自Object，同时，所有class都是Class的对象，而Class又继承自Object，因此所有class也都是Object的对象，结论：所有class既继承自Object，同时又是Object的对象。

那么什么是metaclass呢？根据wikipedia的解释，metaclass就是定义其它class的class。但这个定义明显不适用于 Ruby，因为在Ruby中对应这个概念的就是Class，让我们看看在Ruby中改如何向Class添加一个方法，然后在定义class是使用它：


>> class Class
>>   def attr_abort( *args )
>>     abort "Please no more attributes today."
>>   end
>> end
>>
>> class MyNewClass
>>   attr_abort :id, :diagram, :telegram
>> end


是的，上面的代码打印出了”Please no more attributes today.“，现在我们可以在定义class时调用attr_abort了，是的，在Ruby中我们可以随时随地修改class的定义，但这不是 meta，这不过时普普通通的代码而已，那么究竟什么是Ruby metaclass呢？既然wiki的定义不适合，我们就需要自己定义一个，在我看来：”Ruby metaclass就是object用来重新它自己的class“。

现在，我们已经知道：object不能拥有方法。但有些时候你可能想让一个object拥有它自己的方法，那该如何办呢，答案就是metaclass：


>> require 'yaml'
>> class << m
>>   def to_yaml_properties
>>     [’@driver’, ‘@route’]
>>   end
>> end
>> YAML::dump m
— !ruby/object:MailTruck
driver: Harold
route:
  - 12 Corrigan Way
  - 23 Antler Ave


我们可以看到object m已经有了它自己的to_yaml_properties 方法，那么这个方法存储在哪里呢，它就存储在m的metaclass中，由于metaclass位于class继承层次的最下面，因此它将首先被发现，这也就意味着：定义在metaclass中的方法查找效率是最高的，这也正是metaclass的精髓所在。

或许你已经猜到了class << m 返回的就是object m的metaclass，但一般我们使用下面这种更直接的方式，它们的效果其实是一样的：


def m.to_yaml_properties
  ['@driver', '@route']
end


现在是时间回头看看我们在文章开头给出的那段Ruby代码了，在IRB中require它，然后我们看看该如何来使用它（如果后面的例子都将依赖开始的代码）。


>> m.metaclass
=> #<Class:#<MailTruck:0x81cfb94>>
>> m.metaclass.class
=> Class
>> m.metaclass.superclass
=> #<Class:MailTruck>
>> m.metaclass.instance_methods
=> […, “to_yaml_properties”, …]
>> m.singleton_methods
=> [”to_yaml_properties”]


我们可以看到m.metaclass，它返回了一个class，但是这个class是附着在一个特定的object的，也就是说这个class中定义的方法将能被这个特定的object所调用。Ruby称这种特殊的class为virtual class。

接下来的问题就是：metaclass需要metaclass吗？可以试试下面的代码：


>> m.metaclass.metaclass
=> #<Class:#<Class:#<MailTruck:0x81cfb94>>>
>> m.metaclass.metaclass.metaclass
=> #<Class:#<Class:#<Class:#<MailTruck:0x81cfb94>>>>


是的，metaclass自己也有metaclass，因为它们自己也是object，但我们一般不需要使用metaclass的metaclass，因为意义不大，不过还是让我们来看看metaclass的嵌套：


>> m.meta_eval do
>>   self.meta_eval do
>>     self.meta_eval do
>>       def ribbit; "*ribbit*"; end
>>     end
>>   end
>> end
>> m.metaclass.metaclass.metaclass.singleton_methods
=> ["class_def", "metaclass", "constants", "meta_def",
    "attr_test", "nesting", "ribbit"]


class的metaclass的意义仅仅在于，你可以为某个class定义只有他自己才能访问的方法，除了这个目的，定义在class（或者metaclass）的metaclass中的方法没有任何意义，因为没人会访问它们。

另外需要注意一点，我们上面讲过，object的metaclass中的方法将优于object的class继承树中的方法被找到，但是metaclass 的metaclass则不会，也就是说m.metaclass.metaclass将只影响m.metaclass方法的查找，而不会影响m。

下面让我们来看看metaprogramming最为重要的一个技巧，这个技巧在Rails以及Ruby/X11等应用metaprogramming的项目中随处可见，如果你阅读了本文的其它部分，而错过了这一节，那就相当于你上了某门课程的所有课，却唯独逃了考试前最后一次划重点的课程一样。

在开始之前，让我们先来回顾下两个重要的概念：

1. class也是object，因此class也可以拥有实例变量
2. metaclass也可以拥有实例方法，但是对于它们所附着的object而言，这些方法变成了singleton方法，这些方法会优于类的继承树被找到。

现在让我们来看看class的实例变量，注意，我是指在class中使用实例变量，而不是class的method中：


class MailTruck
  @trucks = []
  def MailTruck.add( truck )
    @trucks << truck
  end
end

但是为什么不直接使用class 变量呢？


class MailTruck
  @@trucks = []
  def MailTruck.add( truck )
    @@trucks << truck
  end
end

它们两个看起来没什么区别，对吗？答案是否定的。基于以下两个原因，我们应该尽可能的用class变量来取代class实例变量：

1. 我们可以很清楚的区分出class变量，因为它们有两个@符合。
2. class变量可以被实例方法所引用，如果需要的话

例如，下面的代码工作正常：


class MailTruck
  @@trucks = []
  def MailTruck.add( truck )
    @@trucks << truck
  end
  def say_hi
    puts "Hi, I'm one of #{@@trucks.length} trucks!"
  end
end

而这段则不行：


class MailTruck
  @trucks = []
  def MailTruck.add( truck )
    @trucks << truck
  end
  def say_hi
    puts "Hi, I'm one of #{@trucks.length} trucks!"
  end
end

很明显，我们应该尽量避免使用class实例变量，而改为使用class变量。

同样，我们已经知道，所有的class方法都定义在metaclass中，这也是为什么我们可以使用self来定义class方法的原因：


class MailTruck
  def self.add( truck )
    @@trucks << truck
  end
end

这和下面这段代码是相同的：


class MailTruck
  class << self
    def add( truck )
      @@trucks << truck
    end
  end
end

大多数情况下，metaclass的instance method和class的instance variable一样，没什么用处。

不过当我们将类继承也考虑进来，那么情形就大为不同了，我们来看看下面这段代码：


class MailTruck
  def self.company( name )
    meta_def :company do; name; end
  end
end

现在，我们已经有了一个可以在MailTrunk以及它的child class的类定义中访问的company方法：


class HappyTruck < MailTruck
  company "Happy's -- We Bring the Mail, and That's It!"
end

在HappyTruck 中调用company方法会发生什么呢？meta_def做了些什么事情，从它的命名我们就可以看出了，它向HappyTruck class的metaclass添加了名为company的方法，这样做的真正意义就在于，company被添加到了HappyTruck class的metaclass中，而不是MailTruck。

这看起来很简单，但却很强大，不是吗？你可以通过定义简单的class method来向它的child class的metaclass添加方法，事实上，这也是Rails metaprogramming的秘密所在。

1. for是通过调用each实现，因此for更慢一些
2. for会在each的scope之外创建一个局部变量，这在某些情况下会引发问题

关于第二点，下面的代码可以很好的说明这个问题：


irb> [1, 2, 3].each do |m| puts m end
irb> puts m
NameError: undefined local variable or method `m' for main:Object
irb> for n in [1, 2, 3] do puts n; end
irb> puts n
=> 3


如果你不了解这一点，那么在某些特殊的情况下，你可能会遇到麻烦，Ruby Forum的某个用户提交的一段代码很好的说明了for可能引发的问题：


a = []
for n in [1, 2, 3] do
a << Proc.new {puts "#{n}"}
end
[1,2,3].each do |m|
a << Proc.new {puts "#{m}"}
end
a.each { |p| p.call }


运行结果：

3
3
3
1
2
3

很显然，for循环的结果不是我们所期待的，因此，结论就是：应该尽可能的使用each替代for循环。

更新：感谢ShiningRay，应该使用each代替for的真正原因是，for实际上是通过each实现的，但它在each的scope外面定义了一个同名变量，下面的代码可以说明问题：

>> a = “1\n2\n”
>> def a.each
>> yield(1)
>> end
>> for i in a
>> puts i
>> end
1
=> nil

也就是说“for i in [1, 2]”就相当于“i = nil；[1,2].each do |i|”，因此前面的结论是不正确的，for应该比each慢（没有进行过测试），这才是for真正的问题所在。

我们都知道，可以通过一下两种方式来构造正则：


irb> /ruby/
=> /ruby/
irb> Regexp.new('ruby')
=> /ruby/


但实际上还有一种：


irb> %r{ruby}
=> /ruby/


如同%w, %q一样，%r将一个字符串转换为一个正则，并且你不止可以使用{}作为起始，结束符：


irb> %r!ruby!
=> /ruby/
irb> %r|ruby|
=> /ruby/


实际上，你可以使用任何不在正则中出现的字符作为字符串的起始和结束符，比如@＃$%^&等等。

来自这里

2. alias 与 alias_method的区别

来自pragmati.st, 区别有3点：

1. alias是Ruby的一个关键字，而alias_method是Module类的一个方法
2. alias的参数就是方法本身（method identify），注意，不是字符串，也不是Symbol，alias_method的参数则是字符串或者symbol，并且使用逗号分隔。
3. alias_method可以重定义，而alias则不能


alias new_method_name old_method_name
alias_method :new_method_name, ld_method_name
alias_method 'new_method_name', 'old_method_name'


3. ruby 中的printf


irb> "my name is %s" % ['yzhang']
=> "my name is yzhang"
irb> "your score is %.2f" % [97.2835]
=> "your score is 97.28"


实际上就是String#% 方法。它接受一个数组作为输入。

简介

Flog是一个计算你的Ruby代码复杂度的工具，来自大牛Ryan Davis的seattle.rb项目。

安装

$ sudo gem install flog

使用

$ find . -name \*.rb | xargs flog

这条命令将会计算你当前目录下的所有.rb文件的复杂度。

Flog根据以下条件判断你的代码复杂度，得分越高，说明你的代码越复杂，

• eval，6分
• 分支语句，1.2分
• ==，1.2分
• puts，1.2分
• 赋值语句，1.2分
• Fixnum，0.4分

因此下面这段代码的得分就是11.2分：

图片来自RubyInside。

JRuby Inside的Feed订阅地址：http://feeds.feedburner.com/JRubyInside

• 完全兼容Ruby1.8.5版本
• 支持大部分Ruby builtin class
• 支持从Ruby内部定义及使用Java class
• Bean Scripting Framework（BSF）支持
• 多License支持（CPL/GPL/LGPL)

JRuby项目始于2001年，最初仅仅是对Ruby 1.6的简单porting，但是随着2006年9月Sun公司的介入，JRuby项目开始进入一个高速发展的阶段，随着1.0版本的发布，JRuby项 目的开发者宣称大部分兼容性Bug都已经得到了解决，现在”它基本可以工作了（It will just works！）！“

事实上，许多公司（Thoughtworks是最著名的），都期盼着JRuby项目能够释放Rails在企业应用开发上的强大动力，现在，随着 JRuby1.0的发布，让我们有理由相信，Rails进军企业级应用的那一天已经不远了，相信Ruby社区很快就会出现大量的基于JRuby的新应用以 及开发指南。