wosuopu (龙昌)

在 Ruby 中使用 DATA 和 END 将代码和数据混合

wosuopu — Sun, 23 Aug 2015 12:03:36 +0800

之前一直不理解 __END__ 的用法，现在看了这篇文章后才算是了解了，于是便翻译之。
《Mixing code and data in Ruby with DATA and __END__》: http://blog.honeybadger.io/data-and-end-in-ruby/

你知道 Ruby 提供了一种方法在你的脚本中可以将源文件作为数据源来使用吗？当你在写一些一次性的脚本用于验证概念时这个小技巧会为你节约一些时间。让我们来看看吧。

DATA 和 END

在下面这个例子中，我使用了一个有趣的关键字 __END__。所有在 __END__ 下面的内容将会被 Ruby 解释器所忽略。但是有趣的是 ruby 为你提供了一个称为 DATA 的 IO 对象，就像你可以读取其他任何文件一样，它能让你读取到 __END__ 以下的所有内容。

下面这个例子中，我们遍历每一行并进行输出。

DATA.each_line do |line|
  puts line
end

__END__
Doom
Quake
Diablo

关于这个技术我最喜欢的实例是使用 DATA 来包含一个 ERB 模板。它同样也可用于 YAML、CSV 等等。

require 'erb'

time = Time.now
renderer = ERB.new(DATA.read)
puts renderer.result()

__END__
The current time is <%= time %>.

实际上你也可以使用 DATA 来读取 __END__ 关键字以上的内容。那是因为 DATA 实际上是一个指向了整个源文件，并定位到 __END__ 关键字的位置。你可以试试看在输出之前将 IO 对象反转。下面这个例子将会输出整个源文件。

DATA.rewind
puts DATA.read # prints the entire source file

__END__
meh

多文件问题

这个技术最大的缺点是它只能用于单个文件的脚本，直接运行该文件，不能在其他文件进行导入。

下面这个例子，我们有两个文件，并且每个都有它们自己的 __END__ 部分。然而却只有一个全局 DATA 对象。因此第二个文件的 __END__ 部分刚访问不到了。

# first.rb
require "./second"

puts "First file\n----------------------"
puts DATA.read

print_second_data()

__END__
First end clause

# second.rb

def print_second_data
  puts "Second file\n----------------------"
  puts DATA.read # Won't output anything, since first.rb read the entire file
end

__END__

Second end clause

snhorne ~/tmp $ ruby first.rb
First file
----------------------
First end clause

Second file
----------------------

对于多文件的一个解决方案

在 Sinatra 中有一个很酷的特性是它允许你在你应用的 __END__ 部分添加多个内联模板。它看起来像下面这样：

# This code is from the Sinatra docs at http://www.sinatrarb.com/intro.html
require 'sinatra'

get '/' do
  haml :index
end

__END__

@@ layout
%html

  = yield

@@ index
%div.title Hello world.

sinatra 是如何实现的呢？毕竟你的应用可能是运行在 rack 上。在生产环境中你不能再通过 ruby myapp.rb 来运行！他们必须有一种在多文件中使用 DATA 的解决方案。

因此如果你稍微深入一下 Sinatra 的源代码，你会发现它们并没有使用 DATA。而是使用了跟下面这段代码类似的方案。

# I'm paraphrasing. See the original at https://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L1284
app, data = File.read(__FILE__).split(/^__END__$/, 2)

实际上它比这个要更复杂一些，因为它们不想读取 __FILE__，它只是 sinatra/base.rb 文件。它们其实是需要获取调用了该方法的文件的内容。它们通过解析 caller 的结果来获取。

caller 方法将会告诉你当前运行的方法是从哪调用的。这里是个简单的例子：

def some_method
  puts caller
end

some_method # => caller.rb:5:in `<main>'

现在可以简单地获取到文件名了，然后从该文件中再提取出与 DATA 等价的内容。

def get_caller_data
  puts File.read(caller.first.split(":").first).split("__END__", 2).last
end

请善用它，不要作恶

希望对于这些技巧你不要经常使用。它们不会使得代码干净、可维护。

然后，你偶尔需要一些又快又脏的实现一个一次性的脚本或者验证一些概念。此时 DATA 和 __END__ 就非常有用了。

我的博客： http://www.xefan.com/archives/84154.html

使用 Rails + Angular 开发的一个记账程序

wosuopu — Wed, 19 Aug 2015 17:42:38 +0800

最初就是想写个小程序来方便自己日常记账，顺便再练习一下 angular。整个程序是一个 SPA。好了直接看效果图：

开发完成之后也算是对 angular 有些熟悉了吧。最近听说 angular 2 也快要发布了，于是去了解了一下。瞬间崩溃了，尼玛这与 angular 1.x 完全不兼容啊，又得重新学习了。不过反而觉得 angular 2 跟 react 之类的比较相似。

程序源代码：https://github.com/wusuopu/rails-billing

