gazeldx (leader.me 张健)

注册域名的 Rubyist 注意了！

gazeldx — Fri, 09 Jan 2026 12:33:54 +0800

我两周前收到 Name cheap 的邮件，说我的帐户被永久封禁了。原因是我是中国人。如果想解除封禁，需要提供在非制裁国家居住的证明。之间我已经按他们的要求，提供了我的护照照片，但这依然不够！

原文如下: Please let us remind you that it is also required to provide us with proof of residence in a non-sanctioned country, such as a lease agreement or utility bill. You can attach this document to this email as a scan or photocopy.

译文如下：请注意，您还需要提供在非制裁国家居住的证明，例如租赁协议或水电费账单。您可以将此文件以扫描件或复印件的形式作为附件添加到此邮件中。

花了 $700 买的域名就这么没了，更别提我的业务无法在这些 Premium 域名上开展了。要拿回这些域名，看来我得出个国，并签一份租房合同

2026-01-12 更新：经过交涉，现在我的帐号已经恢复可用。

leader.me：程序员的“数字名片”，一站式打造个人品牌

gazeldx — Fri, 12 Dec 2025 12:12:01 +0800

为什么开发 leader.me?

2024 年 5 月，我失业了。半年都没找到工作。我反思，用人单位为什么不雇佣我？最后发现，我居然没有拿得出手的作品！其实我做过几个成功的项目，但那时候，我没有把这些成功的项目进行截图，以至于这些项目因故下线后，无法把项目的成功分享给雇主。

因此，我开始刻意地打造自己的作品集。花了六个月时间，完成了 LT 算法网和开源 Markdown/Git 博客，把自己包装成算法高手和开源热心人士。果然，在 2025 年 6 月，我成功入职上海的一家上市公司，做资深 Ruby 开发工程师。

考虑到程序员们在这个就业压力变大的季节，也有同样想向雇主展示自己作品集的需求，我开发了 leader.me，还包括简历、博客等功能，助力程序员打造线上个人 IP。

中国程序员的烦恼

作为中国程序员，你是否还在为个人作品散落、简历无人问津、博客维护费时费力而烦恼？

传统方式如 WordPress，需要自己折腾服务器、主题、SEO，成本高（域名 + 主机每年几百元），内容输出慢；自搭博客更惨，技术债堆积，更新一次像打仗。
Medium 等平台成为会员才能绑定独立域名，会员费高昂。
招聘平台如 LinkedIn？它强在人脉和职位推送，但你的代码仓库、项目细节、深度文章往往被简化成“简历附件”，难以凸显技术深度，品牌感弱。

leader.me 来了——专为开发者设计的 SaaS 平台，定位“专业开发者身份构建”，让你像 GitHub Pages 一样简单，却更精致、更品牌化。

核心功能一应俱全：

作品集（上传项目截图、代码链接，一键展示技术栈）；
简历（动态生成 PDF/网页版，支持实时更新）；
博客（Markdown 编辑，内置代码高亮，SEO 友好）；

这些全集成在一页内，无需多站点跳转，用户一看就懂你的实力。

对比传统博客，leader.me 零代码部署、自动优化，省时 90%；对比 LinkedIn，它不只是“求职工具”，而是你的“个人官网”，突出作品驱动的品牌，吸引猎头主动找上门。

价格亲民：核心服务起步低（具体详见官网），远低于自搭成本。

提供高端子域名（如 yourname.leader.me），瞬间提升专业范儿；
支持自定义域名绑定。

这些小功能，大大放大你的在线影响力。

总之，leader.me 不是博客或招聘站，而是你的“开发者名片”——低成本、高效率，专注品牌输出。别再让作品埋没，赶紧试试 leader.me，10 分钟建站，开启被动收入机会！（官网：www.leader.me）

感恩回馈 Ruby-China 社区的用户

作为社区的老粉丝，能给到大家的，就是实打实的省钱：冲多少，送多少，2025 年 12 月 31 日截止！

与多年优惠叠加后，最低只需要 $3 就可以使用 1 年的 leader.me 产品！

leader.me 开发团队

架构师：张健
主程：Clacky.ai。Clacky.ai 虽然宣称对小白用户友好，实际上，对程序员更友好，对 Ruby 程序员最友好！因为 Clacky.ai 专注主打 Rails 编程，让 Clacky.ai 开发功能时，我的经验是把大的功能模块拆小，给 Clacky.ai 明确的指导，Clacky.ai 基本上能一次搞定。不要让 AI 一个指令开发许多东西，以免代码失控。
辅程：Gemini, 张健
产品经理：张健，Grok, Gemini

今天开源一个博客引擎，助您使用 Markdown 和 Git 进行博客写作

gazeldx — Sat, 19 Apr 2025 10:39:09 +0800

使用 "Markdown" 和 "Git" 享受博客写作。一个基于 Ruby on Rails 8 的开源个人博客引擎。

GitHub 仓库地址：is-bio。
演示网站：张健的博客和 Stop Gaming。

如何在本地使用 Markdown 文件撰写文章，并通过 `git push` 发布？

目前，Jekyll 或 Hugo 已经可以满足上述要求，但并不完美。

is-bio 也可以满足上述要求，但有几点不同。

is-bio 在哪些方面比 Jekyll 或 Hugo 更好？

Jekyll 或 Hugo 生成的博客文章是静态的，而 is-bio 是一个动态博客引擎。
- 静态博客的功能非常有限。
- 在动态博客 is-bio 中，目前已集成电子邮件订阅功能，未来还将支持简历、作品集、评论、点赞、阅读次数、在线支付等功能。
- 此外，您还可以为您的博客添加一些自定义功能。
- 您可能会说，如果我不会用 Ruby 编程怎么办？
  - 两年前，这会是个问题，但现在，我们有了 AI，您可以让 AI 帮助您实现一些小功能！
  - 如果出现错误，告诉 AI 并让 AI 纠正它。
对于不熟悉 Jekyll 或 Hugo 的人来说，即使是找到一个好看的主题也很困难。
- is-bio 目前支持一个漂亮的免费主题，未来还会添加更多主题。
Jekyll 或 Hugo 的文档长达很多页。谁能在一页内解释清楚所有内容？
- is-bio 可以。有关如何使用 is-bio 方法通过 Markdown 和 Git 发布帖子的信息，请阅读 markdown-blog。
一篇博客文章可以翻译成多种语言并在博客上显示。这个功能目前还没有任何博客引擎支持。然而，is-bio 已经支持了，让您的文章能够触达全球用户。
对于建立个人品牌来说，仅有一个博客是不够的。最好有简历和作品集。事实上，博客并不是最重要的功能，简历和作品集才是。在下一个版本中，我们将推出简历功能。

使用 is-bio 的成本是多少？

许多程序员已经在使用服务器，通常，该服务器并未得到充分利用。

您可以在此服务器上安装 is-bio，而无需担心端口 80/443 被另一个网站占用。在安装文档中，我已经指出了如何完美解决这个实际不存在的问题。

因此，您的成本增加可能是$2/月。

为什么开发者不再经常写博客了？

在使用 GitHub Pages（基于 Jekyll）后，他们很少写博客了。为什么？
在我看来，普通的博客系统无法再为博主创造太多价值！那些博客并非旨在为博主带来价值。
以我自己为例，我的 GitHub Pages 的张健的旧博客一点也不吸引人，所以我无法兴奋地写作。

is-bio：一个专注于为开发者带来价值的博客引擎

您可以看到张健的新博客（基于 is-bio）设计精良。
我开始期望客户直接在我的博客上为我的服务付费！
通过博客，我向潜在客户传达了一个信息：我是 Web 开发、算法和戒断游戏成瘾方面的专家！

在服务器上部署 is-bio

如果您想在服务器上部署 is-bio，请阅读 deploy_on_CentOS10.md。

在本地计算机上安装 is-bio

以下内容主要针对在 macOS 本地进行安装。对于其他操作系统，安装过程类似。

安装 Ruby

is-bio 是基于 Ruby 3.3.x 版本开发的，但其他版本应该也可以工作。

如果您是临时用户并且不经常使用 Ruby，请使用 Homebrew 安装 Ruby。
```
brew install ruby
```
Ruby 开发者使用 Ruby 版本管理器来安装 Ruby。

克隆 'is-bio' 项目并安装 Ruby gems

git clone https://github.com/is-bio/is-bio.git
cd /path/to/is-bio
bundle install

设置 credentials

cd /path/to/is-bio
# 此文件包含所有需要设置的credentials。
cat config/credentials.yml.example # 使用下一个命令设置"所有"credentials：
# 保存后，将创建 "config/credentials.yml.enc" 和 "config/master.key"。
# 为了使修改后的credentials生效，您需要重新启动 Rails Web 服务器。
EDITOR="vim" bin/rails credentials:edit

config/credentials.yml.example 中显示的所有项目都需要设置！

如果您仍然不确定如何设置某些项目，可以先使用 config/credentials.yml.example 中的默认值，然后在发现相关功能不起作用时，根据相关说明正确设置值。

准备 SQLite 数据库

cd /path/to/is-bio
rails db:migrate # 数据库文件是 `./storage/development.sqlite3`。运行它没有副作用。
rails db:seed # 运行它没有副作用。

安装主题

阅读 docs/install_theme.md。

启动 Rails Web 服务器

cd /path/to/is-bio
rails assets:precompile # 每当任何资源发生更改时都需要执行此操作。运行它没有副作用。
rails s # 启动 Rails Web 服务器。

访问 http://localhost:3000/。

创建管理员用户

cd /path/to/is-bio
vim db/seeds.rb

取消注释代码的前几行以创建管理员用户。

rails db:seed
git restore db/seeds.rb

使用此电子邮件地址和密码登录 http://localhost:3000/admin。

通过 SMTP 发送电子邮件

请按照 docs/send_email_via_smtp_guide.md 中的说明完成此步骤。

启动 "Solid Queue" 处理后台任务

博客文章、图片、文件同步、发送电子邮件、生成缩略图等都需要启动后台任务！

cd /path/to/is-bio
rm public/assets/.manifest.json
rails assets:precompile # 您需要重新启动 Rails Web 服务器才能使更改生效。
bin/jobs # 启动它

首先，使用电子邮件地址和密码登录 http://localhost:3000/admin。
其次，使用此用户名和密码登录 http://localhost:3000/jobs 查看是否有失败的任务。
- 用户名和密码可以通过运行 EDITOR="vim" bin/rails credentials:edit 获取。

创建并安装您的 "GitHub App" 以将本地 "markdown-blog" 仓库的文件更改同步到博客网站

在这里，博客网站是您的本地 Rails Web 服务器。如果您 deploy_on_CentOS10.md，博客网站是您的真实 Web 服务器。

如果您不熟悉如何使用 Markdown 和 Git 发布博客，请阅读 markdown-blog。

请按照 GitHub_App.md 中的说明完成此步骤。

其它功能：自动生成图片缩略图

欢迎大家提出批评和改进意见。简历和作品集功能还在开发中。

Clacky AI 和 Cursor AI 用 Ruby 语言做力扣题解的对比

gazeldx — Tue, 25 Mar 2025 17:05:43 +0800

两个 AI 编程工具 Clacky AI 和 Cursor AI，用了同样的提示词，没有修改任何设置，随机选四道题目，要求它们参考我写的其它语言的题解，写出 Ruby 版本的题解。大家欣赏下，看看喜欢哪个。

力扣题一

https://leetcode.blog/zh/leetcode/28-find-the-index-of-the-first-occurrence-in-a-string

Clacky AI 给出的实现代码：

# @param {String} haystack
# @param {String} needle
# @return {Integer}
def str_str(haystack, needle)
  (0...haystack.length).each do |i|
    j = 0

    while i + j < haystack.length && haystack[i + j] == needle[j]
      j += 1

      return i if j == needle.length
    end
  end

  -1
end

Cursor AI 给出的实现代码：

def str_str(haystack, needle)
  for i in 0...haystack.length
    j = 0

    while i + j < haystack.length && haystack[i + j] == needle[j]
      j += 1

      if j == needle.length
        return i
      end
    end
  end

  -1
end

本题结论：: Clacky AI 胜出。因为用.each了，符合 Ruby 风格。

力扣题二

https://leetcode.blog/zh/leetcode/160-intersection-of-two-linked-lists

Clacky AI 给出的实现代码：

# Definition for singly-linked list.
# class ListNode
#     attr_accessor :val, :next
#     def initialize(val)
#         @val = val
#         @next = nil
#     end
# end

# @param {ListNode} head_a
# @param {ListNode} head_b
# @return {ListNode}
def get_intersection_node(head_a, head_b)
    node_count_a = 0
    node_count_b = 0

    node = head_a
    while node
        node_count_a += 1
        node = node.next
    end

    node = head_b
    while node
        node_count_b += 1
        node = node.next
    end

    bigger = head_a
    smaller = head_b

    if node_count_b > node_count_a
        bigger = head_b
        smaller = head_a
    end

    (node_count_b - node_count_a).abs.times do
        bigger = bigger.next
    end

    while bigger && smaller
        return bigger if bigger == smaller

        bigger = bigger.next
        smaller = smaller.next
    end

    nil
end

Cursor AI 给出的实现代码，与 Clacky AI 相同，仅有两处不同：

一，注释部分不同。Cursor AI 以下内容没有。

# @param {ListNode} head_a
# @param {ListNode} head_b
# @return {ListNode}

而没有是符合预期的，Clacky AI 总是创造性地加上参数和返回值注释。

二，Indents 不同，Clacky AI 用了 4 个空格做 Indents，这个不符合 Ruby 风格。

本题结论：平手，Clacky AI 略下风。

力扣题三

https://leetcode.blog/zh/leetcode/383-ransom-note

Clacky AI 给出的实现代码：

def can_construct(ransom_note, magazine)
    char_to_count = Hash.new(0)

    magazine.each_char { |c| char_to_count[c] += 1 }

    ransom_note.each_char do |c|
        char_to_count[c] -= 1
        return false if char_to_count[c] < 0
    end

    true
end

(这里，我开始提醒 Clacky AI 要用 indents 2。希望下次会改正，果然，下一题改正了)

Cursor AI 给出的代码完全相同，但 indents 为 2，这是好的。

本题结论：平手。

力扣题四

https://leetcode.blog/zh/leetcode/59-spiral-matrix-ii

Clacky AI 给出的实现代码：

