kenlistian

ruby作为动态语言，不仅用于rail，还可以作为胶水语言广泛用于其他。

在我们常常采用config。ini来处理设置，在ruby中，采用yaml包来解决来解决在config。ini做设置。

先开始认识yaml是什么，（具体看：http://www.yaml.org/）

YAML是"Yet Another Markup Language(另一种标记语言)"的缩写，读音"yamel",或者"雅梅尔"。这种格式大约是2001年出现的，目前为止已经有多种语言的YAML解析器。

YAML是一种直观的能够被电脑识别的的数据数据序列化格式，它并且容易被人类阅读，容易与脚本语言交互的。

换种说法，YAML是一种非常简单的类似于XML的数据描述语言，语法比XML简单很多。他在描述可以被转化成数组或者hash的数据是非常有用。

在YAML里面，

1.结构通过缩进来表示，

2.连续的项目通过减号"-"来表示，

3.map结构里面的key/value对用冒号":"来分隔。

YAML也有用来描述好几行相同结构的数据的缩写语法，数组用'[]'包括起来，hash用'{}'来包括。因此，YAML表达一个简单的config.ini文件

[sys]

database=pubs

username=sa

pwd=sa

可以写到一个points.yml文件中

sys :

{database : pubs , username : sa pwd : sa}

注意：冒号2边要留空格，否则yaml 中的hash解析不出

在ruby中，写一个读取例子，

require 'yaml'
points = YAML.load(IO.read('points.yml'))

points.each{|point|
p point
ss = point[1]
print "database :", ss["database"], "\n"
print "user:" , ss["user"], "\n"
print "pwd:" , ss["pwd"], "\n"
}

则

---------- ruby ----------
["sys", {"user"=>"sa", "pwd"=>"sa", "database"=>"pubs"}]
database :pubs
user:sa
pwd:sa

这篇文章介绍yaml比我深，一并备注；

http://blog.csdn.net/smilewater/archive/2007/07/05/1679835.aspx

********************

yaml的语法标记；

YAML语言元素

1 列表（List）

表示一个列表很简单，在每个条目前加入一个短横线。比如

- Item1
- Item2
- Item3

在Ruby中会被解释为数组对象（Array），上例为：

["Item1", "Item2", "Item3"]

2.哈希表（Hash）

哈希表的键/值之间用冒号（:）进行分隔。

key1 : value1
key2 : value2
key3 : value3

在Ruby中会被解释为如下的哈希对象：

{"key1"=>"value1", "key2"=>"value2", "key3"=>"value3"}

3. 字符串和其它基本类型

YAML会自动判断类型，一般性的文字都会被解释为字符串。在有可能发生歧义的情况下，可以为字符串加上单引号或者双引号（在双引号下转义字符会被转义，转义方式与C语言类似）来避免歧义。

下面是一个例子，包含了字符串、整数、浮点数和日期类型：

1 : 1.0
1.0 : "1.0"
"1.0" : 2006-01-01

它会被解释为：

{1=>1.0, "1.0"=>#<Date: 4907473/2,0,2299161>, 1.0=>"1.0"}

可以看出它的类型被很好的识别出来。

4. 字符串块

字符串可能会占据多行，可以用两种方式来处理这种情况，一种是保留换行符，另外一种则去除换行符。

用| 表示保留换行符：

|
This is line1.
This is line2.
This is line3.

解释为：

"This is line1.\nThis is line2.\nThis is line3."

用>表示删除换行符：

>
Hello,
world.

解释为：

"Hello, world."

以上是一些常用的基本类型，当然它们还可以组合为更复杂的结构，比如列表的内容可以是列表本身，也可以是哈希表；哈希表的内容也可以是列表或哈希表，它们可以嵌套使用，来获得非常复杂的结构。

加入了google的 Analytics功能，

1.在打开一个网页后。

2.运行后下载urchin.js，

3.执行urchinTracker();向www.google-analytics.com发送一个url串，这个串是以image/gif格式类型发送，

其中所带的参数是注册analytics的id号以及关联的网站信息，后面其中通过urchin.js产生的一个串

该串以后再分析。

get后，Responsegoogle返回如下：

HTTP/1.1 200 OK
Pragma: no-cache
Cache-Control: private, no-cache, no-cache="Set-Cookie", proxy-revalidate
Expires: Fri, 04 Aug 1978 12:00:00 GMT
Content-Type: image/gif
Last-Modified: Sat, 15 Mar 2008 23:55:55 GMT
Server: ucfe
Content-Length: 35
Date: Wed, 19 Mar 2008 06:27:37 GMT

其中解body没有任何包体发送。

4。然后ie再向打开的网站get /favicon.ico，如果没有则Response 404

在这里get or post时，就带cookie了，其中cookie就是由urchin。js负责产生和记录。

当下次刷新，级别运行缓存中的urchin。js了。

require "net/http"
require "net/https"
require "erb"
require "singleton"

PANEL = 'panel.dreamhost.com'
PATH = '/index.cgi'
USERAGENT = 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.1) Gecko/20060111 Firefox/1.5.0.1'

