Feed 输出：http://feeds.feedburner.com/red_world

Rails Widgets

http://www.seesaw.it/en/toolbox/widgets/

一个DSLful的Page widgets plugin，让你简单地在页面上添加各种widgets，如tab，nav等，这些似乎是现在页面上不可或缺的页面元素。这个框架旨在减少手工维护这些widgets的代价，手工维护的话，so buggy！

具体看其演示文档可以看到它是干嘛的。

Bj

http://codeforpeople.rubyforge.org/svn/bj

一个让Rails参与管理Server上后台进程（background job）的plugin。这样有什么好处呢？如果你前台Rails app是使用了后台的某些服务的，那这个插件就非常有用了。

不过这个plugin非常少资料，只能从它的README中获得比较多的信息。

……

比较基础和底层的话可以试试HttpClient，hc.apache.org，按照它官方的教程，六步走。这个框架提供了Http访问的能力，加上Java的multithread能力，虽然效率不及noblocking io那么高但胜在文档资料多。这个一个初学者的好起点。

高级点的就是mina，mina.apache.org，一个高性能高扩展能力的network app框架。基于Java的nio，并发能力得以保证，并在比较高层次进行封装。不过这个东西文档不多是弱点。值得一提的是Logo，so Cool。

当你的network app需要大量的数据处理时，使用hadoop是个不错解决方案，hadoop.apache.org/。这个MapReduce实现，非常著名，不用我废话了:P Hbase是Hadoop的一个子项目，是Bigtable的实现。Hbase有Ruby的客户端，Hbase-ruby。

另hypertable也是一个值得注意的Bigtable实现，hypertable.org。

现在的Network app常常需要有搜索功能，这时就需要Lunece，Solr，Nutch啦。Lunece也是不用介绍的。Solr很多人也熟悉，一个企业级搜索服务器，是Lunece的的扩展，提供了web管理界面等。Netch，一个通用型的Web搜索引擎，其实就一大Crawler，他的存储基于hadoop，原dadoop是其子项目。

以上的项目好像基本上都是Apache的Project，现在的Apache项目都有Wiki了，以前貌似没有，进步了。

这就是我最近开发Crawler遇到的几个Java Framework。

Blog可能会用typo，因为比较好折腾，如果用WP，自己想去改也会很麻烦。wiki，不知道会不会自己开发个，或者用instiki，再写些JavaScript，放在greasemonkey，然后就可以像Google Note那样，一选一点就可以把选中的资料加到wiki中。

不知道有什么比较好的Rails主机介绍。。。

最近真的很忙，每天大量的开发，还有学习着很多新的东西（从同事从网络从书本）。有两篇Blog想写，但是没有时间写，一篇是只写了一个开头的《Ruby GUI开发思考》还有一篇关于开发中的测试的心得和思考。本来还想着7月份，Weblog能过百篇，现在看来。。。

我太懒了:P

最近使用它时遇到一个bug，其中用到了它的s3存储管理，发现如果没有指定缩略的参数时更新会出错，看了一下原来是默认参数nil出的错，当在File#join路径时，会调用每个参数的to_s方法，这样nil.to_s当然就出错了。或许，大家使用s3存储，并使用了attachment_fu时都存的是缩略图，所以没有遇到这个bug吧。这个错误只出现在update时，报的错是type error。

# line 196
def full_filename(thumbnail = nil)
  File.join(base_path, thumbnail_name_for(thumbnail))
end

我已经fix了这个bug，并ci到attachment_fu在github的repo。

fix s3 no thumbnail update error bug

mark一篇文章，关于如何在github上ci path：
http://railsontherun.com/2008/3/3/how-to-use-github-and-submit-a-patch

这是我第一次向开源项目提交代码^_^

MapReduce,Hadoop,Hbase,Bigtable,Skynet,Solr,…

I need learn more about nutch-solr-hadoop-hbase-weka recently.

I had a kind of holiday in the summer but I couldn’t really relax. I’ve been on the go all this month. -_- But I have learnt much^_^

下面开始发牢骚。

每次考试完了之后总会觉得考试很假，都是学期初看完了书和相关的东西，比较有兴趣的东西才会去深入研究。但身边大多数人不是这样，一般都是到了最后一周左右时间才开始背书，一般这类同学都会得到比较高的分数。这与老师的出题方向也有关，出题基本都是作业题，就算什么也不会，考试前去背背作业就能拿很高分。记得中央台还报道过学校这里考试前打印店就非常热闹，其实最后一两天打印都是字特别小的“资料”。

中午发现了这个东西挺搞笑：http://www.cnbeta.com/articles/59918.htm

原来做游戏的是比魔鬼还魔鬼，应该去枪毙。其实我一直就认为现在社会上很多奇诡的问题和国人的经济水平，文化水平不高有关。想想小时候家里的电器还不多，就电冰箱电视机，想买本十万个为什么还要和爸妈讲几天。然后忽然到了小学到了中学，再到大学，一时间生活完全变了，物质水平面目全非，精神水平也不敢恭维。这种变化速度国人无法适应。他们说游戏是毒品，他们就是为了赚钱让你玩更长时间，他们还在高楼大厦里，这个逻辑如果放到其它行业其实也是成立的。

还想到一个事情，如果中国不存在盗版软件或者盗版没那么猖獗，计算机会不会不那么流行。在国外来说，现在正常人使用的计算机，应该是软件贵过硬件。

目前国人的所谓家长群体，认为上网就是玩游戏，用电脑就是玩游戏。特别是目前大学生这个群体，很多人买计算机就是买了一部多功能游戏机，目的主要是娱乐。这是个性价比超低的买卖，花五千块去买部计算机打游戏看A片还不如花一千买部psp爽。但大部分人还是买了，用的是家长的血汗钱，就算是家庭经济水平不高的同学也为了面子也会购入计算机，理由是查资料。然后大学宿舍楼就会出现这样的喊声：“XX，建图阿”，“XX，我在X场X桌”，学生会为了娱乐（不单游戏，还有其他），逃课，通宵等等。大学生玩游戏时一般也会有比较多噪音出来，比如我常听见的“你会不会的阿？”，“你们这群傻13/垃圾”，“那么厉害不去打第一名”，“我踢，我踢，看你们还敢打我”……祖国未来的花朵就是这么成长的。

最近sourceforge还给封了。

这个世界太假拉。

发完牢骚，该干嘛干嘛去，END

到了PictureBook的V0.4了。这个版本算是基本的功能都做足了，包括了加上了相册选择，相册持久化等等。

#album_list_view.rb
require 'fox16'
 
include Fox
 
class AlbumListView < FXList
  attr_reader :album_list
  def initialize(p, opts)
    super(p, :opts => opts)
  end
  def switcher=(sw)
    @switcher = sw
  end
 
  def add_album(album)
    appendItem(album.title)
    AlbumView.new(@switcher, album)
  end
   
  def album_list=(albums)
    @album_list = albums
    @album_list.each_album do |album|
      add_album(album)
    end
  end
end
   
#picture_book.rb
$KCODE = "U"
require 'fox16'
require 'yaml'
   
include Fox
   
require 'album'
require 'album_list'
require 'photo'
require 'photo_view'
require 'album_view'
require 'album_list_view'
   
class PictureBook < FXMainWindow
  def initialize(app)
    super(app, "Picture Book" , :width => 600, :height => 400)
    add_menu_bar
    begin
      @album_list = YAML.load_file("picturebook.yml" )
    rescue
      @album_list = AlbumList.new
      @album_list.add_album(Album.new("My Photos" ))
    end
    splitter = FXSplitter.new(self,
      :opts => SPLITTER_HORIZONTAL|LAYOUT_FILL)
    @album_list_view = AlbumListView.new(splitter, LAYOUT_FILL)
    @switcher = FXSwitcher.new(splitter, :opts => LAYOUT_FILL)
    @switcher.connect(SEL_UPDATE) do
      @switcher.current = @album_list_view.currentItem
    end
    @album_list_view.switcher = @switcher
    @album_list_view.album_list = @album_list
  end
   
   
  def create
    super
    show(PLACEMENT_SCREEN)
  end
   
    def add_menu_bar
      # 创建一个菜单栏的实例
      menu_bar = FXMenuBar.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
      # 创建一个菜单栏项
      file_menu = FXMenuPane.new(self)
      FXMenuTitle.new(menu_bar, "文件" , :popupMenu => file_menu)
      # 下面是一个创建菜单栏项和所关联动作的绑定
      import_cmd = FXMenuCommand.new(file_menu, "导入..." )
      import_cmd.connect(SEL_COMMAND) do
        dialog = FXFileDialog.new(self, "导入图片" )
        dialog.selectMode = SELECTFILE_MULTIPLE
        dialog.patternList = ["JPEG Images (*.jpg, *.jpeg)" ]
        if dialog.execute != 0
          import_photos(dialog.filenames)
        end
      end
      new_album_command = FXMenuCommand.new(file_menu, "New Album..." )
      new_album_command.connect(SEL_COMMAND) do
        album_title = FXInputDialog.getString("My Album" , self, "New Album" , "Name:" )
        if album_title
          album = Album.new(album_title)
          @album_list.add_album(album)
          @album_list_view.add_album(album)
          AlbumView.new(@switcher, album)
        end
      end
     exit_cmd = FXMenuCommand.new(file_menu, "退出" )# 一个简单的退出项
     exit_cmd.connect(SEL_COMMAND) do
      store_album_list
      exit
    end
  end
     
  def import_photos(filenames)
    filenames.each do |filename|
      photo = Photo.new(filename)
      current_album.add_photo(photo)
      current_album_view.add_photo(photo)
    end
    current_album_view.create
  end
 
  def current_album_view
    @switcher.childAtIndex(@switcher.current)
  end
   
  def current_album
    current_album_view.album
  end
   
  def store_album_list
    File.open("picturebook.yml" , "w" ) do |io|
      io.write(YAML.dump(@album_list))
    end
  end
 
end
 
if __FILE__ == $0
  FXApp.new do |app|
    PictureBook.new(app)
    app.create
    app.run
  end
end

剩下的晚上再写。。。

这个V0.3的PictureBook添加了相册视图，也就是把相片都放到其中。看看下面的代码吧，我把每次都贴上完整的代码，方便大家复制粘帖:-)

#photo.rb
class Photo
  attr_reader :path
  def initialize(path)
    @path = path
  end
end
 
#album.rb
class Album
  attr_reader :title
  def initialize(title)
    @title = title
    @photos = []
  end
  def add_photo(photo)
    @photos << photo
  end
  def each_photo
    @photos.each { |photo| yield photo }
  end
end
 
#album_list.rb
class AlbumList
  def initialize
    @albums = []
  end
 
  def add_album(album)
    @albums << album
  end
  def remove_album(album)
    @albums.delete(album)
  end
  def each_album
    @albums.each { |album| yield album }
  end
end
 
#photo_view.rb
class PhotoView < FXImageFrame
  MAX_WIDTH = 200
  MAX_HEIGHT = 200
  def initialize(p, photo)
    super(p, nil)
    load_image(photo.path)
  end
  def load_image(path)
    File.open(path, "rb" ) do |io|
      self.image = FXJPGImage.new(app, io.read)
      scale_to_thumbnail
    end
  end
  def scaled_width(width)
    [width, MAX_WIDTH].min
  end
  def scaled_height(height)
    [height, MAX_HEIGHT].min
  end
  def scale_to_thumbnail
    aspect_ratio = image.width.to_f/image.height
    if image.width > image.height
      image.scale(
        scaled_width(image.width),
        scaled_width(image.width)/aspect_ratio,
        1
      )
    else
      image.scale(
        aspect_ratio*scaled_height(image.height),
        scaled_height(image.height),
        1
      )
    end
  end
end
  
#album_view.rb
require 'photo_view'
class AlbumView < FXMatrix
  attr_reader :album
  def initialize(p, album)
    super(p, :opts => LAYOUT_FILL|MATRIX_BY_COLUMNS)
    @album = album
    @album.each_photo { |photo| add_photo(photo) }
  end
  def add_photo(photo)
    PhotoView.new(self, photo)
  end
  def layout
    self.numColumns = [width/PhotoView::MAX_WIDTH, 1].max
    super
  end
end
  
#picture_book.rb
require 'fox16'
include Fox
require 'album'
require 'album_view'
require 'photo'
class PictureBook < FXMainWindow
  def initialize(app)
    super(app, "Picture Book" , :width => 600, :height => 400)
    add_menu_bar
    @album = Album.new("My Photos" )
    @album_view = AlbumView.new(self, @album)
  end
  def add_menu_bar
    menu_bar = FXMenuBar.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
    file_menu = FXMenuPane.new(self)
    FXMenuTitle.new(menu_bar, "File" , :popupMenu => file_menu)
    import_cmd = FXMenuCommand.new(file_menu, "Import..." )
    import_cmd.connect(SEL_COMMAND) do
      dialog = FXFileDialog.new(self, "Import Photos" )
      dialog.selectMode = SELECTFILE_MULTIPLE
      dialog.patternList = ["JPEG Images (*.jpg, *.jpeg)" ]
      if dialog.execute != 0
        import_photos(dialog.filenames)
      end
    end
    exit_cmd = FXMenuCommand.new(file_menu, "Exit" )
    exit_cmd.connect(SEL_COMMAND) do
      exit
    end
  end
  def import_photos(filenames)
    filenames.each do |filename|
      photo = Photo.new(filename)
      @album.add_photo(photo)
      @album_view.add_photo(photo)
    end
    @album_view.create
  end
  def create
    super
    show(PLACEMENT_SCREEN)
  end
end
  
if __FILE__ == $0
  FXApp.new do |app|
    PictureBook.new(app)
    app.create
    app.run
  end
end

这里相对于上个版本的改动的地方有，PictureBook增加了菜单栏，增加了一个视图AlbumView，PhotoView实例的创建放在了AlbumView中，PhotoView中增加了图片的缩略图操作。

菜单栏的创建也听挺麻烦的，先创建FXMenuBar的实例，然后是创建FXMenuTitle和FXMenuPane的实例，FXMenuTitle是FXMenuBar的下级元素，就是菜单栏的每一段，FXMenuPane是FXMenuTitle的弹出菜单。然后要创建FXMenuCommand，它是FXMenuPane的下级元素，实例化后就要用connect方法给出的代码块将其绑定到一定的行为上。

File>Importd这个动作是打开一个文件对话框FXFileDialog让你选择文件，然后用filenames方法获得选择得到的文件的数组。退出的菜单项很简单，就是一个exit方法。

在PhotoView中的图片操作功能是从FXImageFrame继承得到的，这个能力和接口很像RMagic。 AlbumView 是FXMatrix的实例，FXMatrix是一种布局管理器，它以行列的方式来对组件进行布局。好像布局管理器的基类就是FXPacker ，可以通过重写它的Layout方法来改变布局流。像这里就改变了FXMatrix的行数。

接着书中作者又改了一下，因为FXMatrix不能够在图片太多的情况下全部显示，会产生因为图片过多导致产生很多行，然后让超出主窗体的图片行无法看见，所以作者又对AlbumView换了一个布局管理器。

#album_view.rb
require 'photo_view'
class AlbumView < FXScrollWindow
  attr_reader :album
  def initialize(p, album)
    super(p, :opts => LAYOUT_FILL)
    @album = album
    FXMatrix.new(self, :opts => LAYOUT_FILL|MATRIX_BY_COLUMNS)
    @album.each_photo { |photo| add_photo(photo) }
  end
  def layout
    contentWindow.numColumns = [width/PhotoView::MAX_WIDTH, 1].max
    super
  end
  def add_photo(photo)
    PhotoView.new(contentWindow, photo)
  end
end

FXScrollWindow是另一种布局管理器，它只是多了滚动条。其中还是包含了一个FXMatrix。

本书的入门例子是个相册管理的桌面应用，名曰Picture Book。这个例子书中用了5 Chapter（2－6）来讲，基本讲到了常用的Gui组件。

不废话现在来看看代码，下面是第一个版本的Picture Book App：

#photo.rb
class Photo
  attr_reader :path
  def initialize(path)
    @path = path
  end
end
 
#album.rb
class Album
  attr_reader :title
  def initialize(title)
    @title = title
    @photos = []
  end
  def add_photo(photo)
    @photos << photo
  end
  def each_photo
    @photos.each { |photo| yield photo }
  end
end
 
#album_list.rb
class AlbumList
  def initialize
    @albums = []
  end
 
  def add_album(album)
    @albums << album
  end
  def remove_album(album)
    @albums.delete(album)
  end
  def each_album
    @albums.each { |album| yield album }
  end
end
 
#photo_view.rb
class PhotoView < FXImageFrame
   def initialize(p, photo)
      super(p, nil)
      load_image(photo.path)
   end
   def load_image(path)
      File.open(path, "rb" ) do |io|
        self.image = FXJPGImage.new(app, io.read)
      end
   end
end
 
#picturebook.rb
require 'fox16'
include Fox
require 'photo'
require 'photo_view'
class PictureBook < FXMainWindow
  def initialize(app)
    super(app, "Picture Book" , :width => 600, :height => 400)
    photo = Photo.new("shoe.jpg" )
    photo_view = PhotoView.new(self, photo)
  end
  def create
    super
    show(PLACEMENT_SCREEN)
  end
end
if __FILE__ == $0
  FXApp.new do |app|
    PictureBook.new(app)
    app.create
    app.run
  end
end

这是个V0.1的版本。不过你从中看出这个应用写得很MVC。

Model部分就是Photo，Album，AlbumList三个，Controller部分（当然它还没有细化）就是PictureBook，View部分就是PhotoView。就是如此清晰的结构，我想如果是正在学着什么MFC的可怜人儿们看到了之后会把那本什么深入浅出MFC扔了吧。

对比那个HelloWorld，这堆代码除了多了几个普通的Ruby Class（扮演Model的那几个）外，就是多了一个继承自FXImageFrame的PhotoView，还有在FXMainWindow的构造方法中多了对PhotoView的实例化，实例化时将其自身挂钩到PictureBook（构造方法的第一个参数）。之后在App实例化后会实例化MainWindow，接着实例化MainWindow包含的组件，比如PhotoView这个FxImageFrame。PhotoView中对图片的包装是这样的，它先读入Photo的路径，然后用FxImage组件对图片进行包装，然后保存为自己的一个实例变量image中。

PictureBook的第一个版本就是这样。

接着下一篇讲下个版本和下下篇讲下下个版本，然后就介绍完了。

http://pragprog.com/titles/fxruby/fxruby

先来看看它的HelloWorld的代码：
require 'fox16'
include Fox
class HelloWindow < FXMainWindow
  def initialize(app)
    super(app, "Hello, World!" , :width => 200, :height => 100)
  end
  def create
    super
    show(PLACEMENT_SCREEN)
  end
end
if __FILE__ == $0
  FXApp.new do |app|
    HelloWindow.new(app)
    app.create
    app.run
  end
end

HW没什么太多好讲的，有些东西要提一提就Ok了。GUI应用，肯定有个明显的入口点，就是FxApp的实例，因为是Desktop app，所以一般都有个主窗体，在FxRuby中是FXMainWindow的实例。FxRuby中，App实例创建之后还要调用create和run两个方法，主窗体的构造函数要做的事情是设置好主窗体的属性，App的create方法会调用会调用每个下级控件的create方法，在create中要加入的就是显示的方式(好像窗体才需要)等等。从上面的HW就可以看到这些。

FxRuby官方手册中还有另一个复杂一点点的HelloWorld。

入门例子是个相册管理的桌面应用，名曰Picture Book。这个例子书中用了5 Chapter（2－6）来讲，基本讲到了常用的Gui组件。

好像太长了，拆开放到另一个日志上吧。

参考Link：

FxRuby官站：http://www.fxruby.org/

FxRuby的Rdoc：http://www.fxruby.org/doc/api/

FxRuby在线手册：http://www.fxruby.org/doc/book.html

今晚看了最新一期的程序员，这一期的主题讲的是开源，很多地方都提到了一点，就是开源要从大学教育开始，让学生在学习的过程中去阅读这些开源的项目，并且去参与其中，甚至去做出贡献。我觉得这个离国内的现实还是好远，国内的大学绝大多数的学生和老师都对开源没什么认识，他们只认得Ms，认得Windows，他们认为VC就是C++，SQL就是SQL Server，认为电脑就是Windows，课件就叫PPT。

我自从发现了Linux下校园网的上网解决方案之后，就再也没有怎么用过windows，并一年前就把windows删除了。其实我也向很多人推广了Linux，但是很多人都是一两天新鲜过后就删除了或者根本没有用过。现在我怎么用IDE，怎么不爽，总觉得写完一个东西之后一定要按下Esc，：，w。

难道中国大地这片土壤真的不适合开源，还是开源只是少数人的游戏？中国人很让我费解。

因为我是个懒人，我就加了些代码Hack一下，就不用去定义多个shared_request方法。

#spec/spec_helper.rb
module ControllerMacros
 
  module ExampleMethods
    def shared_request
      verb = [:get, :post, :put, :delete].find{|verb| respond_to? :"do_#{verb}"}
      raise "未定义do_get, do_post, do_put, 或do_delete方法 / No do_get, do_post_ do_put, or do_delete has been defined" unless verb
      send("do_#{verb}")
    end
  end