class Solution
  def generate_matrix(n)
    @matrix = Array.new(n) { Array.new(n) }
    @increments = [[0, 1], [1, 0], [0, -1], [-1, 0]]
    @increment_index = 0

    i = 0
    j = 0
    num = 1

    while num <= n * n
      @matrix[i][j] = num
      num += 1

      increment = get_increment(i, j)
      i += increment[0]
      j += increment[1]
    end

    @matrix
  end

  private

  def get_increment(i, j)
    increment = @increments[@increment_index]
    next_i = i + increment[0]
    next_j = j + increment[1]

    if next_i < 0 || next_i >= @matrix.size || 
       next_j < 0 || next_j >= @matrix.size || 
       @matrix[next_i][next_j]
      @increment_index += 1
      @increment_index %= @increments.size
    end

    @increments[@increment_index]
  end
end

Cursor AI 给出的实现代码：

class Solution
  def initialize
    @matrix = nil
    @increments = [[0, 1], [1, 0], [0, -1], [-1, 0]]
    @increment_index = 0
  end

  def generate_matrix(n)
    @matrix = Array.new(n) { Array.new(n, 0) }
    i = 0
    j = 0
    num = 1

    while num <= n * n
      @matrix[i][j] = num
      num += 1

      increment = get_increment(i, j)
      i += increment[0]
      j += increment[1]
    end

    @matrix
  end

  private

  def get_increment(i, j)
    increment = @increments[@increment_index]
    i += increment[0]
    j += increment[1]

    if i < 0 || i >= @matrix.length ||
       j < 0 || j >= @matrix.length ||
       @matrix[i][j] > 0
      @increment_index += 1
      @increment_index %= @increments.length
    end

    @increments[@increment_index]
  end
end

区别：Cursor AI 把实例变量定义在 initialize 方法中，这导致多写了两行代码，另外还多写了一次 @matrix = nil，这个不符合我的刷题喜好。

Clacky AI 定义了 local variables next_i和next_j，这是不符合我的预期的，因为我给出其它语言的例子了。但这个创造感觉还是不错的，可读性提高了。

本题结论：Clacky AI 胜出。

另外，Clacky AI 每一个题解都少输出了一行三个上斜点，后来我提醒它，它最后改正了。

最终结论

本次测试，我发现 Clacky AI 创造性可能更强一点，比如我之前预期是用变量名 charactor的，它认为不好，改成了c了。

Cursor AI 更按部就班一点，因为我明确地告诉他们，依照我手写的其它语言的例子去做，但 Clacky AI 还是会进行再创造，不过几次再创造我愿意接纳了。

最终，我将选择 Clacky AI 写的题解，当然，依然是我的题解，因为逻辑上我要求它们参考我手写的其它语言的例子。

欢迎评论。

Ruby-China 可以安装成一个 App. 但缺少了一个浏览器的后退功能。不太方便。

gazeldx — Tue, 04 Jul 2023 17:59:30 +0800

Best way for Python and Java to reverse a string

gazeldx — Fri, 04 Mar 2022 16:51:59 +0800

Python

According to reverse-a-string-in-python, the solution would be

'hello world'[::-1]

To make it more readable, I have to define a function:

def reverse(target_string):
    return target_string[::-1]

Java

According to reverse-a-string-in-java, the solution would be

new StringBuilder('hello world').reverse().toString()

I think for Python, there should be a method called reverse() to let me use it like 'hello world'.reverse().

How to use Hotwire Turbo in your Rails 6 project with Webpacker.

gazeldx — Thu, 11 Nov 2021 15:16:44 +0800

Background

Turbo can help refresh only a part of our webpage and don't need to refresh the whole page.

If we build a Single Page App or traditional web, we can do this by Ajax with json and JavaScript.

Now we have Turbo and don't need to write Ajax, json or JavaScript to make it.

After you have finished this tutorial, you will see that your Rails app works like a SPA. Cool. Isn't it.

Turbolinks is the old name of Turbo.

From https://github.com/hotwired/turbo-rails , we can see the official example video is represented with an assets pipeline example, not with Webpacker.

Goal

Here I will let you know how to integrate Turbo with Webpacker and Bootstrap 5.

Imagine that we have a navigation bar with some links. Each of those links maps to a Rails route. We hope that when we click those links, the navigation itself, the header and the footer not to be refreshed.

Steps

Create a Rails 6 project (the default is using webpacker).
Add gem 'turbo-rails' to and remove gem 'turbolinks' from Gemfile.
Run bundle install.
Run rails turbo:install.
Run yarn add @hotwired/turbo-rails.
Find a file (like: frontend.js) under app/javascript/packs/ and add import "@hotwired/turbo-rails" to the first line. Then remove import Turbolinks from "turbolinks" and Turbolinks.start() from this file.

Also in this file, add these code to make the frame have a blue border:

turbo-frame {
  display: block;
  border: 1px solid blue;
}

In the file app/views/layouts/application.html.erb, add these:

<head>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= javascript_pack_tag 'frontend' %>
    <%= stylesheet_pack_tag 'frontend' %>
</head>

<div class="row">
  <ul>
    <li>
      <a data-turbo-frame="main_frame" href="<%= products_path %>">Product List </a>
    </li>
    <li>
      <a data-turbo-frame="main_frame" href="<%= cdrs_path %>">CDR List </a>
    </li>
  </ul>
</div>

<div class="row">
  <turbo-frame id="main_frame">
    <%= yield %>
  </turbo-frame>
</div>

In app/controllers/products_controller.rb, write this:

class ProductsController < BaseController
  # Remember to comment out this line like this. Just don't use a layout specifically. If you write a layout specifically, the layout will always be used!
  # Also don't use `layout false`, otherwise when user open the url in a new browser tab, the default layout `application` was lost.
  # In the end, you will have only one layout for the `Turbo` usage, that is the `app/views/layouts/application.html.erb`. And you need never specifically write `layout 'application'`. 
  # That is OK and good enough because you can dynamically generate the content of this `application.html.erb`.
  # You can have other `logouts` for other pages which don't use `Turbo` like `sign_in` or `register` pages.
  # layout 'application'

  def index
    @products = Product.all
  end
end

In app/views/products/index.html.erb, write this:

<%= turbo_frame_tag "main_frame" do %>
  <div class="row">
    <h4>Product List</h4>
  </div>

  <div class="row">
    <div>
      <div class="card">
        <div class="card-body">
          <div class="table-responsive">
            <table class="table table-centered table-borderless table-hover nowrap">
              <thead class="table-light">
                <tr>
                  <th>Product Name</th>
                  <th>Actions</th>
                </tr>
              </thead>

              <tbody>
                <% @products.each do |product| %>
                  <tr>
                    <td><%= product.name %></td>
                    <td>
                      <%= button_to i18n_action(:delete), product_path(product), method: :delete, data: { confirm: i18n_action(:delete_confirm), disable_with: 'Deleting...' }, class: 'btn btn-primary btn-sm' %>
                    </td>
                  </tr>
                <% end %>
              </tbody>
            </table>
          </div>
        </div>
      </div>
    </div>
  </div>

  <%= enable_tooltip %>
<% end %>

Now you can see when you click the Product List link, only the main_frame is refreshed. And the html returned from the Server side is generated only from the code in app/views/products/index.html.erb. Code of app/views/layouts/application.html.erb are not used at all.

Tips

According to https://discuss.hotwired.dev/t/destroy-record-in-turbo-frame/2731/17 , you will have to use button_to tag like above in the app/views/products/index.html.erb to make the record deletion.
The Bootstrap tooltip will not be displayed because the html in main_frame is generated after you click the nav link. So you will have to add this helper method:

def enable_tooltip
  raw '<script>
var tooltipTriggerList = [].slice.call(document.querySelectorAll(\'[data-bs-toggle="tooltip"]\'))
var tooltipList = tooltipTriggerList.map(function (tooltipTriggerEl) {
  return new bootstrap.Tooltip(tooltipTriggerEl)
})
</script>'
end

and call this method in app/views/products/index.html.erb like the example above.

If you are using Devise, you may find that the error message may not be displayed when typing a wrong password.

My solution is that you don't use app/javascript/packs/frontend.js in the layout of sign_in page.

Instead, you can write a new one like app/javascript/packs/blank.js, in this blank.js, don't add import "@hotwired/turbo-rails".

And use the blank.js in the new layout file app/views/layouts/blank.html.erb for the Devise sign_in page , like this:

<head>
    <%= javascript_pack_tag 'blank' %>
    <%= stylesheet_pack_tag 'blank' %>
</head>

[南京] 云启盛鼎诚招 Rails, JavaScript 全栈工程师 (10-25k)【已终止】

gazeldx — Tue, 20 Jul 2021 17:32:40 +0800

公司简介

深圳市云启盛鼎科技有限公司南京分公司为深圳鼎信通达股份有限公司子公司。深圳鼎信通达股份有限公司成立于 2011 年，简称为鼎信通达，公司于 2016 年 12 月成功挂牌新三板，股票代码：870319。鼎信通达专注于下一代 IP 通信产品的研发、生产、销售和服务。公司现有员工 300 人，在北京、上海、杭州、武汉、成都设有分公司、子公司、研发中心。公司团队核心骨干来自于国内和国际一流通信企业，平均行业背景超过 10 年。设备及方案广泛应用于三大运营商、电力行业、金融行业、军工行业、煤矿行业、交通行业、呼叫中心及政企办公。随着业务健康发展壮大，鼎信通达计划用三年时间实现从新三板转创业版上市。

现深圳鼎信通达股份有限公司联合南京昆石网络技术有限公司、统一通信（苏州）有限公司，共同在南京设立深圳市云启盛鼎科技有限公司南京分公司，专注于开创、研发云通信平台，继续用技术创新和创新性服务为客户创造价值，以进取、创新的精神打造全球 IP 通信的领先品牌。

招 Ruby, JavaScript 全栈工程师两名，初、中、高级不限

岗位职责

作为团队核心开发，参与核心产品对应的需求讨论、业务建模、以及技术研发和上线工作；
修复 Bug, 优化系统，处理线上版本紧急技术问题，参与解决高并发问题；
确保线上环境的稳定运行，保证业务的高可用性。

后端能力

计算机及相关专业，本科及以上学历。
精通 Ruby on Rails, RSpec, simple_form, Webpacker, Sidekiq。
熟悉 PostgreSQL、Redis。
懂 Nginx, RabbitMQ, 和 Python 开发者加分。

前端能力

熟练掌握 JavaScript, CSS，Bootstrap。
熟悉 ReactJS (首选）或 JQuery, Vue。
了解 Material-UI。

职业素养

懂 Clean Code 原理，喜欢重构代码，有黑客精神。
具备良好的产品思维，能在没有产品经理的情况下，独立设计有品味的产品。
充满好奇心，享受 coding，学习能力强，对技术有热情，关注技术发展方向。
具有较强的责任心，良好沟通能力和团队合作精神。
具有良好的英语书面表达能力，过 6 级者优先。

工作地点与时间

江苏省南京市秦淮区中山东路 532-2 号金蝶软件园 D 栋 205 室。不支持远程。
周末双休，早 9:00 到下午 6:00。中午休息 1.5 小时，法定假日正常休息。

薪资待遇

10-25K 每月。
五险一金。
年底根据业绩情况发放奖金。
双休。
配备 MacBook Pro.

请有意向者发送简历邮件到 zhangjian@yunqisd.com

[苏州] 东湾信息招聘 Ruby 全栈程序员两名（12-20K，14 薪，双休）(已关闭)

gazeldx — Mon, 23 Nov 2020 16:17:54 +0800

苏州东湾信息

我们主要服务于美国客户，目前公司团队 35 人，80% 以上为程序员。成立仅 3 年，但发展迅速。

美国公司文化，双休，不加班。

团队成员积极乐观，互相关心，工作氛围佳。每个月都团建。

工作地址：苏州工业园区腾飞创新园 A1 塔楼 913&914 室

职位要求

后端能力

计算机相关专业，本科及以上学历。
熟练掌握基本算法与数据结构。
具有优良的编码风格和习惯。
熟悉 HTTP、TCP/IP 协议，RESTful 规范。
熟悉 Linux 开发环境，zsh/vim/git者优先。
良好的 Ruby 或者 Python/PHP 语言基础及开发/重构能力。
具有良好的英语书面表达能力，过 6 级者优先。
熟练使用 Ruby On Rails 或 Flask, Django, Laravel 等主流开发框架者优先。
了解 PostgreSQL、MySQL、Redis、Memcached 等数据库及缓存的使用和基本原理者优先。

前端能力

熟练掌握 HTML5, CSS3, JavaScript 等前端语言。
熟悉 W3C 标准与 ES 规范，熟悉 Web 语义化。
熟练使用至少一种 JS 框架，熟悉 ReactJS, Vue, AngularJS 中的一种。
对代码规范有严格的要求。

职业素养

充满好奇心，享受 coding，学习能力强，对技术有热情，关注技术发展方向。
具有较强的责任心，良好沟通能力和团队合作精神。

薪资待遇

每月 12-20K，14 薪（5 号发工资，试用期不打折）。
五险一金。
配备工作电脑（自备电脑者每月补贴 200 元）。
入职即享带薪年假（5 天起）。

请有意向者发送简历邮件到 zhangjian@easternbay.cn，来信必回 :)

Learn Rails 5 by Reading Source Code

gazeldx — Tue, 05 Mar 2019 15:08:19 +0800

Posted at: https://github.com/gazeldx/Learn-Rails-by-Reading-Source-Code

Learn-Rails-by-Reading-Source-Code

Part 0: Before reading Rails 5 source code
- What will you learn from this tutorial?
Part 1: Your app: an instance of YourProject::Application
Part 2: config
Part 3: Every request and response
Part 4: What does $ rails server do?

Part 0: Before reading Rails 5 source code

1) I suggest you learn Rack http://rack.github.io/ first.

In rack, an object with call method is a rack app.

So what is the object with call method in Rails? I will answer this question in Part 1.

2) You need a good IDE which can help for debugging. I use RubyMine.

What will you learn from this tutorial?

How does Rails start your application?
How does Rails process every request?
How does Rails combine ActionController, ActionView and Routes together?
How does puma, rack, Rails work together?
What's Puma's multiple threads?

I should start with the command $ rails server, but I put this to Part 4. Because it's a little bit complex.

Part 1: Your app: an instance of YourProject::Application

Assume your Rails app's class name is YourProject::Application (defined in ./config/application.rb).

First, I will give you a piece of important code.

# ./gems/railties-5.2.2/lib/rails/commands/server/server_command.rb
module Rails
  module Command
    class ServerCommand < Base
      def perform
        # ...
        Rails::Server.new(server_options).tap do |server|
          # APP_PATH is '/Users/your_name/your_project/config/application'.
          # require APP_PATH will create the 'Rails.application' object.
          # Actually, 'Rails.application' is an instance of `YourProject::Application`.
          # Rack server will start 'Rails.application'.
          require APP_PATH

          Dir.chdir(Rails.application.root)

          server.start
        end
      end
    end
  end

  class Server < ::Rack::Server
    def start
      #...
      # 'wrapped_app' will get an well prepared app from `./config.ru` file.
      # 'wrapped_app' will return an instance of `YourProject::Application`.
      # But the instance of `YourProject::Application` returned is not created in 'wrapped_app'.
      # It has been created when `require APP_PATH` in previous code: 
      # in Rails::Command::ServerCommand#perform
      wrapped_app   

      super # Will invoke ::Rack::Server#start. 
    end
  end
