zhaowenchina

How to write a template engine in less than 30 lines of code

zhaowenchina — Fri, 24 Apr 2015 10:07:37 +0800

庆祝「翻译」节点诞生，发一篇译文。

原文： How to write a template engine in less than 30 lines of code

声明：本文基于模板引擎库 mote。其简洁的代码赋予了我灵感，如果你之前没有探索过模板引擎的内部实现，相信这会是一个绝佳的学习范例。

前言：什么是模板？

模板引擎是一种使用模板来生成文本（字符串）的工具，它还有助于将呈现逻辑与应用逻辑分离。

除非你正挣扎于某些历史悠久的软件代码中（或者你开发的是没有用户界面的软件），否则你极有可能已经接触过模板引擎了。

但是你有没有思考过模板引擎的工作原理呢？你尝试过自己构建一个吗？如果我们瞥一眼主流的模板引擎的代码库，你会看到有几百行 (erb)的代码，甚至几千行 (erubis)。即使是名叫 slim 的家伙也并没有那么苗条。

所以你或许会觉得处理模板是一个相当复杂的问题，然而下面我会一步步地向你展示其实你可以只用少量代码就构建出一个模板引擎。

那让我们开始吧。

定义特性

本文我们将要实现的模板引擎只有两条规则：

以 % 开头的行会被解释为 Ruby 代码。
可以把 Ruby 代码插入到任何行中 {{ ... }} 符号的中间。比如我们可以使用 {{ article.title }}。

完了？就两条规则？没错，记住，第一条规则让我们可以访问 Ruby 的一切，也就是说所有常见的模板特性（比如循环、调用上层函数、嵌入 partial 等）都可以靠这条规则来实现。如此简单的特性甚至还带来了一个额外的好处：你不需要去学一个新的模板语言或者 DSL，因为你已经会 Ruby 了。

你可以这样来调用其他模板：

% render("path/to/template.template", {})

也可以写注释：

% # this is a comment

或者执行 blocks：

% 3.times do |i|
{{i}}
% end

根据上面的特性，我们可以来编写一个示例模板：

