ane (刘宏庆)

数组哈希累加

ane — Wed, 14 Nov 2018 19:19:32 +0800

records =[{"delivery_income_num"=>62,
  "delivery_num"=>0,
  "income_fee"=>3,
  "pickup_alipay_pay_num"=>0,
  "pickup_wechat_pay_num"=>3,
  "box_num"=>0,
}]

    def sum_overview(records)
      delivery_num = 0.0
      income_fee = 0.0
      box_num = 0.0
      records.each do |record|
        delivery_num = delivery_num + record[:delivery_num]
        income_fee = income_fee + record[:income_fee]
        box_num = box_num + record[:box_num]
      end
      {delivery_num: delivery_num, income_fee: income_fee, delivery_rate: delivery_num/box_num}
    end

有个哈希数组，需要对数组里的每个哈希的 value 累加，有什么代码简洁而且还高效的方法或者有没有类似处理功能的 gem 推荐

IO 模式和 IO 多路复用

ane — Wed, 18 Apr 2018 10:32:38 +0800

基础知识

1 用户空间和内核空间

现在操作系统都采用虚拟寻址，处理器先产生一个虚拟地址，通过地址翻译成物理地址（内存的地址），再通过总线的传递，最后处理器拿到某个物理地址返回的字节。

对 32 位操作系统而言，它的寻址空间（虚拟存储空间）为 4G（2 的 32 次方）。

核空间：在 liunx 中，将最高的 1G 字节（从虚拟地址 0xC0000000 到 0xFFFFFFFF），供内核使用，称为“内核空间”。

用户空间：在 liunx 中，将较低的 3G 字节（从虚拟地址 0x00000000 到 0xBFFFFFFF），供各个进程使用，称为“用户空间）。

内核态：当一个任务（进程）执行系统调用而陷入内核代码中执行时，我们就称进程处于内核运行态

用户态：每个进程都有自己的内核栈。当进程在执行用户自己的代码时，则称其处于用户运行态（用户态）

因为每个进程可以通过系统调用进入内核，因此，Linux 内核由系统内的所有进程共享。于是，从具体进程的角度来看，每个进程可以拥有 4G 字节的虚拟空间。

进程寻址空间 0~4G
进程在用户态只能访问 0~3G，只有进入内核态才能访问 3G~4G
进程通过系统调用进入内核态
每个进程虚拟空间的 3G~4G 部分是相同的

1.2 进程上下文切换（进程切换）

为了控制进程的执行，内核必须有能力挂起正在 CPU 上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换（也叫调度）。因此可以说，任何进程都是在操作系统内核的支持下运行的，是与内核紧密相关的。

从一个进程的运行转到另一个进程上运行，这个过程中经过下面这些变化：

保存当前进程 A 的上下文。上下文就是内核再次唤醒当前进程时所需要的状态，由一些对象（程序计数器、状态寄存器、用户栈等各种内核数据结构）的值组成。

这些值包括描绘地址空间的页表、包含进程相关信息的进程表、文件表等。

切换页全局目录以安装一个新的地址空间。
恢复进程 B 的上下文。

可以理解成一个比较耗资源的过程。

1.3 直接 I/O 和缓存 I/O

缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，以 write 为例，数据会先被拷贝进程缓冲区，在拷贝到操作系统内核的缓冲区中，然后才会写到存储设备中。

IO 模式

对于一次 IO 访问（这回以 read 举例），数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的缓冲区，最后交给进程。所以说，当一个 read 操作发生时，它会经历两个阶段：

1. 等待数据准备 (Waiting for the data to be ready)
2. 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)

正式因为这两个阶段，linux 系统产生了下面五种网络模式的方案：

-- 阻塞 I/O（blocking IO）
-- 非阻塞 I/O（nonblocking IO）
-- I/O 多路复用（IO multiplexing）
-- 信号驱动 I/O（signal driven IO）
-- 异步 I/O（asynchronous IO）

block I/O 模型（阻塞 I/O）

read 为例：

（1）进程发起 read，进行 recvfrom 系统调用；

（2）内核开始第一阶段，准备数据（从磁盘拷贝到缓冲区），进程请求的数据并不是一下就能准备好；准备数据是要消耗时间的；

（3）与此同时，进程阻塞（进程是自己选择阻塞与否），等待数据 ing；

（4）直到数据从内核拷贝到了用户空间，内核返回结果，进程解除阻塞。

也就是说，内核准备数据和数据从内核拷贝到进程内存地址这两个过程都是阻塞的。

non-block（非阻塞 I/O 模型）

可以通过设置 socket 使其变为 non-blocking。当对一个 non-blocking socket 执行读操作时，流程是这个样子：

（1）当用户进程发出 read 操作时，如果 kernel 中的数据还没有准备好；

（2）那么它并不会 block 用户进程，而是立刻返回一个 error，从用户进程角度讲，它发起一个 read 操作后，并不需要等待，而是马上就得到了一个结果；

（3）用户进程判断结果是一个 error 时，它就知道数据还没有准备好，于是它可以再次发送 read 操作。一旦 kernel 中的数据准备好了，并且又再次收到了用户进程的 system call；

（4）那么它马上就将数据拷贝到了用户内存，然后返回。

所以，nonblocking IO 的特点是用户进程在内核准备数据的阶段需要不断的主动询问数据好了没有。

I/O 多路复用

I/O 多路复用实际上就是用 select, poll, epoll 监听多个 io 对象，对一个 IO 端口，两次调用，两次返回，比阻塞 IO 并没有什么优越性；关键是能实现同时对多个 IO 端口进行监听；当 io 对象有变化（有数据）的时候就通知用户进程。现在先来看下 I/O 多路复用的流程：

（1）当用户进程调用了 select，那么整个进程会被 block；

（2）而同时，kernel 会“监视”所有 select 负责的 socket；

（3）当任何一个 socket 中的数据准备好了，select 就会返回；

（4）这个时候用户进程再调用 read 操作，将数据从 kernel 拷贝到用户进程。

所以，I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select() 函数就可以返回。

这个图和 blocking IO 的图其实并没有太大的不同，事实上，还更差一些。因为这里需要使用两个 system call (select 和 recvfrom)，而 blocking IO 只调用了一个 system call (recvfrom)。但是，用 select 的优势在于它可以同时处理多个 connection。