end

A rack server need to start with an App object. The App object should have a call method.

config.ru is the conventional entry file for rack app. So let's look at it.

# ./config.ru
require_relative 'config/environment'

run Rails.application # It seems that this is the app.

Let's test it by Rails.application.respond_to?(:call), it returns true.

Let's step into Rails.application.

# ./gems/railties-5.2.2/lib/rails.rb
module Rails
  class << self
    @application = @app_class = nil

    attr_accessor :app_class

    # Oh, 'application' is a class method for module 'Rails'. It is not an object.
    # But it returns an object which is an instance of 'app_class'.
    # So it is important for us to know what class 'app_class' is.
    def application
      @application ||= (app_class.instance if app_class)  
    end
  end
end

Because Rails.application.respond_to?(:call) returns true, app_class.instance has a call method.

When was app_class set?

module Rails
  class Application < Engine
    class << self
      def inherited(base) # This is a hooked method.
        Rails.app_class = base # This line set the 'app_class'.
      end
    end
  end
end

Rails::Application is inherited by YourProject,

# ./config/application.rb
module YourProject
  # The hooked method `inherited` will be invoked here.
  class Application < Rails::Application
  end
end

So YourProject::Application is the Rails.app_class here.

You may have a question: When does Rails execute the code in ./config/application.rb?

To answer this question, we need to look back to config.ru.

# ./config.ru
require_relative 'config/environment' # Let's step into this line.

run Rails.application # It seems that this is the app.

# ./config/environment.rb
# Load the Rails application.
require_relative 'application' # Let's step into this line.

# Initialize the Rails application.
Rails.application.initialize!

# ./config/application.rb
require_relative 'boot'

require 'rails/all'

# Require the gems listed in Gemfile, including any gems
# you've limited to :test, :development, or :production.
Bundler.require(*Rails.groups)

module YourProject
  # The hooked method `inherited` will be invoked here.
  class Application < Rails::Application
    config.load_defaults 5.2
    config.i18n.default_locale = :zh
  end
end

Because YourProject::Application is Rails.app_class, app_class.instance is YourProject::Application.instance.

But where is the call method?

call method should be a method of YourProject::Application.instance.

The call method processes every request. Here it is.

# ./gems/railties/lib/rails/engine.rb
module Rails
  class Engine < Railtie
    def call(env) # This method will process every request. It is invoked by Rack. So it is very important. 
      req = build_request env
      app.call req.env # We will discuss the 'app' object later.
    end
  end
end

# ./gems/railties/lib/rails/application.rb
module Rails
  class Application < Engine
  end
end

# ./config/application.rb
module YourProject
  class Application < Rails::Application
  end
end

Ancestor's chain is YourProject::Application < Rails::Application < Rails::Engine < Rails::Railtie.

So YourProject::Application.new.respond_to?(:call) returns true.

But what does app_class.instance really do?

instance is just a method name. What we really expects is something like app_class.new.

Let's look at the definition of instance.

# ./gems/railties/lib/rails/application.rb
module Rails
  class Application < Engine
    def instance
      super.run_load_hooks! # This line confused me at the beginning. 
    end
  end
end

After a deep research, I realized that this code is equal to:

def instance
  return_value = super # Keyword 'super' means call the ancestor's same name method: 'instance'.
  return_value.run_load_hooks!
end

# ./gems/railties/lib/rails/railtie.rb
module Rails
  class Railtie
    def instance
      # 'Rails::Railtie' is the top ancestor class.
      # Now 'app_class.instance' is 'YourProject::Application.new'.
      @instance ||= new
    end
  end
end

module Rails
  def application
    @application ||= (app_class.instance if app_class)
  end
end

So YourProject::Application.new is Rails.application.

Rack server will start Rails.application in the end.

Rails.application is an important object in Rails.

And you'll only have one Rails.application in one puma process.

Multiple threads in a puma process shares the Rails.application.

Part 2: config

The first time we see the config is in ./config/application.rb.

# ./config/application.rb
#...
module YourProject
  class Application < Rails::Application
    # Actually, `config` is a method of `YourProject::Application`.
    # It is defined in it's grandfather's father: `Rails::Railtie`
    config.load_defaults 5.2  # Let's step into this line to see what is config.
    config.i18n.default_locale = :zh
  end
end

module Rails
  class Railtie
    class << self
      # Method `:config` is defined here.
      # Actually, method `:config` is delegated to another object `:instance`.
      delegate :config, to: :instance 

      # Call `YourProject::Application.config` will actually call `YourProject::Application.instance.config`
      def instance
        # return an instance of `YourProject::Application`.
        # Call `YourProject::Application.config` will actually call `YourProject::Application.new.config`
        @instance ||= new 
      end
    end
  end

  class Engine < Railtie
  end

  class Application < Engine
    class << self
      def instance
        # 'super' will call `:instance` method in `Railtie`, 
        # which will return an instance of `YourProject::Application`.
        return_value = super  
        return_value.run_load_hooks!
      end
    end

    def run_load_hooks!
      return self if @ran_load_hooks
      @ran_load_hooks = true

      # ...
      self # `self` is an instance of `YourProject::Application`, and `self` is `Rails.application`.
    end

    # This is the method `config`.
    def config
      # It is an instance of class `Rails::Application::Configuration`. 
      # Please notice that `Rails::Application` is superclass of `YourProject::Application` (self's class).   
      @config ||= Application::Configuration.new(self.class.find_root(self.class.called_from))
    end
  end
end

In the end, YourProject::Application.config === Rails.application.config returns true.

Invoke Class's config method become invoke the class's instance's config method.

module Rails
  class << self
    def configuration
      application.config
    end 
  end
end

So Rails.configuration === Rails.application.config returns true.

FYI:

module Rails
  class Application
    class Configuration < ::Rails::Engine::Configuration
    end
  end

  class Engine
    class Configuration < ::Rails::Railtie::Configuration
      attr_accessor :middleware

      def initialize(root = nil)
        super()
        #...
        @middleware = Rails::Configuration::MiddlewareStackProxy.new
      end
    end
  end

  class Railtie
    class Configuration
    end
  end
end

Part 3: Every request and response

Imagine we have this route for the home page.

# ./config/routes.rb
Rails.application.routes.draw do
  root 'home#index' # HomeController#index
end

Puma

When a request is made from client, puma will process the request in Puma::Server#process_client.

If you want to know how puma enter the method Puma::Server#process_client, please read part 4 or just search 'process_client' in this document.

# ./gems/puma-3.12.0/lib/puma/server.rb
require 'socket'

module Puma
  # The HTTP Server itself. Serves out a single Rack app.
  #
  # This class is used by the `Puma::Single` and `Puma::Cluster` classes
  # to generate one or more `Puma::Server` instances capable of handling requests.
  # Each Puma process will contain one `Puma::Server` instacne.
  #
  # The `Puma::Server` instance pulls requests from the socket, adds them to a
  # `Puma::Reactor` where they get eventually passed to a `Puma::ThreadPool`.
  #
  # Each `Puma::Server` will have one reactor and one thread pool.
  class Server
    def initialize(app, events=Events.stdio, options={})
      # app: #<Puma::Configuration::ConfigMiddleware:0x00007fcf1612c338 
      #        @app = #<YourProject::Application:0x00007fcf160fb120>
      #        @config = #<Puma::Configuration:0x00007fcf169a6c98>         
      #       >
      @app = app
      #...
    end

    # Given a connection on +client+, handle the incoming requests.
    #
    # This method support HTTP Keep-Alive so it may, depending on if the client
    # indicates that it supports keep alive, wait for another request before
    # returning.
    #
    def process_client(client, buffer)
      begin
        # ...
        while true
          # Let's step into this line.
          case handle_request(client, buffer) # Will return true in this example.
          when true
            return unless @queue_requests
            buffer.reset

            ThreadPool.clean_thread_locals if clean_thread_locals

            unless client.reset(@status == :run)
              close_socket = false
              client.set_timeout @persistent_timeout
              @reactor.add client
              return
            end
          end
        end
        # ...
      ensure
        buffer.reset
        client.close if close_socket
        #...
      end
    end

    # Given the request +env+ from +client+ and a partial request body
    # in +body+, finish reading the body if there is one and invoke
    # the rack app. Then construct the response and write it back to
    # +client+
    #
    def handle_request(req, lines)
      env = req.env
      # ... 
      # app: #<Puma::Configuration::ConfigMiddleware:0x00007fcf1612c338 
      #        @app = #<YourProject::Application:0x00007fcf160fb120>
      #        @config = #<Puma::Configuration:0x00007fcf169a6c98>         
      #       >
      status, headers, res_body = @app.call(env) # Let's step into this line.

      # ...
      return keep_alive
    end    
  end
end

# ./gems/puma-3.12.0/lib/puma/configuration.rb
module Puma
  class Configuration
    class ConfigMiddleware
      def initialize(config, app)
        @config = config
        @app = app
      end

      def call(env)
        env[Const::PUMA_CONFIG] = @config
        # @app: #<YourProject::Application:0x00007fb4b1b4bcf8>
        @app.call(env)
      end
    end
  end
end

Rack apps

As we see when Ruby enter Puma::Configuration::ConfigMiddleware#call, the @app is YourProject::Application instance.

It is just the Rails.application.

Rack need a call method to process request.

Rails defined this call method in Rails::Engine#call, so that YourProject::Application instance will have a call method.

# ./gems/railties/lib/rails/engine.rb
module Rails
  class Engine < Railtie
    def call(env) # This method will process every request. It is invoked by Rack. 
      req = build_request env
      app.call req.env # The 'app' method is blow.
    end

    def app
      # FYI,
      # caller: [
      # "../gems/railties-5.2.2/lib/rails/application/finisher.rb:47:in `block in <module:Finisher>'", 
      # "../gems/railties-5.2.2/lib/rails/initializable.rb:32:in `instance_exec'", 
      # "../gems/railties-5.2.2/lib/rails/initializable.rb:32:in `run'", 
      # "../gems/railties-5.2.2/lib/rails/initializable.rb:63:in `block in run_initializers'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:228:in `block in tsort_each'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:350:in `block (2 levels) in each_strongly_connected_component'",
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:431:in `each_strongly_connected_component_from'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:349:in `block in each_strongly_connected_component'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:347:in `each'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:347:in `call'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:347:in `each_strongly_connected_component'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:226:in `tsort_each'", 
      # "../ruby-2.6.0/lib/ruby/2.6.0/tsort.rb:205:in `tsort_each'", 
      # "../gems/railties-5.2.2/lib/rails/initializable.rb:61:in `run_initializers'", 
      # "../gems/railties-5.2.2/lib/rails/application.rb:361:in `initialize!'", 
      # "/Users/lanezhang/projects/mine/free-erp/config/environment.rb:5:in `<top (required)>'", 
      # "config.ru:2:in `require_relative'", "config.ru:2:in `block in <main>'", 
      # "../gems/rack-2.0.6/lib/rack/builder.rb:55:in `instance_eval'", 
      # "../gems/rack-2.0.6/lib/rack/builder.rb:55:in `initialize'", 
      # "config.ru:in `new'", "config.ru:in `<main>'", 
      # "../gems/rack-2.0.6/lib/rack/builder.rb:49:in `eval'", 
      # "../gems/rack-2.0.6/lib/rack/builder.rb:49:in `new_from_string'", 
      # "../gems/rack-2.0.6/lib/rack/builder.rb:40:in `parse_file'", 
      # "../gems/rack-2.0.6/lib/rack/server.rb:320:in `build_app_and_options_from_config'", 
      # "../gems/rack-2.0.6/lib/rack/server.rb:219:in `app'", 
      # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:27:in `app'", 
      # "../gems/rack-2.0.6/lib/rack/server.rb:357:in `wrapped_app'", 
      # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:92:in `log_to_stdout'", 
      # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:54:in `start'", 
      # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:149:in `block in perform'",
      # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:144:in `tap'", 
      # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:144:in `perform'",
      # "../gems/thor-0.20.3/lib/thor/command.rb:27:in `run'", 
      # "../gems/thor-0.20.3/lib/thor/invocation.rb:126:in `invoke_command'",
      # "../gems/thor-0.20.3/lib/thor.rb:391:in `dispatch'", 
      # "../gems/railties-5.2.2/lib/rails/command/base.rb:65:in `perform'",
      # "../gems/railties-5.2.2/lib/rails/command.rb:46:in `invoke'", 
      # "../gems/railties-5.2.2/lib/rails/commands.rb:18:in `<top (required)>'", 
      # "../path/to/your_project/bin/rails:5:in `require'",
      # "../path/to/your_project/bin/rails:5:in `<main>'"
      # ]
      puts "caller: #{caller.inspect}"

      # You may want to know when is the @app first time initialized.
      # It is initialized when 'config.ru' is load by rack server.
      # Please search `Rack::Server#build_app_and_options_from_config` in this document for more information.
      # When `Rails.application.initialize!` (in ./config/environment.rb) executed, @app is initialized. 
      @app || @app_build_lock.synchronize { # '@app_build_lock = Mutex.new', so multiple threads share one '@app'.
        @app ||= begin
          # In the end, config.middleware will be an instance of ActionDispatch::MiddlewareStack with preset instance variable @middlewares (which is an Array). 
          stack = default_middleware_stack # Let's step into this line
          # 'middleware' is a 'middleware_stack'!
          config.middleware = build_middleware.merge_into(stack)
          # FYI, this line is the last line and the result of this line is the return value for @app.
          config.middleware.build(endpoint) # look at this endpoint below. We will enter method `build` later.
        end
      }

#  @app: #<Rack::Sendfile:0x00007ff14d905f60 
#          @app=#<ActionDispatch::Static:0x00007ff14d906168 
#                 @app=#<ActionDispatch::Executor:0x00007ff14d9061b8 
#                        ...
#                           @app=#<Rack::ETag:0x00007fa1e540c4f8  
#                                  @app=#<Rack::TempfileReaper:0x00007fa1e540c520 
#                                         @app=#<ActionDispatch::Routing::RouteSet:0x00007fa1e594cbe8>
#                                 >
#                         ...    
#                        >
#                             
#                 >
#         >
      @app
    end

    # Defaults to an ActionDispatch::Routing::RouteSet instance.
    def endpoint
      ActionDispatch::Routing::RouteSet.new_with_config(config)
    end
  end