<html>
<body>
% if access == 0
  <div> no access :( </div>
% else
  <ul>
  % data.each do |i|
    <li>{{i}}</li>
  % end
  </ul>
% end
% # comments are just normal ruby comments
</body>
</html>

下面我们称这个模板为 index.template。

下面我们要做的就是怎样编写一个方法来解析这个模板并输出正确的字符串。在此之前，我们先来看一个中间步骤：如何使用纯粹的 Ruby 代码来输出 HTML。

与 index.template 行为相同的 render 函数

在模板引擎出现以前，你同样可以使用纯 Ruby 来达到与 index.template 一样的效果，就像下面的代码：

def render_index(access, data)
  output = "" # 一个新的字符串，用来存放输出的内容
  output << "<html>"
  output << "<body>"

  if access == 0
    output << "<div> no access :( </div>"
  else
    output << "<ul>"
    data.each do |i|
      output << "<li>#{ i }</li>"
    end
    output << "</ul>"
  end

  output << "</body>"
  output << "</html>"

  return output
end

把它粘贴到 IRB 中试试：

>> render_index(0,["foo", "bar"])
=> "<html><body><div> no access :( </div></body></html>"
>> render_index(1,["foo", "bar"])
=> "<html><body><ul><li>foo</li><li>bar</li></ul></body></html>"

假如你的应用程序涉及的范围非常有限，或许你就根本用不着模板引擎，这样就大功告成了！你可以根据需要自己编写 render_index()、render_header()、render_footer() 方法。PHP 本身其实就是一个模板引擎，这也解释了为什么 PHP 社区的人们会经常这么做。

然而我们来看 render_index() 的目的是为了探寻如何将 index.template 转换成 render_index() ，并将转换的方法共通化，这样我们的模板引擎就出来了。我们并不想真的去编写 render_index()、render_header()、render_footer() 方法，也不想用代码生成器来实现。我们想要的是能够动态生成一个行为类似 render_index() 的方法，而不是亲手来写 render_index() 方法的代码。

在看具体的实现方式之前，我们再来看一个中间步骤：

def define_render_index()

  func = "" # 空字符串，用来存储构建方法的字符串
  func << "def render_index(access, data) \n"
  func << "output = \"\" \n"
  func << "output << \"<html>\" \n"
  func << "output << \"<body>\" \n"
  func << "if access == 0\n"
  func << "  output << \"<div> no access :( </div>\" \n"
  func << "else\n"
  func << "   output << \"<ul>\" \n"
  func << "      data.each do |i|\n"
  func << "        output << \"<li> \#{ i } </li>\" \n"
  func << "      end \n"
  func << "   output << \"</ul>\" \n"
  func << "end\n"
  func << "  output << \"</body>\" \n"
  func << "  output << \"</html>\" \n"
  func << "  return output \n"
  func << "end\n"

  eval(func)
end

把它粘贴到 IRB 中并调用：

>> define_render_index() 
=> nil
>> render_index(1, ["foo", "bar"])
=> "<html><body><ul><li>foo</li><li>bar</li></ul></body></html>"

现在我们就得到一个更为完整的蓝图了：我们可以将原始的模板逐行转换为一系列字符串，然后修改这些字符串使其能够被 Ruby 解释。生成了这个方法以后，在调用它时就会执行我们所期望的模板的行为。

上面这个逐行转换的过程就是我们的 parse 方法的根基，下面就让我们具体来看。

Parse 方法

1. 使用 Proc

我们不想让 func 字符串像 define_render_index() 一样以一个具名函数开头，所以我们用 Proc 并将其保存至一个变量，有需要时就 .call 它。

2. 设定 Proc 的变量

define_render_index() 还写死了其中的变量：access 和 data。但我们需要将变量名传给 parse 函数，这样才能构建定义 Proc 的字符串。这里我们把变量名直接以字符串形式传递给 parse 方法，就像这样：

parse(template, "access, data")

3. 将模板逐行转译成函数字符串

上面的 define_render_index() 已经告诉我们逐行处理模板来创建一个新的 Ruby 方法时所需遵循的规则了。这些规则就是：

所有的双引号必须被转义，每一行的内容用双引号围起来，并在每一行的最后添加换行符 "\n"。
如果行的第一个字符（不包括空格）是 %，就把 % 删除。

变换前:
  % if data.empty? 
变换后:
  "if data.empty?\n"

其他的所有行都在前面加上 "output <<"

变换前:
  <html>
变换后:
  "output << \"<html>\" \n"

4. {{ ... }} 会被变换为 #{ ... }

我们会使用正则表达式来实现这一点

变换前:
  <li>{{ i }}</li> 
变换后:
  "output << \"<li> \#{ i } </li>\" \n"

要运用上述规则，我们首先用 .split("\n") 将原始模板文件分割成数组，这样数组中的每个元素就是模板文件的每一行了。然后循环这个数组来构建 func 字符串，最后将其 eval。

我们最终得到的 parse 函数如下：

def parse(template,vars = "")
  lines = File.read(template).split("\n")

  func = "Proc.new do |#{vars}| \n output = \"\" \n "

  lines.each do |line|
    if line =~ /^\s*(%)(.*?)$/
     func << " #{line.gsub(/^\s*%(.*?)$/, '\1') } \n" 
    else
     func << " output << \" #{line.gsub(/\{\{([^\r\n\{]*)\}\}/, '#{\1}') }\" \n "
    end
  end

  func << " output; end \n "

  eval(func)
end

你可以在 IRB 中亲自尝试一番：

>> index = parse("index.template", "access, data")
=> nil
>> index.call(1,["Foo"]) 
=> " <html>\n <body>\n<ul>\n<li>foo</li> \n</ul>\n </body>\n </html>\n"

大功告成了！就这么几行代码，你就实现出一个颇为强劲的模板引擎了。由于没有涉及太多多余的功能，我们将复杂度降到了最低，也提高了模板语言的清晰程度。复杂度的降低能够让应用程序条例更清晰，更不容易出错，还能加快开发特性的速度。

它能扩展（Scale）吗？

上面的代码恐怕不行！但是 mote，也就是本文的灵感来源，当然可以。mote 附带了一些 helper 方法和缓存功能，我们已经成功将其运用在了各种大型的 Web 应用中。更不用提 mote 的速度相当快。

同时我还想就其简洁这个显著的特点说两句——虽然 mote 的体积极其小，但对于其要解决的问题给出了一个专注而又完整的解决之道。

希望这篇文章会对从未探寻过模板引擎的人或者想要做一个模板引擎的人有所帮助。欢迎留下你的评论或者反馈。

Matz 最新作《关于 mruby 的一切》电子书发布了

zhaowenchina — Tue, 06 May 2014 17:44:30 +0800

购买地址： http://www.ituring.com.cn/book/1339

本书是 Matz 在《日经 Linux》杂志上关于 mruby 专栏文章的合集。 mruby 已于数月前发布了 1.0 版本。如果你对 mruby 感兴趣，这本小书是你入门的不二之选。

我是本书的译者。说实话对 mruby 的理解并不深入，因此难免有所疏漏。欢迎大家指教：）

Rails 4.1 的新特性 (译)

zhaowenchina — Wed, 09 Apr 2014 21:06:21 +0800

首发： http://zhaowen.me/blog/2014/04/09/whats-new-in-rails-4-dot-1/ 原文： What's new in Rails 4.1

如果你还不知道的话，Rails 4.1 已经于今天正式发布了！虽然只是版本的小更新，但还是新引入了诸多激动人心的新特性。本文列出了其中几个最让我欣喜的新特性，并介绍了为什么我觉得它们很有用。

Action Mailer 预览

测试 Rails 的邮件模板一直以来都很不方便。目前我的测试流程为：

改动邮件模板
通过 rails console 发送邮件
在浏览器中查看输出内容
重复上述步骤

虽然 Letter Opener gem 提供了一些便利，但还远远不够理想。幸运的是，@pixeltrix 通过一番努力将 MailView gem 集成进了 Rails 4.1。现在你可以轻易地为 mailer 创建 preview 并在浏览器中进行预览了 http://localhost:3000/rails/mailers：

# In /test/mailers/previews/notifier_preview.rb
class NotifierPreview < ActionMailer::Preview
  def welcome
    # Mock up some data for the preview
    user = FactoryGirl.build(:user)

    # Return a Mail::Message here (but don't deliver it!)
    Notifier.welcome(user)
  end
end

需要注意的是，虽然默认情况下 preview 文件位于 test 目录下（可以通过 config.action_mailer.preview_path 修改），但其实它运行于 development 环境。因此，如果你要用 FactoryGirl 等 gem 来生成数据，需要确保 Gemfile 中这些 gem 也在 development 的 group 下面。

如果你的 app 没有 test 目录（比如 rspec 用户），你可能会将默认的 config.action_mailer.preview_path 修改成类似 /app/mailer/previews 的路径。但请注意，/app 目录在 production 环境下是即时加载（eager-loaded）的，所以或许这并不是 preview 文件的最佳存放之处。

该特性的延伸阅读：

Active Record Enums

你曾经在 model 中使用多个 boolean 字段来表示一个复杂的状态吗？我绝对这么干过，并且代码很快就变得无法控制了。

救星 Enums 来了！

class Bug < ActiveRecord::Base
  # Relevant schema change looks like this:
  #
  # create_table :bugs do |t|
  #   t.column :status, :integer, default: 0 # defaults to the first value (i.e. :new)
  # end

  enum status: [ :new, :assigned, :in_progress, :resolved, :rejected, :reopened ]

  belongs_to :assignee, class_name: 'Developer'

  def assignee=(developer)
    if developer && self.new?
      self.status = :assigned
    else
      self.status = :new
    end

    super
  end
end

Bug.resolved           # => a scope to find all resolved bugs

bug.resolved?          # => check if bug has the status :resolved

bug.resolved!          # => update! the bug with status set to :resolved

bug.status             # => a symbol describing the bug's status

bug.status = :resolved # => set the bug's status to :resolved

在内部，与这些状态在数据库中相对应的是整数值，以节省空间。同样值得一提的是，enum 宏所添加的方法是通过 mix-in 一个 module 来实现的。这意味着你可以方便地在 model 中重写它们并使用 super 来调用原来的实现。

使用该特性时还有如下一些注意事项：

I. 不要被其名字所迷惑，在一些数据库中并不使用 ENUM 类型来实现该特性。状态和其对应的整数值的匹配是通过 model 文件来维护的。所以一旦定义完 enum 的 symbol 后，你就不应该再去改动其顺序了。可以明确地指定 mapping 来删除不再使用的状态：

class Bug < ActiveRecord::Base
  enum status: {
    new: 0,
    in_progress: 2,
    resolved: 3,
    rejected: 4,
    reopened: 5
  }
end

II. 避免在一个类的不同 enum 中使用相同的名字！这样会使 Active Record 很迷茫！

class Bug < ActiveRecord::Base
  enum status: [ :new, ... ]
  enum code_review_status: [ :new, ... ] # WARNING: Don't do this!
end

III. 如果你要使用自定义的 scope 来查询 enum 字段，需要传入对应的整数而不是 symbol。你可以使用宏所添加的常量来访问 enum-integer 的匹配：

class Bug < ActiveRecord::Base
  scope :open, -> {
    where('status <> ? OR status <> ?', STATUS[:resolved], STATUS[:rejected])
  }
end

IV. 目前，dirty tracking 方法（比如 status_was?）还无法用于 enum（目前返回的是整数值而不是 symbol 值）。此问题应该在正式版发布前会修复（进度参见 #13267）（译者注：原文写于 Beta 版发布时，现在正式版已修复。）

该特性的延伸阅读：

Action Pack Variants

作为 Web 开发人员，应该已经意识到我们已经全面过渡到了后 PC 时代。虽然我钟爱于响应式设计，但它并不是解决跨设备网页显示问题的银弹。多数情况下，更合适的方法是为特定的设备种类定制 view 来显示最恰当的内容。

有了 Action Pack Variants 以后，在 Rails 4.1 中实现起来就容易多了：

class ApplicationController < ActionController::Base
  before_action :detect_device_variant

  private

    def detect_device_variant
      case request.user_agent
      when /iPad/i
        request.variant = :tablet
      when /iPhone/i
        request.variant = :phone
      end
    end
end

class PostController < ApplicationController
  def show
    @post = Post.find(params[:id])

    respond_to do |format|
      format.json
      format.html               # /app/views/posts/show.html.erb
      format.html.phone         # /app/views/posts/show.html+phone.erb
      format.html.tablet do
        @show_edit_link = false
      end
    end
  end
end

上面的示例用了 before_action 使 HTTP 的 User-Agent 消息头匹配给定的关键字，并相应地赋值给 request.variant。在 respond_to 的 block 中通过指定所支持的 variant，Rails 会根据特定的 format 和 variant 的组合来 render 相应的模板。你还可以传一个 block 来指定某个 variant 的情况下要执行的代码。

实际上你甚至可以将声明省略——只要在 views 目录下有对应的模板文件，Rails 就会自动匹配上。而如果某个 variant 没有专门的模板，Rails 会退一步去加载该 format 默认的模板（比如 show.html.erb）。因此你可以在两个 variant 之间共享模板。在上面的示例中，如果不存在 /app/views/posts/show.html+tablet.erb， tablet variant 就会重用默认模板。

虽然在介绍该特性时，大多数示例都会使用 User-Agent 消息头，但值得注意的是 Rails 中的实现完全是不可预知的。在渲染模板之前，request.variant 可能是基于任何条件被赋值的，例如基于请求的域名（或子域名）、HTTP 消息头、session 数据、甚至是抛硬币的结果。

这就使得该特性具有相当的灵活性，可以用于很多用途，例如 API 版本控制、A/B 测试、甚至可以用来做特性演示！

该特性的延伸阅读：

Application Message Verifier

Rails 4.1 还引入了一个内置的 helper 来生成基于 HMAC 的加密消息。消息验证以前被用于加密 Cookies 等高端操作，然而现在已经可以方便地将其用于其他一些用途了。

例如，你可以实现一个无状态的「重置密码」功能而无须在数据库中存储 token：

class User < ActiveRecord::Base
  class << self
    def verifier_for(purpose)
      @verifiers ||= {}
      @verifiers.fetch(purpose) do |p|
        @verifiers[p] = Rails.application.message_verifier("#{self.name}-#{p.to_s}")
      end
    end
  end

  def reset_password_token
    verifier = self.class.verifier_for('reset-password') # Unique for each type of messages
    verifier.generate([id, Time.now])
  end

  def reset_password!(token, new_password, new_password_confirmation)
    # This raises an exception if the message is modified
    user_id, timestamp = self.class.verifier_for('reset-password').verify(token)

    if timestamp > 1.day.ago
      self.password = new_password
      self.password_confirmation = new_password_confirmation
      save!
    else
      # Token 过期
      # ...
    end
  end
end

class Notifier < ActionMailer::Base
  def reset_password(user)
    @user = user
    @reset_password_url = password_reset_url(token: @user.reset_password_token)
    mail(to: user.email, subject: "Your have requested to reset your password")
  end
end

这样一来，重置密码所需的所有信息都包含在链接中了，没必要在数据库中存储信息。这也能用于 OAuth 等（state 参数）。

使用该特性时，需要重点防范重放攻击。以上面的代码为例，如果我们没有使用 timestamp 来检验是否过期，万一邮件落到了居心不良的人手中，这个 URL 就可以随时用来重置用户的密码！

另外，用来加密消息的 key 基于应用程序的 secret_key_base 以及你加入的「盐值（salt）」（本例中为 User-reset-password）。改变其中一个，就会使得之前的加密消息全部无效。

Spring

根据你使用的 gems，启动一个 Rails app 平均需要 5 秒钟时间。意味着每次运行测试都会浪费 5 秒钟，哪怕你只是运行一个单独的测试用例！如果你遵循 TDD，你每天大约会运行 50 次测试。这么算的话，过去 5 年中就浪费了整整 5 天时间！

我们终于时来运转，由 Rails 4.1 生成的新应用在内部集成了预加载器 Spring。

Spring 使你的应用程序运行于后台，所以你就不必每次运行测试、rake task 或 migration 时都要启动应用程序了。如果你熟悉 Zeus 或 Spork 等 gem，就不会对此感到陌生。然而 spring 使用 binstub 包装了常用的 Rails 命令（默认为 rake 和 rails），因此如果 ./bin 在你的 PATH 中，那么什么都不用做就能提速不少了！

我在自己的项目中试了一下，使用了 spring 后每次运行测试都能节省近 5 秒钟。我能因此得到 5 天假期吗？:)

