lululau

Enumerable#each (with no block given) 和 Enumerable#map (with no block given) 有什么区别

lululau — Fri, 12 Jun 2015 11:14:49 +0800

Enumerable 定义的很多方法，在调用时，如果没有传递一个 block，那么这些方法都会返回一个 Enumerator 实例，比如：

each
map
select
each_slice
each_with_index

等等……

其中的 each，map，select 等方法所返回的 Enumerator 在对其进行迭代时，都是原封不动得依次返回原 Enumerable 对象的各元素。那么问题就是，这三个方法所返回的 Enumerator 对象有什么区别？如果没区别的话，像 map，select 等会返回 Enumerator 这样的设计是出于什么原因或目的？

看到 String#[] 方法的一个用法

lululau — Thu, 23 Jan 2014 00:50:10 +0800

例如：

str = "hello world"
result = $& if str =~ regex

可以用下面这量行代码代替：

result = str[regex]

另外：

result = $2 if str =~ /(\w+)\s(\w+)/

可以换成：

result = str[/(\w+)\s(\w+)/, 2]

这个不知道是不是太 out 了？

Ruby 1.9+ 的字符编码

lululau — Sat, 18 Jan 2014 02:44:30 +0800

从 1.9 开始，Ruby 增加了对字符编码的支持。这篇文章基本上是看了 Ruby 2.0 镐头书第 17 章 Character Encoding 做的笔记，并补充了一些自己通过实验得到的结论。

Ruby 代码文件的编码

你需要告诉 Ruby 你的 Ruby 代码文件使用的是什么编码，因为 Ruby 中的字符串字面量、Symbol 字面量以及正则表达式字面量的字符编码在多数时候取决于定义他们的源文件的字符编码。

(1). 如果你没有声明代码文件的字符编码，那么 Ruby 源文件的默认编码是这样确定的：

Ruby 1.9 默认 Ruby 源文件的编码为 US-ASCII

default_source_encoding.rb:

#!/usr/bin/env ruby
puts __ENCODING__   # 通过 __ENCODING__ 来查询当前文件的字符编码

Shell Commands：

rvm use 1.9 
ruby default_source_encoding.rb
# 输出：
US-ASCII

Ruby 2.0 默认 Ruby 源文件的编码为 UTF-8

Shell Commands：

rvm use 2.0
ruby default_source_encoding.rb
# 输出：
UTF-8

(2). 指定 Ruby 源文件的字符编码 在 Ruby 1.9 中，如果代码文件中包含了非 ASCII 字符，或者在 Ruby 2.0 中代码文件中包含了非 UTF-8 字符，那么就需要在代码文件中声明该代码文件的字符编码：

non_ascii.rb:

#!/usr/bin/env ruby
puts '中文'

Shell Commands:

rvm use 1.9
ruby non_ascii.rb
# 输出：
non_ascii.rb:2: invalid multibyte char (US-ASCII)
non_ascii.rb:2: invalid multibyte char (US-ASCII)

Ruby 使用一个看似神奇实则很简单的标记规则来指定代码文件的字符编码：如果一个文件的第一行（如果第一行是 UNIX shebang #!，那么就是第二行）是注释行，Ruby 会使用 coding:\s*(\S+) 这个正则表达式来对这个注释行进行匹配，如果匹配成功那么该文件的字符编码就被设置为 $1的值。所以，可以这样将一个 Ruby 代码文件的字符编码设置为 UTF-8：

# coding: utf-8

因为 Ruby 只是检索字符串中是否包含 coding: 这个子字符串，所以实际上也可以这样写：

# encoding: utf-8

Emacs 用户可能会更喜欢这样写：

# -*- encoding: utf-8 -*-

另外，如果 Ruby 代码文件包含了 UTF-8 BOM，也就是说代码文件的头三个字节是 \xEF\xBB\xBF，那么 Ruby 认为这个代码文件的字符编码是 UTF-8，而不管上述的标记行：

gbk.rb:

#!/usr/bin/env ruby
# coding: GBK
puts __ENCODING__

Shell Commands:

rvm use 2.0
ruby gbk.rb
# 输出:
GBK
ruby -e 'print [0xEF, 0xBB, 0xBF].pack("c*")' > bom.rb
cat gbk.rb >> bom.rb
ruby bom.rb
# 输出：
UTF-8