end

# ./gems/railties/lib/rails/application...
module Rails
  class Application < Engine
    def default_middleware_stack
      default_stack = DefaultMiddlewareStack.new(self, config, paths)
      default_stack.build_stack # Let's step into this line.
    end

    class DefaultMiddlewareStack
      attr_reader :config, :paths, :app

      def initialize(app, config, paths)
        @app = app
        @config = config
        @paths = paths
      end

      def build_stack
        ActionDispatch::MiddlewareStack.new do |middleware|
          if config.force_ssl
            middleware.use ::ActionDispatch::SSL, config.ssl_options
          end

          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header

          if config.public_file_server.enabled
            headers = config.public_file_server.headers || {}

            middleware.use ::ActionDispatch::Static, paths["public"].first, index: config.public_file_server.index_name, headers: headers
          end

          if rack_cache = load_rack_cache
            require "action_dispatch/http/rack_cache"
            middleware.use ::Rack::Cache, rack_cache
          end

          if config.allow_concurrency == false
            # User has explicitly opted out of concurrent request
            # handling: presumably their code is not threadsafe

            middleware.use ::Rack::Lock
          end

          middleware.use ::ActionDispatch::Executor, app.executor

          middleware.use ::Rack::Runtime
          middleware.use ::Rack::MethodOverride unless config.api_only
          middleware.use ::ActionDispatch::RequestId
          middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies

          middleware.use ::Rails::Rack::Logger, config.log_tags
          middleware.use ::ActionDispatch::ShowExceptions, show_exceptions_app
          middleware.use ::ActionDispatch::DebugExceptions, app, config.debug_exception_response_format

          unless config.cache_classes
            middleware.use ::ActionDispatch::Reloader, app.reloader
          end

          middleware.use ::ActionDispatch::Callbacks
          middleware.use ::ActionDispatch::Cookies unless config.api_only

          if !config.api_only && config.session_store
            if config.force_ssl && config.ssl_options.fetch(:secure_cookies, true) && !config.session_options.key?(:secure)
              config.session_options[:secure] = true
            end
            middleware.use config.session_store, config.session_options
            middleware.use ::ActionDispatch::Flash
          end

          unless config.api_only
            middleware.use ::ActionDispatch::ContentSecurityPolicy::Middleware
          end

          middleware.use ::Rack::Head
          middleware.use ::Rack::ConditionalGet
          middleware.use ::Rack::ETag, "no-cache"

          middleware.use ::Rack::TempfileReaper unless config.api_only
        end
       end
     end
  end
end

# ./gems/actionpack-5.2.2/lib/action_dispatch/middleware/stack.rb
module ActionDispatch
  class MiddlewareStack
    def use(klass, *args, &block)
      middlewares.push(build_middleware(klass, args, block))
    end

    def build_middleware(klass, args, block)
      Middleware.new(klass, args, block)
    end    

    def build(app = Proc.new)
      # See Enumerable#inject for more information.
      return_val = middlewares.freeze.reverse.inject(app) do |a, middleware|
        # a: app, and will be changed when iterating
        # middleware: #<ActionDispatch::MiddlewareStack::Middleware:0x00007f8a4fada6e8>, 'middleware' will be switched to another instance of ActionDispatch::MiddlewareStack::Middleware when iterating
        middleware.build(a) # Let's step into this line.
      end

      return_val
    end    

    class Middleware
      def initialize(klass, args, block)
        @klass = klass
        @args  = args
        @block = block
      end

      def build(app)
        # klass is rack middleware like : Rack::TempfileReaper, Rack::ETag, Rack::ConditionalGet or Rack::Head, etc.
        # It's typical rack app to use these middlewares.
        # See https://github.com/rack/rack-contrib/blob/master/lib/rack/contrib for more information. 
        klass.new(app, *args, &block)
      end      
    end
  end
end

The core app: ActionDispatch::Routing::RouteSet instance

# Paste again FYI. 
#  @app: #<Rack::Sendfile:0x00007ff14d905f60 
#          @app=#<ActionDispatch::Static:0x00007ff14d906168 
#                 @app=#<ActionDispatch::Executor:0x00007ff14d9061b8 
#                        ...
#                           @app=#<Rack::ETag:0x00007fa1e540c4f8  
#                                  @app=#<Rack::TempfileReaper:0x00007fa1e540c520 
#                                         @app=#<ActionDispatch::Routing::RouteSet:0x00007fa1e594cbe8>
#                                 >
#                         ...    
#                        >
#                             
#                 >
#         >

As we see in the Rack middleware stack, the last one is

@app=#<ActionDispatch::Routing::RouteSet:0x00007fa1e594cbe8>

# ./gems/actionpack-5.2.2/lib/action_dispatch/routing/route_set.rb
module ActionDispatch
  module Routing
    class RouteSet
      def initialize(config = DEFAULT_CONFIG)
        @set    = Journey::Routes.new
        @router = Journey::Router.new(@set)
      end

      def call(env)
        req = make_request(env) # return ActionDispatch::Request.new(env)
        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
        @router.serve(req) # Let's step into this line.
      end
    end
  end

# ./gems/actionpack5.2.2/lib/action_dispatch/journey/router.rb  
  module Journey
    class Router
      class RoutingError < ::StandardError
      end

      attr_accessor :routes

      def initialize(routes)
        @routes = routes
      end

      def serve(req)
        find_routes(req).each do |match, parameters, route| # Let's step into 'find_routes'
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

          unless route.path.anchored
            req.script_name = (script_name.to_s + match.to_s).chomp("/")
            req.path_info = match.post_match
            req.path_info = "/" + req.path_info unless req.path_info.start_with? "/"
          end

          parameters = route.defaults.merge parameters.transform_values { |val|
            val.dup.force_encoding(::Encoding::UTF_8)
          }

          req.path_parameters = set_params.merge parameters

          # 'route' is an instance of ActionDispatch::Journey::Route. 
          # 'route.app' is an instance of ActionDispatch::Routing::RouteSet::Dispatcher.
          status, headers, body = route.app.serve(req) # Let's step into method 'serve'

          if "pass" == headers["X-Cascade"]
            req.script_name     = script_name
            req.path_info       = path_info
            req.path_parameters = set_params
            next
          end

          return [status, headers, body]
        end

        [404, { "X-Cascade" => "pass" }, ["Not Found"]]
      end

      def find_routes(req)
        routes = filter_routes(req.path_info).concat custom_routes.find_all { |r|
          r.path.match(req.path_info)
        }

        routes =
          if req.head?
            match_head_routes(routes, req)
          else
            match_routes(routes, req)
          end

        routes.sort_by!(&:precedence)

        routes.map! { |r|
          match_data = r.path.match(req.path_info)
          path_parameters = {}
          match_data.names.zip(match_data.captures) { |name, val|
            path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
          }
          [match_data, path_parameters, r]
        }
      end

    end
  end
end

# ./gems/actionpack-5.2.2/lib/action_dispatch/routing/route_set.rb
module ActionDispatch
  module Routing
    class RouteSet
      class Dispatcher < Routing::Endpoint
        def serve(req)
          params     = req.path_parameters # params: { action: 'index', controller: 'home' }
          controller = controller(req) # controller: HomeController
          # The definition of 'make_response!' is 
          # ActionDispatch::Response.create.tap { |res| res.request = request; }
          res        = controller.make_response!(req) 
          dispatch(controller, params[:action], req, res) # Let's step into this line.
        rescue ActionController::RoutingError
          if @raise_on_name_error
            raise
          else
            return [404, { "X-Cascade" => "pass" }, []]
          end
        end

        private

        def controller(req)
          req.controller_class
        rescue NameError => e
          raise ActionController::RoutingError, e.message, e.backtrace
        end

        def dispatch(controller, action, req, res)
          controller.dispatch(action, req, res) # Let's step into this line.
        end
      end
    end
  end    
end

# ./gems/actionpack-5.2.2/lib/action_controller/metal.rb
module ActionController
  class Metal < AbstractController::Base
    abstract!

    def self.controller_name
      @controller_name ||= name.demodulize.sub(/Controller$/, "").underscore
    end

    def self.make_response!(request)
      ActionDispatch::Response.new.tap do |res|
        res.request = request
      end
    end

    class_attribute :middleware_stack, default: ActionController::MiddlewareStack.new

    def self.inherited(base)
      base.middleware_stack = middleware_stack.dup
      super
    end

    # Direct dispatch to the controller. Instantiates the controller, then
    # executes the action named +name+.
    def self.dispatch(name, req, res)
      if middleware_stack.any?
        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
      else
        # 'self' is HomeController, so for this line Rails will new a HomeController instance.  
        # Invoke `HomeController.ancestors`, you can find many superclasses of HomeController.
        # These are some typical superclasses of HomeController. 
        # HomeController
        # < ApplicationController
        # < ActionController::Base
        # < ActiveRecord::Railties::ControllerRuntime (module included)
        # < ActionController::Instrumentation (module included)
        # < ActionController::Rescue (module included)
        # < AbstractController::Callbacks (module included)
        # < ActionController::ImplicitRender (module included)
        # < ActionController::BasicImplicitRender (module included)
        # < ActionController::Renderers (module included) 
        # < ActionController::Rendering (module included) 
        # < ActionView::Layouts (module included) 
        # < ActionView::Rendering (module included)
        # < ActionDispatch::Routing::UrlFor (module included) 
        # < AbstractController::Rendering (module included)
        # < ActionController::Metal
        # < AbstractController::Base
        new.dispatch(name, req, res) # Let's step into this line.
      end
    end

    def dispatch(name, request, response)
      set_request!(request)
      set_response!(response)
      process(name) # Let's step into this line.
      request.commit_flash
      to_a
    end

    def to_a
      response.to_a
    end
  end
end

# .gems/actionpack-5.2.2/lib/abstract_controller/base.rb
module AbstractController
  class Base
    def process(action, *args)
      @_action_name = action.to_s

      unless action_name = _find_action_name(@_action_name)
        raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
      end

      @_response_body = nil

      # action_name: 'index'
      process_action(action_name, *args) # Let's step into this line.
    end
  end
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/instrumentation.rb
module ActionController
  module Instrumentation
    def process_action(*args)
      raw_payload = {
        controller: self.class.name,
        action: action_name,
        params: request.filtered_parameters,
        headers: request.headers,
        format: request.format.ref,
        method: request.request_method,
        path: request.fullpath
      }

      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)

      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
        begin
          # self: #<HomeController:0x00007fcd3c5dfd48>
          result = super # Let's step into this line.
          payload[:status] = response.status
          result
        ensure
          append_info_to_payload(payload)
        end
      end
    end
  end
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/rescue.rb
module ActionController
  module Rescue
    def process_action(*args)
      super # Let's step into this line.
    rescue Exception => exception
      request.env["action_dispatch.show_detailed_exceptions"] ||= show_detailed_exceptions?
      rescue_with_handler(exception) || raise
    end
  end  
end

# .gems/actionpack-5.2.2/lib/abstract_controller/callbacks.rb
module AbstractController
  # = Abstract Controller Callbacks
  #
  # Abstract Controller provides hooks during the life cycle of a controller action.
  # Callbacks allow you to trigger logic during this cycle. Available callbacks are:
  #
  # * <tt>after_action</tt>
  # * <tt>before_action</tt>
  # * <tt>skip_before_action</tt>
  # * ...
  module Callbacks
    def process_action(*args)
      run_callbacks(:process_action) do
        # self: #<HomeController:0x00007fcd3c5dfd48>
        super # Let's step into this line.
      end
    end
  end
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/rendering.rb
module ActionController
  module Rendering
    def process_action(*)
      self.formats = request.formats.map(&:ref).compact
      super # Let's step into this line.
    end
  end
end

# .gems/actionpack-5.2.2/lib/abstract_controller/base.rb
module AbstractController
  class Base
    def process_action(method_name, *args)
      # self: #<HomeController:0x00007fcd3c5dfd48>, method_name: 'index'
      # In the end, method 'send_action' is method 'send' by `alias send_action send` 
      send_action(method_name, *args)
    end

    alias send_action send
  end
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/basic_implicit_render.rb
module ActionController
  module BasicImplicitRender
    def send_action(method, *args)
      # self: #<HomeController:0x00007fcd3c5dfd48>, method_name: 'index'    
      # Because 'send_action' is an alias of 'send',  
      # self.send('index', *args) will goto HomeController#index.
      x = super
      # performed?: false (for this example)
      x.tap { default_render unless performed? } # Let's step into 'default_render' later.
    end
  end
end

# ./your_project/app/controllers/home_controller.rb
class HomeController < ApplicationController
  # Will go back to BasicImplicitRender#send_action when method 'index' is done.
  def index
    # Question: How does the instance variable '@users' defined in HomeController can be accessed in './app/views/home/index.html.erb' ?
    # I will answer this question later. 
    @users = User.all.pluck(:id, :name)
  end
end

# ./app/views/home/index.html.erb
<div class="container">
  <h1 class="display-4 font-italic">
    <%= t('home.banner_title') %>
    <%= @users %>
  </h1>
</div>

Render view

As we see in ActionController::BasicImplicitRender::send_action, the last line is default_render.

So after HomeController#index is done, Ruby will execute method default_render.

# .gems/actionpack-5.2.2/lib/action_controller/metal/implicit_render.rb 
module ActionController
  # Handles implicit rendering for a controller action that does not
  # explicitly respond with +render+, +respond_to+, +redirect+, or +head+.
  module ImplicitRender
    def default_render(*args)
      # Let's step into template_exists?
      if template_exists?(action_name.to_s, _prefixes, variants: request.variant)
        # Rails has found the default template './app/views/home/index.html.erb', so render it.
        render(*args) # Let's step into this line later
      #...
      else
        logger.info "No template found for #{self.class.name}\##{action_name}, rendering head :no_content" if logger
        super
      end
    end
  end
end

# .gems/actionview-5.2.2/lib/action_view/lookup_context.rb
module ActionView
  class LookupContext
    module ViewPaths
      # Rails checks whether the default template exists.
      def exists?(name, prefixes = [], partial = false, keys = [], **options)
        @view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys, options))
      end
      alias :template_exists? :exists?
    end
  end  
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/instrumentation.rb
module ActionController
  module Instrumentation
    def render(*args)
      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms {
          # self: #<HomeController:0x00007fa7e9c54278> 
          render_output = super # Let's step into super 
        }
      end
      render_output
    end
  end  
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/rendering.rb
module ActionController
  module Rendering
    # Check for double render errors and set the content_type after rendering.
    def render(*args)
      raise ::AbstractController::DoubleRenderError if response_body
      super # Let's step into super
    end
  end
end