你可以阅读 Spring README 来了解它的工作原理，以及如何在既有的项目中引入它。

该特性的延伸阅读：

其他新特性

这些都只是本次更新内容的一部分。还有很多其他可能对你有用的新特性，比如使用 secrets.yml 来记录敏感数据、在测试中控制时间、更好的 JSON 处理、Module#concerning、to_param 宏等等。我建议你通过更新日志来查看所有的变更点！

Ruby 实现的简易推荐系统 (译)

zhaowenchina — Tue, 25 Mar 2014 21:29:40 +0800

首发：http://zhaowen.me/blog/2014/03/25/ruby-recommendation-system/ 原文：Simple recommendation system written in Ruby

我在求职，于是昨天我回顾了一下以前做过的 Rails 项目，试图能给我的简历添上几笔。我找到了一个有意思的老项目，我在其中实现了推荐系统。但也没有很出彩，只是基于博客文章的标签做了推荐。我决定拿出其中的一些代码来写一篇文章。

推荐系统的算法基于 Jaccard 系数，也被称为 Jaccard 相似度系数。Jaccard 系数是由植物学家 Paul Jaccard 提出的，是用来体现样本相似性和差异性的数值。

运作原理

取出当前的 item（比如博客文章）和能够很好地描述它的属性（标签、分类或单词）。然后对其它每个 item 计算出它们交集和并集的商。数学过程可以表述为以下公式。