如果有需要学习 angular 的同学，这个应该可以提供一些参考吧。

Unicorn 是如何与 Nginx 通讯的——介绍 Ruby 中的 Unix Socket

wosuopu — Mon, 03 Aug 2015 23:04:52 +0800

Ruby 应用服务典型地是与一个 web 服务一同使用的，如 nginx。当用户请求你的 Rails 应用中的页面时，nginx 将请求指派给应用服务。然而这个过程是如何完成的呢？nginx 与 unicorn 是如何通讯的呢？

最有效的一种选择是使用 unix 套接字 (sockets)。让我们来看看它们是如何工作的！在这篇文章中我们将从一个基本的套接字 (sockets) 开始，最后将创建一个使用 nginx 代理的简单应用服务。

套接字 (sockets) 允许进程之间通过对一个文件读或者写进行相互通讯。 在这个例子中 Unicorn 创建 socket 并监听它的连接。然后 Nginx 就可以连接到这个 socket 并与 Unicorn 通讯了。

什么是 unix socket？

Unix socket 使得一个进程通过类似文件的方式与另一个进程进行通讯。它是 IPC(Interprocess Communication) 的一种。

要使得可以通过 socket 访问进程，首先需要创建一个 socket 并作为一个文件保存在磁盘中。然后监听这个 socket 的连入连接。当接收到一个连接时，就可以使用标准 IO 方法进行读写数据。

Ruby 通过以下一组类提供了 unix socket 所需的所有内容：

UNIXServer - 创建 socket 并保存到磁盘中，并且让你可以监听新连接。
UNIXSocket - 打开已存在的套接字 (sockets)。

注意：还存在着其它类型的 socket，最突出的是 TCP socket。不过这篇文章只处理 unix socket。那么它们之间的区别是什么呢？unix socket 具有文件名。

最简单的 Socket

我们接下来看两个小程序。

第一个是服务端，它创建一个 UnixServer 实例，然后使用 server.accept 等待连接。当收到连接后则相互问候。

需要说明一下，accept 和 readline 方法都会阻塞程序的执行，直到收到内容。

require "socket"

server = UNIXServer.new('/tmp/simple.sock')

puts "==== Waiting for connection"
socket = server.accept

puts "==== Got Request:"
puts socket.readline

puts "==== Sending Response"
socket.write("I read you loud and clear, good buddy!")

socket.close

这里我们有了服务端，现在还需要客户端。

在下面这个例子中，我们打开由服务端创建的 socket，然后使用普通的 IO 方法进行发送和接收问候。

require "socket"

socket = UNIXSocket.new('/tmp/simple.sock')

puts "==== Sending"
socket.write("Hello server, can you hear me?\n")

puts "==== Getting Response"
puts socket.readline

socket.close

演示一下程序，先运行服务端，然后再运行客户端。你可以看到以下结果：

简单的 Unix socket 服务端/客户端交互的例子。左边是客户端，右边是服务端。

与 nginx 接合

现在我们知道如何创建一个 unix socket 的服务端了，我们可以很容易地与 nginx 接合。

不相信我？让我们来做一个快速的概念验证吧。我修改上面的代码使其输出从 socket 接收到的所有内容。

require "socket"

# Create the socket and "save it" to the file system
server = UNIXServer.new('/tmp/socktest.sock')

# Wait until for a connection (by nginx)
socket = server.accept

# Read everything from the socket
while line = socket.readline
  puts line.inspect
end

socket.close

现在如果我修改 nginx 配置，将请求转发到 /tmp/socktest.sock socket 上。我就能看到 nginx 发送来的数据了。(别担心，我们稍后会讨论它的配置的)

当我发起一个 web 请求时，nginx 将如下数据发送到我的服务端上：

太酷了！这就是一个包含了额外头信息的 HTTP 请求。现在我们准备来构建一个真正的应用服务。但是，首先让我们讨论一个 nginx 的配置吧。

安装配置 Nginx

如果你还没有安装 nginx 的话，请先安装。对于 OSX 可以 homebrew 简单完成：

brew install nginx

现在我们配置 nginx 将 localhost:2048 的请求通过名为 /tmp/socktest.sock 的 socket 转发到上游服务端。名字可以是任意的，它仅需要与我们 web 服务的 socket 名字匹配即可。

你可以将其保存至 /tmp/nginx.conf 并通过命令 nginx -c /tmp/nginx.conf 运行 nginx。

# Run nginx as a normal console program, not as a daemon
daemon off;

# Log errors to stdout
error_log /dev/stdout info;

events {} # Boilerplate

http {

  # Print the access log to stdout
  access_log /dev/stdout;

  # Tell nginx that there's an external server called @app living at our socket
  upstream app {
    server unix:/tmp/socktest.sock fail_timeout=0;
  }

  server {

    # Accept connections on localhost:2048
    listen 2048;
    server_name localhost;

    # Application root
    root /tmp;

    # If a path doesn't exist on disk, forward the request to @app
    try_files $uri/index.html $uri @user3;

    # Set some configuration options on requests forwarded to @app
    location @user5 {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
      proxy_pass http://app;
    }

  }
}