(3). 查询代码文件的编码：
特殊常量 __ENCODING__ 存储了文件的字符编码

字符串（还有 Symbol 和 Regexp）字面量的字符编码

在 Ruby 1.9+ 中，每一个字符串对象、Symbol 对象和正则表达式对象都有自己的字符编码。

show_encoding.rb:

#!/usr/bin/env ruby
# coding: utf-8
str = "中文"
sym = :name
regex = Regexp.new(str.encode("GBK"))
puts str.encoding
puts sym.encoding
puts regex.encoding

Shell Commands:

rvm use 2.0
ruby show_encoding.rb
# 输出：
UTF-8
US-ASCII
GBK

字符串对象、Symbol 对象和正则表达式对象的字面量的编码是这样确定的：

(1). 字符串字面量总是以定义它的源代码文件的字符编码来编码的。

utf8.rb:

#!/usr/bin/env ruby
# coding: utf-8
puts "abc".encoding
puts "中文".encoding

gbk.rb:

#!/usr/bin/env ruby
# coding: GBK
puts "abc".encoding
puts "中文".encoding

Shell Commands:

rvm use 2.0
ruby utf8.rb
ruby gbk.rb
# 输出:
UTF-8
UTF-8
GBK
GBK

(2). Symbol 和正则表达式有点特别（我猜测可能出于性能方面的考量）：如果它们只包含 ASCII 字符（即所有字节的最高位都为 0），那么它们就以 US-ASCII 编码；否则它们就以定义它们的源代码文件的字符编码来编码。

sym_regex_encoding.rb:

#!/usr/bin/env ruby
# coding: UTF-8
a = :name
b = :名字
x = /hello/
y = /你好/
puts a.encoding
puts b.encoding
puts x.encoding
puts y.encoding

Shell Commands:

rvm use 2.0
ruby sym_regex_encoding.rb
# 输出:
US-ASCII
UTF-8
US-ASCII
UTF-8

(3). 一个例外：

在字符串和正则表达式中，可以使用 \uxxxx 或 \u{x... x... x...} 来创建任意的 UNICODE 字符，如果一个字符串字面量或者正则表达式字面量中包含了 \uxxxx 或 \u{x... x... x...} 标记，且此标记所表示的字符不是 ASCII 字符，那么它的编码将设置为 UTF-8，而不管定义它的源代码文件的字符编码是什么。

unicode_notation.rb:

#!/usr/bin/env ruby
# coding: GBK
a = "a"
b = "中"
x = "\u0061"
y = "\u2d4e"
puts a.encoding
puts b.encoding
puts x.encoding
puts y.encoding

Shell Commands:

rvm use 2.0
ruby unicode_notation.rb
# 输出:
GBK
GBK
GBK
UTF-8

虚拟编码 ASCII-8BIT

Ruby 支持一个叫做 ASCII-8BIT 的虚拟字符编码。这个虚拟编码更多地是用来处理二进制数据，或者在不确定 Ruby 代码文件编码时也可以将其指定为 ASCII-8BIT。

编码转换

(1). 可以将字符串从一个编码转换为另外一个编码

transcoding.rb:

#!/usr/bin/env ruby
# coding: UTF-8
a = "中"
puts a.encoding
p a.bytes.map { |e| e.to_s(16) }
b = a.encode("GBK")
puts b.encoding
p b.bytes.map { |e| e.to_s(16) }

Shell Commands:

rvm use 2.0
ruby transcoding.rb
# 输出:
UTF-8
["e4", "b8", "ad"]
GBK
["d6", "d0"]
LANG=zh_CN.UTF-8 echo -n 中 | od -An -tx1
# 输出：
e4  b8  ad
LANG=zh_CN.UTF-8 echo -n 中 | iconv -t GBK | od -An -tx1
# 输出：
d6  d0

(2). 改变一个对象的编码 encode 方法实际上是返回一个新的对象，而要改变一个对象的编码，则使用 force_encoding 方法：

force_encoding.rb:

#!/usr/bin/env ruby
# coding: ASCII-8BIT
a = "中"
puts a.encoding
p a.bytes.map { |e| e.to_s(16) }
a.force_encoding("UTF-8")
puts a.encoding
p a.bytes.map { |e| e.to_s(16) }
a.force_encoding("GBK")
puts a.encoding
p a.bytes.map { |e| e.to_s(16) }