# .gems/actionpack-5.2.2/lib/abstract_controller/rendering.rb
module AbstractController
  module Rendering
    # Normalizes arguments, options and then delegates render_to_body and
    # sticks the result in <tt>self.response_body</tt>.
    def render(*args, &block)
      options = _normalize_render(*args, &block)

      rendered_body = render_to_body(options) # Let's step into this line.

      if options[:html]
        _set_html_content_type
      else
        _set_rendered_content_type rendered_format
      end

      self.response_body = rendered_body
    end
  end
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/renderers.rb
module ActionController
  module Renderers
    def render_to_body(options)
      _render_to_body_with_renderer(options) || super # Let's step into this line and 'super' later.
    end

    # For this example, this method return nil in the end.
    def _render_to_body_with_renderer(options)
      # The '_renderers' is defined at line 31: `class_attribute :_renderers, default: Set.new.freeze.`
      # '_renderers' is an instance predicate method. For more information, 
      # see ./gems/activesupport/lib/active_support/core_ext/class/attribute.rb  
      _renderers.each do |name|
        if options.key?(name)
          _process_options(options)
          method_name = Renderers._render_with_renderer_method_name(name)
          return send(method_name, options.delete(name), options)
        end
      end
      nil
    end
  end  
end

# .gems/actionpack-5.2.2/lib/action_controller/metal/renderers.rb
module ActionController
  module Rendering
    def render_to_body(options = {})
      super || _render_in_priorities(options) || " " # Let's step into 'super'
    end
  end
end

# .gems/actionview-5.2.2/lib/action_view/rendering.rb
module ActionView
  module Rendering
    def render_to_body(options = {})
      _process_options(options)

      _render_template(options) # Let's step into this line.
    end

    def _render_template(options)
      variant = options.delete(:variant)
      assigns = options.delete(:assigns)

      context = view_context # We will step into this line later.

      context.assign assigns if assigns
      lookup_context.rendered_format = nil if options[:formats]
      lookup_context.variants = variant if variant

      view_renderer.render(context, options) # Let's step into this line.
    end
  end
end

# .gems/actionview-5.2.2/lib/action_view/renderer/renderer.rb
module ActionView
  class Renderer
    def render(context, options)
      if options.key?(:partial)
        render_partial(context, options)
      else
        render_template(context, options) # Let's step into this line.
      end
    end

    # Direct access to template rendering.
    def render_template(context, options)
      TemplateRenderer.new(@lookup_context).render(context, options) # Let's step into this line.
    end
  end
end

# .gems/actionview-5.2.2/lib/action_view/renderer/template_renderer.rb
module ActionView
  class TemplateRenderer < AbstractRenderer
    def render(context, options)
      @view    = context
      @details = extract_details(options)
      template = determine_template(options)

      prepend_formats(template.formats)

      @lookup_context.rendered_format ||= (template.formats.first || formats.first)

      render_template(template, options[:layout], options[:locals]) # Let's step into this line.
    end

    def render_template(template, layout_name = nil, locals = nil)
      view, locals = @view, locals || {}

      render_with_layout(layout_name, locals) do |layout| # Let's step into this line
        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
          # template: #<ActionView::Template:0x00007f822759cbc0>
          template.render(view, locals) { |*name| view._layout_for(*name) } # Let's step into this line
        end
      end
    end

    def render_with_layout(path, locals)
      layout  = path && find_layout(path, locals.keys, [formats.first])
      content = yield(layout)

      if layout
        view = @view
        view.view_flow.set(:layout, content)
        layout.render(view, locals) { |*name| view._layout_for(*name) }
      else
        content
      end
    end
  end
end

# .gems/actionview-5.2.2/lib/action_view/template.rb
module ActionView
  class Template
    def render(view, locals, buffer = nil, &block)
      instrument_render_template do
        # self: #<ActionView::Template:0x00007f89bab1efb8 
        #           @identifier="/path/to/your/project/app/views/home/index.html.erb" 
        #           @source="<div class='container'\n ..."
        #        >
        compile!(view)
        # method_name: "_app_views_home_index_html_erb___3699380246341444633_70336654511160" (This method is defined in 'def compile(mod)' below)
        # view: #<#<Class:0x00007ff10d6c9d18>:0x00007ff10ea050a8>, view is an instance of <a subclass of ActionView::Base> which has same instance variables defined in the instance of HomeController.
        # You will get the result html after invoking 'view.send'. 
        view.send(method_name, locals, buffer, &block)
      end
    rescue => e
      handle_render_error(view, e)
    end

    # Compile a template. This method ensures a template is compiled
    # just once and removes the source after it is compiled.
    def compile!(view)
      return if @compiled

      # Templates can be used concurrently in threaded environments
      # so compilation and any instance variable modification must
      # be synchronized
      @compile_mutex.synchronize do
        # Any thread holding this lock will be compiling the template needed
        # by the threads waiting. So re-check the @compiled flag to avoid
        # re-compilation
        return if @compiled

        if view.is_a?(ActionView::CompiledTemplates)
          mod = ActionView::CompiledTemplates
        else
          mod = view.singleton_class
        end

        instrument("!compile_template") do
          compile(mod) # Let's step into this line.
        end

        # Just discard the source if we have a virtual path. This
        # means we can get the template back.
        @source = nil if @virtual_path
        @compiled = true
      end
    end

    def compile(mod)
      encode!
      # @handler: #<ActionView::Template::Handlers::ERB:0x00007ff10e1be188>
      code = @handler.call(self) # Let's step into this line.

      # Make sure that the resulting String to be eval'd is in the
      # encoding of the code
      source = <<-end_src.dup
        def #{method_name}(local_assigns, output_buffer)
          _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
        ensure
          @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
        end
      end_src

      # ...

      #  source:   def _app_views_home_index_html_erb___1187260686135140546_70244801399180(local_assigns, output_buffer)
      #              _old_virtual_path, @virtual_path = @virtual_path, "home/index";_old_output_buffer = @output_buffer;;
      #              @output_buffer = output_buffer || ActionView::OutputBuffer.new;
      #              @output_buffer.safe_append='<div class="container">
      #                <h1 class="display-4 font-italic">
      #                  '.freeze;
      #                   @output_buffer.append=( t('home.banner_title') );
      #                   @output_buffer.append=( @users ); 
      #                   @output_buffer.safe_append='
      #                </h1>
      #              </div>
      #              '.freeze;
      #              @output_buffer.to_s
      #            ensure
      #              @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
      #            end
      mod.module_eval(source, identifier, 0) # This line will actually define the method '_app_views_home_index_html_erb___1187260686135140546_70244801399180'
      # mod: ActionView::CompiledTemplates
      ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
    end

# .gems/actionview-5.2.2/lib/action_view/template/handler/erb.rb     
    module Handlers
      class ERB
        def call(template)
          template_source = template.source.dup.force_encoding(Encoding::ASCII_8BIT)

          erb = template_source.gsub(ENCODING_TAG, "")
          encoding = $2

          erb.force_encoding valid_encoding(template.source.dup, encoding)

          # Always make sure we return a String in the default_internal
          erb.encode!

          self.class.erb_implementation.new(
            erb,
            escape: (self.class.escape_whitelist.include? template.type),
            trim: (self.class.erb_trim_mode == "-")
          ).src
        end
      end
    end
  end
end

How can instance variables defined in Controller be accessed in view file?

It's time to answer the question before:

How can instance variables like @users defined in HomeController be accessed in ./app/views/home/index.html.erb?

I will answer this question by showing the source code below.

# ./gems/actionview-5.2.2/lib/action_view/rendering.rb
module ActionView
  module Rendering
    def view_context
      # view_context_class is a subclass of ActionView::Base.
      view_context_class.new( # Let's step into this line later.
        view_renderer,
        view_assigns, # This line will set the instance variables like '@users' in this example. Let's step into this line.  
        self
      )
    end

    def view_assigns
      # self: #<HomeController:0x00007f83ecfed310>
      protected_vars = _protected_ivars
      # instance_variables is an instance method of class `Object` and it will return an array. And the array contains @users.  
      variables      = instance_variables 

      variables.reject! { |s| protected_vars.include? s }
      ret = variables.each_with_object({}) { |name, hash|
        hash[name.slice(1, name.length)] = instance_variable_get(name)
      }

      # ret: {"marked_for_same_origin_verification"=>true, "users"=>[[1, "Lane"], [2, "John"], [4, "Frank"]]}
      ret
    end

    def view_context_class
      # Will return a subclass of ActionView::Base.
      @_view_context_class ||= self.class.view_context_class
    end

    # How this ClassMethods works? Please look at ActiveSupport::Concern in ./gems/activesupport-5.2.2/lib/active_support/concern.rb
    # FYI, the method 'append_features' will be executed automatically before method 'included' executed. 
    # https://apidock.com/ruby/v1_9_3_392/Module/append_features  
    module ClassMethods
      def view_context_class
        # self: HomeController
        @view_context_class ||= begin
          supports_path = supports_path?
          routes  = respond_to?(:_routes)  && _routes
          helpers = respond_to?(:_helpers) && _helpers

          Class.new(ActionView::Base) do
            if routes
              include routes.url_helpers(supports_path)
              include routes.mounted_helpers
            end

            if helpers
              include helpers
            end
          end
        end
      end
    end
  end
end

# ./gems/actionview-5.2.2/lib/action_view/base.rb
module ActionView
  class Base
    def initialize(context = nil, assigns = {}, controller = nil, formats = nil)
      @_config = ActiveSupport::InheritableOptions.new

      if context.is_a?(ActionView::Renderer)
        @view_renderer = context
      else
        lookup_context = context.is_a?(ActionView::LookupContext) ?
          context : ActionView::LookupContext.new(context)
        lookup_context.formats  = formats if formats
        lookup_context.prefixes = controller._prefixes if controller
        @view_renderer = ActionView::Renderer.new(lookup_context)
      end

      @cache_hit = {}

      assign(assigns) # Let's step into this line.

      assign_controller(controller)
      _prepare_context
    end

    def assign(new_assigns)
      @_assigns = 
        new_assigns.each do |key, value|
          # This line will set the instance variables (like '@users') in HomeController to itself.
          instance_variable_set("@#{key}", value)
        end
    end
  end
end

After all rack apps called, user will get the response.

Part 4: What does `$ rails server` do?

If you start Rails by $ rails server. You may want to know what does this command do?

The command rails locates at ./bin/.

#!/usr/bin/env ruby
APP_PATH = File.expand_path('../config/application', __dir__)

require_relative '../config/boot'
require 'rails/commands' # Let's look at this file.

# ./railties-5.2.2/lib/rails/commands.rb
require "rails/command"

aliases = {
  "g"  => "generate",
  "d"  => "destroy",
  "c"  => "console",
  "s"  => "server",
  "db" => "dbconsole",
  "r"  => "runner",
  "t"  => "test"
}

command = ARGV.shift
command = aliases[command] || command # command is 'server'

Rails::Command.invoke command, ARGV # Let's step into this line.

# ./railties-5.2.2/lib/rails/command.rb
module Rails
  module Command
    class << self
      def invoke(full_namespace, args = [], **config)
        # ...
        # command_name: 'server'  
        # After calling `find_by_namespace`, we will get this result:
        # command: Rails::Command::ServerCommand
        command = find_by_namespace(namespace, command_name)

        # Equals to: Rails::Command::ServerCommand.perform('server', args, config)
        command.perform(command_name, args, config)
      end
    end
  end
end

# ./gems/railties-5.2.2/lib/rails/commands/server/server_command.rb
module Rails 
  module Command
    # There is a class method 'perform' in the Base class.
    class ServerCommand < Base
    end
  end
end

Thor

Thor is a toolkit for building powerful command-line interfaces.

https://github.com/erikhuda/thor

Inheritance relationship: Rails::Command::ServerCommand < Rails::Command::Base < Thor

# ./gems/railties-5.2.2/lib/rails/command/base.rb
module Rails
  module Command
    class Base < Thor
      class << self
        # command: 'server'
        def perform(command, args, config)
          #...
          dispatch(command, args.dup, nil, config) # Thor.dispatch
        end
      end
    end
  end
end

# ./gems/thor-0.20.3/lib/thor.rb
class Thor
  class << self
    # meth is 'server'
    def dispatch(meth, given_args, given_opts, config)
      # ...
      # Will new a Rails::Command::ServerCommand instance here 
      # because 'self' is Rails::Command::ServerCommand.
      instance = new(args, opts, config)
      # ...
      # Method 'invoke_command' is defined in Thor::Invocation. 
      # command: {Thor::Command}#<struct Thor::Command name="server" ...> 
      instance.invoke_command(command, trailing || [])
    end
  end
end

# ./gems/thor-0.20.3/lib/thor/invocation.rb
class Thor
  # FYI, this module is included in Thor.
  # And Thor is grandfather of Rails::Command::ServerCommand
  module Invocation
    def invoke_command(command, *args) # 'invoke_command' is defined at here.
      # ...
      # self: #<Rails::Command::ServerCommand:0x00007fdcc49791b0> 
      # command: {Thor::Command}#<struct Thor::Command name="server" ...> 
      command.run(self, *args)
    end
  end
end

# ./gems/thor-0.20.3/lib/thor/command.rb
class Thor
  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
    def run(instance, args = [])
      # ...
      # instance: #<Rails::Command::ServerCommand:0x00007fdcc49791b0>
      # name: "server"
      # This line will invoke Rails::Command::ServerCommand#server, 
      # the instance method 'server' is defined in Rails::Command::ServerCommand implicitly.
      # I will show you how the instance method 'server' is implicitly defined. 
      instance.__send__(name, *args) 
    end  
  end
end

# ./gems/thor-0.20.3/lib/thor.rb
class Thor
  # ...
  include Thor::Base # Will invoke hooked method 'Thor::Base.included(self)'
end

# ./gems/thor-0.20.3/lib/thor/base.rb
module Thor
  module Base
    class << self
      # 'included' is a hooked method.
      # When module 'Thor::Base' is included, method 'included' is executed. 
      def included(base) 
        # base: Thor
        # this line will define `Thor.method_added`.  
        base.extend ClassMethods
        # Module 'Invocation' is included for class 'Thor' here. 
        # Because Thor is grandfather of Rails::Command::ServerCommand,
        # 'invoke_command' will be instance method of Rails::Command::ServerCommand       
        base.send :include, Invocation # 'invoke_command' is defined in module Invocation
        base.send :include, Shell
      end
    end

    module ClassMethods
      # 'method_added' is a hooked method.
      # When an instance method is created in Rails::Command::ServerCommand, 
      # `method_added` will be executed.
      # So, when method `perform` is defined in Rails::Command::ServerCommand,
      # `method_added` will be executed and create_command('perform') will be invoked. 
      # So in the end, method 'server' will be created by alias_method('server', 'perform').
      # And the method 'server' is for the 'server' in command `$ rails server`.
      def method_added(meth)
        # ...
        # self: {Class} Rails::Command::ServerCommand 
        create_command(meth) # meth is 'perform'. Let's step into this line.
      end
    end
  end