以非后台模式运行 nginx。当你运行 nginx 时它应该看起来像如下这样：

Nginx 以非后台模式运行

自定义应用服务

既然我们已经知道了如何将 nginx 与我们程序进行连接，那么我们就来构建一个简单的应用服务。当 nginx 将请求转发到我们的 socket 时，它是一个标准的 HTTP 请求。经过一些处理后我可以决定 socket 是否会返回一个有效的 HTTP 响应，它会在浏览器中显示。

下面这个应用接受任何请求并显示时间戳。

require "socket"

# Connection creates the socket and accepts new connections
class Connection

  attr_accessor :path

  def initialize(path:)
    @path = path
    File.unlink(path) if File.exists?(path)
  end

  def server
    @server ||= UNIXServer.new(@path)
  end

  def on_request
    socket = server.accept
    yield(socket)
    socket.close
  end
end


# AppServer logs incoming requests and renders a view in response
class AppServer

  attr_reader :connection
  attr_reader :view

  def initialize(connection:, view:)
    @connection = connection
    @view = view
  end

  def run
    while true
      connection.on_request do |socket|
        while (line = socket.readline) != "\r\n"
          puts line
        end
        socket.write(view.render)
      end
    end
  end

end

# TimeView simply provides the HTTP response
class TimeView
  def render
%[HTTP/1.1 200 OK


The current timestamp is: #{ Time.now.to_i }

]
  end
end


AppServer.new(connection: Connection.new(path: '/tmp/socktest.sock'), view: TimeView.new).run

现在运行 nginx 和脚本，然后访问 localhost:2048。请求会发送到我的应用上，然后响应被浏览器渲染。太酷了！

HTTP 请求信息由我们的应用服务输出到 STDOUT

以下就是我们的劳动成果。

浏览器中显示服务端返回的时间戳

我的博客：http://www.xefan.com/archives/84146.html 原文：http://blog.honeybadger.io/how-unicorn-talks-to-nginx-an-introduction-to-unix-sockets-in-ruby/

Ruby 的内存陷阱

wosuopu — Thu, 14 May 2015 23:18:19 +0800

Ruby 有一套自动的内存管理机制。这在大多数情况下是不错的，但是有时它却是个麻烦。

Ruby 的内存管理既简洁又笨重。它将对象（名为 RVALUE）存储在大约有 16KB 大小的堆中。从底层上，RVALUE 是一个 C 的结构体，它包含了一个共同体表示不同的标准 ruby 对象。

因此在堆中存储着大小不超过 40 字节的 RVALUE 对象，如 String、Array、Hash等。这意味着小的对象在堆中很合适，但是一旦它们达到到阈值，那么就需要在 Ruby 的堆之外再分配一片额外的内存。

这块额外的内存空间是灵活的。一旦对象被垃圾回收了它就会被释放掉。但是堆本身的内存是不会被释放给操作系统的。

让我们来看一个简单的例子：

def report
  puts 'Memory ' + `ps ax -o pid,rss | grep -E "^[[:space:]]*#{$$}"`
          .strip.split.map(&:to_i)[1].to_s + 'KB'
end

report
big_var = " " * 10_000_000
report
big_var = nil
report
ObjectSpace.garbage_collect
sleep 1
report

# ⇒ Memory 11788KB
# ⇒ Memory 65188KB
# ⇒ Memory 65188KB
# ⇒ Memory 11788KB

这里我们分配了大量的内存，使用完后又释放给操作系统。这一切看起来似乎没有问题。现在让我们稍微修改一下代码：

-  big_var = " " * 10_000_000
+  big_var = 1_000_000.times.map(&:to_s)

这只是一个简单的修改，不是吗。但是结果：

# ⇒ Memory 11788KB
# ⇒ Memory 65188KB
# ⇒ Memory 65188KB
# ⇒ Memory 57448KB

怎么回事？内存没有释放归还给操作系统。这是因为数组中的每个元素符合 RVALUE 的大小并存储在 ruby 的堆中。

在大多情况下这是正常的。现在 ruby 堆中多了许多空的位置，再次运行代码将不会再消耗额外的内存了。每次我们处理 big_var 和一些空的堆时， GC[:heap_used]的值果然减小了。对于这些操作 Ruby 是早有准备，注意这里是 Ruby 而不是操作系统。

因此，对于创建大量的符合 40 个字节的临时变量就要注意了：

big_var = " " * 10_000_000
big_var.gsub(/\s/) { |c| '-' }

结果同样是 Ruby 的内存疯狂增长，并且这部分内存在程序运行期间是不会归还给操作系统的：

# ⇒ Memory 10156KB
# ⇒ Memory 13788KB
# ⇒ Memory 13788KB
# ⇒ Memory 12808KB

这个问题不是太重要，稍微注意一下即可。

