suffering (zhubo)

Rails 项目 Gem 依赖的社交关系网络关系图及其生成

suffering — Wed, 15 Jul 2015 18:26:27 +0800

自己做的小玩具，以及做小玩具的思路:).

WHAT

Rails 4.2.1 初始化项目 gem 依赖关系图：

原图 (上传至 ruby-china.org 的图会被压缩): http://gemrelationship.zhuboliu.me/gem_relationship.png (帖出来后才发现这张图神似欧亚大陆，连澳大利亚都有~)

WHY?

在阅读 Rails 源码时，我脑子里总是冒出这样的念头:"卧操！这是什么鬼!?这方法是哪里来的!? 自定义的!? 来自父类!? 来自 include/extend 的模块!? 来自第三方 gem!? 哪一个？". 如果是项目内引用定义的，倒是很好查找。但是，如果是来自第三方项目，那来自哪些？这样的阅读体验无疑让人很痛苦。

换个思路，用社交关系网络的概念来生成图，让各种依赖关系一目了然。

IDEAS

rails 依赖许多 gem. 现在，rails 的主要模块本身就被拆成了数个独立的 gem. 我们可以理解为 rails 依赖这些 gem. 同时，这些 gem 又依赖于其他的 gem. 拨出萝卜带出泥，不胜期烦。

从社交关系的角度来看问题，我们作如下两点设定：

一个项目是一个社交圈
项目中运行的每一个 gem, 即为圈子内的一个独立的用户。
如果 gemA 依赖于 gemB , 即 gemA 关注了 gemB, 换而言之 gemA 是 gemB 的粉丝。即画一个 gemA 指向 gemB 的有向箭头指向。

最终生成的图，通过看线条与箭头，我们可以清楚地看到哪些 Gem 受欢迎 (大批的粉丝).

有了思路，接下来就要考虑如何实现的问题了。

HOW?

用户 (gem) 列表数据，即图内的节点。
用户 (gem) 关系数据，即节点间的有向线段。
数据可视化方案。即展示方案，或者说绘图方案。错综复杂的关系如何布局与绘图非常重要。

问题 1 和问题 2 很简单，项目内通过bundle install生成的Gemfile.lock提供了所有的节点与关系。

This is important: the Gemfile.lock makes your application a single package of both your own code and the third-party code it ran the last time you know for sure that everything worked. Specifying exact versions of the third-party code you depend on in your Gemfile would not provide the same guarantee, because gems usually declare a range of versions for their dependencies.

问题 3, 通过网络搜索，发现Graphviz(Graph Visualization Software) 可以很好地解决这个问题。

取数据，生成 Graphviz 有效的文件

创建一个 Rails 原生项目，不添加任何其他 Gem.

cd to/your/path
# rails 4.2.1
rails new rgraph
cd graph
bundle install
touch graph.rb
# edit graph.rb

分析Gemfile.lock文件，生成gem_relationshop.gv文件。

# rails/app/root/path/graph.rb
src_box = []
File.open('gem_relationship.gv', 'w') do |t|
  t.puts "digraph G {"
  File.open("Gemfile.lock").each do |n|
    # 通过缩进来判断指向关系.
    n =~ /^( {2,})([a-zA-Z0-9_-]+)/
    if $1 and $1.length == 4
      @src = $2
      src_box << @src
    elsif $1 and $1.length == 6
      @target = $2
      puts @src
      t.puts "  \"#{@src}\" -> \"#{@target}\""
    else
    end
  end
  t.puts "}"
end

运行 script 生成源文件：

ruby graph.rb

运行 graphviz 相关命令生成图：

# 系统内必须装好 Graphviz.
dot -Tpng -o ./gem_relationship.png ./gem_relationship.gv
# open gem_relationship.png

Done!

再来一个 web 版的吧。

google 的结果是arborjs勉强可以干这事儿，而且arborjs语法类似Graphviz的语法. 使用源码中的 demo，复制一份 json 文件，将生成的.gv的主内容帖进，hack 一下，测试，发布：

在线演示地址：http://gemrelationship.zhuboliu.me 在线站点支持节点拖曳。支持在线编辑，可以考虑直接在项目要目录下生成的文件帖到右边的框内，实时生成关系图。

如果你需要使用此演示站的功能生成自己的 ruby 项目，请确保项目使用bundler且Gemfile.lock存在。

站点实时生成关系图的数据的代码略有不同，如下：

css_box = %W{NAVY BLUE AQUA TEAL OLIVE GREEN LIME ORANGE RED MAROON FUCHSIA PURPLE BLACK GRAY SILVER}
src_box = []
File.open('gem_relationship.gv', 'w') do |t|
  # t.puts "digraph G {"
  File.open("Gemfile.lock").each do |n|
    # 通过缩进来判断指向关系.
    n =~ /^( {2,})([a-zA-Z0-9_-]+)/
    if $1 and $1.length == 4
      @src = $2
      src_box << @src
    elsif $1 and $1.length == 6
      @target = $2
      puts @src
      # t.puts "  \"#{@src}\" -> \"#{@target}\""
      t.puts "#{@src} -> #{@target}"
    else
    end
  end
  # t.puts "}"
  # 随机生成色彩.
  src_box.each do |s|
    t.puts "#{s} {color:#{css_box.shuffle.first}}"
  end
end

注意：不要帖入大型项目的关系数据，节点太多，结果会很难看。

看图说话

railtie, activesupport, activepack, rack是真正的大 V, 粉丝无数，若要阅读 Rails 源码，从了解它们开始吧。

附上一张个人的小项目 (引入第三方 gem 若干) 的图: 原图地址：http://gemrelationship.zhuboliu.me/color.png

后续开发意见征集

有必要做成一个 gem 吗？添加 command line, 在 ruby 项目下运行即直接生成相应关系图。
或者，做成 engine, 在开发模式下，随时可能通过链接进入到一个页面看到指向关系图？类似http://localhost:3000/rails/info的功能。
在前两者的基础上做些 option 定制，可以手动选定中心结点？或者为结点加上链接，可直接点到相应 gem 的官方文档页去？
其他

请有好的意见 @suffering, 谢谢。

参考资料

http://bundler.io/v1.7/rationale.html#checking-your-code-into-version-control http://www.graphviz.org/ http://arborjs.org/ http://arborjs.org/docs/barnes-hut http://getspringy.com/

why no windows

suffering — Thu, 18 Jun 2015 16:21:34 +0800

初步深入 Rack (一)

suffering — Sun, 08 Feb 2015 21:26:17 +0800

前段时间写了篇文章<为什么我们需要 Rack?>, 再过段时间，对 rack 一直都是一个知其然，不知道其所以然的状态。最近从源码读起，这里与大家分享一下. 注意：本帖前半段极其无聊，请大家注意。

Rack 项目的知其然

首先，创建config.ru. 这里直接引用前文的例子。

#config.ru
# 将 body 标签的内容转换为全大写.
class ToUpper
  def initialize(app)
    @app = app
  end
  def call(env)
    status, head, body = @app.call(env)
    upcased_body = body.map{|chunk| chunk.upcase }
    [status, head, upcased_body]
  end
end
# 将 body 内容置于标签, 设置字体颜色为红色, 并指明返回的内容为 text/html.
class WrapWithRedP
  def initialize(app)
    @app = app
  end
  def call(env)
    status, head, body = @app.call(env)
    red_body = body.map{|chunk| "<p style='color:red;'>#{chunk}</p>" }
    head['Content-type'] = 'text/html'
    [status, head, red_body]
  end
end

# 将 body 内容放置到 HTML 文档中.
class WrapWithHtml
  def initialize(app)
    @app = app
  end

  def call(env)
    status, head, body = @app.call(env)
    wrap_html = <<-EOF
       <!DOCTYPE html>
       <html>
         <head>
         <title>hello</title>
         <body>
         #{body[0]}
         </body>
       </html>
    EOF
    [status, head, [wrap_html]]
  end