Shell Commands:

rvm use 2.0
ruby force_encoding.rb
# 输出:
ASCII-8BIT
["e4", "b8", "ad"]
UTF-8
["e4", "b8", "ad"]
GBK
["e4", "b8", "ad"]

可以看到 force_encoding只是改变了对象的字符编码，并没有改变存储字符的实际字节。

IO 的字符编码

如果将一个某种特定字符编码的字符串输出到外部 IO 对象时，Ruby 将会使用什么编码输出这个字符串呢？答案取决于这个 IO 对象的编码是什么。
每个 IO 对象都有两个和字符编码相关的属性：外部编码 external_encoding 和内部编码 internal_encoding。

(1). 输出过程中的编码转换
与输出数据到一个 IO 对象这个过程相关的是 external_encoding，输出过程中的字符编码转换规则为：若此 IO 对象的 external_encoding 为 nil ，则被输出的对象将不会被转换字符编码而直接输出其内存中的实际字节；否则，被输出的对象将使用 external_encoding 进行编码，编码过程中所使用的源编码为被输出对象的 encoding 属性。

output_transcoding.rb:

#!/usr/bin/env ruby
# coding: UTF-8
s_utf8 = "中"
p s_utf8.bytes.map { |e| e.to_s(16) }   # => ["e4", "b8", "ad"]
s_gbk = s_utf8.encode("GBK")
p s_gbk.bytes.map { |e| e.to_s(16) }    # => ["d6", "d0"]
p s_gbk.encoding    # =>  #<Encoding:GBK>
p STDOUT.external_encoding    # => nil
p STDOUT.internal_encoding    # => nil
puts s_gbk      # => 0xd6  0xd0 ， 说明 s_gbk 的字节没有经过编码转换而直接输出
STDOUT.set_encoding("UTF-8:Windows-31J")
p STDOUT.external_encoding     # => #<Encoding:UTF-8>
p STDOUT.internal_encoding     # => #<Encoding:Windows-31J>
puts s_gbk      # => 0xe4  0xb8  0xad ，被正常转换为 UTF-8，说明数据输出过程中的编码转换和 internal_encoding <Windows-31J> 无关

(2). 输入过程中的编码转换
当从一个 IO 对象读取数据时，读取的数据的编码和此 IO 对象的 external_encoding 和 internal_encoding 两个属性都有关系，具体的规则为：若 internal_encoding 为 nil，那么外部数据将被不经任何转换地读进内存，在内存中存储此块数据的对象的 encoding 属性被设置为此 IO 对象的 external_encoding；否则，外部数据被读进内存时将被转换为 internal_encoding 所标识的字符编码，且存储此块数据的对象的 encoding 属性被设置为 internal_encoding，编码转换所使用的源编码为 external_encoding。

Shell Commands:

echo -n $'\xe4\xb8\xad' > tmp  # 向 tmp 文件中输出“中”字经 UTF-8 编码的字节序列
cat tmp
#输出：
中

input_transcoding.rb:

#!/usr/bin/env ruby
File.open "tmp", "r:UTF-8" do |f|
    p f.external_encoding   # => #<Encoding:UTF-8>
    p f.internal_encoding   # => nil
    l = f.gets
    p l.encoding   # => #<Encoding:UTF-8>
    p l.bytes.map { |e| e.to_s(16) }  # => ["e4", "b8", "ad"]
end
File.open "tmp", "r:UTF-8:GBK" do |f|
    p f.external_encoding  # => #<Encoding:UTF-8>
    p f.internal_encoding  # => #<Encoding:GBK>
    l = f.gets
    p l.encoding  # => #<Encoding:GBK>
    p l.bytes.map { |e| e.to_s(16) }  # => ["d6", "d0"]
end

(3). 设置 IO 对象的字符编码
在使用 IO.new()创建一个 IO 对象时，可以指定这个对象的 external_encoding 和 internal_encoding：

open_file.rb:

#!/usr/bin/env ruby
hello = File.new "hello", "w:gbk"
world = File.new "world", "w:ISO8859-1:sjis"
p hello.external_encoding
p hello.internal_encoding
p world.external_encoding
p world.internal_encoding