我的博客：http://www.xefan.com/archives/84145.html

Ruby 3.0 的未来

wosuopu — Wed, 13 May 2015 23:21:54 +0800

原文地址：http://hrnabi.com/2015/05/12/7035/
谁日语好的为大家做下贡献，把原文翻译一下吧。

反正我不会日语，根据文中的一些汉字连蒙带猜的，大致看了一遍，现在简单总结一下。如果有总结得不对的，本人不负责哦。

看来要玩好 Ruby 不仅需要学英语，也还得学日语啊。

在 2014 年 9 月举行的 RubyKaigi 2014 大会上，Matz 在演讲过程中首次提到了 Ruby 3.0。
文中说的 Ruby 3.0 的三个工作方向：

Concurrency (并行性)
JIT (即时编译)
Static typing (静态类型)

Ruby 要引入静态类型检查？
Matz 说，在 20 世纪出生的语言大多是脚本语言，如：Ruby、PHP 和 Perl、JavaScript，这些都不是静态类型的。另一方面，最近推出的如 Scala 和 Dart、Go 是属于静态类型的。在 Ruby 中可以考虑引入 Python 这种通过注释来进行检查的方法。

Ruby 要引入并行计算？
Matz 详细讨论了静态类型，但没有提到并行计算。详细的内容是由笹田氏来说的。
（这部分内容我没看懂，只是大概知道这位笹田氏的博士论文与这个相关。）
关于并行计算，Matz 提到了 Erlang 和 Scala 的 actor 模型。

最后期待下一个 Ruby 开发者大会。

好了，我只看懂了这么多。其余的各位感兴趣的自己去看原文吧。 (怎么感觉好坑啊，这总结得跟没总结一样啊。没办法了我的日语水平有限。)

我的博客地址： http://www.xefan.com/archives/84144.html

Ruby 中一些重要的钩子方法

wosuopu — Fri, 01 May 2015 12:03:30 +0800

原文地址： http://www.sitepoint.com/rubys-important-hook-methods/

Ruby 的哲学理念是基于一个基本的要素，那就是让程序员快乐。Ruby 非常注重程序员的快乐，并且也提供了许多不同的方法来实现它。它的元编程能力能够让程序员编写在运行时动态生成的代码。它的线程功能使得程序员有一种优雅的的方式编写多线程代码。它的钩子方法能让程序员在程序运行时扩展它的行为。

上述的这些特性，以及一些其他很酷的语言方面，使得 Ruby 成为编写代码的优先选择之一。本文将探讨 Ruby 中的一些重要的钩子方法。我们将从不同方面讨论钩子方法，如它们是什么，它们用于什么，以及我们如何使用它们来解决不同的问题。我们同时也了解一下一些流行的 Ruby 框架/Gem 包/库是如何使用它们来提供非常酷的特性的。

我们开始吧。

什么是钩子方法？

钩子方法提供了一种方式用于在程序运行时扩展程序的行为。假设有这样的功能，可以在无论何时一个子类继承了一些特定的父类时收到通知，或者是比较优雅地处理一个对象上的不可调用的方法而不是让编译器抛出异常。这些情况就是使用钩子方法，但是它们的用法并不仅限于此。不同的框架/库使用了不同的钩子方法来实现它们的功能。

在本文中我们将会讨论如下几个钩子方法：

included
extended
prepended
inherited
method_missing

included

Ruby 给我们提供了一种方式使用 模块(modules) （在其他语言中被称作 混入类(mixins)）来编写模块化的代码供其他的 模块/类 使用。 模块 的概念很简单，它就是一个可以在其他地方使用的独立代码块。

例如，如果我们想要编写一些代码在任何时候调用特定的方法都会返回一个静态字符串。我们姑且将这个方法称作 name。你可能在其他地方也会想使用同一块代码。这样最好是新建一个模块。让我们来创建一个：

module Person
  def name
    puts "My name is Person"
  end
end

这是一个非常简单的模块，仅有一个 name 方法用于返回一个静态字符串。在我们的程序中使用这个模块：

class User
  include Person
end

Ruby 提供了一些不同的方法来使用模块。include 是其中之一。include 所做的就是将在 module 内定义的方法在一个 class 的实例变量上可用。在我们的例子中，是将 Person 模块中定义的方法变为一个 User 类实例对象的方法。这就相当于我们是将 name 方法写在 User 类里一样，但是定义在 module 里的好处是可复用。要调用 name 方法我们需要创建一个 User 的实例对象，然后再在这个对象上调用 name 方法。例如：

User.new.name
=> My name is Person

让我们看看基于 include 的钩子方法。included 是 Ruby 提供的一个钩子方法，当你在一些 module 或者 class 中 include 了一个 module 时它会被调用。更新 Person 模块：

module Person
  def self.included(base)
    puts "#{base} included #{self}"
  end

  def name
    "My name is Person"
  end
end