end

# 起始点, 只返回一行字符的 rack app.
class Hello
  def initialize
    super
  end
  def call(env)
    [200, {'Content-Type' => 'text/plain'}, ["hello, this is a test."]]
  end
end
use WrapWithHtml
use WrapWithRedP
use ToUpper
run Hello.new

在 termial 中输入rackup, 而后，一个 web 服务就运行了. 关于这段例子，前文的解释是：

use 与 run 本质上没有太大的差别，只是 run 是最先调用的。 ~~它们生成一个 statck~~(谢谢 @est 指出错误) 本质上是先调用 Hello.new#call, 而后返回 ternary-array, 而后再将之交给另一个 ToUpper, ToUpper 干完自己的活，再交给 WrapWithRedP, 如此一直到 stack 调用完成. use ToUpper; run Hello.new 本质上是完成如下调用: ToUpper.new(Hello.new.call(env)).call(env)

提出问题

看到这里，个人有许多疑问：

rackup命令来自于哪里？
rackup命令如何找到config.ru这个文件的，又是如何加载它运行它的，或者说它是如何加载代码创建服务的？
use 后面跟着的是 middleware 这个知道，但是，它是如何生成加载的 stack 的？
run?
所有的 middleware 只要其实例响应call方法就可以了，它们如何工作？
yyyy?

rackup 命令来自于哪里？如何加载 config.ru 并生成项目的？

那么，从源码一行一行看过去吧，首先是rackup, 放在rack项目的bin文件夹下，只有几行：

#!/usr/bin/env ruby

require "rack"
Rack::Server.start

好吧，个人表示不理解，于是跳到 lib\server.rb

# lib\server.rb
def self.start(options = nil)
  new(options).start
end

-_-!

# lib\server.rb
def initialize(options = nil)
  @options = options
  @app = options[:app] if options && options[:app]
end

-_-! 好吧，Rack::Server.start 时一个参数也没有。因此 new => initialize 时也一个参数也没有。也即是说最后从类方法start又跳回了实例方法start上：

# lib\server.rb
# 这该死的start实例方法相当之长, 这里只引用关键点:
def start &blk
# ...
server.run wrapped_app, options, &blk
# ...
end

好吧，server 来自于方法，wrapped_app 也是个方法：

# lib\server.rb
def server
  @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
end
def wrapped_app
  @wrapped_app ||= build_app app
end
def build_app(app)
  middleware[options[:environment]].reverse_each do |middleware|
    middleware = middleware.call(self) if middleware.respond_to?(:call)
    next unless middleware
    klass, *args = middleware
    app = klass.new(app, *args)
  end
  app
end
def app
  @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
end

这方法间引来引去的，实在让人抓狂，这里直接给出关键点吧。以下内容也不帖出这该死的方法链了，只帖关键点。这样写下去不如直接帖源码自己看不是吗？(我承认我只是表达一下我抓狂的心情) 关键点在于：server 方法的后半段Rack::Handler.default(options) 以及 wrapped_app方法. 这里不卖关子，前者直接决定了调用哪个服务器来运行项目，是thin还是mongrel, WEBrick之类的. wrapped_app与app两个方法则决定了会加载config.ru的内容作为运行项目. options[:builder] ? build_app_from_string : build_app_and_options_from_config 这一行可知，因为 option 根本没指定，所以会调用 build_app_from_string.

# lib\server.rb
def build_app_from_string
  Rack::Builder.new_from_string(self.options[:builder])
end

于是我们华丽地滚到了lib\builder.rb文件：

# lib\builder.rb
def self.new_from_string(builder_script, file="(rackup)")
  eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
    TOPLEVEL_BINDING, file, 0
end

好吧，历经千动百难我们终于找到了正主。这个builder_script就是config.ru文件的内容了。eval方法在TOPLEVEL_BINDING环境下，也即我们运行rackup命令的环境下运行代码. ....但是，妈蛋，这builder_script来自于哪里？self.options[:builder]作为参数传进来的，但是泥煤的这个 options 不是一直都是空的吗!!? 好吧，这个不是options, 这个是options类方法。属于Rack::Server类. 经研究，顺序是这样的：options 方法里引用parse_options(ARGV)也即是分析用户输入内容，但是明显我们没有输入任何内容。parse_options方法开篇第一句：options = default_options, 而后在后面的代码分析 ARGV, 死命地覆盖它。 default_options 是这个方法，里面的一行指定了，options[:config], 是config.ru文件。

# lib\server.rb
def options
  @options ||= parse_options(ARGV)
end
def parse_options(args)
  options = default_options

  # Don't evaluate CGI ISINDEX parameters.
  # http://www.meb.uni-bonn.de/docs/cgi/cl.html
  args.clear if ENV.include?(REQUEST_METHOD)

  options.merge! opt_parser.parse!(args)
  options[:config] = ::File.expand_path(options[:config])
  ENV["RACK_ENV"] = options[:environment]
  options
end

def default_options
  environment  = ENV['RACK_ENV'] || 'development'
  default_host = environment == 'development' ? 'localhost' : '0.0.0.0'

  {
    :environment => environment,
    :pid         => nil,
    :Port        => 9292,
    :Host        => default_host,
    :AccessLog   => [],
    :config      => "config.ru"
  }
end

Rack 如何创建服务并生成 stack 的？

思维回溯，config.ru终于传入eval之中了，我们的项目找到根脚了，个人不禁泪流满面。而 Rack::Builder.initialize最后会将其传入的 block 通过instance_eval方法运行其实例变量环境之中。也即是config.ru的所有文本内容，在Rack::Builder实例化后，在其环境下调用了。~~于是 use 生成 stack~~, 于是 use 方法将 middlewares 加入到@use array 中去，run 方法将其参数设置为起始项目并存入@app, 而后再通过 to_app 将之转化为 stack 待用，最后用户发起请求，server 调用 call 方法，并传入 env. env 在主项目@app, 和 @use 中的 middlewares 中薪火相传，每经手一次，就可能被做些修改，最后，返回值 .

再回到builder.rb文件，也即eval所在的内容：

def self.new_from_string(builder_script, file="(rackup)")
  eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
    TOPLEVEL_BINDING, file, 0
end

好吧，我们知道它调用了类Rack::Builder类的initialize方法。

def initialize(default_app = nil,&block)
  # middlewares 默认为空[]; @map默认不存在. @run 默认等于创建时的项目, @warmup默认不存在.
  @use, @map, @run, @warmup = [], nil, default_app, nil
  # 在Builder实例中运行block, 也即是在builder运行环境中再执行block中的代码.
  instance_eval(&block) if block_given?
end

太过细节的东西不要再讲了，我们再简化一下吧：Rack::Builder 类是核心所在。它包含了生成 middlewares stack 的核心代码，决定了 middlewares 的调用顺序。也决定了它们如何被调用。它提供的use, map, run, to_app等方法，决定了一切：

def use(middleware, *args, &block)
  if @map
    mapping, @map = @map, nil
    @use << proc { |app| generate_map app, mapping }
  end
  @use << proc { |app| middleware.new(app, *args, &block) }
  @use
end
def run(app)
  @run = app
end
def map(path, &block)
  @map ||= {}
  @map[path] = block
end

def to_app
  app = @map ? generate_map(@run, @map) : @run
  fail "missing run or map statement" unless app
  app = @use.reverse.inject(app) { |a,e| e[a] }
  @warmup.call(app) if @warmup
  app
end

def call(env)
  to_app.call(env)
end