所以，如果处理的连接数不是很高的话，使用 select/epoll 的 web server 不一定比使用多线程 + 阻塞 IO 的 web server 性能更好，可能延迟还更大。

select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。

在 IO multiplexing Model 中，实际中，对于每一个 socket，一般都设置成为 non-blocking，但是，如上图所示，整个用户的 process 其实是一直被 block 的。只不过 process 是被 select 这个函数 block，而不是被 socket IO 给 block。

信号驱动 I/O 模型

我们首先开启套接口的信号驱动 I/O 功能，并通过 sigaction 系统调用安装一个信号处理函数。该系统调用立即返回，我们的进程继续工作，也就是说它没有被阻塞。当数据报准备好读取时，内核就为该进程产生一个 SIGIO 信号。我们随后既可以在信号处理函数中调用 recvfrom 读取数据报，并通知主循环数据已准备好待处理，也可以立即通知主循环，让它读取数据报。

无论如何处理 SIGIO 信号，这种模型的优势在于等待数据报到达期间，进程不被阻塞。主循环可以继续执行，只要不时等待来自信号处理函数的通知：既可以是数据已准备好被处理，也可以是数据报已准备好被读取。

asynchronous I/O（异步 I/O）

异步 I/O（asynchronous I/O）由 POSIX 规范定义。一般地说，这些函数的工作机制是：告知内核启动某个操作，并让内核在整个操作（包括将数据从内核拷贝到我们自己的缓冲区）完成后通知我们。这种模型与信号驱动模型的主要区别在于：信号驱动 I/O 是由内核通知我们何时启动一个 I/O 操作，而异步 I/O 模型是由内核通知我们 I/O 操作何时完成。

我们调用 aio_read 函数（POSIX 异步 I/O 函数以 aio_或 lio_开头），给内核传递描述字、缓冲区指针、缓冲区大小（与 read 相同的三个参数）、文件偏移（与 lseek 类似），并告诉内核当整个操作完成时如何通知我们。该系统调用立即返回，在等待 I/O 完成期间，我们的进程不被阻塞。

（1）用户进程发起 read 操作之后，立刻就可以开始去做其它的事。

（2）而另一方面，从 kernel 的角度，当它受到一个 asynchronous read 之后，首先它会立刻返回，所以不会对用户进程产生任何 block。

（3）然后，kernel 会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel 会给用户进程发送一个 signal，告诉它 read 操作完成了。

select/poll/epoll的区别及其Ruby示例

首先前文已述 I/O 多路复用的本质就是用 select/poll/epoll，去监听多个 socket 对象，如果其中的 socket 对象有变化，只要有变化，用户进程就知道了。

select 是不断轮询去监听的 socket，socket 个数有限制，一般为 1024 个；

poll 还是采用轮询方式监听，只不过没有个数限制；

epoll 并不是采用轮询方式去监听了，而是当 socket 有变化时通过回调的方式主动告知用户进程。

阻塞 I/O（blocking IO）

require 'socket'

one_hundred_kb = 1024 * 100

Socket.tcp_server_loop(4481) do |connection|
  begin
    #  readpartial(1) It blocks only if ios has no data immediately available.
    while data = connection.readpartial(one_hundred_kb) do
      puts data
    end
  rescue EOFError # EOFError Raised by some IO operations when reaching the end of file.
  end
  connection.close
end

非阻塞 I/O（nonblocking IO）

IO.select 会阻塞并且轮询 socket

read

require 'socket'

Socket.tcp_server_loop(4481) do |connection|
  loop do
    begin
      puts connection.read_nonblock(4096)
    rescue Errno::EAGAIN
      IO.select([connection])
      retry
    rescue EOFError
      break
    end
  end

  connection.close
end

wirte

require 'socket'

client = TCPSocket.new('localhost',4481)

payload = 'hihihihi' * 10_00

begin
  loop do
    bytes = client.wirte_nonblock(payload)
    break if bytes >= payload.size

    payload.slice!(0,bytes)
    IO.select(nil,[client])
  end
rescue Errno::EAGAIN
  IO.select(nil,[client])
  retry
end

除了非阻塞读写，server 端有非阻塞接受 accept_nonblock。client 有非阻塞连接 connect_nonblock

I/O 多路复用（IO multiplexing）

select 版本

  connections = [<TCPSocket>,<TCPSocket>,<TCPSocket>]
  loop do
    ready = IO.select connections

    readable_connections = ready[0]
    readable_connections.each do |conn|
      begin
        conn.read_nonblock(4096)
      rescue Errno::EAGAIN
      end
    end
  end
``
使用IO.select 可以减低无用连接的开销。

Ruby 为啥没有 List 数据结构

ane — Mon, 09 Apr 2018 20:51:04 +0800

突然好奇这个问题

Ruby 的回调方法

ane — Thu, 19 Oct 2017 10:54:23 +0800

大部分定义在 Module 中

append_features
const_missing
extended
included
method_added
method_removed
prepend_features
prepended

在 Class 中定义的

inherited

定义在 BaseObject 中的

method_missing
singleton_method_added
singleton_method_removed
singleton_method_undefined

源码探索 Rails 路由的处理

ane — Wed, 13 Sep 2017 17:54:43 +0800

首先 Rails4+，默认的 routes 是’config/routes.rb’。要想拆分 routes，可以往 paths 里加入：

class Application < Rails::Application
  config.paths['config/routes.rb'].concat ['config/routes2.rb']
end