你可以看到一个新的方法 included 被定义为 Person 模块的类方法。当你在其他的模块或者类中执行 include Person 时，这个 included 方法会被调用。该方法接收的一个参数是对包含该模块的类的引用。试试运行 User.new.name，你会看到如下的输出：

User included Person
My name is Person

正如你所见，base 返回的是包含该模块的类名。现在我们有了一个包含 Person 模块的类的引用，我们可以通过元编程来实现我们想要的功能。让我们来看看 Devise是如何使用 included 钩子的。

Devise 中的 `included`

Devise 是 Ruby 中使用最广泛的身份验证 gem 包之一。它主要是由我喜欢的程序员 José Valim 开发的，现在是由一些了不起的贡献者在维护。 Devise 为我们提供了从注册到登录，从忘记密码到找回密码等等完善的功能。它可以让我们在用户模型中使用简单的语法来配置各种模块：

devise :database_authenticatable, :registerable, :validatable

在我们模型中使用的 devise 方法在这里定义。为了方便我将这段代码粘贴在下面：

def devise(*modules)
  options = modules.extract_options!.dup

  selected_modules = modules.map(&:to_sym).uniq.sort_by do |s|
    Devise::ALL.index(s) || -1  # follow Devise::ALL order
  end

  devise_modules_hook! do
    include Devise::Models::Authenticatable

    selected_modules.each do |m|
      mod = Devise::Models.const_get(m.to_s.classify)

      if mod.const_defined?("ClassMethods")
        class_mod = mod.const_get("ClassMethods")
        extend class_mod

        if class_mod.respond_to?(:available_configs)
          available_configs = class_mod.available_configs
          available_configs.each do |config|
            next unless options.key?(config)
            send(:"#{config}=", options.delete(config))
          end
        end
      end

      include mod
    end

    self.devise_modules |= selected_modules
    options.each { |key, value| send(:"#{key}=", value) }
  end
end

在我们的模型中传给 devise 方法的模块名将会作为一个数组保存在 *modules 中。对于传入的模块调用 extract_options! 方法提取可能传入的选项。在 11 行中调用 each 方法，并且每个模块在代码块中用 m 表示。在 12 行中 m 将会转化为一个常量（类名），因此使用 m.to.classify 一个例如 :validatable 这样的符号会变为 Validatable 。随便说一下 classify 是 ActiveSupport 的方法。
Devise::Models.const_get(m.to_classify) 会获取该模块的引用，并赋值给 mod。在 27 行使用 include mod 包含该模块。例子中的 Validatable 模块是定义在这里。 Validatable 的 included 钩子方法定义如下：

def self.included(base)
  base.extend ClassMethods
  assert_validations_api!(base)

  base.class_eval do
    validates_presence_of   :email, if: :email_required?
    validates_uniqueness_of :email, allow_blank: true, if: :email_changed?
    validates_format_of     :email, with: email_regexp, allow_blank: true, if: :email_changed?

    validates_presence_of     :password, if: :password_required?
    validates_confirmation_of :password, if: :password_required?
    validates_length_of       :password, within: password_length, allow_blank: true
  end
end

此时模型是 base。在第 5 行的 class_eval 代码块会以该类作为上下文进行求值运算。通过 class_eval 编写的代码与直接打开该类的文件将代码粘贴进去效果是一样的。 Devise 是通过 class_eval 将验证包含到我们的用户模型中的。

当我们试着使用 Devise 注册或者登录时，我们会看到这些验证，但是我们并没有编写这些验证代码。 Devise 是利用了 included 钩子来实现这些的。非常的优雅吧。

extended

Ruby 也允许开发者 扩展(extend) 一个模块，这与 包含(include) 有点不同。 extend 是将定义在 模块(module) 内的方法应用为类的方法，而不是实例的方法。让我们来看一个简单的例子：

module Person
  def name
    "My name is Person"
  end
end

class User
  extend Person
end

puts User.name # => My name is Person

正如你所看到的，我们将 Person 模块内定义的 name 方法作为了 User 的类方法调用。 extend 将 Person 模块内的方法添加到了 User 类中。extend 同样也可以用于将模块内的方法作为单例方法 (singleton methods)。让我们再来看另外一个例子：

# We are using same Person module and User class from previous example.     

u1 = User.new
u2 = User.new

u1.extend Person

puts u1.name # => My name is Person
puts u2.name # => undefined method `name' for #<User:0x007fb8aaa2ab38> (NoMethodError)

我们创建了两个 User 的实例对象，并将 Person 作为参数在 u1 上调用 extend 方法。使用这种调用方式，Person 的 name 方法仅对 u1 有效，对于其他实例是无效的。

正如 included 一样，与 extend 相对应的钩子方法是 extended。当一个模块被其他模块或者类执行了 extend 操作时，该方法将会被调用。让我们来看一个例子：

# Modified version of Person module

module Person
  def self.extended(base)
    puts "#{base} extended #{self}"
  end

  def name
    "My name is Person"
  end
end