use方法将 middleware 放到一个 proc 之中，再将此 proc 放到@use这个 array 之中。
run方法将起始项目放到@app实例变量之中。
map方法用于生成简单的 rack 项目内路由。暂时不放入讨论之中。
to_app方法生成 stack, 并等待最后从 server 处传传进来。用户打开浏览器地址，server(如 thin) 就会调用这个 call 方法，并传入 env 作为其值。问题的关键点在于to_app方法最后返回的那个app, 它本质上已经将项目以及 middlewares 全部串在了一起，并且保证一次调用 call, 就会按规则走完 middlewares 全流程。

_ (是否对前面那么啰嗦，后面语言简洁的转折表示不适应？)

抽象问题，模拟过程

这里不再去解释源码的调用链了，我们来写一段小程序来模拟这个创建 stack，并调用它们的全过程：

# t5.rb
@use = []
class Mdw
  def initialize(app)
    @app = app
  end

  def call(env)
    puts env = "mdw1:" + env
    @app.call(env)
  end
end

class Mdw2
  def initialize(app)
    @app = app
  end

  def call(env)
    puts env = "mdw2:" + env
    @app.call(env)
  end
end

startApp = proc {|app| puts tmp = 'startApp:' + app }

def use(md)
  @use << proc {|app| md.new(app) }
end

def call(s)
  @use.reverse.inject(@app){|a, w| w[a] }.call(s)
end

def run(a)
  @app = a
end

use Mdw
use Mdw2
run startApp

call('env')

运行ruby t5.rb, 可以得到如下内容：

mdw1:env
mdw2:mdw1:env
startApp:mdw2:mdw1:env

startApp与middlewares中用的puts方法输出了值的全变化过程. 这里没有模拟rack返回[statusCode, Headers, Body]模式的部分。只模拟了链式调用的生成，以及调用的过程。

模拟推衍过程

下面附上示例代码t5.rb运行过程的推衍过程: 注意：以下内容极其无聊，请精神正常的人不要较真：