在 rails3 里，采用的是 config.paths['config/routes’]

Http 的处理

ActionDispatch::Routing::Mapper::HttpHelpers 中定义了在 route 里可以设置的 5 种 HTTP via

get 'bacon', to: 'food#bacon’
post 'bacon', to: 'food#bacon’
patch 'bacon', to: 'food#bacon’
put 'bacon', to: 'food#bacon’
delete 'broccoli', to: 'food#broccoli’

最终调用的还是 match 方法

match 'path' => 'controller#action', via: patch
match 'path', to: 'controller#action', via: :post
match 'path', 'otherpath', on: :member, via: :together

所以，直接写成 match 方法，似乎，也算少执行一些代码。

Rails::Application::RoutesReloader

Rails 路由的加载的地方，所有被拆分的路由文件放在@paths里

ActionDispatch::Routing::Mapper::Base

ActionDispatch::Routing::Mapper::Base 里定义了路由的匹配规则，具体可以看看代码注释 ActionDispatch::Routing::RouteSet

RouteSet 其实就是一个 rack

通过 initializer :add_routing_paths 的初始器，指定了 routes.rb 的文件位置，

initializer :add_routing_paths do |app|
  routing_paths = self.paths["config/routes.rb"].existent

  if routes? || routing_paths.any?
    app.routes_reloader.paths.unshift(*routing_paths)
    app.routes_reloader.route_sets << routes
  end
end

可以在 app.routes_reloader.paths 中加入多个 routes 文件。

set_routes_reloader_hook 初始化器，开始执行 routes 文件里的代码，

initializer :set_routes_reloader_hook do |app|
  reloader = routes_reloader
  reloader.execute_if_updated
  reloaders << reloader
  app.reloader.to_run do
    # We configure #execute rather than #execute_if_updated because if
    # autoloaded constants are cleared we need to reload routes also in
    # case any was used there, as in
    #
    #   mount MailPreview => 'mail_view'
    #
    # This means routes are also reloaded if i18n is updated, which
    # might not be necessary, but in order to be more precise we need
    # some sort of reloaders dependency support, to be added.
    require_unload_lock!
    reloader.execute
  end
end

initializer :build_middleware_stack do
  build_middleware_stack
end

alias :build_middleware_stack :app

def app
  @app || @app_build_lock.synchronize {
    @app ||= begin
      stack = default_middleware_stack
      config.middleware = build_middleware.merge_into(stack)
      config.middleware.build(endpoint)
    end
  }
end
def endpoint
  self.class.endpoint || routes
end
def routes
  @routes ||= ActionDispatch::Routing::RouteSet.new_with_config(config)
  @routes.append(&Proc.new) if block_given?
  @routes
end

简而言之，就是:build_middleware_stack 初始化一个 RouteSet，作为第一个 rack 加入 middleware，:add_routing_paths 指定了路由的 path，:set_routes_reloader_hook 执行路由文件，装配路由。

处理 request

当发送请求时，http 服务器会开始调用 middleware 的 call 方法，最底层的 RouteSet，会根据 env 生成一个 ActionDispatch::Request 对象。

def call(env)
  req = make_request(env)
  req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
  @router.serve(req)
end

@router 是一个 ActionDispatch::Journey::Router 对象，里面包含一个@routes，是 ActionDispatch::Journey::Routes 的对象，@routes里包含许多 ActionDispatch::Journey::Route 对象，每一个都是一条 http 的请求匹配模式。

那么 @router 和 RouteSet 怎么关联的？

每一个 http 请求先包装成一个 ActionDispatch::Routing::Mapper 对象，指定了@scope_level，@concerns，@scope。

mapping = Mapping.build(@scope, @set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, options)
@set.add_route(mapping, ast, as, anchor)

每一个 Mapper 对象，包装成 ActionDispatch::Routing::Mapper::Mapping 对象。 RouteSet 的初始化方法

def initialize(config = DEFAULT_CONFIG)
       self.named_routes = NamedRouteCollection.new
       self.resources_path_names = self.class.default_resources_path_names
       self.default_url_options = {}

       @config                     = config
       @append                     = []
       @prepend                    = []
       @disable_clear_and_finalize = false
       @finalized                  = false
       @env_key                    = "ROUTES_#{object_id}_SCRIPT_NAME".freeze

       @set    = Journey::Routes.new
       @router = Journey::Router.new @set
       @formatter = Journey::Formatter.new self
     end

此处的@set就是 RouteSet 对象，@set.add_route里调用了 Journey::Routes.new.add_route

def add_route(name, mapping)
  route = mapping.make_route name, routes.length
  routes << route
  partition_route(route)
  clear_cache!
  route
end
def make_route(name, precedence)
  route = Journey::Route.new(name,
                    application,
                    path,
                    conditions,
                    required_defaults,
                    defaults,
                    request_method,
                    precedence,
                    @internal)

  route
end

在 Journey::Routes.new.add_route 里，调用 mapping.make_route，make_route 生成一条 http 请求的匹配模式，加入到 Journey::Routes 中 Journey::Routes << Journey::Route RouteSet.@set = Journey::Routes RouteSet.@router = Journey::Router.new @set 至此 RouteSet 和 @router，Routes，Route 关联起来了。

当调用 RouteSet 的 call 方法，就调用@router的 serve 方法

def serve(req)
  find_routes(req).each do |match, parameters, route|
    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

    req.path_parameters = set_params.merge parameters

    status, headers, body = route.app.serve(req)

    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

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

此处的 route.app 是 make_route 创建 route 是，传入的 application，是一个 Routing::Endpoint 类，这里是它的一个子类 ActionDispatch::Routing::RouteSet::Dispatcher 对象

def serve(req)
  params     = req.path_parameters
  controller = controller req
  res        = controller.make_response! req
  dispatch(controller, params[:action], req, res)
rescue ActionController::RoutingError
  if @raise_on_name_error
    raise
  else
    return [404, { "X-Cascade" => "pass" }, []]
  end
end

此时 make_response 定义在 ActionController::Base 中，生成 ActionDispatch::Response 对象

dispatch 调用到对应的 action，返回 rack 的返回值

def dispatch(name, request, response) #:nodoc:
  set_request!(request)
  set_response!(response)
  process(name)
  request.commit_flash
  to_a
end

def rack_response(status, header)
  if NO_CONTENT_CODES.include?(status)
    [status, header, []]
  else
    [status, header, RackBody.new(self)]
  end
end

此处的 self 就是 ActionDispatch::Response 对象。

至此，路由的配置，和处理一个 http 请求的过程就完整了。

Ruby webrick

ane — Thu, 24 Aug 2017 15:59:33 +0800

写在开始前，一个简易的 webrick 服务

require  ‘webrick'
root = File.expand_path 'public_html'
server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root
# trap 'INT’作用是当收到’control+c’的中断信号就退出server，用过'rails s' 的应该都清楚
trap 'INT' do server.shutdown end
server.start

代码 so 简单，效果如下：

➜  rake ruby webrick.rb
[2017-08-24 10:36:45] INFO  WEBrick 1.3.1
[2017-08-24 10:36:45] INFO  ruby 2.3.0 (2015-12-25) [x86_64-darwin15]
[2017-08-24 10:36:45] INFO  WEBrick::HTTPServer#start: pid=11803 port=8000

在 public_html 文件夹下放入 index.html，这就算你的首页了。这里涉及的类就很少了，只有一个 WEBrick::HTTPServer，和它的父类::WEBrick::GenericServer。

初始化

GenericServer 的初始化

def initialize(config={}, default=Config::General)
    @config = default.dup.update(config)
    @status = :Stop
    @config[:Logger] ||= Log::new
    @logger = @config[:Logger]
    # 初始化最大连接数
    @tokens = Thread::SizedQueue.new(@config[:MaxClients])
    @config[:MaxClients].times{ @tokens.push(nil) }

    webrickv = WEBrick::VERSION
    rubyv = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
    @logger.info("WEBrick #{webrickv}")
    @logger.info("ruby #{rubyv}")

    @listeners = []
    @shutdown_pipe = nil
    unless @config[:DoNotListen]
      if @config[:Listen]
        warn(":Listen option is deprecated; use GenericServer#listen")
      end
      # 监听端口和IP，最终返回一个TCPServer。
      listen(@config[:BindAddress], @config[:Port])
      if @config[:Port] == 0
        @config[:Port] = @listeners[0].addr[1]
      end
    end
  end

整个初始化，就是返回一个 TCPServer 的 socket。TCP/IP stream 型连接的服务器端套接字的类。accept 实例方法会受理客户端的连接请求，返回已连接的 TCPSocket 的实例。

HTTPServer 的初始化

# Creates a new HTTP server according to +config+
   #
   # An HTTP server uses the following attributes:
   #
   # :AccessLog:: An array of access logs.  See WEBrick::AccessLog
   # :BindAddress:: Local address for the server to bind to
   # :DocumentRoot:: Root path to serve files from
   # :DocumentRootOptions:: Options for the default HTTPServlet::FileHandler
   # :HTTPVersion:: The HTTP version of this server
   # :Port:: Port to listen on
   # :RequestCallback:: Called with a request and response before each
   #                    request is serviced.
   # :RequestTimeout:: Maximum time to wait between requests
   # :ServerAlias:: Array of alternate names for this server for virtual
   #                hosting
   # :ServerName:: Name for this server for virtual hosting

   def initialize(config={}, default=Config::HTTP)
     super(config, default)
     @http_version = HTTPVersion::convert(@config[:HTTPVersion])

     @mount_tab = MountTable.new
     if @config[:DocumentRoot]
       mount("/", HTTPServlet::FileHandler, @config[:DocumentRoot],
             @config[:DocumentRootOptions])
     end

     unless @config[:AccessLog]
       @config[:AccessLog] = [
         [ $stderr, AccessLog::COMMON_LOG_FORMAT ],
         [ $stderr, AccessLog::REFERER_LOG_FORMAT ]
       ]
     end

     @virtual_hosts = Array.new
   end

之前有人问 mount 的意思，这里就写的很清楚了

##
# Mounts +servlet+ on +dir+ passing +options+ to the servlet at creation
# time
def mount(dir, servlet, *options)
  @logger.debug(sprintf("%s is mounted on %s.", servlet.inspect, dir))
  @mount_tab[dir] = [ servlet, options ]
end

mount 就是把不同 servlet 和不同的 dir 对应起来。 webrick 自带 4 个 servlet，分别处理 CGI scripts, ERB pages, Ruby blocks，directory HTTPServlet::FileHandler，就不言而喻了。

def start(&block)
    raise ServerError, "already started." if @status != :Stop
    server_type = @config[:ServerType] || SimpleServer

    setup_shutdown_pipe

    server_type.start{
      @logger.info \
        "#{self.class}#start: pid=#{$$} port=#{@config[:Port]}"
      call_callback(:StartCallback)

      shutdown_pipe = @shutdown_pipe

      thgroup = ThreadGroup.new
      @status = :Running
      begin
        while @status == :Running
          begin
            sp = shutdown_pipe[0]
            # 多路复用IO。参数列表前三项为输入／输出／异常的IO（或者子类）的实例数组。第四个参数是timeout。返回一个包含3个元素的数组，这3个元素分别是等待输入/输
            # 出／异常的对象的数组(指定数组的子集)
            if svrs = IO.select([sp, *@listeners], nil, nil, 2.0)
              if svrs[0].include? sp
                # swallow shutdown pipe
                buf = String.new
                nil while String ===
                          sp.read_nonblock([sp.nread, 8].max, buf, exception: false)
                break
              end
              svrs[0].each{|svr|
                @tokens.pop          # blocks while no token is there.
                # 本质就是调用socket的accept
                if sock = accept_client(svr)
                  unless config[:DoNotReverseLookup].nil?
                    sock.do_not_reverse_lookup = !!config[:DoNotReverseLookup]
                  end
                  # start_thread下面会做进一步解释
                  th = start_thread(sock, &block)
                  th[:WEBrickThread] = true
                  thgroup.add(th)
                else
                  @tokens.push(nil)
                end
              }
            end
          rescue Errno::EBADF, Errno::ENOTSOCK, IOError => ex
            # if the listening socket was closed in GenericServer#shutdown,
            # IO::select raise it.
          rescue StandardError => ex
            msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
            @logger.error msg
          rescue Exception => ex
            @logger.fatal ex
            raise
          end
        end
      ensure
        cleanup_shutdown_pipe(shutdown_pipe)
        cleanup_listener
        @status = :Shutdown
        @logger.info "going to shutdown ..."
        thgroup.list.each{|th| th.join if th[:WEBrickThread] }
        call_callback(:StopCallback)
        @logger.info "#{self.class}#start done."
        @status = :Stop
      end
    }
  end

tokens 的作用类似信号量，初始化 server 的时候，会把 tokens 用 nil 填充满，只有能从 token 获取到信号的时候，才可以创建线程，获取不到信号的时候，会阻塞主线程，以此控制并发数量，具体看 SizedQueue 的定义吧

##
 # Accepts a TCP client socket from the TCP server socket +svr+ and returns
 # the client socket.

 def accept_client(svr)
   sock = nil
   begin
     sock = svr.accept
     sock.sync = true
     Utils::set_non_blocking(sock)
   rescue Errno::ECONNRESET, Errno::ECONNABORTED,
          Errno::EPROTO, Errno::EINVAL
   rescue StandardError => ex
     msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
     @logger.error msg
   end
   return sock
 end

其中 accept_client 会不断返回一个连接好的 socket，针对每个与客户端通信的 socket，webrick 会创建一个线程，在 start_thread 中处理，start_thread 里只要一行主要代码，执行

run(sock)
def start_thread(sock, &block)
   ...
   block ? block.call(sock) : run(sock)
   ...
end

所以，对作者 GenericServer 类的注释，只有这一行，可见 run 方法很重要

##
# Base TCP server class.  You must subclass GenericServer and provide a #run
# method.

##
# Processes requests on +sock+
def run(sock)
  while true
    res = HTTPResponse.new(@config)
    req = HTTPRequest.new(@config)
    server = self
    begin
      timeout = @config[:RequestTimeout]
      while timeout > 0
        break if sock.to_io.wait_readable(0.5)
        break if @status != :Running
        timeout -= 0.5
      end
      raise HTTPStatus::EOFError if timeout <= 0 || @status != :Running
      raise HTTPStatus::EOFError if sock.eof?

 # Parses a request from +socket+.  先是解析请求行，再是请求报文头部解析，最后确#定keep_alive
      req.parse(sock)
      res.request_method = req.request_method
      res.request_uri = req.request_uri
      res.request_http_version = req.http_version
      res.keep_alive = req.keep_alive?
      server = lookup_server(req) || self
      if callback = server[:RequestCallback]
        callback.call(req, res)
      elsif callback = server[:RequestHandler]
        msg = ":RequestHandler is deprecated, please use :RequestCallback"
        @logger.warn(msg)
        callback.call(req, res)
      end
     # 调用get_instance实例化对应的servlet，并且调用servlet的service方法，组装res.body等等
      server.service(req, res)
    rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
      res.set_error(ex)
    rescue HTTPStatus::Error => ex
      @logger.error(ex.message)
      res.set_error(ex)
    rescue HTTPStatus::Status => ex
      res.status = ex.code
    rescue StandardError => ex
      @logger.error(ex)
      res.set_error(ex, true)
    ensure
      if req.request_line
        if req.keep_alive? && res.keep_alive?
          req.fixup()
        end
        res.send_response(sock)
        server.access_log(@config, req, res)
      end
    end
    break if @http_version < "1.1"
    break unless req.keep_alive?
    break unless res.keep_alive?
  end
end

自定义 servlet

只需要继承 WEBrick::HTTPServlet::AbstractServlet，并且提供相应的 do_GET 方法，就基本能实现一个简单的 servlet。可以对 request 和 response 做一些处理。

require 'webrick'

class Simple < WEBrick::HTTPServlet::AbstractServlet
  def do_GET request, response
    status, content_type, body = do_stuff_with request

    response.status = status
    response['Content-Type'] = content_type
    response.body = "#{body} Hello, World!"
  end

  def do_stuff_with request
    return 200, 'text/plain', 'you got a page'
  end
end

class Configurable < Simple
 def initialize server, color, size
   super server
   @color = color
   @size = size
 end

 def do_stuff_with request
   content = "<p " +
             %q{style="color: #{@color}; font-size: #{@size}"} +
             ">Hello, World!"

   return 200, "text/html", content
 end
end

server = WEBrick::HTTPServer.new :Port => 8000

server.mount '/simple', Simple
server.mount '/configurable', Configurable, 'red', '2em'

server.start

其它

除了提到的，webrick 里还涉及到 log，cookie，auth，https，proxy，cgi，HTTPRequest 和 HTTPResponse 相关的处理，可以具体看代码，其实已经不算很复杂了

Rails 里的 cache

ane — Fri, 18 Aug 2017 17:15:30 +0800

Rails 的 cache 统一入口是 Rails.cache。通常会在 environments 里进行配置，配置方式为：config.cache_store = :null_store. 在 Rails 的 bootstrap 中，将 config.cache_store 赋值给 Rails.cache，从而让 Rails.cache 变成一个全局统一的入口。 Rails.cache = ActiveSupport::Cache.lookup_store(config.cache_store)

Rails 自带的 cache 有四种

autoload :FileStore,     "active_support/cache/file_store"
autoload :MemoryStore,   "active_support/cache/memory_store” 
autoload :MemCacheStore, "active_support/cache/mem_cache_store"
autoload :NullStore,     "active_support/cache/null_store”

ActiveSupport::Cache.lookup_store 的参数如果是 nil If no arguments are passed to this method, then a new ActiveSupport::Cache::MemoryStore object will be returned.

所以默认的存储系统是 MemoryStore。ActiveSupport::Cache.lookup_store 接受自定义的存储对象。

#   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
#    => returns MyOwnCacheStore.new

ActiveSupport::Cache::Store 是四个存储类型的基类，提供了统一的 API： +fetch+, +write+, +read+, +exist?+, and +delete+.

需要特别强调 fetch 的:race_condition_ttl 参数，延长了过期数据的过期时间，避免死锁发生，但我觉得也是鸡肋而已。

# Writes the value to the cache, with the key.
#
# Options are passed to the underlying cache implementation.
def write(name, value, options = nil)
  options = merged_options(options)

  instrument(:write, name, options) do
    entry = Entry.new(value, options)
    write_entry(normalize_key(name, options), entry, options)
  end
end

每次缓存的数据，都被包装成了 Entry 对象。这样就可以在过期的情况下，从 Time.now 开始，再续命 race_condition_ttl 时间

if entry && entry.expired?
  race_ttl = options[:race_condition_ttl].to_i
  if (race_ttl > 0) && (Time.now.to_f - entry.expires_at <= race_ttl)
    # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
    # for a brief period while the entry is being recalculated.
    entry.expires_at = Time.now + race_ttl
    write_entry(key, entry, expires_in: race_ttl * 2)
  else
    delete_entry(key, options)
  end
  entry = nil
end

write_entry(key, entry, expires_in: race_ttl * 2) 看了看 write_entry 方法，似乎对 expires_in 没做任何处理，所以，估计还是只是续了 race_condition_ttl 一倍的命

FileStore 有 ActiveSupport::Cache::Strategy::LocalCache 配合本地使用缓存

下面接着讲 Rails 的具体 cache 方案

1. rails 框架自动进行 SQL 缓存

rails 在内存中缓存了每次 sql 查询的结果，那么在同一次经过 ActionPack 时，相同的 sql 会命中缓存，而提高性能 ActiveRecord::Core 中的方法。

def cached_find_by_statement(key, &block) # :nodoc:
  cache = @find_by_statement_cache[connection.prepared_statements]
  cache[key] || cache.synchronize {
    cache[key] ||= StatementCache.create(connection, &block)
  }
end

就 find 查询而言，缓存的是一个关于 sql 语句的抽象二叉树，而不是所谓的查询结果。

2.ActiveRecord 层缓存

在 rails 的 model 层中可以手动缓存某些业务结果到对应的缓存存储系统里。

Rails.cache.fetch(key, expires_in: 1.hour) do 
....
end

3. ActionController 层

action 缓存：rails4 中移除了 action 的缓存，需要 gem(actionpack-action_caching) 才能实现。缓存了 action response 的 html 结果，但可以进入 action-pack 进行 authenticaion 等判断。其内部实现主要是借助 fragment cache 和各种 callback 实现的。如

before_action :authentication, only: :show
cache_action :show, expires_in: 1.hour

采取的是讲缓存的方法设置为 around_action，每次执行 action 的时候，就会 around 这个缓存操作。

def write_fragment(key, content, options = nil)
  return content unless cache_configured?

  key = fragment_cache_key(key)
  instrument_fragment_cache :write_fragment, key do
    content = content.to_str
    cache_store.write(key, content, options)
  end
  content
end

而这个 cache_store，就是在 AbstractController::Caching 中定义的 config.cache_store = ActiveSupport::Cache.lookup_store(store)，也就是 Rails.cache page 缓存：rails4 中移除了 page 的缓存，需要 gem(actionpack-page_caching) 才能实现。缓存了 action response 的 html，无需进入 action-pack，直接可以返回结果，速度是最快的。 cache_page :show, expires_in: 1.hour

def write(content, path, gzip)
  FileUtils.makedirs(File.dirname(path))
  File.open(path, "wb+") { |f| f.write(content) }

  if gzip
    Zlib::GzipWriter.open(path + ".gz", gzip) { |f| f.write(content) }
  end
end

page 缓存就干脆存入文件里，如果可以的话 gzip 压缩

4. ActionView 层缓存

随着互联网应用的逐渐发展，页面复杂程度加剧，后端无法做到整页面的缓存，只能分割成片段。片段缓存的概念逐渐强化。虽然调用的是 Helper 里的 cache，本质还是 ActionController 层的缓存

字符串截取后面

ane — Wed, 05 Jul 2017 15:07:55 +0800

今天看到一段 erlang 代码，大致功能就是输入“xxxx.erl”或者“xxxx”的字符串。截取其中的“.erl”，来进行判断是否是 erlang 源文件

-define(EXT, ".erl").

 lists:reverse(string:sub_string(lists:reverse(Str), 1, length(?EXT))).

代码的思路也只是先把字符串先 reverse 成“lre.xxxx”,再截取 [1..".erl".length],然后再 reverse 成“.erl”。

这种先 reverse 再截取，再 reverse 的方式，不是很清楚，会是从遍历字符串效率角度考虑的吗？发个问题，想让大家多提点思路吧

以前一些算法题类似于字符串首部移到尾部，到是这样的思路方式。

想在一个 Rails 项目里使用同一个 gem 的不同版本，有什么好的实现方式

ane — Tue, 09 May 2017 14:55:47 +0800

简单举例，一个 rails 项目里，使用了 redis 的 3.0.4 和 3.3.3 两个版本，想要在不同的 url 里动态使用不同 redis 版本

刚刚折腾了半天，终于找到一个方式，思路就是别在 gemfile 中添加任何 gem 的依赖，采用 $LOAD_PATH 加入依赖，每次 require 一个 gem 以后，记得使用完的时候在全局里删掉

$LOADED_FEATURES.delete

大概的代码是这样的

def set_book
  if  params[:id] == "1"
   $LOADED_FEATURES.delete_if{|a|  a.include?("redis-3.3.3")}
   $LOAD_PATH.unshift File.expand_path('vendor/bundle/ruby/2.3.0/gems/redis-3.0.4/lib',root)

  require File.expand_path('vendor/bundle/ruby/2.3.0/gems/redis-3.0.4/lib/redis', root)
  elsif  params[:id] == "2"
    $LOADED_FEATURES.delete_if{|a|  a.include?("redis-3.0.4")}
   $LOAD_PATH.unshift File.expand_path('vendor/bundle/ruby/2.3.0/gems/redis-3.3.3/lib', root)
  require File.expand_path('vendor/bundle/ruby/2.3.0/gems/redis-3.3.3/lib/redis', root)
  end
  @book = Book.find(params[:id])
end

[北京] 三元桥听云大家庭招聘 Ruby 工程师

ane — Sun, 18 Sep 2016 14:23:24 +0800

关于我们

（北京基调网络股份有限公司）国内专业的应用性能管理 (APM) 解决方案提供商，国内首家完整实现全栈溯源。专注于帮助开发者解决应用上线后性能问题的监控与管理。及时发现问题，减少用户流失。听云拥有 20 万个遍布全国的真实用户节点，平台每日帮助监控超 100 亿次真实用户请求，每天发现用户性能问题超过 15 万个。每天可为开发者留住用户 175 万个，挽回损失 1400 万元。包括 BAT 在内，Alexa 排名前 100 企业有 81 家使用听云。

听云十年

产品分类

听云 App，听云 Network，听云 Browser，听云 Server，听云 System。

研发力量

听云 65% 的研发团队，采用的开发语言有 Java，Net，Php，Ruby，Go，Python，Node，Javascript，Android，IOS, Erlang。

听云鼓励内部员工岗位流动，今天负责的产品线，明天也许就转入其它产品线部门。同时，听云也鼓励员工同时做多个语言的开发工作。

基本要求

熟悉 Ruby 语言
1. 熟悉 Ruby 语言特性，元编程
熟悉 RubyOnRails 的技术栈
1. Railtie，Engine，Initializable 不会感到陌生
喜欢简洁，能够高效工作
1. review 和定期 refactor
熟悉自动化测试，MiniTest 或 RSpec

加分项

熟悉 Sinatra
熟悉 Jruby
热爱开源

工薪与福利

七险一金。13 薪。零食水果自助。健身房。晚餐自助。另有交通补，餐补等补助多项。

薪资待遇：10k-20k

接受简历邮箱 liuhq@tingyun.com

干掉你代码中的坏味道

ane — Fri, 05 Aug 2016 17:00:44 +0800

最近团队开始抓代码质量了，总结一下自己的经验，先看看坏代码有哪些特点：

“幸福的家庭都一样，不幸的家庭却各有不同”，这句话放到代码里也同样适用。接下来，我们聊一聊如何解决坏代码问题。

如果我问你，“你们是如何保证团队代码质量的”，你的回答可能是：“我们每次写完代码，都会花一些时间 review 一下。”

恩，做的确实不错，但是，做的还不够，除非你是门门考试都 100 的学霸，否则，借助一些工具还是比较稳妥的办法。

在这里简单介绍一个代码分析工具 RubyCritic，这是一个专门针对 Ruby 的一个静态代码分析工具。其它语言的，也有相似功能的工具链，我就不做介绍了。

这是一个命令行工具，第一步就是添加到你的 gem 库中，当然，还可以使用 guard 自动化分析。（Ruby 的世界，你懂得~）第二 step，在 console 运行【RubyCritic】命令，就像这样：

在命令的最后，会生成一个静态页面。长这个样子：

x 轴代表改动频率，Y 轴代表代码复杂程度

这是分析结果的 overview，超过 200 的复杂度的，基本都是坏代码。

再看看 code 里的内容：

对不同文件按照改动频率、复杂度、重复度和坏味道 4 个维度进行综合评定代码质量等级（和美国考试的成绩打分规则一样）。

RubyCritic 对代码分析的原理，其实就是分析一些，被它认为是坏代码的点。注意，我这里使用的措辞是“被它认为，所以，有时候，它不是绝对的正确。”还可以查看具体的类文件中的代码质量问题。

更多的介绍，详见 https://github.com/whitesmith/rubycritic

下面，我们针对 RubyCritic 给我们的一些坏代码的点，有针对性的做些代码调整。

这里使用 git diff 比较新旧版本的差异。operator 原来是实例方法，代码行 7，并且里面还有一个 if 结构体。started_time_and_node 原来是实例方法，代码行 4，并且里面还不止一个 if 结构体。

笔者 review 的方式：

1.实例方法修改为类方法（减少混入方法，解耦合，减低负责度）

2.多使用 Ruby 原生链式操作（减少中间变量，更少的代码，对于脚本语言，就是更快的执行效率，而且很多原生方法是 C 语言实现。）

3.去掉结构体（现代编程语言的结构体，让代码具有丰富的逻辑性和可读性，但是缺点就是 cpu 的额外开销。）

以上部分，属于语法层面的奇技淫巧。

第二部分，我们从设计角度分析一下。

它的代码行只有 141 行，方法也只有 7 个。但是评级却是 C。再看看代码分析细节，这里就展现一小部分，简直就是惨不忍睹，不好意思全展现给大家看了。

没有人会一开始就这样写代码，这种坏代码，永远都是渐渐变馊的。不过笔记仔细想来，当年遇到过比着还馊 1000 倍的代码（1000 倍都不算过分）。

这是笔者做的第一版重构结果。

这里使用了策略模式。Stats_hash 不再是充当一个集合的作用，现在变成了一个环境类，将原来依赖 if 结构数据分装到不同的行为类中。

第二版的改动计划是，引入 work-job 的模式，并发执行 4 个 job。

第三版改动计划就是利用回调方式，去掉与该类不相干的代码，将逻辑分装到行为类里。

好了，写到这里，基本的代码层面的优化思路就这些了，其它就是开支散叶的过程，这里就不冗余了。下一节，咱俩聊一聊性能优化的一些思路。

如何在 controller 中捕获 SyntaxError 异常

ane — Thu, 10 Sep 2015 18:26:41 +0800

最简单的方式是这样的，

def index
    begin
    @articles = Article.all
    rescue Exception => e
        puts "error:#{$!} at:#{$@}" 
    end
end
$! #表示异常信息  
$@ #表示异常出现的代码位置

如果我查找一个不存在的 article，比如这样：

def index
    begin
    @articles = Article.find 10000 # 10000是不存在的
    rescue Exception => e
        puts "error:#{$!} at:#{$@}" 
    end
end

这样是可以顺利捕获这个 StandardError 异常。

我现在改成这样，故意少一个“=”：

def index
    begin
    @articles  Article.all #少等号
    rescue Exception => e
        puts "error:#{$!} at:#{$@}" 
    end
end

console 报一个syntax error, unexpected tCONSTANT, expecting keyword_end,但是代码里没法目前没有捕获到，有什么方法可以获取这个异常？

SyntaxError 异常，在 web-console 这个 gem 中是可以捕获的，目前没搞明白，它是通过怎样的方式捕获

rails4 中使用了 web-console，event = ActiveSupport::Notifications::Event.new (*args).payload[:request].env["web_console.exception"] 这种方式是可以获取 SyntaxError

如何在回掉函数中跳出 while 循环

ane — Wed, 03 Dec 2014 09:59:38 +0800

虽然是 js 代码，但是还是求助万能的 ruby-china.

需求是这样的：“抓取某个网站的数据，因为我不知道它具体分多少页，所以我只能在抓取的时候判断是否是最后一页”

while(flag){
    download(url, function(data) {
        if(data){
            var $ = cheerio.load(data);
            if($(".noresult").length==1){
                console.log('空');
                               flag=false;
            }
        }
    });
}

但是因为 node 的异步原因，这样是没法实现的，能有什么好的办法吗？

============================================================================================ 昨天一下午写不出来，今天早上居然 5 分钟内写出来了，思路是如此的清晰。拿出来，求拍砖，求改进。

var flag =true;
while(flag){
    page++;
    flag= (function(flag){ 
       return flag;
    })(download(url+page, function(data) {
        if(data){
            var $ = cheerio.load(data);
            if($(".noresult").length==1){
                console.log('空');
                return  false;
            }
                  //保存抓取的信息
             return true;
        }
    }));
}

rails 源码里的测试如何运行啊

ane — Wed, 26 Nov 2014 10:36:05 +0800

我跑 activemodel 里的测试文件提示错误，应该怎么测试？

====================================================================================

最近也觉得 gem 有点乱了，所以花了点时间重新整理了一下，重新执行 bundle install 的时候，依旧提示 2-1-stable 的错误。

最后结论是，原来自己 fork 了分支的 master 和原来 rails/rails 的 master 不是一个分支，自己 fork 的分支会将指引到一个 gemfile 是调用 github 地址的 2-1-stable.大家多注意一下。可以用 git tag 看看应该切到那个分支

ActiveSupport::Autoload 中的一点疑惑

ane — Tue, 25 Nov 2014 10:39:12 +0800

刚刚跟踪代码的时候，恰好看到了 ActiveSupport::Autoload 里面的一个奇怪的地方，

github 地址https://github.com/rails/rails/blob/master/activesupport/lib/active_support/dependencies/autoload.rb 37 行

def autoload(const_name, path = @_at_path)
  unless path
    full = [name, @_under_path, const_name.to_s].compact.join("::")
    path = Inflector.underscore(full)
  end

  if @_eager_autoload
    @_autoloads[const_name] = path
  end

  super const_name, path
end

代码里的这行full = [name, @_under_path, const_name.to_s].compact.join("::")中的这个 name 变量是那里来的？找半天也没发现个所以然。

动态定义路由

ane — Mon, 17 Nov 2014 11:50:19 +0800

本着大胆假设，小心求证的路线。

假如有这样的一个需求，就一个静态页面，页面有个表单，理论上的做法就是建 controller,model balbalbal.

但是这样的需求一个接一个出现，而且彼此都是毫无关联的，于是就想做成一个动态的功能，直接将 HTML 页面存起来，表单数据存

mongo 里。

但是，路由似乎还是一个需要程序员去写。若采用程序写入路由的方式，你还得需要重新加载一次 application。

so, 类似这样的需求有什么经验之谈？

最后，楼主采用了 1，2 楼的建议，写了这样的路由

get 'auto/:kind/page' => 'pages#show'

但是为了满足市场的需求（要求 URL 是 xxx.com/market/mic），又不得不暂时加入这样一条路由 get 'market/mic', controller: :pages, action: :show, kind: :mic

controller 中采用 Mongo.find_by_kind(params[:kind]).view的写法。而view中就存储了HTML代片。

但是撸主依然想找一个好方法，去实现这样的需求，

至少将 get 'market/mic', controller: :pages, action: :show, kind: :mic 这样的

路由美化一下也是极好的。若是能提出更好改良方案，那便更是不负恩泽了。

Homebrew 在 Mac 中如何维护

ane — Mon, 03 Nov 2014 15:35:54 +0800

前两天发现 Homebrew 的安装目录，又有许多未提交。

一时不知道怎么处理，求破！

写了段 swift 代码，以为会死循环

ane — Wed, 01 Oct 2014 10:11:28 +0800

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
    willSet {
        square.sideLength = newValue.sideLength
        println("--------")
    }
    didSet {
        println("------++++++")
        Square(sideLength: 50, name: "larger square")
    }
    }
    var square: Square {
    willSet {
        println("++++++++++++")
        triangle.sideLength = newValue.sideLength
    }
    didSet {
        println("+++++----------")
        EquilateralTriangle(sideLength: 150, name: "larger TriangleAndSquare")
    }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.triangle = EquilateralTriangle(sideLength: 150, name: "larger TriangleAndSquare")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength

原以为会死循环，可貌似没有，有清楚机制的吗？

extend main 的作业

ane — Sat, 13 Sep 2014 09:32:49 +0800

先上代码吧

require 'thread_safe'
require 'active_support/core_ext/array/prepend_and_append'
require 'active_support/i18n'

module ActiveSupport
  module Inflector
    extend self

    # A singleton instance of this class is yielded by Inflector.inflections,
    # which can then be used to specify additional inflection rules. If passed
    # an optional locale, rules for other languages can be specified. The
    # default locale is <tt>:en</tt>. Only rules for English are provided.
    #
    #   ActiveSupport::Inflector.inflections(:en) do |inflect|
    #     inflect.plural /^(ox)$/i, '\1\2en'
    #     inflect.singular /^(ox)en/i, '\1'
    #
    #     inflect.irregular 'octopus', 'octopi'
    #
    #     inflect.uncountable 'equipment'
    #   end
    #
    # New rules are added at the top. So in the example above, the irregular
    # rule for octopus will now be the first of the pluralization and
    # singularization rules that is runs. This guarantees that your rules run
    # before any of the rules that may already have been loaded.
    class Inflections
     ....
    end

    # Yields a singleton instance of Inflector::Inflections so you can specify
    # additional inflector rules. If passed an optional locale, rules for other
    # languages can be specified. If not specified, defaults to <tt>:en</tt>.
    # Only rules for English are provided.
    #
    #   ActiveSupport::Inflector.inflections(:en) do |inflect|
    #     inflect.uncountable 'rails'
    #   end
    def inflections(locale = :en)
      if block_given?
        yield Inflections.instance(locale)
      else
        Inflections.instance(locale)
      end
    end
  end
end

这是 rails 的 Inflector.rb 的代码结构，一直疑问这个 self 是什么，ActiveSupport::Inflector.inflections {p self}发现居然是‘main’。不解了，这个为何要继承这个 main?

3 种写法有什么区别

ane — Wed, 03 Sep 2014 23:23:45 +0800

def index
  if current_user
    redirect_to market_path(current_market) and return
  end
end

def index
  if current_user
     return  redirect_to market_path(current_market) 
  end
end

def index
  if current_user
     redirect_to market_path(current_market) 
  end
end