class User
  extend Person
end

该代码的运行结果是输出 User extended Person。

关于 extended 的介绍已经完了，让我们来看看 ActiveRecord 是如何使用它的。

ActiveRecord 中的 `extended`

ActiveRecord 是在 Ruby 以及 Rails 中广泛使用的 ORM 框架。它具有许多酷的特性，因此使用它在很多情况下成为了 ORM 的首选。让我们进入 ActiveRecord 内部看看 ActiveRecord 是如何使用回调的。 (我们使用的是 Rails v3.2.21)

ActiveRecord 在这里 extend 了 ActiveRecord::Models 模块。

extend ActiveModel::Callbacks

ActiveModel 提供了一套在模型类中使用的接口。它们允许 ActionPack 与不是 ActiveRecord 的模型进行交互。在这里， ActiveModel::Callbacks 内部你将会看到如下代码：

def self.extended(base)
  base.class_eval do
    include ActiveSupport::Callbacks
  end
end

ActiveModel::Callbacks 对 base 即就是 ActiveRecord::Callbacks 调用了 class_eval 方法，并包含了 ActiveSupport::Callbacks 模块。我们前面已经提到过了，对一个类调用 class_eval 与手动地将代码写在这个类里是一样的。 ActiveSupport::Callbacks 为 ActiveRecord::Callbacks 提供了 Rails 中的回调方法。

这里我们讨论了 extend 方法，以及与之对应的钩子 extended。并且也了解了 ActiveRecord / ActiveModel 是如何使用上述方法为我们提供可用功能的。

prepended

另一个使用定义在模块内部方法的方式称为 prepend。prepend 是在 Ruby 2.0 中引入的，并且与 include 和 extend 很不一样。使用 include 和 extend 引入的方法可以被目标模块/类重新定义覆盖。例如，如果我们在某个模块中定义了一个名为 name 的方法，并且在目标模块/类中也定义同名的方法。那么这个在我们类在定义的 name 方法将会覆盖模块中的。而 prepend 是不一样的，它会将 prepend 引入的模块中的方法覆盖掉我们模块/类中定义的方法。让我们来看一个简单的例子：

module Person
  def name
    "My name belongs to Person"
  end
end

class User
  include Person
  def name
    "My name belongs to User"
  end
end

puts User.new.name 
=> My name belongs to User

现在再来看看 prepend 的情况：

module Person
  def name
    "My name belongs to Person"
  end
end

class User
  prepend Person
  def name
    "My name belongs to User"
  end
end

puts User.new.name 
=> My name belongs to Person

使用 prepend Person 会将 User 中的同名方法给覆盖掉，因此在终端输出的结果为 My name belongs to Person。 prepend 实际上是将方法添加到方法链的前端。在调用 User 类内定义的 name 方法时，会调用 super 从而调用 Person 模块的 name。

与 prepend 对应的回调名为（你应该猜到了） prepended。当一个模块被预置到另一个模块/类中时它会被调用。我们来看下效果。更新 Person 模块的定义：

module Person
  def self.prepended(base)
    puts "#{self} prepended to #{base}"
  end

  def name
    "My name belongs to Person"
  end
end

你再运行这段代码应该会看到如下结果：

Person prepended to User
My name belongs to Person

prepend 的引入是为了去除 alias_method_chain hack 的丑陋，它曾被 Rails 以及其他库广泛地使用以达到与 prepend 相同的功能。因为 prepend 只有在 Ruby >= 2.0 的版本中才能使用，因此如果你打算使用 prepend 的话，那么你就应该升级你的 Ruby 版本。

inherited

继承是面向对象中一个最重要的概念。Ruby 是一门面向对象的编程语言，并且提供了从基/父类继承一个子类的功能。我们来看一个简单的例子：

class Person
  def name
     "My name is Person"
  end
end

class User < Person
end

puts User.new.name # => My name is Person

我们创建了一个 Person 类和一个子类 User。在 Person 中定义的方法也成为了 User 的一部分。这是非常简单的继承。你可能会好奇，是否有什么方法可以在一个类被其他类继承时收到通知呢？是的，Ruby 有一个名为 inherited 的钩子可以实现。我们再看看这个例子：

class Person
  def self.inherited(child_class)
    puts "#{child_class} inherits #{self}"
  end

  def name
    "My name is Person"
  end
end

class User < Person
end

puts User.new.name

正如你所见，当 Person 类被其他子类继承时 inherited 类方法将会被调用。运行以上代码结果如下：

User inherits Person
My name is Person

让我们看看 Rails 在它的代码中是如何使用 inherited 的。

Rails 中的 `inherited`

Rails 应用中有一个重要的类名为 Application ，定义中 config/application.rb 文件内。这个类执行了许多不同的任务，如运行所有的 Railties，引擎以及插件的初始化。关于 Application 类的一个有趣的事件是，在同一个进程中不能运行两个实例。如果我们尝试修改这个行为，Rails 将会抛出一个异常。让我们来看看 Rails 是如何实现这个特性的。