最后数行代码的推衍过程
# 前面定义middleware类的过程请无视.
# step 1, `use Mdw;useMdw2;run startApp`
@app = proc {|app| puts tmp = 'startApp:' + app }
@use = [proc {|app| Mdw.new(t) }, proc {|app| Mdw2.new(t) }]
# step 2: `@use.reverse.inject(@a){|a, w| w[a] }`
# step 2.1, 第一轮
a = proc {|app| puts tmp = 'startApp:' + app }
e = proc {|app| Mdw2.new(t)
# step 2.2, 第二轮
a = proc {|app| Mdw2.new(t)[proc {|app| puts tmp = 'startApp:' + app }]
# 实际值: a = Md2.new(proc {|app| puts tmp = 'startApp:' + app })
e = proc {|app| Mdw.new(t) }
# step 2.3, 第三轮
a = proc {|app| Mdw.new(t) }[proc {|app| Mdw2.new(t)[proc {|app| puts tmp = 'startApp:' + app }]]
# 实际值: a = proc {|app| Mdw.new(t) }[Mdw2.new(proc {|app| puts tmp = 'startApp:' + app })]
# 实际值: a = Mdw.new(Mdw2.new(proc {|app| puts tmp = 'startApp:' + app }))
# step 3, @use.reverse.inject(@a){|a, w| w[a] }.call('s')
# step 3.1
Mdw.new(Md2.new(proc {|app| puts tmp = 'startApp:' + app })).call('s')
# step 3.2
Mdw2.new(proc {|app| puts tmp = 'startApp:' + app }).call('Mdw1:' + 's')
# step 3.3
proc {|app| puts tmp = 'startApp:' + app }.call('Mdw2:'+'Mdw1:' + 's')
'startApp:' + 'Mdw2:'+'Mdw1:' + 's'
# 如果想实现链式调用, 一个作为另一个的参数, 形成套娃机制. 需要彼此为参数的设定.

看代码，何其苦！虽说真正的猛士敢于面对惨淡的人生，敢于正视淋漓的鲜血，但是且容我们叫一声苦。

Rails 3 组织分割 routes

suffering — Fri, 28 Nov 2014 23:53:37 +0800

项目中 routes 太多太乱时，仅仅备注的话是很乱的，因此可以考虑将之分组之分割到不同的文件里。

解决的思路如下：

在 config 下新建 routes 文件夹
将 routes.rb 拆分放到不同的文件夹内
更改 application.rb 的 load path

场景

#config/routes.rb
YourApppic::Application.routes.draw do
  resources :products
  resources :categories
  namespace :admin do
    resources :products
  end
  get 'welcome/index'
end

创建并拆分文件

cd path/to/your_app/config
mkdir routes
touch admin_routes.rb
touch data_routes.rb
touch none_restful_routes.rb

而后变成：

#config/admin_routes.rb
YourApppic::Application.routes.draw do
  namespace :admin do
    resources :products
  end
end

#config/routes/data_routes.rb
YourApppic::Application.routes.draw do
  resources :products
  resources :categories
end

#config/routes/none_restful_routes.rb
YourApppic::Application.routes.draw do
  get 'welcome/index'
end

修改 application.rb

config.paths["config/routes"] += Dir[Rails.root.join("config/routes/*.rb")]`

重启项目，一切 ok .

考虑 routes override

如果你的 routes 非常依赖顺序。就不要使用 config.paths["config/routes"] += Dir[Rails.root.join("config/routes/*.rb")] 可以考虑指定顺序加载分割后的文件：

# 逐个加载
config.paths.config.routes << File.join(Rails.root, "config/routes/none_restful_routes.rb")
config.paths.config.routes << File.join(Rails.root, "config/routes/admin_routes.rb")
config.paths.config.routes << File.join(Rails.root, "config/routes/data_routes.rb")

# alphabetical 排序加载
config.paths["config/routes"] += Dir[Rails.root.join("config/routes/*.rb")].sort
# 这个需要重命名下文件, 如 0_none_restful_routes.rb, 1_admin_routes.rb, 2_data_routes.rb 这种做法.

参考

http://rails-bestpractices.com/posts/73-split-route-namespaces-into-different-files

http://stackoverflow.com/questions/7303660/splitting-routes-file-into-multiple-files

此版太冷, 发图求暖

suffering — Fri, 17 Oct 2014 14:52:38 +0800

关于 axlsx 导出 excel 的问题

suffering — Tue, 14 Oct 2014 21:08:27 +0800

最近项目上需要导出 excel 并快速打印单据. 工作环境：windows xp + google chrome + EPSON-LQ-630K 具体的工作流程如下：

click to export excel (.xlsx)
open the exported excel
click to print 这个流程倒是很简单。直接使用axlsx, 简单好用很快就搞定了。但是在打印时问题出现了: 导出的 excel 的打印尺寸应该是8.5in * 5.5in. 这不是微软默认的打印尺寸，也不是 epson 默认的打印尺寸。所以只能定义一个打印尺寸. 具体参见：http://msdn.microsoft.com/en-us/library/windows/desktop/dd319099v=vs.85).aspx( axlsx提供了丰富的方法来设置pager size, 也提供了自定义尺寸的 options, 但是，实际使用中却怎么也调试不好。

这里的 axlsx 相应的源码：https://github.com/randym/axlsx/blob/master/lib/axlsx/workbook/worksheet/page_setup.rb 读完后发现usePrinterDefaults放在 todo 里。也即是说，即使设置打印机的默认打印纸，也是不行。导出的 excel 默认为设置成Letter格式. ...

果然程序员最痛恨的还是 windows...

大家有没有好的意见？hack axlsx 的方案或直接换个 gem? 已经试过writeexcel,这个更坑。

悲剧地无人理会...

为什么我们需要 Rack ?

suffering — Sat, 13 Sep 2014 15:21:14 +0800

一切从 Rack 开始

Rails 就是一个 Rack app. 实际上，基本上所有的 Ruby web framework 都是rack app.

官网中列出的使用 Rack 的 web 框架：

Camping
Coset
Espresso
Halcyon
Mack
Maveric
Merb
Racktools::SimpleApplication
Ramaze
Ruby on Rails
Rum
Sinatra
Sin
Vintage
Waves
Wee

基本上，Ruby 世界的 web, rack 已经一统天下了。有兴趣的童鞋可以看看ruby-toolbox的web-app-framework, 看看有哪些没有用到 rack 的：https://www.ruby-toolbox.com/categories/web_app_frameworks

简介

Rack provides a minimal, modular and adaptable interface for developing web applications in Ruby. By wrapping HTTP requests and responses in the simplest way possible, it unifies and distills the API for web servers, web frameworks, and software in between(the so-called middleware) into a single method call.

简单点说，rack 是 Ruby web 应用的简单的模块化的接口。它封装 HTTP 请求与响应，并提供大量的实用工具。它需要一个响应 call 方法的对象，接受 env. 返回三元素的数组：分别是 status code, header, body. 其中 status code 大于等于 100, 小于 600. header 是一个 hash, body 是一个响应 each 方法的数组。

理解上述接口标准，就可以写一个完整的 rack app 了。除了这些，rack 还提供了许多有工具。

gem install rack
gem install pry
pry
require 'rack'
cd Rack
ls

上述得到如下内容：

constants:
  Auth       CommonLogger    Deflater        Handler  MethodOverride  NullLogger  Runtime         ShowStatus
  BodyProxy  ConditionalGet  Directory       Head     Mime            Recursive   Sendfile        Static
  Builder    Config          ETag            Lint     MockRequest     Reloader    Server          URLMap
  Cascade    ContentLength   File            Lock     MockResponse    Request     Session         Utils
  Chunked    ContentType     ForwardRequest  Logger   Multipart       Response    ShowExceptions  VERSION
Rack.methods: release  version

以上内容，除少部分是 Rack 自身运行的依赖外，大部分都是 Rack 提供的可选模块，它们封装了许多简单实用的方法，比如说处理静态文件，缓存，log, 非法内容 sanitize . 使用它们，Ruby web 开发才不会那么痛苦. 另外，还有许多 Rack middleware. 这里有详细列表: https://github.com/rack/rack/wiki/List-of-Middleware

为什么需要 Rack

这里不防用反证法，带大家看看若是没有 Rack, 我们应该如何开发一个 Ruby web app.

如果从零开始了解 web 世界。我们知道，浏览器与服务端通过 HTTP 协议交互。这是一个 request 与 response 的过程。

request 从客户端发出，包含了字符串的头文件，它包括请求的地址，请求方式 (get/post/put/delete 等). 浏览器发送的是格式化的字符串，作为服务端，我们需要分析这段字符串，如果没有 Rack, 我们得自己程序来分析这个 orgin string header.

同样的，按照 http 协议，Response 也是类似的字符串。浏览器接收到它们后，分析并 render, 最终生成页面。没有 rack, 这字符串也得自己来生成。

这里看一个例子，非常有意思的博文。博主去面试，让他写一个简单的 Ruby web server, 要求如下：

Web server returns “Hello World”.
Web server returns the list of files in the base directory.
Web server allows to navigate the directory structure.
If a user click on a file the browser should display it.

总计 4 条要求，其中第一二条实现了，后面两条却失败了 .事后好好研究了下这个，并写出了博客。这个是第三条的实现，就是自己手动输出 response string :

require "socket"
webserver = TCPServer.new('localhost', 2000)
base_dir = Dir.new(".")
while(session = webserver.accept)
  session.print "HTTP/1.1 200/OK\r\nContent-type:text/html\r\n\r\n"

  request = session.gets
  trimmedrequest = request.gsub(/GET\ \//, '').gsub(/\ HTTP.*/, '')
  if trimmedrequest.chomp != ""
    base_dir = Dir.new("./#{trimmedrequest}".chomp)
  end
  session.print "
#{trimmedrequest}

"

  session.print("#{base_dir}")
  if Dir.exists? base_dir
     base_dir.entries.each do |f|
       if File.directory? f
         session.print("<a href="#{f}"> #{f}</a>")
       else
        session.print("
#{f}

")
       end
     end
  else
    session.print("Directory does not exists!")
  end
  session.close
end

原文地址：A Simple Web Server in Ruby

就像terminal端的 Ruby code 运行时通过 gets 方法来获取用户的输入一样，真是简陋得可以。仔细看一下博主的实现，就是将request当字符串处理 (其实 request 本来就是格式化的字符串), 通过正则来获取其REQUEST_METHOD, PATH_INFO等等，将Content-Type设置为text/html, 最后将信息打包，作为response发送给客户端. 至于第四条，则需要手动去设置mimi-type,这样才能以完整的方式将图片等内容在 web 页面中正常展现。

看看 http request header fields: http://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Request_fields 数十条，各有其含义。从头至尾写一个 web server, 你得分析它们，作不同的响应。

再看看 http response fields: http://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Response_fields 同样数十条，浏览器会根据你返回的 header 来决定如何 render page. 如果手动去生成，那是头皮发麻的工作量。

但是，使用 Rack, 以及它提供的工具的话，实现博主接受的考题要求，我们可以这样做，只需要两行代码：

require 'rack'
Rack::Handler::Thin.run Rack::Directory.new('./'), :Port => 9292

当然，是否允许这样做就不得而知了。

数行代码的`rack app`

gem install rack
cd to/your/path
touch app.rb

app.rb内容如下;

#app.rb
require 'rack'
class HelloWorld
  def call(env)
    [200, {"Content-Type" => "text/html"}, ["Hello Rack!"]]
  end
end
Rack::Handler::Mongrel.run HelloWorld.new, :Port => 9292

在 terminal 里运行ruby app.rb, 而后在浏览器里打开http://localhost:9292就可以看到返回的内容了。

使用 middleware stack 的 rack app

#config.ru

# 将 body 标签的内容转换为全大写.
class ToUpper
  def initialize(app)
    @app = app
  end
  def call(env)
    status, head, body = @app.call(env)
    upcased_body = body.map{|chunk| chunk.upcase }
    [status, head, upcased_body]
  end
end
# 将 body 内容置于标签, 设置字体颜色为红色, 并指明返回的内容为 text/html.
class WrapWithRedP
  def initialize(app)
    @app = app
  end
  def call(env)
    status, head, body = @app.call(env)
    red_body = body.map{|chunk| "<p style='color:red;'>#{chunk}</p>" }
    head['Content-type'] = 'text/html'
    [status, head, red_body]
  end
end

# 将 body 内容放置到 HTML 文档中.
class WrapWithHtml
  def initialize(app)
    @app = app
  end

  def call(env)
    status, head, body = @app.call(env)
    wrap_html = <<-EOF
       <!DOCTYPE html>
       <html>
         <head>
         <title>hello</title>
         <body>
         #{body[0]}
         </body>
       </html>
    EOF
    [status, head, [wrap_html]]
  end
end

# 起始点, 只返回一行字符的 rack app.
class Hello
  def initialize
    super
  end
  def call(env)
    [200, {'Content-Type' => 'text/plain'}, ["hello, this is a test."]]
  end
end
use WrapWithHtml
use WrapWithRedP
use ToUpper
run Hello.new

直接运行rackup就可以运行上述 app.

use 与 run 本质上没有太大的差别，只是 run 是最先调用的。它们生成一个 statck, 本质上是先调用 Hello.new#call, 而后返回 ternary-array, 而后再将之交给另一个 ToUpper, ToUpper 干完自己的活，再交给 WrapWithRedP, 如此一直到 stack 调用完成。

use ToUpper; run Hello.new本质上是完成如下调用：

ToUpper.new(Hello.new.call(env)).call(env)

以上只是简单的举例，实际的 web 项目中，有无数的场景需求。比如说，你可以随时需要更改 status code, 或者，你需要判断当前请求是什么类型的，比如说是 get 还是 post, 在 rails 中 resource 生成的同样的 path，如 /products/:id可以是get/put/delete. 但是 Rails 如何知道调用show/update/destroy中的哪一个？这时，这个时候可以去看看 env['REQUEST_METHOD'], 而后判断。这们做虽然不用去分析原始的 head 文件，但是也是愚蠢的行为，这个时候就可以直接用 rack 提供的一些工具了。

require 'rack'
class Hello
    def get_request
       @request ||= Rack::Request.new(@env)
    end

    def response(text, status=200, head={})
      raise "respond" if @respond
      text = [text].flatten
      @response = Rack::Response.new(text, status, head)
    end

    def get_response
      @response || response([])
    end

    %W{get? put? post? delete? patch? trace?}.each do |md|
        define_method md do
            get_request.send(md.intern)
        end
    end
    %W{body headers length= status=  body= header length 
       redirect status content_length content_type}.each do |md|
        define_method md do |*arg|
            get_response.send(md.intern, *arg)
        end
   end

    def call(env)
      @env = env
      content_type   = 'text/plain'
      if get?
        body= ['you send a get request']
      else
        status= 403
        body= ['we do not support request method except get, please try another.']
      end
      [status, headers, body]
    end
end
Rack::Handler::Thin.run Hello.new, :Port => 9292

若想测试非 get 方法，可以通过curl -X POST http://localhost:9292/来测试. 以上示例是对 Rack::Request, Rack::Response 的非常愚蠢的封装，只是展示下使用它们的便捷之处。想看高质的封装代码，不仿看看 sinatra 的: https://github.com/bmizerany/sinatra/blob/work/lib/sinatra/base.rb#L15

Rails On Rack

Rails 中使用的 rack middleware stack:

cd to/your/rails/project/path
rake middleware

得到的内容如下：

use Rack::Sendfile
use ActionDispatch::Static
use Rack::Lock
use #<ActiveSupport::Cache::Strategy::LocalCache::Middleware:0x000000029a0838>
use Rack::Runtime
use Rack::MethodOverride
use ActionDispatch::RequestId
use Rails::Rack::Logger
use ActionDispatch::ShowExceptions
use ActionDispatch::DebugExceptions
use ActionDispatch::RemoteIp
use ActionDispatch::Reloader
use ActionDispatch::Callbacks
use ActiveRecord::Migration::CheckPending
use ActiveRecord::ConnectionAdapters::ConnectionManagement
use ActiveRecord::QueryCache
use ActionDispatch::Cookies
use ActionDispatch::Session::CookieStore
use ActionDispatch::Flash
use ActionDispatch::ParamsParser
use Rack::Head
use Rack::ConditionalGet
use Rack::ETag
run Rails.application.routes

可以看出，Rails 重度依赖 Rack. 理解 Rails, 不防从 Rack 开始。按上述列表，先从Rails.application.routes开始一直走到最后一步. 关于在 Rails 如何使用 rack, 具体请参照 http://guides.rubyonrails.org/rails_on_rack.html 另外这里有xdite一篇博文，讲的是 Rails 如何支持 Rack, 又为什么要支持 Rack, 非常清晰明了。详细可以看看这里：http://wp.xdite.net/?p=1557

结论

从头开始写一个 Rails-like web 框架

suffering — Fri, 12 Sep 2014 21:21:52 +0800

最近阅读Rebuilding Rails时对自建ruby web framework有了兴趣，就模仿 rails 的功能写了个。

目的不是再造个轮子，我也没有这个能力，主要是想在自己写框架的过程中理解 rails 的基本工作原理，提升一下自己的水平。这只是一个演示项目，没有半点的实际使用价值，唯一的作用就是便于阅读，在阅读的过程中可以了解一些 RAILS 的基本原理。

项目地址：https://github.com/suffering/learnmvc

贴上部分 README:

目标

这个项目的目的不是重写一个Ruby web framework, 而是在自己开发一个Rails-like framework时，试着去理解一个ruby mvc style web framework的一些基本原理。

为什么需要

Rails的源码就是头恐怖的怪兽，无数的童鞋倒前仆后继地打开源码，而后倒下。

Rails看起来就像魔法，运行rails s, 而后一切就开始运行了。这些行为都是从哪里开始的？客户端的请求到达后它如何接收？如何处理？为什么在 controller 里可以调用 Model 里定义的模型？为什么 controller 里的实例变量可以在 view 中运用？Rails 是如何将 erb 文件渲染而后生成内容的？它如何与 layout 协作并返回？如此种种。

对于新手来说，这个就是魔法，虽然很疑惑，却是没有时间也没有能力去寻找这些答案。同时，新手也不需要去理解这些因为哪怕不理解，只要懂得 rails 的规则，把相应的东西写在相应的地方 (MVC), rails 就会将它们组合在一起，生成内容并打包发送。事实上，很多人即使不了解这些，只要对 rails 足够了解，经验充足，也可以写出很好的项目来。

但是这样是不够的，只有更多地理解 rails 的内部原理，才能更好地使用它，写出灵活高效的代码。

已经实现的功能

以 rails MVC 的方式组织代码，以 rails 的规则命名 controller, view, model 等之后，相互之间可以协作。
自定义 route, 使用match, resources, get, post, put, delete等方法自定义路由。如 match '/products/:id' => 'products#show'.
自定义 database.yml, 使用activerecord作为ROM
实现 layout yield, content_for, yield, render, redirect_to 等等
实现静态文件 serve.

注：已实现的只是 rails 的九牛一毛。展示的只是基本的调用链。及 MVC 基本的结合方式。许多功能诸如 session, cache, secure, test, configable 等都没有实现。

基本逻辑

一切从 Rack 开始。几乎所有的 ruby web framework 都是 rack app. Rack 对象响应 call 方法，返回三元素的 array, 分别是 status code, header, content body. 只要你的项目符合以上三个要求，就是一个合法的 rack app. 可以运行它，在浏览器访问，看到完整的响应内容。所以，主流程即是 request 与 response 的地程。我们所做的事情就是在中间加入一些自己的东西。
http request 到达 web server 后会即被 rack 封装，而后你得到一个 env 对象。它包含了客户的请求类型 (get/post/put/delete/..), 请求的地址 (env['PATH_INFO'], QUERY_STRING 等等.
1. 通过分析 env, 我们知道客户的请求是指向哪个 controller#action. 而后查看路由表我们的 app 能否响应此请求。
2. 路由表在新建 app 对象时通过 routes 方法来定义，具体的做法是接受一个 block, block 内调用match, get, post等方法时，生成路由规则加入路由表。路由表里包含路径字符串的匹配正则，controller, action, params 等等。
3. 参照上一条，在路由规则中检查 env['PATH\_INFO'], 若匹配，就知道了指向哪个 controller 的哪个 action, 以及其 params. 通过 ctrl_const = Object.const_get(params[:controller].capitalize)来得到相应的 controller.
4. 通过 ctrl_const.new(env).call(params[:action]) 可以调用到相应的方法。
5. 到这一步，已经初步描述了一个请求从客户端到服务器端并指向需要的controller#action的基本过程。也即处理 request 的过程完成。
Response 的过程:
1. 在 ctrl_const.new 上调用 action 后新的对象内就会拥有相应的实例变量。这时通过Tiltgem, 按规则生成目标 view 的名字，找到它，而后 render, render 时将 self 作为 scope 传入。至此 view 里可以调用 action 里所有的实例变量。Tilt.new(view).render self 得到了应该返回的 html 的内容。
2. 上一步render得到的只是Controller#action对应的view, 需要将它交给 layout 处理。同样的使用Tilt, 将上一步得到的 partial view 放到 block 中提交过去。这样 layout 中的<%= yield %>关键字生效。至此，得到完整的 html 内容。
3. Rack 要求调用 call 后的返回的值是一个三值的 array, 分别是 [status code, head content, body].上一步得到的是 html 内容就是 body 部分。

如何使用和阅读本项目的源码

git clone https://github.com/suffering/learnmvc.git
cd learnmvc
#在编辑器中打开
cd srbmvc
bundle install
cd ../simpleapp
bundle install
rackup -p 3002
#通过rackup方式打开后, 代码在更改后不会自动重载, 可以考虑使用rerun
# gem install rerun
# rerun 'rackup -p 3002'
#以这种方式运行, 对任何文件的修改都会重载代码. 简单模拟rails的development mode.

Demo app 运行后，可以看到项目正常运行。

查看simpleapp的源码，你会看到它的基本结构与 rails app 基本相同。

查阅srbmvc的源码，按前文的基本逻辑栏来查看代码，观看其调用链。代码中有少量的注释，没有解释具体的细节，只简单标注出此方法实现的目的与功能。此部分代码的关键点在于从 request 开始后的调用链，route 规则的指定与检查，controller#action的定位以及 render view 部分。其他皆渣。

请将simpleapp与srbmvc结合来阅读。

最好的学习方式是，看完后，自己写一个。在写的过程中，会发现很多以前注意不到的细节。在实现 rails 的各种功能的过程中，你必须对 mvc 的协作方式进行深入思考。人在思考的过程中成长。

感谢@wikimo同学帮忙纠正错误~

Jsquirks: 列出那些变态的 JS 类型转换

suffering — Fri, 08 Aug 2014 01:46:25 +0800

最近从基础开始学习 JS, 被其中的动态类型转换弄得受不了了，于是写了Jsquirks (好吧，我承认是我在参加 Elance 的 JS Skill Test 时被里面的题玩了，于是我才决定重基础开始研究 JS 的.) 研究 JS 的动态类型转换时，总是试图去找其中的模式，结果往往自以为发现了一个能用规则，结果一眨眼就会蹦出个反例。于是就写了段代码用穷举的方式列出各种变态的特殊值与各种值的可能组合，同时列出其值. 后来干脆做成了网页版的，可自由选择用于组合的operand与operator. github 发布，而后上线。与大家分享。对 JS 有兴趣的同学可以去逛逛。各种希奇古怪的计算结果啊，我表示再也不会试图去总结什么固定模式了。

好吧，贴上才写的README.md:

Javascript Quirks with special values and Operations

Demo online: http://jsquirks.zhuboliu.me

Do What

The App combinate the special values and values you selected to simple expressions, run it with the function eval, and display the list of outputs in a table and logged it in the console. By using this, you can find some weired pattern in javascript value type converting.

Special Values

var special_values       = [NaN, null, undefined, 0, 1, 2, true, false, Infinity, -Infinity, " ", "a"];

Operators

var arithmatic_operators = ["+", "-", "*", "/", '%'];
var comparison_operators = [">", ">=", "<", "<="];
var logical_operators    = ["&&", "||"];
var equality_operators   = ["==", "!=", "===", "!=="];
var bitwise_operators    = ["<<", "<<<", ">>", ">>>"];
var unary_operators      = ['typeof', 'void', '+', '-', '~', '!', '!!'];
var operators = {
  arithmatic: arithmatic_operators,
  comparison: comparison_operators,
  logical: logical_operators,
  equality: equality_operators
}

You can add some other operations such as bitwise operaters to the list.

Why am I doing this?

As you know, Javascript will dynamically convert value type in different situations;

The type converting is very weird. I tried to find the inner-rule of dynamic type converting, but I found nothing, It seems that there is no hard and fast rule at all. Every time I found a rule in one place, I found it was wrong in another place later.

At last, I write this simple tool to help me find the rules, of cause it's useless. But with this tool I found some quirks I never found before. Hope this will help.

If You are preparing for some javascript quiz ,for example Elance skill test, this may help. If you found something wrong in the output, please send me a email or open an issue. If you found some hard and fast rule, please pull request.

Resources

CSS Framework: http://getbootstrap.com
View Template: http://getbootstrap.com/examples/dashboard/
JS Libary:
- angularjs: http://angularjs.org
- checklist-model: http://vitalets.github.io/checklist-model/

TODO

add some resourses helpful for understanding the value type converting.
add bitwise operators
add new to operators

升级到 Mac OSX 10.10, 若干天后, 所有 Homebrew 安装的程序全部挂掉

suffering — Mon, 04 Aug 2014 11:45:03 +0800

如题，有什么好的解决方案吗？mysql, mongodb, redis等等等等全部挂掉，系统表示无此程序. brew update, brew doctor 都无视了这些问题。troubleshooting 上也没有好的解决方案，真是无语啊. 话说升级后若干天一切运行正常，只是昨天把电脑交给两个小屁孩玩了一会儿而已，难道现在的的零零后都会折腾 terminal 了吗？ >_<

经典排序算法资料及 ruby 实现

suffering — Fri, 18 Jul 2014 13:23:50 +0800

经典排序算法资料及 ruby 实现

学习<算法导论>时到网络上找了一批排序算法的资料。结合参考资料分别用 ruby 写了一遍。这里分享给大家。配上图与参考资料。

插入排序

def insert_sort!
  (0...self.length).to_a.each do |j|
    key = self[j]
    i = j - 1;
    while i >= 0 and self[i] > key
      self[i+1] = self[i]
      i = i-1
    end
    self[i+1] = key
  end
  self
end

冒泡排序

wikipedia 详解：http://en.wikipedia.org/wiki/Insertion_sort

Problem Solving: Searching and sorting

def bubble_sort!
  f = 1
  while f < self.length
    (0...(self.length-f)).to_a.each do |i|
      self[i], self[i+1] = self[i+1], self[i] if self[i] > self[i+1]
    end
    f += 1
  end
  self
end

鸡尾酒排序

wikipedia 详解：http://en.wikipedia.org/wiki/Cocktail_sort

def cocktail_sort!
    f  = 0
    while f < self.length/2
      i = 0
      while i < self.length - 1
        self[i], self[i+1] = self[i+1], self[i] if self[i] > self[i+1]
        i += 1;
      end
      t = self.length - 1
      while t > 0
         self[t], self[t-1] = self[t-1], self[t] if self[t] < self[t-1]
         t -= 1
      end 
      f += 1
    end
    self
  end

合并排序

wikipedia 详解：http://en.wikipedia.org/wiki/Merge_sort

def merge_sort!
  return self if self.size <= 1
  left = self[0, self.size/2]
  right = self[self.size/2, self.size - self.size/2]
  Array.merge(left.merge_sort, right.merge_sort)
end

def self.merge(left, right)
  sorted = []
  until left.empty? or right.empty?
      sorted << (left.first <= right.first ? left.shift : right.shift)
  end
  sorted + left + right
end

快速排序

wikipedia 详解：http://en.wikipedia.org/wiki/Quicksort

三种 qicksort 的实现方式：http://c2.com/cgi/wiki?QuickSortInRuby

在线图示加语音详解：http://www.csanimated.com/animation.php?t=Quicksort

def quick_sort!
  return [] if self.empty?
  x, *a = self
  left, right = a.partition{|t| t < x}
  left.quick_sort + [x] + right.quick_sort
end

heapSort

wikipedia 详解：http://en.wikipedia.org/wiki/Heapsort

更深入分析：http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/Sorting/heapSort.htm

def heap_sort!
  # in pseudo-code, heapify only called once, so inline it here
  ((length - 2) / 2).downto(0) {|start| siftdown(start, length - 1)}

  # "end" is a ruby keyword
  (length - 1).downto(1) do |end_|
    self[end_], self[0] = self[0], self[end_]
    siftdown(0, end_ - 1)
  end
  self
end

def siftdown(start, end_)
  root = start
  loop do
    child = root * 2 + 1
    break if child > end_
    if child + 1 <= end_ and self[child] < self[child + 1]
      child += 1
    end
    if self[root] < self[child]
      self[root], self[child] = self[child], self[root]
      root = child
    else
      break
    end
  end
end

最后，附上完整的 ruby 实现：

class Array
  # 插入排序
  def insert_sort!
    (0...self.length).to_a.each do |j|
      key = self[j]
      i = j - 1;
      while i >= 0 and self[i] > key
        self[i+1] = self[i]
        i = i-1
      end
      self[i+1] = key
    end
    self
  end

  # 快速排序
  def quick_sort!
    return [] if self.empty?
    x, *a = self
    left, right = a.partition{|t| t < x}
    left.quick_sort + [x] + right.quick_sort
  end

  # 冒泡排序
  def bubble_sort!
    f = 1
    while f < self.length
      (0...(self.length-f)).to_a.each do |i|
        self[i], self[i+1] = self[i+1], self[i] if self[i] > self[i+1]
      end
      f += 1
    end
    self
  end

  # 鸡尾酒排序(>_<)
  def cocktail_sort!
    f  = 0
    while f < self.length/2
      i = 0
      while i < self.length - 1
        self[i], self[i+1] = self[i+1], self[i] if self[i] > self[i+1]
        i += 1;
      end
      t = self.length - 1
      while t > 0
         self[t], self[t-1] = self[t-1], self[t] if self[t] < self[t-1]
         t -= 1
      end 
      f += 1
    end
    self
  end

  # 合并排序
  def merge_sort!
    return self if self.size <= 1
    left = self[0, self.size/2]
    right = self[self.size/2, self.size - self.size/2]
    Array.merge(left.merge_sort, right.merge_sort)
  end

  def self.merge(left, right)
    sorted = []
    until left.empty? or right.empty?
        sorted << (left.first <= right.first ? left.shift : right.shift)
    end
    sorted + left + right
  end

  # heap排序
  def heap_sort!
    # in pseudo-code, heapify only called once, so inline it here
    ((length - 2) / 2).downto(0) {|start| siftdown(start, length - 1)}

    # "end" is a ruby keyword
    (length - 1).downto(1) do |end_|
      self[end_], self[0] = self[0], self[end_]
      siftdown(0, end_ - 1)
    end
    self
  end

  def siftdown(start, end_)
    root = start
    loop do
      child = root * 2 + 1
      break if child > end_
      if child + 1 <= end_ and self[child] < self[child + 1]
        child += 1
      end
      if self[root] < self[child]
        self[root], self[child] = self[child], self[root]
        root = child
      else
        break
      end
    end
  end

  %w(insert quick bubble cocktail merge heap).each do |metd|
    define_method("#{metd}_sort") do
      self.dup.send("#{metd.to_s}_sort!") 
    end
  end
end

p b = ((1..100).to_a + (20..80).to_a).shuffle.sample(19)
p b.methods.grep /_sort/
p b.insert_sort
p b.bubble_sort
p b.quick_sort
p b.cocktail_sort
p b.merge_sort
p b.heap_sort

>_< 请原谅我闪花了你的眼。神马？你觉得眼不花？那看看这个吧：http://www.sorting-algorithms.com/

RubyChinaSPA by Anugarjs 发布

suffering — Thu, 05 Jun 2014 02:20:49 +0800

闲时写的基于 Angularjs 的 ruby-china.org spa 端。

本贴发自 spa 端 (截图除外).

https://github.com/suffering/rubychinaspa

rubyChinaSpa

Build with angularjs and ruby-china.org api/v2.

简介

ruby-china.org 的 SPA 版，根据 ruby-china.org api 制作。使用简单的 angularjs 语法，未涉及复杂的 directive 与 filters 等。

功能

帖子 (index/show)
节点 (index/show)
用户 (index/show)
用户登陆 (基于 loginname, token)
- 发表新贴
- 发表评论
- 收藏帖子
支持 markdown 即时预览 (预览格式与 ruby-china.org 原站略有不同.)
支持 emoji

DEMO

~~因为 CROS 的原因，无论是在线测试还是本地测试，都无法获取 ruby-china.org 的 api 数据。除非 ruby-china.org 管理员允许 CROS.~~

当前 ruby-china.org 官方已支持 CROS, :), 此节可省。以下部分保留以作参考;

DEMO 运行的前提

~~Google chrome 浏览器通过运行非安全模式 (暂时) 解决此问题：~~

Linux: google-chrome --disable-web-security
Mac: open -a Google\ Chrome --args --disable-web-security
windows: 进入到 chrome 安装目录，chrome.exe --disable-web-security

注意：必须完全关闭 google chrome 之后再运行此命令。否则只要有任何一个 chrome 实例存在，此模式将启动失败。

如果运行命令后出现You are using an unsupported command-line flag: --disable-web-security. Stability and security will suffer. 或 您使用的是不受支持的命令行标记: —disable-web-security. 稳定性和安全性会有所下降.的提示，即可正常浏览。

参考

Online Demo:

http://rbspa.zhuboliu.me

测试帐号: rbspa

token: 3d8757cc530374f18778:13471

以上帐号仅为新注册的测试帐号，不能发帖，只能回帖。

注意：可以使用个人的登陆名与 token 登陆，但不推荐使用 (虽然个人保证不在 log 中记录任何个人的 token).

本地测试

git clone https://github.com/suffering/rubychinaspa.git cd rubychinaspa npm install connect node server.js google-chrome http://localhost:1337 --disable-web-security

本地测试分两种模式，一种是直接引用 ruby-china.org/api/v2 的数据，另一种是本地运行 ruby-china, 而后将services.js中的base_url()函数的返回值改为http://localhost:3000.

TODO

简化代码，引入更多 angularjs 的高阶应用。
用户喜欢/收藏功能。
图片上传功能
允许多界面多主题切换。

帖子列表 发帖，markdown 即时预览 节点 Login Users#show

通过 API POST photos 时的 BUG

suffering — Fri, 30 May 2014 17:27:27 +0800

本地测试使用 ruby-china.org 的 api_v2 进行图片上传。图片上传成功，但是返回的地址却都是 photo/.jpg. 在console里找到上传的图片 Photo.all.collect{|t| t.image.url}, 返回的地址也全部都是photo/.jpg.

查看 log, 发现 params[:Filedata] 是一个 <Hashie::Mash>. 而 carrierwave 是无法处理它的。

试着将Hashie::Mash转化为ActionDispatch::Http::UploadedFile 对象后上传也失败了。

通过 API POST 的图片对象是：

#<Hashie::Mash Filedata=#<Hashie::Mash filename="4.png" head="Content-Disposition: form-data; name=\"Filedata\"; filename=\"4.png\"\r\nContent-Type: image/png\r\n" name="Filedata" tempfile=#<Tempfile:/var/folders/27/xnmldrkd5f3fq07zvfzb9by00000gn/T/RackMultipart20140530-7213-1t6ys2x> type="image/png"> format="json" route_info=#<Grape::Route:0x0000010443eef0 @options={:prefix=>"api", :version=>"v2", :namespace=>"/photos", :method=>"POST", :path=>"/api/:version/photos(.:format)", :params=>{}, :compiled=>/\A\/api\/(?<version>v2)\/photos(?:\.(?<format>[^\/.?]+))?\Z/}> token="[FILTERED]" version="v2">

hack 后的代码

#api_v2
resource :photos do
    post do
      authenticate!
      filedata = params[:Filedata]
      filedata_hash = {
        :filename => filedata[:filename],
        :orginal_filename => filedata[:filename],
        :type     => filedata[:type],
        :headers  => filedata[:head],
        :tempfile => filedata[:tempfile]
      }

      @photo = Photo.new
      puts "------ #{params.inspect}"
      @photo.image = ActionDispatch::Http::UploadedFile.new(filedata_hash)
      Rails.logger.info @photo.image.inspect
      @photo.user_id = current_user.id
      if @photo.save
        puts "------ #{@photo.inspect}"
        @photo.image.url
      else
        error!({"error" => @photo.errors.full_messages }, 400)
      end
    end
  end

关于这个问题，是否需要其他方式的 POST, 比如说 BINARY MODE 之类的。折腾了好久，一直没能解决这个问题。

ruby china SPA by angular js

suffering — Mon, 26 May 2014 04:34:13 +0800

闲着无聊使用 anuglarjs 做的 ruby-china.org 的 SPA 应用。

当前只有远程看帖，发帖，回帖的功能，界面也是随便弄的一个，上图片：

功能上有点鸡肋，希望有一天能被采用，到时 rubychina 能切换多主题，甚至自定义界面 : )

changelog

5 月 29

新增创建贴子或添加评论时的markdown内容实时预览，支持 emoji. 上图片:

写求职信的 gem - zresume

suffering — Tue, 02 Apr 2013 14:45:13 +0800

最近写的用来求职的 GEM, 很简单，希望对求职或招聘有帮助. RUBY 程序员就应该以 RUBY 的方式来写简历. https://github.com/suffering/zresume

写这个 gem 主要是为了我个人求职。我想的是写这么个 gem, 在中间用一些自己擅长的技巧，招聘的人若有兴趣可以去看一下源码 (源码也很简单，只有三个文件),看完了，大概也了解了我的水平了，合适与否也一目了然了。这样双方省事不少。

如何在 Mongoid 下做出 active_record 下的 STI (Single Table Inheritance) 逻辑？

suffering — Thu, 22 Mar 2012 17:11:48 +0800

碰到个蛋疼的要求！类似于在 active_record 下使用的 STI(Single Table Inheritance) 逻辑。换个说法：Mongoid inheritance，如何利用父类的 controller 与 view 创建对象到指定子类？ Model 如下： Models

#1
class Category
  include Mongoid::Document
  field :name
  has_many :products
  has_many :pages
end

#2
class Pagecategory < Category
end

#3
class Prodcategory < Category
end

#4
class Page
  include Mongoid::Document
  field :name
  field :content
  belongs_to :category
end

#5
class Product
  include Mongoid::Document
  field :name
  field :description
  belongs_to :category
end

要求可以使用已有的 categories 的 controller 与 views 直接创建 Pagecategory 与 Prodcategory 的实例。（不新建任何 controller 与 views）。可以直接在新建 product 时选择其类。模式如下： <%= simple_form_for @Product do |f|%> <%= f.input :category_id, :collection => Prodcategory.all %> <%= f.input :name %>

<%= f.submit %> <% end %> 问题变成了如何在创建category时，将其自由创建到Pagecategory或Prodcategory?(不让新建controller与view) 这相当于是让 categories 多态。但是，有这种搞法吗？有没有好的解决方案？

github 再一次被墙了？还是仅仅只是我这里的网络环境的问题？

suffering — Thu, 22 Mar 2012 14:26:27 +0800

杯具啊~~~

如何把握 DRY 的度？

suffering — Tue, 20 Mar 2012 17:54:11 +0800

在 Rails 编程中，感觉很难把握 DRY 原则的度。

比如说有一个流程，建立 product 模型。编程 MVC 将所有的功能都做好了。 routes.rb 如下：

  match '/products/:id/hide' => 'products#hide', :as => :hide_product
  match '/products/:id/release' => 'products#release', :as => :release_product
  match '/products/offlines' => 'products#offline', :as => :product_offline
  resources :products do
    collection do
      post 'sort'
    end
  end
end

现在要加一个独立后台，运行rails generate controller Cpanel::Products. 至此，在 routes.rb 里除了原本的resources :products外又多出了：

namespace :cpanel do
  resources :products
end

到这一步得去编辑 namespace，将算定义的 hide,release,offlines,sort 之类的方法重写一次。

同时，views 里相应地也建立了 cpanel/products, controllers 里相应建立了 cpanel/products_controller.rb 文件。

于是又得将已经写好的 view 与 controller 重写一次。当然，可以直接render :file => 'products/show',render :file => 'products/index',但是，很明显，如果 render 'products/form'的话在后台里编辑后会直接跳转到前端 show 页面。

这样的话，routes,views,controllers 里多出了许多只有细微差别的代码。虽然只要 copy 一下，但是感觉上却非常糟糕，很明显是违背 DRY 原则的。

在这种情况下，有什么好的解决方案？copy 不累人，只是这样整出的代码自己都觉得无法原谅。

RAILS 中如何上传超过 200M~300M 的文件？

suffering — Tue, 13 Mar 2012 17:27:26 +0800

配置： LINUX UBUNTU 10.04 (Linode VPS) NGINX PASSENGER RUBY 1.9.3 RAILS 3.2.1 其中，nginx 的配置基本保持默认状态。

相关代码： Gemfile: gem 'mongoid' gem 'paperclip_mongoid' Model: class Support include Mongoid::Document include Mongoid::Paperclip validates_attachment_size :download, :less_than => 300.megabytes validates_attachment_presence :download end 这样的配置，在本地时上传文件没有问题。但是在服务器上之后，20M 的文件都没能成功上传过一个。

如何让 RAILS 支持中文路径？

suffering — Mon, 12 Mar 2012 16:00:49 +0800

使用 paperclip 上传文件。客户需要可以上传中文的文件。但是，在 rails 里，似乎<%= link_to “download", “你好.rar" %>这样的链接会找不到文件。报的是 routes 错误。试过 URI.encode 的方案，不行。大家平时是怎么做的？

suffering (zhubo)

Rails 项目 Gem 依赖的社交关系网络关系图及其生成

WHAT

Rails 4.2.1 初始化项目 gem 依赖关系图：

WHY?

IDEAS

HOW?

取数据，生成 Graphviz 有效的文件

再来一个 web 版的吧。

看图说话

后续开发意见征集

参考资料

why no windows

初步深入 Rack (一)

Rack 项目的知其然

提出问题

rackup 命令来自于哪里？如何加载 config.ru 并生成项目的？

Rack 如何创建服务并生成 stack 的？

抽象问题，模拟过程

相关资料

模拟推衍过程

Rails 3 组织分割 routes

场景

创建并拆分文件

修改 application.rb

考虑 routes override

参考

此版太冷, 发图求暖

关于 axlsx 导出 excel 的问题

为什么我们需要 Rack ?

一切从 Rack 开始

简介

为什么需要 Rack

数行代码的rack app

使用 middleware stack 的 rack app

Rails On Rack

结论

更多文档资料

从头开始写一个 Rails-like web 框架

目标

为什么需要

已经实现的功能

基本逻辑

如何使用和阅读本项目的源码

Jsquirks: 列出那些变态的 JS 类型转换

Javascript Quirks with special values and Operations

Do What

Special Values

Operators

Why am I doing this?

Resources

TODO

升级到 Mac OSX 10.10, 若干天后, 所有 Homebrew 安装的程序全部挂掉

经典排序算法资料及 ruby 实现

经典排序算法资料及 ruby 实现

插入排序

冒泡排序

鸡尾酒排序

合并排序

快速排序

heapSort

RubyChinaSPA by Anugarjs 发布

rubyChinaSpa

简介

功能

DEMO

DEMO 运行的前提

Online Demo:

本地测试

TODO

相关的帖子

通过 API POST photos 时的 BUG

ruby china SPA by angular js

changelog

写求职信的 gem - zresume

如何在 Mongoid 下做出 active_record 下的 STI (Single Table Inheritance) 逻辑？

github 再一次被墙了？还是仅仅只是我这里的网络环境的问题？

如何把握 DRY 的度？

RAILS 中 如何上传超过 200M~300M 的文件？

如何让 RAILS 支持中文路径？

数行代码的`rack app`

RAILS 中如何上传超过 200M~300M 的文件？