该方程的计算结果在 0 到 1 之间。你也能够方便地用以下公式来计算项目间的差异性。

Ruby 的实现示例

下面我将使用书名中的单词来推荐书籍。使用简单的 Book 类即可。

class Book < Struct.new(:title)

  # 长度大于2的不重复的单词的数组
  # 也可以是「标签」或「分类」的数组
  def words
    @words ||= self.title.gsub(/[a-zA-Z]{3,}/).map(&:downcase).uniq.sort
  end

end

BookRecommender 类使用当前的书籍和书籍数组进行初始化。recommendations 方法会循环数组并给每一个元素设定 jaccard_index 值，最后将书籍进行排序。

class BookRecommender

  def initialize book, books
    @book, @books = book, books
  end

  def recommendations

    # 计算每个元素的 jaccard_index 值并排序
    @books.map! do |this_book|

      # 运行中定义 jaccard_index 的取值 singleton 方法
      this_book.define_singleton_method(:jaccard_index) do
        @jaccard_index
      end

      # 还有赋值方法
      this_book.define_singleton_method("jaccard_index=") do |index|
        @jaccard_index = index || 0.0
      end

      # 计算样本的交集
      intersection = (@book.words & this_book.words).size
      # ... 和并集
      union = (@book.words | this_book.words).size

      # 将除法运算的结果赋值，如无法计算则捕捉异常并赋值为0
      this_book.jaccard_index = (intersection.to_f / union.to_f) rescue 0.0

      this_book

      # 排序
    end.sort_by { |book| 1 - book.jaccard_index }

  end