end
Spec::Runner.configure do |config|
  #...
  config.include(ControllerMacros, :type => :controllers)
end

看到ben的Blog写了一篇关于Rspec的测试宏的文章：
http://www.benmabey.com/2008/06/08/writing-macros-in-rspec/

其实很多人都是看到Tammer Saleh在MountainWest_Ruby_Conference2008上的Shoulda演示后，和我有一样的感想，就是如果如此DSL化，如此DRY的测试宏能用在Rspec上那就好了。那时我还把Shoulda的官方文档翻译了一下=_=，还有人和我讨论为什么要用Shoulda，还说他就是喜欢Rspec，其实我一次也没有用过Shoulda，但就是觉得这个DSL写的很好。不过Shoulda的缺点也很明显，AR的测试宏依赖于fixture，在业界不提倡使用fixture的情况下还有对测试数据的控制粒度的角度来说，这个做法是不受欢迎的。Rspec中提倡的是全部数据都是在测试时手动Mock出来，所以在1.1.4中才有了stub_mock!这个方法来减轻Mock对象的负担。

Rspec测试的粒度是比较细的，测试的覆盖面在Stroy框架出来之后也能和之前Rails提供的Unittest一样。但是Rspec的测试代码，看上去很冗余，一开始就有这种感觉，一直到看到了Shoulda才发现原来它冗余的地方是什么，这存在于很多地方，比如Controller中每次都是mock一个请求方法，然后就对各种会触发的行为和保存的状态进行断言。这些每次千篇一律的东西，我在想如果在每个context下定义一个请求方法（do_xxx之类的），然后在测试时会在测试方法内部的断言前或断言后自动调用它，这样就能减少很多冗余了。当然我在看完了Shoulda的文档后也尝试写出Rspec的测试宏，不过由于不知道怎么连接到Rspec中就放弃了，话说回来，Rspec中每个测试中上下文关系是很复杂的。

不说废话了，看看鬼佬们怎么减少Rspec中的冗余吧。

下面是一个常见的以Product为领域模型的Controller的测试，用Rspec-Rails插件生成的Scaffold的测试就类似下面这样：

describe ProductsController do
  describe "handling GET /products" do
 
    before(:each) do
      @product = mock_model(Products)
      Product.stub!(:find).and_return([@product])
    end
 
    def do_get
      get :index
    end
 
    it "should be successful" do
      do_get
      response.should be_success
    end
 
    it "should render index template" do
      do_get
      response.should render_template('index')
    end
 
    it "should find all products" do
      Product.should_receive(:find).with(:all).and_return([@product])
      do_get
    end
 
    it "should assign the found products for the view" do
      do_get
      assigns[:products].should == [@product]
    end
  end
end

上面的代码一看过去就觉得很多重复吧。如果我想让它变成下面这些DSL化的测试代码要怎么办呢？

describe ProductsController do
  describe "处理Get /products" do
    before(:each) do
      @products = mock_model(Product)
      Products.stub!(:find).and_return([@product])
    end
    def do_get
      get :index
    end
    it_should_response_success
    it_should_render :template, "index"
    it_should_receive Product, :find, :all, [@product]
    it_should_assign :products, [@product]
  end
end

那么首先为这些宏定义一个Module吧：

module ControllersMacro
  module ExampleMethods
    def do_action
      verb = [:get, :post, :put, :delete].find{|verb| respond_to? :"do_#{verb}"}
      raise "No do_get, do_post_ do_put, or do_delete has been defined!" unless verb
      send("do_#{verb}")
    end
  end
 
  module ExampleGroupMethods
    def it_should_assign(variable_name, value=nil)
      it "should assign #{variable_name} to the view" do
        value ||= instance_variable_get("@#{variable_name}")
        if value.kind_of?(String) && value.starts_with?("@")
          value = instance_variable_get(value)
        end
        do_action
        assigns[variable_name].should == value
      end
    end
    def it_should_response_success
      it "should be successful" do
        do_action
        response.should be_success
      end
    end
    def it_should_receive model, action, with_value = anything, return_value = anything
      it "should make #{model.to_s} #{action.to_s}" do
        model.should_receive(action).with(with_value).and_return(return_value)
        do_action
      end
    end
  end
 
  def self.included(receiver)
    receiver.extend         ExampleGroupMethods
    receiver.send :include, ExampleMethods
  end
end

这些就是Spec中的DSL，一般称为Rspec Macros，Rspec宏。那么那么把这些宏与Controller们挂钩呢？每次测试挂一次？当然不是，在ben那篇Blog的留言里，Rspec的核心开发成员David Chelimsky给出了答案，原来Rspec中本来就有接口开放了：

Spec::Runner.configure do |config|
  #...
  config.include(ControllerMacros, :type => :controllers)
end

这样就把测试宏挂到了Controller的Spec那里，那还等什么就直接在Spec用这些DSL来写出清爽的Spec吧，享受BDD。在这之后当然，我们不会止步于只在Controller中消除冗余，我立马就想到了Shoulda中几个Api，像下面那样，马上就能想到一些ActiveRecord的测试宏。

module ModelsMacro
  module ExampleMethods
        #......
  end
 
  module ExampleGroupMethods
    def it_should_require_attributes(variable_name)
      it "should require #{variable_name}" do
       #TODO
      end
    end
       
    def it_should_require_unique_attributes variable_name
      it "should require unique attributes #{variable_name}" do
       #TODO
      end
    end
       
    def    it_should_not_allow_values_for variable_name, not_allow = []
      it "should require #{variable_name}" do
       #TODO
      end
    end
       
    def it_should_allow_values_for variable_name, allow_values = []
      it "should allow values for #{variable_name}" do
       #TODO
      end
    end
 
    def it_should_protect_attributes variable_name
      it "should protect attributes #{variable_name}" do
       #TODO
      end
    end
 
    def it_should_have_one variable_name
      it "should have one #{variable_name}" do
       #TODO
      end
    end
       
    def it_should_have_many variable_name, option => {}
      it "should have many #{variable_name}" do
       #TODO
      end
    end
               
    def it_should_belong_to variable_name
      it "should belong to #{variable_name}" do
       #TODO
      end
    end
  end
 
  def self.included(receiver)
    receiver.extend         ExampleGroupMethods
    receiver.send :include, ExampleMethods
  end
end

如果觉得自己写很麻烦，那就用别人做好的现成的东西吧：
一个现成的Rspec宏项目，Skinny Spec。它已经完成了Controller和AR的测试宏，页面的测试宏，还有一个生成器：
http://github.com/rsl/skinny_spec/tree
使用很简单，只要用script/plugin安装就好了。不过这个还有些不足，比如还没有shoulda中那个should_be_restful这个最魔幻的方法，在控制器中做出请求动作的那个方法的定义是实现一个名为shared_request方法，在其中加入请求的方法和参数。

其实我对Rspec还有很多想法，比如更加DSL化的测试，对Mock测试数据时更加强大的控制，测试中描述信息的国际化，动态生成测试方法等等。

清爽的Rspec代码，相信每个人都想把它放进自己的项目中。。。

现在要把自己的知识面收回来，收到一个比较小的知识面上，然后好好把这部分知识学习得深入些。还有就是不要研究过多的过程的东西，比如敏捷，只要了解一下就好了。

编程语言：Ruby，Cpp，C，Erlang，就这四门就够了。整个计算机世界的底层就是C构建出来的，如果要再上一层就是Cpp，要面向对象要DSL就是继承Smalltalk之魂的Ruby，并发的FP语言Erlang很有前途的。D语言的话，以后有机会要用到再说，而Java要用的时候查查书就可以。说什么语言都是一样的人，我觉得是放屁。

开发技术也有几个方向：Web开发，编译器解析器等语言底层构建技术，自动化测试和TDD/BDD。应该就这些了，对于敏捷还是看看就算了，到了实际软件开发的问题开始的时候再考虑这些方法，其实敏捷的经典书籍我也基本看了。

多看看源码。其实现在我看源码的感觉是这样，大概看得懂，可是不懂得怎么改。唉呀呀，还需要修炼。

实践也还是很少。自己有时会写写一些算法的实现，有时会写些小demo。其实我的想法蛮多的，想作的东西也是很多的，但是并不是十分有动力去把这些想法做出来。这次有机会参与到老师的科研项目就要努力去完成它，还有要下定决心完成一个编译器也是一个不错的开始。上次比赛作的那个日程管理平台也是一个不错的东西，其实可以把以前想做的，那个依照《高效人士七个习惯》里提出的日程管理的方法，以Web化的方式实现在这个平台上，要继续开发下去。

自己的不足，对于很多技术的简单应用其实还是游刃有余的状态，但是代码/系统开始复杂的时候就开始手足无措了；看书也很努力很认真，可是思考和总结还是很少，作笔记太少；平时开发时遇到问题时没有作记录下解决方法，之后遇到相同的问题又去查找了一次，太低效率的做法了；有买书强迫症，看到好书就想买，不会太管自己身上还有多少钱，买来又看不完，买了的一些书到现在还只是看完了前言，又浪费钱又阻住地方；英语现在还是太烂，能翻译文档又怎样，能用简单的词语和鬼佬交流又怎样，很多文章还是要一边查词一边看，口语又烂，英文技术写作能力又不行，英语真的是一个相当相当重要的一个工具；数学不行，越来越发现数学的重要，计算机世界本来就是构建在大量的数学定理和分析方法之上的。其实领导能力也是很重要的，自己一个人能做出一个东西，再怎样也是有限的，只有能领导一批人完成一个东西才是真的厉害。

看到了不足就要改进。还有有一个不错的工具，panda和toplang上的同学也经常提到的，那就是Google Notes，好好利用这个工具。

我相信，未来只能由自己创造，自己就是自己的救世主。现在还是和我的理想差的远了，还要努力才行，我要变得很厉害很厉害。

其实这些差距很多人都说是来自小时候的教育，那些人家庭教育背景都是不错的，父母都是大学毕业，或者知识水平比较高。他们都很早就接触了计算机（是接触了计算机而不是接触游戏），小时候就学会了英语。比如云风，初中就开始学习编程，比如toplang里的一些人说到的，高中初中就读了编译原理这一类的计算机经典理论书籍。

不过大部分人应该都是到了大学才真正的开始接触，学习计算机知识。其实如果来到大学之前，对计算机有所了解但不是掌握很多的话，其实四年（其实还不够四年就是大一到大四前段）也就是全部的学习时间。大一还是在懵懵懂懂，在摸索自己的技术之路，到了大二开始知道怎么学习基础，到了大三，开始要想去作些东西，到了大四，没时间了。

其实四年很短，这就拉开了和一开始就接受了很好教育的人的差距。到了工作的时候，如果自己不挤榨时间来学习的话就没有学习的机会了，最近在忙的时候这种感觉特别的重。

官站：http://www.gnu.org/software/guile

很好玩的一个解析器，在学习《SICP》的好工具，而且带有如何实现的文档，翻了一下它的文档，好像与MRI Ruby差不多，支持C 扩展。这是个不错的解析器的参考。

最近比较忙，学习时间只有中午和睡觉前这段时间，可以我还是要努力，我要成为能够被人记住的一个开发者。

calendar(month, year)方法其实是《The Ruby Way》里面的。

其实现在是想作编译器，但是最后可能会做出一个C语言的解析器（让C动起来）的东西，很难说。最近在关注一个Ruby VM，Rubinius，想让Ruby实现Ruby VM的项目。这个东西满有参考价值的，而且可以的话我也想参与到其中。而Rubinius的开发方式是挺特别的，大家都可以提交mspec（用BDD的形式描述VM的运行），然后项目开发者们就实现相关的代码，过几天我把我从Rubinius那里了解到的东西写一下。或许还会翻译一些Rubinius的文档。

要作编译器或者VM，那需要编译原理等知识，下面列举一下所需知识和资料：

程序设计语言原理，其中包括语法，语义的解析等等。《SICP》，《程序设计语言实践之路》。
编译原理，其中包括代码解析，运行时环境构建等等。《编译原理2e》，《现代编译原理-C语言描述》（龙虎两书）

我其实是想在这个过程中学习到更多东西，如果真的可以写出来的话，自己的思想应该就不会像现在那么幼稚了。做个编译器／解析器的第一步应该就是能做出一个Scheme的解析器。

hash_including方法，它能让开发者在Mock接受参数时不用指定全部参数，只需要指定应包含某个键值对。示例代码如下：

# before
account.should_receive(:deposit).with({:amount => 37.42, :date => anything()})
# in 1.1.4
account.should_receive(:deposit).with(hash_including(:amount => 37.42))

修正了heckle支持的bug。

stub_model方法出现了，再也不用在View Spec里用mock_model之后，一个一个属性写上去了。这个方法

参考：
http://blog.davidchelimsky.net/articles/2008/05/27/rspec-1-1-4

谷歌开放了免费的App Engine，500M的储存空间＆5百万的每月PV。看了一下之后是基于Py的，最简单的HelloWorld只要写个输出的Py脚本再用个yaml指定请求的路由处理。如果是需要更加复杂的处理就是要使用谷歌提供的Web框架，其中包装了Django等框架。看来是个不错的机会学习Py和Py的WebApp开发。感觉好像是谷歌开始要推广Py。

在YouTube的视频介绍：
http://www.youtube.com/watch?v=3Ztr-HhWX1c
http://www.youtube.com/watch?v=tcbpTQXNwac
http://www.youtube.com/watch?v=oG6Ac7d-Nx8
http://www.youtube.com/watch?v=oTFL7FPLnXY
http://www.youtube.com/watch?v=JcM2Ejk1tis
http://www.youtube.com/watch?v=K7usoKm5zwE

不知道是不是RP问题，创建时一直提示域名不可用……或许毕业后会去作个Pyer或者Cpper，而不是Rubyist。

不废话了，先看看它的主要功能先。

首先是代码模板：

— Statements ———————————————————