class Panel
include Singleton
def Panel.login(webid, password)
unless @headers.nil?
raise ScriptError, "You should already be logged in!"
end
@http = Net::HTTP.new(PANEL, 443)
@http.use_ssl = true
resp, data = @http.get2(PATH, {'User-Agent' => USERAGENT})
cookie = resp.response['set-cookie'].split('; ')[0]
#主要它应付了有些网站需要cookie的要求
data = "Nscmd=Nlogin&username=#{ERB::Util.url_encode(webid)}&password=#{ERB::Util.url_encode(password)}&submit=Log%20In"
@headers = {
'Cookie' => cookie,
'Referer' => 'https://'+PANEL+PATH,
'Content-Type' => 'application/x-www-form-urlencoded',
'User-Agent' => USERAGENT
}

puts "headers = " + @headers.inspect
resp, data = @http.post2(PATH, data, @headers)

# Output on the screen -> we should get either a 302 redirect (after a successful login) or an error page
puts 'Code = ' + resp.code
puts 'Message = ' + resp.message
resp.each {|key, val| puts key + ' = ' + val}
puts data
end
end

调用

Panel.login("kenlistian", "password")

摘自老外的片段，学习用。

方法一：

def URLDecode(str)
str.gsub!(/%[a-fA-F0-9]{2}/) { |x| x = x[1..2].hex.chr }
end

def URLEncode(str)
str.gsub!(/[^\w$&\-+.,\/:;=?@]/) { |x| x = format("%%%x", x[0]) }
end

链接：http://www.2maomao.com/blog/2-ruby-cookies-en-de-code/

方法二：

采用ERB::Util.url_encode()

其中在url_encode 处理如下

def url_encode(s)
s.to_s.gsub(/[^a-zA-Z0-9_\-.]/n){ sprintf("%%%02X", $&.unpack("C")[0]) }
end

在正则表达式中：

[^a-zA-Z0-9_\-.]表示匹配非a-z 和A-Z 包括0-9 以及下划线和-中横线 的字符，

$& 全局变量，匹配到的字符串存放在 $& 变量中

uppack 是字符对象中的一个方法：是拆字符到数组的函数，

str.unpack( format ) -> anArray

Decodes str (which may contain binary data) according to the format string,

returning an array of each value extracted. 。。

其中C表示按字符拆。还有参数如下：

Directives for String#unpack

Format Function Returns

A String with trailing nulls and spaces removed. String

a String. String

B Extract bits from each character (msb first). String

b Extract bits from each character (lsb first). String

C Extract a character as an unsigned integer. Fixnum

c Extract a character as an integer. Fixnum

d Treat sizeof(double) characters as a native double. Float

E Treat sizeof(double) characters as a double in little-endian byte order. Float

e Treat sizeof(float) characters as a float in little-endian byte order. Float

f Treat sizeof(float) characters as a native float. Float

G Treat sizeof(double) characters as a double in network byte order. Float

g Treat sizeof(float) characters as a float in network byte order. Float

H Extract hex nibbles from each character (most significant first). String

h Extract hex nibbles from each character (least significant first). String

I Treat sizeof(int) ¹ successive characters as an unsigned native integer. Integer

i Treat sizeof(int) ¹ successive characters as a signed native integer. Integer

L Treat four¹ successive characters as an unsigned native long integer. Integer

l Treat four¹ successive characters as a signed native long integer. Integer

M Extract a quoted-printable string. String

m Extract a base64 encoded string. String 能把base64直接解出。

N Treat four characters as an unsigned long in network byte order. Fixnum

n Treat two characters as an unsigned short in network byte order. Fixnum

P Treat sizeof(char *) characters as a pointer, and return len characters from the referenced location. String

p Treat sizeof(char *) characters as a pointer to a null-terminated string. String

S Treat two¹ successive characters as an unsigned short in native byte order. Fixnum

s Treat two¹ successive characters as a signed short in native byte order. Fixnum

U Extract UTF-8 characters as unsigned integers. Integer

u Extract a UU-encoded string. String

V Treat four characters as an unsigned long in little-endian byte order. Fixnum

v Treat two characters as an unsigned short in little-endian byte order. Fixnum