end

演示推荐过程：

# ...
# 读取数据并定义书籍数组
BOOKS = DATA.read.split("\n").map { |l| Book.new(l) }

# 定义当前书籍
current_book = Book.new("Ruby programming language")

# 进行推荐...
books = BookRecommender.new(current_book, BOOKS).recommendations

books.each do |book|
  puts "#{book.title} (#{'%.2f' % book.jaccard_index})"
end

__END__
Finding the best language for the job
Could Ruby save the day
Python will rock your world
Is Ruby better than Python
Programming in Ruby is fun
Python to the moon
Programming languages of the future

下面是名为「Ruby programming language」的书籍的输出结果，右边的数值就是 Jaccard 指数。

Programming in Ruby is fun (0.50)
Programming languages of the future (0.17)
Is Ruby better than Python (0.17)
Could Ruby save the day (0.14)
Finding the best language for the job (0.12)
Python to the moon (0.00)
Python will rock your world (0.00)

总结

以上就是纯粹基于 Ruby 的解决方案，源代码在我的 gist 上。我还写了使用标签的 PostgresSQL 版本。但要注意的是，当样本变得很大以后代码的执行速度也会变慢，因此不要每次操作 item 时都运行推荐，更好的方法是定义后台服务在后台进行推荐的计算。

希望你能够在自己的项目中用到这个方法，也请给我反馈。谢谢！：）

反面模式：用迭代循环来构建集合 (译自 thoughtbot)

zhaowenchina — Tue, 25 Mar 2014 21:27:44 +0800

首发：http://zhaowen.me/blog/2014/03/22/iteration-as-an-anti-pattern/ 原文：Anti-Pattern: Iteratively Building a Collection

Ruby 自带了很多出色的 Enumerable 方法，然而其中最有用的两个方法是传承自 Smalltalk 和 LISP 的 #map 和 #inject。一些冗长的方法定义通过使用这两个方法进行改写以后，可以变得既简洁又更加清晰。

构建一个数组

需求：

每个用户都有一个 PGP 公钥，我想要得到所有用户的公钥以便能够快速地将它们导入密钥服务器。

第一版代码有些冗长且过于死板。

def signer_key_ids
  result = []

  signers.each do |signer|
    result << signer.key_id
  end

  result
end

但只需简单地使用 #map ，就能更清晰地表明该方法的用途。

def signer_key_ids
  rsigners.map { |signer| signer.key_id }
end

由多个数组构建一个数组

另一个需求：

每个用户都有一个 PGP 公钥，我想要一份包括了所有用户的所有 UID 的清单，以便于我能看到他们的名字和地点。

我们可以用 #each 和 #flatten 来结构化地实现。

def signer_uids
  result = []

  signers.each do |signer|
    result << signer.uids
  end

  result.flatten
end

然而 #map 更加清晰。注意这里用到了 Symbol#to_proc。

def signer_uids
  signers.map(&:uids).flatten
end

#inject 配合 Array#+ 就可以不用在末尾调用 #flatten：

def signer_uids
  signers.inject([]) do |result, signer|
    result + signer.uids
  end
end

其实本例中，使用 #inject 还不是最直接的方法，我们可以直接使用 Enumerable#flat_map：

def signer_uids
  signers.flat_map(&:uids)
end

由一个数组构建一个 hash

又收到了一个需求：

每个用户都有一个 PGP 公钥，我想要得到一个散列表来通过每个用户的公钥 id 匹配他的全部 UID，以便于我来构建自己的密钥服务器。

我们需要构建一个 hash，而且我们需要使用数组中的每个元素。至少，下面的代码诠释了这一点：

def signer_keys_and_uids
  result = {}

  signers.each do |signer|
    result[signer.key_id] = signer.uids
  end

  result
end

其实还有另一种诠释的方法：先给定一个空的 hash，把用户数组中的每个元素的公钥 id 到 UID 的配对注入（#inject）到 hash 中：

def signer_keys_and_uids
  signers.inject({}) do |result, signer|
    result.merge(signer.key_id => signer.uids)
  end
end

由一个数组构建一个 Boolean

他们发誓这个最后一个需求：

每个用户都有一个 PGP 公钥，我想要确认我的所有用户都是通过我来认证的，以便于我时常能够互相感觉良好。

上面 hash 的例子中我们处理的是另一个 Enumerable。而这里是一个 Boolean，我们先来看一个绕远路的方法：

def mutually_signed?
  result = true

  signers.each do |signer|
    result = result && signer.signed_by?(self)
  end

  result
end

然后是下面这种方法，有些眼熟：