Shell Commands:

rvm use 2.0
ruby open_file.rb
# 输出
#<Encoding:GBK>
nil
#<Encoding:ISO-8859-1>
#<Encoding:Windows-31J>

若要修改一个 IO 对象的 external_encoding 和 internal_encoding，使用 IO#set_encoding() 方法：

set_enc.rb:

#!/usr/bin/env ruby
p STDOUT.external_encoding
p STDOUT.internal_encoding
p STDERR.external_encoding
p STDERR.internal_encoding
STDOUT.set_encoding('gbk')
STDERR.set_encoding('sjis:utf-8')
p STDOUT.external_encoding
p STDOUT.internal_encoding
p STDERR.external_encoding
p STDERR.internal_encoding

Shell Commands:

rvm use 2.0
ruby set_enc.rb
# 输出
nil
nil
nil
nil
#<Encoding:GBK>
nil
#<Encoding:Windows-31J>
#<Encoding:UTF-8>

IO 默认编码

Ruby 1.9+ 还有一个 IO 默认外部编码 Encoding.default_external 和 IO 默认内部编码 Encoding.default_internal的概念，不过通过我在 ruby-2.0.0-p247 上的实践，发现这个概念真是一团糟。总的来说，当你创建一个 IO 对象时，如果没有在 mode 参数里指定内部编码和外部编码，那么这个 IO 对象的内部编码和外部编码会分别设置为这两个默认编码，但是这需要满足以下规则：

如果 Encoding.default_internal 为 nil，那么用户创建的 IO 对象的内部编码和外部编码，与这两个默认编码没有关系，也就是说在这种情况下，即便是创建 IO 对象时没有指定内部编码和外部编码，Ruby 也不会用这两个默认编码的值去设置这个 IO 对象的内部和外部编码。
例外：如果 IO 对象是以 readonly (如File.new filename, "r") 模式打开的，且没有指定内部编码和外部编码，那么不管default_internal是否为 nil，那么该对象的外部编码都将被设置为 default_external 的值。
如果 Encoding.default_internal 和 Encoding.default_external 的值相同（顺便提一下，default_external 的值永远不会是 nil），那么如果创建 IO 对象时没有指定内部编码和外部编码，那么这个 IO 对象的外部编码将被设置为 default_external 的值，而 IO 对象的内部编码不会被设置。
如果 default_internal 值不为 nil，且与 default_external 不相等，创建 IO 对象时没有指定内部编码和外部编码，那么这个 IO 对象的外部编码将被设置为 default_external 的值，内部编码被设置为 default_internal。

另外，当从一个 IO 对象读取数据时，如果该 IO 对象的 external_encoding 和 internal_encoding 都为 nil，那么外部数据将被不经任何转换地读进内存，在内存中存储此块数据的对象的 encoding 属性被设置为Encoding.default_external；

设置默认编码

可以通过 Encoding.default_external=() 和 Encoding.default_internal=() 来设置默认外部编码和默认内部编码。
也可以通过 ruby 解释器的 -E 选项来指定默认外部编码和默认内部编码。
另外，Ruby 也会从 LANG 环境变量推断默认的外部编码
如果没有设置 LANG 环境变量，也没有指定 -E 选项，那么默认的外部编码就被设置为 US-ASCII

标准 IO 对象的默认编码

STDIN、STDOUT和STDERR这三个标准 IO 对象的外部编码和内部编码的默认值受 Encoding.default_external 和 Encoding.default_internal 控制，其规则和前文所述的 default_external、default_internal 对新建为指定编码的 IO 对象的控制规则一致。

一个典型的例子：系统的 LANG 环境变量为 zh_CN.UTF-8，且没有指定 ruby 解释器的 -E 选项，那么这 3 个标准 IO 对象的内部编码和外部编码分别为：

stdio_encoding.rb:

#!/usr/bin/env ruby
puts Encoding.default_external  # => UTF-8
puts Encoding.default_internal  # => nil
puts STDIN.external_encoding  # => UTF-8
puts STDIN.internal_encoding  # => nil
puts STDOUT.external_encoding  # => nil
puts STDOUT.internal_encoding  # => nil
puts STDERR.external_encoding  # => nil
puts STDERR.internal_encoding  # => nil