X Skip backward one character. ---

x Skip forward one character. ---

Z String with trailing nulls removed. String

@ Skip to the offset given by the length argument.

其中参数带个上述格式，还可在格式后跟个数字or*，表示做几次拆解，

我靠，日本人搞的东西咋这么复杂呢，以为是unix啊，@#￥%！@#￥！，慢慢看吧。

自我感觉比c难学。不过他这一步就可以做好多事情，很好很强大啊。

1. Java：内部字符串用Unicode保存，基本上不用关注这个问题。正则表达式、字符计数和字串截取都工作正常。

2. Perl: 存在两种字符模式，一个是传统的面向字节的，另一个是面向unicode字符的。在后面一种情况下，Perl在内部用UTF-8编码存储字符串。对于 UTF-8字符串，可以使用传统的字符串操作函数，比如length，substr，也可以使用正则表达式，结果确保正确。Perl使用哪种字符模式，主要取决于流的设置，这个设置是通过binmode函数来进行的。对于在程序文本中出现的字符串，当然是以文件本身的编码方式存储的。经常发生的情况是，程序本身用ANSI编码编写（比如CP936），但是处理汉字的时候需要转换成UTF-8，这时候可以用Encode模块里的decode函数讲字符串转成 UTF-8。反过来，encode函数可以把UTF-8编码的Perl字符串转换成CP936，这样就能够在控制台上打印出来。