def mutually_signed?
  signers.inject(true) do |result, signer|
    result && signer.signed_by?(self)
  end
end

然而这个方法太不犀利了，我们可以把它当成一个所有元素必须全部为 true 的 Boolean 的数组：

def mutually_signed?
  signers.map(&:signed_by?).inject(:&)
end

身为 Rubyists，我们还应该知道 Enumerable 有很多其他出色的抽象方法：

def mutually_signed?
  signers.all?(&:signed_by?)
end

下一步是？

想要更好地培养对 #map、#inject 和其他 Enumerble 方法的感觉，我建议暂时离开 Ruby 一会儿。看看下面这些关于函数式编程的优秀书籍：

如果你想要阅读更多关于 Ruby 的 #inject 的文章，可以参阅：

Preload、 Eagerload、 Includes 和 Joins

zhaowenchina — Fri, 14 Mar 2014 08:05:22 +0800

首发：http://zhaowen.me/blog/2014/03/13/preload-eagerload-includes-and-joins/ 原文：Preload, Eagerload, Includes and Joins

Rails 提供了 4 种方式来加载关联表的数据。在这篇文章中，我们来分别来看看这些方法。

Preload

preload 使用一条附加的查询语句来加载关联数据。

User.preload(:posts).to_a

# =>
SELECT "users".* FROM "users"
SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" IN (1)

这也是 includes 默认的加载数据的方式。

preload 总是会生成两条 SQL 语句，所以我们不能在 where 条件中使用 posts 表。比如下面的查询就会报错。

User.preload(:posts).where("posts.desc='ruby is awesome'")

# =>
SQLite3::SQLException: no such column: posts.desc: 
SELECT "users".* FROM "users"  WHERE (posts.desc='ruby is awesome')

preload 也可以指定 where 条件。

User.preload(:posts).where("users.name='Neeraj'")

# =>
SELECT "users".* FROM "users"  WHERE (users.name='Neeraj')
SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" IN (3)

Includes

和 preload 一样，includes 也使用一条附加的查询语句来加载关联数据。

然而，它要比 preload 更聪明一些。我们刚刚看到了使用 preload 无法查询 User.preload(:posts).where("posts.desc='ruby is awesome'")。让我们使用 includes 来试试看。

User.includes(:posts).where('posts.desc = "ruby is awesome"').to_a

# =>
SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, "posts"."id" AS t1_r0, 
       "posts"."title" AS t1_r1, 
       "posts"."user_id" AS t1_r2, "posts"."desc" AS t1_r3 
FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id" 
WHERE (posts.desc = "ruby is awesome")

如你所见，includes 不再使用两条查询语句，而是使用了单独一条 LEFT OUTER JOIN 语句来获取数据，而且也加载了 where 条件。

所以，includes 在某些场合会从两次查询变成一次查询。默认的简单情况下它会使用两次查询。如果出于某些原因，你想强制其使用单次查询，可以使用 references。

User.includes(:posts).references(:posts).to_a

# =>
SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, "posts"."id" AS t1_r0, 
       "posts"."title" AS t1_r1, 
       "posts"."user_id" AS t1_r2, "posts"."desc" AS t1_r3 
FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"

上面的例子就只执行了一次查询。

Eager load

eager_load 使用 LEFT OUTER JOIN 进行单次查询，并加载所有的关联数据。

User.eager_load(:posts).to_a

# =>
SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, "posts"."id" AS t1_r0, 
       "posts"."title" AS t1_r1, "posts"."user_id" AS t1_r2, "posts"."desc" AS t1_r3 
FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"

这与 includes 在 where 或 order 语句中指定了 posts 表的属性的情况下的单次查询完全相同。

Joins

joins 使用 INNER JOIN 来加载关联数据。

User.joins(:posts)

# =>
SELECT "users".* FROM "users" INNER JOIN "posts" ON "posts"."user_id" = "users"."id"

上面的语句不会查询出 posts 表的数据。这个查询还可能会得到重复的结果，我们先创建一些数据。

def self.setup
  User.delete_all
  Post.delete_all

  u = User.create name: 'Neeraj'
  u.posts.create! title: 'ruby', desc: 'ruby is awesome'
  u.posts.create! title: 'rails', desc: 'rails is awesome'
  u.posts.create! title: 'JavaScript', desc: 'JavaScript is awesome'

  u = User.create name: 'Neil'
  u.posts.create! title: 'JavaScript', desc: 'Javascript is awesome'

  u = User.create name: 'Trisha'
end

有了上面的数据后，当我们执行 User.joins(:posts) 后得到的结果为

#<User id: 9, name: "Neeraj">
#<User id: 9, name: "Neeraj">
#<User id: 9, name: "Neeraj">
#<User id: 10, name: "Neil">

要去除重复数据，可以使用 distinct。

User.joins(:posts).select('distinct users.*').to_a

另外，如果我们想要得到 posts 表中的属性值，就必须显式地 select 它们。

records = User.joins(:posts).select('distinct users.*, posts.title as posts_title').to_a
records.each do |user|
  puts user.name
  puts user.posts_title
end

值得注意的是，使用 joins 就意味着 user.posts 会执行一次新的查询。

Ruby 中那些你绕不过的「坑」(译)

zhaowenchina — Sat, 08 Mar 2014 15:51:27 +0800