[北京] 找一份 Ruby 或 Rails 的开发工作

lululau — Thu, 02 Jan 2014 22:08:03 +0800

工作 5 年，5 年间主要工作做 Java Web 开发，期间零碎地做过服务器管理，用 Bash/Ruby/Perl/Python 做工具开发，也用 Rails 和 Django 做过玩具级的小项目。

喜欢 Ruby 和 Rails，想找一份 Ruby 或是 Rails 的开发工作。

我的博客：http://liuxiang.logdown.com/

我的 Github：https://github.com/lululau/

我的简历：http://liuxiang.logdown.com/pages/resume

有需要可以联系我：lululau@me.com

simple_form 的 :collection 选项生成的 radio_buttons / checkboxes 的样式问题

lululau — Thu, 05 Dec 2013 16:19:22 +0800

我用 simple_from（已生成 bootstrap wrappers) 生成的一个 radio_buttons 的表单控件：

<%= f.input :rating, :collection => 1..5, :as => :radio_buttons, :item_wrapper_class => "radio-inline" %>

展示出来后，发现第一个 radio button 往下错位了一点：

发现是因为 simple_form（SimpleForm::Inputs::CollectionRadioButtonsInput#apply_default_collection_options!）对每一个 wrap label 都有一个默认的 radio 的 CSS class，:item_wrapper_class 选项所指定的 class，不是用来替换这个默认的 class，而是合并到一块的，也就是说生成每个 radio button 的 HTML 是这样的：

<label class="radio radio-inline">
  <input type="radio" value="1" name="product[rating]" id="product_rating_1" class="radio_buttons optional">1
</label>

而 bootstrap3 里 .radio class 里定义个一个 10px 的 top margin，另外还定义了 .radio-inline + .radio-inline 的 margin-top 为 0px，因此第一个 radio button 就会往下错 10 个 px，而第二个第三个都不会往下错。

我现在的做法是在 .radio-inline 里加了个 margin-top: 0px，不知道这样会不会有问题，因为 simple_form 和 bootstrap3 都是简单地了解了一下，也不知道这个问题是不是我用的方法不对

Ruby socket 库中的 BasicSocket#recv 方法的一个疑问

lululau — Tue, 03 Sep 2013 14:11:52 +0800

之前发现自己一遇到涉及到 TCP/IP 基础知识的问题时就抓瞎，所以决定好好学习一下 TCP/IP 的基础知识，把 UNP 的基础编程这部分粗略过了一遍，然后想回头过一遍 Ruby 的 socket 库的文档，并且希望能把 Ruby socket 库的用法和 UNP 中讲述的内容对应起来。当看到 BasicSocket#recv(maxlen, flags) 这个方法时，遇到了个问题。recv 方法的 flags 参数是一些标识选项，用于控制 socket 的行为，UNP 对 recv(2) 系统服务的 flags 的描述如下：

UNP 中提到可能不是所有系统都支持这个 MSG_DONTWAIT 选项，我顺便查下了手册，OS X / Linux 中关于 recv(2) 的手册都没有提到 MSG_DONTWAIT 选项，Linux 的 recv(2) 手册中还提到 POSIX 只规定了 MSG_OOB, MSG_PEEK, and MSG_WAITALL 中三个选项，但是实际上 OS X 和 Linux 都定义了 MSG_DONTWAIT（grep MSG_DONTWAIT /usr/include/linux/socket.h /usr/include/sys/socket.h），并且以下C语言和 Python 实现的服务器程序在设置 DONTWAIT 选项调用 recv 时，确实是表现出了 non-block 的行为（立即返回并抛出一个 EAGAIN）：

C 版：

#include <sys/socket.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>


int main(int argc, char const *argv[])
{
    int server_fd, client_fd;
    socklen_t len;
    struct sockaddr_in server_addr, client_addr;

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(6789);
    inet_aton("127.0.0.1", &server_addr.sin_addr);

    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    bind(server_fd, (struct sockaddr *) &server_addr, sizeof(server_addr));
    listen(server_fd, 5);

    while (1) {
        len = sizeof(client_addr);
        client_fd = accept(server_fd, (struct sockaddr *) &client_addr, &len);
        char buf[10];
        recv(client_fd, buf, 10, MSG_DONTWAIT);
        buf[9] = '\0';
        printf("data: %s\n", buf);
    }
}

