gem安装发生的依赖包问题 · Ruby China
这个问题很怪异,时有时无.
有时在某些机子上例如用gem install rails,会提示requires xxxx然后要一个个依赖包手动安装下去,依赖又有依赖...按道理gem 是会自动安装依赖包,但是这个功能有时会失效
想到的解决方法是自己写个递归脚本让他自动装,但这样每递归一次都要更新一次atest文件,速度很慢
一直都找不到这个是什么原因引起,google 和stackoverflow都找过,有些说是某些gem包用C了会和gcc版本有关系,但各种东西升级到最新还是有这个依赖问题,很奇怪
这里没人回复可以人工置顶吗?
建议使用Bundler
依赖保存在Gemfile.lock文件中。
Bundler不仅是rails可以用，自己开发的Gem可以用，其他的项目自己配上也可以用。
bundler 是趋势。。是ruby 界的maven。。而且比maven还要好用一点。。天生惧怕xml人伤不起。。
但是这个功能有时会失效 —— 有时会被墙
不同版本的 rubygem 被墙时出错信息不同，比如：
* 网络被断开
* 无法解决依赖
没有轻功还怎么玩rails..
这问题的确头痛， 装完gem 后， 又要自己去绑定那些依赖
后方可回复, 如果你还没有账号请点击这里 。
共收到 6 条回复文章标签 ‘Ruby’
Ruby使用HTTP协议发送请求
http://blog.csdn.net/garn_hsia/article/details/
Ruby使用HTTP协议发送请求的方法备忘
1. 建立HTTP连接(通过GET方式发送请求参数)
require “open-uri”
#如果有GET请求参数直接写在URI地址中
uri = ‘http://uri’
html_response = nil
open(uri) do |http|
html_response = http.read
puts html_response
2. 通过POST发送请求参数
params = {}
params[“name”] = ‘Tom’
uri = URI.parse(“http://uri”)
res = Net::HTTP.post_form(uri, params)
#返回的cookie
puts res.header[‘set-cookie’]
#返回的html body
puts res.body
ruby 与职业规划
http://happypeter.github.io/ruby-and-career.html
本文由读者来信而发。
您在博客里边推荐的ruby，这个方向适合哪些人呢？ 从个人角度来讲，我比较倾向于您在博客里表达的那种“开源共享合作”的精神，但是现实当中，大家似乎都是从“利益”的角度来进行权衡的。就像ruby也很流行，但是在国内像java这些似乎更热门一些。百度“ruby招聘”，显示有213条相关招聘信息,而java有4万多条。这是否说明选择java会有更多的机会呢？
我本人从未做过 Java 所以评价可能会比较偏颇。Java 本身是一种很繁琐的语言，它诞生于大企业文化之下，非常适合一些把程序员当流水线工人的企业。便于经理把握大项目的进度，但是程序员自身的编程效率就提不上去。我的一个幼稚的估算，同样水平的 Java 程序员和 ruby 程序员，去完成相同的一个 Web 项目，ruby 要比 Java 快5倍。
所以 ruby 适合一些个性很强，有独立创造力的人。ruby 社区有强烈的小企业创业文化，在我眼里这是中国年轻人通往人性自由的一条可行道路。Java 常见于 IBM，Oracle 这些大企业之中，这些大企业我们通常叫做“人类灵魂的屠宰场”。
现实方面，以我个人最近对北京和上海的职场观察，ruby 程序员也是非常的抢手，所以即使你学了 ruby 不去创业，工作也是很好找的。即使从纯“利益”出发，ruby 也是一样可以推荐的。补充一点：我也见过有用 Java 做 andriod 的人，过着个性张扬的生活。但总体来说 Java 世界给我的感觉是个垃圾场，ruby 社区是一个精英的小众群体。
理想和吃饭问题。前几年我做 Linux，那里真是一个要理想不要钱的地方。但是 ruby 社区不一样，它是一个既能继承开源软件的自由分享精神，同时又拥抱市场，积极服务客户的社区。例如，github。
现在很多人的观念里IT这个行业，似乎也是一个吃青春饭的职业，年龄一大可能就失去了竞争的优势。所以有很多人觉得，程序员最终还是要向管理层发展，可是适合做技术的人，并不一定适合做管理。 不知道您有什么看法？希望看到您的回复。
“做技术的人，不一定适合做管理” 在很多情况下是对的，如果你常年被经理压制去做项目的一个小环节，这样几年下来，自然会变成傻子。但是 ruby 社区恰好是个代码和创业思想相融合的地方。推荐 ruby 圈一篇著名文章:
更推荐你去了解一下本文的作者DHH，你就知道 ruby 社区的人都是如何规划职业的。毋庸置疑，好的管理思想和创新思维要比你多会一些函数接口重要一千倍。但是不去编程，脚踏实地的做一些基础工作，那灵感又岂会从天而降。所以扎实的代码功底和高屋建瓴的创造思维是不可偏废的。
是不是青春饭的问题。如果你是个工地里的苦力，那自然就要年轻力壮才能行，但如果你是建筑师… 哈，本文到此结束。
Ruby中爬虫的实现
/2013/09/realization-of-reptiles-in-ruby
Ruby中实现网页抓取，一般用的是mechanize，使用非常简单。 安装
sudo gem install mechanize
agent = Mechanize.new
page = agent.get(
模拟点击事件
page = agent.page.link_with(:text =&gt
模拟表单提交
google_form = page.form('f')
google_form["q"] = 'ruby mechanize'
page = agent.submit(google_form, google_form.buttons.first)
分析页面，mechanize用的是nokogiri解析网页的，所以可以参照nokogiri的文档
table = page.search('a')
text = table.inner_text
有几点注意的地方： 如果需要先登录的网页，那么可以在网站先登录，登录后记录JSESSIONID，然后赋值给agent
cookie = Mechanize::Cookie.new("JSESSIONID", "BA98AD033EE6DF12B986:-1")
cookie.domain = ""
cookie.path = "/"
agent.cookie_jar.add!(cookie)
如果需要保存网页，使用.save_as，(或许save也可以，我没试过)例如
agent.get("").save_as
ruby调用ssh接口
require 'net/ssh'
host = '192.168.100.xx'
username = username
password = pwd
server_cmd1 = 'ls -l'
server_cmd2 = 'cat /etc/issue'
ssh = Net::SSH.start(host, username, :password =& password) do |ssh|
result = ssh.exec!(server_cmd1)
puts result result = ssh.exec!(server_cmd2)
puts result
有没有这样一个需求：同时向几十上百台Linux服务器上传文件并执行命令，如果一个个来，那你就真是挨踢民工。程序员要发挥自己懒惰的个性，借用Net::SSH和net::SCP用Ruby写个脚本你会发现非常简单。
Net::SSH和Net::SCP是两个Ruby操作SSH的gem包。Net::SSH相当于cmd，专门用于执行命令；Net::SCP专门用于传输文件。它们俩结合，可以做任何SSH client能做的事情。
gem install net-ssh
gem install net-scp
以下所有代码都引用这段代码
require 'net/ssh'
require 'net/scp'
HOST = '192.168.1.1'
USER = 'username'
PASS = 'password'
1、使用Net::SSH执行一个命令
Net::SSH.start( HOST, USER, :password =& PASS ) do |ssh|
result = ssh.exec!('ls')
puts result
Net::SSH.start会与目标主机建立一个连接，并返回一个代表连接的session。如果后面接收一个block，会在block结束时自动关闭连接。否则要自己关闭连接。注意密码作为一个hash参数传递，是因为SSH登录验证方式比较多，需要的参数变化多样。
2、使用NET-SFTP传输文件。
如果不需要执行命令，仅仅是传输文件，可以使用Net::SCP.start，类似Net::SSH.start
Net::SCP.start( HOST, USER, :password =& PASS ) do |scp|
scp.upload!( 'c:/scp1.rb', '/home/oldsong/' )
scp.download!( '/home/oldsong/test.txt', 'c:/' )
3、如果即要传输文件，又要执行命令，scp不必重新建立连接，借用ssh连接即可
Net::SSH.start( HOST, USER, :password =& PASS ) do|ssh|
logfiles = ssh.exec!( 'ls *.log' ).split
logfiles.each do |l|
ssh.scp.download!( l, l )
4、如果要传输大文件，最好能显示传输进度，不然好久没反应，还会以为死机了呢。
Net::SSH.start( HOST, USER, :password =& PASS ) do|ssh|
ssh.scp.upload!( 'large.zip', '.' ) do|ch, name, sent, total|
print "\r#{name}: #{(sent.to_f * 100 / total.to_f).to_i}%"
5、上传一个目录，包括子目录中的所有文件。加上“:recursive =& true”参数。
Net::SSH.start( HOST, USER, :password =& PASS ) do|ssh|
ssh.scp.download!( 'logs', '.', :recursive =& true )
6、如果下载后不想保存成文件，而是放到内存中直接处理，只要不给download!传递本地文件名即可，会返回一个字符串。
Net::SCP.start( HOST, USER, :password =& PASS ) do|scp|
puts scp.download!('log.txt').split(/\n/).grep(/^ERROR/)
7、scp最高级应用，根据事件显示所有传输信息。
Net::SCP.start( HOST, USER, :password =& PASS ) do|scp|
sftp.upload!(f, remote_file) do |event, uploader, *args|
case event
when :open
puts "start uploading.#{args[0].local} -& #{args[0].remote} #{args[0].size} bytes}"
when :put then
puts "writing #{args[2].length} bytes to #{args[0].remote} starting at #{args[1]}"
when :close then
puts "finished with #{args[0].remote}"
when :mkdir then
puts "creating directory #{args[0]}"
when :finish then
puts "all done!"
puts "upload success"
Ruby中的字符串与符号
http://blog.csdn.net/besfanfei/article/details/7966987
初学Ruby的时候，往往对字符串（String类）与符号（Symbol）这两种变量类型分不清楚，其实，我们大可不必纠缠这两种变量类型的内部实现，只需记住它们的特点和区别就可以了：
1. 字符串和符号，都是Ruby中表示文本的方式
不管字符串变量也好，符号变量也好，都是用来表示文本的，它们之间，也可以互相转换（通过to_sym和to_s）：
“book”.to_sym
:track.to_s
=& “track”
2. 相同的符号是一个对象，相同的字符并不一定是一个对象
这就是符号和字符串最大的差别，符号是不可变的，不能对一个符号进行修改。所以说，两个看起来相同的符号一定是一个对象，但是说两个看起来一样的字符串是一个对象，就不对了。
这里，我们用 equal? 方法检验这一点，当两个对象相同时，equal? 返回true，反之是false：
:book.equal?(:book)
“book”.equal?(“book”)
3. 处理符号相比字符串，占用更少的资源
这也就是为什么有些时候我们要使用符号的原因，由于字符串变量必须具有各种修改其内容的功能，所以字符串的维护和处理的开销就很大，但是有些时候，我们并不需要修改和处理创建的文本信息，这个时候用符号再好不过了。
比较典型的用法，就是在Rails中，用符号来指代散列中的参数名称：
&% for article in @articles -%&
&%= link_to article.title,
:controller =& “article”,
=& “show”,
=& article.id
&% end -%&
反之，如果我们把 :controller 写成”controller”，把 :action 写成”action”，吧 :id 写成”id”，每一个循环都要创建3个新的字符对象，但是我们又不需要对这些字符串进行修改操作，白白添加了很多处理器开销，而且写成符号的形式更加简练，可以更容易分别出参数和值，何乐而不为呢。
理解 Ruby Symbol (Ruby中的冒号)
http://blog.csdn.net/besfanfei/article/details/7966850
Symbol 是什么
Ruby 是一个强大的面向对象脚本语言（本文所用 Ruby 版本为1.8.6），在 Ruby 中 Symbol 表示“名字”，比如字符串的名字，标识符的名字。
创建一个 Symbol 对象的方法是在名字或者字符串前面加上冒号：
创建 symbol 对象
:”I am a boy”
你可能会问，字符串就是字符串，干吗还有字符串的名字？这是因为在 Ruby 中字符串也是一种对象，即 String 对象。无论其结构还是操作和 Symbol 对象都是不同的。
在 Ruby 中每一个对象都有唯一的对象标识符（Object Identifier），可以通过 object_id 方法来得到一个对象的标识符。我们来看看 Symbol 对象和 String 对象的差别：
Ruby 对象标识符
irb(main):001:0& puts :foo.object_id
irb(main):002:0& puts :foo.object_id
irb(main):003:0& puts :"foo".object_id
irb(main):004:0& puts "foo".object_id
irb(main):005:0& puts "foo".object_id
irb(main):006:0& puts "foo".object_id
可以看到，前三行语句中的 :foo （或者 :”foo”）都是同一个 Symbol 对象，其 object id 为327458，而后三行中的字符串”foo”都是不同的对象，其 object id 依次为296170。
可见，每个 String 对象都是不同的，即便他们包含了相同的字符串内容；而对于 Symbol 对象，一个名字（字符串内容）唯一确定一个 Symbol 对象。
值得注意的是创建 Symbol 对象的字符串中不能含有’\0’字符，而 String 对象是可以的。
非法 Symbol 字符串
irb(main):001:0&
SyntaxError: compile error
(irb):1: symbol cannot contain '\0'
from (irb):1
irb(main):002:0& :"foo\0"
SyntaxError: compile error
(irb):2: symbol cannot contain '\0'
from (irb):2
irb(main):003:0& puts "foo\0".object_id
irb(main):004:0& puts "fo\0o".object_id
irb(main):005:0&
除了可以采用一般的字符串，还可以使用操作符（例如+, -, *, /），变量，常量，方法甚至类的名字来创建Symbol 对象，例如:+就是一个合法的 Symbol 。实际上，在 Ruby 内部操作符、变量等名字本身就是作为Symbol 处理的，例如当你定义一个实例变量时， Ruby 会自动创建一个 Symbol 对象，例如 @test 对应为 :@test 。
实例变量的 Symbol
class Test
attr_accessor :test
这个类定义了一个具有读写方法的实例变量 @test 。实际上 Ruby 创建了两个 Symbol ，一个是实例变量的symbol :@test ，另一个是 :test 。那如果使用字符串对象 ”test” 作为参数呢？也可以，仍然会创建两个 symbol，:test 和 :@test ，为什么还会创建 :test 呢？这是和Ruby的实现相关的（至少Ruby1.8.6里是这样）。
注意，类变量 @@test 和实例变量 @test 对应的 Symbol 显然是不同的。记住：名字相同，则Symbol 相同。
名字相同， Symbol 相同
class Test
puts :Test.object_id
puts :Test.object_id
puts :Test.object_id
Test.new.Test
名字不同， Symbol 不同
class Test
puts :Test.object_id
@@test = 10
puts :@@test.object_id
puts :test.object_id
@test = 10
puts :@test.object_id
t =Test.new
第一个例子里，类名、常量名和方法名都是 Test ，因此相应的 Symbol 对象都是 :Test 。不用担心， Ruby 可以很好区分它在不同上下文中到底表示什么。当然这并不是一个好的编程风格，但对于理解 Ruby 的 Symbol还是有帮助的： Symbol 表示一个名字，仅此而已。
Symbol 对象一旦定义将一直存在，直到程序执行退出。所有 Symbol 对象存放在 Ruby 内部的符号表中，可以通过类方法Symbol.all_symbols 得到当前 Ruby 程序中定义的所有 Symbol 对象，该方法返回一个 Symbol 对象数组。由于 Symbol 比较多，你可以 dump 到文件中来查看。
all_symbols 方法
irb(main):001:0& Symbol.all_symbols.size
irb(main):002:0& Symbol.all_symbols[0..9]
=& [:@level_notifier, :ppx, :msg_dn, :version, :secs, :@user, :pos, :socketpair,
:TkENSURE, :HTTPAccepted]
irb(main):003:0& File.open("sym", "w") do |file| file.puts Symbol.all_symbols end
Symbol 和 String
Symbol 对象和 String 对象是完全不同的东西，对象标识符很明确的说明了这一点。除此之外，我们还可以从两种对象的方法上区分。
查看 Ruby 库参考，你会发现 String 类有非常多的方法，包括 Mixed-in 方法（Ruby中一个类通过 include 其他模块而得到的方法，实现多重继承的效果）、类方法和实例方法；而 Symbol 类只有一个类方法 all_symbols 和7个实例方法。
例如，可以通过 []= 方法改变 string 的内容，而 symbol 则不行：
[]= 方法比较
irb(main):001:0& s="test"
irb(main):002:0& s[0]='1'
irb(main):003:0& puts s
irb(main):004:0& sym=:test
irb(main):005:0& sym[0]=1
NoMethodError: undefined method `[]=' for :test:Symbol
from (irb):5
irb(main):006:0&
虽然 Symbol 和 String 是不同的对象，但它们之间关系很密切。 Ruby 提供了方法在 Symbol和 String 之间转换。
Symbol 转化为 String
使用 to_s 或 id2name 方法将 Symbol 转化为一个 String 对象：
Symbol 到 String
irb(main):001:0& :test.id2name
irb(main):002:0& :test.to_s
irb(main):003:0& :"I am a boy".to_s
=& "I am a boy"
注意，每个 String 对象都是唯一的，因此对一个 Symbol 调用多次将产生多个 String 对象。
String 转化为 Symbol
除了在字符串前面加冒号，还可以使用 to_sym 或 intern 方法将 String 转化为 Symbol ，如果该 Symbol 已经存在，则直接返回。
String 到 Symbol
irb(main):001:0& var1 = "test".to_sym
irb(main):002:0& var2 = "test".intern
irb(main):003:0& var1 == var2
irb(main):004:0&
使用 Symbol
正如前边提到的， Ruby 内部一直在使用 Symbol ，比如 Ruby 程序中的各种名字，Symbol本质上是 Ruby 符号表中的东西。使用 Symbol 处理名字可以降低 Ruby 内存消耗，提高执行速度，这点我们在下一篇文章中会看到。
那么 Symbol 对我们有什么用呢？当然也是内存。使用 String 的开销太大了，因为每一个String 都是一个对象。想想前边的例子，一个字符串每出现一次 Ruby 就会创建一个 String 对象。
通常来讲，当你面临 String 还是 Symbol 的选择时，可以参考以下标准：
如果使用字符串的内容，这个内容可能会变化，使用 String
如果使用固定的名字或者说是标识符，使用 Symbol
那么什么时候我们会用到名字呢？很多时候都会，比如枚举值、关键字（哈希表关键字、方法的参数）等等
作为哈希表的 key
哈希表是 Symbol 应用最为广泛的地方。
在ruby中，哈希和数组类似，一个哈希表是一系列 key/value 对的集合，只不过它的 key 取值范围更广泛，可以是任何对象，比如正则表达式。但通常我们都会取有意义的 key ，比如 String、Symbol 。
下面这个哈希表表示按城市分类的一些机器的集合。
一个哈希表例子
'beijing' =& 'machine1',
'shanghai'
=& 'machine2',
'guangzhou' =& 'machine3',
'tianjin' =&
'machine4',
'shenzhen' =&　'machine5'
如果要引用 beijing 的机器，使用 hosts[‘beijing’] 。但如果我们程序中要频繁引用哈希表中 value ，这样就不大好了，因为 Ruby 对每一次字符串引用都会生成一个 String 对象，累积下来这个开销是相当大的。
我们完全可以使用 Symbol ，因为对于这些 key 来讲，我们用的就是名字而已，例如下面hosts[:beijing]
使用 Symbol 作为 key
hosts　=　{
　:beijing　=&　'machine1',
　:shanghai　=&　'machine2',
　:guangzhou　=&　'machine3',
　:tianjin 　=&　'machine4',
　:shenzhen　=&　'machine5'
通常我们定义的函数的参数的个数和顺序是写死的，调用函数的时候要确保参数的个数、顺序匹配，有时候这样很不方便，使用哈希参数可以解决这个问题。
ROR 中就大量地运用这种方式，也许你已经看到了，到处都是 Symbol 和哈希。比如：
使用哈希参数的方法调用
link_to 'Show', :action =& 'show', :id =& product
add_column :products, :price, :decimal,
:precision =& 8, :scale =& 2, :default =& 0
使用哈希参数的方法可以如下定义，前半部分为固定参数，后面为可变参数，或者干脆全采用哈希参数：
def my_method(para1, …, options={})
#your code
def my_method(options={})
#your code
如果你希望设定一些默认参数，并允许调用者更改这些参数，可以使用哈希对象的 merge! 方法
hsh.merge!( other_hash )。该方法将 other_hash 里内容加到 hsh 中，如果other_hash 与 hsh 有重复的 key ，则 key在 other_hash 中的 value 覆盖 hsh 中对应 key 的 value 。
方法定义-使用默认参数
class Test
def my_method(opts={})
default_opts={:arg1 =& 10, :arg2 =& "abc"}
default_opts.merge!(opts)
default_opts.each{|key,value| puts "#{key} is #{value}"}
t = Test.new
t.my_method :arg1=&5, :arg3=&"def"
arg2 is abc
arg3 is def
在 Rails 中，对 hash 类进行了扩展，可以使用 reverse_merge! 方法来达到上述效果。该方法在 ActiveSupport::CoreExtensions::Hash::ReverseMerge 中定义。Rails 甚至还提供了 assert_valid_keys 方法，对传递进来的哈希表的 keys 进行合法性检验。
Perl 说，条条大路通罗马。在 Ruby 中也是这样的，也许你会发现更好的应用 Symbol 和哈希的方法。
Ruby 是用 C 语言实现的，本文我们将以 Ruby 1.8.6 版本实现为例。
Ruby 是一个完全面向对象的语言，这点很好地体现在对象方法调用的一致性上，一个对象，无论是如何创建的，调用实例方法的方式是一样的，即“&对象&.&方法名&”。
Ruby对象的方法调用
"gin joint".length ?8?1 9
"Rick".index("c") ?8?1 2
-1942.abs ?8?1 1942
自然 Symbol 也是一种对象，那么 Ruby 内部是如何一致地表示各种对象的呢？
VALUE(ruby.h)
typedef unsigned long VALUE;
没错，这就是 Ruby 对象的定义，确切地说是对象的引用。在 Ruby 中绝大多数对象的内容表示为 C 语言中的结构体，比如用户定义的对象和 Ruby 预定义的对象如 String, Array 等。我们知道引用结构体的方法是指针， void * 指针是比较通用的，使用之前先转换为待引用结构体类型的指针。那么为什么不使用 void * 作为对象的引用呢？
这是因为Ruby在 VALUE 中内嵌了其他类型的，不用结构体表示的对象，也就是说直接用VALUE 表示的对象，这其中就有 Symbol 。考虑到现在大多数计算机体系上 void * 指针和 sizeof(unsigned long) 大小是相同的（比如4字节），可以互相转换，因此使用VALUE 更有价值。
内嵌到 VALUE 中的对象有 Fixnum，Symbol，true，false，nil 和 undef 。
Fixnum(ruby.h)
#define FIXNUM_MAX (LONG_MAX&&1)
#define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
#define FIXNUM_FLAG 0x01
#define INT2FIX(i) ((VALUE)(((long)(i))&&1 | FIXNUM_FLAG))
#define LONG2FIX(i) INT2FIX(i)
#define FIX2INT(x) rb_fix2int((VALUE)x)
#define FIXNUM_P(f) (((long)(f))&FIXNUM_FLAG)
Fixnum 类表示小整数，由 INT2FIX 得到。由于可能在程序中频繁使用，将其用结构体表示可能会使执行速度大打折扣，因此直接嵌入 VALUE 中。数值左移一位或上0x01使得 Fixnum总是一个奇数，其实际可用比特位为 sizeof(long)*8-1 ，可表示的最大最小值分别为FIXNUM_MAX 和 FIXNUM_MIN ，超出该范围的数属于 Bignum 类，由C结构体实现。
宏 FIXNUM_P 返回一个布尔值，P 表示断言（predicate），即“参数f是否为 fixnum 对象”。FIX2INT 将 Fixnum 转换回来，由 rb_fix2int 函数实现，它根据实际平台上 int 和long 的大小是否相同来分别处理。
注意，在 VALUE 中 Fixnum 总是一个奇数，而使用 C 结构体表示的 Ruby 对象的内存空间是由 malloc 分配的，所得地址通常为4的倍数，因此以VALUE表示的 Fixnum 和C结构体 Ruby对象不会发生冲突。
Symbol(ruby.h)
typedef unsigned long ID;
#define SYMBOL_FLAG 0x0e
#define SYMBOL_P(x) (((VALUE)(x)&0xff)==SYMBOL_FLAG)
#define ID2SYM(x) ((VALUE)(((long)(x))&&8|SYMBOL_FLAG))
#define SYM2ID(x) RSHIFT((unsigned long)x,8)
Ruby 的 Symbol 定义很简单，它在C层次上就是一个无符号整数，转换为 Ruby 的 VALUE值的方法是先左移8位，然后加上 Symbol 的 flag 0x0e，这使得 Symbol 既不是4的倍数，也不是奇数，以 VALUE 表示的 Symbol不会和 fixnum 对象，结构体对象冲突。
True false nil undef(ruby.h)
#define Qfalse ((VALUE)0) /*false*/
#define Qtrue
((VALUE)2) /*true*/
#define Qnil
((VALUE)4) /*nil*/
#define Qundef ((VALUE)6) /* undefined value for placeholder */
Ruby 中一切皆对象，连 true/false/nil 也是。由于虚拟内存的第一个块（对应地址4）一般不分配， Qnil 也不会和结构体对象冲突。
这样以 VALUE 表示的C结构体对象、Fixnum、Symbol、true、false、nil和undef在内存地址空间中都可以互不侵犯，和平共处。 VALUE 可以引用 Ruby 内部所有的对象，这使得 Ruby可以统一处理不同类型的对象。
当给定一个 VALUE 对象时，使用 TYPE 宏判断该对象的种类，例如 Symbol 对象类型为T_SYMBOL。
TYPE宏(ruby.h)
#define T_MASK
#define BUILTIN_TYPE(x) (((struct RBasic*)(x))-&flags & T_MASK)
static inline int rb_type(obj)
if (FIXNUM_P(obj)) return T_FIXNUM;
if (obj == Qnil) return T_NIL;
if (obj == Qfalse) return T_FALSE;
if (obj == Qtrue) return T_TRUE;
if (obj == Qundef) return T_UNDEF;
if (SYMBOL_P(obj)) return T_SYMBOL;
return BUILTIN_TYPE(obj);
#define TYPE(x) rb_type((VALUE)(x))
inline 函数 rb_type 首先判断 VALUE 是否为内嵌对象，即 Fixnum、Symbol、true、false、nil和undef 。如果都不是，说明该对象是一个C结构体对象，调用 BUILTIN_TYPE 宏二次判断。该宏涉及到结构体对象中的内容。
结构体对象例子： String
我们以 String 对象定义为例看一下 Ruby 结构体对象。
String(ruby.h)
struct RBasic {
struct RString {
#define RSTRING_PTR(s) (RSTRING(s)-&ptr)
#define RSTRING_LEN(s) (RSTRING(s)-&len)
和我们自己在C中使用字符串时差不多，最重要的两个成员是 len 和 ptr 。 len 表示字符串长度， ptr 指向实际的字符数组。 RSTRING_PTR 和 RSTING_LEN 用来快速访问这两个域，当然使用之前最好用 TYPE 宏检查一下 VALUE s 是否真正是一个 String 对象。 aux联合涉及 String 对象处理技巧，这里我们不讨论。
注意 RString 定义中有一个类型为 RBasic 结构体的成员，里面是 flags 和 klass ，联系上面 TYPE 宏的定义， BUILTIN_TYPE 宏要检查这个 flags 值：没错， flags 就存储着结构体对象的类型。当然 T_MASK 只占用了 unsigned long 中的6个比特位，剩下的 flags 位中还有一些用于其他用途。
另一个 RBasic 成员 klass 是 VALUE 类型，指向这个对象归属的类，即“类对象”。在Ruby 中类也是以对象存在的（记住，一切皆对象）。类对象用 struct RClass 结构体表示，对应的 TYPE 标志为 T_CLASS 。
除个别结构体外，绝大多数 Ruby 结构体对象第一个域为 RBasic 成员，这使得 Ruby 可以一致地判断各种对象的类型。
此外还有一个 CLASS_OF 宏，用来得到对象的归属类对象，由 inline 函数 rb_class_of实现，对于结构体对象返回 RBasic 成员的 klass 的值，对于 VALUE 内嵌对象，他们没有结构体，则返回 Ruby 初始化时创建的类对象指针，例如 Symbol 类对象指针为rb_cSymbol 。
CLASS_OF 宏(ruby.h)
static inline VALUE
rb_class_of(obj)
if (FIXNUM_P(obj)) return rb_cF
if (obj == Qnil) return rb_cNilC
if (obj == Qfalse) return rb_cFalseC
if (obj == Qtrue) return rb_cTrueC
if (SYMBOL_P(obj)) return rb_cS
return RBASIC(obj)-&
#define CLASS_OF(v) rb_class_of((VALUE)(v))
可以看到， Symbol 对象和 String 对象在 Ruby 内部的表示完全不同。 Symbol 对象直接嵌入到 VALUE 中，本质上是一个数字，这个数字和创建 Symbol 的名字形成一对一的映射；而String 对象是一个重量级的用C结构体表示的家伙，因此使用 Symbol 和 String 的开销相差很大。
那么 Symbol 对象的数字 ID 和名字是如何对应起来的呢？下面我们就会看到。
符号表（Symbol Table）
我们使用:&字符串&的方式创建 Symbol 对象，但到现在为止，我们看到的 Symbol 只是一个数字，那这个数字对应的名字在哪里？在符号表里。
符号表是一个全局数据结构，它存放了所有 Symbol 的（数字ID，名字）对， Ruby 不会从中删除 Symbol ，因此当你创建一个 Symbol 对象后，它将一直存在，直到程序结束。为了方便 name 和 ID 之间的双向查找，设置了两个符号表 sym_tbl 和 sym_rev_tbl 。
Symbol table(parse.c)
static st_table *sym_
/*name to ID*/
static st_table *sym_rev_ /*ID to name*/
void Init_sym()
sym_tbl = st_init_strtable_with_size(200);
sym_rev_tbl = st_init_numtable_with_size(200);
符号表采用链式哈希表，如下图所示。
bins 为数组指针，每个数组元素类型为 struct st_table_entry * 指针，通过哈希表元素的 next 成员链成链表。 num_bins 为数组元素个数， num_entries 为哈希表元素个数。每个哈希表元素包括哈希值和 key/record 对。
链式哈希表
哈希表定义
typedef struct st_table st_
struct st_hash_type {
int (*compare)();
int (*hash)();
struct st_table {
struct st_hash_type *
struct st_table_entry **
typedef unsigned long st_data_t;
typedef struct st_table_entry st_table_
struct st_table_entry {
st_table_entry *
st_table 的 type 成员存放该哈希表的 key 比较函数指针和哈希函数指针，在哈希表初始化时填入。例如，对于 ID 到 name 的 sym_rev_tbl 表，其哈希函数就是简单地返回ID。
Symbol 方法实现
有了数据结构，我们来看算法：对象方法的实现。
类对象初始化
在 Ruby 中类也是以对象存在的，即类对象。对象通过 CLASS_OF 宏可以得到它的归属类对象，对象的方法就存储在类对象的方法表中，也是一个哈希表。类对象初始化的时候通过调用rb_define_method 将对象方法加入到方法表中。
Symbol类对象初始化(object.c)
VALUE rb_cS /*Symbol class object, global variable*/
/*class name:Symbol, super class:rb_cObject*/
rb_cSymbol = rb_define_class("Symbol", rb_cObject);
/*method initialization*/
rb_define_method(rb_cSymbol, "to_s", sym_to_s, 0);
rb_define_method(rb_cSymbol, "id2name", sym_to_s, 0);
String类对象初始化(String.c)
VALUE rb_cS
/*class name:String, super class:rb_cObject*/
rb_cString
= rb_define_class("String", rb_cObject);
/* method initialization*/
rb_define_method(rb_cString, "intern", rb_str_intern, 0);
rb_define_method(rb_cString, "to_sym", rb_str_intern, 0);
显然， String 对象的 intern 方法和 to_sym 方法由 rb_str_intern 函数实现，而Symbol 对象的 to_s 和 id2name 方法由 sym_to_s 函数实现。
String 到 Symbol 的方法
在 Ruby 内部， String 对象到 Symbol的转换由 string.c 中的函数 rb_str_intern实现。
该函数进行一些必要的检查，然后调用 rb_intern 函数创建字符串和 ID 的映射。该函数很有意思，它实际上是Ruby 解析器的一部分，从中我们可以看到 Ruby 是如何处理程序中的各种名字符号的。
函数 rb_intern 大致完成以下工作：
搜索符号表，如果名字对应的 Symbol 已经创建，直接返回 symbol 的 ID。
解析名字的类型（全局变量、类变量、实例变量、操作符、属性赋值（ attribute assignment ）、局部变量、常量或其他），创建 ID 并打上相应的类型标记（在 ID 的最低3位），其中 Ruby 操作符的 ID 是在 op_tbl 表中预定义的，其他的由全局变量 last_id 动态生成。这样每一个名字都将唯一对应一个 ID。
将（name,ID）对登记在符号表 sym_tbl 和 sym_rev_tbl 中。
简化的 rb_intern 函数(parse.c)
ID rb_intern(name)
const char *
const char *m =
if (st_lookup(sym_tbl, (st_data_t)name, (st_data_t *)&id))
last = strlen(name)-1;
/*...parse the name, tag attribute for id*/
id_regist:
name = strdup(name);
st_add_direct(sym_tbl, (st_data_t)name, id);
st_add_direct(sym_rev_tbl, id, (st_data_t)name);
最终 rb_intern 返回的 ID 被 rb_str_intern 转换为一个VALUE值（通过宏ID2SYM）
Symbol 到 String 的方法
Symbol 到 String 由 sym_to_s 实现。其中 rb_id2name 函数将 id 转换为一个名字，然后 rb_str_new2 使用该名字创建一个新的 string 对象。
sym_to_s 函数(object.c)
static VALUE
sym_to_s(sym)
return rb_str_new2(rb_id2name(SYM2ID(sym)));
函数 rb_id2name 本质上是简单地查询操作符表 op_tbl 和符号表 sym_rev_tbl ，但由于属性赋值类型名字处理的缘故，具体代码要稍复杂一些。
Ruby 1.9 中的新变化
就在本文写作过程中，2007 年圣诞节， Ruby 1.9 发布了。
在 Ruby 1.9 中， Symbol 有了一些变化，使得 Symbol 看起来“更像” String 了。比如Symbol 的===方法，在Ruby 1.8.6 和 Ruby 1.9 中是完全不同的。
symbol===string
irb(main):001:0& [RUBY_VERSION, RUBY_RELEASE_DATE]
=& ["1.8.6", ""]
irb(main):002:0& :a === "a"
irb(main):003:0&
irb(main):001:0& [RUBY_VERSION, RUBY_RELEASE_DATE]
=& ["1.9.0", ""]
irb(main):002:0& :a === "a"
irb(main):003:0&
除此之外，新的 Symbol 类包含了比较模块，使得 Symbol 对象可以使用诸如”==”、”&=”、”&=”等比较操作符。
Symbol 比较
irb(main):001:0&
:test1 &= :test2
irb(main):002:0&
:test3 &= :test2
irb(main):003:0&
Symbol 类还定义了以前只有 String 类才有的方法，比如，[]、casecmp、length、capitalize等等。
在实现上， Symbol 类对象和 string 类对象的初始化都放到了 string.c 中，这似乎也使得 Symbol 和 String 拉近了距离。
难道 Symbol 和 String 变成一个东西了？没有。类的关系没有变， Symbol 的父类还是Object ， Symbol 的表示和存储也没有变。新方法的实现只是利用了 Symbol 和 String的互换函数。比如 Symbol 的 capitalize 方法就是将 Symbol 转换为 String ，最后再转换回来。这个时候其实已经是一个新的 Symbol 了。
capitalize 方法
static VALUE
sym_capitalize(VALUE sym)
return rb_str_intern(rb_str_capitalize(rb_id2str(SYM2ID(sym))));
当然可能还会有新的变化。不过我个人还是希望 Symbol 能保持简单，因为它本来就不复杂。而复杂的东西往往最终会失去生命力。
/keen-allan/articles/2467671.html
最近在学习Rails,因为学习的java为入门语言.些许的不太适应.特别是Ruby的Hash.不过细细的想想就通了.基本上都是通的Key-Value.除了刚开始不太适应写法没什么大的问题.这个是我在网上看到的一篇日志.
&—————————————–施主还是割了吧————————————————–&
1. 如何创建Hash?
x = Hash.new
x = {:a =& 1, :b =& 2}
这些都是创建Hash的方法。
第一个和第二个一样，表示创建空的Hash.
第三个表示创建的Hash，有2对键/值。
2. Hash的键是哪些类型?
可以是任何目标，如：
irb(main):002:0& x={}
irb(main):003:0& x[1]=2
irb(main):004:0& x[“a”]=”b”
=& “b”
irb(main):005:0& x[:z] = 100
irb(main):006:0& x[[1,2,3]] = [4,5,6]
=& [4, 5, 6]
irb(main):007:0& x
=& {“a”=&”b”, [1, 2, 3]=&[4, 5, 6], 1=&2, :z=&100}
有两点注意：
（1）任何目标包括数组、Hash都可以是Key。
（2）使用字符作为Key时，最好使用对应的符号。例如，键”a”可以用:a来代替。这是因为每个字符”a”都是一个目标，而:a是唯一的，
更节省内存。
3. 如何给Hash赋默认的值?
irb(main):003:0& x=Hash.new([])
irb(main):004:0& x[:a]
表示创建一个Hash，它的默认值是空的数组[]。
然后访问x[:a]，虽然这个键没有事先定义，但还是有默认值。
请注意：这种方法赋的默认值，都指向同一个目标，这个目标改变了，会影响到所有默认值。
irb(main):005:0& x[:a] && 1
irb(main):006:0& x[:b]
要做到每个键都对应唯一的默认值，应该如此创建Hash:
irb(main):007:0& y=Hash.new do |h,k| h[k] =[] end
让我们再看看：
irb(main):009:0& y[:a] && 1
irb(main):010:0& y[:b]
一个值的改变，不会影响到其他默认值。
4. 如何遍历Hash?
irb(main):018:0* x={1=&2,3=&4,5=&6}
=& {5=&6, 1=&2, 3=&4}
irb(main):019:0& x.each do |k,v| puts “#{k} #{v}” end
=& {5=&6, 1=&2, 3=&4}
使用Hash的each方法。
5. 如何遍历Hash的Key和Value?
irb(main):020:0& x.keys.each do |k| puts k end
irb(main):021:0& x.values.each do |v| puts v end
使用Hash的keys和values方法，它们返回一个数组。
当然还可以使用each_key和each_value方法，顾名思义就是遍历key和value.
irb(main):016:0& x.each_key do |s| puts s end
=& {1=&2, 3=&4}
irb(main):017:0& x.each_value do |s| puts s end
=& {1=&2, 3=&4}
6. Hash可以sort吗?
ruby的hash实际是可以sort的，返回一个sort后的二维数组。
irb(main):027:0& x
=& {5=&6, 1=&2, 3=&4}
irb(main):028:0& x.sort
=& [[1, 2], [3, 4], [5, 6]]
另外ruby有OrderedHash这个类，它可以让Hash元素按插入顺序来sort，类似于数组的能力。
7. 如何从Hash里添加和删除元素?
增加元素，直接定义Key/Value：
irb(main):040:0& x[7]=8
irb(main):041:0& x
=& {5=&6, 1=&2, 7=&8, 3=&4}
删除元素，使用delete方法，参数是想删除的Key:
irb(main):042:0& x.delete(7)
irb(main):043:0& x
=& {5=&6, 1=&2, 3=&4}
当然也可以用delete_if带条件的删除Hash元素。例如删除所有Key大于3的：
irb(main):074:0* x.delete_if do |k,v| k&3 end
=& {1=&2, 3=&4}
8. 如何查找Hash元素?
使用has_key?和has_value?来判断是否有对应键和值：
irb(main):052:0& x.has_key? 1
irb(main):053:0& x.has_value? 4
irb(main):054:0& x.has_key? 9
考虑到默认值的情况，不能直接用if hash[:key]来判断，例如：
irb(main):055:0& y=Hash.new(9)
irb(main):056:0& y.has_key? :a
irb(main):057:0& puts 1 if y[:a]
其他的查找方法，还有find、select等，例如找到所有Key大于2的元素：
irb(main):038:0& x.select do |k,v| k&2 end
=& [[5, 6], [3, 4]]
9. 可以反转Hash吗?
答案是可以，使用invert方法：
irb(main):011:0* x={1=&2,3=&4,5=&6}
=& {5=&6, 1=&2, 3=&4}
irb(main):012:0& x.invert
=& {6=&5, 2=&1, 4=&3}
10. Hash和数组如何转换?
Hash转换到数组很简单：
irb(main):020:0& x.to_a
=& [[5, 6], [1, 2], [3, 4]]
数组转换到Hash麻烦一点，自己写一个方法to_hash：
irb(main):023:0& class Array
irb(main):024:1&
def to_hash
irb(main):025:2&
unless size%2 == 0
irb(main):026:3&
raise “array with odd number of elements”
irb(main):027:3&
irb(main):028:2&
hash = Hash.new
irb(main):029:2&
0.step(size-1,2) {|x| hash[self[x]] = self[x+1] }
irb(main):030:2&
irb(main):031:2&
irb(main):032:1& end
irb(main):033:0& x=[1,2,3,4,5,6]
=& [1, 2, 3, 4, 5, 6]
irb(main):034:0& x.to_hash
=& {5=&6, 1=&2, 3=&4}
11. Hash的丢值行为?
任何时候修改了Hash的Key（记住Key是包括数组在内的目标），都会发生丢值行为。
irb(main):001:0& h=Hash.new
irb(main):002:0& x=[1,2,3]
=& [1, 2, 3]
irb(main):003:0& h[x]=4
irb(main):004:0& h[x]
irb(main):005:0& x&&4
=& [1, 2, 3, 4]
irb(main):006:0& h[x]
上述修改了键x的值，那么这个键对应的Value就丢失了。
解决办法是rehash。任何时候修改了Key的值，都要rehash一次。
irb(main):007:0& h.rehash
=& {[1, 2, 3, 4]=&4}
irb(main):008:0& h[x]
[笔记]Windows下安装Ruby过程中遇到的问题及解决方法
/linux/windows-install-ruby-problems.html
1) 问题1：编码错误
gem install chunky_png -v 1.3.3
ERROR: While executing gem … (Encoding::UndefinedConversionError)
U+7CFB to IBM437 in conversion from UTF-16LE to UTF-8 to IBM437
解决方法：
打开 ruby 安装目录下的 win32\registry.rb 文件，把
LOCALE = Encoding.find(Encoding.locale_charmap)
LOCALE = Encoding::UTF_8
2) 问题2：更新镜像
gem install chunky_png -v 1.3.3
ERROR: Could not find a valid gem ‘chunky_png’ (&= 0), here is why:
Unable to download data from https://rubygems.org/ – SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed (https://api.rubygems.org/latest_specs.4.8.gz)
链接被ruby.org关闭了，最开始以为是版本或者配置错误。后来搜索一下，应该是因为GFW的原因或者说实在是不稳定…
解决办法：
万能淘宝的镜像站http://ruby.taobao.org/。淘宝ruby资源站是完全的镜像复制，而且十五分钟复制更新一次，连接速度很快很稳定。
在命令行工具输入：
gem sources -a http://ruby.taobao.org/
等成功后再次执行前面的命令即可。
附：《如何快速正确的安装 Ruby, Rails 运行环境》
https://ruby-china.org/wiki/install_ruby_guide
ruby 2.0.0下 bundle install 证书出错解决方法
http://blog.chinaunix.net/uid-9793706-id-3506984.html
mac osx 10.8 下 ruby 升级2.0.0， 不能使用系统自带的openssl,
需要用brew 安装最新版本的openssl。
rails new xxx ,用 bundle install 时提示
/usr/local/homebrew/Cellar/ruby/2.0.0-p0/lib/ruby/2.0.0/net/http.rb:917:in `connect’: SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed (OpenSSL::SSL::SSLError)
原因是当前版本ruby使用的openssl没有相关证书， 把原系统的证书导过去就可以了。
/usr/bin/openssl version -d
/usr/local/opt/openssl/bin/openssl version -d
find-certificate -a -p /Library/Keychains/System.keychain & 11
security find-certificate -a -p /System/Library/Keychains/SystemRootCertificates.keychain & 11
cat 11 && /usr/local/etc/openssl/cert.pem
/openssl-certificate-verify-failed.html
/raggi/openssl-osx-ca/blob/master/bin/openssl-osx-ca
Ubuntu系统安装Ruby的三种方法
http://blog.csdn.net/chszs/article/details/
作者：chszs，转载需注明。博客主页：
Ruby是一个开源的动态编程语言，它有优美的语法，可用于构建可伸缩的Web应用程序。ruby gems可以很好地增强Ruby开发者的开发效率。
要在Ubuntu系统上安装Ruby，有几种方法，每种方法都只需几步就能搞定。
方法一：使用apt-get安装
可以直接使用两个命令完成Ruby的安装。
# sudo apt-get update
# sudo apt-get install ruby
# sudo apt-get install ruby2.0
方法二：使用brightbox ppa仓库安装
# sudo apt-get install python-software-properties
# sudo apt-add-repository ppa:brightbox/ruby-ng
# sudo apt-get update
# sudo apt-get install ruby2.1 ruby2.1-dev
方法三：使用RVM安装
RVM是Ruby的版本管理器工具。
1、安装RVM
# sudo apt-get curl
# curl -L https://get.rvm.io | bash -s stable
# source ~/.rvm/scripts/rvm
2、安装RVM的环境依赖
# rvm requirements
3、安装Ruby
# rvm install ruby
如果想在Ubuntu上安装多个Ruby版本，那么可以使用下面的命令来指定使用rvm作为默认的Ruby版本管理。
# rvm use ruby –default
检查当前成功安装的Ruby版本
# gem list
# gem install [gem-name]
比如gem-name可以写sass
如果要从本地安装gems，命令如下：
# gem install –local [path of gem file]
可以使用命令更新已安装的gems，命令如下：
# gem update –system
# gem update
在Ubuntu上安装ruby-china
/sjyyt/p/3164202.html
1.安装libpng
sudo apt-get install libpng-dev
2.安装imagemagick
sudo apt-get install imagemagick
3.安装MongoDB
参考文档：/community/articles/how-to-install-mongodb-on-ubuntu-12-04
4.安装Redis
参考了discourse文档中关于安装redis的说明
sudo su –
mkdir /tmp/redis_install
cd /tmp/redis_install
wget /files/redis-2.6.7.tar.gz
tar xvf redis-2.6.7.tar.gz
cd redis-2.6.7
make install
./install_server.sh
# Press enter to accept all the defaults
/etc/init.d/redis_6379 start
5.安装memcached
sudo apt-get install memcached
6.安装ruby-china
git clone git:///ruby-china/ruby-china.git
cd ruby-china
ruby setup.rb
# ensure that memcached has started up
我安装ruby-china的简要步骤
https://ruby-china.org/topics/1398
1、在GemFile 中加入TheRubyRacer
2、安装MongoDB: apt-get install mangodb
cp config/config.yml.default config/config.yml
cp config/mongoid.yml.default config/mongoid.yml
cp config/redis.yml.default config/redis.yml
bundle install
bundle update rails
rake assets:precompile
thin start -O -C config/thin.yml
x、 chmod +x ./script/resque
./script/resque start
bundle exec rake sunspot:solr:start
x、sudo apt-get install python-setuptools
x、sudo easy_install pygments
easy_install pygments # 或者 pip install pygments
rake db:migrate
如何快速正确的安装 Ruby, Rails 运行环境
/wangguihua_happy/blog/static//
如何快速正确的安装 Ruby, Rails 运行环境 – wangguihua_happy的日志 – 网易博客
步骤1 － 安装 RVM
RVM 是干什么的这里就不解释了，后面你将会慢慢搞明白。
$ curl -L https://get.rvm.io | bash -s stable
等待一段时间后就可以成功安装好 RVM。
然后，载入 RVM 环境（新开 Termal 就不用这么做了，会自动重新载入的）
$ source ~/.rvm/scripts/rvm
检查一下是否安装正确
$ rvm -v rvm 1.17.3 (stable) by Wayne E. Seguin &&, Michal Papis && [https://rvm.io/]
步骤2 － 用 RVM 安装 Ruby 环境
# 替换 Ruby 下载地址到国内淘宝镜像服务器 $ sed -i .bak 's!ftp.ruby-lang.org/pub/ruby!ruby.taobao.org/mirrors/ruby!' $rvm_path/config/db # 安装 readline 包 $ rvm pkg install readline # 安装 Ruby 1.9.2 $ rvm install 1.9.2 --with-readline-dir=$rvm_path/usr
或者可以安装 1.8.7 版本，也可以是 1.9.3，只要将后面的版本号跟换一下就可以了
同样继续等待漫长的下载，编译过程，完成以后，Ruby, Ruby Gems 就安装好了。
步骤3 － 设置 Ruby 版本
RVM 装好以后，需要执行下面的命令将指定版本的 Ruby 设置为系统默认版本
$ rvm 1.9.2 --default
同样，也可以用其他版本号，前提是你有用 rvm install 安装过那个版本
这个时候你可以测试是否正确
$ ruby -v ruby 1.9.2p290 ( revision 32553) [x86_64-darwin10.8.0]
$ gem -v 1.8.6
$ gem source -r https://rubygems.org/ $ gem source -a http://ruby.taobao.org
步骤4 － 安装 Rails 环境
上面 3 个步骤过后，Ruby 环境就安装好了，接下来安装 Rails
$ gem install bundler rails
然后测试安装是否正确
$ bundle -v Bundler version 1.0
$ rails -v Rails 3.2.1
然后开始你的 Ruby，Rails 之旅吧。
欢迎来到 Ruby 的世界！
如何快速正确的安装 Ruby, Rails 运行环境 – Wiki >> Ruby China
如何快速正确的安装 Ruby, Rails 运行环境
https://ruby-china.org/wiki/install_ruby_guide/
对于新入门的开发者，如何安装 Ruby, Ruby Gems 和 Rails 的运行环境可能会是个问题，本页主要介绍如何用一条靠谱的路子快速安装 Ruby 开发环境。
次安装方法同样适用于产品环境！
首先确定操作系统环境，不建议在 Windows 上面搞，所以你需要用:
任意 Linux 发行版本(,, Redhat, ArchLinux …)
强烈新手使用 Ubuntu 省掉不必要的麻烦！
以下代码区域，带有 $ 打头的表示需要在控制台（终端）下面执行（不包括 $ 符号）
步骤0 － 安装系统需要的包
# 先安装 [Xcode](/xcode/) 开发工具，它将帮你安装好 Unix 环境需要的开发包
# 然后安装 [Homebrew](http://brew.sh)
ruby -e "$(curl -fsSL /mxcl/homebrew/go/install)"
步骤1 － 安装 RVM
RVM 是干什么的这里就不解释了，后面你将会慢慢搞明白。
$ curl -L https://get.rvm.io | bash -s stable
期间可能会问你sudo管理员密码，以及自动通过homebrew安装依赖包，等待一段时间后就可以成功安装好 RVM。
然后，载入 RVM 环境（新开 Termal 就不用这么做了，会自动重新载入的）
$ source ~/.rvm/scripts/rvm
检查一下是否安装正确
rvm 1.22.17 (stable) by Wayne E. Seguin &&, Michal Papis && [https://rvm.io/]
步骤2 － 用 RVM 安装 Ruby 环境
$ rvm install 2.0.0
同样继续等待漫长的下载，编译过程，完成以后，Ruby, Ruby Gems 就安装好了。
步骤3 － 设置 Ruby 版本
RVM 装好以后，需要执行下面的命令将指定版本的 Ruby 设置为系统默认版本
$ rvm 2.0.0 --default
同样，也可以用其他版本号，前提是你有用 rvm install 安装过那个版本
这个时候你可以测试是否正确
ruby 2.0.0p247 ( revision 41674) [x86_64-darwin13.0.0]
$ gem source -r https://rubygems.org/
$ gem source -a https://ruby.taobao.org
步骤4 － 安装 Rails 环境
上面 3 个步骤过后，Ruby 环境就安装好了，接下来安装 Rails
$ gem install rails
然后测试安装是否正确
$ rails -v
Rails 3.2.13
然后开始你的 Ruby，Rails 之旅吧。
欢迎来到 Ruby 的世界！
– 快速安装生产环境的 Ubuntu Server 批量脚本
Ruby-China网站源代码包的本地安装
/likeyu/archive//2367379.html
1、Ruby-China网站源代码包：
$ cd ~/workspace
$ git clone
2、如果想要省心一点，请千万不要尝试在WINDOWS下安装。昨晚上花了30分钟尝试WINDOWS下安装，还安装了git的WINDOWS客户端，各种报错，解决了几个，后来太晚了，睡觉作罢。
3、今天使用UBUNTU LINUX 11.10来安装。上午花了半小时。晚上，边安装，边学习又花了近2小时。已在本地完成全部部署，测试暂未发现问题。（安装LOG在这里： ）
===================================================
接下来才是正文，是整个安装过程的整理。
1、在/home/yourname/下建个目录放ruby-china的源代码。编辑GemFile： 加入execjs 和 TheRubyRacer
$ cd ~/project
$ git clone
$ vi ~/project/ruby-china/GemFile
gem ‘execjs’
gem ‘therubyracer’
2、安装MongoDB:
（MongoDB是一种文件导向数据库：）
sudo apt-get install mongodb
安装完即可，不用过多配置。不过需要手工建立
/data/db 目录： sudo mkdir -p /data/db
&& sudo chmod 755 -R /data/db
测试 （启动 sudo mongod，每次开机系统会自动启动）
& db.foo.save( { a : 1 } )
& db.foo.find()　　
3、安装redis： （Redis是一个开源的使用语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库
sudo apt-get install redis-server
同样不用过多配置。测试（
niuniuqiu@niuniuqiu:~/projects/ruby-china$ redis-cli
redis 127.0.0.1:6379& set foo bar
redis 127.0.0.1:6379& get foo
Redis命令参考简体中文版 （
4、按照官方文档做：
cp config/config.yml.default config/config.yml
cp config/mongoid.yml.default config/mongoid.yml
cp config/redis.yml.default config/redis.yml
bundle install
bundle update rails
rake assets:precompile
thin start -O -C config/thin.yml
可能需要：
chmod +x ./script/resque
./script/resque start
bundle exec rake sunspot:solr:start
5、安装 python-setuptools
sudo apt-get install python-setuptools
6、继续按照官方文档做：
sudo easy_install pygments
# 或者 sudo pip install pygments
7、安装数据库
rake db:migrate
8、我下载的Ruby-China网站源代码包中对db/seeds.rb 相关的 插入代码的语句，已被注释了？
导致 发帖子的时候选择主题类型没用东西可以选，发不了贴。提交:Node 不能为空字符
去掉注释后运行 rake db:seed 即可将这些数据插入。
BTW：现在突然想到其实这部分数据之所以被注释是因为，应该由管理员从后台来维护这部分数据。可是现在不能创建用户，也建立不了管理员用户？好像变成了一个悖论？
8 插入初始化数据：
rake db:seed
9、这时候可以启动WEB服务器了
rails server
(缩写rails s）
10、一个BUG？
发现用户无法退出，出现 所说的情况（用户登录后，我想注销，鼠标点到用户名上，下拉菜单出不来）时，，按照 回帖中指明的方法处理后，恢复正常。
【quakewang : 看上去是precompile的asset导致的，你清空 public/assets 然后清理一下浏览器缓存就能够恢复正常。开发环境下请求获得的application.js内容不应该包含其他js。】
11、管理员后台登陆。
先在前台用户注册中注册一个普通用户，记住邮件地址。然后修改config/config.yml 中的 admin_emails: “ ” （源代码中写成了两行，貌似需要移动到同一行中，多个用户可以用空格分隔）,
普通用户即变成了管理员用户。进入后台管理界面
http://localhost:3000/cpanel 。
管理员检测的相关代码：projects/ruby-china/app/controllers/cpanel/application_controller.rb (RoR就是这么简练)
before_filter :require_admin
def require_admin
　　if not Setting.admin_emails.include?(current_user.email)
　　　　render_404
12、差不多就这么多了，Deploy部分是互联网环境部署时才会用到的。 不要在学习环境中执行。config/config.yml 还有其他的一些配置选项，，一看就懂的。
最后感谢 ruby-china.org 社区各位大大。新手上路，请多指导。
ruby学习之路(一)
/netbuddy/p/3501147.html
学习ruby最好的方法就是下载源码包，里面带有sample和test，是入门学习的最好实例。
我下载的是2.1.0版本，首先./configure，然后make，sudo make install。从common.mk文件中可看出，包含有两类test：test和test-all，test主要是对sample/test.rb进行测试，test-all用于对test文件夹中的用例进行测试。
在make test-all过程中，提示未找到zlib，需要通过gem下载，下面就复习一下gem的语法
gem相关命令使用
1.显示gem的帮助和版本
gem –h/–help
#显示gem的帮助
gem –v /–version
#显示gem的版本号
2. 列出远程库的所有可用软件
gem query –remote
# 短命令: gem q -r
你可以看到一个关于远程主机上所有软件的详细列表。
3. 查找远程主机上的特定软件
gem query –remote –name-matches doom
# 短命令: gem q -rn doom
你将看到一个匹配doom的详细列表。
gem list –remote –d
#用子命令list列出远程安装的gems
4.1 安装一个远程软件
gem install –remote progressbar
# 短命令: gem i -r progressbar –y
远程安装progressbar到你的主机，-y的意思是无条件的安装依赖包
gem install rails –remote
#从远程服务器安装rails包，其中rails可以被替换成任何一个gem list –remote –d中显示的软件包
4.2 安装软件的特定版本
gem ins -r progressbar-0.0.3
安装progressbar的0.0.3版本
gem ins -r progressbar –version ‘& 0.0.1’
将安装progressbar的大于0.0.1的最新版本
5. 查看一个已安装的软件
gem specification progressbar
# 短命令: gem spec progressbar
你会看到关于已安装的包progressbar的详细信息。
6. 卸载一个软件
gem uninstall progressbar
卸载了progressbar
7.1 将所有安装的软件列表
gem query –local
# 短命令: ‘gem q -l’
7.2 查看某个已安装的软件
gem query –local –name-matches doom
# 短命令: ‘gem q -ln doom’
或：gem list –local
7.3 需要注意的安装方法
gem ins rake
会先尝试本地安装，如果本地没有就会远程下载。
gem list -b ^C
列出本地和远程的以C开头的软件
8. 浏览所有安装的软件和它们的说明文档
gem_server
会生成一个web服务器，打开http://localhost:8808
就可以看到一个html详细列出了你需要的信息。
9. 使用配置文件
gem: –gen-rdoc –run-tests
如果你想安装软件后总是生成它们的文档和运行单元测试，你可以在配制文件里写上相关的命令，配置文件名是.gemrc，在主目录里。
10. 构建gem包
gem build package.gemspec
#运用bulid子命令构建gem包
参考自园中麦子加菲的博客
下载gem之前，首先将gem的源更换为淘宝网，步骤如下
$ gem sources –remove https://rubygems.org/
$ gem sources -a http://ruby.taobao.org/
$ gem sources -l
*** CURRENT SOURCES ***
http://ruby.taobao.org
当执行到gem sources -a http://ruby.taobao.org/时报错：
ERROR: While executing gem … (NameError)
uninitialized constant Gem::RemoteFetcher::Zlib
原因是下载列表时需要zlib库，而ruby中没有带这个库，想将源换回之前的库gem sources -a https://rubygems.org/又报错：
ERROR: While executing gem … (Gem::Exception)
Unable to require openssl, install OpenSSL and rebuild ruby (preferred) or use non-HTTPS sources
因此必须安装zlib，从zlib.net网站下载源码包，编译安装后进入ruby源码文件夹，安装ruby自身提供的zlib包
$cd ext/zlib
$ruby ./extconf.rb
$make install
然后再执行gem sources -a http://ruby.taobao.org/，源更改成功
ruby on rails为什么暂时无法成为企业应用开发的主流？
/topic/24499
ruby on rails为什么暂时无法成为企业应用开发的主流？ – Rails – language – ITeye论坛
今天上午和庄表伟在msn上交流了一些看法，下午和JavaEye2.0的主力开发人员讨论了关于ruby on rails在企业应用开发和团队协作的问题。通过讨论，有了一些初步的想法和观点，虽然还不是很清晰，但是现在总结和记录下来，留待今后的实践来验证。
ozzzzzz在中提出了一个衡量未来主流工业语言的标准，其中有一条很有意思：
ozzzzzz 写道
1. 应该能规范书写，而不是像c那样可以造就多种不同的风格。
Java明显是一个编程风格非常容易统一起来的语言，而ruby则很明显是一个难以统一编程风格的语言。JavaEye论坛里面有人曾经说过：
Java语言，高手和低手写出来的代码都差不多，而ruby则不同，高手和低手的代码，高下立判
Java编程语言的语法非常简单，规范比较严密，这样规范化带来的好处就是，一旦程序员具有比较良好的面向对象编程基础和设计模式的掌握，那么编写出来的代码几乎是大同小异的。
为什么优秀的Java开源框架的源代码我们读起来都比较容易呢？为什么Java那么容易写出来无二义性，相似度那么高的代码风格呢？为什么用Java做同样一件事情，往往只有一种最优的写法呢？为什么Java很难搞出来奇技淫巧呢？为什么Java语言一直被人认为是大巧若拙呢？我们再想想，为什么JDK5.0引入的技巧颇高的泛型编程到现在也有三年，为什么还是没有被广泛采用？再想想Java语言被设计出来是用在什么场合的呢？
想清楚这些问题，那么我们就会发现Java成为企业应用开发主流的一个内在原因(外因也很多，这里不谈)，因为Java语言足够死板！
所以写Java程序没有什么花巧，所以为了弄出来点花巧，逼的Java社区搞出来动态反射，搞出来AOP，抄袭了泛型，其目的都是增加Java语言的灵活性。
那么Java这种死板而简单的语言有什么好处呢？好处就是适合作为工业语言！
那么我们分析一下工业语言在语法上面有着什么样的要求呢？
1、语法足够简单而且强壮
2、语法足够死板、做同样的事情，只有一种最优解
3、足够的语法障碍，抑制你的随意发挥，给我规规矩矩的编码
工业语言为什么有这种内在的要求呢？
1、团队协作的需要
大规模的项目需要几十人以上的协作，甚至是异地协作。这种大规模的团队协作要求程序员的代码风格必须高度一致，并且代码块之间的依赖性降到最低。显然死板而容易解藕的Java非常的合格
2、批量生产的需要
现在的软件外包产业体现的尤为明显！不需要你的创意，不需要你的设计，就需要你的coding，而且coding风格，功能已经规定死了。Java显然又非常合适。
好了，上面分析了从语法特点角度，为什么Java成为了工业语言，那么再分析一下为什么ruby不能成为工业语言：
1、ruby的语法过于灵活，发挥的余地太大，导致每个人的代码风格迥异
我刚开始学习ruby的时候非常不适应，被ruby五花八门的语法糖衣搞晕了，同样的一件事情，你有无数种做法，笨拙的，普通的，聪明的，天才的，各式各样，甚至有本《ruby quiz》的书专门讲解ruby编程的各种奇技淫巧。ruby这种内在语法特性直接造就了ruby on rails奇迹。在ruby on rails框架里面，有无数的ruby magic，好用之极又让你惊喜万分，没有ruby这么多灵活的语法支持，rails变不出来这么多魔术。
但是ruby的语法灵活性恰恰是成为工业语言的一大障碍！Java绝顶高手和Java普通高手的代码在风格上不会有大的差别(我就不觉得Rod Johnson代码比我高明到哪里去)，但是ruby绝顶高手和ruby普通高手的代码简直判若云泥！高下立判！绝顶高手如DHH把ruby用的出神入化叹服之余，也让你我之辈根本无法写出来符合DHH风格的ruby代码。
在我们JavaEye2.0网站开发中，也出现了这种问题，两个人写的ruby代码，互相之间理解起来存在困难。而由于做一件事情有很多ruby写法，不同性格的人甚至都会选择不同的实现方法，在一个团队中，要统一编码风格，实在难乎其难！而在Java项目中，基本可以杜绝此类问题。
由于代码风格难以统一，因此在大规模的团队中使用ruby编程，会造成合作上面的障碍！
2、ruby on rails会导致你的代码藕合度非常高，不利于团队协作开发
由于rails规定死你的代码框架，不论是横向的功能解藕，还是纵向的分层解藕，都比较困难。
首先来说纵向的分层解藕，这是Java大规模项目常用的办法，但是在ruby on rails中基本不可能。因为ruby on rails各层之间的隐式约定太多了，你不可能分层开发。目前ruby on rails项目都是建议横向功能解藕，不建议纵向分层解藕的。
再说横向功能解藕：首先每个人必须承担足够大颗粒度的功能模块，不能拆分的太细了。因为rails的一个Controller文件就代表一大块功能了。
例如JavaEye2.0中，整个forum就只有一个controller，整个blog也就只有一个controller。当然你惊叹，整个forum代码就一个文件搞定了啊，代码太少了！但是反过来，你也可以说，论坛这个功能只能交给一个人来做了，没有办法再拆分功能了。这就带来了一个问题，团队协作变的困难了，如果两个人同时做论坛模块，就会出现经常性的该controller文件冲突合并。即使妥协一下，每个人只负责一个大功能块，但是底层的model代码都是互相关联在一起的。又难以避免的并发修改和文件冲突合并。
但是Java不存在这个问题，为什么呢？因为Java把一个Controller分解成为了无数个小Action，把一个Model分解成为了PO，DAO，Service，进行了充分的功能职责的解藕，每个人的工作基本不会互相干扰，那么团队协作的问题就好办了。
在JavaEye2.0开发过程中，就遇到了这个问题，即使是分出来一小部分任务，也经常性导致文件冲突合并，最后只能把大部分的程序任务压到了jerry一个人身上。可敬的jerry同学几乎以一人之力编写了整个JavaEye2.0的绝大多数代码。在惊叹jerry以一个人月的高效率完成整个JavaEye2.0编码工作的同时，我们也不得不反思，为什么ruby on rails这样难以团队协作开发呢？
在我最推崇的《Getting Real》这本书里面建议一个开发团队3个人足够了，一个人设计规划产品功能，一个人设计界面，一个人编写代码。我们现在也是这样的：robbin设计产品功能，ouspec负责界面，jerry编写代码，然后robbin和ouspec负责测试。但并不是所有的项目都可以靠3个人搞定的，大规模应用项目团队协作进行开发，我们目前还没有答案。
jerry有个观点我非常赞同，他认为目前我们没有找到合适的团队协作方法是因为现在的软件开发方法都不适合ruby on rails开发团队。而真正适合ruby on rails的软件开发方法究竟是什么样子，现在还没有出现，恐怕需要人们的探索了。ruby on rails流行必须伴随着适合ruby on rails的软件开发方法一起出现才行。
因此在人们总结出来这种适合ruby on rails的软件开发方法之前，ruby on rails仍然会被局限在web2.0开发领域，在这个领域，ruby on rails的所有优点将发挥的淋漓尽致，而缺点将会被回避开。不过一旦涉及到企业应用开发领域，我们将面临这些问题。
因此，我的结论就是ruby on rails目前尚且不适合企业应用项目的开发。当然如果有适合ruby on rails的软件开发指导方法的出现，或者企业应用本身的定义已经发生了彻底的改变，那么我的结论也就不复存在了。
用一句话来总结就是：
ruby on rails是武林高手的绝世宝剑，却不是两军对垒中士兵使用的常规作战武器(Java却是这种常规武器)。
BTW：我抛出来这个结论，并不代表我的想法已经很成熟了，事实上这也只是我们第一次尝试使用ruby on rails，在不熟悉不了解的情况下做出结论，未免过于草率，但是我之目的在于抛砖引玉，目前我们在开发中遇到了这些团队协作方面的问题，希望我的抛砖能够引出来好玉，解决这些我们还没有想到很好解决办法的问题，多谢啦，哈哈！
美国编程语言薪资排行榜 Ruby局首
/news/2177.html
计算机编程已迅速成为美国最赚钱的行业之一。随着计算机程序员的平均年薪接近10万美元，计算机编程行业的平均年薪迎来了历史最高值。
不过Quartz（QZ.COM）网站编辑的数据显示，掌握不同的计算机语言和技能，也会体现在计算机程序员的收入上。根据美国著名智库布鲁金斯学会（Brookings Institution）在今年7月发布的研究报告，Quartz的编辑迈克斯·尼森（Max Nisen）排列出掌握不同的计算机语言，能够让程序员获得什么样的薪酬。以下为相关排序：
第一：Ruby on Rails，平均薪酬10.9460万美元；
第二：Objective C，平均薪酬10.8225万美元；
第三：Python，平均薪酬10.0717万美元；
第四：JAVA，平均薪酬9.4908万美元；
第五：C++，平均薪酬9.3502万美元；
第六：JavaScript，平均薪酬9.1461万美元；
第七：C，平均薪酬9.0134万美元；
第八：R，平均薪酬9.0055万美元；
第九：C#，平均薪酬8.9074万美元；
第十：Visual Basic，平均薪酬8.5962万美元；
第十一：SQL，平均薪酬8.5511万美元；
第十二：PERL，平均薪酬8.2513万美元。
虽然掌握上述的编程语言能够让程序员获得10万美元的年薪，但是成为一名Salesforce架构师，却能够让程序员获得科技产业的最高薪酬。IT猎头公司Mondo在今年3月发布的报告显示，Salesforce架构师的年薪能够达到18万美元至20万美元。
本文来源于&b&大学IT网&/b&
原文链接：&a href=’/news/2177.html’&/news/2177.html&/a&
我的第一个Ruby On Rails + MongoDB程序
http://blog.csdn.net/mydeman/article/details/6889316
我的第一个Ruby On Rails + MongoDB程序 – mydeman的学习日志 – 博客频道 – CSDN.NET
最近想进一步学习一下MongoDB，而很久之前使用过ROR，正好也凑个机会重新拾起来。下面是建立第一个项目的过程。
主要参考文档：
(可能需要翻墙)
(可能需要翻墙)
一、创建程序的框架
创建项目时不再使用rails active_record支持：
$ rails new todo -O
$ rails new todo -O
依次完成文档1中的所提示的步骤。
1. 编辑GemFile，增加下面的内容：
source “http://gemcutter.org”
gem “mongo_mapper”
source "http://gemcutter.org"
gem "mongo_mapper"
$ bundle install
$ bundle install
安装项目的依赖包
3. 在config/initializer下面新建一个mongo.rb文件，指定全局的数据库信息：
MongoMapper.connection = Mongo::Connection.new(‘localhost’, 27017)
MongoMapper.database = ‘todo’
if defined?(PhusionPassenger)
PhusionPassenger.on_event(:starting_worker_process) do |forked|
MongoMapper.connection.connect if forked
MongoMapper.connection = Mongo::Connection.new('localhost', 27017)
MongoMapper.database = 'todo' #为了简单起见，没有为不同的环境指定不同的数据
if defined?(PhusionPassenger)
PhusionPassenger.on_event(:starting_worker_process) do |forked|
MongoMapper.connection.connect if forked
4. 在lib目录下面新建一个mongo.rake文件（在本文中还没有用到）
namespace :db do
namespace :test do
task :prepare do
namespace :db do
namespace :test do
task :prepare do
# Stub out for MongoDB
完成以上步骤后，启动程序：
$ rails server
**Notice: C extension not loaded. This is required for optimum MongoDB Ruby driver performance.
You can install the extension as follows:
gem install bson_ext
If you continue to receive this message after installing, make sure that the
bson_ext gem is in your load path and that the bson_ext and mongo gems are of the same version.
=& Booting WEBrick
=& Rails 3.0.10 application starting in development on http://0.0.0.0:3000
=& Call with -d to detach
=& Ctrl-C to shutdown server
[ 23:36:14] INFO
WEBrick 1.3.1
[ 23:36:14] INFO
ruby 1.9.2 () [x86_64-linux]
[ 23:36:14] INFO
WEBrick::HTTPServer#start: pid=19595 port=3000
$ rails server
**Notice: C extension not loaded. This is required for optimum MongoDB Ruby driver performance.
You can install the extension as follows:
gem install bson_ext
If you continue to receive this message after installing, make sure that the
bson_ext gem is in your load path and that the bson_ext and mongo gems are of the same version.
=& Booting WEBrick
=& Rails 3.0.10 application starting in development on http://0.0.0.0:3000
=& Call with -d to detach
=& Ctrl-C to shutdown server
[ 23:36:14] INFO
WEBrick 1.3.1
[ 23:36:14] INFO
ruby 1.9.2 () [x86_64-linux]
[ 23:36:14] INFO
WEBrick::HTTPServer#start: pid=19595 port=3000
从上面输出中可以看到bson_ext库没有加载。首先按照提示安装该库：
sudo gem install bson_ext
sudo gem install bson_ext
然后编辑GemFile，加入下面一行：
gem “bson_ext”
gem "bson_ext"
再次启动程序，Notice提示消息消失，启动正常。在浏览器输入：http://127.0.0.1:3000，就可以看到如下页面：
二、添加页面和处理逻辑
通过rails的generate命令来生成页面、控制器和模型层文件：
$ rails generate scaffold project name:string –orm=mongo_mapper
$ rails generate scaffold project name:string --orm=mongo_mapper
命令执行完毕后，重新启动服务器，在浏览器输入中：http://127.0.0.1/projects，就可以看到如下：
点击New Project链接，添加一个新项目：
输入项目名称后，点击Create Project按钮保存
点击Back链接回到列表页面，可以看到新创建的项目blog，已经在列表里了：
登录到MongoDB数据库中可以查询到刚刚插入的数据：
到现在为止还没有写一行代码。不过先到这里吧，以后接着续。
在Ruby把MySQL做NoSQL用 Friendly简介
/blog/602245
Friendly是一个github上的一个插件，起源是因为FriendFeed把MySQL做NoSQL的用，具体参见这篇：
/entry/how-friendfeed-uses-mysql
Friendly就是这样的作用，把MySQL变成一个文件数据库来用。NoSQL日趋狂热，schemaless是其中一个原因。客户端的改变可以将MySQL达到同样目的。下面是简单的介绍：
安装friendly
Ruby代码 复制代码 收藏代码
1.sudo gem install friendly
Ruby代码 复制代码 收藏代码
1.#environment.rb:
2. config.gem “friendly”
Ruby代码 复制代码 收藏代码
1.#and create a config/friendly.yml:
3. development:
4. :adapter: “mysql”
5. :host: “localhost”
6. :user: “root”
7. :password: “swordfish”
8. :database: “friendly_development”
没有使用Rails:
Ruby代码 复制代码 收藏代码
1.Friendly.configure :adapter =& “mysql”,
2. :host =& “localhost”,
3. :user =& “root”,
4. :password =& “swordfish”,
5. :database =& “playing_with_friendly”
Ruby代码 复制代码 收藏代码
1.class BlogPost
2. include Friendly::Document
4. attribute :author, String
5. attribute :title, String
6. attribute :body, String
Ruby代码 复制代码 收藏代码
1.#script/console:
3. Friendly.create_tables!
Ruby代码 复制代码 收藏代码
1.class BlogPost
2. include Friendly::Document
4. attribute :author, String
5. attribute :title, String
6. attribute :body, String
8. indexes :author
9. indexes :created_at
Ruby代码 复制代码 收藏代码
1.#Run create_tables again and the index tables will be created for you.
2. Friendly.create_tables!
创建Objects
Ruby代码 复制代码 收藏代码
1.#With familiar ActiveRecord syntax:
2. BlogPost.create :author =& “James Golick”,
3. :title =& “Friendly has familiar syntax.”,
4. :body =& “So, there’s very little learning curve.”
Ruby代码 复制代码 收藏代码
1.BlogPost.all(:author =& “James Golick”)
Ruby代码 复制代码 收藏代码
1.#Most recent posts:
3. BlogPost.all(:order! =& :created_at.desc)
Ruby代码 复制代码 收藏代码
1.#Install the memcached gem:
3. sudo gem install memcached
5.#配置 Friendly:
7. Friendly.cache = Friendly::Memcached.new(Memcached.new)
9.#Configure your model to cache:
11. class BlogPost
12. include Friendly::Document
14. attribute :author, String
15. attribute :title, String
16. attribute :body, String
18. indexes :author
19. indexes :created_at
21. caches_by :id
关注“Linux运维技术”微信公众号
2016年十一月
21222324252627