首发：http://zhaowen.me/blog/2014/03/04/ruby-gotchas/ 原文：Ruby Gotchas that will come back to haunt you

大多数 Ruby on Rails 的初学者们都会为这个出色的框架着迷，在缺乏 Ruby 语言知识的情况下就开始开发应用程序。这也无可厚非。至少，除非这些初学者们坚持了下来，然后摇身一变，成了没有 Ruby 基础知识的「senior」开发者。

不论如何，不管初学者还是有经验的程序员，迟早都会遇到传说中的「Ruby 的坑」。这些平时埋伏很深的语言上的细微之处将会耗费我们数个小时的死命调试（ puts "1" ），查明真相后我们会惊呼「怎么会这样？？！」，「好吧，我发誓这一次我会去看那本镐头封面的书！」，又或者，我们喊了声「操！」然后就去睡觉了。

我在这篇文章中列举了开发者们需要警惕的 Ruby 中常见的坑。我在每个条目中都给出了示例代码，包括了让人迷惑的或容易出错的代码。

另外，我也给出了最佳实践来简化你（和维护你代码的人）的生活。如果你对「最佳实践」不感冒，你也可以选择阅读详细的解释来了解为什么这个坑会引发 bug（多数情况下是因为它和你所想的不一样）。

`and/or` 不同于 `&&/||`

surprise = true and false # => surprise 的值为 true
surprise = true && false  # => surprise 的值为 false

最佳实践

只使用 && / || 运算符。

详情

and / or 运算符的优先级比 && / || 低
and / or 的优先级比 = 低，而 && / || 的优先级比 = 高
and 和 or 的优先级相同，而 && 的优先级比 || 高

我们来给上述示例代码加上括号，这样就可以明显地看出 and 和 && 在用法上的不同之处了。

(surprise = true) and false # => surprise is true
surprise = (true && false)  # => surprise is false

也有这样的说法：and / or 用于流程控制，而 && / || 用于布尔型运算。但我认为：不要使用这些运算符的关键字版本（and / or / not），而使用更为清晰的 if 和 unless 等。更加明确，更少困惑，更少 bugs。

延伸阅读：Difference between “or” and || in Ruby?

`eql?` 不同于 `==`（也不同于 `equal?` 或 `===`）

1 == 1.0   # => true
1.eql? 1.0 # => false

最佳实践

只使用 == 运算符。

详情

==、===、eql? 和 equal? 都是互不相同的运算符，各自有不同的用法，分别用于不同的场合。当你要进行比较时，总是使用 ==，除非你有特殊的需求（比如你真的需要区分 1.0 和 1）或者出于某些原因重写（override）了某个运算符。

没错，eql? 可能看起来要比平凡的 == 更为聪明，但是你真的需要这样吗，去 区分两个相同的东西 ？

延伸阅读：What’s the difference between equal?, eql?, ===, and ==?

`super` 不同于 `super()`

class Foo
  def show
    puts 'Foo#show'
  end
end

class Bar < Foo
  def show(text)
    super

    puts text
  end
end

Bar.new.show('test') # ArgumentError: wrong number of arguments (1 for 0)

最佳实践

在这里，省略括号可不仅仅是品味（或约定）的问题，而是确实会影响代码的逻辑。

详情

使用 super（没有括号）调用父类方法时，会将传给这个方法的参数原封不动地传给父类方法（因此在 Bar#show 里面的 super 会变成 super('test')，引发了错误，因为父类的方法不接收参数）
super()（带括号）在调用父类方法时不带任何参数，正如我们期待的那样。

自定义异常不能继承 `Exception`

class MyException < Exception
end

begin
  raise MyException
rescue
  puts 'Caught it!'
end

# MyException: MyException
#       from (irb):17
#       from /Users/karol/.rbenv/versions/2.1.0/bin/irb:11:in `<main>'

（上述代码不会捕捉到 MyException，也不会显示 'Caught it!' 的消息。）

最佳实践

自定义异常类时，继承 StandardError 或任何其后代子类（越精确越好）。永远不要直接继承 Exception。
永远不要 rescue Exception。如果你想要大范围捕捉异常，直接使用空的 rescue 语句（或者使用 rescue => e 来访问错误对象）。

详情

当你使用空的 rescue 语句时，它会捕捉所有继承自 StandardError 的异常，而不是 Exception。
如果你使用了 rescue Exception（当然你不应该这样），你会捕捉到你无法恢复的错误（比如内存溢出错误）。而且，你会捕捉到 SIGTERM 这样的系统信号，导致你无法使用 CTRL+C 来中止你的脚本。

延伸阅读：Why is it bad style to `rescue Exception => e` in Ruby?

`class Foo::Bar` 不同于 `module Foo; class Bar`

MY_SCOPE = 'Global'

module Foo
  MY_SCOPE = 'Foo Module'

  class Bar
    def scope1
      puts MY_SCOPE
    end
  end
end

class Foo::Bar
  def scope2
    puts MY_SCOPE
  end
end

Foo::Bar.new.scope1 # => "Foo Module"
Foo::Bar.new.scope2 # => "Global"

最佳实践

总是使用长的，更清晰的，module 把 class 包围的写法：

module Foo
  class Bar
  end
end

详情