Application 类继承自 Rails::Application，它是在这里定义的。在 62 行定义了 inherited 钩子，它会在我们的 Rails 应用 Application 类继承 Rails::Application 时被调用。 inherited 钩子的代码如下：

class << self
  def inherited(base)
    raise "You cannot have more than one Rails::Application" if Rails.application
    super
    Rails.application = base.instance
    Rails.application.add_lib_to_load_path!
    ActiveSupport.run_load_hooks(:before_configuration, base.instance)
  end
end

class << self 是 Ruby 中的另一个定义类方法的方式。在 inherited 中的第 1 行是检查 Rails.application 是否已存在。如果存在则抛出异常。第一次运行这段代码时 Rails.application 会返回 false 然后调用 super。在这里 super 即是 Rails::Engine 的 inherited 钩子，因为 Rails::Application 继承自 Rails::Engine。

在下一行，你会看到 Rails.application 被赋值为 base.instance 。其余就是设置 Rails 应用了。

这就是 Rails 如何巧妙地使用 inherited 钩子来实现我们的 Rails Application 类的单实例。

method_missing

method_missing 可能是 Ruby 中使用最广的钩子。在许多流行的 Ruby 框架/gem 包/库中都有使用它。当我们试图访问一个对象上不存在的方法时则会调用这个钩子方法。让我们来看一个简单的例子：

class Person
  def name
    "My name is Person"
  end
end

p = Person.new

puts p.name     # => My name is Person 
puts p.address  # => undefined method `address' for #<Person:0x007fb730a2b450> (NoMethodError)

我们定义了一个简单的 Person 类，它只有一个 name 方法。然后创建一个 Person 的实例对象，并分别调用 name 和 address 两个方法。因为 Person 中定义了 name，因此这个运行没问题。然而 Person 并没有定义 address，这将会抛出一个异常。 method_missing 钩子可以优雅地捕捉到这些未定义的方法，避免此类异常。让我们修改一下 Person 类：

class Person
  def method_missing(sym, *args)
     "#{sym} not defined on #{self}"
  end

  def name
    "My name is Person"
  end
end

p = Person.new

puts p.name     # => My name is Person
puts p.address  # => address not defined on #<Person:0x007fb2bb022fe0>

method_missing 接收两个参数：被调用的方法名和传递给该方法的参数。首先 Ruby 会寻找我们试图调用的方法，如果方法没找到则会寻找 method_missing 方法。现在我们重载了 Person 中的 method_missing，因此 Ruby 将会调用它而不是抛出异常。

让我们来看看 Rake 是如何使用 method_missing 的。

Rake 中的 `method_missing`

Rake 是 Ruby 中使用最广泛的 gem 包之一。Rake 使用 method_missing 来提供访问传递给 Rake 任务的参数。首先创建一个简单的 rake 任务：

task :hello do
  puts "Hello"
end

如果你通过调用 rake hello 来执行这个任务，你会看到输出 Hello。让我们扩展这个 rake 任务，以便接收一个参数（一个人名）并向他打招呼：

task :hello, :name do |t, args|
  puts "Hello #{args.name}"
end

t 是任务名，args 保存了传递过来的参数。正如你所见，我们调用 args.name 来获取传递给 hello 任务的 name 参数。运行该任务，并传递一个参数：

rake hello["Imran Latif"]
=> Hello Imran Latif

让我们来看看 Rake 是如何使用 method_missing 为我们提供了传递给任务的参数的。

在上面任务中的 args 对象是一个 Rake::TaskArguments 实例，它是在这里所定义。这个类负责管理传递给 Rake 任务的参数。查看 Rake::TaskArguments 的代码，你会发现并没有定义相关的方法将参数传给任务。那么 Rake 是如何将参数提供给任务的呢？答案是 Rake 是使用了 method_missing 巧妙地实现了这个功能。看看第 64 行 method_missing 的定义：

def method_missing(sym, *args)
  lookup(sym.to_sym)
end

在这个类中定义 method_missing 是为了保证能够访问到那些未定义的方法，而不是由 Ruby 抛出异常。在 method_missing 中它调用了 lookup 方法：

def lookup(name)
  if @hash.has_key?(name)
   @hash[name]
  elsif @parent
    @parent.lookup(name)
  end
end

method_missing 调用 lookup，并将方法名以 Symbol(符号) 的形式传递给它。 lookup 方法将会在 @hash 中进行查找，它是在 Rake::TaskArguments 的构造函数中创建的。如果 @hash 中包含该参数则返回，如果在 @hash 中没有则 Rake 会尝试调用 @parent 的 lookup。如果该参数没有找到，则什么都不返回。

这就是 Rake 如何巧妙地使用 method_missing 提供了访问传递给 Rake 任务的参数的。感谢Jim Weirich编写了 Rake。

结束语