Python 版：

#!/usr/bin/env python

from socket import *

server_sock = socket(AF_INET, SOCK_STREAM)
server_sock.bind(("127.0.0.1", 6789))
server_sock.listen(5)

while True:
    client_sock, client_addr = server_sock.accept()
    data = client_sock.recv(10, MSG_DONTWAIT)
    print "data: %s" % data
    client_sock.close()
server_sock.close()

而 Ruby 版的程序在调用 recv 时，却没有表现出来 non-block 的特性，而是一直阻塞在 recv 调用中知道接受到客户端发送过来数据为止：

#!/usr/bin/env ruby

require "socket"

server = TCPServer.new '127.0.0.1', 6789
server.listen 5
while client = server.accept    
    data = client.recv(10, Socket::MSG_DONTWAIT)
    # begin
    #     data = client.recv_nonblock 10
    # rescue Errno::EAGAIN
    #     retry
    # end
    puts "data: #{data.inspect}"
    client.close
end

so, why ?

顺便附上 Client 的代码：

#!/usr/bin/env ruby

require "socket"

sock = TCPSocket.new "127.0.0.1", 6789
while line = gets
    sock.puts line
end

instance_eval 是如何做到修改 Block 里的 self 引用的？

lululau — Thu, 29 Aug 2013 11:25:45 +0800

比如这段代码

class Person
    def hello
        yield
    end
    def world(&proc)
        proc.call
    end
end

p = Person.new
p.hello {puts self.class}
p.world {puts self.class}
p.instance_eval {puts self.class}

输出：

Object
Object
Person

如果我想写一个叫做haha方法，然后通过的调用 p.haha {puts self.class} 输出 Person，如果不借助 instance_eval (包括不借助那些已经借助了instance_eval的方法：Module#define_method 等)，可以写出这个 haha 方法吗？说到底就是像 instance_eval 那样修改一个 Block 里的 self 引用是可行的吗？

在 action 里调用一个耗时很长的外部命令时，整个应用都被卡死的问题

lululau — Tue, 19 Feb 2013 15:08:02 +0800

class PeopleController < ApplicationController
  # GET /people
  # GET /people.json
  def index
    @people = Person.all

    respond_to do |format|
      format.html # index.html.erb
      format.json { render :json => @people }
    end
  end

  # GET /people/1
  # GET /people/1.json
  def show
    @person = Person.find(params[:id])
    system "sleep 1000000"
    respond_to do |format|
      format.html # show.html.erb
      format.json { render :json => @person }
    end
  end

  ....

end

如上面的代码所示，名为 show 的 action 里，调用了"sleep 1000000"，然后整个应用全部卡死了，不管通过浏览器访问哪个 action 都不返回。

请教这个问题怎么解决？

请教个 Ruby 的基础问题

lululau — Fri, 20 Apr 2012 23:15:09 +0800

方法“attr_accessor”和“module_function”同样都是类"Module"的实例方法，但是为什么“attr_accessor”可以在定义类的时候这样用：

class Hello
  attr_accessor :hello
end

而“module_function”却不可以这样用呢：

class Hello
  def hello
  end

  module_function :hello
end

我觉得唯一合理的解释就是类“Class”在继承类“Module”的时候，把方法“module_function”给删除了？

哪里能找到关于 ri 文档格式的说明文档

lululau — Tue, 10 Jan 2012 18:25:08 +0800

问题是这样的，最近一段时间安装的所有的 gems 在查看其文档时，都会报一个错误：

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/rdoc/ri/ri_reader.rb:54:in `initialize': No such file or directory - /Library/Ruby/Gems/1.8/doc/uuid-2.3.4/ri/UUID/cdesc-UUID.yaml (Errno::EENOENT)

好像 ri 需要一个 cdesc-CLASSNAME.yaml 一个说明文件，但是我发现最近安装的 gems 里都没有这个问题，取而代之的时 cdesc-CLASSNAME.ri 文件，而早先安装的 gems 里都有那个 yaml 文件。而如果我先把早先安装的一个 gems 卸载然后重新安装，发现那个 yaml 文件也没有了。

谁知道这是怎么回事吗？

或者哪里有关于 ri 文档格式的说明文档？