module 关键字（class 和 def 也一样）会对其包围的区域创建新的词法作用域（lexical scope）。所以，上面的 module Foo 创建了 'Foo' 作用域，常量 MY_SCOPE 和它的值 'Foo Module' 就在其中。
在这个 module 中，我们声明了 class Bar，又会创建新的词法作用域（名为 'Foo::Bar'），它能够访问父作用域（'Foo'）和定义在其中的所有常量。
然而，当你使用了这个 :: 「捷径」来声明 Foo::Bar 时，class Foo::Bar 又创建了一个新的词法作用域，名字也叫 'Foo::Bar'，但它没有父作用域，因此不能访问 'Foo' 里面的东西。
因此，在 class Foo::Bar 中我们只能访问定义在脚本的开头的 MY_SCOPE 常量（不在任何 module 中），其值为 'Global'。

延伸阅读：Ruby – Lexical scope vs Inheritance

多数 `bang!` 方法如果什么都没做就会返回 `nil`

'foo'.upcase! # => "FOO"
'FOO'.upcase! # => nil

最佳实践

永远不要依赖于内建的 bang! 方法的返回值，比如在条件语句或流程控制中：

@name.upcase! and render :show

上面的代码会造成一些无法预测的行为（或者更准备地说，我们可以预测到当 @name 已经是全部大写的时候就会失败）。另外，这个示例也再一次说明了为什么你不应该使用 and/or 来控制流程。敲两个回车吧，不会有树被砍的。

@name.upcase!

render :show

`attribute=(value)` 方法永远返回传给它的 `value` 而无视 `return` 值

class Foo
  def self.bar=(value)
    @foo = value

    return 'OK'
  end
end

Foo.bar = 3 # => 3

（注意这个赋值方法 bar= 返回了 3，尽管我们显式地在最后 return 'OK'。）

最佳实践

永远不要依赖赋值方法的返回值，比如下面的条件语句：

puts 'Assigned' if (Foo.bar = 3) == 'OK' # => nil

显然这个语句不会如你所想。

延伸阅读：ruby, define []= operator, why can’t control return value?

`private` 并不会让你的 `self.method` 成为私有方法

class Foo

  private
  def self.bar
    puts 'Not-so-private class method called'
  end

end

Foo.bar # => "Not-so-private class method called"

（注意，如果这个方法真的是私有方法，那么 Foo.bar 就会抛出 NoMethodError。）

最佳实践

要让你的类方法变得私有，你需要使用 private_class_method :method_name 或者把你的私有类方法放到 class << self block 中：

class Foo

  class << self
    private    
    def bar
      puts 'Class method called'
    end    
  end

  def self.baz
    puts 'Another class method called'
  end
  private_class_method :baz

end

Foo.bar # => NoMethodError: private method `bar' called for Foo:Class
Foo.baz # => NoMethodError: private method `baz' called for Foo:Class

延伸阅读：creating private class method

我才不怕这些 Ruby 的坑！

上面列举的 Ruby 的坑可能看上去没什么大不了的，乍一看似乎只是属于代码风格和约定的范畴。

但相信我，如果你不重视它们，终有一天你会在 Ruby on Rails 的开发过程中碰到诡异无比的问题。它会让你心碎。因为你已经累觉不爱。然后孤独终老。永远。

zhaowenchina

How to write a template engine in less than 30 lines of code

前言：什么是模板？

定义特性

与 index.template 行为相同的 render 函数

Parse 方法

1. 使用 Proc

2. 设定 Proc 的变量

3. 将模板逐行转译成函数字符串

4. {{ ... }} 会被变换为 #{ ... }

它能扩展（Scale）吗？

Matz 最新作《关于 mruby 的一切》电子书发布了

Rails 4.1 的新特性 (译)

Action Mailer 预览

Active Record Enums

Action Pack Variants

Application Message Verifier

Spring

其他新特性

Ruby 实现的简易推荐系统 (译)

运作原理

Ruby 的实现示例

总结

反面模式：用迭代循环来构建集合 (译自 thoughtbot)

构建一个数组

由多个数组构建一个数组

由一个数组构建一个 hash

由一个数组构建一个 Boolean

下一步是？

Preload、 Eagerload、 Includes 和 Joins

Preload

Includes

Eager load

Joins

Ruby 中那些你绕不过的「坑」(译)

and/or 不同于 &&/||

最佳实践

详情

eql? 不同于 ==（也不同于 equal? 或 ===）

最佳实践

详情

super 不同于 super()

最佳实践

详情

自定义异常不能继承 Exception

最佳实践

详情

class Foo::Bar 不同于 module Foo; class Bar

最佳实践

详情

多数 bang! 方法如果什么都没做就会返回 nil

最佳实践

attribute=(value) 方法永远返回传给它的 value 而无视 return 值

最佳实践

private 并不会让你的 self.method 成为私有方法

最佳实践

我才不怕这些 Ruby 的坑！

`and/or` 不同于 `&&/||`

`eql?` 不同于 `==`（也不同于 `equal?` 或 `===`）

`super` 不同于 `super()`

自定义异常不能继承 `Exception`

`class Foo::Bar` 不同于 `module Foo; class Bar`

多数 `bang!` 方法如果什么都没做就会返回 `nil`

`attribute=(value)` 方法永远返回传给它的 `value` 而无视 `return` 值

`private` 并不会让你的 `self.method` 成为私有方法