\sd do { } while (n,v,i)
\sf for (n,i)
\sfo for { } (n,v,i)
\si if (n,i)
\sif if { } (n,v,i)
\sie if else (n,v,i)
\sife if { } else { } (n,v,i)
\sw while (n,i)
\swh while { } (n,v,i)
\ss switch (n,v,i)
\sc case (n,i)
\s{ { } (n,v,i)

— Preprocessor ——————————————————-

\p< #include <&gt; (n,i)
\p” #include “” (n,i)
\pd #define (n,i)
\pu #undef (n,i)
\pie #if #else #endif (n,v,i)
\pid #ifdef #else #endif (n,v,i)
\pin #ifndef #else #endif (n,v,i)
\pind #ifndef #def #endif (n,v,i)
\pi0 #if 0 #endif (n,v,i)
\pr0 remove #if 0 #endif (n)
— Idioms ————————————————————-

\if function (n,v,i)
\isf static function (n,v,i)
\im main() (n,v,i)
\i0 for( x=0; x<n; x+=1 ) (n,v,i)
\in for( x=n-1; x>=0; x-=1 ) (n,v,i)
\ie enum + typedef (n,i)
\is struct + typedef (n,i)
\iu union + typedef (n,i)
\ip printf() (n,i)
\isc scanf() (n,i)
\ica p=calloc() (n,i)
\ima p=malloc() (n,i)
\isi sizeof() (n,v,i)
\ias assert() (n,v)
\ii open input file (n,i)
\io open output file (n,i)

— Snippets ———————————————————–

\nr read code snippet (n)
\nw write code snippet (n,v)
\ne edit code snippet (n)
\np pick up prototype (n,v)
\ni insert prototype(s) (n)
\nc clear prototype(s) (n)
\ns show prototype(s) (n)

— C++ —————————————————————-

\+c class (n,i)
\+cn class (using new) (n,i)
\+ci class implementation (n,i)
\+cni class (using new) implementation (n,i)
\+mi method implementation (n,i)
\+ai accessor implementation (n,i)

\+tc template class (n,i)
\+tcn template class (using new) (n,i)
\+tci template class implementation (n,i)
\+tcni template class (using new) impl. (n,i)
\+tmi template method implementation (n,i)
\+tai template accessor implementation (n,i)

\+tf template function (n,i)
\+ec error class (n,i)
\+tr try … catch (n,v,i)
\+ca catch (n,v,i)
\+c. catch(…) (n,v,i)

这个表最左边的就是按键，中间就是对应的模板，最后面是对应的模式。n是normal，i就是插入模式，v是虚拟模式。展开的模板放在 ~/.vim/c-support/templates 这里，自己可以hack，比如第一件事就是把Templates中的个人资料改一下。我还把函数声明改了一下，默认是把返回值类型放到上一行，看起来不爽。

然后就是编译链接和运行代码啦，我只用快捷键。

F9 compile and link
Alt-F9 write buffer and compile
Ctrl-F9 run executable
Shift-F9 set command line arguments

Shift-F2 switch between source files and header files

有了这些快捷键之后加上Vim7本身就有的一点点补全功能，其实这个工具也有些IDEful了。

最后看看一些实用功能，比如代码和注释的转化，还有行尾插入注释，插入注释行等等。

— Comments ———————————————————–

\cl end-of-line comment (n,v,i)
\cj adjust end-of-line comment(s) (n,v,i)
\cs set end-of-line comment column (n)
\c* code -> comment /* */ (n,v)
\c/ code -> comment // (n,v)
\cc code -> comment // (n,v)
\co comment -> code (n,v)
\cfr frame comment (n,i)
\cfu function comment (n,i)
\cme method description (n,i)
\ccl class description (n,i)
\cd date (n,i)
\ct date \& time (n,i)

有空试用一下lua-support和bash-support。其实一直想写篇rails.vim的配置和使用和一点点Src分析。

没有一种程序设计语言是完美无缺的。幸运的是，一种程序设计语言不必是完美无缺的，也可以成为构造伟大系统的良好工具。事实上，一种通用的程序设计语言根本不可能对它被用于的所有工作都是最完美的，对一项工作来说最完美的东西对于另外的工作就常常会表现出严重的缺陷，因为在一个领域中的最完美事物实际上也就是意味着专门化。Cpp的设计是想成为构造范围广泛多样的系统的良好工具，而且能够直接表达范围广泛多样的思想。

并不是所有的东西都能直接通过语言的某些内部特征表述。事实上，这也不应该成为一种理想。语言特征的存在是为了支持各种各样的程序设计风格和技术，因此，学习一种语言的工作就应该集中于去把握对该语言而言固有的和自然的风格－－而不是去理解该语言所有语言特征的细枝末节。

在实践性的程序设计中，理解语言中最晦涩难懂的语言特征，或者使用最大量的不同特征并不能获得什么利益。把一种特征孤立起来看并没有什么意思，只是在由技术和其他特征所形成的环境里，这一特征才获得了意义和趣味。因此，在阅读后面的章节时请牢记，考察Cpp的各种细节的真实目的在于能够应用它们，在有效的环境里，去支持良好的程序设计风格。

Bjarne真的是一个超人级的人物，很早就看清了程序设计语言的真谛。这段话的意思人人都懂吧。（还有赞叹一下裘掌门的翻译功力）

上次Topcoder的比赛很失败，让我觉着自己。这让我又回过头来再看Cpp的书，看Cpp圣经－－TCppPL，看侯Sir的STL剖析。看着Cpp的代码有种亲切的感觉，书中Bjarne写出来的Sample，很优美干练，可读性也非常高。

其实程序设计语言规格到底还是给人来描述现实问题的，描述后让计算机来处理问题，所以能更好地解决问题的语言就是一门不错的语言。RoR最能体现专门化解决问题的思想，Ruby的DSL能力不是盖的。而创造Ruby的这些DSL或者框架的超人们，他们都是掌握了良好程序设计风格的家伙。（说到最后知不到自己在说什么）

namespace :rails do
  namespace :freeze do
    desc 'Lock to latest Edge Rails, for a specific release use RELEASE=1.2.0'
    task :edge do
      require 'open-uri'
      version = ENV["RELEASE"] || "edge"
      target = "rails_#{version}.zip"
      url = "http://dev.rubyonrails.org/archives/#{target}"
 
      chdir 'vendor' do
        puts "Downloading Rails from #{url}"
        File.open('rails.zip', 'wb') do |dst|
          open url do |src|
            while chunk = src.read(4096)
            dst << chunk
          end
        end
      end
 
      puts 'Unpacking Rails'
      rm_rf 'rails'
      `unzip rails.zip`
      %w(rails.zip rails/Rakefile rails/cleanlogs.sh rails/pushgems.rb rails/release.rb).each do |goner|
        rm_f goner
      end
    end
 
    puts 'Updating current scripts, javascripts, and configuration settings'
    Rake::Task['rails:update'].invoke
    end
  end
end

这段代码其实是Rails2.1里的rails:freeze:edeg的Rake任务代码，因为Rails的代码库已经迁移至github，好像svn不提供新的版本，现在获取Rails最新版本的方法一是到github那里clone下来，要么就到http://dev.rubyonrails.org/archives/下载一个打包好的zip文件。

其实最傻瓜的方法就是直接下载http://dev.rubyonrails.org/archives/rails_edge.zip然后解压到vendor/那里，其实上面贴的rake脚本也是做了这个事情:-)

*2.1.0 RC1 (May 11th, 2008)*

* script/dbconsole fires up the command-line database client. #102 [Steve Purcell]

* Fix bug where plugin init.rb files from frozen gem specs weren’t being run. (pjb3) [#122 state:resolved]

* Made the location of the routes file configurable with config.routes_configuration_file (Scott Fleckenstein) [#88]

* Rails Edge info returns the latest git commit hash [Francesc Esplugas]

* Added Rails.public_path to control where HTML and assets are expected to be loaded from (defaults to Rails.root + “/public”) #11581 [nicksieger]

* rake time:zones:local finds correct base utc offset for zones in the Southern Hemisphere [Geoff Buesing]

* Don’t require rails/gem_builder during rails initialization, it’s only needed for the gems:build task. [rick]

* script/performance/profiler compatibility with the ruby-prof >= 0.5.0. Closes #9176. [Catfish]

* Flesh out rake gems:unpack to unpack all gems, and add rake gems:build for native extensions. #11513 [ddollar]

rake gems:unpack # unpacks all gems
rake gems:unpack GEM=mygem # unpacks only the gem ‘mygem’

rake gems:build # builds all unpacked gems
rake gems:build GEM=mygem # builds only the gem ‘mygem’

* Add config.active_support for future configuration options. Also, add more new Rails 3 config settings to new_rails_defaults.rb [rick]

* Add Rails.logger, Rails.root, Rails.env and Rails.cache shortcuts for RAILS_* constants [pratik]

* Allow files in plugins to be reloaded like the rest of the application. [rick]

Enables or disables plugin reloading.

config.reload_plugins = true

You can get around this setting per plugin.
If #reload_plugins? == false (DEFAULT), add this to your plugin’s init.rb to make it reloadable:

Dependencies.load_once_paths.delete lib_path

If #reload_plugins? == true, add this to your plugin’s init.rb to only load it once:

Dependencies.load_once_paths < “openid”, :version => “1.1.4″
config.gem “ruby-yadis”, :lib => “yadis”, :version => “0.3.4″

config.after_initialize do
ActionController::Base.send :include, OpenIdAuthentication
end

* Added config.gem for specifying which gems are required by the application, as well as rake tasks for installing and freezing gems. [rick]

Rails::Initializer.run do |config|
config.gem “bj”
config.gem “hpricot”, :version => ‘0.6′, :source => “http://code.whytheluckystiff.net”
config.gem “aws-s3″, :lib => “aws/s3″
end

# List required gems.
rake gems

# Install all required gems:
rake gems:install

# Unpack specified gem to vendor/gems/gem_name-x.x.x
rake gems:unpack GEM=bj

* Removed the default .htaccess configuration as there are so many good deployment options now (kept it as an example in README) [DHH]

* config.time_zone accepts TZInfo::Timezone identifiers as well as Rails TimeZone identifiers [Geoff Buesing]

* Rails::Initializer#initialize_time_zone raises an error if value assigned to config.time_zone is not recognized. Rake time zone tasks only require ActiveSupport instead of entire environment [Geoff Buesing]

* Stop adding the antiquated test/mocks/* directories and only add them to the path if they’re still there for legacy reasons [DHH]

* Added that gems can now be plugins if they include rails/init.rb #11444 [jbarnette]

* Added Plugin#about method to programmatically access the about.yml in a plugin #10979 [lazyatom]

plugin = Rails::Plugin.new(path_to_my_plugin)
plugin.about["author"] # => “James Adam”
plugin.about["url"] # => “http://interblah.net”

* Improve documentation. [Radar, Jan De Poorter, chuyeow, xaviershay, danger, miloops, Xavier Noria, Sunny Ripert]

* Added config.time_zone = ‘UTC’ in the default environment.rb [Geoff Buesing]

* Added rake tasks time:zones:all, time:zones:us and time:zones:local for finding time zone names for config.time_zone option [Geoff Buesing]

* Add config.time_zone for configuring the default Time.zone value. #10982 [Geoff Buesing]

* Added support for installing plugins hosted at git repositories #11294 [danger]

* Fixed that script/generate would not look for plugin generators in plugin_paths #11000 [glv]

* Fixed database rake tasks to work with charset/collation and show proper error messages on failure. Closes #11301 [matt]

* Added a -e/–export to script/plugin install, uses svn export. #10847 [jon@blankpad.net)]

* Reshuffle load order so that routes and observers are initialized after plugins and app initializers. Closes #10980 [rick]

* Git support for script/generate. #10690 [ssoroka]

* Update scaffold to use labels instead of bold tags. Closes #10757 [zach-inglis-lt3]

* Resurrect WordNet synonym lookups. #10710 [tom./, matt]

* Added config.cache_store to environment options to control the default cache store (default is FileStore if tmp/cache is present, otherwise MemoryStore is used) [DHH]

* Added that rails:update is run when you do rails:freeze:edge to ensure you also get the latest JS and config files #10565 [jeff]

* SQLite: db:drop:all doesn’t fail silently if the database is already open. #10577 [Cheah Chu Yeow, mrichman]

* Introduce native mongrel handler and push mutex into dispatcher. [Jeremy Kemper]

* Ruby 1.9 compatibility. #1689, #10546 [Cheah Chu Yeow, frederico]

可以看到最下面这里有写着兼容Ruby1.9，另一个比较重大的特性就是Timezone的加入，另外还有对于Rails应用程序的依赖包的管理。其它都是小改动或者修补Bug。

Shoulda：让Test::Unit也BDD

Shoulda教程之一—基本的should语句

Shoulda教程之二—上下文

Shoulda教程之三—测试ActiveRecord模型

Shoulda教程之四—测试控制器

其实看到Shoulda这个框架之后我会有很多思考，思考之前的BDD或TDD是不是太麻烦了，比如每次Fun Test都是要些mock Model，然后才能测试每次每次都是在重复，而每次页面的测试（Rspec里才有分离出来的测试）每次都要先构造出页面中要调用的对象，再assigns页面要调用到的元素之后再测试。整个过程非常繁琐，虽然这样可以很细粒度地测试到整个应用，但一点也不DRY（或许我的水平还不够）。

再抱怨一点，很多有名的Rails开源应用（如Beast，Redmind，Typo等等）很多都还未迁移到Rspec，虽然他们的项目目录中很多都有了spec这个目录，可是一般都是空的。想看到的Rspec的用于集成测试的Stroy框架的实例也没有，这个只能在教程中看到。Rspec的教程也太少，Rdoc中基本没有什么解释，代码里也是，如果对一些东西不知道怎么用就要去看代码，有些代码只是包装了Rails中的assist方法的还要去查Rails的方法代码（如果对Rails的一些assist不熟的话）。虽然这个过程可以看很多代码，学到更多，可是也太费时间了。

最后如果能把Shoulda的一些强大的宏移植到Rspec那就好了。当然，我会继续研究Shoulda源码，还要下一步要看看merb。

翻译完最后生成PDF在这里可以下载：http://download.csdn.net/source/458857

基本的控制助手方法

如ActiveRecord宏一样，Shoulda 提供了一套测试控制器的宏，以尽可能简洁的方法进行测试。所有的这些方法都在Shoulda的Rdoc中，但这里再送上一个快捷的例子：

class UsersControllerTest < Test::Unit::TestCase
  context "on GET to :show" do
    setup { get :show, :id => 1 }
  
    should_assign_to :user
    should_respond_with :success
    should_render_template :show
    should_not_set_the_flash
  
    should "do something else really cool" do
      assert_equal 1, assigns(:user).id
    end
  end
  
  context "on POST to :create" do
    setup { post :create, :user => {:name => 'Ronald', :party => 'Repukeulan' } }
    should_assign_to :user
    should_redirect_to "user_url(@user)"
    should_set_the_flash_to(/created/i)
  end
end

应该RESTful

这里每个 should_xxx 宏都会产生一个单独的测试方法，编写起来又DRY。而should_be_restful 宏可以产生遵循基本的RESTful设计模式的控制器。should_be_restful 宏就像一个超级测试生成器，每次调用是都会产生40到50个测试方法。这里有个超简单的例子：

class UsersControllerTest < Test::Unit::TestCase
  def setup
    @user = User.find(:first)
  end
  
  should_be_restful do |resource|
    resource.create.params = { :name => "Billy Bumbler", :party => 'Sure do!'}
    resource.update.params = { :name => "Changed" }
  end
end

这里会生成一整套包含全部CRUD行为的测试，也包括 :new 和 :edit 。对这个宏还有很多定义的空间，能让它处理各种情况的控制器，不过默认设置已经非常智能了。在上面的例子中，通过测试类名就能查找出如何处理User模型，users_url方法，params[:user]，@user 和@users实例变量等。

配置should_be_restful

来看看更改should-be_restful产生的测试的行为的方法。（这些也在Rdoc文档中有详细记录）

class UsersControllerTest < Test::Unit::TestCase
  def setup
    @user = User.find(:first)
  end
  
  should_be_restful do |resource|
    resource.klass      = User
    resource.object     = :user
    resource.parent     = []
    resource.actions    = [:index, :show, :new, :edit, :update, :create, :destroy]
    resource.formats    = [:html, :xml]
  
    resource.create.params = { :name => "bob", :email => 'bob@bob.com', :age => 13}
    resource.update.params = { :name => "sue" }
  
    resource.create.redirect  = "user_url(@user)"
    resource.update.redirect  = "user_url(@user)"
    resource.destroy.redirect = "users_url"
  
    resource.create.flash  = /created/i
    resource.update.flash  = /updated/i
    resource.destroy.flash = /removed/i
  end
end

下面是参数的具体解释：

* klass：要处理的模型类。
* objuect：用于#edit，#update和#destroy测试的对象的名字。所以如果在setup中实例化@user，那么res.object 应该设置为 :user。
* parent：嵌套资源中的上级对象名字。这是要传入到嵌套资源url助手方法的参数。如果不需要用到嵌套资源，可以忽略这个参数。如果使用嵌套资源，路由设置中:users置于:cities之下，那么user测速中res.parent设置应为:city。实际上，parent参数是User模型类的关联对象引用。所以如果当User belongs_to :location，class_name => “City”，那么应该把这个参数设置为:city。
* actions：要测试的行为列表。这个值应该是[:index, :show, :new, :edit, :create, :update, :destroy]（默认）的子集或全集。如果控制器是read_only的，那么可能需要设置这个值为[:index, :show]。
* formats：测试控制器支持的格式列表。默认值为:html和 :xml，以后会加入JSON，CSV和其他。添加上其他的新格式也是非常简单的，可以参考ThoughtBot::Shoulda::Controller::XML文件。

在#create，#update和#destory测试中可以附上一些参数：

* params：要传给行为的参数。
* flash：在行为完成之后在flash中预期得到的值。可以是字符串或者正则表达式。
* redirect：在行为完成之后应该重定向到方向。这里有些巧妙…在测试运行时才会解释设置的字符串。这个延后解析的字符串将会遍历所有的命名路由和所有控制器创建的实例变量。

Denied行为

RESTful 控制器的部分或全部的行为在大多数场景里是有访问限制的（比如需要用户认证的时候）。resource.denied选项让should_be_restful原生地支持行为的访问限制。

class UsersControllerTest < Test::Unit::TestCase
  def setup
  @user = User.find(:first)
  end
  
  should_be_restful do |resource|
    resource.create.params = { :name => "bob", :email => 'bob@bob.com', :age => 13}
    resource.update.params = { :name => "sue" }
  
    resource.denied.actions  = [:new, :create, :edit, :update, :destroy]
    resource.denied.redirect = "new_session_url"
    resource.denied.flash    = /administrator/i
  end
end

每个列在resource.denied.actions的行为（默认为空）将测试行为被限制访问，相关的记录不会被触及。 :redirect 和 :flash 参数和上面的 resource.create 和 resource.update 一样。

混合使用should_be_restful和上下文

测试每个控制器和所有控制器行为时，混合should_be_restful和上下文代码块是一个非常强大的方法。下面的代码是在我们（作者）的应用的测试中很常见到。

class PostsControllerTest < Test::Unit::TestCase
  def setup
    @user = users(:bob)
    @post = @user.posts.first
  end
  
  context "An administrator" do
    setup { login_as users(:admin) }
  
    should_be_restful do |resource|
      resource.create.params = { :subject => "test", :body => "message" }
      resource.update.params = { :subject => "changed" }
    end
  end
  
  context "A user" do
    setup { login_as @user }
  
    should_be_restful do |resource|
      resource.create.params = { :subject => "test", :body => "message" }
      resource.update.params = { :subject => "changed" }
    end
  end
  
  context "A stranger" do
    setup { login_as users(:sally) }
  
    should_be_restful do |resource|
      resource.create.params   = { :subject => "test", :body => "message" }
      resource.denied.actions  = [:edit, :update, :destroy]
      resource.denied.redirect = "login_url"
      resource.denied.flash    = /only the owner can/i
    end
  end
  
  context "The public" do
    setup { logout }
  
    should_be_restful do |resource|
      resource.denied.actions  = [:new, :create, :edit, :update, :destroy]
      resource.denied.redirect = "signup_url"
      resource.denied.flash    = /must be a member/i
    end
  end
end

混合与匹配

最后，记住更好的测试在should_be_restful助手之外的额外行为，或者在Shoulda中加入一般的test_xxx方法。

class UsersControllerTest < Test::Unit::TestCase
  def setup
    @user = User.find
  end
  
  should_be_restful do |resource|
    resource.create.params = { :name => "Billy Bumbler", :party => 'Sure do!'}
    resource.update.params = { :name => "Changed" }
  end
  
  context "on GET to /users/:id;activate"
    setup { get :activate, :id => @user.id }
    should_render_template :activate
    # etc.
  end
  
  def test_normal_stuff
    assert true
  end
end

Continuous Integration，持续集成，简称CI。这是一项业界推荐的软件开发实践，是XP中提到的实践之一。CI有四个特征：

1. 与版本控制系统的连接
2. 构建脚本
3. 某种类型的反馈机制
4. 集成源代码变更的过程

CI的价值在于：

1. 减少风险
2. 减少重复过程
3. 在随时随地生成可部署的软件
4. 对开发团队的软件产品建立起更大的产品信心

CI的步骤：

“I Build So Consistently”。四个步骤：“Identify”，“Build”，“Share”，“Continuous”。

CI的实践：

经常提交代码
不要提交无法构建的代码
立即修复无法集成的构建
编写自动化的开发者测试
必须通过所有测试和审查
执行私有构建
避免签出无法构建的代码

CI可以缓解一些关键的风险：

没有可部署的软件
很晚才发现缺陷
缺乏项目可见性
低品质的软件

CI系统的创建：

持续数据库集成
持续测试
持续审查
持续部署
持续反馈

Rails 的CI系统有来自TW的cruisecontrolrb

@person = Person.create(params[:person]) do |p|
 p.name = 'Konata Izumi'
 p.age = 17
end

现在可以通过 change_table 代码块来完成对数据库表的修改。

change_table :videos do |t|
 t.add_timestamps
 t.add_belongs_to :goat
 t.add_string :name, :email, :limit => 20
 t.remove_column :name, :email # takes multiple arguments
 t.rename :new_name
 t.string :new_string_column # executes against the renamed table name
end

补充些要注意的事情：

* add_XXX 方法会添加一个新列，比如 add_string 会添加一个新的 string 类型的字段。
* Of course, add_timestamps 会添加神奇的 created_at 和 updated_at 的 datetime 类型的字段。
* remove_column 现在可以接受多个参数。
* rename 方法会重命名数据库表。

script/dbconsole 脚本允许用户使用Rails的控制台客户端连接到数据库。

如果需要连接到MySQL的生产数据库作一些操作，直接运行 RAILS_ENV=production script/dbconsole 就能登录到数据库服务器上并使用MySQL的命令行客户端。当然，这个脚本也同样在 PostgreSQL 和 SQLite 数据库运行。

要在当前Rails应用程序中使用这个新脚本，就要先升级到edge Rails，再运行 rake rails:update:script 。好好享受这个脚本的便利吧。

Shoulda具有一套ActiveRecord测试宏，这让开发效率大大提高，TDD变得轻而易举。关于这个方面的所有的文档都在Shoulda的Rdoc中。下面就来个小小的例子：

class UserTest :dogs
 should_belong_to :lover
end

上面的代码创建了如下的测试：

test: Person should allow phone_number to be set to “(123) 456-7890″.
test: Person should belong to lover.
test: Person should have many dogs.
test: Person should have many messes through dogs.
test: Person should have one profile.
test: Person should not allow admin to be changed by update.
test: Person should not allow phone_number to be set to “1234″.
test: Person should not allow phone_number to be set to “abcd”.
test: Person should require name to be set.
test: Person should require phone_number to be set.
test: Person should require unique value for name.

前提

一件需要知道的事情是一些ActiveRecord测试宏找到第一个初始的记录(通过 Class.find(:first))。你可以让这个工作通过一个具有一条记录的fixture文件，或者通过在setup中创建一条记录，类似下面这样：

class UserTest < Test::Unit::TestCase
 def setup
  @user = User.create!(params)
 end
 
 should_require_unique_attributes :name
end

或者通过一个context，如下：

class UserTest < Test::Unit::TestCase
 context "given an existing record" do
  setup do
   @user = User.create!(params)
  end
 
  should_require_unique_attributes :name
 end
end

但是Shoulda不止是提供了对模型的测试，还提供了很多强大的助手方法可以使用于控制器。

上下文

在学习了Should语句之后，Shoulda的更多基本构建代码的知识就是上下文(Context)。上下文创建一个运行should语句的类似场景的fixture。Context代码块可以包含 setup/teardown 代码块，should代码块，或者其他context代码块。下面来试试在测试中使用简单的context：

class QueueTest < Test::Unit::TestCase
 context "一个队列实例" do
  setup do
   @queue = Queue.new
  end
 
  should "响应 :push 调用" do
   assert_respond_to @queue, :push
  end
 end
end

这里创建了一个名为”测试：一个队列实例可以响应:push调用”的测试方法，这很漂亮和易读。

嵌套

上面详尽的测试，简单测试队列的实例响应:push调用，但也提出了更多的上下文和测试。现在想看看让队列返回任何放进其中的东西。来添加一个嵌套的上下文进到其中：

class QueueTest < Test::Unit::TestCase
 context "一个队列实例" do
  setup do
   @queue = Queue.new
  end
 
  should "响应 :push 调用" do
   assert_respond_to @queue, :push
  end
 
  context "具有一个元素" do
   setup { @queue.push(:something) }
 
   should "在:pop调用后返回元素" do
    assert_equal :something, @queue.pop
   end
  end
 end
end

上面生成了测试方法”测试：一个队列实例应该响应:push调用”和”测试：一个队列实例具有一个元素应该在:pop调用后返回元素”。

注意一下，上下文的setup代码块是为每个should代码块运行一次的。首先@queue实例被创建出来，然后:something被放进去，接着执行assert_equal。下面用一个同样语意的测试方法虚拟地演示一下，记住下面的代码只是为了帮助理解，并不会实际的发生：

define_method "测试：一个队列实例有一个元素应该在:pop调用后返回元素。" do
 @queue = Queue.new
 @queue.push(:something)
 assert_equal :something, @queue.pop
end

现在，如果使用一般的测试风格，就会在一个测试方法中，把一个元素放进队列中并在一个测试方法中把元素取出来，然后进行断言。但是将这个测试分离出来放到一个测试push的上下文时，就可以添加更多的共享同样setup的测试。

class QueueTest < Test::Unit::TestCase
 context "一个队列实例" do
  setup do
   @queue = Queue.new
  end
 
  should "响应 :push 调用" do
   assert_respond_to @queue, :push
  end
 
  context "具有一个元素" do
   setup { @queue.push(:something) }
 
   should "在:pop调用后返回元素" do
    assert_equal :something, @queue.pop
   end
 
   should "在:size调用后返回1" do
    assert_equal 1, @queue.size
   end
  end
 end
end

在让测试保持可读性和防止重复代码方面，嵌套的上下文是一个强大的工具。测试文件变得更大时，更多的这种重构就会起作用。

在setup中断言

另一个美妙的setup代码块的特性是，可以运行一部分测试方法，也就是可以完美地把断言放在其中。在setup代码块中调用断言来代替在should代码块中断言，并不是一个非常好的做法，但是可以起到一个明确的检查作用。来个例子：

class PersonTest < Test::Unit::TestCase
 context "A Person" do
  setup { assert @person = Person.find(:first) }
 
  should "rock out" do
   assert @person.rocks_out!
  end
 end
end

在find调用失败时，在setup中看到失败的断言比出现烦人的异常要好看多了。

should代码块和上下文是为测试宏(test macros)不错的起点。Shoulda还有一个ActiveRecord助手方法集合，让测试简明扼要。

Should 语句

Should语句是一种简洁，优雅，高可读性的方式创建测试。Should语句能轻松地创建测试方法，所以完全向后兼容一般的Test::Unit 用法

class QuoteTest < Test::Unit::TestCase
 def setup
  # 和一般的Test::Unit一样
 end
 
 def test_should_be_true
  assert true
 end
 
 should "为真" do
  assert true
 end
end


以上的代码片断创建了两个测试方法:”测试: 应该为真”和test_should_be_true。在这个级别，两个方法只有名字不同。一旦你学习有关Contexts的知识，就可以找到一些非常有用的技巧。

下面是实现代码

#!/usr/bin/ruby -w
# Apriori 算法实现
 
class Apriori
attr_accessor :date_set, :min_sup, :lv1_item_set
 
# 从指定文件中得到整个事务集
def get_data_set(input_file)
 raise "Error: File #{input_file} does not exist" unless File.exists?(input_file)
 content = ''
 open(input_file) {|f| content = f.read}
 content.inject([]) {|set, l| set <= item.size
   @lv1_item_set.each do |i1| # 第一级项集
    if (item | i1).size > item.size && intersection?(date, (item | i1))
     candidacy_set.push((item | i1).sort).uniq! # 候选集生成
    end
   end
  end
 end
 end
 candidacy_set.sort
end
 
# 从候选集产生频繁集
def create_frequent_item_set(candidacy_set)
 frequent_item_set = Hash.new(0)
 candidacy_set.each do |e|
  @date_set.each { |date| frequent_item_set[e] += 1 if intersection?(date, e)}
 end
 return frequent_item_set.delete_if {|k, v| v = @min_sup }
# 输出第一级项集
open(output_file, "w") do |f|
@lv1_item_set.each { |e| f.puts e + " : " + @hash[e].to_s }
end
# 迭代生成候选集
result = []
until(result.empty?) do
# ......
end
end
end

Shoulda – Making tests easy on the fingers and eyes

我是在MountainWest RubyConf 2008的视频看到Tammer Saleh 讲了Shoulda才知道这个框架的：
http://mwrc2008.confreaks.com/12saleh.html

下面是官方资料的一点翻译：

Shoulda Rails插件能让你轻松地写出优雅，易懂，易维护的测试。Shoulda 包含了添加到了Test::Unit框架的宏，断言和助手方法。不需重新编写测试，完全适合已有的测试。

助手方法 – context方法和should方法使用了类似Rspec的测试块语法。还有，内置的contexts和一种可读性极强的语法。

宏 – 通过强大的宏生成上百行Controller和ActiveRecord测试。能让你快速开始，确保应用程序遵循最佳实践。

断言 – 许多一般的Rails测试惯用法提取了一个好用的断言集合。

也有一个精简的Shoulda的Gem包适合非Rails应用。

以后应该会继续翻译下去的。

Shoulda 官方主页
Shoulda 的RDocs

http://weblog.rubyonrails.com/2008/4/30/rails-2-1-release-candidate-is-imminent

其中过程,FF3忽然崩溃，又要翻译多一次，其实里面还有点还没有翻译完。。。

终于为ArchLinux做出了点贡献。

Stroy格式：
Title (故事标题)
 
故事的描述:
作为一个怎样的角色
我想要什么样
最后得到怎样的结果
 
验证故事的标准: (以场景(Scenario)的形式提出)
 
Scenario: 场景标题
Given [场景内容]
  And [场景附加内容]…
When [发生事件]
Then [产生的后果]
  And [其它后果]…
 
Scenario: …

以上就是故事编写的基本结构，Given后可以加多个And，Then也是。故事直接保存为文本文件就可以了。然后开始编写故事的验证机制（其实就是针对上面描述的场景以代码来表示）。

故事验证格式：
steps_for(:故事名) do
  Given("场景内容") do |占位符|
    代码描述
  end
  When("发生事件") do |占位符|
    代码描述
  end
  Then("产生的后果") do |占位符|
    代码描述
  end
end

解释下，Given块的个数应该与故事清单中的Given语句加后面的And的个数相当，Then块也是。

例子：
故事login
Story: 以存在的用户身份登录
作为一个未认证的用户
我想要登录到网站
那么我能看见我的账户信息
  
Scenario: 正常登录
Given 我的账户为test@example.org
When 我用邮箱为test@example.org和密码是foofoo进行登录
Then 我能够登录
And 我会看到账户页面
故事验证login.rb：
require 'rubygems'
require 'spec/story'
  
steps_for(:login) do
  Given "我的账户为$email" do |email|
    @user = find_or_create_user_by_email({:email => email,
    :password => 'foofoo',
    :password_confirmation => 'foofoo'})
  end
  
  When "我用邮箱为$email和密码是$password进行登录" do |email, password|
    post '/login', :user => {:email => email, :password => password}
  end
  
  Then("我能够登录") do
  end
  
  Then("我会看到账户页面") do
  end
end
  
with_steps_for(:login) do
  run "login"
end

参考：
http://rspec.info/
http://blog.davidchelimsky.net/articles/2007/10/22/plain-text-stories-on-rails
http://dannorth.net/whats-in-a-story
http://www.letrails.cn/archives/rspec-story-tutorials（上一链接文章的中译版）

我要获得改变这个世界的能力。然后去改变世界，改变所谓的现实

我憎恨丑恶的东西，还有憎恨师兄这个词。。。

期间，厂长说“界面要做出一个架构出来”，接着说“就是要能够看到一些框框，然后可以输入东西。”我晕忽忽，“架构”他们是这样理解。

由于国人的生产劳动力依然廉价，生产自动化难以普及，由于规模较小导致管理集权，生产由客户来单驱动，缺乏市场分析，分工粒度较小。不知道多久之后中国的制造业才能实现信息化自动化。

昨天 rubyonrailscn.org 发给 我 的消息
标题: Re: Re: 征询你的同意，我们希望把你的一些文章收入到 Ruby on Rails 中文 wiki 内容库中
正文:
chenk85, 你好！

谢谢你的同意！

你的文章《[翻译]来自Rails Envy的Rails Cache教程 part1》已经被收入和整理在 Rails 知识库中的如下地址：

http://wiki.rubyonrailscn.org/rails/show/RailsEnvyRailsCachePart1

请看一下，如果有问题的话请和我联系。

谢谢你对Rails中文站的支持，希望不久能看到更多你的作品。

Ruby on Rails 中文网站
Web: http://www.rubyonrailscn.org/
Email contact@rubyonrailscn.org

呵呵。。。

这次我选了ZenTest的1.0版来研究，代码文件大小只有3.7K，144行。

下面是代码：
#!/usr/local/bin/ruby -w -I.
 
VERSION = '1.0.0'
 
puts "# Created with ZenTest v. #{VERSION}"
 
$AUTOTESTER = true
 
# 重写at_exit方法，让该方法不做任何事情
module Kernel
  alias :old_at_exit :at_exit
  def at_exit()
   # nothing to do...
  end
end
 
require 'test/unit'
require 'test/unit/ui/console/testrunner'
 
# 产生文件的副本
files = ARGV.clone
 
# 保存测试类的hash（ klass -> klassmethods）
test_klasses = {}
# 保存待测试类的hash（ klass -> klassmethods）
klasses = {}
# 保存待测试类的方法的hash（ klass -> klassmethods）
all_methods = {} # fallback
 
# 迭代处理参数指定的每个文件
ARGV.each do |file|
 
  # 导入文件，失败则抛出异常，并输出错误信息
  begin
   require "#{file}"
  rescue LoadError => err
   puts "Couldn't load #{file}: #{err}"
   next
  end
 
  # 迭代处理文件的每一行
  IO.foreach(file) do |line|
  # 如果该行中包含类定义（class Xxx）则处理
  if line =~ /^\s*class\s+(\S+)/ then
   # 保存类名
   klassname = $1
   # 将类名转换为Symbol后再得到该类的类型值
   klass = Module.const_get(klassname.intern)
   # 如果该类为单元测试类
   target = klassname =~ /^Test/ ? test_klasses : klasses
 
   # record public instance methods JUST in this class
   # 保存类的公用实例方法到一个methond -> boolean的Hash中
   # 并将该Hash保存到以该类为键值的target hash中
   public_methods = klass.public_instance_methods
   klassmethods = {}
   public_methods.each do |meth|
   klassmethods[meth] = true
  end
  target[klassname] = klassmethods
 
  # record ALL instance methods including superclasses (minus Object)
  # 将该类中由Object类继承的实例方法除去后保存
  the_methods = klass.instance_methods(true) - Object.instance_methods(true)
  # 生成同上个代码块类似的hash
  klassmethods = {}
  the_methods.each do |meth|
   klassmethods[meth] = true
  end
  all_methods[klassname] = klassmethods
  end
  end
end
 
# 上面的迭代代码块运行完成后将记录下文件中所有类和其公共的实例方法
 
print "# "
p all_methods
 
missing_methods = {} # key = klassname, val = array of methods
# 在待测试类上进行迭代（以待测试类的名字）
klasses.each_key do |klassname|
  # 生成测试类类名
  testklassname = "Test#{klassname}"
 
  if test_klasses[testklassname] then
   methods = klasses[klassname]
   testmethods = test_klasses[testklassname]
 
   # check that each method has a test method
   # 检查每个方法是否有一个测试方法
   klasses[klassname].each_key do | methodname |
   testmethodname = "test_#{methodname}".gsub(/\[\]=/, "index_equals").gsub(/\[\]/, "index_accessor")
   unless testmethods[testmethodname] then
   puts "# ERROR method #{testklassname}\##{testmethodname} does not exist (1)" if $VERBOSE
   missing_methods[testklassname] ||= []
   missing_methods[testklassname].push(testmethodname)
   end
  end
  # check that each test method has a method
  testmethods.each_key do | testmethodname |
  if testmethodname =~ /^test_(.*)/ then
   methodname = $1.gsub(/index_equals/, "[]=").gsub(/index_accessor/, "[]")
   # try the current name
   orig_name = methodname.dup
   found = false
   until methodname == "" or methods[methodname] or all_methods[klassname][methodname] do
   # try the name minus an option (ie mut_opt1 -> mut)
   if methodname.sub!(/_[^_]+$/, '') then
   if methods[methodname] or all_methods[klassname][methodname] then
   found = true
   end
   else
   break # no more substitutions will take place
   end
   end
 
   unless found or methods[methodname] or methodname == "initialize" then
   puts "# ERROR method #{klassname}\##{orig_name} does not exist (2)" if $VERBOSE
   missing_methods[klassname] ||= []
   missing_methods[klassname].push(orig_name)
   end
   else
   unless testmethodname =~ /^util_/ then
   puts "# WARNING Skipping #{testklassname}\##{testmethodname}"
   end
   end
   end
  else
   puts "# ERROR test class #{testklassname} does not exist" if $VERBOSE
 
   missing_methods[testklassname] ||= []
   klasses[klassname].keys.each do |meth|
   missing_methods[testklassname].push("test_#{meth}")
  end
  end
end
# 真正地创建测试类，为没有测试的类添加方法。
missing_methods.keys.sort.each do |klass|
  # 判断是否为测试类
  testklass = klass =~ /^Test/
 
  puts "class #{klass}" + (testklass ? " < Test::Unit::TestCase" : '')
 
  methods = missing_methods[klass] | []
  m = []
  methods.sort.each do |method|
  # 为测试类生成代码
  if testklass then
   s = " def #{method}\n assert(false, 'Need to write #{method} tests')\n end"
  else
   s = " def #{method}\n # TO" + "DO: write some code\n end"
   end
   m.push(s)
  end
 
   puts m.join("\n\n")
 
   puts "end"
   puts ""
end

整个程序的主要分为三个部分，第一个是导入文件并收集文件中的类的信息，第二部分是收集前一部分收集到的类的方法的信息进行处理，最后是生成测试类的代码。

由于本本的特殊性要安装下列软件包：
apci,apcid – 高级电源支持
dus hal udev – 自动挂载
pmtools – 休眠
powertop – 本本节能工具
hotkey-setup laptop-mode-tools – 笔记本支持工具
cpudyn cpufreqd cpufrequtils CPU支持
iwlwifi-3945-ucode – 无线网卡驱动
参考
http://wiki.archlinux.org/index.php/Laptop
http://wiki.archlinux.org/index.php/Pm-utils
http://wiki.archlinux.org/index.php/Cpufrequtils
http://wiki.archlinux.org/index.php/Networkmanager

安装并设置了这些后就能很好的支持到笔记本的各种特性，如休眠，Fn键，自动降频，电池电量显示，无线等。

买回来了本本HP6520s（KS260PA）。6850RMB（一本，一电，一鼠，一包，一清洁）+135RMB（1条KS的内存）。

买本本的经历比较简单，一开始去本地HP代理问过一下价格，然后就叫他拿货，之后就去到验机（看序列号是否一致），测试（用Ubuntu的Live CD），带回来。

在中关村的资料：http://detail.zol.com.cn/notebook/index139838.shtml

配置上的确是不错的，迅驰4.5的T8100，加了1G的内存，升到2G，加上是800的前端，速度果然是飞快。发热也不厉害，电池能顶3个小时左右。唯一不满的地方就是屏幕，显示效果有点差，好像看网上的评价，基本都是说显示效果差。

[chenkai@localhost ~]$ cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 23
model name : Intel(R) Core(TM)2 Duo CPU T8100 @ 2.10GHz
stepping : 6
cpu MHz : 800.000
cache size : 3072 KB
physical id : 0
siblings : 2
core id : 0
cpu cores : 2
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 10
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm constant_tsc arch_perfmon pebs bts pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 lahf_lm ida
bogomips : 4194.59
clflush size : 64
processor : 1
vendor_id : GenuineIntel
cpu family : 6
model : 23
model name : Intel(R) Core(TM)2 Duo CPU T8100 @ 2.10GHz
stepping : 6
cpu MHz : 800.000
cache size : 3072 KB
physical id : 0
siblings : 2
core id : 1
cpu cores : 2
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 10
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm constant_tsc arch_perfmon pebs bts pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 lahf_lm ida
bogomips : 4191.10
clflush size : 64


CPU是最强的部分:)

买回来后就装上了Arch Linux，详见我另一日志。

http://lightyror.thegiive.net/2007/06/comet-push-server.html
http://www.javaeye.com/topic/19089

在Peedcode的教学视频中很多时候看到作者用autotest时，测试结果会以桌面系统Notify的形式通知用户，每次看到都觉得好羡慕。其实在Gnome环境下的同学不用羡慕，因为在Gnome下也可以，把你Home目录下的.autotest文件（附件有），加入以下代码，并把附件中的图片文件放到Home下（把dot改为.）。

require 'rnotify'
require 'gtk2'
 
module Autotest::RNotify
  class Notification
   attr_accessor :verbose, :image_root, :tray_icon, :notification,
   :image_pass, :image_pending, :image_fail
 
   def initialize(timeout = 5000,
   image_root = "#{ENV['HOME']}/.autotest_images" ,
   verbose = false)
    self.verbose = verbose
    self.image_root = image_root
 
    puts 'Autotest Hook: loading Notify' if verbose
    Notify.init('Autotest') || raise('Failed to initialize Notify')
 
    puts 'Autotest Hook: initializing tray icon' if verbose
    self.tray_icon = Gtk::StatusIcon.new
    tray_icon.icon_name = 'face-monkey'
    tray_icon.tooltip = 'RSpec Autotest'
 
    puts 'Autotest Hook: Creating Notifier' if verbose
    self.notification = Notify::Notification.new('X', nil, nil, tray_icon)
    notification.timeout = timeout
 
    Thread.new { Gtk.main }
    sleep 1
    tray_icon.embedded? || raise('Failed to set up tray icon')
   end
 
    def notify(icon, tray, title, message)
    notification.update(title, message, nil)
notification.pixbuf_icon = icon
tray_icon.tooltip = "Last Result: #{message}"
tray_icon.icon_name = tray
notification.show
end
 
def passed(title, message)
self.image_pass ||= Gdk::Pixbuf.new("#{image_root}/pass.png", 48,48)
notify(image_pass, 'face-smile', title, message)
end
 
def pending(title, message)
self.image_pending ||= Gdk::Pixbuf.new("#{image_root}/pending.png",48,48)
notify(image_pending, 'face-plain', title, message)
end
 
def failed(title, message)
self.image_fail ||= Gdk::Pixbuf.new("#{image_root}/fail.png", 48,48)
notify(image_fail, 'face-sad', title, message)
end
 
def quit
puts 'Autotest Hook: Shutting Down...' if verbose
#Notify.uninit
Gtk.main_quit
end
end
 
Autotest.add_hook :initialize do |at|
@notify = Notification.new
end
 
Autotest.add_hook :ran_command do |at|
results = at.results.last
 
puts "the results is #{results}"
 
unless results.nil?
output = results[/(\d+)\s+example?,\s*(\d+)\s+failures?(,\s*(\d+)\s+peding)?/]
 
if $~[2].to_i > 0
@notify.failed("Tests Failed", output)
elsif $~[4].to_i > 0
@notify.pending("Tests Pending", output)
else
unless at.tainted
@notify.passed("All Tests Passed", output)
else
@notify.passed("Tests Passed", output)
end
end
end
end
 
  Autotest.add_hook :quit do |at|
   @notify.quit
  end
end

ohoh～～我们来看看效果怎样，在任意一个加入rspec on rails插件的Project下（当然是写了spec的）执行autotest：

是不是很有趣呢？当然这个依赖于库ruby-gnome2，ruby-libnotify，都是用各自Linux发行班的包管理软件可以轻松得到的，比如我的arch就是，yaourt ruby-gnome2 ruby-libnotify。这个其实也可以用在unit test下，不过需要修改Autotest.add_hook :ran_command中的正则。

Ruby一个可爱的地方就是配置文件也是代码，代码还是代码。autotest的扩展性真好，这也是得益于Ruby的哲学，要修改一个类的行为就打开它，定义它，很优雅。Code is the best firend of Programmer 。

参考资料：
http://www.ikhono.net/2007/12/16/gnome-autotest-notifications

dot_autotest_images.zip

两个Model，Project和Task，关系是Project has_many Task。

在ProjectController的show中：
@project = Project.find(params[:id], :include => [:articles, :tasks])

这是project/show页面：
<h1><%=h @project.title %></h1> <h2><%=h @project.description %></h2> <p>统计信息:<br/>共有<%= @project.tasks.count %>个<%=link_to '任务', project_tasks_path(@project)%>， 已完成<%= @project.completed_tasks.length %>个任务。 <hr/> <h3>最新未完成的5个任务</h3> <table>   <tr>     <th width="25%">任务名</th>     <th width="75%">任务摘要</th>   </tr>   <% for task in @project.tasks.incompleted %>     <tr>       <td><%= link_to task.name, project_task_path(@project,task) %></td>       <td><%= task.content %></td>     </tr>   <% end %> </table>

来看看log吧：

Project Load Including Associations (0.000595) SELECT `projects`.`id` AS t0_r0, `projects`.`title` AS t0_r1, `projects`.`description` AS t0_r2, `projects`.`created_at` AS t0_r3, `projects`.`updated_at` AS t0_r4, `articles`.`id` AS t1_r0, `articles`.`subject` AS t1_r1, `articles`.`summary` AS t1_r2, `articles`.`content` AS t1_r3, `articles`.`project_id` AS t1_r4, `articles`.`created_at` AS t1_r5, `articles`.`updated_at` AS t1_r6, `articles`.`lock_version` AS t1_r7, `tasks`.`id` AS t2_r0, `tasks`.`name` AS t2_r1, `tasks`.`content` AS t2_r2, `tasks`.`completed` AS t2_r3, `tasks`.`project_id` AS t2_r4, `tasks`.`created_at` AS t2_r5, `tasks`.`updated_at` AS t2_r6 FROM `projects` LEFT OUTER JOIN `articles` ON articles.project_id = projects.id LEFT OUTER JOIN `tasks` ON tasks.project_id = projects.id WHERE (`projects`.`id` = 2)
Rendering template within layouts/application
Rendering projects/show
SQL (0.000255) SELECT count(*) AS count_all FROM `tasks` WHERE (tasks.project_id = 2)

可以看到在Project的Eager Loading的查询之后可以看到又有一个count()的select查询进行了。那前面的Eager Loading的效果似乎没有了。再试试把count方法调用改为调用length方法，这时就看不到另外的那个count()查询了。

这个可能在写代码的时候不会太留意，不过这对性能的影响还是有些的，如果Eager Loading后不会在调用统计函数就ok了。

在migrate中可以用referece类型来表示引用外键，比如在创建task的migrate中

create_table :tasks do |t|
...
t.references :project
...
end


路由规则定义如下：
# config/routes.rb
ActionController::Routing::Routes.draw do |map|
map.resources :projects do |project|
project.resources :tasks
end
end

比较好的一个方法调用Task所属Project的方法是用before_filter调用一个方法来设置：
class ArticlesController < ApplicationController
before_filter :load_project
...
def load_project
@project = Project.find params[:project_id]
end
end

把Controller中的涉及内嵌资源的find和new的调用改一下：
@project.tasks.find #=> 代替原来的Tasks.find
@projece.tasks.build #=> 代替原来的Tasks.new

还有把Controller中的redirect_to方法的参数修改一下：
redirect_to([@project, @task])

那在Task的view中应该做如下处理

在生成表单时，传入一个数组给form_for方法：
form_for([@project, @task])

调用TasksController的new方法：
new_project_task_path
# => domain/projects/:id/tasks/new

调用TasksController的show方法：
link_to 'Show', [@project, @task]
# => domain/projects/:id/tasks/:id

调用TasksController的edit方法：
link_to 'Edit' edit_project_task_path
# => domain/projects/:id/tasks/:id/edit
或者
link_to 'Delete', [:edit, @project, @task]
# => domain/projects/:id/tasks/:id/edit

调用TasksController的destory方法：
link_to 'Delete', [@project, @task], :confirm => 'Are you sure?', :method => :delete
# => domain/projects/:id/tasks/:id

通过这些方法就能让内嵌资源使用时更加优雅，而不用在导向时指定controller和action，再传入父资源和子资源的id。这些xx_path方法会帮你查找routes.rb的路由定义，然后生成url，当然这一切都是基于Rails2.0提倡的RESTful。

参考文章：
http://www.akitaonrails.com/2007/12/12/rolling-with-rails-2-0-the-first-full-tutorial

老师讲课讲得不错，很清楚的展示上面讲的东西。其实我很多东西有兴趣，只是限于时间不够精力不够不能学那么多，这个数据仓库也只是了解一下就OK了。

讲到数据库，看了豆瓣的开发者http://www.dbanotes.net/的blog，感觉现在由于长尾，小型数据库也开始受到重视，比如MySQL，风光地被SUN收购了。另，BS Ms的心理又来了：不喜欢Ms的SQL Server，好像学校的老师都是拿这个来作实验和讲课。

HTML页面负责的是基本内容和一点点表现逻辑；Css文件负责页面布局和页面里每个元素的样式；JavaScript文件负责的是页面的一些动态表现逻辑。这好像软件架构中的分层一样，把不同职责的部分分开来。

而在传送到客户浏览器之前，这些Html都还是各种脚本，比如Ruby的就是erb，Java的就是Jsp。都先用编程语言来描述页面的基本内容，一般其中充满了if／else／while（用来对Model中属性的各种输出）。对于Rails来说，最直接就是用Ruby来描述这些，Java呢，很喜欢搞个标签库这种东西，说是方便美工，其实也使页面逻辑更难看懂。

JavaScript负责的动态表现逻辑，一般叫Ajax，用的好的话可以获得用户体验，最近看到China-pub的Ajax就做得不错。Css也是Ajax的一个重要部分，那些什么颜色变化都是通过js来修改页面元素的样式实现的，现在web2.0的观感，也是由Css实现的。像FF的插件Greasemonkey就能用js来修改页面的观感。

好像前端就是这些。

进gnome桌面的速度很快，一闪就初始化好了面板，很好很强大，其他的软件感觉也快了，不知是不是心理作用。不过还剩下自动挂载U盘没有解决，还有gvim的配色混乱。

作下笔记：

关于MySQL的：

Arch的MySQL 5.0.51-3软件包中有bug，安装后须先修改/usr/share/mysql/mysql_system_tables_data.sql，找到这行：

INSERT INTO tmp_user (host,user) VALUES (@@hostname,);

将INSERT改为REPLACE后保存，再运行初始化脚本。

然后再设置编码，在／etc／my.conf加上：

a. [client]
default-character-set = utf8

b. [mysqld]
default-character-set = utf8
init-connect = ‘SET NAMES UTF8′

之后执行/etc/rc.d/mysqld start启动，再运行mysql_secure_installation 设置一下。

今年的Linux课程，老师竟然选了《鸟哥的私房菜》，不错。

放假看完了励志经典《高效能人士的七个习惯》，收获不少。很多书都是看到一半，比如《JavaScript高级程序设计》，《Ajax基础教程》，《RESTful web server》，《编写有效用例》。主要时间还是在研究wiki，blog，BBS这些web应用的特征。完成了那个翻译的发布站，感觉上好像一个没什么实际作用的应用，只是把文章分为翻译的状态不同（），再加上一个版本控制，而且都还没有富客户端编辑器。好像很失败，回到学校后自己看了看删了。不过自己做了一个简单的查询单词（用金山词霸在线的词典），和一个小小的BBS，只是有简单的发帖，回复功能。感觉要做到产品级的话就要能做出像基于PHP的Wordpress那样管理功能强大，又说到这个真的很想试用下google的blogger。剩下的时间都是在搞CSS，现在能自己弄出一个类似Ruby on Rails主页的那个界面，能弄出有些web2.0风格的界面。

本来放假里准备读英语和做做一些运动的，可是因为一开始就感冒了一个多星期，这些东西也就进行了两三天，到了感冒好了之后又没有继续。行动力真是差。后来回家的习惯又是发作，每天都睡到中午才起床，几次还睡了一整天，在学校时都是一点睡七点起床的标准作息。

职业规划在这个假期也完成了大部分，自己喜欢做什么，能做什么，希望做什么都是统一的。而在这条道路上，要怎么做，在什么时间要做什么。这些都大概有了计划。也看了一些公司的资料，有在找自己希望就职的公司。

这个放假买了*nway的洗洁精，回家洗碗。还有换了家里洗手盆的进排水管。还算是做了些有贡献的事：）

好像放假很多时间都是在睡觉，很多时间都浪费了。

最近好多好多新闻，春节前后，很多人都还在忙活。雅虎忙着被收购，微软忙着收购，，美国忙着大选，，俄罗斯忙着把飞机开到日本领空，，台湾忙着大选，，香港警方忙着抓发照片的，艺人忙着删照片，媒体们忙着炒照片，，各地还忙着收拾大雪残局。。。

今天还在网上看到有消息称Nv想要收购AMD，如果真的成了，Intel就又要有得忙活了，收了之后一统显卡市场对抗准备出产独显的Intel。其实Intel在显卡市场也厉害，他卖出的集显比Nv和Ati的独显卡还多，就像Nokia卖出的集成在手机的数码相机比那些专卖数码相机的厂商的出货量还大。这个道理和MS卖Windows的道理差不多。

这年头新闻的可看性比不上评论的可看性，动漫的可看性比不上动漫迷们的YY。不雅照事件，经过广大的网民YY之后，有了对联，谜语，古诗，剧本等等等等。。。有句话叫广大劳动人民的创造力是无限的。

其实要容易记的话可以自己在bashrc里配置一下alias就好。

再说说包下载的提速。。。
修改一下/etc/pacman.conf，把下面这句的注释去掉：
XferCommand = /usr/bin/wget -c --passive-ftp -c %u
这样就可以使用wget来下载包。

也可以用aria2，在配置文件中加上这句：
XferCommand = /usr/bin/aria2c -s 4 -m 2 -d / -o %o %u
-s后面是连接的服务器数量，-m是线程数。

wiki中提供了另一个脚本，是用aria2下载的。

在wiki中还提供了几个包查询彩色输出的脚本。

pacman也有GUI前端，不过我还没有见过用过，过几天回学校就会用上的。

Java interfaces:

* jacman A nice Java-based interface.

GTK2/Gnome interfaces:

* gtkpacman Pygtk gui to ArchLinux pacman. An -svn version is available as well (gtkpacman-svn).
* alunn Tray notifications of new updates and news from Arch front page.
* guzuta Yet another PyGTK frontend.
* pacmon-svn Tray applet that notifies the user of available pacman updates.

KDE/Qt interfaces:

* pacmanager-svn Qt4 package manager based on pacman.
* kpacupdate Pacman update notification tool for the KDE system tray.

之后就慢慢研究一下启动加载的模块，然后在编译一下内核，Arch好好玩。。。

运行pppoe-setup然后再pppoe-start联网，开始升级，发现真的如很多人说的，太慢了，一开始都是在10K/s上下徘徊，见事不对，记得好像在wiki上有一篇是pacman提速的文章，这篇文章里，有讲到把pacman的下载方式改为用其它下载工具的方法，但文章中提示要把pacman升级到最新版，那就忍一下，看看书等升级好。升级很慢而且好像把系统里的所有包都升了，我下载的是core-2007.08的iso，果然软件的升级很快。

升级完后改一下pacman的配置，用aria2c从多个服务器下载来加速软件包的下载，方法会在另一篇post中写出来。不过就算是用这种方法下载速度还是很慢，也就是120K/s上下。没有国内源，也没有第三方镜像，软件包的下载速度果然和Ubuntu没得比。因为很慢所以就安装了浏览器links，一边下载软件包一边可以上Arch的wiki上看看文章。

接着就是要安装桌面环境，安装xorg，gnome包和gnome-extra包，因为家里是Ati的集显X200，所以显卡难配，装了xf86-ati驱动之后进桌面就花了，还是回学校再弄一下，学校电脑的nv卡还是比较好配。

如果Ubuntu有了i686版本的话，或许我会用Ubuntu做平时工作的平台。Ubuntu桌面环境的傻瓜和友好是很多发行版比得上的，只是包太多太杂。Ubuntu不允许多个版本的软件包并存，而且默认对软件包的优化也不够，看看这个：
-rw-r--r-- 1 root root 424317 2008-02-12 18:39 abi-2.6.22-14-generic
-rw-r--r-- 1 root root 75311 2008-02-12 18:39 config-2.6.22-14-generic
-rw-r--r-- 1 root root 7233219 2008-02-16 01:30 initrd.img-2.6.22-14-generic
-rw-r--r-- 1 root root 80021 2008-02-14 02:22 kconfig26
-rw-r--r-- 1 root root 4716941 2008-02-14 02:23 kernel26-fallback.img
-rw-r--r-- 1 root root 1658157 2008-02-14 02:23 kernel26.img
-rw-r--r-- 1 root root 103204 2007-09-28 18:06 memtest86+.bin
-rw-r--r-- 1 root root 845769 2008-02-10 23:23 System.map26
-rw-r--r-- 1 root root 823535 2008-02-12 18:39 System.map-2.6.22-14-generic
-rw-r--r-- 1 root root 1861784 2008-02-10 23:23 vmlinuz26
-rw-r--r-- 1 root root 1764536 2008-02-12 18:39 vmlinuz-2.6.22-14-generic

对比一下引导程序的尺寸，差好多。。。

D语言已经到了2.0，DMD也到了2.0a，不过很多项目还是只支持到DMD1.0。不过也可以用另一个编译器GNU的DGC。D语言有两个标准库，默认C风格的Phobos和C++风格的Tango。更多的项目都是基于Tango开发的，一些基于Phobos的项目也开始向着Tango转移。从这里可以看出D语言的主要受众是原C/C++的用户。

这次有三个示例代码，三个示例：

第一个是Helloworld
import std.stdio;
  
void main() {
  nbspwritef("Hello");
}

可以看到这里用的是std.stdio中的输出方法writef()，一个很类似C的printf的方法，可以对输出进行格式化。

第二个示例展示的是代码的赋值，传统的类C式风格。
import std.stdio;
  
int magicNumber = 42;
char[6u] password = "sesame";
void main() {
  writefln("Magic number: ", magicNumber);
  writefln("Password: ", password);
}

这里要注意的是由于D语言是原生支持utf8的，所以在数组中可以使用nu这样的数量表示。

第三个例子是展示D语言的数据类型。
import std.stdio;
  
int main() {
  // Show information about integer types...
  writefln("bool\tmin: %d\tmax: %d (%d)", bool.min, bool.max, bool.sizeof);
  writefln("ubyte\tmin: %d\tmax: %d (%d)", ubyte.min, ubyte.max, ubyte.sizeof);
  writefln("ushort\tmin: %d\tmax: %d (%d)", ushort.min, ushort.max, ushort.sizeof);
  writefln("uint\tmin: %d\tmax: %d (%d)", uint.min, uint.max, uint.sizeof);
  writefln("ulong\tmin: %d\tmax: %d (%d)\n", ulong.min, ulong.max, ulong.sizeof);
  writefln("byte\tmin: %d\tmax: %d (%d)", byte.min, byte.max, byte.sizeof);
  writefln("short\tmin: %d\tmax: %d (%d)", short.min, short.max, short.sizeof);
  writefln("int\tmin: %d\tmax: %d (%d)", int.min, int.max, int.sizeof);
  writefln("long\tmin: %d\tmax: %d (%d)\n", long.min, long.max, long.sizeof);
  
  // Show information about floating-point types...
  writef("float (%d)\tdouble (%d)\treal (%d)\t", float.sizeof, double.sizeof, real.sizeof);
  writef("ifloat (%d)\tidouble (%d)\tireal (%d)\t", ifloat.sizeof, idouble.sizeof, ireal.sizeof);
  writef("cfloat (%d)\tcdouble (%d)\tcreal (%d)\t", cfloat.sizeof, cdouble.sizeof, creal.sizeof);
    
  // Show information about character types...
  writef("char (%d)\twchar (%d)\tdchar (%d)\t", char.sizeof, wchar.sizeof, dchar.sizeof);
  return 0;
}

这里就看到了std.stdio.writefln()方法的格式化功能。每种数据类型都有min和max，sizeof属性，这就是D语言的特性之一的原生属性支持（现代面向对象思想）。其中，浮点数里以i开头的表示复数中的虚部，以c开头就是复数，没有前缀的就是实数，而float，double，real的精度逐渐递减，c开头的浮点数类型的长度是无前缀的和以i开头的浮点数的长度之和。字符中，无前缀的char是utf8编码的，8位，w开头的wchar是utf16的，16位，d开头的dchar是utf32，32位。具体的D语言的数据类型可以参看D语言规范中关于数据类型的部分。

可以看到D语言的语句还是比较面熟的，是最流行的C风格。在之后的“一日一DD”中会继续看代码学D语言的。

代码来自TutorialFundamentals

[Ctrl + r]查找和执行历史命令
[Ctrl + p] 或 [Ctrl + n] 快速向前或向后滚动查找一个历史命令

[Ctrl + a] 跳转至命令行首 Ahead of line
[Ctrl + e] 跳转至命令行尾 End of line

[Ctrl + f] 向前跳转一个字符 jump Forward one character
[Ctrl + b] 向后跳转一个字符 jump Backward one character

[Alt + f] 向前跳转到下一个字的第一个字符
[Alt + b] 向后跳转到下一个字的第一个字符

[Ctrl + w] 向后删除一个字，用来对付刚刚输入的错误字很有用

[Ctrl + u] 从光标当前位置删除所有字符至行首
[Ctrl + k] 从光标当前位置删除所有字符至行尾

[Ctrl + d] 删除光标当前位置的字符

[Ctrl + y] 粘贴最后一个被删除的字

[Alt + d] 删除从光标当前位置，到当前字的结尾字符

Ctrl + l 相当于clear 命令

注意，在GUI下记得把shell的Alt+f快捷键打开菜单栏的选项关掉。。。

参考自：《快速编辑 Shell 命令行》

Blog搬家的感受挺多的，我的Blog一开始是在msn space上，之后就是在BlogJava，后来到了ruby-lang.org.cn（x-space）。我的日志越写越多，越写越能写出些有价值东西（相对论，其实现在写的也很多东西很废，慢慢写慢慢会写）。一边搬家一边看着自己以前写过的日志，感触挺深的。感觉自己长大了，学习了。。。

现在在这里写日志知道怎么办了，贴代码的时候要自己手工加空格（nbsp;），我的code标签的样式是抄ee的，黑底白字的block。

这次搬家的手法比较弱智，是手工一篇一篇搬的，一来是x-sapce不支持输出，二来是自己懒得去研究怎么要把x-sapce的日志导出。。。

下一步要做的就是美化一下这里，改下主题（牢骚一下），写些页面，写下自我介绍。看到标签云真开心。接着可以开始写我的vim和d语言的日志了（本来这几天要写的，就是忙着Blog搬家），ohoh~~

最后一句废话：年轻人选择Blog要慎重，要知道自己的需求是什么，要找个能导出导入（方便搬家），能选择RSS输出的格式的。。。

在网上搜索了一下，能够支持xspace导出的有一个程序，blogbak，试着用了一下，发现这是刚下了一贼船又上另一贼船，虽然的确可以导出xspace的文章出来，但是导出的blog文件只能在它的支持商51XXX上导入。。。

看来要好好看看RSS2.0和Atom的规范还有blogger的api。。。还有把自己的全部文章手动导出来一下。。。

发现有些女生已经嫁了，有些还有孩子了。最近要结婚的一个同学，嫁了一个月收入5W以上的人，这让我什么都说不出。。。貌似现在做销售的就是社会的高薪人士，有些不服气，这些在广州深圳收入过W的人，现在买楼买房，很轻松，哪里想刚刚毕业的学生，几千块的月薪还要扣20%的税，扣完之后你还能剩多少？女生就是嫁得好就好了，有些刚毕业就有人娶的基本不用奋斗了，所以有人说女生要成功直接嫁给Gates就好了。

我呢，还是在花父母的钱的学生仔，去实习，去工作之还要再花父母多少钱，还要奋斗几年才能娶女朋友，还有要奋斗几年才能实现自己的梦想，感觉自己的梦想好像幻想。。。

不行，我要努力。。。要给老婆幸福，要给父母幸福，要实现自己的梦想。。。

第一要努力，第二还是要努力，第三还是要努力。。。

drive2me大哥的意见

享受努力的过程是一大幸福。有些人走捷径就没有这种乐趣。
本来人生就是来享受过程的。对吧。

没有什么可以比的，走自己的路，对自己负责，就好了。

有些幸福的永恒的，而有些是短暂的，把握自己的人才能把握自己的幸福。依靠别人幸福的人，不会永久幸福的。

下午闲着无事，又跑到Ubuntu论坛的吵架版看猴子戏，并且自己也过了一回当猴子的瘾。。。

用Ubuntu下半年了，感觉回到win下有种别扭的感觉。有个喜欢重装suse的同学问我，你平时用Linux做什么？我那时愣了一下，想想回答说，上网。。。

在12月底时就把硬盘中win在玩了一次实况之后删了，因为又用不到win了所以删了。现在在VBox里开win也是上网银或者改doc（在永中里编辑后看看有没有问题）。

最近才看了LFS和Gentoo的文档，知道了它们是怎么安装的，好像都是满麻烦的，把系统里每个部分，包括基本的内核，常用的工具，每个核心的库都自己编译出来。虽然麻烦但是真正的自定义Linux，真正的是玩Linux。有些人说自己整出一个LFS可以用一辈子。。。

现在开始有空的时候就用Ubuntu的apt-get source来自己编译软件和每个库，一个一个编译构建包，试试感觉，等以后换个Gentoo做准备。

其实用什么OS，自己喜欢就好。我想用Linux就用嘛。

我就是喜欢用Linux，因为编码是utf8，因为有多个实用Unix工具，因为写代码的时候完全用鼠标，因为平时WM操作的时候可以尽量不用鼠标，因为不会中病毒，因为不用时不时就清理系统，因为不用重装系统，因为在不同的电脑上只要把硬盘插上就可以用。。。

Ruby Snippets的演示：
http://eustaquiorangel.com/blog/show/438

Rails.vim的演示：
http://www.youtube.com/watch?v=3 … ls%20testing%20ruby

我的插件列表：

vim-ruby gem install vim-ruby –remote && vim-ruby-install.rb
rails.vim
http://www.vim.org/scripts/script.php?script_id=1567
rubysnippets
http://www.vim.org/scripts/script.php?script_id=1966
project
http://www.vim.org/scripts/script.php?script_id=69
NERD_tree
http://www.vim.org/scripts/script.php?script_id=1658
bufexplorer
http://www.vim.org/scripts/script.php?script_id=42
taglist
http://www.vim.org/scripts/script.php?script_id=273
winmanager
http://www.vim.org/scripts/script.php?script_id=95
matchit
http://www.vim.org/scripts/script.php?script_id=39
svncommand
http://www.vim.org/scripts/script.php?script_id=922
surround
http://www.vim.org/scripts/script.php?script_id=1697
supertab
http://www.vim.org/scripts/script.php?script_id=1643

加上上面的插件后，VIM就很好很强大，有rails.vim（目前支持Rails2.0）的跳转和快捷的rake执行等等的优点不用多说了，而vim- ruby则提供了高亮和代码补全等，今天找到的Ruby Snippets就实现了类似Textmate的模板补全（让我眼红了很久的功能）。nerd-tree和bufexplorer，winmanager 组成了一个代码浏览文件浏览的强大功能，svncommand和surround分别提供了svn支持和标签补全。。。

这样的VIM真是很好很强大。。。

上图：

参考的资料：
http://wiki.rubyonrails.org/rails/pages/HowtoUseVimWithRails
http://www.upulife.com/leo/?p=191
http://www.upulife.com/leo/?p=196
http://blog.csdn.net/wooin/archive/2007/10/31/1858917.aspx

合适的缓存机制可以提升Rails应用的性能。而Page Cache就是Rails中最高效的缓存。Page Cahe机制可以让每次请求不用进行数据库查询，甚至不用触动到Ruby解析器，完全由前端web服务器来进行服务。

配置

如果你想在devlopment模式启用cache机制，就需要修改 /config/environments/development.rb文件，找到下面这行并把配置项改为true：
config.action_controller.perform_caching = true
页面缓存

两种很适合缓存页面的情况：

1. 当页面对于所有用户都是相同的
2. 当页面是公开的，而且无须用户认证

假设环境是在一个不经常改动的Blog页面中。。。Controller的代码应该貌似这样：
class BlogController < ApplicationController
  def list
     Post.find(:all, :order => "created_on desc", :limit => 10)
  end
  ...
如果想要缓存list action中显示的页面就在代码中加入：
class BlogController < ApplicationController
   caches_page :list
  
   def list
     Post.find(:all, :order => "created_on desc", :limit => 10)
   end
  ...
这样，在下次请求时就会生成并返回缓存好的list.html页面，下下次的话就是直接返回缓存页面。
如果使用的是mongrel，对list action进行配置后的第一次请求时，/logs/development.log会有貌似以下的记录：
Processing BlogController#list (for 127.0.0.1 at 2007-02-23 00:58:56) [GET]
Parameters: {"action"=>"list", "controller"=>"blog"}
SELECT * FROM posts ORDER BY created_on LIMIT 10
Rendering blog/list
Cached page: /blog/list.html (0.00000)
Completed in 0.18700 (5 reqs/sec) | Rendering: 0.10900 (58%) | DB: 0.00000 (0%) | 200 OK [http://localhost/blog/list]
Cached page: /blog/list.html这行记录表明了页面已被导入，并存放在 /public/blog/list.html 位置下。在这个文件中没有一丁点Ruby代码。下一次请求到来时又会绕过Rails再次返回这个静态页面，这就提升了效率，降低了服务器的开销。

这样的话，如果是有动态表单的页面和经常更新的页面，Page Cache就不太适合了。不过还可以采用其它的缓存机制，请留意本教程的Part2。（卖广告:>）
如果在代码里再加上这一句：
caches_page :show
当URL指向/blog/show/5访问id为5的blog日志时，请问调用的是哪个缓存文件（或其文件名为什么）？
答案是：/public/blog/show/5.html
看看下面的例子（URL和对应的缓存文件）：
http://localhost:3000/blog/list => /public/blog/list.html
http://localhost:3000/blog/edit/5 => /public/edit/5.html
http://localhost:3000/blog => /public/blog.html
http://localhost:3000/ => /public/index.html
http://localhost:3000/blog/list?page=2 => /public/blog/list.html
伊，等等，不太对阿。第一行和最后一行怎么返回的缓存文件一样？Page Cache忽略了URL附带的参数了。

在采用分页的页面怎么使用Page Cahe

要缓存不同的文件，只能创建不同格式的URL了。使用“/blog/list?page=2”的话会出问题，那就使用“/blog/list/2”吧。这样子的话，数字2就是作为params[:id]了，那就要修改路由规则（/config/routes.rb）了：
map.connect 'blog/list/:page',
    :controller => 'blog',
    :action => 'list',
    :requirements => { :page => /\d+/},
    :page => nil
配合新的路由，页面的链接也要改一下：
<%= link_to "Next Page", :controller => 'blog', :action => 'list', :page => 2 %>
上面这句生成的URL就是“/blog/list/2”了，访问这 URL时会以下两件事会发生：
Rails应用把数字2作为params[:page]
这个页面被缓存为/public/blog/list/2.html
上面这个示例告诉我们，如果要使用PageCache机制的话，那就要对附加参数做一下处理，让附加参数成为URL的一部分。

清理Cache

页面失效了怎么办？那就清理掉失效页面呗！

以下两行代码可以清除上面例子中生成的Cache：
# This will remove /blog/list.html
expire_page(:controller => 'blog', :action => 'list')
# This will remove /blog/show/5.html
expire_page(:controller => 'blog', :action => 'show', :id => 5)
那就要在每次添加/改动/删除blog日志时都进行这些操作。要把这两行代码加入action中吗？不，有优雅的解决方法。。。

Sweepers

Sweepers是一些能在页面失效是删除旧的缓存的代码。Sweepers监视Model的一举一动，当Model进行CRUD时，Sweepers得知后就会去把相应的缓存删除掉。
Sweepers的操作应该放在一个Controller中，而且作者认为还应该与其它的controller分离开。那就要改动配置文件/config/environment.rb：
Rails::Initializer.run do |config|
   # ...
   config.load_paths += %W( #{RAILS_ROOT}/app/sweepers )
   # ...
end
友情提示，改动环境变量之后记得重启服务器。

如上改动后在/app/sweepers创建sweepers，文件 /app/sweepers/blog_sweeper.rb应该是这样：
class BlogSweeper < ActionController::Caching::Sweeper
  observe Post # This sweeper is going to keep an eye on the Post model
  # If our sweeper detects that a Post was created call this
  def after_create(post)
          expire_cache_for(post)
  end
  
  # If our sweeper detects that a Post was updated call this
  def after_update(post)
          expire_cache_for(post)
  end
  
  # If our sweeper detects that a Post was deleted call this
  def after_destroy(post)
          expire_cache_for(post)
  end
         
  private
  def expire_cache_for(record)
    # Expire the list page now that we posted a new blog entry
    expire_page(:controller => 'blog', :action => 'list')
   
    # Also expire the show page, incase we just edited a blog entry
    expire_page(:controller => 'blog', :action => 'show', :id => record.id)<
  end
end
生成Sweepers可以使用插件Sweeper Generator，可以参看martin的介绍。

友情提示：用after_save方法可以代替上面的after_create和after_update两个方法。
要调用Sweepers，在文件/app/controllers/BlogController.rb中应这些写代码：
class BlogController < ApplicationController
   caches_page :list, :show
   cache_sweeper :blog_sweeper, :only => [:create, :update, :destroy]
   ...
当创建一个Blog日志时，会在 logs/development.log中发现这样的记录：
Expired page: /blog/list.html (0.00000)
Expired page: /blog/show/3.html (0.00000)
hoho~ sweepers生效了。

在Apache/Lighttpd的漂亮演出

许多Rails应用都会使用Apache作为前端，用Mongrel / Lighttpd处理动态的RoR请求。要使Rails的Page Cache机制生效，告诉服务器当请求来的时候去哪里查找缓存页面。下面是配置Apache为例，修改httpd.conf文件：
<VirtualHost *:80>
  ...
  # Configure mongrel_cluster
  <Proxy balancer://blog_cluster>
    BalancerMember [url]http://127.0.0.1:8030[/url]
  </Proxy>
  RewriteEngine On
  # Rewrite index to check for static
  RewriteRule ^/$ /index.html [QSA]
  # Rewrite to check for Rails cached page
  RewriteRule ^([^.]+)$ $1.html [QSA]
  # Redirect all non-static requests to cluster
  RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
  RewriteRule ^/(.*)$ balancer://blog_cluster%{REQUEST_URI} [P,QSA,L]
  ...
</VirtualHost>
在lighttpd中应该是类似这样：
server.modules = ( "mod_rewrite", ... )
url.rewrite += ( "^/$" => "/index.html" )
url.rewrite += ( "^([^.]+)$" => "$1.html" )
这样代理服务器就会/public目录下查询cache文件，这样你可能会想要修改cache文件的目录。

把Cache文件分离处理

首先这样修改/config/environment.rb：
config.action_controller.page_cache_directory = RAILS_ROOT + "/public/cache/"
这样就让Rails在/public/cache/ 下生成缓存文件了。接着就修改前端服务器Apache的配置文件httpd.conf：
  # Rewrite index to check for static
  RewriteRule ^/$ cache/index.html [QSA]
  # Rewrite to check for Rails cached page
  RewriteRule ^([^.]+)$ cache/$1.html [QSA]
清理单个局部或者全部缓存

当开始使用页面缓存的时候可能会发现，一旦对模型有CRUD操作，基本上所有的缓存都要被清除掉。那直接删除了生成的缓存文件岂不是更好更快。

首先要把cache文件分离出来，这在上一步已经做了。下面的代码直接删除cache文件夹下的所有文件，并记录事件到日志中：
class BlogSweeper < ActionController::Caching::Sweeper
  observe Post
  def after_save(record)
    self.class::sweep
  end
  
  def after_destroy(record)
    self.class::sweep
  end
  
  def self.sweep
    cache_dir = ActionController::Base.page_cache_directory
    unless cache_dir == RAILS_ROOT+"/public"
      FileUtils.rm_r(Dir.glob(cache_dir+"/*")) rescue Errno::ENOENT
      RAILS_DEFAULT_LOGGER.info("Cache directory '#{cache_dir}' fully sweeped.")
    end
  end
end
FileUtils.rm_r 方法删除目录下所有文件。这就相当于执行了多次的expire操作。也可以删词cache目录的子目录下的文件，如下面代码展示的对 /public/blog目录下所有文件进行删除：
        cache_dir = ActionController::Base.page_cache_directory
        FileUtils.rm_r(Dir.glob(cache_dir+"/blog/*")) rescue Errno::ENOENT
更高级的Page Cache技巧？

在大型Web应用中Page Cache的处理将会是非常复杂的。

Rick Olson写了Referenced Page Caching Plugin用数据库来对缓存页面进行跟踪。README中有一些示例展示。

Max Dunn写了篇文章 Advanced Page Caching，向我们展示了他如何使用cookies动态地改变页面缓存处理基于用户角色的wiki页面。

最后，Page Cache还无法解决缓存xml文件，Mike Zornek讲述了这个问题并提出了一些方法，详见这里。

Page Cache怎么测试？

Rails本身并没有提供给我们。Damien Merenne写了一个插件 swank plugin试图解决这个问题。试一下。

删掉了一些废铁，改了一下主题。又发一下牢骚，这里的界面也不好玩，比起wordpress等那些系统来说，可定制性弱很多，又没有什么吸引人的功能，而且速度太慢了，又不支持firefox。

看到以前自己写的，感觉很多东西都很弱智，竟然还傻乎乎贴了一堆抄书帖和转帖，基本上没有自己发现和理解整理的东西。虽然现在也没有太多有创造性的东西写出来，可是有时做做翻译，做做技术整理总结，比以前算是有进步了。一开始初心者很多东西还是在看别人的，慢慢地积累之后才有自己的想法，慢慢地成长。现在回想起来，感觉自己大学这两年多已经对软件开发入了门。该知道的原理不敢说都懂了都理解了，只能说基本都了解，知道自己欠缺什么，应该学习哪些，未来的路子和方向也明朗了。

也看到了自己的感情生活的经历，其实自己的感情也是经历了很多，我希望能和老婆婷婷继续走下去，坚持到毕业，再坚持到能够有地方住，然后就能结婚了。因为现在的楼价物价都是很高的，所以我要更加努力才能养地起一个家。现在才懂事，才知道爸爸妈妈是多么伟大，多么厉害，我的爸爸一个人担负起了整个家的经济收入，我的妈妈一个人负担起了家里大大小小的事情照顾整家人的起居饮食，他们是最伟大的，我爱我的爸爸妈妈。我希望以后能和爸爸一样养起整个家，有能力像妈妈照顾家庭。这些好像是小学生说的话，但是这真的是发自我内心的。

我要每天都比昨天进步，每天有收获，成为一个对社会有用的人。

本教程的编写顺序是按照各个缓存的效率来排序的，Page缓存最快，所以在第一篇教程就介绍了，这篇教程就介绍其它的几种缓存。

Action 缓存

Action缓存和Page缓存十分相似，唯一的区别就是对页面的请求会触及Rails服务器并且filter还是会运行。类似下面代码这样设置Action缓存：
class BlogController < ApplicationController
  layout 'base'
  before_filter :authenticate  # <--- Check out my authentication
  caches_action :list, :show

可以从代码中看到，用户必须通过认证才能访问list action，当对list进行请求时可以从 /log/development.log看到如下日志
Processing BlogController#list (for 127.0.0.1 at 2007-03-04 12:51:24) [GET]
Parameters: {"action"=>"list", "controller"=>"blog"}
Checking Authentication
Post Load (0.000000) SELECT * FROM posts ORDER BY created_on LIMIT 10
Rendering blog/list
Cached fragment: localhost:3000/blog/list (0.00000)
Completed in 0.07800 (12 reqs/sec) | Rendering: 0.01600 (20%) | DB: 0.00000 (0%) | 200 OK [http://localhost/blog/list]
看到“Cached fragment: localhost:3000/blog/list”这行了吗？这表示有缓存文件生成，并且可以找到如下这个文件：
/tmp/cache/localhost:3000/blog/list.cache
默认的情况是， Action缓存会在/tmp/cache/目录下缓存文件，而不是像Page缓存那样直接输出.html文件，是输出.cache文件。如果你在单个应用中包含了一个以上的自域名，缓存文件的路径会包含主机和端口（localhost:3000）。这种情况下每个自域名会缓存在各自的目录下。

如果打开“list.cache”文件，就会看到其中的内容是完整的静态html页面，就像Page缓存的一样。那它们之间有什么区别呢？如果我们再次对页面做出请求（经过上面的请求之后），来看看/log/development.log：
Processing BlogController#list (for 127.0.0.1 at 2007-03-04 13:01:31) [GET]
Parameters: {"action"=>"list", "controller"=>"blog"}
Checking Authentication
Fragment read: localhost:3000/blog/list (0.00000)
Completed in 0.00010 (10000 reqs/sec) | DB: 0.00000 (0%) | 200 OK [http://localhost/blog/list]

如你所见， 前置过滤器Authentication执行了，接着读取了缓存文件，然后输出。所以在这个情况下，依然是输出那个完整的缓存文件，并且还做了用户认证的检查。

这里值得注意的是，action执行前前置过滤器必须被执行。另一方面，你也可能会缓存到一个错误的html文件。

怎样清理Action缓存

如教程Part1中，缓存必须在数据发生变化后被清除掉。这里也是用sweepers，只不过在/app/sweepers/blog_sweeper.rb中”expire_page” 要改为 “expire_action”：
# Expire the list page now that we posted a new blog entry
expire_action(:controller => 'blog', :action => 'list')
# Also expire the show page, incase we just edited a blog entry
expire_action(:controller => 'blog', :action => 'show', :id => record.id)

也可以用以下的rake任务来清除 Action 缓存和 Fragment 缓存：
rake tmp:cache:clear
这个rake任务会删除所有的.cache文件。

Fragment Caching

使用了缓存之后会让应用变得飞快，但是由于这是动态的web应用，缓存整个页面并且总能命中这是不实际的，所以有了Fragment缓存。Fragment缓存能缓存页面中的一部分。

要对Blog应用中Post列表进行Fragment进行缓存就要编辑 /app/views/blog/list.rhtml：
<strong>My Blog Posts</strong>
<% cache do %>
<ul>
<% for post in @posts %>
<li><%= link_to post.title, :controller => 'blog', :action => 'show', :id => post %></li>
<% end %>
</ul>
<% end %>

这段cache do的代码会创建文件/tmp/cache/localhost:3000/blog/list.cache，即使用当前的controller和action来进行命名。当下次请求来到并命中cache do部分的代码时就会读取刚刚说到那个缓存文件。让我们查看/log/development.log，来看看第一次和第二次请求中发生了什么：
Processing BlogController#list (for 127.0.0.1 at 2007-03-17 22:02:16) [GET]
Authenticating User
Post Load (0.000230) SELECT * FROM posts
Rendering blog/list
Cached fragment: localhost:3000/blog/list (0.00267)
Completed in 0.02353 (42 reqs/sec) | Rendering: 0.01286 (54%) | DB: 0.00248 (10%) | 200 OK [http://localhost/blog/list]
Processing BlogController#list (for 127.0.0.1 at 2007-03-17 22:02:17) [GET]
Authenticating User
Post Load (0.000219) SELECT * FROM posts
Rendering blog/list
Fragment read: localhost:3000/blog/list (0.00024)
Completed in 0.01530 (65 reqs/sec) | Rendering: 0.00545 (35%) | DB: 0.00360 (23%) | 200 OK [http://localhost/blog/list]
有没有感觉到一些冗余？
在第一次请求时生成了缓存，第二次时读取缓存，但是对Posts的SQL查询进行了两次。我们已经对SQL查询的结果缓存到页面中了，我们在缓存之后不用再进行SQL查询了，是吗？

解决这个问题的其中的一个方法就是编辑/controllers/blog_controller.rb，在查询前加上一个条件检查：
def list
unless read_fragment({})
@post = Post.find(:all, :order => 'created_on desc', :limit => 10) %>
end
end
现在只会在没有缓存的时候才有查询出现。或者有人会想，把这个请求放到view中的cache do代码块中不就好了吗？但是这个是MVC架构啊。

猜猜怎样清除Fragment缓存

# Expire the blog list fragment
expire_fragment(:controller => 'blog', :action => 'list')
没错吧？

在分页中使用Fragment缓存

默认情况下，缓存的命名是通过直接查找当前的controller和action名字来决定的。也就是说controller 为 “blog”并且 action 为 “list”就会缓存到 “/localhost:3000/blog/list.cache”。

在分页的情况下，就要把分页的页码加到缓存文件中。blog_controller.rb应该类似下面那样处理：
def list
unless read_fragment({:page => params[:page] || 1}) # Add the page param to the cache naming
@post_pages, @posts = paginate :posts, :per_page => 10
end
end
在这里代码也可以为：read_fragment({:controller => ‘blog’, :action => ‘list’, :page => params[:page] || 1})，但Rails决定了前两个参数，这个无法改变，所以可以省略。

/views/blog/list.rhtml如下：
<% cache ({:page => params[:page] || 1}) do %>
... All of the html to display the posts ...
<% end %>
这段代码会在第一次访问 /blog/list时，会创建 /localhost:3000/blog/list.page=1.cache 的缓存文件，按理可知访问分页2时会创建缓存文件/localhost:3000/blog/list.page=2.cache。 Pretty cool!

对Fragment缓存高级命名机制

大多数时候要对cache进行命名，这里有个示例：

话说现代的Web设计中每个页面都有一个用户自定义的导航目录（nav menu）。这里是一个列出用户要完成的项目任务（task）的导航目录：
<div id="nav-bar">
<strong>Your Tasks</strong>
<ul>
<% for task in Task.find_by_member_id(session[:user_id]) %>
<li><%= task.name %></li>
<% end %>
</ul>
</div>
这个会在站点的每个页面中显示，如果能在用户第一次访问页面时缓存起来，在之后的访问就不用总是打扰数据库了。那就要对代码进行一点点改动：
<div id="nav-bar">
<strong>Your Tasks</strong>
<% cache (:controller => "base", :action => "user_tasks", :user_id => session[:user_id]) do %>
<ul>
<% for task in Task.find_by_member_id(session[:user_id]) %>
<li><%= task.name %></li>
<% end %>
</ul>
<% end %>
</div>
当user_id为1时会创建缓存文件/localhost:3000/base/user_tasks.user_id=1.cache。

Fragment缓存命名示例
这里有些用户命名缓存的例子：
cache ("turkey") => "/tmp/cache/turkey.cache"
cache (:controller => 'blog', :action => 'show', :id => 1) => "/tmp/cache/localhost:3000/blog/show/1.cache"
cache ("blog/recent_posts") => "/tmp/cache/blog/recent_posts.cache"
cache ("#{request.host_with_port}/blog/recent_posts") => "/tmp/cache/localhost:3000/blog/recent_posts.cache"
怎样一次sweep多个缓存

上面的分页的Fragment缓存最后生成了很多缓存文件，已知的清除方法只是：
expire_fragment(:controller => 'blog', :action => 'list', :page => 1)
expire_fragment(:controller => 'blog', :action => 'list', :page => 2)
expire_fragment(:controller => 'blog', :action => 'list', :page => 3)
.....
但是这里还有一个方法来做这些事情：
expire_fragment(%r{blog/list.*})
这样会查找blog/list下的所有cache文件。使用这个方法要明白下面几点：
1. 不能在Memcached（下面会提到）下运行。
2. 这种方法会对所有的cache文件进行正则匹配，如果你的系统中有4,000+个cache文件，这会让你的系统处理很久。
3. 如果你不慎写错了正则表达式，那可能会出大问题。

Action/Fragment缓存的几种缓存机制

Page 缓存只能使用文件系统。Action 和 Fragment缓存就有几种选择：
1. File Store – (默认) – 把缓存放在磁盘中 (默认在 /tmp/cache/ 目录)。
2. Memory Store – Rails服务器的处理方法，放在内存。
3. DRb Store – 使用DRb服务器。
4. MemCache Store – MemCache是一个高性能的缓存处理程序。注意它不是用Ruby实现的。

作者认为FileStore是一开始最好的选择，在以后升级为其它的方式（如MemCache）也不难，要改变缓存文件存储的位置可以编辑config/environment.rb：
ActionController::Base.fragment_cache_store = :file_store, "/path/to/cache/directory"
ActiveRecord查询缓存

这是第四种缓存机制，对这种机制并没有过多的文档，它只出现在 Rails Edge中，现在来介绍一下。

ActiveRecord并不需要做配置，在默认情况下会自动运行。看看这个action：
class BlogController < ApplicationController
def some_complex_thing
post = Post.find(1)
# .... Do alot of other stuff
post_again = Post.find(1)
end
end
在没有AR缓存的情况下，SQL查询会进行两次。现在使用了AR缓存后，在第二次的查询会读取第一次查询时生成的缓存。这样就不用担心在单个的Action中两次相同的查询会查询数据库两次了。

不过这里的例子不够直观，但想像复杂的认证代码。很多时候可能会在多种认证方式中进行用户数据的查询，而且这是发布在几个不同地方的代码中的，如果缓存了结果，无疑对性能有提高。

查询缓存在action中第一次查询时缓存，在action结束时清除掉缓存。这里没有真正的存储，当 inserts/updates/deletes 执行时，全部缓存就会刷新。如果你要在多个actions或users间缓存数据，请使用MemCache。

参考：
关于fragment缓存的失效可以参看martin推荐的timed_fragment_cache插件
关于AR的缓存，可以看看这篇文章的，这篇文章yudi有翻译。

其中采用的方法都类似于《Agile Web 2e》的dopet示例的处理方法：

• 通过虚拟的password属性来作为密码
• 通过随机生成的salt和密码明文（或者MD5等方法）加密后存入数据库
• 在controller中通过before_filter来阻止未通过认证的用户对action进行调用
• 在view中通过如islogin?，isadmin?等方法来让保护需要登录或者为管理员的行为

插件中一般都是做出一个Model和两个Controller，处理用户数据的User。而Controller，一个负责登录和登出，另一个User的负责用户创建和删除。

关于记住用户状态的实现，大部分用户认证的插件都有。参考User+authentication+in+Ruby+on+Rails：
添加一个cookie_hash字段到user中：
class AddUserCookieHash < ActiveRecord::Migration
 def self.up
  add_column :users, :cookie_hash, :string
 end
 def self.down
  remove_column :users, :cookie_hash
 end
end
接着在登录页面，如login.html.erb中，加入：
remember me
然后在管理login的controller中添加：
def login
 if request.post?
  @user = User.find_by_username(params[:login])
  if @user and @user.password_is? params[:password]
   session[:uid] = @user.id
   # 当用户需要被记住时，开始对cookie进行处理
   # 对cookie生成一个密钥之后放入cookie和存入数据库（user表中）
   # 其中还指定了一个cookies失效时间，默认为30天，其实可以把这个参数提出来
   if params[:remember]
    cookie_pass = [Array.new(9){rand(256).chr}.join].pack("m").chomp
    cookie_hash = Digest::MD5.hexdigest(cookie_pass +     @user.password_salt)
    cookies[:userapp_login_pass] = { :value => cookie_pass, :expires => 30.days.from_now }
    cookies[:userapp_login] = { :value => @user.username, :expires => 30.days.from_now }
    User.update(@user.id, :cookie_hash => cookie_hash)
   end
   redirect_to :controller => 'panel', :action => 'secret'
   else
    @auth_error = 'Bad username or password'
   end
  end
 end
最后在ApplicationController中加入：
session :session_key => '_userapp_session_id'
before_filter :check_cookie
def check_cookie
return if session[:uid]
if cookies[:logowanie_login]
@user = User.find_by_username(cookies[:userapp_login])
return unless @user
cookie_hash = Digest::MD5.hexdigest(cookies[:userapp_login_pass] + @user.password_salt)
if @user.cookie_hash == cookie_hash
flash[:info] = 'You\'ve been automatically logged in' # annoying msg
session[:uid] = @user.id
else
flash[:error] = 'Something is wrong with your cookie'
end
end
end
而关于角色的认证可以使用插件：ActiveRBAC

CSS其实不难理解，但是实际操作和设计上，就要依靠个人的艺术嗅觉和想像力了，看来我没有这方面的天赋。

说说blog的问题，这里的二级域名失效了，要去问问sky怎么了。想去找其它的blog系统，wordpress.com提供的wordpress没有加上代码高亮系统， google提供的blogger国内访问不到它的二级域名，又不喜欢javaeye的blog，也不想回到以前的blogjava那个系统（感觉自己的 blog会淹没在那一堆抄书帖和转帖中）。最好的还是自己去租个空间，用个Mephisto或者typo 系统，这样还可以练习自己配置和管理Rails应用的能力。

文中有实验性标记的说明很可能会在短时间内被拿掉，原文中解释为”crazy ideas“。
最近将持续连载翻译Ruby1.9的变化。

新的语法和语意

新的字面量hash语法[Ruby2]
{a: "foo"}                # => {:a=>"foo"}
代码块局部变量 [实验性]

如下使用:
# {normal args一般参数; 局部变量local variables}
d = 2
a = lambda{|;d| d = 1}
a.call()
d                # => 2
当一个变量被隐藏时，Ruby1.9会给出一个警告:
-:2: warning: shadowing outer local variable - d
代码块参数的作用域总是在代码块内
a = 1
10.times{|a| } # !> shadowing outer local variable - a 代码块外的局部变量a被隐藏
a                                                 # => 1
新的lambdas语法 [非常实验性]
a = ->(b,c){ b + c }
a.call(1,2) # => 3
注意这里没有说是替换目前传统的代码块语法。Matz已经明确说明了后者会永远有效。新的语法允许为代码块参数指定默认值，如 {|a,b=1| ... } 这种语法在目前的基于bison的Ruby解析器LALR是不能实现的.

这种新语法可以不用括号包裹参数:
-> { }.call # => nil
-> a, b  { a + b }.call(1,2) # => 3
c = 1; -> a, b; c  { c = a + b }.call(1,2); c # => 1
还可以更加诡异地使用:
c = 2; -> ;c { c = 1 }.call; c # => 2
甚至是
c = 2; -> *d ; c { d }.call(1,2,3) # => [1, 2, 3]
c = 2; -> ; c { c = 1 }.call; c # => 2
用.()替代使用call方法或者[]方法来调用Procs[实验性]

现在可以这样做:
a = lambda{|*b| b}
a.(1,2)                # => [1, 2]
注意你需要句点:
a = lambda{|*b| b}
a(1,2)                # =>
               #           (eval):2: syntax error...
               #                         (a)(1,2)...
~> -:2: undefined method `a' for main:Object (NoMethodError)
可以在括号内使用任何表达式:(lambda{|a,b| a + b}).(1,2)                # => 3
.()用法会无视接受者而调用其call方法:
"foo".(1,2)   # ~>  undefined method `call' for "foo":String (NoMethodError)
Block arguments代码块参数

代码块可以使用&block参数:
define_method(:foo){|&b| b.call(bar)}
ruby-dev:23533

新的代码块参数语意

|v|现在会像|v,|的形式工作:
[RUBY_VERSION, RUBY_RELEASE_DATE]                 # => ["1.8.5", "2006-08-25"]
def m; yield 1, 2; end
m{|v| v}                                          # => [1, 2] # !> multiple values for a block parameter (2 for 1)
相对应的：
[RUBY_VERSION, RUBY_RELEASE_DATE]                 # => ["1.9.0", "2007-08-03"]
def m; yield 1, 2; end
m{|v| v}                                          # => 1
to_splat 方法使用*参数
用to_splat方法代替to_a方法

nil.to_splat 返回 [].

允许多个*操作符

经Audrey Tang建议，Ruby1.9允许在方法调用是使用多个*操作符
   def foo(*a)
     a
   end
   
   foo(1, *[2,3], 4, *[5,6])                        # => [1, 2, 3, 4, 5, 6]
表达式也是：
[RUBY_VERSION, RUBY_RELEASE_DATE]                # => ["1.9.0", "2007-08-03"]
a = [1,2,3]
b = [4,5,6]
[*a, *b]                                         # => [1, 2, 3, 4, 5, 6]
允许在可选参数后加上必要参数

ruby-dev:29014
   def m(a, b=nil, *c, d)
     [a,b,c,d]
   end
   m(1,2)                                         # => [1, nil, [], 2]
?c的语意

?a现在返回一个单字符字符串代替原来的整数值: ?a   # => "a"
[] 方法的参数

可以在[]方法中使用星号，”assocs”(不用方括号的hash)和代码块参数:
   RUBY_VERSION                                       # => "1.9.0"
   RUBY_RELEASE_DATE                                  # => "2006-06-11"
   class Foo; def [](*a, &block); block.call(a) end end
   
   a = (0..3).to_a
   Foo.new[*a, :op => :+]{|x| x }                     # => [0, 1, 2, 3, {:op=>:+}]
printf风格的格式化字符串(%)
%c 可以输出单字符字符串
%u 为负数提供类似%d的格式 (ruby-core:11575)

允许三元运算符( ? : )扩展到新行
p 1 == 2 ?
   0
   :
   1
# >> 1
ruby-dev:29189

defined?方法和局部变量
RUBY_VERSION                                      # => "1.8.5"
RUBY_RELEASE_DATE                                 # => "2006-08-25"
a = 0
defined? a                                        # => "local-variable"
1.times do |i|
  defined? i                                      # => "local-variable(in-block)"
end
相对应的：
RUBY_VERSION                                      # => "1.9.0"
RUBY_RELEASE_DATE                                 # => "2007-08-03"
a = 0
defined? a                                        # => "local-variable"
1.times do |i|
  defined? i                                      # => "local-variable"
end

本文是之前NetBean6关于Ruby部分的教程（http://www.ruby-lang.org.cn/forums/thread-1896-1-1.html）其中的一个例子，如何在10分钟创建一个Weblog的升级版。我会把和之前的不同之处用蓝色标记出来

Rails2.0到来之后带来了很多新的特性，新的变化，这样就导致了以前大量的Rails1.2.X的示例无法在升级到Rails2.0之后运行。 NetBeans6关于Ruby部分的教程中的例子就是这样，由于之前采用的是Rails1.2.5还有ActionController的脚手架方法（scaffold），这些与Rails 2.0并不兼容，故作者写了一篇文章，也就是之前那篇的升级版，一边学习Rails 2.0的新特性新变化，一边修改例子。

首先创建一个Rails项目，这个和以前一样，也就是File > New Project，名字取weblog2.0吧，具体参考上面提到的那篇旧的文章！

创建出项目后自动打开database.yml，真是神奇，NB6竟然帮我们修改好了，使用了以前默认的MySQL，莫非它知道我们对MySQL比较熟？配置一下用户名和密码吧。然后就右键点击项目选择Rake Task => db => create来创建数据库。

接着开始使用Rails 2.0的脚手架创建Model和Controller。右击项目后选择Generate，接着在下拉列表中选择scaffold，再在Model栏中输入Post title:string。注意在Rails 2.0下不能在此对话框的Controller和Action栏里填入字符。这样就创建好了Post model和PostsController还有相关的view（可以看到后缀都改为.html.erb了）。在生成的迁移任务（migrate）中可以看到Rails 2.0的新脚手架已经帮你填好了，如下代码：
# db/migrate/001_create_posts.rb
class CreatePosts < ActiveRecord::Migration
  def self.up
    create_table :posts do |t|
      t.string :title
      t.timestamps
    end
  end
  def self.down
    drop_table :posts
  end
end
那就直接可以运行migrate了，和之前一样，右击项目=> Migrate Database => To current version，或者 Rake Task => db => migrate。
接下来就可以运行一下看看这个应用了。不过先要修改默认路由，注释掉默认路由（welcome），然后添加新的路由:
# config/routes.rb
# map.root :controller => "welcome"
map.root :controller => "posts"
Rails 2.0脚手架默认生成的规则是REST的，以后添加自定义的Controller的Action要用REST化的方式编写路由。这里可以看到用的也是 具名路由，map.root。接着删除了public/ index.html后按下NB6工具栏上面大大的三角形运行服务器，这就可以用浏览器打开那localhost:3000看到我们刚刚完成的一切了。

按照之前的教程里，下一步就是添加Post的字段。右击Database Magrate => Generate，接着在Argument栏中填入AddBodyToPost body:text。这样Rails 2.0又帮我们写好了migrate任务，剩下的就是执行migrate任务。添加了新的字段后，就要修改view了，让我们再次打开Generate对话框，在下拉框中选择scaffold，在Model栏输入Post title:string body:text –skip-migration，并且这次要在下面的单选按钮中选择overwrite。然后就可以打开浏览器看看生效了没有。

下一步就是让Rails对创建Post时进行输入校验。这里展示的是对Post的属性进行非空校验，在Post Model源码（ap
p/model/post.rb）中新建一行，输入vp再按tab，NB6的模板完成功能就体现了，vp自动扩展为 validates_presence_of，那接着就输入:title, :body。（由此可得vu就是 validates_uniqueness_of，试了一下，果然，具体模板完成请看NB6中选项里关于模板的部分）下来就是打开浏览器试验一下。

最后一步就是稍微打扮一下weblog，打开app/view/posts/index.html.erb，把文件里的内容替换为以下内容：
<h1>The Ruby Blog</h1>
<% @posts.each do |post| %>
  <h2><%= post.title %></h2>
  <p><%= post.body %></p>
  <small> <%= link_to 'Permalink', post_path(post) %></small>
  <hr>
<% end %>
<br />
<%= link_to 'New post', new_post_path %>
最后就是让Posts按时间顺序显示，把上面第3行代码改为：
<% @posts.reverse.each do |post| %>
可以看到在视图中，新的脚手架创建的这句代码<%= link_to ‘New post’, new_post_path %>中的new_post_path，这是Rails2.0中REST化的体现之一。另外，原文中第6行代码还是以前那种写法，也就是指定controller和action的写法，我改了过来，让它和下面New Post的写法统一，我在原文下面留言提了这个。

很多同学都有问我，Rails升级到2.0后NB6中关于Ruby的这个10分钟创建weblog的教程怎么做，这里就是答案。有什么错误请大家指出来哦。

回到家里觉得少了安全感，回来那天上楼时发现一家人给入室盗窃了，又听说几个月前对面那栋楼也给入室了。

小区里的大树都给锯了，整个小区有种和以前不同的感觉，凄凉的感觉。。。

寒假开始了，又有一堆时间要自己支配，自己学习。要实现自己在一个月前定下的计划。

给自己加油！

励志类：
《高效能人士的七个习惯》《要事第一》，科维的两本修身的书。

技术类：
《RESTful Web Services》，深入认识REST，这本书的大部分例子都是用rails写的。DHH作序推荐的。

《JavaScript高级程序设计》，是时候看看JS了，不懂JS的话，做Web开发是有点辛苦。

还有把《Rails Cookbook》的笔记整理出来。

官方主页：http://code.macournoyer.com/thin/

thin是个合成品，分别使用了来自mongrel的解析器，Every Machine的网络IO库，Rack的web服务器和Ruby框架的接口。

也就是说thin有mongrel的速度和安全性，有Every Machine的高伸缩性，性能和稳定性。

那如何在你的Rails中使用thin呢？

首先安装thin：
gem install thin
然后要运行thin服务器就在你的根目录下执行：
thin start
运行成功：
>> Thin web server (v0.5.0)
>> Listening on 0.0.0.0:3000, CTRL+C to stop
另外一个运行thin的方法（通过Rack的rackup命令）：
在你的Rails应用根目录下创建一个名为config.ru的文件：
require 'rubygems'
require 'thin'
app = proc do |env|
  [ 200, { 'Content-Type' => 'text/html' }, ['hi'] ]
end
run app
然后就执行
rackup -s thin
这样也可以运行thin服务器。

本文相关资料：
http://code.macournoyer.com/thin/
http://mongrel.rubyforge.org/
http://rubyeventmachine.com/
http://rack.rubyforge.org/

另：
Rack支持的服务器：

•     Mongrel
•     Mongrel/Swiftcore
•     WEBrick
•     FCGI
•     CGI

对岸的同学的讨论：
http://lightyror.thegiive.net/2008/01/thin-mongrel-app-server.html

下载地址：http://svn.rubyonrails.org/rails/plugins/

列表

• account_location/
• acts_as_list/
• acts_as_nested_set/
• acts_as_tree/
• atom_feed_helper/
• auto_complete/
• continuous_builder/
• deadlock_retry/
• exception_notification/
• http_authentication/
• in_place_editing/
• javascript_test/
• legacy/
• localization/
• open_id_authentication/
• scaffolding/
• scriptaculous_slider/
• ssl_requirement/
• token_generator/
• tzinfo_timezone/
• tztime/
• upload_progress/

1. 安装配置文件，复制dmd/bin/dmd.conf到 /usr/local/bin下。
2. 为dmd/bin下的这几个文件添加执行权限，dmd,dumpobj,obj2asm,rdmd。
3. 安装编译器，复制上面的几个文件到 /usr/local/bin。
4. 安装lib，复制dmd/lib/libphobos2.a 到 /usr/local/lib。
5. 安装源码，复制dmd/src/phobos到/usr/local/src。
6. 安装man，复制dmd/man/man1下的所有文件到/usr/local/man/man1下。

这样就OK了。

dmd.conf也可以放在/etc下不过要把lib和src的路径改为绝对路径，原文件中的路径是用%@P%来标示当前路径。

测试一下编译，没有报找不到文件就OK了。

其实D语言也是红色的。。。D语言应该是接任 Java和C#的下个静态语言王者。现在几个主流的编辑器都支持D语言，比如vim，emacs，scite。

dmd中带的几个例子中有几个是只能在windows下运行的，有点不爽。

D语言的几个资源：
http://www.digitalmars.com/d/index.html
http://www.dnaic.com/d/doc/d/index.html
http://www.dsource.org

下载Typo 后解压。

1. 在lang目录下新建一个zh_CN.rb文件，然后仿照 lang中的其它文件进行翻译。
2. 在ApplicationController类中添加这行：& nbsp; Localization.lang = ‘zh_CN’。

这样就OK了。

我用 de_DE.rb来汉化，汉化了70%左右，算是个半成品，还没有怎么校对过。

对于上面的言论，我想每个Linux Fan都会听到很不爽，包括我。不是不爽windows和Linux比较，是不爽她的无知。其实又提界面的这个常见的口水战主题的话，讲太多也是没意义的。只是她不是那同个时代的东西来比较，根本没有可比性，RedHat Linux 9同时间段的微软windows产品是windows 2000（或者NT），界面一比校，色盲都看得出哪个好看。到了现在的“畏死它”和同时期的装上了Bery和Compiz的Ubuntu，这次无论在性能上还是在美观上，还是Linux领先，而且不止领先一个身位。每次她都是提到X-window都是叫做“X-windows”，我前两次都是说出来纠正一下，她基本不理会我的意见，后来基本我习惯了，觉得算了。基本上看国外的视频教程，他们都是用Mac OSX或者Linux的，我上次也在一篇文章里说过，一个不经常用Linux外国佬他竟然懂得很多很多Linux的知识。对于外国的学术和教育机构不用 windows的说法我也听说了很多次。为什么中国会这样呢？

这门课的老师是个副教授，还是西电大毕业的研究生。都快50（或者过50）的人了，知识面还那么小，感觉她很多时候都是在误导人。有时不是我喜欢逃课，是去那里听课，听到老师一些讲错的地方实在会让我很难受。我总觉得一个从事计算机相关行业的人，对技术应该体会很深，至少对某个方面应该是很熟的，可是我发现很多老师都没有。有一次某老师在说：“我很喜欢研究编程语言，我懂得很多种语言，比如C啊，C++，Java，Pacal，还有你们应该没有听说的elisp，那是一种编辑器的扩展语言，还有Fortran我也会。其实编程语言都是一样的，差不多的。”我觉得说编程语言都一样的人，一般都不会是个很厉害的人。以后写篇日志讲讲这个。

看到这里看这篇文章的人会问，题目为什么叫“康抽西”？因为这位老师讲到Linux怎么中断程序时，说Ctrl+C的时候就念“康抽西”。

首先checkout出来。
命令语法为 svn co URL dir（会提示输入用户名和密码）URL为svn仓库地址，dir为本地文件夹（即存放checkout出来文件的本地文件夹）

Screenshot-chenk@chen: ~-tmp.png

checkout出来的目录：

Screenshot-repo – 文件管理器.png

然后添加文件进去。（先把要上传的文件复制到对应的文件夹里，然后再执行命令）

Screenshot-branches – 文件管理器.png

执行添加命令：
命令语法为svn add uploadfile

Screenshot-chenk@chen: ~-tmp-repo.png

最后执行commit完成提交。
命令语法为svn ci -m “提交信息”

Screenshot-chenk@chen: ~-tmp-repo-1.png

以后每次更新到最新的版本只要在仓库目录下执行svn update就可以了。

Screenshot-chenk@chen: ~-cn_repo.png

checkout和commit可以简写为co和ci。

要查看版本信息可以执行svn log：

Screenshot-chenk@chen: ~-cn_repo.png

一般我们在中文化工作中要做的就是这些了。

在组织管理上的总结：

• 在管理上不够正规。这主要和我的管理经验不足有关，在学生会里学到的一点点管理经验根本不够。
• 没有能把大家积极性完全调动起来，导致大家讨论不积极。
• 任务的时间控制不好，提交校对时间没有分配好。从第三次任务开始我会定时发邮件通知每个人距离要提交还有多少时间，还有跟进好每个人的情况。
• 对每次翻译任务的分析不到位，每次都是到了翻译完了才能找出一些前期分析不足。这个以后要下点功夫分析翻译的任务，这对翻译的工作将是很好的前期准备，对提高翻译效率和质量有很大帮助。
• 校对任务的分配不到位。以后要重视校对任务的分配还有完成的问题。
• 由于有两处讨论区（google论坛和这里），导致讨论内容分散。以后规定google论坛只负责分配任务和一些通知，讨论集中在论坛。

在翻译上：

• 英文基础不好，很多惯用短语搭配不懂意思。这个我正在看英语短语和搭配。
• 对句型，对介词把握不好。这个还是要靠翻译多一点文章。

在翻译上其实随着翻译的，看的文章多了水平有在慢慢提高着。现在还没有完成的NetBeans6的第二期任务，问题主要是校对上的，校对的速度跟不上，这个我会好好分析一下怎么解决。其实在这个活动中drive2me大哥的帮助和支持是至关重要的，如果没有他的帮忙我真的是搞不起这个活动。不过到目前为止，我还不能做到让大哥满意的工作，无论在管理上还是翻译上，我除了抱歉之外，能做的就是在下次任务中我做得更好。

Reprise – A Minimalistic Blog

这个应用的代码：点这里查看

一个简单的hello world的web应用要写多少代码？用Sinatra只需5行代码：

CODE:

require 'rubygems'
require 'sinatra'

get '/' do
  'Hello World'
endSinatra官方主页：http://sinatra.rubyforge.org/

原文标题：NetBeans IDE 6.0 Ruby Documentation
原文作者：Sun
原文地址：http://www.netbeans.org/kb/60/ruby/index.html

译者：Ruby中文社区翻译团队
译文首发：http://ruby-lang.org.cn/forums/thread-1896-1-1.html

转载请保留本版权信息，违者必究！

下面题目为中文的文章为完成翻译的文章，而视频演示为官网提供的Flash。

10月 2007

教程和演示

配置环境Ruby环境

• Installing and Configuring Ruby Support

使用Ruby编辑器

• Editing Ruby Code [视频演示]
• 代码补全视频演示
• 代码提示和快速修正视频演示

集成Java和Ruby开发

• Mixing Java and Ruby Applications [视频演示]

介绍 Ruby on Rails

• 10分钟内创建一个RubyWeb日志 [视频演示]
• 创建Rails模型类间的关系
• 与Ruby on Rails一起使用Ajax

使用Ruby on Rails做更多的事

• Flickr在Rails中的应用[视频演示]

• Using jMaki With NetBeans Ruby[视频演示]

调试和测试                                

• 调试Ruby代码视频演示
• Test-Driven Rails Development

今天一开场我这边就进了一个，但是很快禁区里手球送了一个点球让他们追平了，后来就给人又进多两个。本来在领先后还有三个机会，一个中柱，两个给对方后卫补了空门。

这是第二次的联赛，也是倒数第二次。大一没有经验打的很烂，大二又没有举行，到现在大三了感觉有机会夺冠了，可以又止步于8强，到了大四的时候体力上应该是跟不上了。反正很失望。

今天我基本上拿不到球，控不到球，传出的威胁球不多，太失败。本来想着天天去练球，结果练到今天还没比赛整条腿就已经很酸痛了。都怪昨天去当裁判，弄完之后看见别人在踢球又去踢了一下，想走的时候看见别人跑步的时候又去跑了几圈。欲速则不达，早知道不要练什么体力了，保留体力好好打比赛更好，今年联赛都没有进球。后悔阿。。

不过这次的联赛里，我班里的人都表现的很团结，我就是喜欢足球的这种团结的气氛。下个星期再和一班来一场友谊赛。联赛没得打了之后时间就比较多了，不用经常去训练，不用经常很累要休息很多，刚好rubyist要开始了可以专心的开发还有做好我的翻译。

联赛出局，心情郁闷中……

由于我的英语基础不好，对于比较口语化的英语，英语的分词，时态，还有介词都处理得不好，遇到它们时我就有点不知所措了：（

drive2me 大哥在指导中，教会了我翻译的几个要点。翻译要注意细节，细节决定成败。英文文章和中文一样，整个文章都是围绕着一个中心，每一句都是和其上下文紧紧相关的，开始觉得之前高中到小学的语文课教的对文章的分析有用了，比如这个词在这里意义不明显，但是结合全文来看这个词的含义就出来了。还有对于句式的处理，比如转折，比较等等，在英文中一两个词就可以表达出来，中文可能要花好几个词还有语气来表达。最后还有一点，要忠于原文，忠于作者原意，作者表达出来的就翻译出来，作者没有说的就不要多加上去。最后这点看上去好像很废话，可是到了真正在翻译时就能理解了。

嗯嗯，就是经验，这对我以后很有帮助。我相信我以后的翻译更好的。组织文档翻译小组是一次机会，一次让我提高的机会，我想我能做好的。

标签: framework, ruby, Ruby on Rails

作者： madpilot

本文由Ruby中文化团队的Maninred翻译，转载请注明出处，谢谢合作。< br>
原文链接：
http://www.sitepoint.com/blogs/2 … res-multiple-views/

下一个主要版本的Ruby on Rails（指2.0）加入了复合视图这个新特性。大约上个月底，预览版发布了，我有幸试用了一下，我想及时地概述一下一些新特点。

复合视图

在rails 1.2中，支持多种数据类型的respond_to块被引入，它可以轻松地支持象XML或者JSON。你需要做就是像下面这样：

CODE:

def index
@stories = Story.find :all
respond to { |format|
format.html {}
format.xml {
render :xml => @stories.to_xml
}
format.json {
render :json => @stories.to_json
}
}
end然后在浏览器上，如果你加上了扩展文件（比如/stories/index.xml）并得到包括请求格式的内容，那么你可以在environment.rb文件的最后添加MIME::Type.register，来创建自定义的类型。

这种做法的一个问题是，基于扩展文件这种方式没有办法支持不同的HTML页面。因为MIME::Type解析器工作方式是，添加其他MIME类型为 text/html的内容标识（handler）会扰乱默认的标识（handler），这意味着上面的代码会提供错误的视图。

输入Mime::Type.register_alias

现在你可以告诉Rails用HTML响应你希望使用的多种文件类型。就是说你想设计一个mobile版本和iPhone版本的站点，你能通过添加下面的代码到/config/initializers/mime_types.rb文件创建两个新的格式：

CODE:

Mime::Type.register_alias "text/html", :iphone
Mime::Type.register_alias "text/html", :mobile这使下面代码可以运作:

CODE:

def index
@stories = Story.find :all
respond to { |format|
format.html {}
format.xml {
render :xml => @stories.to_xml
}
format.json {
render :json => @stories.to_json
}
format.iphone {
// Serve up the iPhone version
}
format.mobile {
// Serve up the mobile version
}
}
end当然，必须在每个respond_to代码块用手工提交不同的版本的做法不太符合DRY原则，所以已经为所有的视图文件创建了一种新的命名惯例。相对于在上面的index.rhtml中调用视图文件，根据你要使用的方式建立三种不同的版本的视图文件更好，比如， index.html.erb, index.iphone.erb 和 index.mobile.erb。

当rails找到一个匹配的视图就使用它;当找不到时就使用默认的.html.erb或者.rhtml文件。这让你的站点方便地用不同的版本的视图提供服务。

PS：
这篇文章有drive2me大哥帮我校对，谢谢drive2me帮我耐心地讲解，和校对。

今晚看了Rail cookbook，看了第六章，讲REST的，每个Recipe都有一个生动的例子做解释，代码最具表现力的。过几天想把这一章翻译出来，放在论坛给大家看看。还有这本书感觉上和《Rails Recipes》很类似，虽然Recipes只是粗略地浏览一下而已，不过感觉是一样的。Cookbook和Recipes配合着《滑板之道》一起看好像效果比较好，因为Rails的每个特性，都在这两本书上有很好应用示例。这样的书里的只是很容易应用到实际开发上，嗯，实用主义。

Ruby Cookbook也是比较实用，我买这本书的用意就是想看看很多api的例子。我自己在写一个叫RStyle的项目，现在才0.1，是个代码格式化器，里面涉及了一个代码分析器。在写代码分析器时，我开始有点不知所措了，所以想找点Ruby编程的书看看，好像《Ruby Way》这本书里讲的一些数据结构也挺适合的，嗯下次买这本。还没有开始看，应该会很有趣。

《HF设计模式》就是我垂涎已久的书了，中文版跳票了很久，一年前就在等这本书的中文版，现在终于到手了。这系列的书就是有趣生动，多图片，一边学习一边玩，很好的感觉。比如适配器模式，这里的图片用了插座的例子，一个两头的插头，要插进一个三孔的插座，要怎么办？答案是用一个两头转三头的插头，是不是很生动？我一直在想设计模式在Ruby中会怎么表现，正好一边看这本书可以一边思考这个问题。

最近想看多一点源码，最近在看redmine的源码，觉得这个系统很经典，很多代码值得玩味，以后写点心得和研究出来。我要学多一点，写多一点，总结多一点，我要变得更厉害。

其实很多地方我对他的操作有很多建议，但是都说不出，平时真是太少读口语。他问我改名的命令是什么，我回答是连V的发音都发不准，真失败。在外国佬面前我好像是个哑巴，太没用了。在平时我可以在不借助翻译软件的情况下看懂英文原版书的，也可以很好地翻译英文的，自认为是这样。好像我的英语能力还在书面英语阶段。

回来之后我很失落，而且下定决心要读多点英语。在整个暑假，我在背新概念英语，大概是两天一篇，看来成效还没有出现。以后没事不听歌了，听英语好了，一个星期要背两三篇新概念英语。在以后做软件开发这行的话，交流是很重要的，和客户交流，和团队中的同事交流，其中很难说没有外国人，那这样英语就是交流的重要工具了。我需要达到能独立和外国人用英语交流的水平。

我不想再在鬼佬面前当哑巴了。

升级完重启，一堆问题开始来了。首先Grub只能认到整个扩展分区，认不到每个分区。不知是不是我的硬盘的分区表坏了。然后就是因为显卡驱动的原因，新内核进不去。再之后就是gnome不能启动，好在还有个xfce和fvwm，进去把Gnome重装一下，OK。进去Gnome后发现字体很难看，接着越调整越有问题，后来刷新了一下字体缓存就正常了。后来又发现Firefox的字体显示出来很小，调整了还是这样，卸了之后装了swiftfox好像好一点。不过用firefox看flash会假死。

完成了升级后，感觉变化不大，不过很明显新的Gnome的cpu占用小了，反应快了。还没有体验到新内核的提速，等到Ati的8.42.4来临再来。说到 8.42.4，ati拖了几天了，win的都出了好多天了，真是不公平。本来还想着U7.10能集成到新的官方驱动的，结果还是不行，只能寄望于8.04 了。

总的来说升级带来的问题不多，升级后的效果也不错，我升级的时候还很紧张呢：）

PS：这篇blog写了三次，第一次没有登录，登录完回来就没有，第二次时，快写完的时候开了InfoQ准备看flash，结果firefox死了。

现在上图看看：

类似于java，在ruby中：

内存管理都是由GC（garbage collector）负责。
都是强类型语言。
都有public，private，protected的方法可见性之分。
都有嵌入式文档工具（ruby的叫做RDoc）。rdoc生成的文档看起来非常像由javadoc生成的。

不同：

于java不同的是，在ruby中：

你不必编译代码，你只需要直接运行代码。
Gui开发包不同。比如，ruby的用户会尝试WxRuby，FXRuby，Ruby-GNOME2,或者基于Ruby Tk库。
你要在定义任何事物（像class）后面加上关键字end，而不是用花括号（{}）来包围代码块。
使用了require代替了import。
所有的成员变量（属性）都是private级的。在类外访问任何事物要通过方法调用。
什么都是对象，包括2和3.14159。
没有静态类型检查。
变量名都只是标签，它们没有与类型相关。
不用声明变量类型，你只需要赋值给新的变量名就可以了（例子，a = [1,2,3] 相当于 int[] a = {1,2,3};）。
没有类型强制转换这个概念，只管调用方法就好了。
用 foo = Foo.new( “hi”) 取代这样新建对象的方法 Foo foo = new Foo( “hi” )。
构造方法一直都叫“initialize”，不是和class同名的方法。
使用“混入” 代替 “接口”。
YAML 比 XML 更受欢迎。
这里用nil代替null。
==和equals()方法处理方法不同。当你想要测试相等性时就使用 == 操作符（就像Java的equals()方法）。当要想要知道两个对象是否是同一个时就使用equal?()方法(就像Java中的==)。 [点击图片可在新窗口打开]

周蟒的官方主页：
http://code.google.com/p/zhpy/

簡介

周蟒 (zhpy) 是一種簡單易學、功能強大的程式語言。它具有高效率的高階資料結構、簡單而有效的物件導向程式設計方式。並讓你可以使用純中文語句 (繁體或簡體) 來編寫程式。 馬上照著 咬一口周蟒語言 一書學習吧!
周蟒是什麼?

* 友善而易於學習的中文程式語言
* 清晰可讀的語法
* 直觀的物件導向能力
* 方便的動態物件類型
* 透過模組有架構地組織程式
* 多平台適用(Windows, Linux, Mac)的程式語言
* 全功能的中文版本 Python 語言

特點

* 周蟒是全功能的 Python 程式語言。
o 周蟒本身就是個 python 模組
o 擁有所有 python 程式語言的功能與特性
o 可以在周蟒中使用所有的 python 模組
* 安裝容易
o 可使用 easy_install 命令線上安裝
o 檔案體積小 (=0.8)
o 可在作業系統中當作中文腳本執行
o 可在 Python 互動式直譯器中測試周蟒中文程式
* 擴充性好
o 可以混用繁簡中英 關鍵詞/保留字
o 可以自訂參考字表
* 發展性高
o 周蟒, python 程式碼可互相轉換 (>=0.8)
o 可用周蟒程式碼生成英文 python source
o 可用 python 程式碼生成繁簡體周蟒程式
o 產生的 python source 可應用在任何 python 程式中
o zhpy 換上日韓關鍵字也可以擴展成日蟒, 韓蟒
* 完整測試
o 超過60筆單元測試(unittest)與文件測試(doctest)
o 完整的範例測試與命令行測試

周蟒背後的哲學有三:

* 把事情做好 (Getting Things Done)
* 程式碼被閱讀的機會比被修改的機會多 (Code is read much more than it it written)
* 一致的表達 (There should be one obvious way to do it)

程式語言再怎麼修改得接近自然語言, 都仍然具有程式語言的邏輯與規則, 周蟒語言的目的並不是接近中文自然語言，而是做出一個實用的中文程式語言。

周蟒的長處是在於發揮 “完全相容 Python 程式語言” 的中文程式語言的優點， 所有語法，關鍵詞都依照 Python 的風格。學習周蟒後要橋接到 Python 語言相當容易。

由設計目的跟設計哲學產生出的周蟒，其寫作特色有：

* Python 程式語言 + 中文支援
* 互動式直譯器
* 白話關鍵詞
* 縮排與關鍵詞前後留白
* 使用數學運算符號, 英文標點
* 較多的可參考文件

最简单的例子：
印出 '哈啰, 世界'
这就是中文的HelloWorld，是不是看起来很有亲切感。这句和以下等价：
print '哈囉, 世界'
函数定义也是中文的：

#!/usr/bin/env zhpy
# 檔名: function1.py
定義 說哈囉():
印出 '哈囉, 世界!' # 函式主體
說哈囉() # 呼叫函式

想了解多一点可以看看这个“咬一口周蟒中文程式語言”教程，看看不会花很多时间，大概一个下午就可以了。

安装文件：
http://zhpy.googlecode.com/files/zhpy-1.1.zip

api文档：
http://zhpy.googlecode.com/files/apidocs1.1.zip

# file doller.rb
class Dollar
def initialize(amount)
@amount = amount
end
def times(multiplier)
@amount = @amount * multiplier
end
def amount
return @amount
end
end
第二次迭代后的代码

# file tc_doller.rb
$:.unshift File.join(File.dirname(__FILE__), "..", "src")
require 'test/unit'
require 'dollar'
class TestMoney < Test::Unit::TestCase
def testMultiplication
five = Dollar.new(5)
product = five.times(2)
assert_equal(10, product.amount)
product = five.times(3)
assert_equal(15, product.amount)
end
end

def times(multiplier)
return Dollar.new @amount * multiplier
end
end

第三，四次迭代后的代码（添加了相等性测试，刚好Ruby中的equal?和==的语意和Java相反）

# file tc_doller.rb
$:.unshift File.join(File.dirname(__FILE__), "..", "src")
require 'test/unit'
require 'dollar'

def ==(obj)
return obj.amount == @amount
end
end

第五，六，七次迭代后的代码（短命的Franc对象登场）

# file tc_doller.rb

def ==(obj)
return obj.amount.equal?(@amount)
end
end

第八，九，十，十一次迭代（消除子类，很巧妙的一步）

# file tc_doller.rb

def ==(obj)
return obj.amount.equal?(@amount) && (obj.currency == @currency)
end
end

最后的一部分
最后是完成不同货币之间的计算，引入了两个新的对象负责处理汇率的Bank和货币相加的Sum对象。

由于Ruby的动态性无须让Sum和Money实现同一接口，反正原书中的Expression对象也是为了Sum和Money对象可以通信。或许可以把Sum简化掉，有空时再想想。

# file tc_doller.rb

def times(multiplier)
return Sum.new(augend.times(multiplier), addend.times(multiplier))
end
end

记得刚刚接触电脑的时候就用了一段时间的RH9,觉得很神秘很帅。后来来到学校后发现校园网上不到网，用xrgsu要么掉线要么上不到，试了sesu和fc 都是这样。因为万恶的锐捷又不能用虚拟机上网。这次是因为有个师兄用ubuntu7.04成功的上到了所以我又用回了Linux，用回了久违的VI。我不知为什么学了vi和emacs两个编辑器，但是一直都用不惯emacs，vi就用得很顺手。Linux下的编辑器就好在可以双手不离开键盘，不用去用到鼠标，不过太久没有用了，时不时手还是会想去摸鼠标，然后想一想手又缩回来按快捷键。

Ubuntu的中文社区很活跃，中文的资料又多得不得了，一般有什么问题搜索一下就可以查找到。

Ubuntu下用得最爽的是FireFox，好像没有windows下的内存泄漏现象。Linux下的BT软件就不怎样，还是用wine+比特精灵比较好。相对于bt，linux下的电驴软件就很厉害了，MLDonkey很快，最高能过1M/s。

下载安装软件，Ubuntu继承了Debian系的apt-get系列的方便，很大得方便了我这类懒人。只要一个命令就可以简单地在非图形界面安装软件，而且自动安装软件源中最新的版本，一并安装配置。只是把软件安装到哪里要自己去查找，有时是挺麻烦的，比如在安装后要修改配置文件的时候，特别是安装时文件分得很散，在配置radrails时要求输入rails和rake的路径。不过用了一段时间后熟悉了目录的配置之后就要找程序文件就简单多了，程序文件一般放在/usr/bin下。

不过有时一些软件还是自己手动安装好。第一有个权限问题，我的电脑还是主要用来做开发和学习的，而且又是我自己一个人用，对于Linux系统一向来的用户安全机制对我来说有点多余。自动安装的一些软件，有时要设置权限，比较麻烦。第二就是版本问题，软件源里的软件虽说都是稳定版本，但是我有时想要新一点的版本，比如Eclilpse3.3,NetBeans6。

在开发时最大的好处就是编码问题在 Linux下对utf-8的支持很好。还有好像一些ide在Linux下好像速度快一点，还有ruby也是，反应快了很多。正在试着Gvim+ rails.vim的感觉。不过还是习惯eclipse。Linux下的软件，要么是gtk的，要么是Qt，要么java的，感觉上至少比win32程序用起来觉得舒服一点，完全是心理作用。

最后有两件事让我不爽，一个是特效开不到，我的显卡是Ati 的X1650,万恶的ati官方驱动不支持XGL，开源驱动又不支持X1650。另一件事是我用eva和QQ2006上了几天之后登录的时候竟然说我“您的IP不能用低版本的QQ”，真是万恶的腾讯。我最后找了飘云版的QQ2007（因为不带键盘锁）才能用wine跑QQ2007。用wine+qq的时候发现打字那个提示框很快会不见，我用的是fcitx，还有我不能发起语音请求，发起时qq会崩溃，别人发起我接受就正常。

Ubuntu好好玩。

暑假前已经计划好了要做什么，就是要把这个学期还没有做好的几个应用做好它，把picocontainer的1.0版的代码分析和文档汉化做完（在期末考试前因为无聊所以就做了这个事），还有再写一些有趣的代码，比如一个简单的XML仓库。

读书的计划提前完成了，看完了《领域模型驱动》，《web开发敏捷之道》（新鲜热辣），《Ruby for rails》。看了一半《对象设计》，还有把《重构》又看了一遍。

还好带了一些英语资料，手机里也存了一些英语的对话，每天背一篇短文，没事练习听着英语大声念几句。感觉还好。

今天看了一下敏捷大会的消息，又看了一下Thoughtworks里的强人的博客，觉得毕业后去那里的希望很渺茫。英语又差，技术和那些强人差了几个数量级，看来要更加更加努力。