end

# ./gems/railties-5.2.2/lib/rails/command/base.rb
module Rails
  module Command
    # Rails::Command::Base is superclass of Rails::Command::ServerCommand
    module Base
      class << self
        def create_command(meth)
          if meth == "perform"
            # Calling instance method 'server' of Rails::Command::ServerCommand 
            # will be transferred to call instance method 'perform'.
            alias_method('server', meth) 
          end
        end  
      end
    end
  end
end

# ./gems/thor-0.20.3/lib/thor/command.rb
class Thor
  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
    def run(instance, args = [])
      #...
      # instance: {Rails::Command::ServerCommand}#<Rails::Command::ServerCommand:0x00007fa5f319bf40>
      # name: 'server'.
      # Will actually invoke 'instance.perform(*args)'. 
      # Equals to invoke Rails::Command::ServerCommand#perform(*args).
      # Let's step into  Rails::Command::ServerCommand#perform.
      instance.__send__(name, *args) 
    end
  end
end

# ./gems/railties-5.2.2/lib/rails/commands/server/server_command.rb
module Rails
  module Command
    class ServerCommand < Base
      # This is the method will be executed when `$ rails server`.
      def perform
        # ...
        Rails::Server.new(server_options).tap do |server|
          # APP_PATH is '/Users/your_name/your_project/config/application'.
          # require APP_PATH will create the 'Rails.application' object.
          # 'Rails.application' is 'YourProject::Application.new'.
          # Rack server will start 'Rails.application'.
          require APP_PATH

          Dir.chdir(Rails.application.root)

          server.start # Let's step into this line.
        end
      end
    end
  end
end

Rails::Server#start

# ./gems/railties-5.2.2/lib/rails/commands/server/server_command.rb
module Rails
  class Server < ::Rack::Server
    def start
      print_boot_information

      trap(:INT) do
        exit
      end

      create_tmp_directories
      setup_dev_caching

      # This line is important. Although the method name seems not.
      log_to_stdout# Let step into this line.

      super # Will invoke ::Rack::Server#start. I will show you later. 
    ensure
      puts "Exiting" unless @options && options[:daemonize]
    end

    def log_to_stdout
      # 'wrapped_app' will get an well prepared Rack app from './config.ru' file.
      # It's the first time invoke 'wrapped_app'.
      # The app is an instance of YourProject::Application.
      # But the app is not created in 'wrapped_app'.
      # It has been created when `require APP_PATH` in previous code,
      # just at the 'perform' method in Rails::Command::ServerCommand.   
      wrapped_app # Let's step into this line

      # ...
    end
  end
end

# ./gems/rack-2.0.6/lib/rack/server.rb
module Rack
  class Server
    def wrapped_app
      @wrapped_app ||= 
        build_app(
          app # Let's step into this line.
        )
    end

    def app
      @app ||= build_app_and_options_from_config # Let's step into this line.
      @app
    end

    def build_app_and_options_from_config
      # ...
      # self.options[:config]: 'config.ru'. Let's step into this line.
      app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
      # ...
      app
    end

    # This method is called in Rails::Server#start
    def start(&blk)
      #...
      wrapped_app
      #...

      # server: {Module} Rack::Handler::Puma
      # wrapped_app: {YourProject::Application} #<YourProject::Application:0x00007f7fe5523f98>
      server.run(wrapped_app, options, &blk) # We will step into this line (Rack::Handler::Puma.run) later.
    end
  end
end

# ./gems/rack/lib/rack/builder.rb
module Rack
  module Builder
    def self.parse_file(config, opts = Server::Options.new)
      # config: 'config.ru'
      cfgfile = ::File.read(config)

      app = new_from_string(cfgfile, config)

      return app, options
    end

    # Let's guess what does 'run Rails.application' do in config.ru?
    # You may guess that: 
    #   Run YourProject::Application instance.
    # But 'run' maybe not what you are thinking about.
    # Because the 'self' object in 'config.ru' is #<Rack::Builder:0x00007f8c861ec278 @warmup=nil, @run=nil, @map=nil, @use=[]>, 
    # 'run' is an instance method of Rack::Builder.
    # Let's look at the definition of the 'run' method: 
    # def run(app)
    #   @run = app # Just set an instance variable for Rack::Builder instance.
    # end
    def self.new_from_string(builder_script, file="(rackup)")
      # Rack::Builder implements a small DSL to iteratively construct Rack applications.
      eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
        TOPLEVEL_BINDING, file, 0
    end
  end
end

Starting Puma

As we see in Rack::Server#start, there is Rack::Handler::Puma.run(wrapped_app, options, &blk).

# ./gems/puma-3.12.0/lib/rack/handler/puma.rb
module Rack
  module Handler
    module Puma
      # This method is invoked in `Rack::Server#start`:
      # Rack::Handler::Puma.run(wrapped_app, options, &blk) 
      def self.run(app, options = {})
        conf   = self.config(app, options)

        # ...
        launcher = ::Puma::Launcher.new(conf, :events => events)

        begin
          # Puma will run your app (instance of YourProject::Application)
          launcher.run # Let's step into this line.
        rescue Interrupt 
          puts "* Gracefully stopping, waiting for requests to finish"
          launcher.stop
          puts "* Goodbye!"
        end
      end
    end  
  end
end

# .gems/puma-3.12.0/lib/puma/launcher.rb
module Puma
  # Puma::Launcher is the single entry point for starting a Puma server based on user
  # configuration. It is responsible for taking user supplied arguments and resolving them
  # with configuration in `config/puma.rb` or `config/puma/<env>.rb`.
  #
  # It is responsible for either launching a cluster of Puma workers or a single
  # puma server.
  class Launcher
    def initialize(conf, launcher_args={})
      @runner        = nil
      @config        = conf

      # ...
      if clustered?
        # ...
        @runner = Cluster.new(self, @events)
      else
        # For this example, it is Single.new.
        @runner = Single.new(self, @events)
      end

      # ...
    end

    def run
      #...

      # Set the behaviors for signals like `$ kill -s SIGTERM puma_process_id` received. 
      setup_signals # We will discuss this line later.

      set_process_title

      @runner.run # We will enter `Single.new(self, @events).run` here.

      case @status
      when :halt
        log "* Stopping immediately!"
      when :run, :stop
        graceful_stop
      when :restart
        log "* Restarting..."
        ENV.replace(previous_env)
        @runner.before_restart
        restart!
      when :exit
        # nothing
      end
    end
  end
end

# .gems/puma-3.12.0/lib/puma/single.rb
module Puma
  # This class is instantiated by the `Puma::Launcher` and used
  # to boot and serve a Ruby application when no puma "workers" are needed
  # i.e. only using "threaded" mode. For example `$ puma -t 1:5`
  #
  # At the core of this class is running an instance of `Puma::Server` which
  # gets created via the `start_server` method from the `Puma::Runner` class
  # that this inherits from.
  class Single < Runner
    def run
      # ...

      # @server: Puma::Server.new(app, @launcher.events, @options)
      @server = server = start_server # Let's step into this line.

      # ...
      thread = server.run # Let's step into this line later.

      # This line will suspend the main thread execution.
      # And the `thread`'s block (which is method `handle_servers`) will be executed.
      # See `Thread#join` for more information.
      # I will show you a simple example for using `thread.join`.
      # Please search `test_thread_join.rb` in this document.
      thread.join

      # The below line will never be executed because `thread` is always running and `thread` has joined.
      # When `$ kill -s SIGTERM puma_process_id`, the below line will still not be executed
      # because the block of `Signal.trap "SIGTERM"` in `Puma::Launcher#setup_signals` will be executed.
      # If you remove the line `thread.join`, the below line will be executed, 
      # but the main thread will exit after all code executed and all the threads not joined will be killed.
      puts "anything which will never be executed..."
    end
  end
end

# .gems/puma-3.12.0/lib/puma/runner.rb
module Puma
  # Generic class that is used by `Puma::Cluster` and `Puma::Single` to
  # serve requests. This class spawns a new instance of `Puma::Server` via
  # a call to `start_server`.
  class Runner
    def app
      @app ||= @launcher.config.app
    end

    def start_server
      min_t = @options[:min_threads]
      max_t = @options[:max_threads]

      server = Puma::Server.new(app, @launcher.events, @options)
      server.min_threads = min_t
      server.max_threads = max_t
      # ...

      server
    end
  end
end

# .gems/puma-3.12.0/lib/puma/server.rb
module Puma
  class Server
    def run(background=true)
      #...
      @status = :run
      queue_requests = @queue_requests

      # This part is important.
      # Remember the block of ThreadPool.new will be called when a request added to the ThreadPool instance.
      # And the block will process the request by calling method `process_client`.
      # Let's step into this line later to see how puma call the block.
      @thread_pool = ThreadPool.new(@min_threads,
                                    @max_threads,
                                    IOBuffer) do |client, buffer|

        # Advertise this server into the thread
        Thread.current[ThreadLocalKey] = self

        process_now = false

        if queue_requests
          process_now = client.eagerly_finish
        end  

        # ...
        if process_now
          # Process the request. You can treat `client` as request.
          # If you want to know more about 'process_client', please read part 3 
          # or search 'process_client' in this document.  
          process_client(client, buffer)  
        else
          client.set_timeout @first_data_timeout
          @reactor.add client
        end
      end

      # ...

      if background # background: true (for this example)
        # This part is important.
        # Remember puma created a thread here!
        # We will know that the newly created thread's job is waiting for requests.
        # When a request comes, the thread will transfer the request processing work to a thread in ThreadPool.
        # The method `handle_servers` in thread's block will be executed immediately 
        # (executed in the newly created thread, not in the main thread).
        @thread = Thread.new { handle_servers } # Let's step into this line to see what I said.
        return @thread
      else
        handle_servers
      end
    end

    def handle_servers      
      sockets = [check] + @binder.ios
      pool = @thread_pool
      queue_requests = @queue_requests

      # ...

      # The thread is always running, because @status has been set to :run in Puma::Server#run.
      # Yes, it should always be running to transfer the incoming requests.
      while @status == :run
        begin
          # This line will cause current thread waiting until a request arrives.
          # So it will be the entry of every request!
          # sockets: [#<IO:fd 23>, #<TCPServer:fd 22, AF_INET, 0.0.0.0, 3000>] 
          ios = IO.select sockets

          ios.first.each do |sock|
            if sock == check
              break if handle_check
            else
              if io = sock.accept_nonblock
                # You can simply think a Puma::Client instance as a request.  
                client = Client.new(io, @binder.env(sock))

                # ...

                # FYI, the method '<<' is redefined.
                # Add the request (client) to thread pool means 
                # a thread in the pool will process this request (client).   
                pool << client # Let's step into this line.

                pool.wait_until_not_full # Let's step into this line later.
              end
            end
          end
        rescue Object => e
          @events.unknown_error self, e, "Listen loop"
        end
      end
    end    
  end
end

# .gems/puma-3.12.0/lib/puma/thread_pool.rb
module Puma
  class ThreadPool
    # Maintain a minimum of +min+ and maximum of +max+ threads
    # in the pool.
    #
    # The block passed is the work that will be performed in each
    # thread.
    #
    def initialize(min, max, *extra, &block)
      #..
      @mutex = Mutex.new
      @todo = [] # @todo is requests (in puma, they are Puma::Client instances) which need to be processed.  
      @spawned = 0 # the count of @spawned threads
      @min = Integer(min) # @min threads count
      @max = Integer(max) # @max threads count
      @block = block # block will be called in method `spawn_thread` to processed a request.    
      @workers = []
      @reaper = nil

      @mutex.synchronize do
        @min.times { spawn_thread } # Puma spawns @min count threads.
      end
    end

    def spawn_thread
      @spawned += 1

      # Create a new Thread now.
      # The block of the thread will be executed immediately and separately from the calling thread (main thread).
      th = Thread.new(@spawned) do |spawned|
        # Thread name is new in Ruby 2.3
        Thread.current.name = 'puma %03i' % spawned if Thread.current.respond_to?(:name=)
        block = @block
        mutex = @mutex
        #...

        extra = @extra.map { |i| i.new }

        # Pay attention to here: 
        # 'while true' means this part will always be running.
        # And there will be @min count threads always running!
        # Puma uses these threads to process requests. 
        # The line: 'not_empty.wait(mutex)' will make current thread waiting.  
        while true
          work = nil

          continue = true

          mutex.synchronize do
            while todo.empty?
              if @trim_requested > 0
                @trim_requested -= 1
                continue = false
                not_full.signal
                break
              end

              if @shutdown
                continue = false
                break
              end

              @waiting += 1 # `@waiting` is the waiting threads count.
              not_full.signal

              # This line will cause current thread waiting
              # until `not_empty.signal` executed in some other place to wake it up .
              # Actually, `not_empty.signal` is located at `def <<(work)` in the same file.
              # You can search `def <<(work)` in this document.
              # Method `<<` is used in method `handle_servers`: `pool << client` in Puma::Server#run.
              # `pool << client` means add a request to the thread pool, 
              # and then the waked up thread will process the request. 
              not_empty.wait mutex

              @waiting -= 1
            end

            # `work` is the request (in puma, it's Puma::Client instance) which need to be processed.
            work = todo.shift if continue  
          end

          break unless continue

          if @clean_thread_locals
            ThreadPool.clean_thread_locals
          end

          begin
            # `block.call` will switch program to the block definition part.
            # The block definition part is in `Puma::Server#run`:
            # @thread_pool = ThreadPool.new(@min_threads,
            #                               @max_threads,
            #                               IOBuffer) do |client, buffer| #...; end
            # So please search `ThreadPool.new` in this document to look back.
            block.call(work, *extra)
          rescue Exception => e
            STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
          end
        end

        mutex.synchronize do
          @spawned -= 1
          @workers.delete th
        end
      end # end of the Thread.new.

      @workers << th

      th
    end

    def wait_until_not_full
      @mutex.synchronize do
        while true
          return if @shutdown

          # If we can still spin up new threads and there
          # is work queued that cannot be handled by waiting
          # threads, then accept more work until we would
          # spin up the max number of threads.
          return if @todo.size - @waiting < @max - @spawned

          @not_full.wait @mutex 
        end
      end
    end

    # Add +work+ to the todo list for a Thread to pickup and process.
    def <<(work)
      @mutex.synchronize do
        if @shutdown
          raise "Unable to add work while shutting down"
        end

        # work: #<Puma::Client:0x00007ff114ece6b0>
        # You can treat Puma::Client instance as a request.
        @todo << work

        if @waiting < @todo.size and @spawned < @max
          spawn_thread # Create one more thread to process request. 
        end

        # Wake up the waiting thread to process the request.
        # The waiting thread is defined in the same file: Puma::ThreadPool#spawn_thread.
        # This code is in `spawn_thread`:
        # while true 
        #   # ...
        #   not_empty.wait mutex
        #   # ... 
        #   block.call(work, *extra) # This line will process the request.
        # end 
        @not_empty.signal  
      end
    end
  end