3. Python: 为了支持Unicode，整个做了一个Unicode内建对象，把string对象的全部方法重新实现了一遍。Python对Unicode的支持比较简单。比如 s = unicode('给他5个dollar!", 'gbk')，就能得到一个unicode对象。上面调用中的'gbk'参数是说传过去的字符串是用GBK编码的。对于得到的这个unicode对象，调用string同名方法，所有的结果都是正确的。

4. Ruby：Ruby对于Unicode的支持最差，或者说根本没有支持。Ruby始终只是把String看成是字节序列。使用Ruby处理中文，要用 iconv库转来转去。Ruby的正则表达式对unicode不友好。新加入Rails的一个库据称可以解决Ruby unicode支持的问题，不过代价是三十倍的性能下降。

来自：http://blog.csdn.net/myan/archive/2007/01/25/1493288.aspx

这是2007的，不知道ruby1.8.6如何，

很搞笑，当在搜狗中输入ruby是，其中文是"如碧玉"，呵呵，的确是如碧玉啊。闲话少讲，对异常处理做一个总结性笔记。

异常处理的格式如下：

begin
表达式..
[rescue [error_type,..] [=> evar] [then]
表达式..]..
[else
表达式..]
[ensure
表达式..]
end

和c++异常处理是一样的，细节部分不再啰嗦。

1.rescue可以多次重复，

2.当rescue后什么也不带，则为standarError类型异常。

异常类的总类是Exception

其中方法有：backtrace,exception, to_s(to_str),set_backtrace

继承于Exception的异常类有

Interrupt

NotImplementError

SignalException

StandardError 如果在rescure没有指定异常类，则默认异常为该类。

SystemExit

fatal

下面是继承StandardError类中的异常类

1.ArgumentError 参数异常

2.FloatDomainError

3.IndexError

4.IOError 有子类EOFError

5.LoadError

6.LocalJumpError

7.NameError

8 RuntimeError 由raise 引起的错误，

9 SecurityError

10 SyntaxError

11 SystemCallError 有子类Error

12 SystemStackError

13 TypeError

14 ThreadError

15 ZeroDivisionError

在resure中没有指定异常类的话，则默认为StandarError类的错误，则能扑捉到15类的错误类。

采用自定义异常类，则必定继承于StandarError类或其子类。否则不能被resure扑捉到。当然再加个

else也是可以让它处理的，只是这样用法比较少见。

自定义异常类

1.class MyException < RuntimeError
2.end

3.begin
4. raise MyException, "kenlistian example "

5.rescue MyException => myex
6. p myex.to_s
7. p myex.backtrace.join("\n")

8.rescue =>myAllEx

9. p myAllEx.backtrace #处理其他所有的异常。注意，当执行了MyException后，此异常不处理的。同C++

10.end

---------- ruby ----------
"kenlistian example"
"test10.rb:8"

这里说明下backtrace，这个是记录跟踪信息。格式返回的事一个array，如对以上不采用to_s 和join，则返回的是：

---------- ruby ----------
#<MyException: kenlistian example>
["test10.rb:8"]

在backtrace中其中的格式是：

"#{sourcefile}:#{sourceline}:in `#{method}'" (within methods)

"#{sourcefile}:#{sourceline}" (at top level)

再说明下全局变量$#和$@也保存者异常处理的信息。

$# ======> myex 等同抛出的异常对象

$@ ======> myex.backtrace 等同backtrac中处理信息

***********************************

抛出异常，显然用raise。raise不是保留字，是Kernel模块中定义的方法。和fail是同一个格式，格式如下

raise([error_type,][message][,traceback])

如下：

raise
raise message 或 exception
raise error_type, message
raise error_type, message, traceback

第一句将再次引发上一个异常。

第二句，若参数是字符串的话，就把它当作错误信息(message)再引发RuntimeError异常。
若参数为异常对象则引发该异常。

第三句，将引发第一个参数所指的异常，并以第二个参数的内容作为错误信息。

第四句，第三参数装载的是源自于$@或caller的堆栈信息，它指明发生异常的地点。

使用rescue error_type => var就可以得到异常对象。

关于caller方法的说明：

caller([level]) Returns the context information (the backtrace) of current call in the form used for the variable $@. When level specified, caller goes up to calling frames level times and returns the context information. caller returns an empty array at toplevel.

The lines below prints stack frame:

for c in caller(0)
print c, "\n"
end

简而言之，就是察看堆栈信息。其参数表示察看深度。拿例子说话：

def meth1(deep)

meth2(deep)

end

def meth2(deep)

meth3(deep)

end

def meth3(deep)

caller(deep) #察看堆栈信息，deep表示深度

end

puts meth1(0) #0 表示最深，

puts meth1(1) # 察看堆栈中n-1层，就是最后压栈的不看。如下运行结果

---------- ruby ----------
test1.rb:10:in `meth3'
test1.rb:6:in `meth2'
test1.rb:2:in `meth1'
test1.rb:13

test1.rb:6:in `meth2'
test1.rb:2:in `meth1'
test1.rb:13

输出完成 (耗时 0 秒) - 正常终止

******************************************

catch 和throw，这2个方法很自由，主要感觉是独立性很强。你可以在任何地方写一个方法，

然后用catch来扑捉throw，注意别把raise和throw搞错了，catch是不抓raise的。

def method1(n)
puts "come on,kenlistian"
throw :done if n <= 0
puts "go here ,kenlistian"
end

catch(:done) {
method1(-1)
puts 'go here'
}
puts "Reach here!"

---------- ruby ----------
come on,kenlistian
Reach here!

Array 作为一个类，其中方法有：(简单的就不想说明了，仅作参考）

ruby下采用ado方式连接，(odbc更简单)

1.下载dbi，from: http://rubyforge.org/frs/?group_id=234&release_id=20222

0.2.0即可。

2. 解压拷贝到ruby中的lib中。（目前我版本1.8.6）

3. 打开readme，运行脚本所说的3步骤。

ruby setup.rb config
ruby setup.rb setup
ruby setup.rb install

4. 要把解压bdi中的ado.rb文件放在如下目录，（目录没有自建)

      ../ruby/lib/ruby/site_ruby/1.8/DBD/ADO/

5. 测试 ，(可以在irb下测)，也可以建一rb文件运行。

附：帮助直接打开dbi的doc目录下的index.html自看，一目了然。

附：连接odbc方法

1. 在odbc建到acess or msssql or oracle 的连接

2.对上connect部分改写如下：

  dbh = DBI.connect('dbi:ODBC:你的odbc库名','USERNAME','PASSWORD')

转(http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/227040)

require 'net/http'

#以http:\\finance.yahoo.com\q?s=IBM 页面为例子
http = Net::HTTP.new('finance.yahoo.com', 80)
resp, page = http.get('/q?s=IBM', nil )

#传入tag解析出数据
def parse_html(data,tag)
   return data.scan(%r{<#{tag}\s*.*?>(.*?)</#{tag}>}im).flatten
end
#flatten 是一维化数组

output = []
table_data = parse_html(page,"table")
table_data.each do |table|
   out_row = []
   row_data = parse_html(table,"tr")
   row_data.each do |row|
      cell_data = parse_html(row,"td")
      cell_data.each do |cell|
         cell.gsub!(%r{<.*?>},"")
      end
      out_row << cell_data
   end
   output << out_row
end

#组织显示
def parse_nested_array(array,tab = 0)
   n = 0
   array.each do |item|
      if(item.size > 0)
         puts "#{"\t" * tab}[#{n}] {"
         if(item.class == Array)
            parse_nested_array(item,tab+1)
         else
            puts "#{"\t" * (tab+1)}#{item}"
         end
         puts "#{"\t" * tab}}"
      end
      n += 1
   end
end

parse_nested_array(output)