我们讨论了 5 个重要的 Ruby 钩子方法，探索了它们是如何工作的，以及一些流行的框架/gem 包是如何使用它们来提供一些优雅的功能。我希望你能喜欢这篇文章。请在评论中告诉我们你所喜欢的 Ruby 钩子，以及你使用它们所解决的问题。

编写 Ruby 的 C 扩展

wosuopu — Mon, 22 Sep 2014 21:16:22 +0800

最近在折腾用 C 语言编写 Ruby 扩展时发现相关资料很少，于是乎在折腾完了之后我把收集到的资料整理成了一本电子书。但愿对各位需要写扩展的有所帮忙。

电子书地址： https://www.gitbook.io/book/wusuopu/write-ruby-extension-with-c

不足之处欢迎指正。

Ruby 元编程第二版发布了

wosuopu — Sun, 17 Aug 2014 10:31:25 +0800

之前本来说是 6 月份发布的，然后又延期到了 8 月 20 号。但是今天再上去看的时候发现已经发布了。

电子版的是$25，感觉略贵了点。有没有人一起合买啊？

http://pragprog.com/book/ppmetr2/metaprogramming-ruby-2

使用 ruby 开发 vim 插件

wosuopu — Thu, 03 Jul 2014 23:19:24 +0800

作为一个 Vimmer 和 Pythoner，之前折腾过用 python 编写 vim 插件。现在作为半个 Rubist，又开始继续折腾。

在开始编写插件之前，你需要确认 Vim 是否支持 Ruby，通过以下命令来判别：

$ vim --version | grep +ruby

如果输出为空，则表示你当前的 vim 不支持 Ruby，需要重新编译一下，并启用对 Ruby 的支持。

顺便说下我当前的环境是：

vim 7.4
ruby 2.1.0

环境检查没有问题那么就开始吧。
在~/.vim/plugin 目录下创建一个 demo.vim 文件。

在开头写上以下代码：

if !has('ruby')
    echo "Error: Required vim compiled with +ruby"
    finish
endif

这段代码就是用 VimL 编写的，它将检查 Vim 是否支持 Ruby。

接下来再判断该插件是否已经加载过了，以免重复加载：

if exists('g:loaded_ruby_demo_plugin')
    finish
endif
let g:loaded_ruby_demo_plugin = 1

所有的检查都没有问题，则开始插件的正文了。先定义一个函数。

function! DemoFun1()
ruby<<EOF
buf = VIM::Buffer.current
puts "current buffer name: #{buf.name} number: #{buf.number} length: #{buf.length}"
EOF
endfunction

function 与 endfunction 是 vim 中用于定义函数的，在”ruby<<EOF”和”EOF”之间部分的是 Ruby 代码。这个例子是输出当前缓冲区的名字、编号以及总行数。
执行命令:call DemoFun1()，应该就可以看到输出结果了。

然后再举个例子说下函数的参数处理。

function! DemoFun2(arg1)
ruby<< EOF
puts "you input: #{VIM.evaluate('a:arg1')}"
EOF
endfunction

这里定义了一个函数接收一个参数，然后将其输出。使用 VIM.evaluate 将 vim 的变量转化为 Ruby 的变量。

为了方便我们再定义两个命令，以简化对这两个函数的调用。

command! -nargs=0 DemoFun1 call DemoFun1()  
command! -nargs=1 -rang DemoFun2 call DemoFun2(<f-args>)

要获取完整的代码可以访问： https://gist.github.com/wusuopu/c1182efefa85d4f6839b

接下来再简单说下 vim 中 Ruby 的使用。

vim 为 Ruby 提供了一个 VIM 模块，通过它可以在 Ruby 中访问 vim 的接口。同时还提供了两个全局变量：$curwin、$curbuf，它们分别代表了当前窗口对象以及当前缓冲区对象。

VIM 模块中有 Buffer 和 Window 两个对象，分别是用来对缓冲区和窗口进行操作的。同时 VIM 模块还提供了 message、set_option、command 和 evaluate 四个函数。

想要查看更多的帮忙信息，可以在 vim 中执行如下命令：

:help ruby

好了，先写这么多吧，其余的自己去尝试吧。

博客原文地址： http://www.xefan.com/archives/84117.html

使用 css 绘制 lxde

wosuopu — Wed, 15 Jan 2014 21:51:13 +0800

最近在学习 CSS，本来是打算写点小东西练习练习。正好自己用的是 linux 系统的 lxde 桌面，于是就用 CSS 来绘制一个 lxde。效果如图：

源代码： https://github.com/wusuopu/css3-lxde

刚学了两个多星期的 Ruby，动手写一个简单的有道词典

wosuopu — Wed, 20 Nov 2013 21:54:22 +0800

程序是在命令行下运行的，打算之后有时间用 GTK 写个前端界面。

目前程序可以进行联网查单词，并把查询结果存到本地 sqlite 数据库中，这样下次再查同一个词时就不用再联网了。

源代码：https://github.com/wusuopu/youdao-dict-rb