end

Conclusion

In conclusion, $ rails server will execute Rails::Command::ServerCommand#perform.

In #perform, call Rails::Server#start. Then call Rack::Server#start.

Then call Rack::Handler::Puma.run(YourProject::Application.new).

In .run, Puma will new a always running Thread for ios = IO.select(#<TCPServer:fd 22, AF_INET, 0.0.0.0, 3000>).

Request is created from ios object.

A thread in puma threadPool will process the request.

The thread will invoke rack apps' call to get the response for the request.

Exiting Puma

Process and Thread

Because Puma is using multiple threads, we need to have some basic concepts about Process and Thread.

This link is good for you to obtain the concepts: Process and Thread

In the next part, you will often see thread.join.

I will use two simple example to tell what does thread.join do.

Example one

Try to run test_thread_join.rb.

# ./test_thread_join.rb
thread = Thread.new() do
  3.times do |n|
    puts "~~~~ " + n.to_s
  end
end

# sleep 1
puts "==== I am the main thread."

# thread.join # Try to uncomment these two lines to see the differences.
# puts "==== after thread.join"

You will find that if there is no thread.join, you can only see ==== I am the main thread. in console.

After you added thread.join, you can see:

~~~~ 1
~~~~ 2
~~~~ 3

in console.

Example two

Try to run test_thread_join2.rb.

# ./test_thread_join2.rb
arr = [
  Thread.new { sleep 1 },
  Thread.new do
    sleep 5
    puts 'I am arr[1]'
  end,
  Thread.new { sleep 8}
]

puts Thread.list.size # returns 4 (including the main thread)

sleep 2

arr.each { |thread| puts "~~~~~ #{thread}" }

puts Thread.list.size # returns 3 (because arr[0] is dead)

# arr[1].join # uncomment to see differences

arr.each { |thread| puts "~~~~~ #{thread}" }

puts "Exit main thread"

Send `SIGTERM` to Puma

When you stop puma by running $ kill -s SIGTERM puma_process_id, you will enter setup_signals in Puma::Launcher#run.

# .gems/puma-3.12.0/lib/puma/launcher.rb
module Puma
  # Puma::Launcher is the single entry point for starting a Puma server based on user
  # configuration.
  class Launcher
    def run
      #...

      # Set the behaviors for signals like `$ kill -s SIGTERM puma_process_id`. 
      setup_signals # Let's step into this line.

      set_process_title

      @runner.run

      # ...
    end

    # Set the behaviors for signals like `$ kill -s SIGTERM puma_process_id`.
    # Signal.list #=> {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "IOT"=>6, "ABRT"=>6, "FPE"=>8, "KILL"=>9, "BUS"=>7, "SEGV"=>11, "SYS"=>31, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "URG"=>23, "STOP"=>19, "TSTP"=>20, "CONT"=>18, "CHLD"=>17, "CLD"=>17, "TTIN"=>21, "TTOU"=>22, "IO"=>29, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "USR1"=>10, "USR2"=>12, "PWR"=>30, "POLL"=>29}
    # Press `Control + C` to quit means 'SIGINT'.
    def setup_signals
      begin
        # After running `$ kill -s SIGTERM puma_process_id`, Ruby will execute the block of `Signal.trap "SIGTERM"`.
        Signal.trap "SIGTERM" do
          graceful_stop # Let's step into this line.

          raise SignalException, "SIGTERM"
        end
      rescue Exception
        log "*** SIGTERM not implemented, signal based gracefully stopping unavailable!"
      end

      begin
        Signal.trap "SIGUSR2" do
          restart
        end
      rescue Exception
        log "*** SIGUSR2 not implemented, signal based restart unavailable!"
      end

      begin
        Signal.trap "SIGUSR1" do
          phased_restart
        end
      rescue Exception
        log "*** SIGUSR1 not implemented, signal based restart unavailable!"
      end

      begin
        Signal.trap "SIGINT" do
          if Puma.jruby?
            @status = :exit
            graceful_stop
            exit
          end

          stop
        end
      rescue Exception
        log "*** SIGINT not implemented, signal based gracefully stopping unavailable!"
      end

      begin
        Signal.trap "SIGHUP" do
          if @runner.redirected_io?
            @runner.redirect_io
          else
            stop
          end
        end
      rescue Exception
        log "*** SIGHUP not implemented, signal based logs reopening unavailable!"
      end
    end

    def graceful_stop
      # @runner: instance of Puma::Single (for this example)
      @runner.stop_blocked # Let's step into this line.
      log "=== puma shutdown: #{Time.now} ==="
      log "- Goodbye!"
    end
  end
end

# .gems/puma-3.12.0/lib/puma/launcher.rb
module Puma
  class Single < Runner
    def run
      # ...

      # @server: Puma::Server.new(app, @launcher.events, @options)
      @server = server = start_server # Let's step into this line.

      # ...
      thread = server.run

      # This line will suspend the main thread execution.
      # And the `thread`'s block (which is the method `handle_servers`) will be executed.  
      thread.join
    end

    def stop_blocked
      log "- Gracefully stopping, waiting for requests to finish"
      @control.stop(true) if @control
      # @server: instance of Puma::Server
      @server.stop(true) # Let's step into this line
    end
  end
end

# .gems/puma-3.12.0/lib/puma/server.rb
module Puma
  class Server
    def initialize(app, events=Events.stdio, options={})
      # 'Puma::Util.pipe' returns `IO.pipe`.
      @check, @notify = Puma::Util.pipe # @check, @notify is a pair.

      @status = :stop
    end

    def run(background=true)
      # ...
      @thread_pool = ThreadPool.new(@min_threads,
                                    @max_threads,
                                    IOBuffer) do |client, buffer|

        #...
        # Process the request.
        process_client(client, buffer)  
        #...
      end

      # 'Thread.current.object_id' returns '70144214949920', 
      # which is the same as the 'Thread.current.object_id' in Puma::Server#stop.
      # Current thread is the main thread here.
      puts "#{Thread.current.object_id}"

      # The created @thread is the @thread in `stop` method below.
      @thread = Thread.new {
        # FYI, this is in the puma starting process.      
        # 'Thread.current.object_id' returns '70144220123860', 
        # which is the same as the 'Thread.current.object_id' in 'handle_servers' in Puma::Server#run
        # def handle_servers
        #   begin
        #     # ...
        #   ensure
        #     # FYI, the 'ensure' part is in the puma stopping process.
        #     puts "#{Thread.current.object_id}" # returns '70144220123860' too.
        #   end
        # end
        puts "#{Thread.current.object_id}" # returns '70144220123860'

        handle_servers
      }
      return @thread
    end

    # Stops the acceptor thread and then causes the worker threads to finish
    # off the request queue before finally exiting.
    def stop(sync=false)
      # This line will set '@status = :stop',
      # and cause `ios = IO.select sockets` (in method `handle_servers`) to return result.
      # So that the code after `ios = IO.select sockets` will be executed.   
      notify_safely(STOP_COMMAND) # Let's step into this line.

      # 'Thread.current.object_id' returns '70144214949920', 
      # which is the same as the 'Thread.current.object_id' in Puma::Server#run.
      # Current thread is exactly the main thread here.
      puts "#{Thread.current.object_id}"

      # The @thread is just the always running Thread created in `Puma::Server#run`.
      # Please look at method `Puma::Server#run`.
      # `@thread.join` will suspend the main thread execution.
      # And the code in @thread will continue be executed.
      @thread.join if @thread && sync
    end

    def notify_safely(message)
      @notify << message
    end

    def handle_servers
      begin
        check = @check
        # sockets: [#<IO:fd 23>, #<TCPServer:fd 22, AF_INET, 0.0.0.0, 3000>]
        sockets = [check] + @binder.ios
        pool = @thread_pool
        #...

        while @status == :run
          # After `notify_safely(STOP_COMMAND)` in main thread, `ios = IO.select sockets` will return result.
          # FYI, `@check, @notify = IO.pipe`.
          # def notify_safely(message)
          #   @notify << message
          # end
          # sockets: [#<IO:fd 23>, #<TCPServer:fd 22, AF_INET, 0.0.0.0, 3000>]
          ios = IO.select sockets

          ios.first.each do |sock|
            if sock == check
              # The @status is updated to :stop for this example in `handle_check`.
              break if handle_check # Let's step into this line.
            else
              if io = sock.accept_nonblock
                client = Client.new(io, @binder.env(sock))

                # ...
                pool << client
                pool.wait_until_not_full
              end
            end
          end
        end

        # Let's step into `graceful_shutdown`.
        graceful_shutdown if @status == :stop || @status == :restart

      # ...
      ensure
        # FYI, the 'ensure' part is in the puma stopping process.
        # 'Thread.current.object_id' returns '70144220123860', 
        # which is the same as the 'Thread.current.object_id' in 'Thread.new block' in Puma::Server#run
        # @thread = Thread.new do
        #   # FYI, this is in the puma starting process.
        #   puts "#{Thread.current.object_id}" # returns '70144220123860'
        #   handle_servers
        # end
        puts "#{Thread.current.object_id}"

        @check.close
        @notify.close

        # ...
      end
    end

    def handle_check
      cmd = @check.read(1)

      case cmd
      when STOP_COMMAND
        @status = :stop # The @status is updated to :stop for this example. 
        return true
      when HALT_COMMAND
        @status = :halt
        return true
      when RESTART_COMMAND
        @status = :restart
        return true
      end

      return false
    end

    def graceful_shutdown
      if @thread_pool
        @thread_pool.shutdown # Let's step into this line.
      end
    end    
  end
end

module Puma
  class ThreadPool
    # Tell all threads in the pool to exit and wait for them to finish.
    def shutdown(timeout=-1)
      threads = @mutex.synchronize do
        @shutdown = true
        # `broadcast` will wakes up all threads waiting for this lock.
        @not_empty.broadcast
        @not_full.broadcast

        # ...

        # dup workers so that we join them all safely
        # @workers is an array.   
        # @workers.dup will not create new thread.
        # @workers is an instance variable and will be changed when shutdown (by `@workers.delete th`). 
        # So ues @workers.dup here.
        @workers.dup
      end

      # Wait for threads to finish without force shutdown.
      threads.each do |thread|
        thread.join
      end

      @spawned = 0
      @workers = []
    end

    def initialize(min, max, *extra, &block)
      #..
      @mutex = Mutex.new
      @spawned = 0 # The count of @spawned threads.
      @todo = [] # @todo is requests (in puma, it's Puma::Client instance) which need to be processed.  
      @min = Integer(min) # @min threads count
      @block = block # block will be called in method `spawn_thread` to process a request.    
      @workers = []

      @mutex.synchronize do
        @min.times { spawn_thread } # Puma spawns @min count threads.
      end
    end

    def spawn_thread
      @spawned += 1

      # Run a new Thread now.
      # The block of the thread will be executed separately from the calling thread. 
      th = Thread.new(@spawned) do |spawned|
        block = @block
        mutex = @mutex
        #...

        while true
          work = nil

          continue = true

          mutex.synchronize do
            while todo.empty?
              # ...

              if @shutdown
                continue = false
                break
              end

              # ...
              # After `@not_empty.broadcast` is executed in '#shutdown', `not_empty` is waked up.
              # Ruby will continue to execute the next line here.
              not_empty.wait mutex

              @waiting -= 1
            end

            # ...
          end

          break unless continue

          # ...
        end

        mutex.synchronize do
          @spawned -= 1
          @workers.delete th
        end
      end # end of the Thread.new.

      @workers << th

      th
    end
  end
end

So all the threads in the ThreadPool joined and finished.

Let's inspect the caller in block of Signal.trap "SIGTERM" below.

# .gems/puma-3.12.0/lib/puma/launcher.rb
module Puma
  # Puma::Launcher is the single entry point for starting a Puma server based on user
  # configuration.
  class Launcher
    def run
      #...

      # Set the behaviors for signals like `$ kill -s SIGTERM puma_process_id`. 
      setup_signals # Let's step into this line.

      set_process_title

      # Process.pid: 42264 
      puts "Process.pid: #{Process.pid}"

      @runner.run

      # ...
    end

    def setup_signals
      # ...
      begin
        # After running `$ kill -s SIGTERM puma_process_id`, Ruby will execute the block of `Signal.trap "SIGTERM"`.
        Signal.trap "SIGTERM" do
          # I inspect `caller` to see the caller stack.
          # caller: [
          #   "../gems/puma-3.12.0/lib/puma/single.rb:118:in `join'", 
          #   "../gems/puma-3.12.0/lib/puma/single.rb:118:in `run'",
          #   "../gems/puma-3.12.0/lib/puma/launcher.rb:186:in `run'",
          #   "../gems/puma-3.12.0/lib/rack/handler/puma.rb:70:in `run'",
          #   "../gems/rack-2.0.6/lib/rack/server.rb:298:in `start'",
          #   "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:55:in `start'", 
          #   "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:149:in `block in perform'", 
          #   "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:144:in `tap'", 
          #   "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:144:in `perform'", 
          #   "../gems/thor-0.20.3/lib/thor/command.rb:27:in `run'", 
          #   "../gems/thor-0.20.3/lib/thor/invocation.rb:126:in `invoke_command'", 
          #   "../gems/thor-0.20.3/lib/thor.rb:391:in `dispatch'", 
          #   "../gems/railties-5.2.2/lib/rails/command/base.rb:65:in `perform'", 
          #   "../gems/railties-5.2.2/lib/rails/command.rb:46:in `invoke'", 
          #   "../gems/railties-5.2.2/lib/rails/commands.rb:18:in `<top (required)>'", 
          #   "../path/to/your_project/bin/rails:5:in `require'", 
          #   "../path/to/your_project/bin/rails:5:in `<main>'"
          # ]
          puts "caller: #{caller.inspect}"

          # Process.pid: 42264 which is the same as the `Process.pid` in the Puma::Launcher#run.
          puts "Process.pid: #{Process.pid}"

          graceful_stop

          # This SignalException is not rescued in the caller stack.
          # So in the the caller stack, Ruby will goto the `ensure` part in
          # "../gems/railties-5.2.2/lib/rails/commands/server/server_command.rb:55:in `start'".
          # So the last code executed is `puts "Exiting" unless @options && options[:daemonize]`
          # when running `$ kill -s SIGTERM puma_process_id`.
          # You can search `puts "Exiting"` in this document to see it.
          raise SignalException, "SIGTERM"
        end
      rescue Exception
        # This `rescue` is only for `Signal.trap "SIGTERM"`, not for `raise SignalException, "SIGTERM"`.
        log "*** SIGTERM not implemented, signal based gracefully stopping unavailable!"
      end
    end
  end
end

Welcome to point out the mistakes in this article :)

只收邮费转 4 本 Ruby 经典书 (己结帖)

gazeldx — Sun, 21 Oct 2018 09:04:38 +0800

邮费 12 元。请加我微信，当你把邮费转我后，就在本帖下留言结帖。

谢谢。

用源 gems.ruby-china.org 报错，之后用 ruby.taobao.org 替代后好了，请管理员关注下

gazeldx — Tue, 03 May 2016 13:56:11 +0800

报错如下：

$ gem install actionview -v 4.1.7
Fetching: actionview-4.1.7.gem ( 10%)
ERROR:  While executing gem ... (Gem::RemoteFetcher::FetchError)
    too many connection resets (https://gems-ruby-china.b0.upaiyun.com/gems/actionview-4.1.7.gem)

是时候搞点新玩意了——用 react-native 开发跨平台 APP

gazeldx — Mon, 18 Apr 2016 13:55:15 +0800

https://github.com/facebook/react-native 从去年发布，短短 1 年出头，github 关注度已经到 30665。

中文社区 http://reactnative.cn/ 也搞得很活跃。

从我自己的使用看，两年前曾经尝试用 Ruby Motion 搞 APP 开发，1 天时间没把 helloWorld 搞出来。 1 个月前用 react-native 搞 APP 开发，1 天时间把 helloWorld 搞出来了，之间也遇到一些问题，都被自己解决了，见： http://gazeldx.github.io/react-native/2016/03/19/React-native/

搞了这么多年 Web 了，是时候搞点新玩意了。

本来想研究深入点，把自己的 APP 上线后，开源让大家围观的。不过由于近期本人重回股市，业余时间重点切换了，只能以此文引诱下大家了。

我的 Sinatra 实践

gazeldx — Sun, 24 Jan 2016 14:35:03 +0800

一直以来，我都在社区积极地实践 Sinatra。这次正好在我发起的“公益读书”活动项目中完整的实践了一次。以前自己的 Sinatra 项目好多都是Classic style，这一次用Modular Application，并且目录结构和 Rails 的目录结构也很像。

Sinatra 做项目的特别之处在于，您的代码都是您可以掌控的，不会像 Rails 那样一下子引入那么多的 gem，而且好多并不是您需要的。因此用 Sinatra 对您的 DIY 能力是种考验。

美德公益读书活动

公益读书活动详情源代码在 https://github.com/gazeldx/meidebook

功能展示

包含“注册、登录、搜索图书、查看图书信息、评论图书、发表读书心得、上传图片、验证码等”功能。

请访问美德公益图书 - 首页体验相关功能（更侧重手机访问体验）。

安装本项目

采用Sinatra架构搭建本项目，数据库操作用Sequel，数据库用SQLite，界面用WeUI。

安装 Ruby

安装rbenv

相比 RVM，我更喜欢 rbenv。RVM 中我想要的功能，rbenv 都有。用了 rbenv，你会发现一些 RVM 的不便之处。

安装rbenv-gemset

安装其它软件

ImageMagick 用于图片处理。

安装本程序

$ git clone git@github.com:gazeldx/meidebook.git
$ cd /path/to/meidebook
$ gem install bundler
$ bundle install
$ sequel -m db/migrations sqlite://db/book_development.db -E # 创建数据库
$ puma # 启动项目，这时可以访问 http://localhost:9292/ 了

代码说明

./config.ru是第一个被加载的文件，./controllers/application_controller.rb是一个很重要的文件。

安装 Nginx 并运行程序在 80 端口

详见./deploy/README.md

其它使用帮助见Wiki

公益读书

gazeldx — Sat, 26 Dec 2015 23:02:58 +0800

你一定读过对自己帮助很大的书，而且相信这些书对别人也会有莫大的帮助。

为什么不把这些好书送给别人呢？

为了让正能量得以不断传承，我们希望受赠者在一个月内读完，并把书传递给下个读者。

为让传书游戏更有趣，捐书人写下互动文字

捐书人游戏玩法

（一）我们建议捐书人只捐自己最爱的书。那些在自己书柜里剩下的、占地方、以后又不会看的书，不建议您用这样的方式捐（如果要捐，你可以不写引导扩散的话，这样就只会影响到一个读者）。因为读者在看您捐的书时，是要花宝贵的时间的。要给就给读者大餐，看完后大呼过瘾。我想这时，您也会感到由衷的开心，特别是这些书被广泛扩散时。表面上，你损失了一本心爱的好书。实际上，你可以再买一本，损失不过十几块钱。而回报，捐过就知道。

（二）我们建议捐书人在书的第一页空白处写上活动简介（如上图）。

之后写上自己的昵称、联系方式、日期和口讯（写在一行），并在本行之后划上一行行横线，在每一行开头写上读者 1、读者 2、读者 N，为以后的读者互动提供引导。

（三）捐书人可以为本书取一个编号，这样，在美德公益图书网站（筹建中）http://meidebook.com 上，可以根据此编号查询到该书的当前状态（因为热心的读者会把扉页拍成照片上传）。每一本捐出的图书都对应了一个唯一的 URL，如：上图所示，捐书人设定的图书编号是“loveme1982”，对应的 URL 就是 http://meidebook.com/loveme1982 ，捐书人和读者可以在此 URL 中聊天，因为 loveme1982 是由捐书人设定的，这保证了进入该 URL 的人都是拿到了本书的读者。

在该页面，会关联该捐书人捐过的所有图书。自然，这个页面就成了捐书人的好书推荐。更多好书就这样被读者发现。

读者游戏玩法

（一）我们建议读者在一个月内读完本书，并把书传递给下一位读者。在传递时，请把游戏玩法和下一位读者简单说明一下。读者如果不愿意读完，可以立刻把书传出去。这样做的目的是加速图书的流传，让正能量传播地快些。

（二）读者可以无条件的中止传递，自行处置手中的图书。因为我们希望最好的书得到最好的流传。为防止“劣币驱逐良币”现象发生，我们加入了本条规则。我们对书顺利传递充满信心，对终结传递倒是有些担心。因为想终结一本书的理由很多，如书中讲述的道理不科学，内容不够正能量等。但大多数人都会想：“可能别人认为这本书好呢？如果我终结了这本书，我内心会不安。”请不要感到不安，无条件、无理由的终结一本书，是“美德公益图书”的游戏规则，我们非常鼓励这种行为。因为你对这本书的终结，为更高质量的图书的广泛流传留出了空间。

运营建议

如果你有兴趣开发运营类似的网站，我就更开心了。我祝福你能运营得比“美德公益图书”影响力更大（当我把这个想法告诉我的同事们的时候，就有个同事因为某些游戏规则和我的想法不一致，要自己造平台了）。

我建议您在运营时注意下图书的质量，好书让这个世界更美好，劣质的书相反。

其实每个捐书者在捐书时，都是一个崭新的开始。如果捐书有任何想法，完全可以制定自己的游戏玩法，不受“美德公益图书”的玩法限制。

一个 String 类型处理不当导致的性能问题，在导出 CSV 文件等�场景不注意就会中招

gazeldx — Wed, 16 Dec 2015 10:07:06 +0800

一种的生成 csv 文件的做法：

csv = ''
@customers.each do |customer|
  csv = "#{csv}#{customer.id},#{.......}\n"
end
return csv

这种做法存在性能问题，特别是 customers 达到 1 万条以上，并且每一行内容比较长的时候。原因是 csv 这个字符串变量太大了（达到 1M），再往 csv 的末尾追加内容会比较吃力，这种情况，生成 csv 最终结果要 1 分钟。

解决的办法：

csv = []
@customers.each do |customer|
  csv << "#{customer.id},#{.......}"
end
return csv.join("\n")

csv 从字符串变成了 Array, 避免了超大 String 的可能。和上述同样场景下，生成 csv 最终结果只要 5 秒。

请管理员解释下：为什么我提交的开源项目在 Sites 里面始终不能显示？

gazeldx — Sun, 15 Nov 2015 13:11:37 +0800

https://github.com/gazeldx/ruby-db-admin 这是本人开发的基于 Ruby 的数据库管理系统。我曾经再次提交到 https://ruby-china.org/sites ，当时是成功了，可过一阵子再去看，就消失了。请问管理员这是什么原因？上 Sites 有什么要求吗？

建议 Ruby-China 把 “求职” 全部替换为 “找工作”

gazeldx — Tue, 29 Sep 2015 13:42:10 +0800

“求职”，一下子让人找工作的人感觉自己在求职位。其实只是找工作，谁也不求谁啊。

[北京] 诚觅 Ruby App 服务端工程师一名 20K

gazeldx — Sat, 12 Sep 2015 15:48:43 +0800

团队风格

一、小而美目前研发团队规模已经扩大到 9 人，苏州 6 人，北京 3 人。 APP 团队已经在北京初步搭建（尚缺一个 Rubyist——你），苏州研发团队专注于通讯 SaaS 平台服务提供，北京团队专注于移动互联产品。二、目前团队基本上是无人管理的状态，自发做事，自我管理。三、领导处于经常被员工顶撞的状态。

工作要求

工作职责

1、为 APP（安卓和 iOS）提供 API 数据支持 2、服务端设计与开发

个性方面

1、有担当 2、学习能力佳，英文佳 3、性格开朗，乐于分享 4、对代码有洁癖者佳（有过度洁癖者请谨慎）

技术栈

1、Ruby 基础扎实 2、熟悉 Rails, Grape, Sinatra 等架构 3、做过 Node.js 4、Linux, 关系型和非关系型数据库，Redis, Git 等 5、有 APP API 开发经验者优

福利待遇

1、基本月工资 20K 左右，视能力而定 2、股份期权激励 3、工作日 9 点 -18 点，中午休息一个小时，双休，不加班 4、五险一金

[苏州] 诚招 Ruby & Rails, JavaScript 全栈工程师

gazeldx — Wed, 24 Jun 2015 14:13:44 +0800

对您的期待

我们期待您是这样的一个伙伴： 1 对计算机技术孜孜追求，甚至有些代码洁癖。 2 不畏惧挑战，勇于担当。 3 学习能力佳，英文佳（必须）。 4 性格开朗，乐于分享。

如果下面提到的部分技术您不熟悉，也没有关系，因为可能是您还没有熟悉该技术的需求。成为同事后，我们一起在项目中熟悉。

Ruby 技术栈

Ruby 基础扎实，熟悉 Rails。 Grape, Sinatra 和 RSpec 需要了解。

JavaScript 技术栈

NodeJS

其他技术栈

Linux, Git, PostgreSQL, Redis 等。

加分项

RubyMotion, Swift, Python, Lisp, Scala, MongoDB, Meteor, EmberJS, AngularJS, ionic, phoneGap, Cordova, React-native 等。安卓 Android APP 和苹果 iOS APP 开发经验。

我们面临的挑战

1 软件如何有效支持大并发网络环境？ 2 前后端程序，还有手机 APP 项目，需要投入人力。

我们非常关注把优秀的技术用对地方，并关注代码质量。在这里，每个同事都像兄弟一样相处。我们关心你技术的成长！

薪资水平

薪资 10000 - 16000 元。这个薪资和上海等一线城市的确没法比，不过在苏州市场上还是有竞争力的（您可能不知道，苏州房价偏低，适合定居）。如果您是技术上牛人，社区中的名人，薪资可以再加。

我们是一个崇尚敏捷的团队，不提倡加班。自在双休。

gazeldx (leader.me 张健)

注册域名的 Rubyist 注意了！

leader.me：程序员的“数字名片”，一站式打造个人品牌

为什么开发 leader.me?

中国程序员的烦恼

感恩回馈 Ruby-China 社区的用户

leader.me 开发团队

今天开源一个博客引擎，助您使用 Markdown 和 Git 进行博客写作

使用 "Markdown" 和 "Git" 享受博客写作。一个基于 Ruby on Rails 8 的开源个人博客引擎。

如何在本地使用 Markdown 文件撰写文章，并通过 git push 发布？

is-bio 在哪些方面比 Jekyll 或 Hugo 更好？

使用 is-bio 的成本是多少？

为什么开发者不再经常写博客了？

is-bio：一个专注于为开发者带来价值的博客引擎

在服务器上部署 is-bio

在本地计算机上安装 is-bio

安装 Ruby

克隆 'is-bio' 项目并安装 Ruby gems

设置 credentials

准备 SQLite 数据库

安装主题

启动 Rails Web 服务器

创建管理员用户

通过 SMTP 发送电子邮件

启动 "Solid Queue" 处理后台任务

创建并安装您的 "GitHub App" 以将本地 "markdown-blog" 仓库的文件更改同步到博客网站

其它功能：自动生成图片缩略图

Clacky AI 和 Cursor AI 用 Ruby 语言做力扣题解的对比

力扣题一

力扣题二

力扣题三

力扣题四

最终结论

Ruby-China 可以安装成一个 App. 但缺少了一个浏览器的后退功能。不太方便。

Best way for Python and Java to reverse a string

Python

Java

How to use Hotwire Turbo in your Rails 6 project with Webpacker.

Background

Goal

Steps

Tips

[南京] 云启盛鼎诚招 Rails, JavaScript 全栈工程师 (10-25k)【已终止】

公司简介

招 Ruby, JavaScript 全栈工程师两名，初、中、高级不限

岗位职责

后端能力

前端能力

职业素养

工作地点与时间

薪资待遇

[苏州] 东湾信息招聘 Ruby 全栈程序员两名（12-20K，14 薪，双休）(已关闭)

苏州东湾信息

职位要求

后端能力

前端能力

职业素养

薪资待遇

Learn Rails 5 by Reading Source Code

Learn-Rails-by-Reading-Source-Code

Table of Contents

Part 0: Before reading Rails 5 source code

What will you learn from this tutorial?

Part 1: Your app: an instance of YourProject::Application

Part 2: config

Part 3: Every request and response

Puma

Rack apps

The core app: ActionDispatch::Routing::RouteSet instance

Render view

How can instance variables defined in Controller be accessed in view file?

Part 4: What does $ rails server do?

Thor

Rails::Server#start

Starting Puma

Conclusion

Exiting Puma

Process and Thread

Example one

Example two

如何在本地使用 Markdown 文件撰写文章，并通过 `git push` 发布？

Part 4: What does `$ rails server` do?

Send `SIGTERM` to Puma